Struct ethers_solc::ProjectPathsConfig

pub struct ProjectPathsConfig {
    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>,
}

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

Implementations

impl ProjectPathsConfig

pub fn builder() -> ProjectPathsConfigBuilder

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 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

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<&PathBuf>

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

Example

 use std::path::Path;
use ethers_solc::ProjectPathsConfig;
let config = ProjectPathsConfig::builder().lib("lib").build().unwrap();
assert_eq!(config.find_library_ancestor("lib/src/Greeter.sol").unwrap(), Path::new("lib"));

pub fn resolve_import_and_include_paths( &self, cwd: &Path, import: &Path, include_paths: &mut IncludePaths ) -> 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

Example

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 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.

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

Flattens all file imports into a single string

Trait Implementations

impl Clone for ProjectPathsConfig

fn clone(&self) -> ProjectPathsConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectPathsConfig

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

Formats the value using the given formatter.

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

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> From<&'a ProjectPathsConfig> for SolFilesCache

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

Converts to this type from the input type.

impl Serialize for ProjectPathsConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.