Struct foundry_compilers::cache::CompilerCache

pub struct CompilerCache<S = Settings> {
    pub format: String,
    pub paths: ProjectPaths,
    pub files: BTreeMap<PathBuf, CacheEntry<S>>,
}

A multi version cache file

Fields

format: String

paths: ProjectPaths

contains all directories used for the project

files: BTreeMap<PathBuf, CacheEntry<S>>

Implementations

impl<S> CompilerCache<S>

pub fn new(format: String, paths: ProjectPaths) -> Self

impl<S: CompilerSettings> CompilerCache<S>

pub fn is_empty(&self) -> bool

pub fn contains(&self, file: &Path, version: &Version) -> bool

Returns true if the cache contains any artifacts for the given file and version.

pub fn remove(&mut self, file: &Path) -> Option<CacheEntry<S>>

Removes entry for the given file

pub fn len(&self) -> usize

How many entries the cache contains where each entry represents a sourc file

pub fn artifacts_len(&self) -> usize

How many Artifacts this cache references, where a source file can have multiple artifacts

pub fn entries(&self) -> impl Iterator<Item = &CacheEntry<S>>

Returns an iterator over all CacheEntry this cache contains

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

Returns the corresponding CacheEntry for the file if it exists

pub fn entry_mut( &mut self, file: impl AsRef<Path> ) -> Option<&mut CacheEntry<S>>

Returns the corresponding CacheEntry for the file if it exists

pub fn read(path: impl AsRef<Path>) -> Result<Self>

Reads the cache json file from the given path

See also Self::read_joined()

Errors

If the cache file does not exist

Examples

use foundry_compilers::{cache::SolFilesCache, Project};

let project = Project::builder().build()?;
let mut cache = SolFilesCache::read(project.cache_path())?;
cache.join_artifacts_files(project.artifacts_path());

pub fn read_joined<C>(paths: &ProjectPathsConfig<C>) -> Result<Self>

Reads the cache json file from the given path and returns the cache with paths adjoined to the ProjectPathsConfig.

This expects the artifact files to be relative to the artifacts dir of the paths and the CachEntry paths to be relative to the root dir of the paths

Examples

use foundry_compilers::{cache::SolFilesCache, Project};

let project = Project::builder().build()?;
let cache = SolFilesCache::read_joined(&project.paths)?;

pub fn write(&self, path: impl AsRef<Path>) -> Result<()>

Write the cache as json file to the given path

pub fn join_entries(&mut self, root: impl AsRef<Path>) -> &mut Self

Sets the CacheEntry’s file paths to root adjoined to self.file.

pub fn strip_entries_prefix(&mut self, base: impl AsRef<Path>) -> &mut Self

Removes base from all CacheEntry paths

pub fn join_artifacts_files(&mut self, base: impl AsRef<Path>) -> &mut Self

Sets the artifact files location to base adjoined to the CachEntries artifacts.

pub fn strip_artifact_files_prefixes( &mut self, base: impl AsRef<Path> ) -> &mut Self

Removes base from all artifact file paths

pub fn remove_missing_files(&mut self)

Removes all CacheEntry which source files don’t exist on disk

NOTE: this assumes the files are absolute

pub fn all_artifacts_exist(&self) -> bool

Checks if all artifact files exist

pub fn with_stripped_file_prefixes(self, base: impl AsRef<Path>) -> Self

Strips the given prefix from all file paths that identify a CacheEntry to make them relative to the given base argument

In other words this sets the keys (the file path of a solidity file) relative to the base argument, so that the key /Users/me/project/src/Greeter.sol will be changed to src/Greeter.sol if base is /Users/me/project

Examples

use foundry_compilers::{artifacts::contract::CompactContract, cache::SolFilesCache, Project};

let project = Project::builder().build()?;
let cache =
    SolFilesCache::read(project.cache_path())?.with_stripped_file_prefixes(project.root());
let artifact: CompactContract = cache.read_artifact("src/Greeter.sol", "Greeter")?;

Note: this only affects the source files, see Self::strip_artifact_files_prefixes()

pub fn find_artifact_path( &self, contract_file: impl AsRef<Path>, contract_name: impl AsRef<str> ) -> Option<&Path>

Returns the path to the artifact of the given (file, contract) pair

Examples

use foundry_compilers::{cache::SolFilesCache, Project};

let project = Project::builder().build()?;
let cache = SolFilesCache::read_joined(&project.paths)?;
cache.find_artifact_path("/Users/git/myproject/src/Greeter.sol", "Greeter");

pub fn read_artifact<Artifact: DeserializeOwned>( &self, contract_file: impl AsRef<Path>, contract_name: impl AsRef<str> ) -> Result<Artifact>

Finds the path to the artifact of the given (file, contract) pair (see Self::find_artifact_path()) and deserializes the artifact file as JSON.

Examples

use foundry_compilers::{artifacts::contract::CompactContract, cache::SolFilesCache, Project};

let project = Project::builder().build()?;
let cache = SolFilesCache::read_joined(&project.paths)?;
let artifact: CompactContract =
    cache.read_artifact("/Users/git/myproject/src/Greeter.sol", "Greeter")?;

NOTE: unless the cache’s files keys were modified contract_file is expected to be absolute.

pub fn read_artifacts<Artifact: DeserializeOwned + Send + Sync>( &self ) -> Result<Artifacts<Artifact>>

Reads all cached artifacts from disk using the given ArtifactOutput handler

Examples

use foundry_compilers::{
    artifacts::contract::CompactContractBytecode, cache::SolFilesCache, Project,
};

let project = Project::builder().build()?;
let cache = SolFilesCache::read_joined(&project.paths)?;
let artifacts = cache.read_artifacts::<CompactContractBytecode>()?;

impl<S: CompilerSettings> CompilerCache<S>

pub async fn async_read(path: impl AsRef<Path>) -> Result<Self>

Available on crate feature async only.

pub async fn async_write(&self, path: impl AsRef<Path>) -> Result<()>

Available on crate feature async only.

Trait Implementations

impl<S: Clone> Clone for CompilerCache<S>

fn clone(&self) -> CompilerCache<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for CompilerCache<S>

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

Formats the value using the given formatter.

impl<S> Default for CompilerCache<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for CompilerCache<S>

where S: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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<S: PartialEq> PartialEq for CompilerCache<S>

fn eq(&self, other: &CompilerCache<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> Serialize for CompilerCache<S>

where S: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq> Eq for CompilerCache<S>

impl<S> StructuralPartialEq for CompilerCache<S>