frame for gix repo exclude query (#301)

README.md

@@ -48,6 +48,8 @@ Please see _'Development Status'_ for a listing of all crates and their capabili
     * **mailmap**
       * [x] **verify** - check entries of a mailmap file for parse errors and display them
     * **repository**
+      * **exclude**
+         * [x] **query** - check if path specs are excluded via gits exclusion rules like `.gitignore`.
       * **verify** - validate a whole repository, for now only the object database.
       * **commit**
          * [x] **describe** - identify a commit by its closest tag in its past

crate-status.md

@@ -436,7 +436,8 @@ See its [README.md](https://github.com/Byron/gitoxide/blob/main/git-lock/README.
   * **refs**
     * [ ] run transaction hooks and handle special repository states like quarantine
     * [ ] support for different backends like `files` and `reftable`
-  * [ ] worktrees
+  * **worktrees**
+    * [ ] open a repository with worktrees
   * [ ] remotes with push and pull
   * [x] mailmap   
   * [x] object replacements (`git replace`)

git-path/src/lib.rs

@@ -40,5 +40,19 @@
 //! Callers may `.expect()` on the result to indicate they don't wish to handle this special and rare case. Note that servers should not
 //! ever get into a code-path which does panic though.
 
+/// A dummy type to represent path specs and help finding all spots that take path specs once it is implemented.
+#[derive(Clone, Debug)]
+pub struct Spec(String);
+
+impl FromStr for Spec {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Spec(s.to_owned()))
+    }
+}
+
 mod convert;
+
 pub use convert::*;
+use std::str::FromStr;

gitoxide-core/src/repository/exclude.rs

@@ -0,0 +1,29 @@
+use anyhow::bail;
+use std::io;
+use std::path::PathBuf;
+
+use crate::OutputFormat;
+use git_repository as git;
+
+pub mod query {
+    use crate::OutputFormat;
+    use git_repository as git;
+
+    pub struct Options {
+        pub format: OutputFormat,
+        pub pathspecs: Vec<git::path::Spec>,
+    }
+}
+
+pub fn query(
+    repository: PathBuf,
+    mut out: impl io::Write,
+    query::Options { format, pathspecs }: query::Options,
+) -> anyhow::Result<()> {
+    if format != OutputFormat::Human {
+        bail!("JSON output isn't implemented yet");
+    }
+
+    let repo = git::open(repository)?.apply_environment();
+    todo!("impl");
+}

gitoxide-core/src/repository/mod.rs

@@ -16,3 +16,5 @@ pub mod verify;
 pub mod odb;
 
 pub mod mailmap;
+
+pub mod exclude;

src/plumbing/main.rs

@@ -191,6 +191,22 @@ pub fn main() -> Result<()> {
                     },
                 ),
             },
+            repo::Subcommands::Exclude { cmd } => match cmd {
+                repo::exclude::Subcommands::Query { pathspecs } => prepare_and_run(
+                    "repository-exclude-query",
+                    verbose,
+                    progress,
+                    progress_keep_open,
+                    None,
+                    move |_progress, out, _err| {
+                        core::repository::exclude::query(
+                            repository,
+                            out,
+                            core::repository::exclude::query::Options { format, pathspecs },
+                        )
+                    },
+                ),
+            },
             repo::Subcommands::Mailmap { cmd } => match cmd {
                 repo::mailmap::Subcommands::Entries => prepare_and_run(
                     "repository-mailmap-entries",

src/plumbing/options.rs

@@ -370,6 +370,24 @@ pub mod repo {
             #[clap(subcommand)]
             cmd: mailmap::Subcommands,
         },
+        /// Interact with the exclude files like .gitignore.
+        Exclude {
+            #[clap(subcommand)]
+            cmd: exclude::Subcommands,
+        },
+    }
+
+    pub mod exclude {
+        use git_repository as git;
+
+        #[derive(Debug, clap::Subcommand)]
+        pub enum Subcommands {
+            /// Check if path-specs are excluded and print the result similar to `git check-ignore`.
+            Query {
+                /// The git path specifications to check for exclusion.
+                pathspecs: Vec<git::path::Spec>,
+            },
+        }
     }
 
     pub mod mailmap {