ttys3/git-cz - Change HXCFU6ZFK2G33HC3VX2PAQTL3UJK4BG472O4G6T5YF3ZOQKIE4HQC

feat: Allow a custom scope regex in the configuration Add `scopeRegex` to the `.versionrc` file. This will be used to check the validity of the conventional commit. It can be usefull to limit the scopes to a limitied number (e.g. `changelog|check|commit|version`) Refs: #8

Created by Hannes De Valkeneer on August 19, 2020

HXCFU6ZFK2G33HC3VX2PAQTL3UJK4BG472O4G6T5YF3ZOQKIE4HQC

Dependencies

In channels

main

Change contents

File addition: .versionrc (-rw-r--r--)

[1.0]

template: "src/conventional/changelog"
scopeRegex: "changelog|check|commit|version"

Deletion in Cargo.lock at line 113 [7.13]
∅:D[6.365] → [7.3694:3772]
∅:D[8.77] → [7.3694:3772]
∅:D[9.914] → [7.3694:3772]
B:BD[7.3694] → [7.3694:3772]
```
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
```
Deletion in Cargo.toml at line 20 [10.46904]
∅:D[6.4478] → [10.47245:47267]
∅:D[8.2463] → [10.47245:47267]
∅:D[9.12787] → [10.47245:47267]
∅:D[4.1381] → [10.47245:47267]
B:BD[10.47245] → [10.47245:47267]
```
lazy_static = "1.4.0"
```

Insertion in src/cli.rs at line 10 [10.42789]

[10.43121]

    #[structopt(short = "c", long = "config", global = true)]
    pub config: Option<PathBuf>,

Replacement in src/cmd/changelog.rs at line 6 [10.36278]

B:BD[11.21] → [12.0:143]

            ChangelogWriter, CommitContext, CommitGroup, Config, Context, ContextBase,
            ContextBuilder, Note, NoteGroup, Reference,

[11.21]

[11.151]

            ChangelogWriter, CommitContext, CommitGroup, Context, ContextBase, ContextBuilder,
            Note, NoteGroup, Reference,

Replacement in src/cmd/changelog.rs at line 9 [10.36278]
∅:D[11.162] → [13.444:460]
B:BD[13.444] → [13.444:460]
```
        Footer,
```
[11.162]
[10.36445]
```
        config::Config,
        CommitParser, Footer,
```
Deletion in src/cmd/changelog.rs at line 20 [10.36278]
B:BD[14.1770] → [12.144:158]
```
use url::Url;
```
Insertion in src/cmd/changelog.rs at line 37 [10.36278]
[12.200]
[15.292]
```
    commit_parser: CommitParser,
```

Insertion in src/cmd/changelog.rs at line 57 [10.36278]

[16.341]

[12.278]

        let commit_parser = CommitParser::builder()
            .scope_regex(config.scope_regex.clone())
            .build();

Insertion in src/cmd/changelog.rs at line 68 [10.36278]
[12.386]
[12.386]
```
            commit_parser,
```

Replacement in src/cmd/changelog.rs at line 122 [10.36278]

B:BD[10.38016] → [10.38016:38135]

            if let Some(Ok(conv_commit)) =
                commit.message().map(crate::conventional::Commit::from_str)

[10.38016]

[10.38135]

            if let Some(Ok(conv_commit)) = commit.message().map(|msg| self.commit_parser.parse(msg))

Deletion in src/cmd/changelog.rs at line 225 [10.36278]

B:BD[14.2706] → [14.2706:2712]

∅:D[14.2712] → [10.39645:39648]

B:BD[10.39645] → [10.39645:39648]

B:BD[10.39648] → [12.1106:1210]

∅:D[12.1210] → [13.1722:1818]

B:BD[13.1722] → [13.1722:1818]

B:BD[13.1818] → [12.1211:1544]

    }
}
fn make_cl_config(git: &GitHelper) -> Config {
    let mut config: Config = std::fs::read(".versionrc")
        .ok()
        .and_then(|versionrc| serde_yaml::from_reader(versionrc.as_slice()).ok())
        .unwrap_or_default();
    if let Config {
        host: None,
        owner: None,
        repository: None,
        ..
    } = config
    {
        if let Ok((host, owner, repository)) = host_info(git) {
            config.host = host;
            config.owner = owner;
            config.repository = repository;
        }

Deletion in src/cmd/changelog.rs at line 226 [10.36278]
B:BD[12.1550] → [12.1550:1561]
```
    config
```

Deletion in src/cmd/changelog.rs at line 228 [10.36278]

B:BD[12.1564] → [12.1564:2724]

∅:D[13.1847] → [10.39702:39705]

∅:D[12.2724] → [10.39702:39705]

B:BD[10.39702] → [10.39702:39705]

type HostOwnerRepo = (Option<String>, Option<String>, Option<String>);
/// Get host, owner and repository based on the git remote origin url.
pub(crate) fn host_info(git: &GitHelper) -> Result<HostOwnerRepo, Error> {
    if let Some(mut url) = git.url()? {
        if !url.contains("://") {
            // check if it contains a port
            if let Some(colon) = url.find(':') {
                match url.as_bytes()[colon + 1] {
                    b'0'..=b'9' => url = format!("scheme://{}", url),
                    _ => url = format!("scheme://{}/{}", &url[..colon], &url[colon + 1..]),
                }
            }
        }
        let url = Url::parse(url.as_str())?;
        let host = url.host().map(|h| format!("https://{}", h));
        let mut owner = None;
        let mut repository = None;
        if let Some(mut segments) = url.path_segments() {
            owner = segments.next().map(|s| s.to_string());
            repository = segments
                .next()
                .map(|s: &str| s.trim_end_matches(".git").to_string());
        }
        Ok((host, owner, repository))
    } else {
        Ok((None, None, None))
    }
}

Replacement in src/cmd/changelog.rs at line 229 [10.36278]
B:BD[10.39741] → [10.39741:39783]
```
    fn exec(&self) -> Result<(), Error> {
```
[10.39741]
[10.39783]
```
    fn exec(&self, config: Config) -> Result<(), Error> {
```
Deletion in src/cmd/changelog.rs at line 231 [10.36278]
B:BD[10.39843] → [13.1848:1849]
Deletion in src/cmd/changelog.rs at line 245 [10.36278]
B:BD[10.39881] → [12.2725:2771]
```
        let config = make_cl_config(&helper);
```
Deletion in src/cmd/changelog.rs at line 252 [10.36278]
∅:D[12.2901] → [15.1010:1011]
B:BD[15.1010] → [15.1010:1011]
Insertion in src/cmd/check.rs at line 2 [10.34349]
[10.34417]
[10.34417]
```
use conventional::Config;
```

Replacement in src/cmd/check.rs at line 5 [10.34349]

B:BD[10.34450] → [10.34450:34496]

fn print_check(commit: &Commit<'_>) -> bool {

[10.34450]

[10.34496]

fn print_check(commit: &Commit<'_>, parser: &conventional::CommitParser) -> bool {

Replacement in src/cmd/check.rs at line 9 [10.34349]

B:BD[10.34701] → [10.34701:34771]

    let msg_parsed: Result<conventional::Commit, &str> = msg.parse();

[10.34701]

[10.34771]

    let msg_parsed = parser.parse(msg);

Replacement in src/cmd/check.rs at line 26 [10.34349]
B:BD[10.35261] → [10.35261:35303]
```
    fn exec(&self) -> Result<(), Error> {
```
[10.35261]
[10.35303]
```
    fn exec(&self, config: Config) -> Result<(), Error> {
```

Insertion in src/cmd/check.rs at line 38 [10.34349]

[10.35616]

        let parser = conventional::CommitParser::builder()
            .scope_regex(config.scope_regex)
            .build();

Replacement in src/cmd/check.rs at line 48 [10.34349]

B:BD[10.35816] → [10.35816:35870]

            fail += u32::from(!print_check(&commit));

[10.35816]

[10.35870]

            fail += u32::from(!print_check(&commit, &parser));

Replacement in src/cmd/commit.rs at line 1 [2.2942]

B:BD[2.2942] → [2.2943:2992]

use crate::{cli::CommitCommand, Command, Error};

[2.2942]

[2.2992]

use crate::{cli::CommitCommand, conventional::Config, Command, Error};

Replacement in src/cmd/commit.rs at line 100 [2.2942]

B:BD[2.5580] → [2.5580:5622]

    fn exec(&self) -> Result<(), Error> {

[2.5580]

[2.5622]

    fn exec(&self, _: Config) -> Result<(), Error> {

Replacement in src/cmd/version.rs at line 4 [10.31432]
B:BD[10.31489] → [10.31489:31523]
```
    conventional::{Commit, Type},
```
[10.31489]
[10.31523]
```
    conventional::{CommitParser, Config, Type},
```
Replacement in src/cmd/version.rs at line 9 [10.31432]
B:BD[10.31595] → [17.1963:1993]
```
use std::{fmt, str::FromStr};
```
[10.31595]
[18.547]
```
use std::fmt;
```
Insertion in src/cmd/version.rs at line 55 [10.31432]
[10.31990]
[18.1157]
```
        parser: &CommitParser,
```

Replacement in src/cmd/version.rs at line 64 [10.31432]

B:BD[10.32335] → [10.32335:32430]

            .filter_map(|commit| commit.message().and_then(|msg| Commit::from_str(msg).ok()));

[10.32335]

[10.32430]

            .filter_map(|commit| commit.message().and_then(|msg| parser.parse(msg).ok()));

Replacement in src/cmd/version.rs at line 109 [10.31432]
B:BD[10.33289] → [10.33289:33331]
```
    fn exec(&self) -> Result<(), Error> {
```
[10.33289]
[10.33331]
```
    fn exec(&self, config: Config) -> Result<(), Error> {
```

Replacement in src/cmd/version.rs at line 126 [10.31432]

B:BD[5.271] → [5.271:338]

                    self.find_bump_version(tag.as_str(), version)?

[5.271]

[5.338]

                    let parser = CommitParser::builder()
                        .scope_regex(config.scope_regex)
                        .build();
                    self.find_bump_version(tag.as_str(), version, &parser)?

Replacement in src/cmd.rs at line 1 [10.34207]
B:BD[10.34207] → [10.34208:34226]
```
use crate::Error;
```
[10.34207]
[10.34226]
```
use crate::{conventional::Config, Error};
```

Replacement in src/cmd.rs at line 9 [10.34207]

B:BD[10.34294] → [10.34294:34335]

    fn exec(&self) -> Result<(), Error>;

[10.34294]

[10.34335]

    fn exec(&self, config: Config) -> Result<(), Error>;

Replacement in src/conventional/changelog.rs at line 1 [10.18829]
B:BD[10.18829] → [12.11422:11434]
```
mod config;
```
[10.18829]
[12.11434]
```
use super::config::Config;
```
Deletion in src/conventional/changelog.rs at line 4 [10.18829]
B:BD[10.18871] → [12.11453:11484]
```
pub(crate) use config::Config;
```
Replacement in src/conventional/commits.rs at line 2 [10.8282]
B:BD[10.8301] → [10.8301:8331]
```
use std::{fmt, str::FromStr};
```
[10.8301]
[10.8331]
```
use std::fmt;
```
Replacement in src/conventional/commits.rs at line 71 [10.8282]
B:BD[10.10433] → [10.10433:10460]
```
pub(crate) struct Commit {
```
[10.10433]
[10.10460]
```
pub struct Commit {
```

Replacement in src/conventional/commits.rs at line 86 [10.8282]

B:BD[10.10829] → [10.10829:10884]

impl FromStr for Commit {
    type Err = &'static str;

[10.10829]

[10.10884]

pub struct CommitParser {
    regex_first_line: Regex,
    regex_footer: Regex,
}

Replacement in src/conventional/commits.rs at line 91 [10.8282]

B:BD[10.10885] → [10.10885:11092]

B:BD[10.11092] → [3.0:67]

∅:D[19.63] → [10.11149:11278]

∅:D[3.67] → [10.11149:11278]

B:BD[10.11149] → [10.11149:11278]

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        lazy_static! {
            static ref RE_FIRST_LINE: Regex = Regex::new(
                r#"(?xms)
            ^
            (?P<type>[a-zA-Z]+)
            (?:\((?P<scope>[[:alnum:]]+(?:[-_/][[:alnum:]]+)*)\))?
            (?P<breaking>!)?
            :\x20(?P<desc>[^\r\n]+)
            $"#,
            )
            .unwrap();
        }

[10.10885]

[10.11278]

impl CommitParser {
    pub fn builder() -> CommitParserBuilder {
        CommitParserBuilder::new()
    }
    pub fn parse(&self, s: &str) -> Result<Commit, &str> {

Replacement in src/conventional/commits.rs at line 99 [10.8282]

B:BD[10.11357] → [10.11357:11422]

            if let Some(capts) = RE_FIRST_LINE.captures(first) {

[10.11357]

[10.11422]

            if let Some(capts) = self.regex_first_line.captures(first) {

Deletion in src/conventional/commits.rs at line 106 [10.8282]

B:BD[10.11847] → [10.11847:12392]

                        lazy_static! {
                            static ref RE_FOOTER : Regex = Regex::new(
                                r#"(?xm)
                                        ^
                                        (?:(?P<key>(?:BREAKING\x20CHANGE|[a-zA-Z]+(?:-[a-zA-Z]+)*)):\x20|
                                        (?P<ref>[a-zA-Z]+(?:-[a-zA-Z]+)*)\x20\#)
                                        (?P<value>.+)
                                        $"#,
                            ).unwrap();
                        }

Replacement in src/conventional/commits.rs at line 109 [10.8282]

B:BD[10.12557] → [10.12557:12633]

                            if let Some(capts) = RE_FOOTER.captures(line) {

[10.12557]

[10.12633]

                            if let Some(capts) = self.regex_footer.captures(line) {

Insertion in src/conventional/commits.rs at line 161 [10.8282]

[10.14966]

pub struct CommitParserBuilder {
    scope_regex: String,
}
impl CommitParserBuilder {
    pub fn new() -> Self {
        Self {
            scope_regex: "[[:alnum:]]+(?:[-_/][[:alnum:]]+)*".into(),
        }
    }
    pub fn scope_regex(self, scope_regex: String) -> Self {
        Self { scope_regex }
    }
    pub fn build(&self) -> CommitParser {
        let regex_first_line = Regex::new(&format!(
            r#"(?xms)
        ^
        (?P<type>[a-zA-Z]+)
        (?:\((?P<scope>{})\))?
        (?P<breaking>!)?
        :\x20(?P<desc>[^\r\n]+)
        $"#,
            self.scope_regex
        ))
        .expect("valid scope regex");
        let regex_footer = Regex::new(
            r#"(?xm)
                    ^
                    (?:(?P<key>(?:BREAKING\x20CHANGE|[a-zA-Z]+(?:-[a-zA-Z]+)*)):\x20|
                    (?P<ref>[a-zA-Z]+(?:-[a-zA-Z]+)*)\x20\#)
                    (?P<value>.+)
                    $"#,
        )
        .unwrap();
        CommitParser {
            regex_first_line,
            regex_footer,
        }
    }
}

Insertion in src/conventional/commits.rs at line 207 [10.8282]

[10.15009]


    fn parser() -> CommitParser {
        CommitParser::builder().build()
    }

Replacement in src/conventional/commits.rs at line 215 [10.8282]

B:BD[10.15101] → [10.15101:15159]

        let commit: Commit = msg.parse().expect("valid");

[10.15101]

[10.15159]

        let commit: Commit = parser().parse(msg).expect("valid");

Replacement in src/conventional/commits.rs at line 232 [10.8282]

B:BD[10.15575] → [10.15575:15633]

        let commit: Commit = msg.parse().expect("valid");

[10.15575]

[10.15633]

        let commit: Commit = parser().parse(msg).expect("valid");

Replacement in src/conventional/commits.rs at line 249 [10.8282]

∅:D[3.164] → [19.151:209]

B:BD[19.151] → [19.151:209]

        let commit: Commit = msg.parse().expect("valid");

[3.164]

[19.209]

        let commit: Commit = parser().parse(msg).expect("valid");

Replacement in src/conventional/commits.rs at line 266 [10.8282]

B:BD[10.16060] → [10.16060:16118]

        let commit: Commit = msg.parse().expect("valid");

[10.16060]

[10.16118]

        let commit: Commit = parser().parse(msg).expect("valid");

Replacement in src/conventional/commits.rs at line 285 [10.8282]

B:BD[10.16716] → [10.16716:16774]

        let commit: Commit = msg.parse().expect("valid");

[10.16716]

[10.16774]

        let commit: Commit = parser().parse(msg).expect("valid");

Replacement in src/conventional/commits.rs at line 314 [10.8282]

B:BD[10.17700] → [10.17700:17758]

        let commit: Commit = msg.parse().expect("valid");

[10.17700]

[10.17758]

        let commit: Commit = parser().parse(msg).expect("valid");

File move: config.rs → config.rs
BF:BFD[10.18465] → [12.2902:2913]
[10.5171]
[12.2914]
Insertion in src/conventional/config.rs at line 1 [12.2914]
[12.2914]
[12.2915]
```
use crate::{error::Error, git::GitHelper};
```
Replacement in src/conventional/config.rs at line 3 [12.2914]
B:BD[12.2952] → [4.1558:1582]
```
use std::path::PathBuf;
```
[12.2952]
[12.2952]
```
use std::path::{Path, PathBuf};
use url::Url;
```

Replacement in src/conventional/config.rs at line 16 [12.2914]

B:BD[12.3332] → [4.1583:1651]

/// Additional config: `host`, `owner`, `repository` and `template`

[12.3332]

[12.3386]

/// Additional config: `host`, `owner`, `repository`, `scope_regex` and `template`

Replacement in src/conventional/config.rs at line 52 [12.2914]

B:BD[12.5478] → [4.1652:1760]

    /// An optional template directory. The template should be called `template.hbs`. Partials can be used.

[12.5478]

[4.1760]

    /// `template`. An optional template directory. The template should be called `template.hbs`. Partials can be used.

Insertion in src/conventional/config.rs at line 54 [12.2914]

[4.1802]

[12.5478]

    /// `scopeRegex`. A regex to define possible scopes.
    /// For this project this could be `"changelog|check|commit|version"`.
    /// Defaults to `"[[:alnum:]]+(?:[-_/][[:alnum:]]+)*"`.
    #[serde(default = "default_scope_regex")]
    pub(crate) scope_regex: String,

Insertion in src/conventional/config.rs at line 77 [12.2914]

[4.1831]

[12.6106]

            scope_regex: "[[:alnum:]]+(?:[-_/][[:alnum:]]+)*".to_string(),

Insertion in src/conventional/config.rs at line 125 [12.2914]

[12.7090]

fn default_scope_regex() -> String {
    "[[:alnum:]]+(?:[-_/][[:alnum:]]+)*".to_string()
}
type HostOwnerRepo = (Option<String>, Option<String>, Option<String>);
/// Get host, owner and repository based on the git remote origin url.
pub(crate) fn host_info(git: &GitHelper) -> Result<HostOwnerRepo, Error> {
    if let Some(mut url) = git.url()? {
        if !url.contains("://") {
            // check if it contains a port
            if let Some(colon) = url.find(':') {
                match url.as_bytes()[colon + 1] {
                    b'0'..=b'9' => url = format!("scheme://{}", url),
                    _ => url = format!("scheme://{}/{}", &url[..colon], &url[colon + 1..]),
                }
            }
        }
        let url = Url::parse(url.as_str())?;
        let host = url.host().map(|h| format!("https://{}", h));
        let mut owner = None;
        let mut repository = None;
        if let Some(mut segments) = url.path_segments() {
            owner = segments.next().map(|s| s.to_string());
            repository = segments
                .next()
                .map(|s: &str| s.trim_end_matches(".git").to_string());
        }
        Ok((host, owner, repository))
    } else {
        Ok((None, None, None))
    }
}
pub(crate) fn make_cl_config(git: &GitHelper, path: impl AsRef<Path>) -> Config {
    let mut config: Config = (std::fs::read(path))
        .ok()
        .and_then(|versionrc| (serde_yaml::from_reader(versionrc.as_slice())).ok())
        .unwrap_or_default();
    if let Config {
        host: None,
        owner: None,
        repository: None,
        ..
    } = config
    {
        if let Ok((host, owner, repository)) = host_info(git) {
            config.host = host;
            config.owner = owner;
            config.repository = repository;
        }
    }
    config
}

Replacement in src/conventional/config.rs at line 203 [12.2914]
B:BD[12.8146] → [12.8146:8162]
```
              ]
```
[12.8146]
[12.8162]
```
              ],
```

Insertion in src/conventional/config.rs at line 285 [12.2914]

[4.1864]

[12.11389]

                scope_regex: "[[:alnum:]]+(?:[-_/][[:alnum:]]+)*".to_string(),

Insertion in src/conventional.rs at line 24 [10.5181]
[10.8227]
[10.8227]
```
pub(crate) mod config;
```

Replacement in src/conventional.rs at line 26 [10.5181]

B:BD[10.8228] → [13.6475:6523]

pub(crate) use commits::{Commit, Footer, Type};

[10.8228]

pub(crate) use commits::{CommitParser, Footer, Type};
pub(crate) use config::Config;

Deletion in src/main.rs at line 1 [10.17]
B:BD[10.17] → [10.18:58]
```
#[macro_use]
extern crate lazy_static;
```

Insertion in src/main.rs at line 9 [10.17]

[13.6546]

[10.190]

use conventional::config::make_cl_config;
use git::GitHelper;

Insertion in src/main.rs at line 19 [10.17]

[10.962]

    let git = GitHelper::new("v")?;
    let config = make_cl_config(&git, opt.config.unwrap_or_else(|| ".versionrc".into()));

Replacement in src/main.rs at line 22 [10.17]

B:BD[10.992] → [10.992:1142]

B:BD[10.1142] → [2.6115:6164]

        cli::Command::Check(cmd) => cmd.exec(),
        cli::Command::Changelog(cmd) => cmd.exec(),
        cli::Command::Version(cmd) => cmd.exec(),
        cli::Command::Commit(cmd) => cmd.exec(),

[10.992]

[10.1142]

        cli::Command::Check(cmd) => cmd.exec(config),
        cli::Command::Changelog(cmd) => cmd.exec(config),
        cli::Command::Version(cmd) => cmd.exec(config),
        cli::Command::Commit(cmd) => cmd.exec(config),

feat: Allow a custom scope regex in the configuration Add `scopeRegex` to the `.versionrc` file. This will be used to check the validity of the conventional commit. It can be usefull to limit the scopes to a limitied number (e.g. `changelog|check|commit|version`) Refs: #8

Dependencies

In channels

Change contents

File addition: .versionrc (-rw-r--r--)

Deletion in Cargo.lock at line 113 [7.13]

Deletion in Cargo.toml at line 20 [10.46904]

Insertion in src/cli.rs at line 10 [10.42789]

Replacement in src/cmd/changelog.rs at line 6 [10.36278]

Replacement in src/cmd/changelog.rs at line 9 [10.36278]

Deletion in src/cmd/changelog.rs at line 20 [10.36278]

Insertion in src/cmd/changelog.rs at line 37 [10.36278]

Insertion in src/cmd/changelog.rs at line 57 [10.36278]

Insertion in src/cmd/changelog.rs at line 68 [10.36278]

Replacement in src/cmd/changelog.rs at line 122 [10.36278]

Deletion in src/cmd/changelog.rs at line 225 [10.36278]

Deletion in src/cmd/changelog.rs at line 226 [10.36278]

Deletion in src/cmd/changelog.rs at line 228 [10.36278]

Replacement in src/cmd/changelog.rs at line 229 [10.36278]

Deletion in src/cmd/changelog.rs at line 231 [10.36278]

Deletion in src/cmd/changelog.rs at line 245 [10.36278]

Deletion in src/cmd/changelog.rs at line 252 [10.36278]

Insertion in src/cmd/check.rs at line 2 [10.34349]

Replacement in src/cmd/check.rs at line 5 [10.34349]

Replacement in src/cmd/check.rs at line 9 [10.34349]

Replacement in src/cmd/check.rs at line 26 [10.34349]

Insertion in src/cmd/check.rs at line 38 [10.34349]

Replacement in src/cmd/check.rs at line 48 [10.34349]

Replacement in src/cmd/commit.rs at line 1 [2.2942]

Replacement in src/cmd/commit.rs at line 100 [2.2942]

Replacement in src/cmd/version.rs at line 4 [10.31432]

Replacement in src/cmd/version.rs at line 9 [10.31432]

Insertion in src/cmd/version.rs at line 55 [10.31432]

Replacement in src/cmd/version.rs at line 64 [10.31432]

Replacement in src/cmd/version.rs at line 109 [10.31432]

Replacement in src/cmd/version.rs at line 126 [10.31432]

Replacement in src/cmd.rs at line 1 [10.34207]