feat: add some subcommands like enforce_ex() & disable semantic-release-action at forks (#6)

* feat: implement completion and enforceEx subcommand

* chore: cargo clippy

* feat: disable semantic-release-action at forks

Author: liulifox233

.github/workflows/release.yml

@@ -13,6 +13,7 @@ on:
 
 jobs:
   release:
+    if: github.repository == 'casbin-rs/casbin-rust-cli'
     uses: semantic-release-action/rust/.github/workflows/release-binary.yml@v5
     secrets:
       cargo-registry-token: ${{ secrets.CARGO_TOKEN }}

.gitignore

@@ -14,4 +14,6 @@ target/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+.vscode

Cargo.lock

@@ -12,7 +12,8 @@ repository = "https://github.com/casbin-rs/casbin-rust-cli"
 readme= "README.md"
 
 [dependencies]
-casbin = { version = "2.7.0", features = ["explain", "logging"] }
+casbin = { version = "2.8.0", features = ["explain", "logging"] }
 clap = { version = "4.5.27", features = ["derive"] }
-serde_json = "1.0.137"
+serde_json = "1.0.138"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread"] }
+clap_complete_command = "0.6.1"

Cargo.toml

@@ -1,84 +1,168 @@
 use casbin::prelude::*;
-use clap::Parser;
+use clap::{CommandFactory, Parser, Subcommand};
 use serde_json::json;
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Clone)]
 #[command(author, version, about, long_about)]
 struct Args {
     /// The command to execute
-    #[arg(value_enum)]
+    #[command(subcommand)]
     command: Cmd,
-
-    /// The path of the model file or model text
-    #[arg(short, long)]
-    model: String,
-
-    /// The path of the policy file or policy text
-    #[arg(short, long)]
-    policy: String,
-
-    /// The arguments for the enforcer
-    command_args: Vec<String>,
 }
 
-#[derive(Debug, Clone, clap::ValueEnum)]
+#[derive(Subcommand, Debug, Clone)]
 #[clap(rename_all = "camelCase")]
 pub enum Cmd {
+    /// Generate the autocompletion script for the specified shell
+    Completion {
+        /// The shell to generate the completions for
+        #[arg(value_enum)]
+        shell: clap_complete_command::Shell,
+    },
     /// Check permissions
-    Enforce,
-    // /// Check permissions and get which policy it is
-    // EnforceEx,
+    Enforce {
+        /// The path of the model file or model text
+        #[arg(short, long)]
+        model: String,
+
+        /// The path of the policy file or policy text
+        #[arg(short, long)]
+        policy: String,
+
+        /// The arguments for the enforcer
+        command_args: Vec<String>,
+    },
+    /// Check permissions and get which policy it is
+    EnforceEx {
+        /// The path of the model file or model text
+        #[arg(short, long)]
+        model: String,
+
+        /// The path of the policy file or policy text
+        #[arg(short, long)]
+        policy: String,
+
+        /// The arguments for the enforcer
+        command_args: Vec<String>,
+    },
 }
 
 #[tokio::main]
 async fn main() {
     let args = Args::parse();
 
-    let model = DefaultModel::from_file(args.model)
+    match args.command {
+        Cmd::Enforce {
+            model,
+            policy,
+            command_args,
+        } => {
+            let model = DefaultModel::from_file(model)
+                .await
+                .expect("failed to load model");
+            let adapter = FileAdapter::new(policy);
+
+            let e = Enforcer::new(model, adapter)
+                .await
+                .expect("failed to create enforcer");
+
+            let allow = e.enforce(command_args).expect("failed to enforce");
+
+            let response = json!({
+                "allow": allow,
+                "explain": Vec::<String>::new(),
+            });
+
+            println!("{}", response);
+        }
+        Cmd::EnforceEx {
+            model,
+            policy,
+            command_args,
+        } => {
+            let model = DefaultModel::from_file(model)
+                .await
+                .expect("failed to load model");
+            let adapter = FileAdapter::new(policy);
+
+            let e = Enforcer::new(model, adapter)
+                .await
+                .expect("failed to create enforcer");
+
+            let (allow, explain) = e.enforce_ex(command_args).expect("failed to enforce");
+
+            let response = json!({
+                "allow": allow,
+                "explain": explain.first().unwrap_or(&Vec::<String>::new()),
+            });
+
+            println!("{}", response);
+        }
+        Cmd::Completion { shell } => {
+            shell.generate(&mut Args::command(), &mut std::io::stdout());
+        }
+    };
+}
+
+#[tokio::test]
+async fn test_enforce() {
+    let model = DefaultModel::from_file("examples/basic_model.conf".to_owned())
         .await
         .expect("failed to load model");
-    let adapter = FileAdapter::new(args.policy);
+    let adapter = FileAdapter::new("examples/basic_policy.csv".to_owned());
 
     let e = Enforcer::new(model, adapter)
         .await
         .expect("failed to create enforcer");
-    let allow = e.enforce(args.command_args).expect("failed to enforce");
+
+    let allow = e
+        .enforce(vec![
+            "alice".to_owned(),
+            "data1".to_owned(),
+            "read".to_owned(),
+        ])
+        .expect("failed to enforce");
 
     let response = json!({
         "allow": allow,
         "explain": Vec::<String>::new(),
     });
 
-    println!("{}", response);
+    let expected = json!({
+        "allow": true,
+        "explain": [],
+    });
+
+    assert_eq!(response, expected);
 }
 
 #[tokio::test]
-async fn test_enforce() {
-    let args = Args {
-        command: Cmd::Enforce,
-        model: "examples/basic_model.conf".to_owned(),
-        policy: "examples/basic_policy.csv".to_owned(),
-        command_args: vec!["alice".to_owned(), "data1".to_owned(), "read".to_owned()],
-    };
-
-    let model = DefaultModel::from_file(args.model)
+async fn test_enforce_explain() {
+    let model = DefaultModel::from_file("examples/basic_model.conf".to_owned())
         .await
         .expect("failed to load model");
-    let adapter = FileAdapter::new(args.policy);
+    let adapter = FileAdapter::new("examples/basic_policy.csv".to_owned());
 
     let e = Enforcer::new(model, adapter)
         .await
         .expect("failed to create enforcer");
-    let allow = e.enforce(args.command_args).expect("failed to enforce");
+
+    let (allow, explain) = e
+        .enforce_ex(vec![
+            "alice".to_owned(),
+            "data1".to_owned(),
+            "read".to_owned(),
+        ])
+        .expect("failed to enforce");
 
     let response = json!({
         "allow": allow,
-        "explain": Vec::<String>::new(),
+        "explain": explain.first().unwrap_or(&Vec::<String>::new()),
     });
 
     let expected = json!({
         "allow": true,
-        "explain": [],
+        "explain": ["alice", "data1", "read"],
     });
 
     assert_eq!(response, expected);