Struct GitVersion 

pub struct GitVersion {
    major: u64,
    minor: u64,
    patch: u64,
    commits_ahead: u64,
    hash: Option<String>,
    dirty: bool,
}

A parsed git describe version string.

Fields

major: u64

minor: u64

patch: u64

commits_ahead: u64

hash: Option<String>

dirty: bool

Implementations

impl GitVersion

pub fn parse(version: &str) -> Result<Self, VersionError>

Parses a version string in git describe format.

Supported formats:

• v0.9.46 - Tagged release
• v0.9.46-5-gabc123 - Development build with commits ahead
• v0.9.46-5-gabc123-dirty - Dirty working tree

Errors

Returns VersionError::InvalidFormat if the version string cannot be parsed.

Examples

use cadmus_core::version::GitVersion;

let v = GitVersion::parse("v0.9.46").unwrap();
assert_eq!(v.major(), 0);
assert_eq!(v.minor(), 9);
assert_eq!(v.patch(), 46);

pub fn major(&self) -> u64

Returns the major version number.

pub fn minor(&self) -> u64

Returns the minor version number.

pub fn patch(&self) -> u64

Returns the patch version number.

pub fn commits_ahead(&self) -> u64

Returns the number of commits ahead of the tag.

pub fn hash(&self) -> Option<&str>

Returns the git hash if present.

pub fn is_dirty(&self) -> bool

Returns true if the working tree was dirty.

pub fn is_tagged_release(&self) -> bool

Returns true if this is a tagged release (no commits ahead).

pub fn compare( &self, other: &GitVersion, ) -> Result<VersionComparison, VersionError>

Compares this version with another.

If both versions contain different git hashes, this method will use the GitHub API to check ancestry relationships.

For local-only comparison without network access, use the Ord implementation which compares semantic version numbers and commit count.

Examples

use cadmus_core::version::{GitVersion, VersionComparison};

// Local is newer than remote (higher semver)
let local: GitVersion = "v0.9.46".parse().unwrap();
let remote: GitVersion = "v0.9.45".parse().unwrap();
let result = local.compare(&remote).unwrap();
assert_eq!(result, VersionComparison::Newer);

// Local is older than remote (lower semver)
let local: GitVersion = "v0.9.44".parse().unwrap();
let remote: GitVersion = "v0.9.45".parse().unwrap();
let result = local.compare(&remote).unwrap();
assert_eq!(result, VersionComparison::Older);

// Local equals remote (same version)
let local: GitVersion = "v0.9.46".parse().unwrap();
let remote: GitVersion = "v0.9.46".parse().unwrap();
let result = local.compare(&remote).unwrap();
assert_eq!(result, VersionComparison::Equal);

Trait Implementations

impl Clone for GitVersion

fn clone(&self) -> GitVersion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitVersion

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

Formats the value using the given formatter.

impl<'r> Decode<'r, Sqlite> for GitVersion

fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError>

Decode a new value of this type using a raw value from the database.

impl<'de> Deserialize<'de> for GitVersion

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GitVersion

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

Formats the value using the given formatter.

impl Encode<'_, Sqlite> for GitVersion

fn encode_by_ref( &self, buf: &mut SqliteArgumentsBuffer, ) -> Result<IsNull, BoxDynError>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl FromStr for GitVersion

type Err = VersionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Ord for GitVersion

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for GitVersion

fn eq(&self, other: &GitVersion) -> 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 PartialOrd for GitVersion

Ordering is based on semver components (major, minor, patch) followed by the number of commits ahead of the tag. This is a purely local comparison that does not require network access.

When two versions share the same semver and commit count but have different git hashes (divergent branches), this ordering treats them as equal. Use GitVersion::compare instead if you need GitHub-based ancestry checks to distinguish divergent development builds.

Dirty-flag ordering

A dirty build (v0.10.0-dirty) is treated as strictly newer than its clean counterpart (v0.10.0). This means that switching from a dirty dev build back to the clean release of the same version will be detected as a downgrade by the version gate, triggering a backup restore. This is intentional for production use but can be surprising during local development.

Examples

use cadmus_core::version::GitVersion;

let v1: GitVersion = "v0.9.46".parse().unwrap();
let v2: GitVersion = "v0.10.0".parse().unwrap();
let v3: GitVersion = "v0.10.0-5-gabc123".parse().unwrap();
let v3_dirty: GitVersion = "v0.10.0-5-gabc123-dirty".parse().unwrap();

assert!(v1 < v2);
assert!(v2 < v3);
assert!(v1 < v3);
assert!(v3 < v3_dirty);
assert_eq!(v2, v2);

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for GitVersion

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Type<Sqlite> for GitVersion

fn type_info() -> SqliteTypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &SqliteTypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.

impl Eq for GitVersion

impl StructuralPartialEq for GitVersion