From 9897d90be9df8b05413fc530901051ddae0e0a3c Mon Sep 17 00:00:00 2001 From: Jason Travis Smith Date: Fri, 8 Apr 2016 19:59:39 -0400 Subject: [PATCH] Commented the current code. The output directory is now also set at the start. --- README.md | 2 +- examples/build.rs | 17 ++++++++++- src/processor.rs | 74 ++++++++++++++++++++++++++++++++++++----------- 3 files changed, 74 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index d7dd49e..3e7583d 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ to be placed, and what tool should be used to build them. The file should be placed in the "resources" directory and named "resources.msnr". The format is a simple text file composed of sections seperated by -empty lines. Each section defines a resource to comile. The format for +empty lines. Each section defines a resource to compile. The format for each section is as follows. diff --git a/examples/build.rs b/examples/build.rs index 985b6a1..63035be 100644 --- a/examples/build.rs +++ b/examples/build.rs @@ -5,6 +5,7 @@ extern crate mason; +use std::env; use std::path::PathBuf; use mason::Processor; @@ -48,7 +49,21 @@ pub fn main() None => { - output_dir = PathBuf::new(); + // Try to just get the current directory. + match env::current_dir() + { + Ok(dir) => + { + output_dir = PathBuf::from(dir); + } + + Err(error) => + { + // Then just default to "". + warn!("{}", error); + output_dir = PathBuf::new(); + } + } } } diff --git a/src/processor.rs b/src/processor.rs index 7efa1a5..8678751 100644 --- a/src/processor.rs +++ b/src/processor.rs @@ -1,36 +1,40 @@ +use std::env; use std::fs::File; use std::io::{BufRead, BufReader}; use std::path::{Path, PathBuf}; -/// +/// The default name of the resources directory. const DEFAULT_RESOURCES_DIR: &'static str = "resources"; -/// +/// The default name to be used for the resource manifest file. const DEFAULT_MANIFEST_FILENAME: &'static str = "resources.msnr"; -/// +/// Defines a resource to be compiled. struct Section { - /// + /// A unique name used to reference the + /// resource defined in this Section. pub name: String, - /// + /// A hint for what kind of loader to + /// use for this resource. pub type_hint: String, - /// + /// The path to the resources src information. pub src_path: String, - /// + /// The path to place the compiled resource at. pub dst_path: String, - /// + /// The compiler to invoke to compile the + /// resource defined in this Section. pub compiler: String, - /// + /// The arguments to pass to the compiler. pub arguments: String } @@ -59,7 +63,7 @@ pub struct Processor impl Section { - /// + /// Create a new Section with default values. pub fn new() -> Section { Section @@ -76,41 +80,68 @@ impl Section impl Processor { - /// + /// Create a new resource manifest Processor. pub fn new() -> Processor { + let out_dir: PathBuf; + + // Try to just get the current directory. + match env::current_dir() + { + Ok(dir) => + { + out_dir = PathBuf::from(dir); + } + + Err(error) => + { + warn!("{}", error); + out_dir = PathBuf::new(); + } + } + Processor { manifest_filename: String::from(DEFAULT_MANIFEST_FILENAME), resources_dir: PathBuf::from(DEFAULT_RESOURCES_DIR), - output_dir: PathBuf::new(), + output_dir: out_dir, task_count: 1u64, sections: Vec::new() } } + /// Change the directory to load the resource manifest file from. + /// This is also the directory used as the root when looking for + /// resources. /// + /// Defaults to "". pub fn set_resources_dir(&mut self, dir: &Path) { self.resources_dir = PathBuf::from(dir); println!("Resource dir: {}", self.resources_dir.to_str().unwrap()); } + /// Change the directory to place the compiled resources into. + /// This is also the directory where the loaded manifest file will + /// be placed. /// + /// Defaults to "resources". pub fn set_output_dir(&mut self, dir: &Path) { self.output_dir = PathBuf::from(dir); println!("Output dir: {}", self.output_dir.to_str().unwrap()); } + /// Sets the amount of tasks to have live to compile the resources. /// + /// Each resource will be compiled on a seperate blocking thread. pub fn set_task_count(&mut self, count: u64) { self.task_count = count; println!("Task count: {}", self.task_count); } - /// + /// Process the resource manifest file. pub fn process_manifest_file(&mut self) { // Read the manifest file from the resources directory. @@ -120,7 +151,7 @@ impl Processor self.compile_resources(); } - /// + /// Read the manifest file. /// /// Reading the manifest file can be a blocking /// operation since there is nothing else to do until @@ -207,7 +238,7 @@ impl Processor self.read_manifest_section(§ion_buffer); } - /// + /// Read a single manifest section from a given buffer. fn read_manifest_section(&mut self, buffer: &Vec) { let mut header: &str; @@ -215,14 +246,22 @@ impl Processor let mut section: Section; let mut values: Vec<&str>; + // Only do something if there are some + // lines in the buffer to process. if buffer.len() > 0 { + // Create a new Section and fill out its information + // by parsing the data in the buffer. section = Section::new(); for line in buffer.iter() { + // Split each line in the buffer by the '=' character. + // This should be parsed into 2 lines then. values = line.split("=").collect(); if values.len() == 2 { + // Get the header and value to set + // the Sections values. header = values[0].trim(); value = values[1].trim(); if header == "name" @@ -252,16 +291,17 @@ impl Processor } else { - warn!("Detected a name value entry that is incomplete.\n{}", + warn!("Detected a name value entry that is incorrect.\n{}", line.trim()); } } + // Add the newly created section to the list of sections. self.sections.push(section); } } - /// + /// Compile all the resources in the Section list. fn compile_resources(&self) { }