Add clippy cfg to simple-sample

Author: pollenjp

Diff for: examples/simple-sample/Cargo.toml

@@ -14,3 +14,43 @@ cdkam_ansible.path = "../cdkam_ansible"
 anyhow.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+
+[lints.clippy]
+
+# category
+#
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+restriction = { level = "warn", priority = -1 }
+# cargo = "warn"
+
+# style
+#
+get_first = "allow"
+
+# nursery
+#
+branches_sharing_code = "allow"
+
+# restriction
+#
+# https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
+blanket_clippy_restriction_lints = "allow"
+absolute_paths = "allow"
+arbitrary_source_item_ordering = "allow"
+dbg_macro = "allow"
+implicit_return = "allow"
+min_ident_chars = "allow"
+missing_docs_in_private_items = "allow"
+missing-errors-doc = "allow"
+mod_module_files = "allow"
+# FIXME: later
+print_stdout = "allow"
+pub_with_shorthand = "allow"
+question_mark_used = "allow"
+self_named_module_files = "allow"
+shadow_reuse = "allow"
+shadow_same = "allow"
+shadow_unrelated = "allow"
+single_call_fn = "allow"
+single_char_lifetime_names = "allow"

Diff for: examples/simple-sample/src/inventory/mod.rs

@@ -1,11 +1,5 @@
 use anyhow::{bail, Result};
 use cdk_ansible::{Child, Inventory, InventoryRoot, OptU};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum HostName {
-    HostA,
-}
-
 use cdk_ansible_macro::FieldCount;
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, FieldCount)]
@@ -25,18 +19,18 @@ impl Hosts {
     ///
     pub fn to_inventory(&self) -> Result<Inventory> {
         let debian_ansible_python_interpreter_tuple = (
-            "ansible_python_interpreter".to_string(),
-            serde_json::Value::String("/usr/bin/python3".to_string()),
+            "ansible_python_interpreter".to_owned(),
+            serde_json::Value::String("/usr/bin/python3".to_owned()),
         );
         let inventory = Inventory {
-            name: "inventory".to_string(),
+            name: "inventory".to_owned(),
             root: InventoryRoot {
                 all: Child {
                     hosts: OptU::Some(
                         vec![(
                             self.host_a.fqdn.clone(),
                             Some(
-                                vec![debian_ansible_python_interpreter_tuple.clone()]
+                                vec![debian_ansible_python_interpreter_tuple]
                                     .into_iter()
                                     .collect::<serde_json::Map<String, serde_json::Value>>(),
                             ),
@@ -50,14 +44,12 @@ impl Hosts {
             },
         };
 
-        let hosts = if let OptU::Some(hosts) = &inventory.root.all.hosts {
-            hosts.clone()
-        } else {
+        let OptU::Some(hosts) = inventory.root.all.hosts.clone() else {
             bail!("hosts is not set");
         };
 
         // Validate: count Hosts' attributes
-        if Hosts::field_count() != hosts.len() {
+        if hosts.len() == Self::field_count() {
             bail!("Some hosts are not set");
         }
 
@@ -71,10 +63,11 @@ pub struct HostA {
     pub fqdn: String,
 }
 
+#[expect(clippy::unnecessary_wraps, reason = "use anyhow::Result interface")]
 pub fn get_hosts() -> Result<Hosts> {
     Ok(Hosts {
         host_a: {
-            let name = "host-a".to_string();
+            let name = "host-a".to_owned();
             HostA {
                 name: name.clone(),
                 fqdn: format!("{}.example.com", &name),

Diff for: examples/simple-sample/src/lib.rs

@@ -1,16 +1,49 @@
+use anyhow::Result;
 use cdk_ansible::settings;
+use cdk_ansible::{run, settings::SynthSettings, Synthesizer};
+use cdk_ansible::{Inventory, Playbook};
 
-pub mod inventory;
-pub mod playbooks;
+mod inventory;
+mod playbooks;
 
-pub trait PlaybookGenArgs {
+use inventory::get_hosts;
+use playbooks::generate_all;
+
+#[inline]
+pub fn main() -> Result<()> {
+    run(std::env::args_os(), CustomSynthesizer {})?;
+    Ok(())
+}
+
+struct CustomSynthesizer;
+
+impl Synthesizer for CustomSynthesizer {
+    fn synth_playbooks(&self, args: &SynthSettings) -> Result<Vec<Playbook>> {
+        let playbooks = generate_all(&PlaybookSynthConfig {
+            synth_settings: args.clone(),
+            hosts: get_hosts()?,
+        })?;
+        Ok(playbooks)
+    }
+
+    fn synth_inventory(&self, args: &SynthSettings) -> Result<Inventory> {
+        dbg!(&args); // FIXME: remove this
+        let hosts = get_hosts()?;
+        let inventory = hosts.to_inventory()?;
+        Ok(inventory)
+    }
+}
+
+trait PlaybookGenArgs {
+    #[expect(dead_code, reason = "not used yet")]
     fn get_synth_settings(&self) -> &settings::SynthSettings;
     fn get_hosts(&self) -> &inventory::Hosts;
 }
 
 /// A simple struct to implement [`PlaybookGenArgs`]
 #[derive(Debug, Clone)]
-pub struct PlaybookSynthConfig {
+struct PlaybookSynthConfig {
+    #[expect(dead_code, reason = "not used yet")]
     pub synth_settings: settings::SynthSettings,
     pub hosts: inventory::Hosts,
 }

Diff for: examples/simple-sample/src/main.rs

@@ -1,31 +1,6 @@
 use anyhow::Result;
-use cdk_ansible::{run, settings::SynthSettings, Synthesizer};
-use cdk_ansible::{Inventory, Playbook};
-use simple_sample::inventory::get_hosts;
-use simple_sample::playbooks::generate_all_playbooks;
-use simple_sample::PlaybookSynthConfig;
-
-struct CustomSynthesizer {}
-
-impl Synthesizer for CustomSynthesizer {
-    fn synth_playbooks(&self, synth_settings: &SynthSettings) -> Result<Vec<Playbook>> {
-        let playbook_gen_config = PlaybookSynthConfig {
-            synth_settings: synth_settings.clone(),
-            hosts: get_hosts()?,
-        };
-        let playbooks = generate_all_playbooks(&playbook_gen_config)?;
-        Ok(playbooks)
-    }
-
-    fn synth_inventory(&self, synth_settings: &SynthSettings) -> Result<Inventory> {
-        dbg!(&synth_settings);
-        let hosts = get_hosts()?;
-        let inventory = hosts.to_inventory()?;
-        Ok(inventory)
-    }
-}
+use simple_sample::main as simple_sample_main;
 
 fn main() -> Result<()> {
-    run(std::env::args_os(), CustomSynthesizer {})?;
-    Ok(())
+    simple_sample_main()
 }

Diff for: examples/simple-sample/src/playbooks/mod.rs

@@ -7,7 +7,7 @@ mod playbook2;
 use crate::PlaybookGenArgs;
 
 /// Generate all playbooks and return them
-pub fn generate_all_playbooks(args: &impl PlaybookGenArgs) -> Result<Vec<Playbook>> {
+pub fn generate_all<T: PlaybookGenArgs>(args: &T) -> Result<Vec<Playbook>> {
     let playbooks = vec![playbook1::playbook1(args)?, playbook2::playbook2(args)?];
 
     // validate playbook names are unique
@@ -37,15 +37,18 @@ mod test {
     fn test_validate_playbook_names() {
         let playbooks = vec![
             Playbook {
-                name: "playbook".to_string(),
+                name: "playbook".to_owned(),
                 plays: vec![],
             },
             Playbook {
-                name: "playbook".to_string(),
+                name: "playbook".to_owned(),
                 plays: vec![],
             },
         ];
-        let err = validate_playbook_names(&playbooks).unwrap_err();
-        assert_eq!(err.to_string(), "Playbook names are not unique");
+        #[expect(clippy::unreachable, reason = "should be an error")]
+        match validate_playbook_names(&playbooks) {
+            Ok(()) => unreachable!("should be an error"),
+            Err(e) => assert_eq!(e.to_string(), "Playbook names are not unique"),
+        }
     }
 }

Diff for: examples/simple-sample/src/playbooks/playbook1.rs

@@ -3,36 +3,33 @@ use cdk_ansible::{OptU, Play, PlayOptions, Playbook, Task, TaskOptions};
 
 use crate::playbooks::PlaybookGenArgs;
 
-pub fn playbook1(args: &impl PlaybookGenArgs) -> Result<Playbook> {
+#[expect(clippy::unnecessary_wraps, reason = "use anyhow::Result interface")]
+pub fn playbook1<T: PlaybookGenArgs>(args: &T) -> Result<Playbook> {
     Ok(Playbook {
         // Save as `playbook1.json`
-        name: "playbook1".to_string(),
+        name: "playbook1".to_owned(),
         plays: vec![Play {
-            name: "Debug".to_string(),
+            name: "Debug".to_owned(),
             hosts: vec![args.get_hosts().host_a.fqdn.clone()],
             tasks: vec![
                 Task {
-                    name: "Debug msg".to_string(),
-                    options: TaskOptions {
-                        ..Default::default()
-                    },
+                    name: "Debug msg".to_owned(),
+                    options: TaskOptions::default(),
                     command: Box::new(cdkam_ansible::builtin::debug::Module {
                         module: cdkam_ansible::builtin::debug::Args {
                             options: cdkam_ansible::builtin::debug::Opt {
-                                msg: OptU::Some("msg".to_string()),
+                                msg: OptU::Some("msg".to_owned()),
                                 ..Default::default()
                             },
                         },
                     }),
                 },
                 Task {
-                    name: "No options' module".to_string(),
-                    options: TaskOptions {
-                        ..Default::default()
-                    },
+                    name: "No options' module".to_owned(),
+                    options: TaskOptions::default(),
                     command: Box::new(cdkam_ansible::builtin::service_facts::Module {
                         module: cdkam_ansible::builtin::service_facts::Args {
-                            options: Default::default(),
+                            options: cdkam_ansible::builtin::service_facts::Opt::default(),
                         },
                     }),
                 },

Diff for: examples/simple-sample/src/playbooks/playbook2.rs

@@ -1,24 +1,22 @@
+use crate::playbooks::PlaybookGenArgs;
 use anyhow::Result;
 use cdk_ansible::{OptU, Play, PlayOptions, Playbook, Task, TaskOptions};
 
-use crate::playbooks::PlaybookGenArgs;
-
-pub fn playbook2(args: &impl PlaybookGenArgs) -> Result<Playbook> {
+#[expect(clippy::unnecessary_wraps, reason = "use anyhow::Result interface")]
+pub fn playbook2<T: PlaybookGenArgs>(args: &T) -> Result<Playbook> {
     Ok(Playbook {
         // Save as `playbook2.json`
-        name: "playbook2".to_string(),
+        name: "playbook2".to_owned(),
         plays: vec![Play {
-            name: "Debug".to_string(),
+            name: "Debug".to_owned(),
             hosts: vec![args.get_hosts().host_a.fqdn.clone()],
             tasks: vec![Task {
-                name: "Debug msg".to_string(),
-                options: TaskOptions {
-                    ..Default::default()
-                },
+                name: "Debug msg".to_owned(),
+                options: TaskOptions::default(),
                 command: Box::new(cdkam_ansible::builtin::debug::Module {
                     module: cdkam_ansible::builtin::debug::Args {
                         options: cdkam_ansible::builtin::debug::Opt {
-                            msg: OptU::Some("msg".to_string()),
+                            msg: OptU::Some("msg".to_owned()),
                             ..Default::default()
                         },
                     },