willbe/entity/

dependency.rs

mod private
{


  use crate::*;

  // use crates_tools::CrateArchive;
  // use workspace::Workspace;
  use error::
  {
    // untyped::Result,
    // typed::Error,
    untyped::format_err,
  };

  /// A dependency of the main crate
  #[ derive( Debug, Clone, Copy ) ]
  #[ repr( transparent ) ]
  pub struct DependencyRef< 'a >
  {
    inner : &'a cargo_metadata::Dependency,
  }
  // fix clippy
  impl DependencyRef< '_ >
  {

    /// The file system path for a local path dependency.
    /// Only produced on cargo 1.51+
    #[ must_use ]
    pub fn crate_dir( &self ) -> Option< CrateDir >
    {
      match &self.inner.path
      {
        Some( path ) => path.as_path().try_into().ok(),
        None => None,
      }
    }

    /// Name as given in the Cargo.toml.
    #[ must_use ]
    pub fn name( &self ) -> String
    {
      self.inner.name.clone()
    }

    /// The kind of dependency this is.
    #[ must_use ]
    pub fn kind( &self ) -> DependencyKind
    {
      match self.inner.kind
      {
        cargo_metadata::DependencyKind::Normal => DependencyKind::Normal,
        cargo_metadata::DependencyKind::Development => DependencyKind::Development,
        cargo_metadata::DependencyKind::Build => DependencyKind::Build,
        cargo_metadata::DependencyKind::Unknown => DependencyKind::Unknown,
      }
    }

    /// Required version
    #[ must_use ]
    pub fn req( &self ) -> semver::VersionReq
    {
      self.inner.req.clone()
    }
  }

  impl< 'a > From< &'a cargo_metadata::Dependency > for DependencyRef< 'a >
  {
    #[ inline( always ) ]
    fn from( inner : &'a cargo_metadata::Dependency ) -> Self
    {
      Self { inner }
    }
  }

  /// Dependencies can come in three kinds
  #[ derive( Eq, PartialEq, Debug, Clone, Copy ) ]
  pub enum DependencyKind
  {
    /// The 'normal' kind
    Normal,
    /// Those used in tests only
    Development,
    /// Those used in build scripts only
    Build,
    /// The 'unknown' kind
    Unknown,
  }

  //

  /// Identifier of any crate (local and remote).
  #[ derive( Debug, Clone, Hash, Eq, PartialEq ) ]
  pub struct CrateId
  {
    /// The name of the crate.
    pub name : String, // qqq : that should be Arc< str >
    /// The absolute path to the crate, if available.
    pub crate_dir : Option< CrateDir >, // qqq : that should be Option< Arc< CrateDir > >
    // pub path : Option< AbsolutePath >,
  }

  impl< 'a > From< &WorkspacePackageRef< 'a > > for CrateId
  {
    fn from( value : &WorkspacePackageRef< 'a > ) -> Self
    {
      Self
      {
        name : value.name().into(),
        crate_dir : Some( value.crate_dir().unwrap() )
        // path : Some( AbsolutePath::try_from( value.manifest_file().parent().unwrap() ).unwrap() ),
      }
    }
  }

  impl From< &DependencyRef< '_ > > for CrateId
  {
    fn from( value : &DependencyRef< '_ > ) -> Self
    {
      Self
      {
        name : value.name(),
        crate_dir : value.crate_dir(),
        // path : value.path().clone().map( | path | AbsolutePath::try_from( path ).unwrap() ),
      }
    }
  }

  /// Sorting variants for dependencies.
  #[ derive( Debug, Copy, Clone ) ]
  pub enum DependenciesSort
  {
    /// List will be topologically sorted.
    Topological,
    /// List will be unsorted.
    Unordered,
  }

  #[ derive( Debug, Clone ) ]
  /// Args for `local_dependencies` function.
  pub struct DependenciesOptions
  {
    /// With dependencies of dependencies.
    pub recursive : bool,
    /// With sorting.
    pub sort : DependenciesSort,
    /// Include dev dependencies.
    pub with_dev : bool,
    /// Include remote dependencies.
    pub with_remote : bool,
  }

  impl Default for DependenciesOptions
  {
    fn default() -> Self
    {
      Self
      {
        recursive : true,
        sort : DependenciesSort::Unordered,
        with_dev : false,
        with_remote : false,
      }
    }
  }

  // qqq : for Bohdan : poor description
  /// Recursive implementation of the `list` function
  /// # Errors
  /// qqq: doc
  ///
  /// # Panics
  /// qqq: doc
  #[ allow( clippy::needless_pass_by_value, clippy::implicit_hasher ) ]
  pub fn list_rec
  (
    workspace : &Workspace, // aaa : for Bohdan : no mut // aaa : no mut
    package : &Package< '_ >,
    graph : &mut collection::HashMap< CrateId, collection::HashSet< CrateId > >,
    opts : DependenciesOptions
  )
  // qqq : use typed error
  -> error::untyped::Result< CrateId >
  {
    let DependenciesOptions
    {
      recursive,
      sort : _,
      with_dev,
      with_remote,
    } = opts;
    if recursive && with_remote { unimplemented!( "`recursive` + `with_remote` options") }

    let manifest_file = &package.manifest_file();

    let package = workspace
    .package_find_by_manifest( manifest_file )
    .ok_or( format_err!( "Package not found in the workspace with path : `{}`", manifest_file.as_ref().display() ) )?;

    let deps : collection::HashSet< _ > = package
    .dependencies()
    // .iter()
    .filter( | dep | ( with_remote || dep.crate_dir().is_some() ) && ( with_dev || dep.kind() != DependencyKind::Development ) )
    .map( | dep | CrateId::from( &dep ) )
    .collect();

    let package = CrateId::from( &package );
    graph.insert( package.clone(), deps.clone() );

    if recursive
    {
      for dep in deps
      {
        if graph.get( &dep ).is_none()
        {
          // unwrap because `recursive` + `with_remote` not yet implemented
          list_rec
          (
            workspace,
            &dep.crate_dir.unwrap().try_into()?,
            // &dep.path.as_ref().unwrap().join( "Cargo.toml" ).try_into().unwrap(),
            graph,
            opts.clone(),
          )?;
        }
      }
    }

    Ok( package )
  }

  /// Returns local dependencies of a specified package by its package path from a workspace.
  ///
  /// # Arguments
  ///
  /// - `workspace` - holds cached information about the workspace, such as the packages it contains and their dependencies. By passing it as a mutable reference, function can update the cache as needed.
  /// - `package` - The package package file contains package about the package such as its name, version, and dependencies.
  /// - `opts` - used to specify options or configurations for fetching local dependencies.
  ///
  /// # Returns
  ///
  /// If the operation is successful, returns a vector of `PathBuf` objects, where each `PathBuf` represents the path to a local dependency of the specified package.
  /// # Errors
  /// qqq: doc
  // qqq : typed error?
  #[ allow( clippy::needless_pass_by_value ) ]
  pub fn list
  (
    workspace : &mut Workspace,
    package : &Package< '_ >,
    opts : DependenciesOptions
  )
  // qqq : use typed error
  -> error::untyped::Result< Vec< CrateId > >
  {
    let mut graph = collection::HashMap::new();
    let root = list_rec( workspace, package, &mut graph, opts.clone() )?;

    let output = match opts.sort
    {
      DependenciesSort::Unordered =>
      {
        graph
        .into_iter()
        .flat_map( | ( id, dependency ) |
        {
          dependency
          .into_iter()
          .chain( Some( id ) )
        })
        .unique()
        .filter( | x | x != &root )
        .collect()
      }
      DependenciesSort::Topological =>
      {
        // aaa : too long line
        // aaa : splited
        graph::toposort( graph::construct( &graph ) )
        .map_err( | err | format_err!( "{}", err ) )?
        .into_iter()
        .filter( | x | x != &root )
        .collect()
      },
    };

    Ok( output )
  }

}

//

crate::mod_interface!
{

  exposed use DependencyRef;
  exposed use DependencyKind;

  own use CrateId;
  own use DependenciesSort;
  own use DependenciesOptions;
  own use list_rec;
  own use list;

}