Struct nextver::Sem

pub struct Sem;

Scheme for formats that have only semantic specifiers, such as <MAJOR>.<MINOR>.<PATCH>.

Sem behaves almost exactly like the SemVer scheme, but with a few differences.

See the available specifiers for this scheme in the table.

Rules

• The first specifier must be MAJOR.
• MINOR and PATCH are not required. If MINOR is present, it must be after MAJOR, and if PATCH is present, it must be after MINOR.
• As for all schemes, arbitrary literals can be placed in the format string. For example, dots, hyphens, or any other character(s) can be used, such as v<MAJOR>#<MINOR>-p<PATCH>.

Example Formats

• <MAJOR>.<MINOR>.<PATCH>: Major, minor, and patch. Dot-separated.
• v<MAJOR>.<MINOR>: v followed by major and minor. Dot-separated.

Implementations

impl Sem

pub fn next_version_string( format_str: &str, version_str: &str, level: SemLevel ) -> Result<String, CompositeError>

Increments the version string (formatted by the format string) by the given semantic specifier and returns the new version’s string.

This is a convenience method that creates a temporary Format and Version with Scheme::new_version, and increments it with Version::next.

Example

use nextver::prelude::*;

let next_str = Sem::next_version_string(
  "<MAJOR>.<MINOR>.<PATCH>",
  "1.2.3",
   SemLevel::Minor
).unwrap();

assert_eq!("1.3.0", next_str);

Errors

Returns a CompositeError of all error surface area from Self::new_version and Version::next.

Trait Implementations

impl Debug for Sem

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

Formats the value using the given formatter.

impl PartialEq for Sem

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

fn new_format(format_str: &str) -> Result<Format<'_, Self>, FormatError>

Parse a format string containing specifier and literal tokens into a Format.

fn new_version<'vs>( format_str: &str, version_str: &'vs str ) -> Result<Version<'vs, Self>, CompositeError>

Parses a version string against a format string, and returns a Version object if the version string matches the format string. Otherwise, returns a NextError.

fn is_valid(format_str: &str, version_str: &str) -> Result<bool, FormatError>

Returns Ok(true) if the given version string is valid for the given format string, or else Ok(false). Returns an error if the format string could not be parsed.

impl Eq for Sem

impl StructuralPartialEq for Sem