Struct Rob

pub struct Rob {
    pub cfg: Config,
    /* private fields */
}

The main Rob structure.

Fields

cfg: Config

Implementations

impl Rob

pub const MAX_DIR_LVL: usize = 4usize

pub fn new() -> Rob

pub fn needs_rebuild(bin: &str, src: &str) -> IoResult<bool>

Checks if src file needs rebuild

pub fn needs_rebuild_many(bin: &str, srcs: &Vec<String>) -> RobResult<bool>

pub fn go_rebuild_yourself(source_path: &str) -> IoResult<()>

Modified text from: https://github.com/tsoding/nobuild Go Rebuild Urself™ Technology

How to use it:

fn main() {
    go_rebuild_yourself!();
    // actual work
}

After your added this macro every time you run ./rob it will detect that you modified its original source code and will try to rebuild itself before doing any actual work. So you only need to bootstrap your build system once.

The modification is detected by comparing the last modified times of the executable and its source code. The same way the make utility usually does it.

pub fn get_last_modification_time<P>(p: P) -> IoResult<SystemTime>

where P: AsRef<Path>,

pub fn noext(p: &str) -> String

Takes path and returns it without the file extension

pub fn is_file<P>(p: P) -> bool

where P: Into<PathBuf>,

pub fn is_dir<P>(p: P) -> bool

where P: Into<PathBuf>,

pub fn path_exists<P>(p: P) -> bool

where P: Into<PathBuf>,

pub fn rename<P>(from: P, to: P) -> IoResult<()>

where P: AsRef<Path>,

pub fn mkdir<P>(p: P) -> IoResult<()>

where P: Into<PathBuf>,

pub fn rm_if_exists<P>(p: P)

where P: Into<PathBuf> + ToOwned<Owned = String>,

pub fn rm<P>(p: P) -> IoResult<()>

where P: Into<PathBuf> + ToOwned<Owned = String>,

pub fn log(lvl: LogLevel, out: &str)

pub fn echo(&mut self, echo: bool) -> &mut Self

pub fn keepgoing(&mut self, keepgoing: bool) -> &mut Self

pub fn append<S>(&mut self, xs: &[S]) -> &mut Self

where S: ToString + PartialEq<&'static str>,

pub fn append_mv<S>(&mut self, xs: &[S]) -> &mut Self

where S: ToString + PartialEq<&'static str>,

pub fn execute_jobs_sync(&mut self) -> RobResult<Vec<Vec<Output>>>

pub fn execute_jobs_async(&mut self) -> RobResult<Vec<Vec<Output>>>

pub fn append_job_job(&mut self, job: Job) -> &mut Self

pub fn append_job<S>( &mut self, target: &str, deps: Vec<S>, cmd: RobCommand, ) -> &mut Self

where S: Into<String>,

pub fn execute(&mut self) -> IoResult<&mut Self>

pub fn execute_sync(&mut self) -> IoResult<Output>

pub fn execute_all_sync(&mut self) -> RobResult<Vec<Output>>

pub fn output(&mut self) -> Option<Output>

pub fn outputs_refs(&self) -> VecDeque<&Output>

pub fn outputs(self) -> VecDeque<Output>

Trait Implementations

impl Clone for Rob

fn clone(&self) -> Rob

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rob

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Rob

fn default() -> Rob

Returns the “default value” for a type.

impl Hash for Rob

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Rob

fn eq(&self, other: &Rob) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Rob

impl StructuralPartialEq for Rob