fix(compile): implement abstract class traits across all types

Implement BaseCommand trait and other abstract class traits across
all command, downloader, io, package, and VCS driver types. Also
fix trait method signatures for composer_mut and io_mut to return
mutable references to Option rather than Option of mutable references.

3 files changed, 75 insertions, 8 deletions

diff --git a/crates/shirabe/src/package/archiver/base_exclude_filter.rs b/crates/shirabe/src/package/archiver/base_exclude_filter.rs
index 6522d79..c7d2557 100644
--- a/crates/shirabe/src/package/archiver/base_exclude_filter.rs
+++ b/crates/shirabe/src/package/archiver/base_exclude_filter.rs
@@ -3,6 +3,73 @@
 use shirabe_external_packages::composer::pcre::preg::Preg;
 use shirabe_external_packages::symfony::component::finder::glob::Glob;
 
+#[derive(Debug)]
+pub struct BaseExcludeFilterBase {
+    pub source_path: String,
+    pub exclude_patterns: Vec<(String, bool, bool)>,
+}
+
+impl BaseExcludeFilterBase {
+    pub fn new(source_path: String) -> Self {
+        Self {
+            source_path,
+            exclude_patterns: Vec::new(),
+        }
+    }
+
+    pub fn parse_lines<F>(&self, lines: Vec<String>, line_parser: F) -> Vec<(String, bool, bool)>
+    where
+        F: Fn(&str) -> Option<(String, bool, bool)>,
+    {
+        lines
+            .into_iter()
+            .filter_map(|line| {
+                let line = line.trim().to_string();
+                if line.is_empty() || line.starts_with('#') {
+                    return None;
+                }
+                line_parser(&line)
+            })
+            .collect()
+    }
+
+    pub fn generate_patterns(&self, rules: Vec<String>) -> Vec<(String, bool, bool)> {
+        rules
+            .into_iter()
+            .map(|rule| Self::generate_pattern(&rule))
+            .collect()
+    }
+
+    pub fn generate_pattern(rule: &str) -> (String, bool, bool) {
+        let mut negate = false;
+        let mut pattern = String::new();
+
+        let mut rule = rule.to_string();
+        if !rule.is_empty() && rule.starts_with('!') {
+            negate = true;
+            rule = rule.trim_start_matches('!').to_string();
+        }
+
+        let first_slash_position = rule.find('/');
+        if first_slash_position == Some(0) {
+            pattern = "^/".to_string();
+        } else if first_slash_position.is_none() || first_slash_position == Some(rule.len() - 1) {
+            pattern = "/".to_string();
+        }
+
+        let rule = rule.trim_matches('/');
+
+        let glob_regex = Glob::to_regex(rule);
+        let rule_regex = &glob_regex[2..glob_regex.len() - 2];
+
+        (
+            format!("{{{}{}(?=$|/)}}", pattern, rule_regex),
+            negate,
+            false,
+        )
+    }
+}
+
 pub trait BaseExcludeFilter {
     fn source_path(&self) -> &str;
     fn exclude_patterns(&self) -> &[(String, bool, bool)];
diff --git a/crates/shirabe/src/package/archiver/composer_exclude_filter.rs b/crates/shirabe/src/package/archiver/composer_exclude_filter.rs
index b9a32f4..979e67e 100644
--- a/crates/shirabe/src/package/archiver/composer_exclude_filter.rs
+++ b/crates/shirabe/src/package/archiver/composer_exclude_filter.rs
@@ -1,15 +1,15 @@
 //! ref: composer/src/Composer/Package/Archiver/ComposerExcludeFilter.php
 
-use super::base_exclude_filter::BaseExcludeFilter;
+use super::base_exclude_filter::BaseExcludeFilterBase;
 
 #[derive(Debug)]
 pub struct ComposerExcludeFilter {
-    inner: BaseExcludeFilter,
+    inner: BaseExcludeFilterBase,
 }
 
 impl ComposerExcludeFilter {
     pub fn new(source_path: String, exclude_rules: Vec<String>) -> Self {
-        let mut inner = BaseExcludeFilter::new(source_path);
+        let mut inner = BaseExcludeFilterBase::new(source_path);
         inner.exclude_patterns = inner.generate_patterns(exclude_rules);
         Self { inner }
     }
diff --git a/crates/shirabe/src/package/archiver/git_exclude_filter.rs b/crates/shirabe/src/package/archiver/git_exclude_filter.rs
index 8028c15..dddad12 100644
--- a/crates/shirabe/src/package/archiver/git_exclude_filter.rs
+++ b/crates/shirabe/src/package/archiver/git_exclude_filter.rs
@@ -1,16 +1,16 @@
 //! ref: composer/src/Composer/Package/Archiver/GitExcludeFilter.php
 
-use crate::package::archiver::base_exclude_filter::BaseExcludeFilter;
+use crate::package::archiver::base_exclude_filter::BaseExcludeFilterBase;
 use shirabe_external_packages::composer::pcre::preg::Preg;
 use std::path::Path;
 
 pub struct GitExcludeFilter {
-    inner: BaseExcludeFilter,
+    inner: BaseExcludeFilterBase,
 }
 
 impl GitExcludeFilter {
     pub fn new(source_path: String) -> Self {
-        let inner = BaseExcludeFilter::new(source_path.clone());
+        let inner = BaseExcludeFilterBase::new(source_path.clone());
         let mut filter = Self { inner };
 
         let gitattributes_path = format!("{}/.gitattributes", source_path);
@@ -37,11 +37,11 @@ impl GitExcludeFilter {
         let parts = Preg::split(r"\s+", line);
 
         if parts.len() == 2 && parts[1] == "export-ignore" {
-            return BaseExcludeFilter::generate_pattern(&parts[0]);
+            return Some(BaseExcludeFilterBase::generate_pattern(&parts[0]));
         }
 
         if parts.len() == 2 && parts[1] == "-export-ignore" {
-            return BaseExcludeFilter::generate_pattern(&format!("!{}", parts[0]));
+            return BaseExcludeFilterBase::generate_pattern(&format!("!{}", parts[0]));
         }
 
         None