Struct CrateHandle

pub struct CrateHandle { /* private fields */ }

Implementations

impl CrateHandle

pub fn crate_path(&self) -> &PathBuf

pub fn cargo_toml_handle(&self) -> &Arc<Mutex<CargoToml>>

impl CrateHandle

pub fn new_sync<P>(crate_path: &P) -> Result<CrateHandle, CrateError>

where P: for<'async_trait> HasCargoTomlPathBuf + for<'async_trait> HasCargoTomlPathBufSync + for<'async_trait> AsRef<Path> + for<'async_trait> Send + for<'async_trait> Sync + 'async_trait, CrateError: From<<P as HasCargoTomlPathBuf>::Error> + From<<P as HasCargoTomlPathBufSync>::Error>,

Initializes a crate handle from a given crate_path

impl CrateHandle

pub fn cargo_toml_direct(&self) -> Arc<Mutex<CargoToml>>

sometimes we need to do this, but do try not to

Trait Implementations

impl ApplyAiReadmeOutput for CrateHandle

type Error = CrateError

fn update_readme_md<'life0, 'life1, 'async_trait>( &'life0 self, new_contents: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as ApplyAiReadmeOutput>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

Updates the local README.md with the given text.

fn update_cargo_toml<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, new_description: &'life1 str, new_keywords: &'life2 [String], new_categories: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as ApplyAiReadmeOutput>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, CrateHandle: 'async_trait,

Updates the Cargo.toml fields, e.g. description, keywords, categories, etc.

impl AsRef<Path> for CrateHandle

fn as_ref(&self) -> &Path

Allows CrateHandle to be used as a path by referencing crate_path

impl<P> AsyncTryFrom<P> for CrateHandle

where P: for<'async_trait> HasCargoTomlPathBuf + for<'async_trait> HasCargoTomlPathBufSync + for<'async_trait> AsRef<Path> + for<'async_trait> Send + for<'async_trait> Sync + 'async_trait, CrateError: From<<P as HasCargoTomlPathBuf>::Error> + From<<P as HasCargoTomlPathBufSync>::Error>,

fn new<'life0, 'async_trait>( crate_path: &'life0 P, ) -> Pin<Box<dyn Future<Output = Result<CrateHandle, <CrateHandle as AsyncTryFrom<P>>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Initializes a crate handle from a given crate_path

type Error = CrateError

impl CheckIfReadmeExists for CrateHandle

fn check_readme_exists(&self) -> Result<(), CrateError>

Checks if README.md exists

impl CheckIfSrcDirectoryContainsValidFiles for CrateHandle

fn check_src_directory_contains_valid_files(&self) -> Result<(), CrateError>

Checks if the src/ directory contains a lib.rs or main.rs

impl CleanupCrate for CrateHandle

fn cleanup_crate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), WorkspaceError>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl Clone for CrateHandle

fn clone(&self) -> CrateHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CrateHandle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CrateHandle

fn deserialize<D>( deserializer: D, ) -> Result<CrateHandle, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnsureAllSourceFilesAreRegistered for CrateHandle

type Error = SourceFileRegistrationError

fn ensure_all_source_files_are_registered<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as EnsureAllSourceFilesAreRegistered>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl EnsureGitClean for CrateHandle

type Error = GitError

fn ensure_git_clean<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as EnsureGitClean>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl GatherBinTargetNames for CrateHandle

type Error = CrateError

fn gather_bin_target_names<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, <CrateHandle as GatherBinTargetNames>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl GetCargoMetadata for CrateHandle

3. For single crates (CrateHandle), we do a similar approach, but we run cargo metadata from that crate’s directory (the parent of Cargo.toml), or pass --manifest-path if you prefer.

type Error = CrateError

fn get_cargo_metadata<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Metadata, <CrateHandle as GetCargoMetadata>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl GetFilesInDirectory for CrateHandle

fn get_files_in_dir<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir_name: &'life1 str, extension: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, CrateHandle: 'async_trait,

Asynchronously returns a list of files with the given extension in the specified directory

impl GetFilesInDirectoryWithExclusions for CrateHandle

fn get_files_in_dir_with_exclusions<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, dir_name: &'life1 str, extension: &'life2 str, exclude_files: &'life3 [&'life4 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, CrateHandle: 'async_trait,

Asynchronously returns a list of files with the given extension in the specified directory, excluding specified file names.

impl GetInternalDependencies for CrateHandle

fn internal_dependencies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Gathers all [dependencies] entries that have path = "../some-other-crate". Returns their names as used in the Cargo.toml [dependencies] table key.

impl GetReadmePath for CrateHandle

fn readme_path<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<PathBuf>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Asynchronously returns the path to the README.md if it exists

impl GetSourceFilesWithExclusions for CrateHandle

fn source_files_excluding<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, exclude_files: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, CrateHandle: 'async_trait,

Asynchronously returns a list of source files (.rs) in the src/ directory, excluding specified files

impl GetTestFiles for CrateHandle

fn test_files<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Asynchronously returns a list of test files (.rs) in the tests/ directory

impl HasCargoToml for CrateHandle

fn cargo_toml( &self, ) -> Arc<Mutex<dyn CargoTomlInterface<Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError, Error = CargoTomlError>>>

impl HasTestsDirectory for CrateHandle

fn has_tests_directory(&self) -> bool

impl IsPrivate for CrateHandle

fn is_private<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, <CrateHandle as IsPrivate>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Checks if the crate is private by reading the ‘publish’ field or ‘publish = false’ or ‘package.publish = false’ in Cargo.toml. Returns Ok(true) if private, Ok(false) if not private.

type Error = CrateError

impl NameAllFiles for CrateHandle

fn name_all_files<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as NameAllFiles>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Removes old marker lines in .rs files of this crate, then inserts one new marker line.

Old markers removed:

1. Lines with 6+ dashes plus [ File: ... ] e.g. // -------------- [ File: path.rs ]

2. Lines that exactly match // old marker (case-sensitive).

After removal, it prepends: // ---------------- [ File: relative/path.rs ]

The relative path is path.strip_prefix(self.as_ref()) where possible.

type Error = CrateError

impl Named for CrateHandle

fn name(&self) -> Cow<'_, str>

Returns the name associated with self. We use Cow to allow both owned and borrowed strings.

impl PinAllWildcardDependencies for CrateHandle

type Error = CrateError

fn pin_all_wildcard_dependencies<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as PinAllWildcardDependencies>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl PinWildcardDependencies for CrateHandle

type Error = CrateError

fn pin_wildcard_dependencies<'life0, 'life1, 'async_trait>( &'life0 mut self, lock_versions: &'life1 BTreeMap<String, BTreeSet<Version>>, ) -> Pin<Box<dyn Future<Output = Result<(), CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

impl ReadFileString for CrateHandle

fn read_file_string<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<String, CrateError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

impl ReadyForCargoPublish for CrateHandle

fn ready_for_cargo_publish<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as ReadyForCargoPublish>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Checks if the crate is ready for Cargo publishing

type Error = CrateError

impl RebuildOrTest for CrateHandle

fn rebuild_or_test<'life0, 'life1, 'async_trait>( &'life0 self, runner: &'life1 dyn CommandRunner, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as RebuildOrTest>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

Runs cargo build and then cargo test in this crate’s directory. Logs success or error details; returns Ok(()) if both succeed.

type Error = CrateError

impl RunLinting for CrateHandle

Now do not implement RunLinting in a generic way for all C: CrateHandleInterface. Instead, implement it for your actual concrete crate type—for example, CrateHandle.

That ensures there is no overlap with Workspace<P,H> in the compiler’s eyes.

type Report = LintReport

type Error = LintingError

fn run_linting<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<CrateHandle as RunLinting>::Report, <CrateHandle as RunLinting>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl RunTestsWithCoverage for CrateHandle

type Report = TestCoverageReport

type Error = WorkspaceError

fn run_tests_with_coverage<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<CrateHandle as RunTestsWithCoverage>::Report, <CrateHandle as RunTestsWithCoverage>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl Serialize for CrateHandle

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SortAndFormatImports for CrateHandle

type Error = CrateError

fn sort_and_format_imports<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as SortAndFormatImports>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Sorts & formats the imports for either a single crate or an entire workspace.

impl TopologicalSortInternalDeps for CrateHandle

fn topological_sort_internal_deps<'life0, 'life1, 'async_trait>( &'life0 self, config: &'life1 TopologicalSortConfig, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, WorkspaceError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

Returns a flat topological ordering of all internal dependencies leading up to (and including) this crate.

fn layered_topological_order_upto_self<'life0, 'life1, 'async_trait>( &'life0 self, config: &'life1 TopologicalSortConfig, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<String>>, WorkspaceError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

Returns a layered topological ordering of all internal dependencies up to this crate.

impl TryPublish for CrateHandle

type Error = CrateError

fn try_publish<'life0, 'async_trait>( &'life0 self, dry_run: bool, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as TryPublish>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl UpdateReadmeFiles for CrateHandle

type Error = AiReadmeWriterError

fn update_readme_files<'life0, 'async_trait>( crate_handle: Arc<Mutex<CrateHandle>>, plant: bool, force: bool, config: &'life0 ReadmeWriterConfig, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as UpdateReadmeFiles>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

Orchestrates the steps to generate queries, call the AI, and update README(s). The force parameter means: if false, skip crates/workspaces that already have a README. The config carries user preferences (docs/fn-bodies/test-items/etc.) for readme generation.

impl ValidateIntegrity for CrateHandle

type Error = CrateError

fn validate_integrity<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as ValidateIntegrity>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl VerifyCrateIsNotPrivate for CrateHandle

type Error = CrateError

fn verify_crate_is_not_private<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as VerifyCrateIsNotPrivate>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl VerifyCrateVersionIsNotYetPublishedOnCratesIo for CrateHandle

type Error = CrateError

fn verify_crate_version_is_not_yet_published_on_crates_io<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as VerifyCrateVersionIsNotYetPublishedOnCratesIo>::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CrateHandle: 'async_trait,

impl Versioned for CrateHandle

type Error = CrateError

fn version(&self) -> Result<Version, <CrateHandle as Versioned>::Error>

impl WatchAndReload for CrateHandle

fn watch_and_reload<'a, 'life0, 'async_trait>( &'life0 self, tx: Option<Sender<Result<(), <CrateHandle as WatchAndReload>::Error>>>, runner: Arc<dyn CommandRunner + Send + Sync + 'a>, cancel_token: CancellationToken, ) -> Pin<Box<dyn Future<Output = Result<(), <CrateHandle as WatchAndReload>::Error>> + Send + 'async_trait>>

where 'a: 'async_trait, 'life0: 'async_trait, CrateHandle: 'async_trait,

Sets up file-watching for this one crate, then enters a watch loop until cancel_token is triggered. Triggers rebuild/test whenever a relevant change is detected.

fn is_relevant_change<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CrateHandle: 'async_trait,

A change is considered “relevant” if it’s Cargo.toml or in src/

type Error = CrateError

impl<P> CrateHandleInterface<P> for CrateHandle

where P: for<'async_trait> HasCargoTomlPathBuf + for<'async_trait> HasCargoTomlPathBufSync + for<'async_trait> AsRef<Path> + for<'async_trait> Send + for<'async_trait> Sync + 'async_trait, CrateError: From<<P as HasCargoTomlPathBuf>::Error> + From<<P as HasCargoTomlPathBufSync>::Error>,