Compare commits

..

9 Commits

Author SHA1 Message Date
67aa158e13 more 2024-07-01 14:17:49 -07:00
3182d5dd75 ya 2024-07-01 14:10:52 -07:00
b09f3a6ab0 the good 2024-07-01 14:09:52 -07:00
f7f309b2bb geweewweg 2024-07-01 14:04:50 -07:00
dba7aa427f level up 2024-07-01 13:46:02 -07:00
48c2a010d8 compile 2024-07-01 12:39:43 -07:00
43b5dfd0d5 CompileNode 2024-07-01 12:39:43 -07:00
581a0d6699 quicksave 2024-07-01 11:59:22 -07:00
2efbc3b437 wip 2024-07-01 11:18:34 -07:00
19 changed files with 601 additions and 2327 deletions

View File

@ -1,24 +0,0 @@
---
kind: pipeline
type: docker
platform:
os: linux
arch: amd64
steps:
- name: image
image: plugins/docker
settings:
registry: git.itzana.me
repo: git.itzana.me/strafesnet/asset-tool
tags:
- latest
username:
from_secret: GIT_USER
password:
from_secret: GIT_PASS
dockerfile: Containerfile
when:
branch:
- master

615
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -1,7 +1,7 @@
workspace = { members = ["rbx_asset", "rox_compiler"] } workspace = { members = ["rbx_asset", "rox_compiler"] }
[package] [package]
name = "asset-tool" name = "asset-tool"
version = "0.4.7" version = "0.3.1"
edition = "2021" edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

View File

@ -1,6 +1,6 @@
# Using the `rust-musl-builder` as base image, instead of # Using the `rust-musl-builder` as base image, instead of
# the official Rust toolchain # the official Rust toolchain
FROM docker.io/clux/muslrust:stable AS chef FROM clux/muslrust:stable AS chef
USER root USER root
RUN cargo install cargo-chef RUN cargo install cargo-chef
WORKDIR /app WORKDIR /app
@ -16,8 +16,8 @@ RUN cargo chef cook --release --target x86_64-unknown-linux-musl --recipe-path r
COPY . . COPY . .
RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool
FROM docker.io/alpine:latest AS runtime FROM alpine AS runtime
RUN addgroup -S myuser && adduser -S myuser -G myuser RUN addgroup -S myuser && adduser -S myuser -G myuser
COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/ COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/
USER myuser USER myuser
ENTRYPOINT ["/usr/local/bin/asset-tool"] CMD ["/usr/local/bin/asset-tool"]

View File

@ -1,21 +1,3 @@
# asset-tool # asset-tool
[![Build Status](https://ci.itzana.me/api/badges/StrafesNET/asset-tool/status.svg?ref=refs/heads/master)](https://ci.itzana.me/StrafesNET/asset-tool)
For uploading and downloading roblox assets. For uploading and downloading roblox assets.
See [releases](https://git.itzana.me/StrafesNET/asset-tool/releases) for downloads.
To get started, you will need an api key and/or cookie depending on which command you use. Api keys can be created from the open cloud section on the creator hub, cookies must be extracted from a browser session. Do not share your cookie file with anyone or use it with tools that you do not trust, as it gives unrestricted permissions to do any account actions on your behalf. The api keys are significantly more safe because you can choose exactly what permissions the given key has, and which ip addresses can use it.
The help text lists available commands:
`asset-tool --help`
For help with a specific command:
`asset-tool download --help`
Example incantation to download a list of models:
`asset-tool download --cookie-file Documents\mycookie.txt 255299419 1213190363`

View File

@ -1,19 +1,14 @@
[package] [package]
name = "rbx_asset" name = "rbx_asset"
version = "0.2.3" version = "0.1.0"
edition = "2021" edition = "2021"
publish = ["strafesnet"] publish = ["strafesnet"]
repository = "https://git.itzana.me/StrafesNET/asset-tool"
license = "MIT OR Apache-2.0"
description = "Strongly typed interface to the Roblox API using a Cookie or an API key."
authors = ["Rhys Lloyd <krakow20@gmail.com>"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
chrono = { version = "0.4.38", features = ["serde"] } chrono = { version = "0.4.38", features = ["serde"] }
flate2 = "1.0.29" flate2 = "1.0.29"
reqwest = { version = "0.12.4", features = ["json","multipart"] } reqwest = { version = "0.12.4", features = ["json"] }
serde = { version = "1.0.199", features = ["derive"] } serde = { version = "1.0.199", features = ["derive"] }
serde_json = "1.0.111"
url = "2.5.0" url = "2.5.0"

View File

@ -1,176 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

View File

@ -1,23 +0,0 @@
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

View File

@ -1,475 +0,0 @@
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub enum AssetType{
Audio,
Decal,
Model,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct CreateAssetRequest{
pub assetType:AssetType,
pub creationContext:CreationContext,
pub description:String,
pub displayName:String,
}
#[derive(Debug)]
pub enum AssetOperationError{
Operation(OperationError),
Serialize(serde_json::Error),
}
impl std::fmt::Display for AssetOperationError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for AssetOperationError{}
#[derive(Debug)]
pub struct AssetOperation{
operation:RobloxOperation,
}
impl AssetOperation{
pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,AssetOperationError>{
serde_json::from_value(
self.operation
.try_get_reponse(context).await
.map_err(AssetOperationError::Operation)?
).map_err(AssetOperationError::Serialize)
}
}
#[derive(Debug)]
pub enum CreateError{
Parse(url::ParseError),
Serialize(serde_json::Error),
Reqwest(reqwest::Error),
}
impl std::fmt::Display for CreateError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,"{self:?}")
}
}
impl std::error::Error for CreateError{}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct UpdateAssetRequest{
pub assetId:u64,
pub displayName:Option<String>,
pub description:Option<String>,
}
//woo nested roblox stuff
#[derive(Clone,Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub enum Creator{
userId(String),//u64 string
groupId(String),//u64 string
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct CreationContext{
pub creator:Creator,
pub expectedPrice:Option<u64>,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub enum ModerationState{
Reviewing,
Rejected,
Approved,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct ModerationResult{
pub moderationState:ModerationState,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct Preview{
pub asset:String,
pub altText:String,
}
#[allow(nonstandard_style,dead_code)]
pub struct UpdatePlaceRequest{
pub universeId:u64,
pub placeId:u64,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct UpdatePlaceResponse{
pub versionNumber:u64,
}
#[derive(Debug)]
pub enum UpdateError{
ParseError(url::ParseError),
SerializeError(serde_json::Error),
Reqwest(reqwest::Error),
}
impl std::fmt::Display for UpdateError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for UpdateError{}
struct GetAssetOperationRequest{
operation_id:String,
}
pub struct GetAssetInfoRequest{
pub asset_id:u64,
}
/*
{
"assetId": "5692158972",
"assetType": "Model",
"creationContext":{
"creator":
{
"groupId": "6980477"
}
},
"description": "DisplayName: Ares\nCreator: titanicguy54",
"displayName": "bhop_ares.rbxmx",
"path": "assets/5692158972",
"revisionCreateTime": "2020-09-14T16:08:05.063Z",
"revisionId": "1",
"moderationResult":{
"moderationState": "Approved"
},
"state": "Active"
}
*/
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct AssetResponse{
pub assetId:String,//u64 wrapped in quotes wohoo!!
pub assetType:AssetType,
pub creationContext:CreationContext,
pub description:String,
pub displayName:String,
pub path:String,
pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
pub revisionId:String,//u64
pub moderationResult:ModerationResult,
pub icon:Option<String>,
pub previews:Option<Vec<Preview>>,
}
#[allow(nonstandard_style,dead_code)]
pub struct GetAssetVersionRequest{
pub asset_id:u64,
pub version:u64,
}
#[allow(nonstandard_style,dead_code)]
pub struct GetAssetRequest{
pub asset_id:u64,
pub version:Option<u64>,
}
#[derive(Debug)]
pub enum GetError{
ParseError(url::ParseError),
Reqwest(reqwest::Error),
IO(std::io::Error)
}
impl std::fmt::Display for GetError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for GetError{}
pub struct AssetVersionsRequest{
pub asset_id:u64,
pub cursor:Option<String>,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct AssetVersion{
pub Id:u64,
pub assetId:u64,
pub assetVersionNumber:u64,
pub creatorType:String,
pub creatorTargetId:u64,
pub creatingUniverseId:Option<u64>,
pub created:chrono::DateTime<chrono::Utc>,
pub isPublished:bool,
}
#[derive(Debug,serde::Deserialize)]
#[allow(nonstandard_style,dead_code)]
pub struct AssetVersionsResponse{
pub previousPageCursor:Option<String>,
pub nextPageCursor:Option<String>,
pub data:Vec<AssetVersion>,
}
#[derive(Debug)]
pub enum AssetVersionsError{
ParseError(url::ParseError),
Reqwest(reqwest::Error),
}
impl std::fmt::Display for AssetVersionsError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for AssetVersionsError{}
pub struct InventoryPageRequest{
pub group:u64,
pub cursor:Option<String>,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct InventoryItem{
pub id:u64,
pub name:String,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct InventoryPageResponse{
pub totalResults:u64,//up to 50
pub filteredKeyword:Option<String>,//""
pub searchDebugInfo:Option<String>,//null
pub spellCheckerResult:Option<String>,//null
pub queryFacets:Option<String>,//null
pub imageSearchStatus:Option<String>,//null
pub previousPageCursor:Option<String>,
pub nextPageCursor:Option<String>,
pub data:Vec<InventoryItem>,
}
#[derive(Debug)]
pub enum InventoryPageError{
ParseError(url::ParseError),
Reqwest(reqwest::Error),
}
impl std::fmt::Display for InventoryPageError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for InventoryPageError{}
#[derive(Debug)]
pub enum OperationError{
Get(GetError),
NoOperationId,
NotDone,
}
impl std::fmt::Display for OperationError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,"{self:?}")
}
}
impl std::error::Error for OperationError{}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
struct RobloxOperation{
pub path:Option<String>,
pub metadata:Option<String>,
pub done:Option<bool>,
pub error:Option<String>,
pub response:Option<serde_json::Value>,
pub operationId:Option<String>,
}
impl RobloxOperation{
pub fn operation_id(&self)->Option<&str>{
match self.operationId.as_deref(){
//try getting it from undocumented operationId first
Some(operation_id)=>Some(operation_id),
//skip the first 11 characters
//operations/[uuid]
None=>self.path.as_deref()?.get(11..),
}
}
pub async fn try_get_reponse(&self,context:&CloudContext)->Result<serde_json::Value,OperationError>{
context.get_asset_operation(GetAssetOperationRequest{
operation_id:self.operation_id()
.ok_or(OperationError::NoOperationId)?
.to_owned(),
}).await.map_err(OperationError::Get)?
.response.ok_or(OperationError::NotDone)
}
}
//idk how to do this better
enum ReaderType<R:std::io::Read>{
GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
Raw(std::io::BufReader<R>),
}
fn maybe_gzip_decode<R:std::io::Read>(input:R)->std::io::Result<ReaderType<R>>{
let mut buf=std::io::BufReader::new(input);
let peek=std::io::BufRead::fill_buf(&mut buf)?;
match &peek[0..2]{
b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(buf))),
_=>Ok(ReaderType::Raw(buf)),
}
}
fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
let mut contents=Vec::new();
readable.read_to_end(&mut contents)?;
Ok(contents)
}
#[derive(Clone)]
pub struct ApiKey(String);
impl ApiKey{
pub fn new(api_key:String)->Self{
Self(api_key)
}
pub fn get(self)->String{
self.0
}
}
#[derive(Clone)]
pub struct CloudContext{
pub api_key:String,
pub client:reqwest::Client,
}
impl CloudContext{
pub fn new(api_key:ApiKey)->Self{
Self{
api_key:api_key.get(),
client:reqwest::Client::new(),
}
}
async fn get(&self,url:impl reqwest::IntoUrl)->Result<reqwest::Response,reqwest::Error>{
self.client.get(url)
.header("x-api-key",self.api_key.as_str())
.send().await
}
async fn post(&self,url:url::Url,body:impl Into<reqwest::Body>+Clone)->Result<reqwest::Response,reqwest::Error>{
self.client.post(url)
.header("x-api-key",self.api_key.as_str())
.body(body)
.send().await
}
async fn patch_form(&self,url:url::Url,form:reqwest::multipart::Form)->Result<reqwest::Response,reqwest::Error>{
self.client.patch(url)
.header("x-api-key",self.api_key.as_str())
.multipart(form)
.send().await
}
async fn post_form(&self,url:url::Url,form:reqwest::multipart::Form)->Result<reqwest::Response,reqwest::Error>{
self.client.post(url)
.header("x-api-key",self.api_key.as_str())
.multipart(form)
.send().await
}
pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,CreateError>{
let url=reqwest::Url::parse("https://apis.roblox.com/assets/v1/assets").map_err(CreateError::Parse)?;
let request_config=serde_json::to_string(&config).map_err(CreateError::Serialize)?;
let part=reqwest::multipart::Part::bytes(body)
//you must have a file name or roblox will 400!!!!!!!!!
.file_name("image");
let form=reqwest::multipart::Form::new()
.text("request",request_config)
.part("fileContent",part);
let operation=self.post_form(url,form).await
.map_err(CreateError::Reqwest)?
.error_for_status().map_err(CreateError::Reqwest)?
.json::<RobloxOperation>().await.map_err(CreateError::Reqwest)?;
Ok(AssetOperation{
operation,
})
}
pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,UpdateError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.assetId);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
let request_config=serde_json::to_string(&config).map_err(UpdateError::SerializeError)?;
let form=reqwest::multipart::Form::new()
.text("request",request_config)
.part("fileContent",reqwest::multipart::Part::bytes(body));
let operation=self.patch_form(url,form).await
.map_err(UpdateError::Reqwest)?
//roblox api documentation is very poor, just give the status code and drop the json
.error_for_status().map_err(UpdateError::Reqwest)?
.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)?;
Ok(AssetOperation{
operation,
})
}
async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
self.get(url).await.map_err(GetError::Reqwest)?
.error_for_status().map_err(GetError::Reqwest)?
.json::<RobloxOperation>().await.map_err(GetError::Reqwest)
}
pub async fn get_asset_info(&self,config:GetAssetInfoRequest)->Result<AssetResponse,GetError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.asset_id);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
self.get(url).await.map_err(GetError::Reqwest)?
.error_for_status().map_err(GetError::Reqwest)?
.json::<AssetResponse>().await.map_err(GetError::Reqwest)
}
pub async fn get_asset_version(&self,config:GetAssetVersionRequest)->Result<Vec<u8>,GetError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions/{}",config.asset_id,config.version);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
let body=self.get(url).await.map_err(GetError::Reqwest)?
.error_for_status().map_err(GetError::Reqwest)?
.bytes().await.map_err(GetError::Reqwest)?;
match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
Ok(ReaderType::GZip(readable))=>read_readable(readable),
Ok(ReaderType::Raw(readable))=>read_readable(readable),
Err(e)=>Err(e),
}.map_err(GetError::IO)
}
pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
let version=match config.version{
Some(version)=>version,
None=>self.get_asset_info(GetAssetInfoRequest{asset_id:config.asset_id}).await?.revisionId.parse().unwrap(),
};
self.get_asset_version(GetAssetVersionRequest{
asset_id:config.asset_id,
version,
}).await
}
pub async fn get_asset_versions(&self,config:AssetVersionsRequest)->Result<AssetVersionsResponse,AssetVersionsError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions",config.asset_id);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(AssetVersionsError::ParseError)?;
self.get(url).await.map_err(AssetVersionsError::Reqwest)?
.error_for_status().map_err(AssetVersionsError::Reqwest)?
.json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)
}
pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
//url borrow scope
{
let mut query=url.query_pairs_mut();//borrow here
if let Some(cursor)=config.cursor.as_deref(){
query.append_pair("cursor",cursor);
}
}
self.get(url).await.map_err(InventoryPageError::Reqwest)?
.error_for_status().map_err(InventoryPageError::Reqwest)?
.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
}
pub async fn update_place(&self,config:UpdatePlaceRequest,body:impl Into<reqwest::Body>+Clone)->Result<UpdatePlaceResponse,UpdateError>{
let raw_url=format!("https://apis.roblox.com/universes/v1/{}/places/{}/versions",config.universeId,config.placeId);
let mut url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
//url borrow scope
{
let mut query=url.query_pairs_mut();//borrow here
query.append_pair("versionType","Published");
}
self.post(url,body).await.map_err(UpdateError::Reqwest)?
.error_for_status().map_err(UpdateError::Reqwest)?
.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)
}
}

View File

@ -62,24 +62,24 @@ pub struct UploadResponse{
} }
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct GetAssetRequest{ pub struct DownloadRequest{
pub asset_id:u64, pub asset_id:u64,
pub version:Option<u64>, pub version:Option<u64>,
} }
#[derive(Debug)] #[derive(Debug)]
pub enum GetError{ pub enum DownloadError{
ParseError(url::ParseError), ParseError(url::ParseError),
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
IO(std::io::Error) IO(std::io::Error)
} }
impl std::fmt::Display for GetError{ impl std::fmt::Display for DownloadError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,"{self:?}") write!(f,"{self:?}")
} }
} }
impl std::error::Error for GetError{} impl std::error::Error for DownloadError{}
pub struct AssetVersionsPageRequest{ pub struct HistoryPageRequest{
pub asset_id:u64, pub asset_id:u64,
pub cursor:Option<String>, pub cursor:Option<String>,
} }
@ -97,48 +97,36 @@ pub struct AssetVersion{
} }
#[derive(serde::Deserialize)] #[derive(serde::Deserialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct AssetVersionsPageResponse{ pub struct HistoryPageResponse{
pub previousPageCursor:Option<String>, pub previousPageCursor:Option<String>,
pub nextPageCursor:Option<String>, pub nextPageCursor:Option<String>,
pub data:Vec<AssetVersion>, pub data:Vec<AssetVersion>,
} }
#[derive(Debug)] #[derive(Debug)]
pub enum PageError{ pub enum HistoryPageError{
ParseError(url::ParseError), ParseError(url::ParseError),
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
} }
impl std::fmt::Display for PageError{ impl std::fmt::Display for HistoryPageError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,"{self:?}") write!(f,"{self:?}")
} }
} }
impl std::error::Error for PageError{} impl std::error::Error for HistoryPageError{}
pub enum Owner{ pub struct InventoryPageRequest{
User(u64), pub group:u64,
Group(u64),
}
impl Owner{
fn get_url_info(&self)->(&str,u64){
match self{
&Owner::User(id)=>("user",id),
&Owner::Group(id)=>("group",id),
}
}
}
pub struct CreationsPageRequest{
pub owner:Owner,
pub cursor:Option<String>, pub cursor:Option<String>,
} }
#[derive(serde::Deserialize,serde::Serialize)] #[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct CreationsItem{ pub struct InventoryItem{
pub id:u64, pub id:u64,
pub name:String, pub name:String,
} }
#[derive(serde::Deserialize,serde::Serialize)] #[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct CreationsPageResponse{ pub struct InventoryPageResponse{
pub totalResults:u64,//up to 50 pub totalResults:u64,//up to 50
pub filteredKeyword:Option<String>,//"" pub filteredKeyword:Option<String>,//""
pub searchDebugInfo:Option<String>,//null pub searchDebugInfo:Option<String>,//null
@ -147,40 +135,19 @@ pub struct CreationsPageResponse{
pub imageSearchStatus:Option<String>,//null pub imageSearchStatus:Option<String>,//null
pub previousPageCursor:Option<String>, pub previousPageCursor:Option<String>,
pub nextPageCursor:Option<String>, pub nextPageCursor:Option<String>,
pub data:Vec<CreationsItem>, pub data:Vec<InventoryItem>,
} }
#[derive(Debug)]
pub struct UserInventoryPageRequest{ pub enum InventoryPageError{
pub user_id:u64, ParseError(url::ParseError),
pub cursor:Option<String>, Reqwest(reqwest::Error),
} }
impl std::fmt::Display for InventoryPageError{
#[derive(serde::Deserialize,serde::Serialize)] fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
#[allow(nonstandard_style,dead_code)] write!(f,"{self:?}")
pub struct UserInventoryItemOwner{
userId:u64,
username:String,
buildersClubMembershipType:u64,
} }
#[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct UserInventoryItem{
userAssetId:u64,
assetId:u64,
assetName:String,
collectibleItemId:Option<String>,
collectibleItemInstanceId:Option<String>,
owner:UserInventoryItemOwner,
created:chrono::DateTime<chrono::Utc>,
updated:chrono::DateTime<chrono::Utc>,
}
#[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct UserInventoryPageResponse{
pub previousPageCursor:Option<String>,
pub nextPageCursor:Option<String>,
pub data:Vec<UserInventoryItem>,
} }
impl std::error::Error for InventoryPageError{}
//idk how to do this better //idk how to do this better
enum ReaderType<R:std::io::Read>{ enum ReaderType<R:std::io::Read>{
@ -202,25 +169,15 @@ fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
} }
#[derive(Clone)] #[derive(Clone)]
pub struct Cookie(String); pub struct RobloxContext{
impl Cookie{
pub fn new(cookie:String)->Self{
Self(cookie)
}
pub fn get(self)->String{
self.0
}
}
#[derive(Clone)]
pub struct CookieContext{
pub cookie:String, pub cookie:String,
pub client:reqwest::Client, pub client:reqwest::Client,
} }
impl CookieContext{ impl RobloxContext{
pub fn new(cookie:Cookie)->Self{ pub fn new(cookie:String)->Self{
Self{ Self{
cookie:cookie.get(), cookie,
client:reqwest::Client::new(), client:reqwest::Client::new(),
} }
} }
@ -261,14 +218,15 @@ impl CookieContext{
query.append_pair("description",config.description.as_str()); query.append_pair("description",config.description.as_str());
query.append_pair("ispublic",if config.ispublic{"True"}else{"False"}); query.append_pair("ispublic",if config.ispublic{"True"}else{"False"});
query.append_pair("allowComments",if config.allowComments{"True"}else{"False"}); query.append_pair("allowComments",if config.allowComments{"True"}else{"False"});
if let Some(group_id)=config.groupId{ match config.groupId{
query.append_pair("groupId",group_id.to_string().as_str()); Some(group_id)=>{query.append_pair("groupId",group_id.to_string().as_str());},
None=>(),
} }
} }
self.post(url,body).await.map_err(CreateError::PostError)? let resp=self.post(url,body).await.map_err(CreateError::PostError)?;
.error_for_status().map_err(CreateError::Reqwest)?
.json::<UploadResponse>().await.map_err(CreateError::Reqwest) Ok(resp.json::<UploadResponse>().await.map_err(CreateError::Reqwest)?)
} }
pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{ pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{
let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?; let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?;
@ -297,12 +255,12 @@ impl CookieContext{
} }
} }
self.post(url,body).await.map_err(UploadError::PostError)? let resp=self.post(url,body).await.map_err(UploadError::PostError)?;
.error_for_status().map_err(UploadError::Reqwest)?
.json::<UploadResponse>().await.map_err(UploadError::Reqwest) Ok(resp.json::<UploadResponse>().await.map_err(UploadError::Reqwest)?)
} }
pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{ pub async fn download(&self,config:DownloadRequest)->Result<Vec<u8>,DownloadError>{
let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?; let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(DownloadError::ParseError)?;
//url borrow scope //url borrow scope
{ {
let mut query=url.query_pairs_mut();//borrow here let mut query=url.query_pairs_mut();//borrow here
@ -311,18 +269,18 @@ impl CookieContext{
query.append_pair("version",version.to_string().as_str()); query.append_pair("version",version.to_string().as_str());
} }
} }
let body=self.get(url).await.map_err(GetError::Reqwest)? let resp=self.get(url).await.map_err(DownloadError::Reqwest)?;
.error_for_status().map_err(GetError::Reqwest)?
.bytes().await.map_err(GetError::Reqwest)?; let body=resp.bytes().await.map_err(DownloadError::Reqwest)?;
match maybe_gzip_decode(&mut std::io::Cursor::new(body)){ match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
Ok(ReaderType::GZip(readable))=>read_readable(readable), Ok(ReaderType::GZip(readable))=>read_readable(readable),
Ok(ReaderType::Raw(readable))=>read_readable(readable), Ok(ReaderType::Raw(readable))=>read_readable(readable),
Err(e)=>Err(e), Err(e)=>Err(e),
}.map_err(GetError::IO) }.map_err(DownloadError::IO)
} }
pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{ pub async fn history_page(&self,config:HistoryPageRequest)->Result<HistoryPageResponse,HistoryPageError>{
let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(PageError::ParseError)?; let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(HistoryPageError::ParseError)?;
//url borrow scope //url borrow scope
{ {
let mut query=url.query_pairs_mut();//borrow here let mut query=url.query_pairs_mut();//borrow here
@ -334,13 +292,11 @@ impl CookieContext{
} }
} }
self.get(url).await.map_err(PageError::Reqwest)? Ok(self.get(url).await.map_err(HistoryPageError::Reqwest)?
.error_for_status().map_err(PageError::Reqwest)? .json::<HistoryPageResponse>().await.map_err(HistoryPageError::Reqwest)?)
.json::<AssetVersionsPageResponse>().await.map_err(PageError::Reqwest)
} }
pub async fn get_creations_page(&self,config:&CreationsPageRequest)->Result<CreationsPageResponse,PageError>{ pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
let (owner,id)=config.owner.get_url_info(); let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/{}/{}/10?limit=50",owner,id).as_str()).map_err(PageError::ParseError)?;
//url borrow scope //url borrow scope
{ {
let mut query=url.query_pairs_mut();//borrow here let mut query=url.query_pairs_mut();//borrow here
@ -349,22 +305,7 @@ impl CookieContext{
} }
} }
self.get(url).await.map_err(PageError::Reqwest)? Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
.error_for_status().map_err(PageError::Reqwest)? .json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
.json::<CreationsPageResponse>().await.map_err(PageError::Reqwest)
}
pub async fn get_user_inventory_page(&self,config:&UserInventoryPageRequest)->Result<UserInventoryPageResponse,PageError>{
let mut url=reqwest::Url::parse(format!("https://inventory.roblox.com/v2/users/{}/inventory/10?limit=100&sortOrder=Desc",config.user_id).as_str()).map_err(PageError::ParseError)?;
//url borrow scope
{
let mut query=url.query_pairs_mut();//borrow here
if let Some(cursor)=config.cursor.as_deref(){
query.append_pair("cursor",cursor);
}
}
self.get(url).await.map_err(PageError::Reqwest)?
.error_for_status().map_err(PageError::Reqwest)?
.json::<UserInventoryPageResponse>().await.map_err(PageError::Reqwest)
} }
} }

View File

@ -1,2 +1 @@
pub mod cloud; pub mod context;
pub mod cookie;

View File

@ -2,11 +2,6 @@
name = "rox_compiler" name = "rox_compiler"
version = "0.1.0" version = "0.1.0"
edition = "2021" edition = "2021"
publish = ["strafesnet"]
repository = "https://git.itzana.me/StrafesNET/asset-tool"
license = "MIT OR Apache-2.0"
description = "Read/write a folder structure from Roblox place/model files."
authors = ["Rhys Lloyd <krakow20@gmail.com>"]
[dependencies] [dependencies]
futures = "0.3.30" futures = "0.3.30"

View File

@ -1,176 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

View File

@ -1,23 +0,0 @@
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

View File

@ -19,15 +19,15 @@ impl PropertiesOverride{
impl std::fmt::Display for PropertiesOverride{ impl std::fmt::Display for PropertiesOverride{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{ fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
if let Some(name)=self.name.as_deref(){ if let Some(name)=self.name.as_deref(){
writeln!(f,"-- Properties.Name = \"{}\"",name)?; writeln!(f,"--!Properties.Name = \"{}\"",name)?;
} }
if let Some(class)=self.class.as_deref(){ if let Some(class)=self.class.as_deref(){
writeln!(f,"-- Properties.ClassName = \"{}\"",class)?; writeln!(f,"--!Properties.ClassName = \"{}\"",class)?;
} }
Ok(()) Ok(())
} }
} }
pub(crate) fn sanitize(s:&str)->std::borrow::Cow<'_,str>{ pub(crate) fn sanitize<'a>(s:&'a str)->std::borrow::Cow<'a,str>{
lazy_regex::regex!(r"[^A-Za-z0-9.-]").replace_all(s,"_") lazy_regex::regex!(r"[^A-z0-9.-]").replace_all(s,"_")
} }

View File

@ -1,4 +1,4 @@
use std::path::{Path,PathBuf}; use std::path::PathBuf;
use futures::{StreamExt, TryStreamExt}; use futures::{StreamExt, TryStreamExt};
use tokio::io::AsyncReadExt; use tokio::io::AsyncReadExt;
@ -55,9 +55,9 @@ struct QuerySingle{
script:QueryHandle, script:QueryHandle,
} }
impl QuerySingle{ impl QuerySingle{
fn rox(search_path:&Path,search_name:&str)->Self{ fn rox(search_path:&PathBuf,search_name:&str)->Self{
Self{ Self{
script:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.lua",search_name))) script:tokio::spawn(get_file_async(search_path.clone(),format!("{}.lua",search_name)))
} }
} }
} }
@ -76,7 +76,7 @@ struct QueryTriple{
client:QueryHandle, client:QueryHandle,
} }
impl QueryTriple{ impl QueryTriple{
fn rox_rojo(search_path:&Path,search_name:&str,search_module:bool)->Self{ fn rox_rojo(search_path:&PathBuf,search_name:&str,search_module:bool)->Self{
//this should be implemented as constructors of Triplet and Quadruplet to fully support Trey's suggestion //this should be implemented as constructors of Triplet and Quadruplet to fully support Trey's suggestion
let module_name=if search_module{ let module_name=if search_module{
format!("{}.module.lua",search_name) format!("{}.module.lua",search_name)
@ -84,12 +84,12 @@ impl QueryTriple{
format!("{}.lua",search_name) format!("{}.lua",search_name)
}; };
Self{ Self{
module:tokio::spawn(get_file_async(search_path.to_owned(),module_name)), module:tokio::spawn(get_file_async(search_path.clone(),module_name)),
server:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.server.lua",search_name))), server:tokio::spawn(get_file_async(search_path.clone(),format!("{}.server.lua",search_name))),
client:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.client.lua",search_name))), client:tokio::spawn(get_file_async(search_path.clone(),format!("{}.client.lua",search_name))),
} }
} }
fn rojo(search_path:&Path)->Self{ fn rojo(search_path:&PathBuf)->Self{
QueryTriple::rox_rojo(search_path,"init",false) QueryTriple::rox_rojo(search_path,"init",false)
} }
} }
@ -146,9 +146,9 @@ impl Query for QueryTriple{
async fn resolve(self)->QueryHintResult{ async fn resolve(self)->QueryHintResult{
let (module,server,client)=tokio::join!(self.module,self.server,self.client); let (module,server,client)=tokio::join!(self.module,self.server,self.client);
mega_triple_join(( mega_triple_join((
module.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}), server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}), client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
)) ))
} }
} }
@ -159,7 +159,7 @@ struct QueryQuad{
client:QueryHandle, client:QueryHandle,
} }
impl QueryQuad{ impl QueryQuad{
fn rox_rojo(search_path:&Path,search_name:&str)->Self{ fn rox_rojo(search_path:&PathBuf,search_name:&str)->Self{
let fill=QueryTriple::rox_rojo(search_path,search_name,true); let fill=QueryTriple::rox_rojo(search_path,search_name,true);
Self{ Self{
module_implicit:QuerySingle::rox(search_path,search_name).script,//Script.lua module_implicit:QuerySingle::rox(search_path,search_name).script,//Script.lua
@ -173,10 +173,10 @@ impl Query for QueryQuad{
async fn resolve(self)->QueryHintResult{ async fn resolve(self)->QueryHintResult{
let (module_implicit,module_explicit,server,client)=tokio::join!(self.module_implicit,self.module_explicit,self.server,self.client); let (module_implicit,module_explicit,server,client)=tokio::join!(self.module_implicit,self.module_explicit,self.server,self.client);
mega_quadruple_join(( mega_quadruple_join((
module_implicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module_implicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
module_explicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module_explicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}), server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}), client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
)) ))
} }
} }
@ -203,7 +203,7 @@ impl ScriptWithOverrides{
let mut count=0; let mut count=0;
for line in source.lines(){ for line in source.lines(){
//only string type properties are supported atm //only string type properties are supported atm
if let Some(captures)=lazy_regex::regex!(r#"^\-\-\s*Properties\.([A-Za-z]\w*)\s*\=\s*"(\w+)"$"#) if let Some(captures)=lazy_regex::regex!(r#"^\-\-\!\s*Properties\.([A-z]\w*)\s*\=\s*"(\w+)"$"#)
.captures(line){ .captures(line){
count+=line.len(); count+=line.len();
match &captures[1]{ match &captures[1]{
@ -237,10 +237,7 @@ struct CompileNode{
pub enum CompileNodeError{ pub enum CompileNodeError{
IO(std::io::Error), IO(std::io::Error),
ScriptWithOverrides(ScriptWithOverridesError), ScriptWithOverrides(ScriptWithOverridesError),
InvalidClassOrHint{ InvalidHintOrClass(Option<String>,ScriptHint),
class:Option<String>,
hint:ScriptHint
},
QueryResolveError(QueryResolveError), QueryResolveError(QueryResolveError),
/// Conversion from OsString to String failed /// Conversion from OsString to String failed
FileName(std::ffi::OsString), FileName(std::ffi::OsString),
@ -248,7 +245,7 @@ pub enum CompileNodeError{
extension:String, extension:String,
style:Option<Style>, style:Option<Style>,
}, },
UnknownExtension, NoExtension,
} }
impl std::fmt::Display for CompileNodeError{ impl std::fmt::Display for CompileNodeError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{ fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@ -280,7 +277,7 @@ impl CompileNode{
|(None,ScriptHint::LocalScript)=>CompileClass::LocalScript(script_with_overrides.source), |(None,ScriptHint::LocalScript)=>CompileClass::LocalScript(script_with_overrides.source),
(Some("Script"),_) (Some("Script"),_)
|(None,ScriptHint::Script)=>CompileClass::Script(script_with_overrides.source), |(None,ScriptHint::Script)=>CompileClass::Script(script_with_overrides.source),
(class,hint)=>Err(CompileNodeError::InvalidClassOrHint{class:class.map(|s|s.to_owned()),hint})?, other=>Err(CompileNodeError::InvalidHintOrClass(other.0.map(|s|s.to_owned()),other.1))?,
}, },
}) })
} }
@ -338,9 +335,12 @@ impl CompileNode{
.into_string() .into_string()
.map_err(CompileNodeError::FileName)?; .map_err(CompileNodeError::FileName)?;
//reject goobers //reject goobers
let is_goober=matches!(style,Some(Style::Rojo)); let is_goober=match style{
Some(Style::Rojo)=>true,
_=>false,
};
let (ext_len,file_discernment)={ let (ext_len,file_discernment)={
if let Some(captures)=lazy_regex::regex!(r"^.*(\.module\.lua|\.client\.lua|\.server\.lua)$") if let Some(captures)=lazy_regex::regex!(r"^.*(.module.lua|.client.lua|.server.lua|.rbxmx|.lua)$")
.captures(file_name.as_str()){ .captures(file_name.as_str()){
let ext=&captures[1]; let ext=&captures[1];
(ext.len(),match ext{ (ext.len(),match ext{
@ -352,12 +352,6 @@ impl CompileNode{
}, },
".client.lua"=>FileDiscernment::Script(ScriptHint::LocalScript), ".client.lua"=>FileDiscernment::Script(ScriptHint::LocalScript),
".server.lua"=>FileDiscernment::Script(ScriptHint::Script), ".server.lua"=>FileDiscernment::Script(ScriptHint::Script),
_=>panic!("Regex failed"),
})
}else if let Some(captures)=lazy_regex::regex!(r"^.*(\.rbxmx|\.lua)$")
.captures(file_name.as_str()){
let ext=&captures[1];
(ext.len(),match ext{
".rbxmx"=>{ ".rbxmx"=>{
if is_goober{ if is_goober{
Err(CompileNodeError::ExtensionNotSupportedInStyle{extension:ext.to_owned(),style})?; Err(CompileNodeError::ExtensionNotSupportedInStyle{extension:ext.to_owned(),style})?;
@ -368,7 +362,7 @@ impl CompileNode{
_=>panic!("Regex failed"), _=>panic!("Regex failed"),
}) })
}else{ }else{
return Err(CompileNodeError::UnknownExtension); return Err(CompileNodeError::NoExtension);
} }
}; };
file_name.truncate(file_name.len()-ext_len); file_name.truncate(file_name.len()-ext_len);
@ -435,30 +429,26 @@ impl std::fmt::Display for CompileError{
impl std::error::Error for CompileError{} impl std::error::Error for CompileError{}
pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->Result<(),CompileError>{ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->Result<(),CompileError>{
//hack to traverse root folder as the root object
"src".clone_into(&mut dom.root_mut().name);
//add in scripts and models //add in scripts and models
let mut folder=config.input_folder.clone(); let mut folder=config.input_folder.clone();
let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)]; let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)];
while let Some(instruction)=stack.pop(){ while let Some(instruction)=stack.pop(){
match instruction{ match instruction{
CompileStackInstruction::TraverseReferent(item_ref,blacklist)=>{ CompileStackInstruction::TraverseReferent(item_ref,blacklist)=>{
//scope to avoid holding item ref let sans={
{
let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?; let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?;
let folder_name=sanitize(item.name.as_str()); sanitize(item.name.as_str()).to_string()
folder.push(folder_name.as_ref()); };
//drop item folder.push(sans.as_str());
}
stack.push(CompileStackInstruction::PopFolder); stack.push(CompileStackInstruction::PopFolder);
//check if a folder exists with item.name //check if a folder exists with item.name
if let Ok(dir)=tokio::fs::read_dir(folder.as_path()).await{ if let Ok(dir)=tokio::fs::read_dir(folder.as_path()).await{
let mut exist_names:std::collections::HashSet<String>={ let mut exist_names:std::collections::HashSet<String>={
let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?; let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?;
//push existing dom children objects onto stack (unrelated to exist_names) //push existing dom children objects onto stack (unrelated to exist_names)
stack.extend(item.children().iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None))); stack.extend(item.children().into_iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None)));
//get names of existing objects //get names of existing objects
item.children().iter().map(|&child_ref|{ item.children().into_iter().map(|&child_ref|{
let child=dom.get_by_ref(child_ref).ok_or(CompileError::NullChildRef)?; let child=dom.get_by_ref(child_ref).ok_or(CompileError::NullChildRef)?;
Ok::<_,CompileError>(sanitize(child.name.as_str()).to_string()) Ok::<_,CompileError>(sanitize(child.name.as_str()).to_string())
}).collect::<Result<_,CompileError>>()? }).collect::<Result<_,CompileError>>()?
@ -475,7 +465,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
let ret1={ let ret1={
//capture a scoped mutable reference so we can forward dir to the next call even on an error //capture a scoped mutable reference so we can forward dir to the next call even on an error
let dir2=&mut dir1; let dir2=&mut dir1;
async move{//error catcher so I can use ? (||async move{//error catcher so I can use ?
let ret2=if let Some(entry)=dir2.next_entry().await?{ let ret2=if let Some(entry)=dir2.next_entry().await?{
//cull early even if supporting things with identical names is possible //cull early even if supporting things with identical names is possible
if exist_names.contains(entry.file_name().to_str().unwrap()){ if exist_names.contains(entry.file_name().to_str().unwrap()){
@ -486,8 +476,8 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
}else{ }else{
TooComplicated::Stop TooComplicated::Stop
}; };
Ok(ret2) Ok::<_,std::io::Error>(ret2)
}.await })().await
}; };
match ret1{ match ret1{
Ok(TooComplicated::Stop)=>None, Ok(TooComplicated::Stop)=>None,
@ -503,19 +493,10 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
Ok(Some(entry))=>tokio::spawn(async move{ Ok(Some(entry))=>tokio::spawn(async move{
let met=entry.metadata().await.map_err(CompileError::IO)?; let met=entry.metadata().await.map_err(CompileError::IO)?;
//discern that bad boy //discern that bad boy
let compile_class={ let compile_class=match met.is_dir(){
let result=match met.is_dir(){
true=>CompileNode::from_folder(&entry,style).await, true=>CompileNode::from_folder(&entry,style).await,
false=>CompileNode::from_file(&entry,style).await, false=>CompileNode::from_file(&entry,style).await,
}; }.map_err(CompileError::CompileNode)?;
match result{
Ok(compile_class)=>compile_class,
Err(e)=>{
println!("Ignoring file {entry:?} due to error {e}");
return Ok(None);
},
}
};
//prepare data structure //prepare data structure
Ok(Some((compile_class.blacklist,match compile_class.class{ Ok(Some((compile_class.blacklist,match compile_class.class{
CompileClass::Folder=>PreparedData::Builder(rbx_dom_weak::InstanceBuilder::new("Folder").with_name(compile_class.name.as_str())), CompileClass::Folder=>PreparedData::Builder(rbx_dom_weak::InstanceBuilder::new("Folder").with_name(compile_class.name.as_str())),
@ -534,10 +515,10 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
.map(|f|async{f}).buffer_unordered(32) .map(|f|async{f}).buffer_unordered(32)
//begin processing immediately //begin processing immediately
//TODO: fix dom being &mut &mut inside the closure .try_fold((&mut stack,&mut dom),|(stack,dom):(&mut Vec<CompileStackInstruction>,_),bog|async{
.try_fold((&mut stack,&mut dom),|(stack,dom),bog|async{
//push child objects onto dom serially as they arrive //push child objects onto dom serially as they arrive
if let Some((blacklist,data))=bog{ match bog{
Some((blacklist,data))=>{
let referent=match data{ let referent=match data{
PreparedData::Model(mut model_dom)=>{ PreparedData::Model(mut model_dom)=>{
let referent=model_dom.root().children()[0]; let referent=model_dom.root().children()[0];
@ -548,6 +529,8 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
}; };
//new children need to be traversed //new children need to be traversed
stack.push(CompileStackInstruction::TraverseReferent(referent,blacklist)); stack.push(CompileStackInstruction::TraverseReferent(referent,blacklist));
},
None=>(),
} }
Ok((stack,dom)) Ok((stack,dom))
}).await?; }).await?;
@ -556,5 +539,5 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
CompileStackInstruction::PopFolder=>assert!(folder.pop(),"pop folder bad"), CompileStackInstruction::PopFolder=>assert!(folder.pop(),"pop folder bad"),
} }
} }
Ok(()) unreachable!();
} }

View File

@ -147,7 +147,10 @@ impl DecompiledContext{
"Model"=>Class::Model, "Model"=>Class::Model,
_=>Class::Folder, _=>Class::Folder,
}; };
let skip=class==Class::Model; let skip=match class{
Class::Model=>true,
_=>false,
};
if let Some(parent_node)=tree_refs.get_mut(&item.parent()){ if let Some(parent_node)=tree_refs.get_mut(&item.parent()){
let referent=item.referent(); let referent=item.referent();
let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class); let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class);
@ -179,14 +182,14 @@ impl DecompiledContext{
if node.class==Class::Folder&&script_count!=0{ if node.class==Class::Folder&&script_count!=0{
node.class=Class::Model node.class=Class::Model
} }
if node.class==Class::Folder&&node.children.is_empty(){ if node.class==Class::Folder&&node.children.len()==0{
delete=Some(node.parent); delete=Some(node.parent);
}else{ }else{
//how the hell do I do this better without recursion //how the hell do I do this better without recursion
let is_script=matches!( let is_script=match node.class{
node.class, Class::ModuleScript|Class::LocalScript|Class::Script=>true,
Class::ModuleScript|Class::LocalScript|Class::Script _=>false,
); };
//stack is popped from back //stack is popped from back
if is_script{ if is_script{
stack.push(TrimStackInstruction::DecrementScript); stack.push(TrimStackInstruction::DecrementScript);
@ -234,7 +237,7 @@ impl DecompiledContext{
WriteStackInstruction::Node(node,name_count)=>{ WriteStackInstruction::Node(node,name_count)=>{
//track properties that must be overriden to compile folder structure back into a place file //track properties that must be overriden to compile folder structure back into a place file
let mut properties=PropertiesOverride::default(); let mut properties=PropertiesOverride::default();
let has_children=!node.children.is_empty(); let has_children=node.children.len()!=0;
match node.class{ match node.class{
Class::Folder=>(), Class::Folder=>(),
Class::ModuleScript=>(),//.lua files are ModuleScript by default Class::ModuleScript=>(),//.lua files are ModuleScript by default
@ -294,7 +297,7 @@ impl DecompiledContext{
let write_models=config.write_models; let write_models=config.write_models;
let write_scripts=config.write_scripts; let write_scripts=config.write_scripts;
let results:Vec<Result<(),WriteError>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{ let results:Vec<Result<(),WriteError>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{
write_item(dom,write_path,node,node_name_override,properties,style,write_models,write_scripts) write_item(&dom,write_path,node,node_name_override,properties,style,write_models,write_scripts)
})); }));
for result in results{ for result in results{
result?; result?;

View File

@ -1,9 +1,9 @@
mod common; mod common;
mod compile; mod compile;
mod decompile; mod decompile;
//export minimal interface //export specific types
pub use common::Style; pub use common::Style;
pub use compile::CompileConfig; pub use compile::CompileConfig;
pub use compile::compile;//cringe unstandardized interface pub use compile::compile;//cringe non standardized interface
pub use decompile::WriteConfig;
pub use decompile::DecompiledContext; pub use decompile::DecompiledContext;
pub use decompile::WriteConfig;

File diff suppressed because it is too large Load Diff