version-manager 3.0.0

A simple version manager for your projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::{
    VersionError,
    files::TrackedFiles,
    version::{Operator, SetTypes},
};
use clap::{Args, Parser, Subcommand, value_parser};
use clio::ClioPath;
use regex::Regex;

#[derive(Parser, Debug, Clone, PartialEq)]
#[command(arg_required_else_help(true))]
pub struct FilesCommand {
    #[clap(subcommand)]
    pub command: Files,
}

impl TryFrom<FilesCommand> for Operator {
    type Error = VersionError;

    fn try_from(cmd: FilesCommand) -> Result<Self, Self::Error> {
        cmd.command.try_into()
    }
}

impl TryFrom<&FilesCommand> for Operator {
    type Error = VersionError;

    fn try_from(cmd: &FilesCommand) -> Result<Self, Self::Error> {
        (&cmd.command).try_into()
    }
}

#[derive(Subcommand, Debug, Clone, PartialEq)]
#[command(arg_required_else_help(true))]
pub enum Files {
    /// Add a file to add the version number
    Track(TrackFile),
    /// Remove a file from tracking the version number
    Rm(File),
    /// Set the version number from a file
    Update(File),
    /// Update all files
    UpdateAll,
    /// List tracked files
    List,
}

impl TryFrom<Files> for Operator {
    type Error = VersionError;

    fn try_from(cmd: Files) -> Result<Self, Self::Error> {
        let op = match cmd {
            Files::Track(track) => Operator::AddFile(track.try_into()?),
            Files::Rm(file) => Operator::RmFile(file.to_string()),
            Files::Update(file) => Operator::Update(file.to_string()),
            Files::UpdateAll => Operator::UpdateAll,
            Files::List => Operator::ListFiles,
        };
        Ok(op)
    }
}

impl TryFrom<&Files> for Operator {
    type Error = VersionError;

    fn try_from(cmd: &Files) -> Result<Self, Self::Error> {
        let op = match cmd {
            Files::Track(track) => Operator::AddFile(track.try_into()?),
            Files::Rm(file) => Operator::RmFile(file.to_string()),
            Files::Update(file) => Operator::Update(file.to_string()),
            Files::UpdateAll => Operator::UpdateAll,
            Files::List => Operator::ListFiles,
        };
        Ok(op)
    }
}

#[derive(Args, Debug, Clone, PartialEq)]
#[command(arg_required_else_help(true))]
pub struct TrackFile {
    /// The path to the file to track
    #[arg(value_parser = value_parser!(ClioPath).exists().is_file())]
    pub path: ClioPath,
    /// The expression to match the version number
    ///
    /// This expression should be a regex with a single capture group that matches the version number
    pub expr: String,
}

impl TryFrom<&TrackFile> for SetTypes {
    type Error = VersionError;

    fn try_from(track_file: &TrackFile) -> Result<Self, Self::Error> {
        let track_file = TrackedFiles::new_from_path_and_regex(
            track_file.path.to_path_buf(),
            track_file.expr.clone().parse::<Regex>()?,
        );
        Ok(SetTypes::NewFile(track_file))
    }
}

impl TryFrom<TrackFile> for SetTypes {
    type Error = VersionError;

    fn try_from(track_file: TrackFile) -> Result<Self, Self::Error> {
        let track_file = TrackedFiles::new_from_path_and_regex(
            track_file.path.to_path_buf(),
            track_file.expr.clone().parse::<Regex>()?,
        );
        Ok(SetTypes::NewFile(track_file))
    }
}

#[derive(Args, Debug, Clone, PartialEq)]
#[command(arg_required_else_help(true))]
pub struct File {
    /// The path to the file
    #[arg(value_parser = clap::value_parser!(ClioPath).exists().is_file())]
    pub path: ClioPath,
}

impl ToString for File {
    fn to_string(&self) -> String {
        self.path.to_string()
    }
}

impl TryFrom<&File> for SetTypes {
    type Error = VersionError;

    fn try_from(file: &File) -> Result<Self, Self::Error> {
        Ok(SetTypes::String(file.path.to_string()))
    }
}

impl TryFrom<File> for SetTypes {
    type Error = VersionError;

    fn try_from(file: File) -> Result<Self, Self::Error> {
        Ok(SetTypes::String(file.path.to_string()))
    }
}