pass tally into stack instruction to generate name override

more requests
download version history
2024-01-06 15:01:56 -08:00 · 2024-01-06 13:10:13 -08:00 · 2024-01-06 13:10:13 -08:00 · 2024-01-06 12:39:16 -08:00 · 2024-01-06 12:38:43 -08:00 · 2024-01-06 11:15:07 -08:00
4 changed files with 623 additions and 38 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -26,6 +26,21 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.5"
@ -97,6 +112,7 @@ name = "asset-tool"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "chrono",
 "clap",
 "flate2",
 "futures",
@ -107,6 +123,8 @@ dependencies = [
 "rbx_reflection_database",
 "rbx_xml",
 "reqwest",
+ "serde",
+ "serde_json",
 "tokio",
 ]

@ -201,6 +219,21 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

+[[package]]
+name = "chrono"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "clap"
 version = "4.4.12"
@ -600,6 +633,29 @@ dependencies = [
 "tokio-native-tls",
 ]

+[[package]]
+name = "iana-time-zone"
+version = "0.1.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6a67363e2aa4443928ce15e57ebae94fd8949958fd1223c4cfc0cd473ad7539"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "idna"
 version = "0.2.3"
@ -913,9 +969,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

 [[package]]
 name = "proc-macro2"
-version = "1.0.71"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75cb1540fadbd5b8fbccc4dddad2734eba435053f725621c070711a14bb5f4b8"
+checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
 dependencies = [
 "unicode-ident",
 ]
@ -957,9 +1013,9 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
 "proc-macro2",
 ]
@ -1230,18 +1286,18 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
+checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
+checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1250,9 +1306,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.108"
+version = "1.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
+checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4"
 dependencies = [
 "itoa",
 "ryu",
@ -1298,9 +1354,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "syn"
-version = "2.0.43"
+version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1629,6 +1685,15 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.0",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -7,6 +7,7 @@ edition = "2021"

 [dependencies]
 anyhow = "1.0.75"
+chrono = { version = "0.4.31", features = ["serde"] }
 clap = { version = "4.4.2", features = ["derive"] }
 flate2 = "1.0.28"
 futures = "0.3.30"
@ -16,5 +17,12 @@ rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
-reqwest = { version = "0.11.23", features = ["cookies"] }
+reqwest = { version = "0.11.23", features = ["cookies", "json"] }
+serde = { version = "1.0.195", features = ["derive"] }
+serde_json = "1.0.111"
 tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "fs"] }
+
+[profile.release]
+#lto = true
+strip = true
+codegen-units = 1
--- a/23
+++ b/23
@ -0,0 +1,23 @@
+# Using the `rust-musl-builder` as base image, instead of 
+# the official Rust toolchain
+FROM clux/muslrust:stable AS chef
+USER root
+RUN cargo install cargo-chef
+WORKDIR /app
+
+FROM chef AS planner
+COPY . .
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM chef AS builder
+COPY --from=planner /app/recipe.json recipe.json
+# Notice that we are specifying the --target flag!
+RUN cargo chef cook --release --target x86_64-unknown-linux-musl --recipe-path recipe.json
+COPY . .
+RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool
+
+FROM alpine AS runtime
+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/
+USER myuser
+CMD ["/usr/local/bin/asset-tool"]
--- a/src/main.rs
+++ b/src/main.rs
@ -2,21 +2,46 @@ use std::io::{Read,Seek};
 use clap::{Args,Parser,Subcommand};
 use anyhow::Result as AResult;
 use futures::StreamExt;
+use rbx_dom_weak::types::Ref;

 type AssetID=u64;
+type AssetIDFileMap=Vec<(AssetID,std::path::PathBuf)>;
+const CONCURRENT_REQUESTS:usize=32;

 #[derive(Parser)]
 #[command(author,version,about,long_about=None)]
 #[command(propagate_version = true)]
 struct Cli{
+	#[arg(short,long)]
+	group:Option<u64>,
+	//idk how to do this better
+	#[arg(long)]
+	cookie_literal:Option<String>,
+	#[arg(long)]
+	cookie_env:Option<String>,
+	#[arg(long)]
+	cookie_file:Option<std::path::PathBuf>,
+
+	#[arg(long)]
+	asset_id:Option<AssetID>,
+
+	#[arg(short,long)]
+	input:Option<std::path::PathBuf>,
+
+	#[arg(short,long)]
+	output:Option<std::path::PathBuf>,
+
 	#[command(subcommand)]
 	command:Commands,
 }

 #[derive(Subcommand)]
 enum Commands{
-	Download(AssetIDList),
-	Upload{path:std::path::PathBuf,asset_id:AssetID},
+	DownloadHistory,
+	Download,
+	Upload,
+	Compile,
+	Decompile,
 }

 #[derive(Args)]
@ -24,20 +49,61 @@ struct PathBufList{
 	paths:Vec<std::path::PathBuf>
 }

-#[derive(Args)]
-struct AssetIDList{
-	asset_ids:Vec<AssetID>,
+#[derive(serde::Deserialize)]
+struct VersionPage{
+	previousPageCursor:Option<String>,
+	nextPageCursor:Option<String>,
+	data:Vec<AssetVersion>,
+}
+#[derive(serde::Deserialize,serde::Serialize)]
+struct AssetVersion{
+	Id:u64,
+	assetId:AssetID,
+	assetVersionNumber:u64,
+	creatorType:String,
+	creatorTargetId:u64,
+	creatingUniverseId:Option<u64>,
+	created:chrono::DateTime<chrono::Utc>,
+	isPublished:bool,
 }

 #[tokio::main]
 async fn main()->AResult<()>{
 	let cli=Cli::parse();
+
+	let cookie_enum={
+		match (cli.cookie_literal,cli.cookie_env,cli.cookie_file){
+			(Some(literal),None,None)=>Some(Cookie::Literal(literal)),
+			(None,Some(env_var),None)=>Some(Cookie::Environment(env_var)),
+			(None,None,Some(path))=>Some(Cookie::File(path)),
+			(None,None,None)=>None,
+			_=>return Err(anyhow::Error::msg("Cookie was specified multiple times.")),
+		}
+	};
+	let cookie=match cookie_enum{
+		Some(c)=>Some(format!(".ROBLOSECURITY={}",match c{
+			Cookie::Literal(s)=>s,
+			Cookie::Environment(var)=>std::env::var(var)?,
+			Cookie::File(path)=>tokio::fs::read_to_string(path).await?,
+		})),
+		None=>None,
+	};
+
 	match cli.command{
-		Commands::Download(asset_id_list)=>download_list(asset_id_list.asset_ids).await,
-		Commands::Upload{path,asset_id}=>upload_file(path,asset_id),
+		Commands::DownloadHistory=>download_history(cookie.unwrap(),cli.asset_id.unwrap()).await,
+		Commands::Download=>download_list(cookie.unwrap(),vec![(cli.asset_id.unwrap(),cli.output.unwrap())]).await,
+		Commands::Upload=>upload_list(cookie.unwrap(),cli.group,vec![(cli.asset_id.unwrap(),cli.output.unwrap())]).await,
+		Commands::Compile=>compile(cli.input.unwrap(),cli.output.unwrap()),
+		Commands::Decompile=>decompile(cli.input.unwrap(),cli.output.unwrap()),
 	}
 }

+enum Cookie{
+	Literal(String),
+	Environment(String),
+	File(std::path::PathBuf),
+}
+
 enum ReaderType<'a,R:Read+Seek>{
 	GZip(flate2::read::GzDecoder<&'a mut R>),
 	Raw(&'a mut R),
@ -55,29 +121,44 @@ fn maybe_gzip_decode<R:Read+Seek>(input:&mut R)->AResult<ReaderType<R>>{
 	}
 }

-fn upload_file(_path:std::path::PathBuf,_asset_id:AssetID)->AResult<()>{
-	Ok(())
-}
-
-const CONCURRENT_REQUESTS:usize=8;
-
-fn read_readable(mut readable:impl Read)->AResult<Vec<u8>>{
-	let mut contents=Vec::new();
-	readable.read_to_end(&mut contents)?;
-	Ok(contents)
-}
-
-async fn download_list(asset_ids:Vec<AssetID>)->AResult<()>{
-	let cookie=format!(".ROBLOSECURITY={}",std::env::var("RBXCOOKIE_PROJECTSLIME")?);
+async fn upload_list(cookie:String,group:Option<u64>,asset_id_file_map:AssetIDFileMap)->AResult<()>{
 	let client=reqwest::Client::new();
-	futures::stream::iter(asset_ids)
-	.map(|asset_id|{
+	futures::stream::iter(asset_id_file_map)
+	.map(|(asset_id,file)|{
 		let client=&client;
 		let cookie=cookie.as_str();
+		let group=&group;
 		async move{
-			let resp=client.get(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+			let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1")?;
+			//url borrow scope
+			{
+				let mut query=url.query_pairs_mut();//borrow here
+				query.append_pair("assetid",asset_id.to_string().as_str());
+				match group{
+					Some(group_id)=>{query.append_pair("groupId",group_id.to_string().as_str());},
+					None=>(),
+				}
+			}
+			
+			let body=tokio::fs::read_to_string(file).await?;
+			let mut resp=client.post(url.clone())
 			.header("Cookie",cookie)
+			.body(body.clone())
 			.send().await?;
+
+			//This is called a CSRF challenge apparently
+			if resp.status()==reqwest::StatusCode::FORBIDDEN{
+				if let Some(csrf_token)=resp.headers().get("X-CSRF-Token"){
+					resp=client.post(url)
+					.header("X-CSRF-Token",csrf_token)
+					.header("Cookie",cookie)
+					.body(body)
+					.send().await?;
+				}else{
+					return Err(anyhow::Error::msg("Roblox returned 403 with no CSRF"));
+				}
+			}
+
 			Ok((asset_id,resp.bytes().await?))
 		}
 	})
@ -85,7 +166,37 @@ async fn download_list(asset_ids:Vec<AssetID>)->AResult<()>{
 	.for_each(|b:AResult<_>|async{
 			match b{
 				Ok((asset_id,body))=>{
-					let dest=std::path::PathBuf::from(asset_id.to_string());
+					println!("asset_id={} response.body={:?}",asset_id,body);
+				},
+				Err(e)=>eprintln!("ul error: {}",e),
+			}
+		}).await;
+	Ok(())
+}
+
+fn read_readable(mut readable:impl Read)->AResult<Vec<u8>>{
+	let mut contents=Vec::new();
+	readable.read_to_end(&mut contents)?;
+	Ok(contents)
+}
+
+async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<()>{
+	let client=reqwest::Client::new();
+	futures::stream::iter(asset_id_file_map)
+	.map(|(asset_id,file)|{
+		let client=&client;
+		let cookie=cookie.as_str();
+		async move{
+			let resp=client.get(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+			.header("Cookie",cookie)
+			.send().await?;
+			Ok((file,resp.bytes().await?))
+		}
+	})
+	.buffer_unordered(CONCURRENT_REQUESTS)
+	.for_each(|b:AResult<_>|async{
+			match b{
+				Ok((dest,body))=>{
 					let contents=match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
 						Ok(ReaderType::GZip(readable))=>read_readable(readable),
 						Ok(ReaderType::Raw(readable))=>read_readable(readable),
@ -103,4 +214,382 @@ async fn download_list(asset_ids:Vec<AssetID>)->AResult<()>{
 			}
 		}).await;
 	Ok(())
+}
+
+async fn download_history(cookie:String,asset_id:AssetID)->AResult<()>{
+	let client=reqwest::Client::new();
+	let asset_id_string=asset_id.to_string();
+
+	//poll paged list of all asset versions
+	let mut cursor:Option<String>=None;
+	let mut asset_list=Vec::new();
+	loop{
+		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",asset_id).as_str())?;
+		//url borrow scope
+		{
+			let mut query=url.query_pairs_mut();//borrow here
+			//query.append_pair("sortOrder","Asc");
+			//query.append_pair("limit","100");
+			//query.append_pair("count","100");
+			match &cursor{
+				Some(next_page)=>{query.append_pair("cursor",next_page);}
+				None=>(),
+			}
+		}
+		println!("page url={}",url);
+		let resp=client.get(url)
+		.header("Cookie",cookie.clone())
+		.send().await?;
+		match resp.json::<VersionPage>().await{
+			Ok(mut page)=>{
+				asset_list.append(&mut page.data);
+				if page.nextPageCursor.is_none(){
+					break;
+				}
+				cursor=page.nextPageCursor;
+			},
+			Err(e)=>panic!("error: {}",e),
+		}
+	}
+	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
+	let mut path=std::path::PathBuf::new();
+	path.set_file_name("versions.json");
+	tokio::fs::write(path,serde_json::to_string(&asset_list)?).await?;
+
+	//download all versions
+	futures::stream::iter(asset_list)
+	.map(|asset_version|{
+		let client=&client;
+		let cookie=cookie.as_str();
+		let asset_id_str=asset_id_string.as_str();
+		async move{
+			let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/")?;
+			//url borrow scope
+			{
+				let mut query=url.query_pairs_mut();//borrow here
+				query.append_pair("ID",asset_id_str);
+				query.append_pair("version",asset_version.assetVersionNumber.to_string().as_str());
+			}
+			println!("download url={}",url);
+			let mut result=Err(anyhow::Error::msg("all requests failed"));
+			for i in 1..=8{
+				let resp=client.get(url.clone())
+				.header("Cookie",cookie)
+				.send().await?;
+
+				if !resp.status().is_success(){
+					println!("request {} failed",i);
+					continue;
+				}
+
+				let mut path=std::path::PathBuf::new();
+				path.set_file_name(format!("{}_v{}.rbxl",asset_id,asset_version.assetVersionNumber));
+				result=Ok((path,resp.bytes().await?));
+				break;
+			}
+			result
+		}
+	})
+	.buffer_unordered(CONCURRENT_REQUESTS)
+	.for_each(|b:AResult<_>|async{
+			match b{
+				Ok((dest,body))=>{
+					let contents=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),
+					};
+					match contents{
+						Ok(data)=>match tokio::fs::write(dest,data).await{
+							Err(e)=>eprintln!("fs error: {}",e),
+							_=>(),
+						},
+						Err(e)=>eprintln!("gzip error: {}",e),
+					};
+				},
+				Err(e)=>eprintln!("dl error: {}",e),
+			}
+		}).await;
+	Ok(())
+}
+
+fn load_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
+	let mut first_8=[0u8;8];
+	if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){
+		match &first_8[0..4]{
+			b"<rob"=>{
+				match &first_8[4..8]{
+					b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg),
+					b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg),
+					other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
+				}
+			},
+			_=>Err(anyhow::Error::msg("unsupported file type")),
+		}
+	}else{
+		Err(anyhow::Error::msg("peek failed"))
+	}
+}
+
+#[derive(PartialEq)]
+enum Class{
+	Folder,
+	ModuleScript,
+	LocalScript,
+	Script,
+	Model,
+}
+
+struct TreeNode{
+	name:String,
+	referent:Ref,
+	parent:Ref,
+	class:Class,
+	children:Vec<Ref>,
+}
+impl TreeNode{
+	fn new(name:String,referent:Ref,parent:Ref,class:Class)->Self{
+		Self{
+			name,
+			referent,
+			parent,
+			class,
+			children:Vec::new(),
+		}
+	}
+}
+
+enum TrimStackInstruction{
+	Referent(Ref),
+	IncrementScript,
+	DecrementScript,
+}
+
+enum WriteStackInstruction<'a>{
+	Node(&'a TreeNode,u32),//(Node,NameTally)
+	PushFolder(String),
+	PopFolder,
+	Destroy(Ref),
+}
+
+#[derive(Default,serde::Deserialize,serde::Serialize)]
+struct PropertiesOverride{
+	//Name:Option<String>,
+	ClassName:Option<String>,
+}
+impl PropertiesOverride{
+	fn is_some(&self)->bool{
+		self.ClassName.is_some()
+	}
+}
+
+fn sanitize<'a>(s:&'a str)->std::borrow::Cow<'a,str>{
+	lazy_regex::regex!(r"[^a-zA-Z0-9._-]").replace_all(s,"_")
+}
+
+fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeNode,node_name_override:&str)->AResult<()>{
+	file.push(sanitize(node_name_override).as_ref());
+	match node.class{
+		Class::Folder=>(),
+		Class::ModuleScript|Class::LocalScript|Class::Script=>{
+			assert!(file.set_extension("lua"),"could not set extension");
+			assert!(dom.get_by_ref(node.referent).is_some_and(|item|{
+				//TODO: delete disabled scripts
+				if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get("Source"){
+					std::fs::write(file,source).is_ok()
+				}else{false}
+			}),"no string property or file failed to write");
+		},
+		Class::Model=>{
+			assert!(file.set_extension("rbxmx"));
+			let output=std::io::BufWriter::new(std::fs::File::create(file)?);
+			rbx_xml::to_writer_default(output,dom,&[node.referent])?;
+		},
+	}
+	Ok(())
+}
+
+fn decompile(input_file:std::path::PathBuf,output_folder:std::path::PathBuf)->AResult<()>{
+	//rules:
+	//Class Script|LocalScript|ModuleScript->$Name.lua
+	//Class Model->$Name.rbxmx
+	//overrides.json per-folder [Override{name,class}]
+	//Everything else goes into template.rbxlx
+
+	//read file
+	let mut input=std::io::BufReader::new(std::fs::File::open(input_file)?);
+	let mut dom=load_dom(&mut input)?;
+
+	let mut tree_refs=std::collections::HashMap::new();
+	tree_refs.insert(dom.root_ref(),TreeNode::new(
+		"src".to_string(),
+		dom.root_ref(),
+		Ref::none(),
+		Class::Folder
+	));
+
+	//run rules
+	let mut stack=vec![dom.root()];
+	while let Some(item)=stack.pop(){
+		let class=match item.class.as_str(){
+			"ModuleScript"=>Class::ModuleScript,
+			"LocalScript"=>Class::LocalScript,
+			"Script"=>Class::Script,
+			"Model"=>Class::Model,
+			_=>Class::Folder,
+		};
+		let skip=match class{
+			Class::Model=>true,
+			_=>false,
+		};
+		if let Some(parent_node)=tree_refs.get_mut(&item.parent()){
+			let referent=item.referent();
+			let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class);
+			parent_node.children.push(referent);
+			tree_refs.insert(referent,node);
+		}
+		if skip{
+			continue;
+		}
+		for &referent in item.children(){
+			if let Some(c)=dom.get_by_ref(referent){
+				stack.push(c);
+			}
+		}
+	}
+
+	//trim empty folders
+	let mut script_count=0;
+	let mut stack:Vec<TrimStackInstruction>=tree_refs.get(&dom.root_ref()).unwrap().children
+	.iter().map(|&c|TrimStackInstruction::Referent(c)).collect();
+	while let Some(instruction)=stack.pop(){
+		match instruction{
+			TrimStackInstruction::IncrementScript=>script_count+=1,
+			TrimStackInstruction::DecrementScript=>script_count-=1,
+			TrimStackInstruction::Referent(referent)=>{
+				let mut delete=None;
+				if let Some(node)=tree_refs.get_mut(&referent){
+					if node.class==Class::Folder&&script_count!=0{
+						node.class=Class::Model
+					}
+					if node.class==Class::Folder&&node.children.len()==0{
+						delete=Some(node.parent);
+					}else{
+						//how the hell do I do this better without recursion
+						let is_script=match node.class{
+							Class::ModuleScript|Class::LocalScript|Class::Script=>true,
+							_=>false,
+						};
+						//stack is popped from back
+						if is_script{
+							stack.push(TrimStackInstruction::DecrementScript);
+						}
+						for &child_referent in &node.children{
+							stack.push(TrimStackInstruction::Referent(child_referent));
+						}
+						if is_script{
+							stack.push(TrimStackInstruction::IncrementScript);
+						}
+					}
+				}
+				//trim referent
+				if let Some(parent_ref)=delete{
+					let parent_node=tree_refs.get_mut(&parent_ref)
+					.expect("parent_ref does not exist in tree_refs");
+					parent_node.children.remove(
+						parent_node.children.iter()
+						.position(|&r|r==referent)
+						.expect("parent.children does not contain referent")
+					);
+					tree_refs.remove(&referent);
+				}
+			},
+		}
+	}
+
+	//generate folders, models, and scripts
+	//delete models and scripts from dom
+
+	let mut name_tally=std::collections::HashMap::<String,u32>::new();
+	let mut folder=output_folder.clone();
+	let mut stack=vec![WriteStackInstruction::Node(tree_refs.get(&dom.root_ref()).unwrap(),0)];
+	while let Some(instruction)=stack.pop(){
+		match instruction{
+			WriteStackInstruction::PushFolder(component)=>folder.push(component),
+			WriteStackInstruction::PopFolder=>assert!(folder.pop(),"weirdness"),
+			WriteStackInstruction::Destroy(referent)=>dom.destroy(referent),
+			WriteStackInstruction::Node(node,name_count)=>{
+				//properties.json to override class or other simple properties
+				let mut properties=PropertiesOverride::default();
+				let has_children=node.children.len()!=0;
+				match node.class{
+					Class::Folder=>(),
+					Class::ModuleScript=>{
+						//.lua files are ModuleScript by default
+						if has_children{
+							properties.ClassName=Some("ModuleScript".to_string())
+						}
+					},
+					Class::LocalScript=>properties.ClassName=Some("LocalScript".to_string()),
+					Class::Script=>properties.ClassName=Some("Script".to_string()),
+					Class::Model=>(),
+				}
+				let name_override=if 0<name_count{
+					format!("{}_{}",node.name,name_count)
+				}else{
+					node.name.clone()
+				};
+				if has_children||properties.is_some(){
+					//push temp subfolder
+					let mut subfolder=folder.clone();
+					subfolder.push(sanitize(name_override.as_str()).as_ref());
+					//make folder
+					std::fs::create_dir(subfolder.clone())?;
+					//write properties
+					if properties.is_some(){
+						let mut file=subfolder.clone();
+						file.push("properties");
+						assert!(file.set_extension("json"),"could not set extension");
+						std::fs::write(file,serde_json::to_string(&properties)?)?
+					}
+					//write item in subfolder
+					write_item(&dom,subfolder,node,name_override.as_str())?;
+				}else{
+					//write item
+					write_item(&dom,folder.clone(),node,name_override.as_str())?;
+				}
+				//queue item to be deleted from dom after child objects are handled (stack is popped from the back)
+				match node.class{
+					Class::Folder=>(),
+					_=>stack.push(WriteStackInstruction::Destroy(node.referent)),
+				}
+				if has_children{
+					stack.push(WriteStackInstruction::PopFolder);
+					name_tally.clear();
+					for referent in &node.children{
+						if let Some(c)=tree_refs.get(referent){
+							let v=name_tally.entry(c.name.clone()).and_modify(|v|*v+=1).or_default();
+							stack.push(WriteStackInstruction::Node(c,*v));
+						}
+					}
+					stack.push(WriteStackInstruction::PushFolder(sanitize(name_override.as_str()).to_string()));
+				}
+			},
+		}
+	}
+
+	//write what remains in template.rbxlx
+	{
+		let mut file=output_folder.clone();
+		file.push("template");
+		assert!(file.set_extension("rbxlx"));
+		let output=std::io::BufWriter::new(std::fs::File::create(file)?);
+		rbx_xml::to_writer_default(output,&dom,&[dom.root_ref()])?;
+	}
+
+	Ok(())
+}
+
+fn compile(_folder:std::path::PathBuf,_file:std::path::PathBuf)->AResult<()>{
+	Ok(())
 }
Author	SHA1	Message	Date
Quaternions	f0de2a41ad	pass tally into stack instruction to generate name override	2024-01-06 15:01:56 -08:00
Quaternions	fdbe3251b3	more requests	2024-01-06 13:10:13 -08:00
Quaternions	b2f92a741c	download version history	2024-01-06 13:10:13 -08:00
Quaternions	7e4a9f872c	add version history deps	2024-01-06 12:39:16 -08:00
Quaternions	5f1178d0cf	use output instead of key val pair	2024-01-06 12:38:43 -08:00
Quaternions	bb32d30896	error msg	2024-01-06 11:15:07 -08:00
Quaternions	03ae57e2e1	sanitize	2024-01-06 11:13:52 -08:00
Quaternions	589c1b044e	invalid states are representable but I don't care	2024-01-05 21:36:21 -08:00
Quaternions	aed3b69ca0	decompile	2024-01-05 21:07:04 -08:00
Quaternions	4a081d5b8f	delete useless enum	2024-01-05 13:47:32 -08:00
Quaternions	54ca5520b7	containerfile	2024-01-02 13:11:28 -08:00
Quaternions	23dfcadc85	only support one asset for now	2024-01-01 12:22:12 -08:00
Quaternions	1075d59a91	async upload	2024-01-01 12:22:12 -08:00
Quaternions	01676bb4da	redo asset stuff as asset id and file list	2024-01-01 12:21:34 -08:00
Quaternions	df62258608	implement cookie and group as arg (bad)	2024-01-01 12:21:34 -08:00
Quaternions	dc4ec4547a	release opti	2024-01-01 12:21:34 -08:00
Quaternions	929484855d	async download	2024-01-01 12:21:33 -08:00