chore: cargo clippy --fix

8 files changed, 256 insertions, 242 deletions

diff --git a/crates/shirabe-external-packages/src/composer/ca_bundle/ca_bundle.rs b/crates/shirabe-external-packages/src/composer/ca_bundle/ca_bundle.rs
index 4a980c6..a0db297 100644
--- a/crates/shirabe-external-packages/src/composer/ca_bundle/ca_bundle.rs
+++ b/crates/shirabe-external-packages/src/composer/ca_bundle/ca_bundle.rs
@@ -8,11 +8,11 @@ impl CaBundle {
         todo!()
     }
 
-    pub fn get_system_ca_root_bundle_path(logger: Option<&dyn LoggerInterface>) -> String {
+    pub fn get_system_ca_root_bundle_path(_logger: Option<&dyn LoggerInterface>) -> String {
         todo!()
     }
 
-    pub fn validate_ca_file(ca_file: &str, logger: Option<&dyn LoggerInterface>) -> bool {
+    pub fn validate_ca_file(_ca_file: &str, _logger: Option<&dyn LoggerInterface>) -> bool {
         todo!()
     }
 
diff --git a/crates/shirabe-external-packages/src/composer/metadata_minifier/metadata_minifier.rs b/crates/shirabe-external-packages/src/composer/metadata_minifier/metadata_minifier.rs
index f886197..8861936 100644
--- a/crates/shirabe-external-packages/src/composer/metadata_minifier/metadata_minifier.rs
+++ b/crates/shirabe-external-packages/src/composer/metadata_minifier/metadata_minifier.rs
@@ -5,11 +5,11 @@ use shirabe_php_shim::PhpMixed;
 pub struct MetadataMinifier;
 
 impl MetadataMinifier {
-    pub fn expand(minified_data: IndexMap<String, PhpMixed>) -> IndexMap<String, PhpMixed> {
+    pub fn expand(_minified_data: IndexMap<String, PhpMixed>) -> IndexMap<String, PhpMixed> {
         todo!()
     }
 
-    pub fn minify(packages: IndexMap<String, PhpMixed>) -> IndexMap<String, PhpMixed> {
+    pub fn minify(_packages: IndexMap<String, PhpMixed>) -> IndexMap<String, PhpMixed> {
         todo!()
     }
 }
diff --git a/crates/shirabe-external-packages/src/composer/pcre/preg.rs b/crates/shirabe-external-packages/src/composer/pcre/preg.rs
index 3dd8b4f..9c39d42 100644
--- a/crates/shirabe-external-packages/src/composer/pcre/preg.rs
+++ b/crates/shirabe-external-packages/src/composer/pcre/preg.rs
@@ -2,518 +2,518 @@
 pub struct Preg;
 
 impl Preg {
-    pub fn r#match(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn r#match(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn match_strict_groups(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn match_strict_groups(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_strict_groups3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_strict_groups4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_strict_groups5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn match_with_offsets(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn match_with_offsets(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_with_offsets3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_with_offsets4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn match_with_offsets5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn match_all(pattern: &str, subject: &str) -> anyhow::Result<usize> {
+    pub fn match_all(_pattern: &str, _subject: &str) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
-    pub fn match_all_strict_groups(pattern: &str, subject: &str) -> anyhow::Result<usize> {
+    pub fn match_all_strict_groups(_pattern: &str, _subject: &str) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_strict_groups3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_strict_groups4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_strict_groups5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
-    pub fn match_all_with_offsets(pattern: &str, subject: &str) -> anyhow::Result<usize> {
+    pub fn match_all_with_offsets(_pattern: &str, _subject: &str) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_with_offsets3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_with_offsets4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _flags: i64,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
     pub fn match_all_with_offsets5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<usize> {
         todo!()
     }
 
-    pub fn replace(pattern: &str, replacement: &str, subject: &str) -> anyhow::Result<String> {
+    pub fn replace(_pattern: &str, _replacement: &str, _subject: &str) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace4(
-        pattern: &str,
-        replacement: &str,
-        subject: &str,
-        limit: i64,
+        _pattern: &str,
+        _replacement: &str,
+        _subject: &str,
+        _limit: i64,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace5(
-        pattern: &str,
-        replacement: &str,
-        subject: &str,
-        limit: i64,
-        count: &mut usize,
+        _pattern: &str,
+        _replacement: &str,
+        _subject: &str,
+        _limit: i64,
+        _count: &mut usize,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback<F: Fn(&indexmap::IndexMap<CaptureKey, String>) -> String>(
-        pattern: &str,
-        replacement: F,
-        subject: &str,
+        _pattern: &str,
+        _replacement: F,
+        _subject: &str,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback4<F: Fn(&indexmap::IndexMap<CaptureKey, String>) -> String>(
-        pattern: &str,
-        replacement: F,
-        subject: &str,
-        limit: i64,
+        _pattern: &str,
+        _replacement: F,
+        _subject: &str,
+        _limit: i64,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback5<F: Fn(&indexmap::IndexMap<CaptureKey, String>) -> String>(
-        pattern: &str,
-        replacement: F,
-        subject: &str,
-        limit: i64,
-        count: &mut usize,
+        _pattern: &str,
+        _replacement: F,
+        _subject: &str,
+        _limit: i64,
+        _count: &mut usize,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback6<F: Fn(&indexmap::IndexMap<CaptureKey, String>) -> String>(
-        pattern: &str,
-        replacement: F,
-        subject: &str,
-        limit: i64,
-        count: Option<&mut usize>,
-        flags: i64,
+        _pattern: &str,
+        _replacement: F,
+        _subject: &str,
+        _limit: i64,
+        _count: Option<&mut usize>,
+        _flags: i64,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback_array(
-        pattern: &indexmap::IndexMap<String, String>,
-        subject: &str,
+        _pattern: &indexmap::IndexMap<String, String>,
+        _subject: &str,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback_array3(
-        pattern: &indexmap::IndexMap<String, String>,
-        subject: &str,
-        limit: i64,
+        _pattern: &indexmap::IndexMap<String, String>,
+        _subject: &str,
+        _limit: i64,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback_array4(
-        pattern: &indexmap::IndexMap<String, String>,
-        subject: &str,
-        limit: i64,
-        count: &mut usize,
+        _pattern: &indexmap::IndexMap<String, String>,
+        _subject: &str,
+        _limit: i64,
+        _count: &mut usize,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
     pub fn replace_callback_array5(
-        pattern: &indexmap::IndexMap<String, String>,
-        subject: &str,
-        limit: i64,
-        count: Option<&mut usize>,
-        flags: i64,
+        _pattern: &indexmap::IndexMap<String, String>,
+        _subject: &str,
+        _limit: i64,
+        _count: Option<&mut usize>,
+        _flags: i64,
     ) -> anyhow::Result<String> {
         todo!()
     }
 
-    pub fn split(pattern: &str, subject: &str) -> anyhow::Result<Vec<String>> {
+    pub fn split(_pattern: &str, _subject: &str) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
-    pub fn split3(pattern: &str, subject: &str, limit: i64) -> anyhow::Result<Vec<String>> {
+    pub fn split3(_pattern: &str, _subject: &str, _limit: i64) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
     pub fn split4(
-        pattern: &str,
-        subject: &str,
-        limit: i64,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _limit: i64,
+        _flags: i64,
     ) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
     pub fn split_with_offsets(
-        pattern: &str,
-        subject: &str,
+        _pattern: &str,
+        _subject: &str,
     ) -> anyhow::Result<Vec<(String, usize)>> {
         todo!()
     }
 
     pub fn split_with_offsets3(
-        pattern: &str,
-        subject: &str,
-        limit: i64,
+        _pattern: &str,
+        _subject: &str,
+        _limit: i64,
     ) -> anyhow::Result<Vec<(String, usize)>> {
         todo!()
     }
 
     pub fn split_with_offsets4(
-        pattern: &str,
-        subject: &str,
-        limit: i64,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _limit: i64,
+        _flags: i64,
     ) -> anyhow::Result<Vec<(String, usize)>> {
         todo!()
     }
 
-    pub fn grep(pattern: &str, array: &[&str]) -> anyhow::Result<Vec<String>> {
+    pub fn grep(_pattern: &str, _array: &[&str]) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
-    pub fn grep3(pattern: &str, array: &[&str], flags: i64) -> anyhow::Result<Vec<String>> {
+    pub fn grep3(_pattern: &str, _array: &[&str], _flags: i64) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
-    pub fn is_match(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn is_match_strict_groups(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match_strict_groups(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_strict_groups3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_strict_groups4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_strict_groups5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, String>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn is_match_with_offsets(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match_with_offsets(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_with_offsets3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_with_offsets4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_with_offsets5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, (String, usize)>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn is_match_all(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match_all(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn is_match_all_strict_groups(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match_all_strict_groups(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_strict_groups3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_strict_groups4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_strict_groups5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<String>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn is_match_all_with_offsets(pattern: &str, subject: &str) -> anyhow::Result<bool> {
+    pub fn is_match_all_with_offsets(_pattern: &str, _subject: &str) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_with_offsets3(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_with_offsets4(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
-        flags: i64,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _flags: i64,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
     pub fn is_match_all_with_offsets5(
-        pattern: &str,
-        subject: &str,
-        matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
-        flags: i64,
-        offset: usize,
+        _pattern: &str,
+        _subject: &str,
+        _matches: Option<&mut indexmap::IndexMap<CaptureKey, Vec<(String, usize)>>>,
+        _flags: i64,
+        _offset: usize,
     ) -> anyhow::Result<bool> {
         todo!()
     }
diff --git a/crates/shirabe-external-packages/src/composer/semver/compiling_matcher.rs b/crates/shirabe-external-packages/src/composer/semver/compiling_matcher.rs
index dea5475..5a8f09d 100644
--- a/crates/shirabe-external-packages/src/composer/semver/compiling_matcher.rs
+++ b/crates/shirabe-external-packages/src/composer/semver/compiling_matcher.rs
@@ -1,18 +1,16 @@
-use shirabe_php_shim::PhpMixed;
-
 #[derive(Debug)]
 pub struct CompilingMatcher;
 
 impl CompilingMatcher {
-    pub fn r#match(constraint: &dyn std::any::Any, package: &dyn std::any::Any) -> bool {
+    pub fn r#match(_constraint: &dyn std::any::Any, _package: &dyn std::any::Any) -> bool {
         todo!()
     }
 
-    pub fn matches(constraint: &dyn std::any::Any, operator: &str, version: &str) -> bool {
+    pub fn matches(_constraint: &dyn std::any::Any, _operator: &str, _version: &str) -> bool {
         todo!()
     }
 
-    pub fn match_(constraint: &dyn std::any::Any, operator: &str, version: &str) -> bool {
+    pub fn match_(_constraint: &dyn std::any::Any, _operator: &str, _version: &str) -> bool {
         todo!()
     }
 
diff --git a/crates/shirabe-external-packages/src/composer/semver/intervals.rs b/crates/shirabe-external-packages/src/composer/semver/intervals.rs
index 957436d..d0a736c 100644
--- a/crates/shirabe-external-packages/src/composer/semver/intervals.rs
+++ b/crates/shirabe-external-packages/src/composer/semver/intervals.rs
@@ -5,21 +5,21 @@ pub struct Intervals;
 
 impl Intervals {
     pub fn is_subset_of(
-        constraint_a: &dyn std::any::Any,
-        constraint_b: &dyn std::any::Any,
+        _constraint_a: &dyn std::any::Any,
+        _constraint_b: &dyn std::any::Any,
     ) -> anyhow::Result<bool> {
         todo!()
     }
 
-    pub fn compact_constraint(constraint: &dyn std::any::Any) -> Box<dyn std::any::Any> {
+    pub fn compact_constraint(_constraint: &dyn std::any::Any) -> Box<dyn std::any::Any> {
         todo!()
     }
 
-    pub fn compact(constraint: &dyn std::any::Any) -> Box<dyn std::any::Any> {
+    pub fn compact(_constraint: &dyn std::any::Any) -> Box<dyn std::any::Any> {
         todo!()
     }
 
-    pub fn get(constraint: &dyn std::any::Any) -> anyhow::Result<PhpMixed> {
+    pub fn get(_constraint: &dyn std::any::Any) -> anyhow::Result<PhpMixed> {
         todo!()
     }
 
diff --git a/crates/shirabe-external-packages/src/composer/semver/semver.rs b/crates/shirabe-external-packages/src/composer/semver/semver.rs
index f467c2c..fe370d8 100644
--- a/crates/shirabe-external-packages/src/composer/semver/semver.rs
+++ b/crates/shirabe-external-packages/src/composer/semver/semver.rs
@@ -2,15 +2,15 @@
 pub struct Semver;
 
 impl Semver {
-    pub fn sort(versions: Vec<String>) -> anyhow::Result<Vec<String>> {
+    pub fn sort(_versions: Vec<String>) -> anyhow::Result<Vec<String>> {
         todo!()
     }
 
-    pub fn rsort(versions: Vec<String>) -> Vec<String> {
+    pub fn rsort(_versions: Vec<String>) -> Vec<String> {
         todo!()
     }
 
-    pub fn satisfies(version: &str, constraint: &str) -> bool {
+    pub fn satisfies(_version: &str, _constraint: &str) -> bool {
         todo!()
     }
 }
diff --git a/crates/shirabe-external-packages/src/composer/spdx_licenses/spdx_licenses.rs b/crates/shirabe-external-packages/src/composer/spdx_licenses/spdx_licenses.rs
index 95640c9..684e73b 100644
--- a/crates/shirabe-external-packages/src/composer/spdx_licenses/spdx_licenses.rs
+++ b/crates/shirabe-external-packages/src/composer/spdx_licenses/spdx_licenses.rs
@@ -3,16 +3,22 @@ use shirabe_php_shim::PhpMixed;
 #[derive(Debug)]
 pub struct SpdxLicenses;
 
+impl Default for SpdxLicenses {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl SpdxLicenses {
     pub fn new() -> Self {
         todo!()
     }
 
-    pub fn validate(&self, license: &str) -> bool {
+    pub fn validate(&self, _license: &str) -> bool {
         todo!()
     }
 
-    pub fn get_license_by_identifier(&self, identifier: &str) -> Option<PhpMixed> {
+    pub fn get_license_by_identifier(&self, _identifier: &str) -> Option<PhpMixed> {
         todo!()
     }
 
diff --git a/crates/shirabe-external-packages/src/composer/util/composer_mirror.rs b/crates/shirabe-external-packages/src/composer/util/composer_mirror.rs
index 21d0fdf..66e363c 100644
--- a/crates/shirabe-external-packages/src/composer/util/composer_mirror.rs
+++ b/crates/shirabe-external-packages/src/composer/util/composer_mirror.rs
@@ -3,21 +3,31 @@ pub struct ComposerMirror;
 
 impl ComposerMirror {
     pub fn process_url(
-        mirror: &str,
-        package_name: &str,
-        version: &str,
-        reference: Option<&str>,
-        url: &str,
-        custom_filename: Option<&str>,
+        _mirror: &str,
+        _package_name: &str,
+        _version: &str,
+        _reference: Option<&str>,
+        _url: &str,
+        _custom_filename: Option<&str>,
     ) -> String {
         todo!()
     }
 
-    pub fn process_git_url(mirror: &str, package_name: &str, url: &str, extension: &str) -> String {
+    pub fn process_git_url(
+        _mirror: &str,
+        _package_name: &str,
+        _url: &str,
+        _extension: &str,
+    ) -> String {
         todo!()
     }
 
-    pub fn process_hg_url(mirror: &str, package_name: &str, url: &str, extension: &str) -> String {
+    pub fn process_hg_url(
+        _mirror: &str,
+        _package_name: &str,
+        _url: &str,
+        _extension: &str,
+    ) -> String {
         todo!()
     }
 }