From 2c026ae3d18a71b3732ff03d684a71bf0660b884 Mon Sep 17 00:00:00 2001
From: Charlie Ozinga <ozchaz@gmail.com>
Date: Wed, 11 Nov 2020 13:02:45 -0700
Subject: [PATCH] fix: add "info -A" and global "-c" flags

---
 README.md          |  8 ++++----
 docs/reference.md  | 16 ++++++++++++---
 docs/use_cases.md  |  2 +-
 docs/vcs_levels.md | 16 ++++++++++++++-
 src/cli.rs         | 46 ++++++++++++++++++++++++++++++-------------
 src/commands.rs    | 49 +++++++++++++++++++++++++++-------------------
 src/git.rs         | 44 ++++++++++++++++++++++++-----------------
 src/init.rs        |  8 ++++----
 src/mono.rs        |  6 +++---
 src/state.rs       |  9 +++++----
 src/vcs.rs         | 18 +++++++++++++++++
 11 files changed, 150 insertions(+), 72 deletions(-)

diff --git a/README.md b/README.md
index 70021f5..f4a12db 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,7 @@ can be a headache to resolve. And it can be inefficient to halt all
 contributions while a release is being built.
 -->
 
-Software go through a _release process_, where the software is
+Software goes through a _release process_, where the software is
 described, assigned a version number, and deployed to sites where it can
 be executed or distributed. This process occurs first when the
 application is created, and again whenever maintenance or improvements
@@ -129,9 +129,9 @@ Subdirectories](./docs/subs.md) page for a description.
 ### VCS Levels
 
 VCS Levels allow you to control the way Versio interacts with a Git
-repository: you can have interact only locally, with a remote, or not at
-all. See the description in its [document](./docs/vcs_levels.md) for
-more information.
+repository: you can interact only locally, with a remote, or not at all.
+See the description in its [document](./docs/vcs_levels.md) for more
+information.
 
 ### Version Chains
 
diff --git a/docs/reference.md b/docs/reference.md
index 5432ed3..7e9cfc3 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -95,6 +95,10 @@ $ versio <global options> [subcommand] <subcommand options>
 - `vcs-level` (`-l`), `vcs-level-min` (`-m`), `vcs-level-max` (`-x`):
   see the [VCS Levels](./vcs_levels.md) page for a description of these
   global options.
+- `no-current` (`-c`): when the calculated vcs level is "local",
+  commands that make no changes (`check`, `get`, `show`, `diff`,
+  `files`, `changes`, `plan`, `info`) will not verify that the repo is
+  current.
 
 ### Subcommands
 [Subcommands]: #subcommands
@@ -139,8 +143,8 @@ along with their options and flags. You can always use `versio help` or
 - `files`: See all files that have changed since the previous version.
 - `plan`: View the update plan.
 - `info`: Outputs a JSON document with information about projects:
-  - `--id` (`-i <ID>`): include an ID'd project in the document (you can
-    provide this option more than once).
+  - `--id` (`-i <ID>`): include a single project with the given ID (you
+    can provide this option more than once).
   - `--name` (`-n <name>`): include a named project in the document (you
     can provide this option more than once).
   - `--label` (`-l <label>`): include all projects with a label (you can
@@ -148,7 +152,13 @@ along with their options and flags. You can always use `versio help` or
   - `--all` (`-a`): include all projects.
   - `--show-root` (`-R`): include the projects' root directories in the
     document.
-  - `--show-name` (`-N`): include the projects' names in the document.
+  - `--show-name` (`-N`): include the projects' names.
+  - `--show-full-version` (`-F`): include the projects' full version
+    (including the tag prefix).
+  - `--show-version` (`-V`): include the projects' version numbers.
+  - `--show-tag-prefix` (`-T`): include the projects' tag prefixes.
+  - `--show-id` (`-I`): include the projects' ids.
+  - `--show-all` (`-A`): include all fields from the projects.
 
   This command is useful to generate a machine-consumable document of
   one or more of the project configurations. It's especially helpful to
diff --git a/docs/use_cases.md b/docs/use_cases.md
index cd252bd..f35484e 100644
--- a/docs/use_cases.md
+++ b/docs/use_cases.md
@@ -10,7 +10,7 @@ Get up and running quickly with Versio, and get a brief introduction to
 what it does. This example assumes a standard Node.js/NPM layout, but
 Versio can handle lots of different project types.
 
-If you don't have rust installed, you can't use `cargo install`.
+If you don't have Rust installed, you can't use `cargo install`.
 Instead, download a binary for your platform directly from the [Releases
 page](https://github.com/chaaz/versio/releases).
 
diff --git a/docs/vcs_levels.md b/docs/vcs_levels.md
index f40963e..3102b0c 100644
--- a/docs/vcs_levels.md
+++ b/docs/vcs_levels.md
@@ -14,7 +14,7 @@ There are four such levels, ordered from minimal to maximal:
   level: no network or remote interaction is allowed. Fetches, pulls
   and pushes are not done: not even with tags. No effort is made to
   ensure that the local repository is synchronized with any remote.
-  
+
 - **Remote**: The command interacts fully with the VCS system, including
   a guarantee that the local repository is fully synced with the remote
   both before and after the command executes.
@@ -49,6 +49,20 @@ gather information and write a new versions and changelogs based on pull
 request information from the remote GitHub API, but then run `versio -l
 local release --resume` to commit and tag only the local repo.
 
+### Vs Current
+
+The `--no-current` flag only works on some commands, and only when the
+final VCS level is calculated as "local" (see "Calculation" below).
+Normally all commands at the "local" level will verify that the repo is
+current: i.e., it does not contain local modifications or untracked
+files. These commands don't make any changes though, so it may be safe
+to run them without this check, depending on your workflow.
+
+At a VCS level of "remote" or higher, the check is always done (the
+`--no-current` flag is ignored) because only a current repo can be
+reconciled with remote changes. At the level of "none", the VCS isn't
+consulted in any case, so the flag is effectively ignored.
+
 ## Calculation
 
 Every Versio command except for `versio init` calculates the final VCS
diff --git a/src/cli.rs b/src/cli.rs
index 354658b..2f1d45f 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -48,6 +48,14 @@ pub fn execute(info: &EarlyInfo) -> Result<()> {
         .display_order(1)
         .help("The maximum VCS level")
     )
+    .arg(
+      Arg::with_name("ignorecurrent")
+        .short("c")
+        .long("no-current")
+        .takes_value(false)
+        .display_order(1)
+        .help("Accept local repo changes")
+    )
     .subcommand(
       SubCommand::with_name("check")
         .setting(AppSettings::UnifiedHelpMessage)
@@ -285,6 +293,14 @@ pub fn execute(info: &EarlyInfo) -> Result<()> {
         .arg(
           Arg::with_name("all").short("a").long("all").takes_value(false).display_order(1).help("Info on all projects")
         )
+        .arg(
+          Arg::with_name("showall")
+            .short("A")
+            .long("show-all")
+            .takes_value(false)
+            .display_order(1)
+            .help("Show all fields")
+        )
         .arg(
           Arg::with_name("showroot")
             .short("R")
@@ -348,23 +364,25 @@ fn parse_matches(m: ArgMatches) -> Result<()> {
   }
 
   let pref_vcs = parse_vcs(&m)?;
+  let ignore_current = m.is_present("ignorecurrent");
 
   match m.subcommand() {
-    ("check", _) => check(pref_vcs)?,
+    ("check", _) => check(pref_vcs, ignore_current)?,
     ("get", Some(m)) => get(
       pref_vcs,
       m.is_present("wide"),
       m.is_present("versiononly"),
       m.is_present("prev"),
       m.value_of("id"),
-      m.value_of("name")
+      m.value_of("name"),
+      ignore_current
     )?,
-    ("show", Some(m)) => show(pref_vcs, m.is_present("wide"), m.is_present("prev"))?,
+    ("show", Some(m)) => show(pref_vcs, m.is_present("wide"), m.is_present("prev"), ignore_current)?,
     ("set", Some(m)) => set(pref_vcs, m.value_of("id"), m.value_of("name"), m.value_of("value").unwrap())?,
-    ("diff", Some(_)) => diff(pref_vcs)?,
-    ("files", Some(_)) => files(pref_vcs)?,
-    ("changes", Some(_)) => changes(pref_vcs)?,
-    ("plan", Some(_)) => plan(pref_vcs)?,
+    ("diff", Some(_)) => diff(pref_vcs, ignore_current)?,
+    ("files", Some(_)) => files(pref_vcs, ignore_current)?,
+    ("changes", Some(_)) => changes(pref_vcs, ignore_current)?,
+    ("plan", Some(_)) => plan(pref_vcs, ignore_current)?,
     ("release", Some(m)) if m.is_present("abort") => abort()?,
     ("release", Some(m)) if m.is_present("resume") => resume(pref_vcs)?,
     ("release", Some(m)) => release(pref_vcs, m.is_present("all"), m.is_present("dry"), m.is_present("pause"))?,
@@ -380,14 +398,14 @@ fn parse_matches(m: ArgMatches) -> Result<()> {
 
       let show = InfoShow::new()
         .pick_all(m.is_present("all"))
-        .show_name(m.is_present("showname"))
-        .show_root(m.is_present("showroot"))
-        .show_id(m.is_present("showid"))
-        .show_full_version(m.is_present("showfull"))
-        .show_version(m.is_present("showversion"))
-        .show_tag_prefix(m.is_present("showtagprefix"));
+        .show_name(m.is_present("showname") || m.is_present("showall"))
+        .show_root(m.is_present("showroot") || m.is_present("showall"))
+        .show_id(m.is_present("showid") || m.is_present("showall"))
+        .show_full_version(m.is_present("showfull") || m.is_present("showall"))
+        .show_version(m.is_present("showversion") || m.is_present("showall"))
+        .show_tag_prefix(m.is_present("showtagprefix") || m.is_present("showall"));
 
-      info(pref_vcs, ids, names, labels, show)?
+      info(pref_vcs, ids, names, labels, show, ignore_current)?
     }
     ("", _) => empty_cmd()?,
     (c, _) => unknown_cmd(c)?
diff --git a/src/commands.rs b/src/commands.rs
index b1c0581..07aaf02 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -6,7 +6,7 @@ use crate::git::Repo;
 use crate::mono::Mono;
 use crate::output::{Output, ProjLine};
 use crate::state::{CommitState, StateRead};
-use crate::vcs::{VcsLevel, VcsRange};
+use crate::vcs::{VcsLevel, VcsRange, VcsState};
 use error_chain::bail;
 use std::collections::HashMap;
 use std::fs::{remove_file, File};
@@ -34,8 +34,8 @@ impl EarlyInfo {
   pub fn working_dir(&self) -> &Path { &self.working_dir }
 }
 
-pub fn check(pref_vcs: Option<VcsRange>) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart)?;
+pub fn check(pref_vcs: Option<VcsRange>, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let mut output = output.check();
 
@@ -46,9 +46,10 @@ pub fn check(pref_vcs: Option<VcsRange>) -> Result<()> {
 }
 
 pub fn get(
-  pref_vcs: Option<VcsRange>, wide: bool, versonly: bool, prev: bool, id: Option<&str>, name: Option<&str>
+  pref_vcs: Option<VcsRange>, wide: bool, versonly: bool, prev: bool, id: Option<&str>, name: Option<&str>,
+  ignore_current: bool
 ) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart)?;
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart, ignore_current)?;
 
   if prev {
     get_using_cfg(&mono.config().slice_to_prev(mono.repo())?, wide, versonly, id, name)
@@ -83,8 +84,8 @@ fn get_using_cfg<R: StateRead>(
   output.commit()
 }
 
-pub fn show(pref_vcs: Option<VcsRange>, wide: bool, prev: bool) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart)?;
+pub fn show(pref_vcs: Option<VcsRange>, wide: bool, prev: bool, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::None, VcsLevel::Smart, ignore_current)?;
 
   if prev {
     show_using_cfg(&mono.config().slice_to_prev(mono.repo())?, wide)
@@ -115,8 +116,8 @@ pub fn set(pref_vcs: Option<VcsRange>, id: Option<&str>, name: Option<&str>, val
   mono.commit(false, false)
 }
 
-pub fn diff(pref_vcs: Option<VcsRange>) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::Local, VcsLevel::Smart)?;
+pub fn diff(pref_vcs: Option<VcsRange>, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Local, VcsLevel::Local, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let mut output = output.diff();
 
@@ -126,8 +127,8 @@ pub fn diff(pref_vcs: Option<VcsRange>) -> Result<()> {
   output.commit()
 }
 
-pub fn files(pref_vcs: Option<VcsRange>) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart)?;
+pub fn files(pref_vcs: Option<VcsRange>, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let mut output = output.files();
 
@@ -135,8 +136,8 @@ pub fn files(pref_vcs: Option<VcsRange>) -> Result<()> {
   output.commit()
 }
 
-pub fn changes(pref_vcs: Option<VcsRange>) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart)?;
+pub fn changes(pref_vcs: Option<VcsRange>, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let mut output = output.changes();
 
@@ -144,8 +145,8 @@ pub fn changes(pref_vcs: Option<VcsRange>) -> Result<()> {
   output.commit()
 }
 
-pub fn plan(pref_vcs: Option<VcsRange>) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart)?;
+pub fn plan(pref_vcs: Option<VcsRange>, ignore_current: bool) -> Result<()> {
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let mut output = output.plan();
 
@@ -154,9 +155,10 @@ pub fn plan(pref_vcs: Option<VcsRange>) -> Result<()> {
 }
 
 pub fn info(
-  pref_vcs: Option<VcsRange>, ids: Vec<ProjectId>, names: Vec<&str>, labels: Vec<&str>, show: InfoShow
+  pref_vcs: Option<VcsRange>, ids: Vec<ProjectId>, names: Vec<&str>, labels: Vec<&str>, show: InfoShow,
+  ignore_current: bool
 ) -> Result<()> {
-  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::None, VcsLevel::Smart)?;
+  let mono = with_opts(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::None, VcsLevel::Smart, ignore_current)?;
   let output = Output::new();
   let all = show.all();
   let mut output = output.info(show);
@@ -331,7 +333,7 @@ pub fn release(pref_vcs: Option<VcsRange>, all: bool, dry: bool, pause: bool) ->
 
 pub fn resume(user_pref_vcs: Option<VcsRange>) -> Result<()> {
   let vcs = combine_vcs(user_pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart)?;
-  let repo = Repo::open(".", vcs.max())?;
+  let repo = Repo::open(".", VcsState::new(vcs.max(), false))?;
   let output = Output::new();
   let mut output = output.resume();
 
@@ -366,12 +368,19 @@ pub fn sanity_check() -> Result<()> {
   }
 }
 
+fn with_opts(
+  user_pref_vcs: Option<VcsRange>, my_pref_lo: VcsLevel, my_pref_hi: VcsLevel, my_reqd_lo: VcsLevel,
+  my_reqd_hi: VcsLevel, ignore_current: bool
+) -> Result<Mono> {
+  let vcs = combine_vcs(user_pref_vcs, my_pref_lo, my_pref_hi, my_reqd_lo, my_reqd_hi)?;
+  Mono::here(VcsState::new(vcs.max(), ignore_current))
+}
+
 fn build(
   user_pref_vcs: Option<VcsRange>, my_pref_lo: VcsLevel, my_pref_hi: VcsLevel, my_reqd_lo: VcsLevel,
   my_reqd_hi: VcsLevel
 ) -> Result<Mono> {
-  let vcs = combine_vcs(user_pref_vcs, my_pref_lo, my_pref_hi, my_reqd_lo, my_reqd_hi)?;
-  Mono::here(vcs.max())
+  with_opts(user_pref_vcs, my_pref_lo, my_pref_hi, my_reqd_lo, my_reqd_hi, false)
 }
 
 fn combine_vcs(
diff --git a/src/git.rs b/src/git.rs
index 5517d01..fa063a6 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -3,7 +3,7 @@
 use crate::config::CONFIG_FILENAME;
 use crate::either::IterEither2 as E2;
 use crate::errors::{Result, ResultExt};
-use crate::vcs::VcsLevel;
+use crate::vcs::{VcsLevel, VcsState};
 use chrono::{DateTime, FixedOffset};
 use error_chain::bail;
 use git2::build::CheckoutBuilder;
@@ -25,7 +25,8 @@ use std::iter::empty;
 use std::path::{Path, PathBuf};
 
 pub struct Repo {
-  vcs: GitVcsLevel
+  vcs: GitVcsLevel,
+  ignore_current: bool
 }
 
 impl Repo {
@@ -94,25 +95,26 @@ impl Repo {
     Ok(repo.workdir().ok_or_else(|| bad!("Repo has no working dir"))?.to_path_buf())
   }
 
-  pub fn open<P: AsRef<Path>>(path: P, vcs: VcsLevel) -> Result<Repo> {
-    if vcs == VcsLevel::None {
+  pub fn open<P: AsRef<Path>>(path: P, vcs: VcsState) -> Result<Repo> {
+    let ignore_current = vcs.ignore_current();
+    if vcs.level().is_none() {
       let root = find_root_blind(path)?;
-      return Ok(Repo { vcs: GitVcsLevel::None { root } });
+      return Ok(Repo { ignore_current, vcs: GitVcsLevel::None { root } });
     }
 
     let flags = RepositoryOpenFlags::empty();
     let repo = Repository::open_ext(path, flags, empty::<&OsStr>())?;
     let branch_name = find_branch_name(&repo)?;
 
-    if vcs == VcsLevel::Local {
-      return Ok(Repo { vcs: GitVcsLevel::Local { repo, branch_name } });
+    if vcs.level().is_local() {
+      return Ok(Repo { ignore_current, vcs: GitVcsLevel::Local { repo, branch_name } });
     }
 
     let remote_name = find_remote_name(&repo, &branch_name)?;
     let fetches = RefCell::new(HashMap::new());
     let root = repo.workdir().ok_or_else(|| bad!("Repo has no working dir."))?.to_path_buf();
 
-    Ok(Repo { vcs: GitVcsLevel::from(vcs, root, repo, branch_name, remote_name, fetches) })
+    Ok(Repo { ignore_current, vcs: GitVcsLevel::from(vcs.level(), root, repo, branch_name, remote_name, fetches) })
   }
 
   pub fn working_dir(&self) -> Result<&Path> {
@@ -126,7 +128,9 @@ impl Repo {
 
   pub fn revparse_oid(&self, spec: FromTag) -> Result<String> {
     let repo = self.repo()?;
-    verify_current(repo).chain_err(|| "Can't complete get.")?;
+    if !self.ignore_current {
+      verify_current(repo).chain_err(|| "Can't complete revparse.")?;
+    }
     Ok(repo.revparse_single(spec.tag())?.id().to_string())
   }
 
@@ -218,13 +222,17 @@ impl Repo {
     match &self.vcs {
       GitVcsLevel::None { .. } => bail!("Can't get OID at `none`."),
       GitVcsLevel::Local { repo, .. } => {
-        verify_current(repo).chain_err(|| "Can't complete get.")?;
+        if !self.ignore_current {
+          verify_current(repo).chain_err(|| "Can't complete get.")?;
+        }
         get_oid_local(repo, spec)
       }
       GitVcsLevel::Remote { repo, branch_name, remote_name, fetches }
       | GitVcsLevel::Smart { repo, branch_name, remote_name, fetches } => {
         if spec == "HEAD" {
-          verify_current(repo).chain_err(|| "Can't complete get.")?;
+          if !self.ignore_current {
+            verify_current(repo).chain_err(|| "Can't complete HEAD get.")?;
+          }
           get_oid_local(repo, spec)
         } else {
           // get_oid_remote() will verify current
@@ -689,7 +697,7 @@ enum GitVcsLevel {
 
 impl GitVcsLevel {
   fn from(
-    level: VcsLevel, root: PathBuf, repo: Repository, branch_name: Option<String>, remote_name: String,
+    level: &VcsLevel, root: PathBuf, repo: Repository, branch_name: Option<String>, remote_name: String,
     fetches: RefCell<HashMap<String, Oid>>
   ) -> GitVcsLevel {
     match level {
@@ -801,8 +809,8 @@ fn find_branch_name(repo: &Repository) -> Result<Option<String>> {
     match head_ref.symbolic_target() {
       None => Ok(None),
       Some(branch_name) => {
-        if branch_name.starts_with("refs/heads/") {
-          Ok(Some(branch_name[11 ..].to_string()))
+        if let Some(bname_suff) = branch_name.strip_prefix("refs/heads/") {
+          Ok(Some(bname_suff.to_string()))
         } else {
           return err!("Current {} is not a branch.", branch_name);
         }
@@ -815,10 +823,10 @@ fn find_github_info(repo: &Repository, remote_name: &str, auth: &Auth) -> Result
   let remote = repo.find_remote(remote_name)?;
 
   let url = remote.url().ok_or_else(|| bad!("Invalid utf8 remote url."))?;
-  let path = if url.starts_with("https://github.com/") {
-    &url[19 ..]
-  } else if url.starts_with("git@github.com:") {
-    &url[15 ..]
+  let path = if let Some(url_suff) = url.strip_prefix("https://github.com/") {
+    url_suff
+  } else if let Some(url_suff) = url.strip_prefix("git@github.com:") {
+    url_suff
   } else {
     return err!("Can't find github in remote url {}", url);
   };
diff --git a/src/init.rs b/src/init.rs
index b5416c2..566ecc8 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -98,7 +98,7 @@ fn find_project(name: &OsStr, file: &Path) -> Result<Option<ProjSummary>> {
 
 fn add_gemspec(fname: &str, file: &Path) -> Result<Option<ProjSummary>> {
   let spec_suffix = ".gemspec";
-  if fname.ends_with(spec_suffix) {
+  if let Some(fname_pref) = fname.strip_suffix(spec_suffix) {
     let name_reg = r#"spec\.name *= *['"]([^'"]*)['"]"#;
     let version_reg = r#"spec\.version *= *(\S*)"#;
     let name = extract_name(file, |d| find_reg_data(&d, &name_reg))?;
@@ -116,7 +116,7 @@ fn add_gemspec(fname: &str, file: &Path) -> Result<Option<ProjSummary>> {
       return Ok(Some(ProjSummary::new_file(name, dirn, fname, "pattern", version_reg, &["gem"])));
     } else if vers.ends_with("::VERSION") {
       // But other times, the version is in the gem itself i.e. 'MyGem::VERSION'. Search the standard place.
-      let vers_file = Path::new("lib").join(&fname[.. fname.len() - spec_suffix.len()]).join("version.rb");
+      let vers_file = Path::new("lib").join(fname_pref).join("version.rb");
       if dir.join(&vers_file).exists() {
         let version_reg = r#"VERSION *= *['"](\d+\.\d+\.\d+)['"]"#;
         let vfn = vers_file.to_string_lossy();
@@ -148,7 +148,7 @@ fn generate_yaml(projs: &[ProjSummary]) -> String {
   let mut yaml = String::new();
   yaml.push_str("options:\n");
   yaml.push_str("  prev_tag: \"versio-prev\"\n");
-  yaml.push_str("\n");
+  yaml.push('\n');
 
   if !projs.is_empty() {
     yaml.push_str("projects:\n");
@@ -187,7 +187,7 @@ fn generate_yaml(projs: &[ProjSummary]) -> String {
     if proj.subs() {
       yaml.push_str("    subs: {}\n");
     }
-    yaml.push_str("\n");
+    yaml.push('\n');
   }
 
   yaml.push_str("sizes:\n");
diff --git a/src/mono.rs b/src/mono.rs
index 2252557..769a53d 100644
--- a/src/mono.rs
+++ b/src/mono.rs
@@ -7,7 +7,7 @@ use crate::errors::Result;
 use crate::git::{Auth, CommitInfoBuf, FromTag, FromTagBuf, FullPr, GithubInfo, Repo};
 use crate::github::{changes, line_commits_head, Changes};
 use crate::state::{CommitArgs, CurrentState, OldTags, PrevFiles, PrevTagMessage, StateRead, StateWrite};
-use crate::vcs::VcsLevel;
+use crate::vcs::VcsState;
 use chrono::{DateTime, FixedOffset};
 use error_chain::bail;
 use log::trace;
@@ -30,9 +30,9 @@ pub struct Mono {
 }
 
 impl Mono {
-  pub fn here(vcs: VcsLevel) -> Result<Mono> { Mono::open(".", vcs) }
+  pub fn here(vcs: VcsState) -> Result<Mono> { Mono::open(".", vcs) }
 
-  pub fn open<P: AsRef<Path>>(dir: P, vcs: VcsLevel) -> Result<Mono> {
+  pub fn open<P: AsRef<Path>>(dir: P, vcs: VcsState) -> Result<Mono> {
     let repo = Repo::open(dir.as_ref(), vcs)?;
     let root = repo.working_dir()?;
 
diff --git a/src/state.rs b/src/state.rs
index 1b239a6..e8334ec 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -339,9 +339,9 @@ impl PickPath {
   pub fn new(file: PathBuf, picker: Picker) -> PickPath { PickPath { file, picker } }
 
   pub fn write_value(&self, val: &str) -> Result<()> {
-    let data = std::fs::read_to_string(&self.file)?;
+    let data =
+      std::fs::read_to_string(&self.file).chain_err(|| format!("Can't read file {}.", self.file.to_string_lossy()))?;
     let data = NamedData::new(self.file.clone(), data);
-
     let mut mark = self.picker.scan(data)?;
     mark.write_new_value(val)?;
     Ok(())
@@ -349,7 +349,8 @@ impl PickPath {
 }
 
 pub fn read_from_slice<P: AsRef<Path>>(slice: &Slice, path: P) -> Result<String> {
-  let blob = slice.blob(&path.as_ref().to_string_lossy().to_string())?;
-  let cont: &str = std::str::from_utf8(blob.content())?;
+  let path = path.as_ref().to_string_lossy().to_string();
+  let blob = slice.blob(&path)?;
+  let cont: &str = std::str::from_utf8(blob.content()).chain_err(|| format!("Not UTF8: {}", path))?;
   Ok(cont.to_string())
 }
diff --git a/src/vcs.rs b/src/vcs.rs
index 04753b3..0dd9967 100644
--- a/src/vcs.rs
+++ b/src/vcs.rs
@@ -7,6 +7,18 @@ use log::debug;
 use std::cmp::{max, min};
 use std::str::FromStr;
 
+#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy, Debug)]
+pub struct VcsState {
+  level: VcsLevel,
+  ignore_current: bool
+}
+
+impl VcsState {
+  pub fn new(level: VcsLevel, ignore_current: bool) -> VcsState { VcsState { level, ignore_current } }
+  pub fn level(&self) -> &VcsLevel { &self.level }
+  pub fn ignore_current(&self) -> bool { self.ignore_current }
+}
+
 #[derive(Debug)]
 pub struct VcsRange {
   min: VcsLevel,
@@ -64,6 +76,12 @@ pub enum VcsLevel {
   Smart = 3
 }
 
+impl VcsLevel {
+  pub fn is_none(&self) -> bool { matches!(self, Self::None) }
+  pub fn is_local(&self) -> bool { matches!(self, Self::Local) }
+  pub fn is_network(&self) -> bool { matches!(self, Self::Remote | Self::Smart) }
+}
+
 impl FromStr for VcsLevel {
   type Err = crate::errors::Error;