decompile

Cargo.lock

@@ -107,6 +107,8 @@ dependencies = [
  "rbx_reflection_database",
  "rbx_xml",
  "reqwest",
+ "serde",
+ "serde_json",
  "tokio",
 ]
 
@@ -913,9 +915,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 +959,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 +1232,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 +1252,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 +1300,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",

Cargo.toml

@@ -17,6 +17,8 @@ rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
 reqwest = { version = "0.11.23", features = ["cookies"] }
+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]

src/main.rs

@@ -2,6 +2,7 @@ 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)>;
@@ -38,6 +39,12 @@ struct Cli{
 	#[arg(long,value_parser=parse_key_val::<AssetID,std::path::PathBuf>)]
 	asset_id:(AssetID,std::path::PathBuf),
 
+	#[arg(short,long)]
+	input:Option<std::path::PathBuf>,
+
+	#[arg(short,long)]
+	output:Option<std::path::PathBuf>,
+
 	#[command(subcommand)]
 	command:Commands,
 }
@@ -46,6 +53,8 @@ struct Cli{
 enum Commands{
 	Download,
 	Upload,
+	Compile,
+	Decompile,
 }
 
 #[derive(Args)]
@@ -74,6 +83,8 @@ async fn main()->AResult<()>{
 	match cli.command{
 		Commands::Download=>download_list(cookie,vec![cli.asset_id]).await,
 		Commands::Upload=>upload_list(cookie,cli.group,vec![cli.asset_id]).await,
+		Commands::Compile=>compile(cli.input.unwrap(),cli.output.unwrap()),
+		Commands::Decompile=>decompile(cli.input.unwrap(),cli.output.unwrap()),
 	}
 }
 
@@ -194,3 +205,272 @@ async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<
 		}).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),
+	PushFolder(std::path::Component<'a>),
+	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 write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeNode)->AResult<()>{
+	file.push(node.name.as_str());
+	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}
+			}),"some ting wong");
+		},
+		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 folder=output_folder.clone();
+	let mut stack=vec![WriteStackInstruction::Node(tree_refs.get(&dom.root_ref()).unwrap())];
+	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)=>{
+				//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=>(),
+				}
+				if has_children||properties.is_some(){
+					//push temp subfolder
+					let mut subfolder=folder.clone();
+					subfolder.push(node.name.as_str());
+					//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)?;
+				}else{
+					//write item
+					write_item(&dom,folder.clone(),node)?;
+				}
+				//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);
+					for referent in &node.children{
+						if let Some(c)=tree_refs.get(referent){
+							stack.push(WriteStackInstruction::Node(c));
+						}
+					}
+					stack.push(WriteStackInstruction::PushFolder(std::path::Component::Normal(std::ffi::OsStr::new(node.name.as_str()))));
+				}
+			},
+		}
+	}
+	}
+	//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(())
+}