Using petgraph identifiers

Author: alshdavid

packages/mach/src/cmd/build/build.rs

@@ -52,7 +52,6 @@ pub fn build(
       env: mach_options.env,
       out_folder: mach_options.out_folder,
     },
-    asset_contents: Default::default(),
     asset_graph: Default::default(),
     bundle_graph: Default::default(),
     plugins: Default::default(),
@@ -64,11 +63,17 @@ pub fn build(
 
   // This will resolve imports, transform files and build the AssetGraph.
   resolve_and_transform(&mut c)?;
-  emit_file(&c, "asset_graph.dot", c.debug_asset_graph_dot(DebugAssetGraphOptions{ show_specifiers: false }))?;
+  emit_file(
+    &c,
+    "asset_graph.dot",
+    c.debug_asset_graph_dot(DebugAssetGraphOptions {
+      show_specifiers: false,
+    })?,
+  )?;
 
   // This will read the asset graph and organize related assets into groupings (a.k.a bundles)
   bundle(&mut c)?;
-  emit_file(&c, "bundle_graph.dot", c.debug_bundle_graph_dot())?;
+  emit_file(&c, "bundle_graph.dot", c.debug_bundle_graph_dot()?)?;
 
   // This will apply the runtime to and optimize the bundles
   package(&mut c)?;

packages/mach/src/core/bundling/bundle.rs

@@ -2,58 +2,56 @@ use petgraph::graph::NodeIndex;
 use petgraph::visit::EdgeRef;
 use petgraph::visit::NodeRef;
 
+use crate::types::AssetGraphExt;
 use crate::types::AssetId;
 use crate::types::Bundle;
+use crate::types::BundleGraphExt;
 use crate::types::BundleId;
 use crate::types::Compilation;
+use crate::types::ROOT_ASSET;
+use crate::types::ROOT_BUNDLE;
 
 // Simple bundling algorithm that does not deduplicate assets or bundle split
 pub fn bundle(c: &mut Compilation) -> anyhow::Result<()> {
-  let asset_graph = c.asset_graph.as_graph();
-  let root_node = c.asset_graph.root_node();
+  c.bundle_graph.add_bundle(Bundle::default()); // Root bundle
 
   let mut entries = Vec::<(AssetId, BundleId)>::new();
 
-  for entry_index in asset_graph.neighbors(root_node) {
-    let bundle = c
-      .bundle_graph
-      .get_bundle(c.bundle_graph.root_node())
-      .unwrap();
-    let asset = c.asset_graph.get_with_nx(entry_index).unwrap();
-    entries.push((asset.id.clone(), bundle.id.clone()));
+  for entry_index in c.asset_graph.neighbors(ROOT_ASSET.clone()) {
+    let bundle = c.bundle_graph.try_get_bundle(ROOT_BUNDLE.clone())?;
+
+    let asset = c.asset_graph.try_get_asset(entry_index)?;
+    entries.push((asset.id.get()?.clone(), bundle.id.get()?.clone()));
   }
 
   while let Some((entry_id, parent_bundle_id)) = entries.pop() {
-    let parent_bundle_nx = c.bundle_graph.get_index(&parent_bundle_id).unwrap().clone();
-
-    let entry_asset_nx = c
-      .asset_graph
-      .get_nx(&entry_id)
-      .unwrap()
-      .clone();
-    let entry_asset = c.asset_graph.get_with_nx(entry_asset_nx).unwrap();
+    let parent_bundle_id = {
+      let parent_bundle = c.bundle_graph.try_get_bundle(parent_bundle_id)?;
+      parent_bundle.id.get()?.clone()
+    };
+    let entry_asset = c.asset_graph.get_asset(entry_id).unwrap();
 
-    let mut bundle = Bundle {
+    let bundle = c.bundle_graph.add_bundle(Bundle {
       id: Default::default(),
       kind: entry_asset.kind.clone(),
-      entry_asset: Some(entry_asset.id.clone()),
+      entry_asset: Some(entry_asset.id.get()?.clone()),
       assets: Default::default(),
-    };
+    });
 
-    let mut dependencies = Vec::<NodeIndex>::from(vec![entry_asset_nx]);
+    let mut dependencies = Vec::<NodeIndex>::from(vec![entry_asset.id.get()?.clone()]);
 
     while let Some(current_nx) = dependencies.pop() {
-      let current_asset = c.asset_graph.get_with_nx(current_nx).unwrap();
-      bundle.insert_asset(&current_asset);
+      let current_asset = c.asset_graph.get_asset(current_nx).unwrap();
+      bundle.insert_asset(&current_asset)?;
 
-      let mut dependencies_edges = c.asset_graph.as_graph().edges(current_nx);
+      let mut dependencies_edges = c.asset_graph.edges(current_nx);
       while let Some(edge) = dependencies_edges.next() {
         let dependency_nx = edge.target().id();
-        let dependency_asset = c.asset_graph.get_with_nx(dependency_nx).unwrap();
+        let dependency_asset = c.asset_graph.get_asset(dependency_nx).unwrap();
 
         // Type change creates new bundle
         if bundle.kind != dependency_asset.kind {
-          entries.push((dependency_asset.id.clone(), bundle.id.clone()));
+          entries.push((dependency_asset.id.get()?.clone(), bundle.id.get()?.clone()));
           continue;
         }
 
@@ -65,8 +63,9 @@ pub fn bundle(c: &mut Compilation) -> anyhow::Result<()> {
     }
 
     if bundle.assets.len() != 0 {
-      let nx = c.bundle_graph.add_bundle(bundle);
-      c.bundle_graph.add_edge(&parent_bundle_nx, &nx)?;
+      let current_bundle_id = bundle.id.get()?.clone();
+      c.bundle_graph
+        .add_edge(parent_bundle_id, current_bundle_id, ());
     }
   }
 

packages/mach/src/core/config/constants.rs

@@ -1,5 +1,4 @@
 pub mod bundling;
-pub mod config;
 pub mod emit;
 pub mod packaging;
 pub mod plugins;

packages/mach/src/core/config/mod.rs

@@ -1,7 +1,7 @@
 mod resolve_and_transform;
 mod run_resolvers;
 mod run_transformers;
-#[cfg(test)]
-mod testing;
+// #[cfg(test)]
+// mod testing;
 
 pub use self::resolve_and_transform::*;

packages/mach/src/core/mod.rs

@@ -2,27 +2,26 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 use super::run_resolvers::run_resolvers;
-use crate::core::config::ROOT_ASSET;
 use crate::core::resolve_and_transform::run_transformers::run_transformers;
 use crate::types::Asset;
+use crate::types::AssetGraphExt;
 use crate::types::AssetId;
 use crate::types::Compilation;
 use crate::types::Dependency;
-use crate::types::DependencyId;
 use crate::types::LinkingSymbol;
 
 pub fn resolve_and_transform(c: &mut Compilation) -> anyhow::Result<()> {
   let mut queue = vec![];
+  let root_asset = c.asset_graph.add_asset(Asset::default());
 
-  c.asset_graph.add_asset(ROOT_ASSET.clone());
-
+  // Add entries from config
   for entry in c.config.entries.iter() {
     queue.push(Dependency {
-      id: DependencyId::new(),
+      id: Default::default(),
       specifier: entry.to_str().unwrap().to_string(),
       source_asset_path: c.config.project_root.clone(),
       resolve_from: c.config.project_root.clone(),
-      source_asset_id: ROOT_ASSET.id.clone(),
+      source_asset_id: root_asset.id.get()?.clone(),
       specifier_type: Default::default(),
       priority: Default::default(),
       linking_symbol: LinkingSymbol::ImportDirect {
@@ -32,39 +31,49 @@ pub fn resolve_and_transform(c: &mut Compilation) -> anyhow::Result<()> {
     });
   }
 
+  // Avoid re-processing assets
   let mut completed_assets = HashMap::<PathBuf, AssetId>::new();
 
   while let Some(dependency) = queue.pop() {
     let resolve_result = run_resolvers(&c, &dependency)?;
 
     if let Some(asset_id) = completed_assets.get(&resolve_result.file_path) {
+      // Asset exists
       c.asset_graph
-        .add_dependency(&dependency.source_asset_id.clone(), &asset_id, dependency)?;
+        .add_dependency(dependency.source_asset_id, asset_id.clone(), dependency);
       continue;
     };
 
-    let new_asset_id = AssetId::new();
-    let mut new_asset = Asset {
-      id: new_asset_id.clone(),
-      file_path_absolute: resolve_result.file_path.clone(),
-      file_path: resolve_result.file_path_relative.clone(),
-      bundle_behavior: dependency.bundle_behavior.clone(),
-      name: Default::default(),
-      kind: Default::default(),
-      content: Default::default(),
-      linking_symbols: Default::default(),
+    // New Asset
+    let mut transformer_pipeline_result = run_transformers(&c, &resolve_result)?;
+
+    // Create new asset and add it to the
+    let new_asset_id = {
+      let asset = c.asset_graph.add_asset(Asset {
+        id: Default::default(),
+        name: transformer_pipeline_result.name,
+        file_path_absolute: resolve_result.file_path.clone(),
+        file_path: resolve_result.file_path_relative.clone(),
+        kind: transformer_pipeline_result.kind,
+        content: transformer_pipeline_result.content,
+        bundle_behavior: transformer_pipeline_result.bundle_behavior,
+        linking_symbols: transformer_pipeline_result.linking_symbols,
+      });
+      asset.id.get()?.clone()
     };
-    completed_assets.insert(resolve_result.file_path.clone(), new_asset_id.clone());
 
-    let mut asset_dependencies = run_transformers(&c, &mut new_asset, &resolve_result)?;
+    c.asset_graph
+      .add_dependency(dependency.source_asset_id.clone(), new_asset_id, dependency);
 
-    while let Some(dependency_options) = asset_dependencies.pop() {
+    completed_assets.insert(resolve_result.file_path.clone(), new_asset_id.clone());
+
+    while let Some(dependency_options) = transformer_pipeline_result.dependencies.pop() {
       let new_dependency = Dependency {
-        id: DependencyId::new(),
+        id: Default::default(),
         specifier: dependency_options.specifier.clone(),
         specifier_type: dependency_options.specifier_type,
         source_asset_path: resolve_result.file_path.clone(),
-        source_asset_id: new_asset.id.clone(),
+        source_asset_id: new_asset_id.clone(),
         resolve_from: resolve_result.file_path.clone(),
         priority: dependency_options.priority,
         linking_symbol: dependency_options.linking_symbol,
@@ -73,14 +82,6 @@ pub fn resolve_and_transform(c: &mut Compilation) -> anyhow::Result<()> {
 
       queue.push(new_dependency);
     }
-
-    c.asset_graph.add_asset(new_asset);
-
-    c.asset_graph.add_dependency(
-      &dependency.source_asset_id.clone(),
-      &new_asset_id.clone(),
-      dependency,
-    )?;
   }
 
   Ok(())

packages/mach/src/core/resolve_and_transform/mod.rs

@@ -1,18 +1,25 @@
 use std::fs;
 
 use super::run_resolvers::RunResolversResult;
-use crate::types::Asset;
 use crate::types::BundleBehavior;
 use crate::types::Compilation;
 use crate::types::DependencyOptions;
 use crate::types::LinkingSymbol;
 use crate::types::MutableAsset;
 
+pub struct TransformerPipelineResult {
+  pub name: String,
+  pub kind: String,
+  pub content: Vec<u8>,
+  pub linking_symbols: Vec<LinkingSymbol>,
+  pub bundle_behavior: BundleBehavior,
+  pub dependencies: Vec<DependencyOptions>,
+}
+
 pub fn run_transformers(
   c: &Compilation,
-  asset: &mut Asset,
   resolve_result: &RunResolversResult,
-) -> anyhow::Result<Vec<DependencyOptions>> {
+) -> anyhow::Result<TransformerPipelineResult> {
   let mut file_path = resolve_result.file_path.clone();
 
   let Ok(mut content) = fs::read(&resolve_result.file_path) else {
@@ -67,22 +74,22 @@ pub fn run_transformers(
     i += 1;
   }
 
-  // Update existing Asset with new data
-  asset.name = file_path
-    .file_stem()
-    .unwrap_or_default()
-    .to_str()
-    .unwrap_or_default()
-    .to_string();
-  asset.content = content;
-  asset.kind = file_path
-    .extension()
-    .unwrap_or_default()
-    .to_str()
-    .unwrap_or_default()
-    .to_string();
-  asset.linking_symbols = linking_symbols;
-  asset.bundle_behavior = bundle_behavior;
-
-  Ok(asset_dependencies)
+  Ok(TransformerPipelineResult {
+    name: file_path
+      .file_stem()
+      .unwrap_or_default()
+      .to_str()
+      .unwrap_or_default()
+      .to_string(),
+    kind: file_path
+      .extension()
+      .unwrap_or_default()
+      .to_str()
+      .unwrap_or_default()
+      .to_string(),
+    content,
+    linking_symbols,
+    bundle_behavior,
+    dependencies: asset_dependencies,
+  })
 }

packages/mach/src/core/resolve_and_transform/resolve_and_transform.rs

@@ -1,15 +1,19 @@
 use std::fmt::Debug;
 use std::path::PathBuf;
 
-use super::AssetId;
+use petgraph::graph::NodeIndex;
+
 use super::BundleBehavior;
+use super::Identifier;
 use super::LinkingSymbol;
 use crate::kit::hash::hash_sha_256;
 
+pub type AssetId = NodeIndex;
+
 #[derive(Clone, Default)]
 pub struct Asset {
-  /// Internal identifier
-  pub id: AssetId,
+  /// Identifier, assigned when the asset is added to the asset graph
+  pub id: Identifier<AssetId>,
   /// The file name without the extension
   pub name: String,
   /// Absolute filepath to the asset
@@ -28,7 +32,6 @@ pub struct Asset {
 
 impl Asset {
   pub fn content_hash(&self) -> String {
-    // Todo, cache this
     return hash_sha_256(&self.content);
   }
 }
@@ -39,7 +42,7 @@ impl Debug for Asset {
     f: &mut std::fmt::Formatter<'_>,
   ) -> std::fmt::Result {
     f.debug_struct("Asset")
-      .field("id", &self.id.0)
+      .field("id", &self.id)
       .field("file_path", &self.file_path_absolute)
       .field("file_path_rel", &self.file_path)
       .field("bundle_behavior", &self.bundle_behavior)