release: 0.2.0 (#8)

* feat: remove ; and & separators

* doc: update document

* chore: fix clippy errors

* chore: use Cargo instead of cargo

* chore: update CHANGELOG

Author: guuzaa

CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.2.0] - 2025-03-08
+
+### Changed
+- Simplified command parsing by removing `;` and `&` separators
+- Commands are now only separated by spaces 
+- For commands with arguments, you need to quote the entire command
+- Updated documentation to reflect the new simplified syntax
+- Removed dependent execution strategy (previously used with `&` separator)
+- Improved parser to directly use parsed CLI arguments instead of re-parsing a command string
+
+### Fixed
+- Improved handling of commands with arguments
+
+## [0.1.6] - 2025-03-07
+
+### Added
+- Initial release
+- Support for running multiple commands sequentially or in parallel
+- Support for different separators (space, `;`, `&`)
+- Verbose mode for detailed output 

Cargo.lock

@@ -1,8 +1,8 @@
 [package]
 name = "cargo-q"
-version = "0.1.6"
+version = "0.2.0"
 edition = "2021"
-description = "A cargo subcommand for running multiple cargo commands in a time"
+description = "A Cargo subcommand for running multiple Cargo commands sequentially or in parallel."
 keywords = ["cargo", "subcommand", "plugin"]
 categories = ["command-line-utilities", "development-tools::cargo-plugins"]
 license = "Apache-2.0"

Cargo.toml

@@ -1,6 +1,6 @@
 # cargo-q
 
-A Cargo subcommand that allows running multiple Cargo commands in a time.
+A Cargo subcommand for running multiple Cargo commands sequentially or in parallel.
 
 ## Installation
 
@@ -11,11 +11,8 @@ cargo install cargo-q
 ## Features
 
 - Run multiple Cargo commands sequentially
-- Use different separators for command execution:
-  - Space: Run commands sequentially (independent execution)
-  - `;`: Run independent commands sequentially
-  - `&`: Run commands with dependencies (each command depends on previous command's success)
-- Support parallel execution for independent commands
+- Commands are separated by spaces
+- Support parallel execution for commands
 - Verbose mode for detailed output
 
 ## Usage
@@ -28,39 +25,32 @@ cargo q check
 
 ### Run Multiple Commands
 
-#### Sequential Execution (Space Separator)
 ```bash
-# Run commands sequentially and independently
-cargo q "check test"      # Runs check, then test
-cargo q 'check test'      # Single and double quotes both work
+# Run commands sequentially
+cargo q check test      # Runs check, then test
 ```
 
-#### Independent Commands (`;` Separator)
-```bash
-# Run commands sequentially and independently
-cargo q "test --features feature1 ; run"  # Commands with parameters need ; separator
-```
+### Commands with Arguments
 
-#### Dependent Commands (`&` Separator)
 ```bash
-# Run commands with explicit dependencies
-cargo q "check & test & run"  # Each command runs only if previous command succeeds
-cargo q "check&test&run"      # Spaces around & are optional
+# For commands with arguments
+cargo q "test --no-run"   # Run test with --no-run flag
+cargo q "test --features feature1"  # Use quotes for complex arguments
 ```
 
 ### Parallel Execution
 
 ```bash
-# Run independent commands in parallel
-cargo q -p "build -r; build"      # Run both commands in parallel
-cargo q --parallel "check; test"   # Same as above
+# Run commands in parallel
+cargo q -p check test      # Run both commands in parallel
+cargo q --parallel check test   # Same as above
 ```
 
 ### Verbose Output
 
 ```bash
-cargo q -v "check test"       # Show detailed output
-cargo q --verbose "check test"  # Same as above
+cargo q -v check test       # Show detailed output
+cargo q --verbose check test  # Same as above
 ```
 
 ## License

README.md

@@ -8,14 +8,15 @@ use clap::Parser;
 pub struct Cli {
     /// Commands to execute
     ///
-    /// Supports multiple separators:
+    /// Commands are separated by spaces:
     ///
-    ///   space: Independent commands (e.g., "check test")
+    ///   e.g., check test run
     ///
-    ///   ;    : Independent commands with args (e.g., "test --features f1 ; run")
+    /// Note: For commands with arguments, you need to quote the entire command:
     ///
-    ///   &    : Dependent commands (e.g., "check & test & run")
-    pub command_string: String,
+    ///   e.g., "test --features f1" "run --release"
+    #[arg(required = true, allow_hyphen_values = true)]
+    pub commands: Vec<String>,
 
     /// Run commands in verbose mode
     ///
@@ -25,7 +26,7 @@ pub struct Cli {
 
     /// Run commands in parallel
     ///
-    /// Only works with independent commands (space or ; separator)
+    /// Runs all commands in parallel instead of sequentially
     #[arg(short, long)]
     pub parallel: bool,
 }
@@ -34,8 +35,6 @@ impl Cli {
     pub fn parse() -> Self {
         // Skip the all arguments which are "q" for cargo subcommands
         let args = std::env::args()
-            .collect::<Vec<_>>()
-            .into_iter()
             .filter(|arg| arg != "q")
             .collect::<Vec<_>>();
 

src/cli.rs

@@ -1,43 +1,26 @@
 use crate::routine::Routine;
-use crate::strategy::{
-    DependentStrategy, ExecutionStrategy, ParallelStrategy, SequentialStrategy, Strategy,
-};
-use std::io::{self, Error, ErrorKind};
+use crate::strategy::{ExecutionStrategy, ParallelStrategy, SequentialStrategy};
+use std::io;
 
 pub(crate) struct Executor {
     pub(super) parallel: bool,
     pub(super) verbose: bool,
-    pub(super) strategy: Strategy,
     pub(super) routines: Vec<Routine>,
 }
 
 impl Executor {
-    pub fn new(parallel: bool, verbose: bool, routines: Vec<Routine>, strategy: Strategy) -> Self {
+    pub fn new(parallel: bool, verbose: bool, routines: Vec<Routine>) -> Self {
         Executor {
             parallel,
             verbose,
-            strategy,
             routines,
         }
     }
 
     pub fn execute(&self) -> io::Result<()> {
-        let strategy: Box<dyn ExecutionStrategy> = match (self.parallel, self.strategy) {
-            (true, Strategy::Independent) => Box::new(ParallelStrategy),
-            (true, _) => {
-                return Err(Error::new(
-                    ErrorKind::InvalidInput,
-                    "Parallel execution only supports independent commands now",
-                ))
-            }
-            (false, Strategy::Independent) => Box::new(SequentialStrategy),
-            (false, Strategy::Dependent) => Box::new(DependentStrategy),
-            (false, Strategy::Pipe) => {
-                return Err(Error::new(
-                    ErrorKind::Unsupported,
-                    "Pipe strategy not implemented yet",
-                ))
-            }
+        let strategy: Box<dyn ExecutionStrategy> = match self.parallel {
+            true => Box::new(ParallelStrategy),
+            false => Box::new(SequentialStrategy),
         };
 
         strategy.execute(&self.routines, self.verbose)

src/executor.rs

@@ -11,9 +11,7 @@ use parser::Parser;
 
 fn main() {
     let cli = Cli::parse();
-    let parser = Parser::new();
-    let executor = parser.parse(&cli.command_string, cli.parallel, cli.verbose);
-
+    let executor = Parser.parse(&cli.commands, cli.parallel, cli.verbose);
     if let Err(e) = executor.execute() {
         eprintln!("{}", e);
         std::process::exit(1);