Struct foundry_compilers::ProjectPathsConfig

pub struct ProjectPathsConfig<L = MultiCompilerLanguage> {
    pub root: PathBuf,
    pub cache: PathBuf,
    pub artifacts: PathBuf,
    pub build_infos: PathBuf,
    pub sources: PathBuf,
    pub tests: PathBuf,
    pub scripts: PathBuf,
    pub libraries: Vec<PathBuf>,
    pub remappings: Vec<Remapping>,
    pub include_paths: BTreeSet<PathBuf>,
    pub allowed_paths: BTreeSet<PathBuf>,
    pub _l: PhantomData<L>,
}

Where to find all files or where to write them

Fields

root: PathBuf

Project root

cache: PathBuf

Path to the cache, if any

artifacts: PathBuf

Where to store build artifacts

build_infos: PathBuf

Where to store the build info files

sources: PathBuf

Where to find sources

tests: PathBuf

Where to find tests

scripts: PathBuf

Where to find scripts

libraries: Vec<PathBuf>

Where to look for libraries

remappings: Vec<Remapping>

The compiler remappings

include_paths: BTreeSet<PathBuf>

Paths to use for solc’s --include-path

allowed_paths: BTreeSet<PathBuf>

The paths which will be allowed for library inclusion

_l: PhantomData<L>

Implementations

impl ProjectPathsConfig

pub fn builder() -> ProjectPathsConfigBuilder

pub fn find_artifacts_dir(root: impl AsRef<Path>) -> PathBuf

Attempts to autodetect the artifacts directory based on the given root path

Dapptools layout takes precedence over hardhat style. This will return:

• <root>/out if it exists or <root>/artifacts does not exist,
• <root>/artifacts if it exists and <root>/out does not exist.

pub fn find_source_dir(root: impl AsRef<Path>) -> PathBuf

Attempts to autodetect the source directory based on the given root path

Dapptools layout takes precedence over hardhat style. This will return:

• <root>/src if it exists or <root>/contracts does not exist,
• <root>/contracts if it exists and <root>/src does not exist.

pub fn find_libs(root: impl AsRef<Path>) -> Vec<PathBuf>

Attempts to autodetect the lib directory based on the given root path

Dapptools layout takes precedence over hardhat style. This will return:

• <root>/lib if it exists or <root>/node_modules does not exist,
• <root>/node_modules if it exists and <root>/lib does not exist.

impl ProjectPathsConfig<SolcLanguage>

pub fn flatten(&self, target: &Path) -> Result<String>

Flattens the target solidity file into a single string suitable for verification.

This method uses a dependency graph to resolve imported files and substitute import directives with the contents of target files. It will strip the pragma version directives and SDPX license identifiers from all imported files.

NB: the SDPX license identifier will be removed from the imported file only if it is found at the beginning of the file.

impl<L> ProjectPathsConfig<L>

pub fn hardhat(root: impl AsRef<Path>) -> Result<Self>

Creates a new hardhat style config instance which points to the canonicalized root path

pub fn dapptools(root: impl AsRef<Path>) -> Result<Self>

Creates a new dapptools style config instance which points to the canonicalized root path

pub fn current_hardhat() -> Result<Self>

Creates a new config with the current directory as the root

pub fn current_dapptools() -> Result<Self>

Creates a new config with the current directory as the root

pub fn paths(&self) -> ProjectPaths

Returns a new ProjectPaths instance that contains all directories configured for this project

pub fn paths_relative(&self) -> ProjectPaths

Same as paths but strips the root form all paths.

See: ProjectPaths::strip_prefix_all

pub fn create_all(&self) -> Result<(), SolcIoError>

Creates all configured dirs and files

pub fn slash_paths(&mut self)

Converts all \\ separators in all paths to /

pub fn has_library_ancestor(&self, file: impl AsRef<Path>) -> bool

Returns true if the file belongs to a library, See Self::find_library_ancestor()

pub fn find_library_ancestor(&self, file: impl AsRef<Path>) -> Option<&Path>

Returns the library the file belongs to

Returns the first library that is an ancestor of the given file.

Note: this does not resolve remappings Self::resolve_import(), instead this merely checks if a library is a parent of file

Examples

use foundry_compilers::ProjectPathsConfig;
use std::path::Path;

let config = ProjectPathsConfig::builder().lib("lib").build()?;
assert_eq!(config.find_library_ancestor("lib/src/Greeter.sol"), Some(Path::new("lib")));
Ok::<_, Box<dyn std::error::Error>>(())

pub fn resolve_import_and_include_paths( &self, cwd: &Path, import: &Path, include_paths: &mut BTreeSet<PathBuf>, ) -> Result<PathBuf>

Attempts to resolve an import from the given working directory.

The cwd path is the parent dir of the file that includes the import

This will also populate the include_paths with any nested library root paths that should be provided to solc via --include-path because it uses absolute imports.

pub fn resolve_import(&self, cwd: &Path, import: &Path) -> Result<PathBuf>

Attempts to resolve an import from the given working directory.

The cwd path is the parent dir of the file that includes the import

pub fn resolve_library_import( &self, cwd: &Path, import: &Path, ) -> Option<PathBuf>

Attempts to find the path to the real solidity file that’s imported via the given import path by applying the configured remappings and checking the library dirs

Examples

Following @aave dependency in the lib folder node_modules

<root>/node_modules/@aave
├── aave-token
│   ├── contracts
│   │   ├── open-zeppelin
│   │   ├── token
├── governance-v2
    ├── contracts
        ├── interfaces

has this remapping: @aave/=@aave/ (name:path) so contracts can be imported as

import "@aave/governance-v2/contracts/governance/Executor.sol";

So that Executor.sol can be found by checking each lib folder (node_modules) with applied remappings. Applying remapping works by checking if the import path of an import statement starts with the name of a remapping and replacing it with the remapping’s path.

There are some caveats though, dapptools style remappings usually include the src folder ds-test/=lib/ds-test/src/ so that imports look like import "ds-test/test.sol"; (note the missing src in the import path).

For hardhat/npm style that’s not always the case, most notably for openzeppelin-contracts if installed via npm. The remapping is detected as '@openzeppelin/=node_modules/@openzeppelin/contracts/', which includes the source directory contracts, however it’s common to see import paths like:

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

instead of

import "@openzeppelin/token/ERC20/IERC20.sol";

There is no strict rule behind this, but because crate::remappings::Remapping::find_many returns '@openzeppelin/=node_modules/@openzeppelin/contracts/' we should handle the case if the remapping path ends with contracts and the import path starts with <remapping name>/contracts. Otherwise we can end up with a resolved path that has a duplicate contracts segment: @openzeppelin/contracts/contracts/token/ERC20/IERC20.sol we check for this edge case here so that both styles work out of the box.

pub fn with_language<Lang>(self) -> ProjectPathsConfig<Lang>

impl<L: Language> ProjectPathsConfig<L>

pub fn read_sources(&self) -> Result<Sources>

Returns all sources found under the project’s configured sources path

pub fn read_tests(&self) -> Result<Sources>

Returns all sources found under the project’s configured test path

pub fn read_scripts(&self) -> Result<Sources>

Returns all sources found under the project’s configured script path

pub fn has_input_files(&self) -> bool

Returns true if the there is at least one solidity file in this config.

See also, Self::input_files()

pub fn input_files_iter(&self) -> impl Iterator<Item = PathBuf> + '_

Returns an iterator that yields all solidity file paths for Self::sources, Self::tests and Self::scripts

pub fn input_files(&self) -> Vec<PathBuf>

Returns the combined set solidity file paths for Self::sources, Self::tests and Self::scripts

pub fn read_input_files(&self) -> Result<Sources>

Returns the combined set of Self::read_sources + Self::read_tests + Self::read_scripts

Trait Implementations

impl<L: Clone> Clone for ProjectPathsConfig<L>

fn clone(&self) -> ProjectPathsConfig<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug> Debug for ProjectPathsConfig<L>

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

Formats the value using the given formatter.

impl<'de, L> Deserialize<'de> for ProjectPathsConfig<L>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ProjectPathsConfig

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

Formats the value using the given formatter.

impl<'a, S: CompilerSettings> From<&'a ProjectPathsConfig> for CompilerCache<S>

fn from(config: &'a ProjectPathsConfig) -> Self

Converts to this type from the input type.

impl<L> Serialize for ProjectPathsConfig<L>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.