Merge remote-tracking branch 'origin/dev'

.github/workflows/ci.yml

@@ -54,7 +54,7 @@ jobs:
           git config --global user.name 'github-actions[bot]'
           git config --global user.email 'github-actions[bot]@users.noreply.github.com'
           cargo build
-          cargo test --lib
+          cargo test
 
   inc:
     name: Increment version

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gitnu"
-version = "0.7.5"
+version = "0.7.6-alpha.6"
 authors = ["Nguyen Vu Khang <[email protected]>"]
 description = """
 gitnu indexes your git status so you can use numbers instead of filenames.
@@ -19,10 +19,6 @@ atty = "0.2.14"
 
 [[bin]]
 bench = false
-test = false
+doctest = false
 path = "src/main.rs"
 name = "git-nu"
-
-[lib]
-doctest = false
-test = false

Makefile

@@ -2,23 +2,21 @@ LOCAL_BIN=$(HOME)/.local/bin
 GITNU_RELEASE_BIN=$(PWD)/target/release/git-nu
 GITNU_DEBUG_BIN=$(PWD)/target/debug/git-nu
 
-ONE_TEST := 'tests::add_and_status_diff_dirs'
+ONE_TEST := 'tests::exit_codes'
+ONE_TEST := 'tests::git_add_untracked'
 
-current:
-	make test
-	# make test-one
+current: test
 
 install:
-	make build
-	make load-bin
+	cargo install --all-features --path . --locked --bins
 
 build:
 	cargo build --bin git-nu --release
 	@echo "Release build complete."
 
 test:
 	cargo build
-	cargo test --lib
+	cargo test
 
 test-one:
 	cargo build

src/cache.rs

@@ -1,10 +1,8 @@
-use crate::pathdiff;
 use crate::prelude::*;
 
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
 #[derive(Debug, Default)]
 pub struct Cache {
@@ -13,23 +11,25 @@ pub struct Cache {
 }
 
 impl Cache {
+    /// Initialize cache by reading the cache file in `git_dir`.
     pub fn new<P>(git_dir: &PathBuf, cwd: P) -> Self
     where
         P: AsRef<Path>,
     {
         Self::try_read(git_dir, cwd).unwrap_or_default()
     }
 
+    /// Try to read the cache file from `git_dir`.
     fn try_read<P>(git_dir: &PathBuf, cwd: P) -> Result<Self>
     where
         P: AsRef<Path>,
     {
-        let mut filepath = cwd.as_ref().to_path_buf();
-        filepath.push(git_dir);
-        filepath.push(CACHE_FILE_NAME);
+        let mut cache_path = cwd.as_ref().to_path_buf();
+        cache_path.push(git_dir);
+        cache_path.push(CACHE_FILE_NAME);
 
-        let file = File::open(filepath)?;
-        let mut lines = BufReader::new(file).lines().filter_map(|v| v.ok());
+        let f = File::open(cache_path)?;
+        let mut lines = BufReader::new(f).lines().filter_map(|v| v.ok());
 
         let prefix = {
             let first_line = lines.next().ok_or(Error::InvalidCache)?;
@@ -47,11 +47,14 @@ impl Cache {
         Ok(Self { prefix, files })
     }
 
-    pub fn load(&self, index: usize, cmd: &mut Command) {
+    /// Append the `index`-th cached value into an ArgHolder.
+    pub fn load<A: ArgHolder>(&self, index: usize, argh: &mut A) {
         match (&self.prefix, self.files.get(index)) {
-            (Some(prefix), Some(pathspec)) => cmd.arg(prefix.join(pathspec)),
-            (None, Some(pathspec)) => cmd.arg(pathspec),
-            _ => cmd.arg(index.to_string()),
+            (Some(prefix), Some(pathspec)) => {
+                argh.add_arg(prefix.join(pathspec))
+            }
+            (None, Some(pathspec)) => argh.add_arg(pathspec),
+            _ => argh.add_arg(index.to_string()),
         };
     }
 }

src/error.rs

@@ -0,0 +1,45 @@
+use std::any::Any;
+use std::io;
+
+#[derive(Debug)]
+pub enum Error {
+    InvalidCache,
+    NotGitCommand,
+    NotGitRepository,
+    NotImplemented,
+    Io(io::Error),
+    ThreadError(Box<dyn Any + Send + 'static>),
+}
+
+impl PartialEq for Error {
+    fn eq(&self, rhs: &Error) -> bool {
+        let lhs = self;
+        use Error::*;
+        match (lhs, rhs) {
+            (NotGitRepository, NotGitRepository) => true,
+            (NotImplemented, NotImplemented) => true,
+            (InvalidCache, InvalidCache) => true,
+            (NotGitCommand, NotGitCommand) => true,
+            (Io(lhs), Io(rhs)) => lhs.kind() == rhs.kind(),
+            (ThreadError(_), ThreadError(_)) => true,
+            _ => false,
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! error {
+    ($enum:ident, $from:ty) => {
+        impl From<$from> for Error {
+            fn from(err: $from) -> Self {
+                Self::$enum(err)
+            }
+        }
+    };
+    ($enum:ident) => {
+        Err(Error::$enum)
+    };
+}
+
+error!(Io, io::Error);
+error!(ThreadError, Box<dyn Any + Send + 'static>);