Enum ProjectType

#[non_exhaustive]
pub enum ProjectType {
    Bazaar,
    Darcs,
    Fossil,
    Git,
    Mercurial,
    Pijul,
    Subversion,
    Bundler,
    C,
    Cargo,
    Docker,
    Elixir,
    Go,
    Gradle,
    JavaScript,
    Leiningen,
    Maven,
    Perl,
    PHP,
    Pip,
    V,
    Zig,
}

Project types recognised by watchexec.

There are two kinds of projects: VCS and software suite. The latter is more characterised by what package manager or build system is in use. The enum is marked non-exhaustive as more types can get added in the future.

Do not rely on the ordering or value (e.g. with transmute) of the variants.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bazaar

VCS: Bazaar.

Detects when a .bzr folder or a .bzrignore file is present. Bazaar does not support (at writing, anyway) ignore files deeper than the repository origin, so this should not false-positive.

Darcs

VCS: Darcs.

Detects when a _darcs folder is present.

Fossil

VCS: Fossil.

Detects when a .fossil-settings folder is present.

Git

VCS: Git.

Detects when a .git file or folder is present, or any of the files .gitattributes or .gitmodules. Does not check or return from the presence of .gitignore files, as Git supports nested ignores, and that would result in false-positives.

Mercurial

VCS: Mercurial.

Detects when a .hg folder is present, or any of the files .hgignore or .hgtags. Mercurial does not support (at writing, anyway) ignore files deeper than the repository origin, so this should not false-positive.

Pijul

VCS: Pijul.

This is not detected at the moment.

Subversion

VCS: Subversion (aka SVN).

Detects when a .svn folder is present.

Bundler

Soft: Ruby’s Bundler.

Detects when a Gemfile file is present.

C

Soft: the C programming language.

Detects when a .ctags file is present.

Cargo

Soft: Rust’s Cargo.

Detects Cargo workspaces and Cargo crates through the presence of a Cargo.toml file.

Docker

Soft: the Docker container runtime.

Detects when a Dockerfile file is present.

Elixir

Soft: the Elixir language.

Detects when a mix.exs file is present.

Go

Soft: the Go language.

Detects when a go.mod or go.sum file is present.

Gradle

Soft: Java’s Gradle.

Detects when a build.gradle file is present.

JavaScript

Soft: EcmaScript (aka JavaScript).

Detects when a package.json or cgmanifest.json file is present.

This is a catch-all for all package.json-based projects, and does not differentiate between NPM, Yarn, PNPM, Node, browser, Deno, Bun, etc.

Leiningen

Soft: Clojure’s Leiningen.

Detects when a project.clj file is present.

Maven

Soft: Java’s Maven.

Detects when a pom.xml file is present.

Perl

Soft: the Perl language.

Detects when a .perltidyrc or Makefile.PL file is present.

PHP

Soft: the PHP language.

Detects when a composer.json file is present.

Pip

Soft: Python’s Pip.

Detects when a requirements.txt or Pipfile file is present.

V

Soft: the V language.

Detects when a v.mod file is present.

Zig

Soft: the Zig language.

Detects when a build.zig file is present.

Implementations

impl ProjectType

pub const fn is_vcs(self) -> bool

Returns true if the project type is a VCS.

pub const fn is_soft(self) -> bool

Returns true if the project type is a software suite.

Trait Implementations

impl Clone for ProjectType

fn clone(&self) -> ProjectType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectType

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

Formats the value using the given formatter.

impl Hash for ProjectType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ProjectType

fn eq(&self, other: &ProjectType) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for ProjectType

impl Eq for ProjectType

impl StructuralPartialEq for ProjectType