Struct OFile 

pub struct OFile {
    pub name: String,
    pub include_paths: Vec<PathBuf>,
    pub compile_flags: Vec<String>,
}

Fields

name: String

include_paths: Vec<PathBuf>

compile_flags: Vec<String>

Implementations

impl OFile

pub fn new( name: &str, include_paths: Vec<PathBuf>, compile_flags: Vec<String>, ) -> Self

Examples found in repository

examples/project_expand/main.rs (line 86)

fn main() {
    env_logger::init();

    let args: Args = argh::from_env();

    let srcdir = args.src;
    let sandbox = args.sandbox;

    let mut g = G::new(srcdir.clone(), sandbox);

    let main_c = g
        .add_root_node(CFile::new("project_expand/main.c"))
        .unwrap();
    let main_o = g
        .add_node(OFile::new("project_expand/main.o", vec![], vec![]))
        .unwrap();
    let _wrapper_h = g
        .add_root_node(HFile::new("project_expand/wrapper.h"))
        .unwrap();
    let app = g.add_node(XFile::new("project_expand/app")).unwrap();

    let languages_yml = g
        .add_root_node(YmlDesc::new("project_expand/languages.yml"))
        .unwrap();
    let languages_json = g
        .add_node(JsonDesc::new("project_expand/languages.json"))
        .unwrap();
    let liblangs = g
        .add_node(AFile::new("project_expand/generated/liblangs.a"))
        .unwrap();

    g.add_edge(main_c, main_o);
    g.add_edge(main_o, app);
    g.add_edge(languages_yml, languages_json);
    g.add_edge(languages_json, liblangs);
    g.add_edge(liblangs, app);

    info!(
        "Created graph with {} nodes and {} edges",
        g.g.node_count(),
        g.g.edge_count()
    );

    let success = g.make();
    info!("Build {}", if success { "succeeded" } else { "failed" });

    // Write mermaid graph to file
    let mermaid_path = srcdir.join("project_expand/graph.mermaid");
    let mermaid = g.to_mermaid();
    fs::write(&mermaid_path, &mermaid).expect("Failed to write graph.mermaid");
    info!("Wrote mermaid graph to {}", mermaid_path.display());
}

examples/project_C/main.rs (line 84)

fn main() {
    env_logger::init();

    let args: Args = argh::from_env();

    let srcdir = args.src;
    let sandbox = args.sandbox;

    // ANCHOR: instanciate
    let mut g = G::new(srcdir, sandbox);
    // ANCHOR_END: instanciate

    // ANCHOR: add_nodes
    let main_c = g.add_root_node(CFile::new("project_C/main.c")).unwrap();
    let main_o = g
        .add_node(OFile::new("project_C/main.o", vec![], vec![]))
        .unwrap();
    let add_c = g.add_root_node(CFile::new("project_C/add.c")).unwrap();
    let add_o = g
        .add_node(OFile::new(
            "project_C/add.o",
            vec![],
            vec!["-DYYY_defined".to_string()],
        ))
        .unwrap();
    let _add_h = g.add_root_node(HFile::new("project_C/add.h")).unwrap();
    let _wrapper_h = g.add_root_node(HFile::new("project_C/wrapper.h")).unwrap();
    let project_a = g.add_node(AFile::new("project_C/libproject.a")).unwrap();
    let app = g.add_node(XFile::new("project_C/app")).unwrap();
    // ANCHOR_END: add_nodes

    // ANCHOR: add_edges
    g.add_edge(main_c, main_o);
    g.add_edge(main_o, app);
    g.add_edge(add_c, add_o);
    g.add_edge(add_o, project_a);
    g.add_edge(project_a, app);
    // ANCHOR_END: add_edges

    info!(
        "Created graph with {} nodes and {} edges",
        g.g.node_count(),
        g.g.edge_count()
    );

    // ANCHOR: make
    // make() will:
    // 1. Mount root nodes (copy source files to sandbox)
    // 2. Scan for dependencies (adds edges for #include directives)
    // 3. Build all nodes in dependency order (parallel where possible)
    let success = g.make();
    info!("Build {}", if success { "succeeded" } else { "failed" });
    // ANCHOR_END: make
}

examples/project_expand/../../tests/common/json_desc.rs (line 122)

    fn expand(&self, sandbox: &Path, _predecessors: &[&(dyn GNode + Send + Sync)]) -> ExpandResult {
        let input_path = sandbox.join(&self.name);
        let json_content = fs::read_to_string(&input_path)
            .map_err(|e| ExpandError::ReadError(input_path.clone(), e))?;

        let languages: Vec<Language> = serde_json::from_str(&json_content).map_err(|e| {
            ExpandError::ParseError(format!(
                "Failed to parse JSON {}: {}",
                input_path.display(),
                e
            ))
        })?;

        let generated_dir = sandbox.join("project_expand/generated");
        fs::create_dir_all(&generated_dir).ok();

        let mut nodes: Vec<Box<dyn GNode + Send + Sync>> = Vec::new();
        let mut edges: Vec<Edge> = Vec::new();

        let lib_path = "project_expand/generated/liblangs.a";

        for lang in &languages {
            // Generate C file
            let c_path = format!("project_expand/generated/{}.c", lang.language);
            let c_content = format!(
                "const char* helloworld_{}=\"{}\" ;\nconst char* get_{}() {{ return helloworld_{} ; }}\n",
                lang.language, lang.helloworld, lang.language, lang.language
            );
            let c_full_path = sandbox.join(&c_path);
            fs::write(&c_full_path, &c_content)
                .map_err(|e| ExpandError::WriteError(c_full_path, e))?;
            nodes.push(Box::new(CFile::new(&c_path)));

            // Generate H file
            let h_path = format!("project_expand/generated/{}.h", lang.language);
            let h_content = format!("const char* get_{}() ;\n", lang.language);
            let h_full_path = sandbox.join(&h_path);
            fs::write(&h_full_path, &h_content)
                .map_err(|e| ExpandError::WriteError(h_full_path, e))?;
            nodes.push(Box::new(HFile::new(&h_path)));

            // Create OFile for this language
            let o_path = format!("project_expand/generated/{}.o", lang.language);
            nodes.push(Box::new(OFile::new(&o_path, vec![], vec![])));

            // Add edges from JsonDesc to CFile and HFile (so they are not treated as root nodes)
            edges.push(Edge {
                nfrom: Box::new(JsonDesc::new(&self.name)),
                nto: Box::new(CFile::new(&c_path)),
            });
            edges.push(Edge {
                nfrom: Box::new(JsonDesc::new(&self.name)),
                nto: Box::new(HFile::new(&h_path)),
            });

            // Add edges: CFile -> OFile -> AFile
            edges.push(Edge {
                nfrom: Box::new(CFile::new(&c_path)),
                nto: Box::new(OFile::new(&o_path, vec![], vec![])),
            });
            edges.push(Edge {
                nfrom: Box::new(OFile::new(&o_path, vec![], vec![])),
                nto: Box::new(AFile::new(lib_path)),
            });
        }

        // Generate languages.h with array of function pointers
        let languages_h_path = PathBuf::from("project_expand/generated/languages.h");
        let mut h_content = String::new();
        h_content.push_str("#ifndef LANGUAGES_H\n");
        h_content.push_str("#define LANGUAGES_H\n\n");

        for lang in &languages {
            h_content.push_str(&format!(
                "#include \"project_expand/generated/{}.h\"\n",
                lang.language
            ));
        }
        h_content.push_str("\n");

        h_content.push_str(&format!("#define N_languages {}\n\n", languages.len()));

        h_content.push_str("typedef const char* (*get_language_fn)() ;\n\n");
        h_content.push_str("get_language_fn languages[] = {\n");
        for lang in &languages {
            h_content.push_str(&format!("    get_{},\n", lang.language));
        }
        h_content.push_str("} ;\n\n");

        h_content.push_str("#endif\n");

        let languages_h_full_path = sandbox.join(&languages_h_path);
        fs::write(&languages_h_full_path, &h_content)
            .map_err(|e| ExpandError::WriteError(languages_h_full_path, e))?;
        nodes.push(Box::new(HFile::new(&languages_h_path.to_string_lossy())));

        // Add edge from JsonDesc to languages.h
        edges.push(Edge {
            nfrom: Box::new(JsonDesc::new(&self.name)),
            nto: Box::new(HFile::new(&languages_h_path.to_string_lossy())),
        });

        Ok((nodes, edges))
    }

Trait Implementations

impl GNode for OFile

fn build( &self, sandbox: &Path, predecessors: &[&(dyn GNode + Send + Sync)], ) -> bool

fn scan( &self, sandbox: &Path, predecessors: &[&(dyn GNode + Send + Sync)], ) -> (bool, Vec<PathBuf>)

fn tag(&self) -> String

fn pathbuf(&self) -> PathBuf

fn expand( &self, _sandbox: &Path, _predecessors: &[&(dyn GNode + Send + Sync)], ) -> ExpandResult