12 Commits

Author SHA1 Message Date
c58cbff4b2 chore: Release 2025-01-30 21:34:21 -05:00
9d944c3218 feat: Pipe 2025-01-30 21:04:54 -05:00
6fa4b21c4f chore: Release comlexr version 1.2.0 2025-01-14 15:55:33 -05:00
Gerald Pinder
fc55ab350d Merge branch 'add-env-cd' into 'main'
feat: Add the ability to set current dir and env vars

See merge request wunker-bunker/comlexr!2
2025-01-14 20:53:54 +00:00
gerald.pinder
403c7be922 feat: Add the ability to set current dir and env vars 2025-01-14 15:39:52 -05:00
b87fe80302 chore: Release comlexr version 1.1.0 2025-01-11 16:01:52 -05:00
a4a41c8dfe chore: Add CHANGELOG.md 2025-01-11 16:01:42 -05:00
3a0dbacf12 chore: Remove earthly check in release just script 2025-01-11 15:59:30 -05:00
bcf4664f0e chore: Add git hooks 2025-01-11 15:55:12 -05:00
820afa2171 feat: Add more support for patterns and conditional match 2025-01-11 15:52:13 -05:00
0858e04c41 chore: Clean up parse logic for Value 2025-01-11 11:36:21 -05:00
ebc4cc0bd4 fix: Properly parse Expressions, Idents, and Literals 2025-01-11 11:16:23 -05:00
19 changed files with 1440 additions and 197 deletions

2
.gitignore vendored
View File

@@ -1 +1,3 @@
/target /target
/expand.rs
/.sccache

3
.gitlab-ci.yml Normal file
View File

@@ -0,0 +1,3 @@
include:
- project: wunker-bunker/ci-pipelines
file: cargo-lib.yml

6
.helix/languages.toml Normal file
View File

@@ -0,0 +1,6 @@
[language-server.rust-analyzer.config]
cargo.features = "all"
[language-server.rust-analyzer.config.check]
command = "clippy"
args = ["--no-deps", "--workspace"]

5
.rusty-hook.toml Normal file
View File

@@ -0,0 +1,5 @@
[hooks]
pre-push = "cargo fmt --check && cargo test && cargo clippy -- -D warnings"
[logging]
verbose = true

39
CHANGELOG.md Normal file
View File

@@ -0,0 +1,39 @@
# Changelog
All notable changes to this project will be documented in this file.
## [1.3.0] - 2025-01-31
### 🚀 Features
- Pipe
## [1.2.0] - 2025-01-14
### 🚀 Features
- Add the ability to set current dir and env vars
### ⚙️ Miscellaneous Tasks
- Release comlexr version 1.2.0
## [1.1.0] - 2025-01-11
### 🚀 Features
- Add more support for patterns and conditional match
### 🐛 Bug Fixes
- Properly parse Expressions, Idents, and Literals
### ⚙️ Miscellaneous Tasks
- Clean up parse logic for Value
- Add git hooks
- Remove earthly check in release just script
- Add CHANGELOG.md
- Release comlexr version 1.1.0
<!-- generated by git-cliff -->

312
Cargo.lock generated
View File

@@ -17,20 +17,56 @@ version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
[[package]]
name = "bitflags"
version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
[[package]] [[package]]
name = "cfg-if" name = "cfg-if"
version = "1.0.0" version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "ci_info"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24f638c70e8c5753795cc9a8c07c44da91554a09e4cf11a7326e8161b0a3c45e"
dependencies = [
"envmnt",
]
[[package]] [[package]]
name = "comlexr" name = "comlexr"
version = "1.0.0" version = "1.3.0"
dependencies = [
"comlexr_macro",
"rstest",
"rusty-hook",
"tempfile",
"thiserror",
]
[[package]]
name = "comlexr_macro"
version = "1.3.0"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
"rstest",
"syn", "syn",
"tempfile",
]
[[package]]
name = "envmnt"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2d328fc287c61314c4a61af7cfdcbd7e678e39778488c7cb13ec133ce0f4059"
dependencies = [
"fsio",
"indexmap 1.9.3",
] ]
[[package]] [[package]]
@@ -39,6 +75,28 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
dependencies = [
"libc",
"windows-sys",
]
[[package]]
name = "fastrand"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
name = "fsio"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1fd087255f739f4f1aeea69f11b72f8080e9c2e7645cd06955dad4a178a49e3"
[[package]] [[package]]
name = "futures-core" name = "futures-core"
version = "0.3.31" version = "0.3.31"
@@ -82,18 +140,55 @@ dependencies = [
"slab", "slab",
] ]
[[package]]
name = "getopts"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
dependencies = [
"unicode-width",
]
[[package]]
name = "getrandom"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
dependencies = [
"cfg-if",
"libc",
"wasi",
"windows-targets",
]
[[package]] [[package]]
name = "glob" name = "glob"
version = "0.3.2" version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2" checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
[[package]]
name = "hashbrown"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
[[package]] [[package]]
name = "hashbrown" name = "hashbrown"
version = "0.15.2" version = "0.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
[[package]]
name = "indexmap"
version = "1.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
dependencies = [
"autocfg",
"hashbrown 0.12.3",
]
[[package]] [[package]]
name = "indexmap" name = "indexmap"
version = "2.7.0" version = "2.7.0"
@@ -101,15 +196,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
dependencies = [ dependencies = [
"equivalent", "equivalent",
"hashbrown", "hashbrown 0.15.2",
] ]
[[package]]
name = "libc"
version = "0.2.169"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
[[package]]
name = "linux-raw-sys"
version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
[[package]] [[package]]
name = "memchr" name = "memchr"
version = "2.7.4" version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "nias"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab250442c86f1850815b5d268639dff018c0627022bc1940eb2d642ca1ce12f0"
[[package]]
name = "once_cell"
version = "1.20.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
[[package]] [[package]]
name = "pin-project-lite" name = "pin-project-lite"
version = "0.2.16" version = "0.2.16"
@@ -223,12 +342,57 @@ dependencies = [
"semver", "semver",
] ]
[[package]]
name = "rustix"
version = "0.38.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
dependencies = [
"bitflags",
"errno",
"libc",
"linux-raw-sys",
"windows-sys",
]
[[package]]
name = "rusty-hook"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96cee9be61be7e1cbadd851e58ed7449c29c620f00b23df937cb9cbc04ac21a3"
dependencies = [
"ci_info",
"getopts",
"nias",
"toml",
]
[[package]] [[package]]
name = "semver" name = "semver"
version = "1.0.24" version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba" checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
[[package]]
name = "serde"
version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "slab" name = "slab"
version = "0.4.9" version = "0.4.9"
@@ -249,6 +413,49 @@ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]]
name = "tempfile"
version = "3.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "38c246215d7d24f48ae091a2902398798e05d978b24315d6efbc00ede9a8bb91"
dependencies = [
"cfg-if",
"fastrand",
"getrandom",
"once_cell",
"rustix",
"windows-sys",
]
[[package]]
name = "thiserror"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "toml"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "toml_datetime" name = "toml_datetime"
version = "0.6.8" version = "0.6.8"
@@ -261,7 +468,7 @@ version = "0.22.22"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5" checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
dependencies = [ dependencies = [
"indexmap", "indexmap 2.7.0",
"toml_datetime", "toml_datetime",
"winnow", "winnow",
] ]
@@ -272,6 +479,94 @@ version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
[[package]]
name = "unicode-width"
version = "0.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
[[package]]
name = "wasi"
version = "0.13.3+wasi-0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
dependencies = [
"wit-bindgen-rt",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets",
]
[[package]]
name = "windows-targets"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
"windows_aarch64_gnullvm",
"windows_aarch64_msvc",
"windows_i686_gnu",
"windows_i686_gnullvm",
"windows_i686_msvc",
"windows_x86_64_gnu",
"windows_x86_64_gnullvm",
"windows_x86_64_msvc",
]
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]] [[package]]
name = "winnow" name = "winnow"
version = "0.6.24" version = "0.6.24"
@@ -280,3 +575,12 @@ checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
dependencies = [ dependencies = [
"memchr", "memchr",
] ]
[[package]]
name = "wit-bindgen-rt"
version = "0.33.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
dependencies = [
"bitflags",
]

View File

@@ -1,29 +1,56 @@
[package] [workspace]
name = "comlexr" members = ["macro"]
[workspace.package]
description = "Dynamically build Command objects with conditional expressions" description = "Dynamically build Command objects with conditional expressions"
repository = "https://gitlab.com/wunker-bunker/comlexr" repository = "https://gitlab.com/wunker-bunker/comlexr"
version = "1.0.0" version = "1.3.0"
edition = "2018" edition = "2021"
rust-version = "1.60"
license = "MIT" license = "MIT"
[lib] [workspace.dependencies]
proc-macro = true tempfile = "3.6"
[dependencies] [workspace.lints.rust]
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
[dev-dependencies]
rstest = "0.24"
[lints.rust]
unsafe_code = "forbid" unsafe_code = "forbid"
[lints.clippy] [workspace.lints.clippy]
correctness = "deny" correctness = "deny"
suspicious = "deny" suspicious = "deny"
perf = "deny" perf = "deny"
style = "deny" style = "deny"
nursery = "deny" nursery = "deny"
pedantic = "deny" pedantic = "deny"
[package]
name = "comlexr"
version.workspace = true
edition.workspace = true
rust-version.workspace = true
description.workspace = true
repository.workspace = true
license.workspace = true
[package.metadata.release]
pre-release-hook = ["git", "cliff", "-o", "CHANGELOG.md", "--tag", "{{version}}"]
pre-release-replacements = [
{ file = "README.md", search = "comlexr = \"\\d+.\\d+.\\d+\"", replace = "comlexr = \"{{version}}\"" }
]
[package.metadata."docs.rs"]
all-features = true
[dependencies]
comlexr_macro = { version = "=1.3.0", path = "./macro" }
thiserror = "1.0.65"
[dev-dependencies]
rstest = "0.24"
rusty-hook = "0.11"
tempfile.workspace = true
[lints]
workspace = true

View File

@@ -8,11 +8,11 @@ Add `comlexr` to your project's `Cargo.toml`:
```toml ```toml
[dependencies] [dependencies]
comlexr = "1.0.0" comlexr = "1.3.0"
``` ```
### Rust Edition ## MSRV
This project uses Rust **2018 edition** to ensure compatibility and stable language features. The minimum supported Rust version is `1.60.0` for broader support.
## Usage ## Usage
@@ -150,14 +150,98 @@ let command = cmd!(
assert_eq!(format!("{command:?}"), r#""echo" "test" "2" "4" "6""#.to_string()); assert_eq!(format!("{command:?}"), r#""echo" "test" "2" "4" "6""#.to_string());
``` ```
### Set Current Directory
Specify the directory to run the command.
```rust
use comlexr::cmd;
let command = cmd!(
cd "~/";
"echo",
"test",
);
assert_eq!(format!("{command:?}"), r#"cd "~/" && "echo" "test""#);
```
### Setting Environment Variables
Set environment variables for the command.
```rust
use comlexr::cmd;
const NEW_VAR: &str = "NEW_VAR";
let command = cmd!(
env {
"TEST": "test",
NEW_VAR: "new_var"
};
"echo",
"test",
);
assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" TEST="test" "echo" "test""#);
```
#### Current Directory and Env Variable Order Matters
Environment variable declarations **MUST** come after the current directory declaration.
```rust
use comlexr::cmd;
let command = cmd!(
cd "~/";
env {
"TEST": "test",
};
"echo",
"test",
);
assert_eq!(
format!("{command:?}"),
r#"cd "~/" && TEST="test" "echo" "test""#
);
```
### Piping commands
When using the `pipe` feature, you can make use of `pipe!` to chain the stdout of commands to stdin. Execution is lazy so commands aren't run until `status()` or `output()` is called.
```rust
use comlexr::{pipe, cmd};
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("out");
let mut pipe = pipe!(cmd!("echo", "test") | cmd!("tee", &file));
let status = pipe.status().unwrap();
assert!(status.success());
```
### Sending variables to stdin
You can also send data to the stdin of the first command in the chain.
```rust
use comlexr::{pipe, cmd};
let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|"));
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
```
## Features ## Features
- Conditional expressions (`if`, `if let`) - Conditional expressions (`if`, `if let`)
- Iteration constructs (`for`, `for in`) - Iteration constructs (`for`, `for in`)
- Pattern matching (`match`) - Pattern matching (`match`)
- Support for closures and dynamic expressions - Support for closures and dynamic expressions
- Piping stdout from one command to the stdin of another
## Examples ## Examples
See the [tests](./tests/) directory for more examples on how to use `comlexr` effectively in your project. See the [tests](./tests/) directory for more examples on how to use `comlexr` effectively in your project.
## License ## License
This project is licensed under the [MIT License](LICENSE). This project is licensed under the [MIT License](./LICENSE).

View File

@@ -11,32 +11,32 @@ default_job = "clippy-all"
command = ["cargo", "check", "--color", "always"] command = ["cargo", "check", "--color", "always"]
need_stdout = false need_stdout = false
default_watch = false default_watch = false
watch = ["src", "Cargo.toml"] watch = ["src", "Cargo.toml", "macro"]
[jobs.check-all] [jobs.check-all]
command = ["cargo", "check", "--all-features", "--color", "always"] command = ["cargo", "check", "--all-features", "--color", "always"]
need_stdout = false need_stdout = false
default_watch = false default_watch = false
watch = ["src", "Cargo.toml"] watch = ["src", "Cargo.toml", "macro"]
[jobs.clippy] [jobs.clippy]
command = [ command = [
"cargo", "clippy", "cargo", "clippy", "--workspace",
"--color", "always", "--color", "always",
] ]
need_stdout = false need_stdout = false
default_watch = false default_watch = false
watch = ["src", "Cargo.toml"] watch = ["src", "Cargo.toml", "macro"]
[jobs.clippy-all] [jobs.clippy-all]
command = [ command = [
"cargo", "clippy", "cargo", "clippy", "--workspace",
"--all-features", "--all-features",
"--color", "always", "--color", "always",
] ]
need_stdout = false need_stdout = false
default_watch = false default_watch = false
watch = ["src", "Cargo.toml"] watch = ["src", "Cargo.toml", "macro"]
[jobs.test] [jobs.test]
command = [ command = [
@@ -46,7 +46,7 @@ command = [
env.RUSTFLAGS="-Zmacro-backtrace" env.RUSTFLAGS="-Zmacro-backtrace"
need_stdout = true need_stdout = true
default_watch = false default_watch = false
watch = ["src", "Cargo.toml", "tests"] watch = ["src", "Cargo.toml", "tests", "README.md", "macro"]
[jobs.test-all] [jobs.test-all]
command = [ command = [
@@ -56,18 +56,18 @@ command = [
env.RUSTFLAGS="-Zmacro-backtrace" env.RUSTFLAGS="-Zmacro-backtrace"
need_stdout = true need_stdout = true
default_watch = false default_watch = false
watch = ["src", "Cargo.toml", "tests"] watch = ["src", "Cargo.toml", "tests", "README.md", "macro"]
[jobs.doc] [jobs.doc]
command = ["cargo", "doc", "--color", "always", "--no-deps"] command = ["cargo", "doc", "--color", "always", "--no-deps", "--workspace", "--all-features"]
need_stdout = false need_stdout = false
default_watch = false default_watch = false
watch = ["src", "Cargo.toml"] watch = ["src", "Cargo.toml", "macro"]
# If the doc compiles, then it opens in your browser and bacon switches # If the doc compiles, then it opens in your browser and bacon switches
# to the previous job # to the previous job
[jobs.doc-open] [jobs.doc-open]
command = ["cargo", "doc", "--color", "always", "--no-deps", "--open"] command = ["cargo", "doc", "--color", "always", "--no-deps", "--open", "--workspace", "--all-features"]
need_stdout = false need_stdout = false
on_success = "back" # so that we don't open the browser at each change on_success = "back" # so that we don't open the browser at each change

59
justfile Normal file
View File

@@ -0,0 +1,59 @@
export RUST_BACKTRACE := "1"
set dotenv-load := true
set positional-arguments := true
# default recipe to display help information
default:
@just --list
# Clean up development files and images
clean:
cargo clean
# Run unit tests
test:
cargo test --workspace -- --show-output
# Run unit tests for all features
test-all-features:
cargo test --workspace --all-features -- --show-output
# Run clippy
lint:
cargo clippy
# Run clippy for all features
lint-all-features:
cargo clippy --all-features
# Expand the macros of a module for debugging
expand *args:
cargo expand $@ > ./expand.rs
$EDITOR ./expand.rs
# Installs cargo tools that help with development
tools:
rustup toolchain install stable nightly
rustup component add --toolchain stable rust-analyzer clippy rustfmt
cargo install --locked cargo-watch cargo-expand bacon
# Run cargo release and push the tag separately
release *args:
#!/usr/bin/env bash
set -euxo pipefail
# --workspace: updating all crates in the workspace
# --no-tag: do not push tag for each new version
# --no-confirm: don't look for user input, just run the command
# --execute: not a dry run
cargo release $1 -v \
--workspace \
--no-tag \
--no-confirm \
--execute
VERSION=$(cargo metadata --format-version 1 | jq -r '.packages[] | select(.name == "comlexr") .version')
echo "Pushing tag: v${VERSION}"
git tag "v${VERSION}"
git push origin "v${VERSION}"

26
macro/Cargo.toml Normal file
View File

@@ -0,0 +1,26 @@
[package]
name = "comlexr_macro"
version.workspace = true
edition.workspace = true
rust-version.workspace = true
description.workspace = true
repository.workspace = true
license.workspace = true
[package.metadata."docs.rs"]
all-features = true
[lib]
proc-macro = true
[dependencies]
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full", "derive"] }
[dev-dependencies]
tempfile.workspace = true
[lints]
workspace = true

View File

@@ -1,23 +1,38 @@
use quote::{quote, ToTokens}; use quote::{quote, ToTokens};
use syn::{braced, bracketed, parse::Parse, punctuated::Punctuated, token, Token}; use syn::{
braced, bracketed,
parse::{discouraged::Speculative, Parse},
punctuated::Punctuated,
token, Token,
};
use crate::macros::enum_to_tokens;
pub struct Command { pub struct Command {
cd: CurrentDir,
env_vars: EnvVars,
program: Value, program: Value,
args: Option<Punctuated<LogicArg, Token![,]>>, args: Option<Punctuated<LogicArg, Token![,]>>,
} }
impl Parse for Command { impl Parse for Command {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let cd = input.parse()?;
let env_vars = input.parse()?;
let program = input.parse()?; let program = input.parse()?;
if input.is_empty() { if input.is_empty() {
Ok(Self { Ok(Self {
cd,
env_vars,
program, program,
args: None, args: None,
}) })
} else { } else {
_ = input.parse::<Token![,]>()?; _ = input.parse::<Token![,]>()?;
Ok(Self { Ok(Self {
cd,
env_vars,
program, program,
args: Some(Punctuated::parse_terminated(input)?), args: Some(Punctuated::parse_terminated(input)?),
}) })
@@ -27,22 +42,27 @@ impl Parse for Command {
impl ToTokens for Command { impl ToTokens for Command {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self { program, args } = self; let Self {
cd,
env_vars,
program,
args,
} = self;
let program = quote! { ::std::process::Command::new(#program) }; let program = quote! { ::std::process::Command::new(#program) };
let args = args.as_ref().map(Punctuated::iter); let args = args
.as_ref()
.map(Punctuated::iter)
.map_or_else(Vec::new, Iterator::collect);
tokens.extend(args.map_or_else( tokens.extend(quote! {
|| quote! { #program },
|args| {
quote! {
{ {
let mut _c = #program; let mut _c = #program;
#cd
#env_vars
#(#args)* #(#args)*
_c _c
} }
} });
},
));
} }
} }
@@ -59,7 +79,10 @@ enum LogicArg {
impl Parse for LogicArg { impl Parse for LogicArg {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
if input.peek(Token![for]) { if input.peek(Token![for]) {
if input.peek3(Token![in]) { let pat_fork = input.fork();
_ = pat_fork.parse::<Token![for]>()?;
if pat_fork.call(syn::Pat::parse_single).is_ok() && pat_fork.peek(Token![in]) {
input.parse().map(Self::ForIn) input.parse().map(Self::ForIn)
} else { } else {
input.parse().map(Self::ForIter) input.parse().map(Self::ForIter)
@@ -80,19 +103,7 @@ impl Parse for LogicArg {
} }
} }
impl ToTokens for LogicArg { enum_to_tokens! {LogicArg: Expr, ForIter, ForIn, IfLet, If, Match, Closure}
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(match self {
Self::Expr(expr) => quote! { #expr },
Self::ForIter(for_iter) => quote! { #for_iter },
Self::ForIn(for_in) => quote! { #for_in },
Self::IfLet(if_let) => quote! { #if_let },
Self::If(if_) => quote! { #if_ },
Self::Match(match_) => quote! { #match_ },
Self::Closure(closure) => quote! { #closure },
});
}
}
struct ForIter { struct ForIter {
expr: Value, expr: Value,
@@ -258,28 +269,54 @@ impl ToTokens for Match {
struct MatchArm { struct MatchArm {
pattern: syn::Pat, pattern: syn::Pat,
if_expr: Option<Value>,
args: Arguments, args: Arguments,
} }
impl Parse for MatchArm { impl Parse for MatchArm {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let pattern = input.call(syn::Pat::parse_multi)?; let pattern = input.call(syn::Pat::parse_multi)?;
let if_expr = if input.peek(Token![if]) {
_ = input.parse::<Token![if]>()?;
Some(input.parse()?)
} else {
None
};
_ = input.parse::<Token![=>]>()?; _ = input.parse::<Token![=>]>()?;
let args = input.parse()?; let args = input.parse()?;
Ok(Self { pattern, args }) Ok(Self {
pattern,
if_expr,
args,
})
} }
} }
impl ToTokens for MatchArm { impl ToTokens for MatchArm {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self { pattern, args } = self; let Self {
pattern,
if_expr,
args,
} = self;
tokens.extend(quote! { tokens.extend(if_expr.as_ref().map_or_else(
|| {
quote! {
#pattern => { #pattern => {
#args #args
} }
}); }
},
|if_expr| {
quote! {
#pattern if #if_expr => {
#args
}
}
},
));
} }
} }
@@ -321,14 +358,7 @@ impl Parse for Arguments {
} }
} }
impl ToTokens for Arguments { enum_to_tokens! {Arguments: Single, Multi}
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(match self {
Self::Single(arg) => quote! { #arg },
Self::Multi(args) => quote! { #args },
});
}
}
struct MultiArg(Punctuated<SingleArg, Token![,]>); struct MultiArg(Punctuated<SingleArg, Token![,]>);
@@ -366,7 +396,100 @@ impl ToTokens for SingleArg {
} }
} }
enum Value { struct EnvVars(Option<Punctuated<EnvVar, Token![,]>>);
impl Parse for EnvVars {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let fork = input.fork();
let ident = fork.cursor().ident();
match ident {
Some((ident, _)) if ident == "env" => {
_ = fork.parse::<syn::Ident>()?;
let envs;
braced!(envs in fork);
Punctuated::parse_terminated(&envs)
.and_then(|envs| {
_ = fork.parse::<Token![;]>()?;
input.advance_to(&fork);
Ok(Self(Some(envs)))
})
.or_else(|_| Ok(Self(None)))
}
_ => Ok(Self(None)),
}
}
}
impl ToTokens for EnvVars {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self(envs) = self;
let envs = envs
.as_ref()
.map_or_else(Vec::new, |envs| envs.iter().collect());
tokens.extend(quote! {
#(#envs)*
});
}
}
struct EnvVar {
key: Value,
value: Value,
}
impl Parse for EnvVar {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let key = input.parse()?;
_ = input.parse::<Token![:]>()?;
let value = input.parse()?;
Ok(Self { key, value })
}
}
impl ToTokens for EnvVar {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self { key, value } = self;
tokens.extend(quote! { _c.env(#key, #value); });
}
}
struct CurrentDir(Option<Value>);
impl Parse for CurrentDir {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let fork = input.fork();
let ident = fork.cursor().ident();
match ident {
Some((ident, _)) if ident == "cd" => {
_ = fork.parse::<syn::Ident>();
fork.parse()
.and_then(|value| {
_ = fork.parse::<Token![;]>()?;
input.advance_to(&fork);
Ok(Self(Some(value)))
})
.or_else(|_| Ok(Self(None)))
}
_ => Ok(Self(None)),
}
}
}
impl ToTokens for CurrentDir {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self(cd) = self;
let cd = cd.iter();
tokens.extend(quote! { #(_c.current_dir(#cd);)* });
}
}
pub enum Value {
Lit(syn::Lit), Lit(syn::Lit),
Ident(syn::Ident), Ident(syn::Ident),
Expr(syn::Expr), Expr(syn::Expr),
@@ -374,22 +497,26 @@ enum Value {
impl Parse for Value { impl Parse for Value {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
if input.peek(syn::Lit) { let expr_fork = input.fork();
input.parse().map(Self::Lit) expr_fork
} else if input.peek(syn::Ident) { .parse()
.map(|expr| {
input.advance_to(&expr_fork);
Self::Expr(expr)
})
.or_else(|_| {
if input.peek(syn::Ident) {
input.parse().map(Self::Ident) input.parse().map(Self::Ident)
} else if input.peek(syn::Lit) {
input.parse().map(Self::Lit)
} else { } else {
input.parse().map(Self::Expr) Err(syn::Error::new(
input.span(),
"Expected an expression, ident, or literal",
))
} }
})
} }
} }
impl ToTokens for Value { enum_to_tokens! {Value: Lit, Ident, Expr}
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(match self {
Self::Lit(lit) => quote! { #lit },
Self::Ident(ident) => quote! { #ident },
Self::Expr(expr) => quote! { #expr },
});
}
}

200
macro/src/lib.rs Normal file
View File

@@ -0,0 +1,200 @@
extern crate quote;
extern crate syn;
use quote::quote;
use syn::parse_macro_input;
mod cmd;
mod macros;
mod pipe;
/// Generates a command expression by combining static strings, conditional logic, loops,
/// pattern matching, and closures to dynamically build and format command-line arguments.
///
/// The `cmd!` macro supports flexible syntax constructs such as:
/// - **Static arguments**: Basic string arguments.
/// - **Conditional inclusion**: Using `if` or `if let` to conditionally include arguments.
/// - **Iterative inclusion**: Using `for` loops to include multiple arguments from collections.
/// - **Pattern matching**: Using `match` expressions for dynamic argument selection.
/// - **Closures**: Dynamically generating arguments at runtime.
///
/// # Examples
///
/// ## Basic Usage
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!("echo", "test");
/// assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string());
/// ```
///
/// ## Current Directory
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!(
/// cd "~/";
/// "echo",
/// "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"cd "~/" && "echo" "test""#);
/// ```
///
/// ## Environment Vars
/// ```
/// # use comlexr_macro::cmd;
/// const NEW_VAR: &str = "NEW_VAR";
///
/// let command = cmd!(
/// env {
/// "TEST": "test",
/// NEW_VAR: "new_var"
/// };
/// "echo",
/// "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" TEST="test" "echo" "test""#);
/// ```
///
/// ### Current Directory and Environment Variable Order
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!(
/// cd "~/";
/// env {
/// "TEST": "test",
/// };
/// "echo",
/// "test",
/// );
///
/// assert_eq!(
/// format!("{command:?}"),
/// r#"cd "~/" && TEST="test" "echo" "test""#
/// );
///
/// ```
///
/// ## Conditional Arguments
/// ```
/// # use comlexr_macro::cmd;
/// let include_arg = true;
///
/// let command = cmd!("echo", "test", if include_arg => "optional_arg");
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "optional_arg""#.to_string());
/// ```
///
/// ## Conditional Pattern Matching
/// ```
/// # use comlexr_macro::cmd;
/// let single_option = Some("single");
/// let multi_option: Option<&str> = None;
///
/// let command = cmd!(
/// "echo",
/// "test",
/// if let Some(arg) = single_option => arg,
/// if let Some(arg) = multi_option => [
/// "multi",
/// arg,
/// ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "single""#.to_string());
/// ```
///
/// ## Iterative Argument Inclusion
/// ```
/// # use comlexr_macro::cmd;
/// let args = &["arg1", "arg2"];
///
/// let command = cmd!("echo", for args);
/// assert_eq!(format!("{command:?}"), r#""echo" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Iteration with `for in`
/// ```
/// # use comlexr_macro::cmd;
/// let single_iter = &["arg1", "arg2"];
/// let multi_iter = &["multi1", "multi2"];
///
/// let command = cmd!(
/// "echo",
/// "test",
/// for arg in single_iter => arg,
/// for arg in multi_iter => [
/// "multi",
/// arg,
/// ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2" "multi" "multi1" "multi" "multi2""#.to_string());
/// ```
///
/// ## Match Statements
/// ```
/// # use comlexr_macro::cmd;
/// enum TestArgs {
/// Arg1,
/// Arg2,
/// Arg3,
/// }
///
/// let match_arg = TestArgs::Arg2;
/// let command = cmd!(
/// "echo",
/// "test",
/// match match_arg {
/// TestArgs::Arg1 => "arg1",
/// TestArgs::Arg2 => ["arg1", "arg2"],
/// TestArgs::Arg3 => ["arg1", "arg2", "arg3"],
/// }
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Dynamic Closures
/// ```
/// # use comlexr_macro::cmd;
/// let numbers = vec![1, 2, 3];
/// let multiplier = 2;
///
/// let command = cmd!("echo", || numbers.into_iter().map(|n| format!("{}", n * multiplier)));
/// assert_eq!(format!("{command:?}"), r#""echo" "2" "4" "6""#.to_string());
/// ```
#[proc_macro]
pub fn cmd(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let command = parse_macro_input!(input as cmd::Command);
quote! { #command }.into()
}
/// Chain the stdout of commands to stdin. Execution is lazy so commands aren't run until `status()` or `output()` is called.
///
/// ```ignore
/// use comlexr::{pipe, cmd};
///
/// let dir = tempfile::tempdir().unwrap();
/// let file = dir.path().join("out");
/// let mut pipe = pipe!(cmd!("echo", "test") | cmd!("sed", "s|e|oa|") | cmd!("tee", &file));
///
/// let output = pipe.output().unwrap();
/// assert!(output.status.success());
/// assert_eq!(String::from_utf8_lossy(&output.stdout), "toast\n");
/// ```
///
/// Or pass data via stdin.
///
/// NOTE: Data must implement `AsRef<[u8]>`.
///
/// ```ignore
/// use comlexr::{pipe, cmd};
///
/// let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|"));
///
/// let output = pipe.output().unwrap();
/// assert!(output.status.success());
/// assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
/// ```
#[proc_macro]
pub fn pipe(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let pipe = parse_macro_input!(input as pipe::Pipe);
quote! { #pipe }.into()
}

13
macro/src/macros.rs Normal file
View File

@@ -0,0 +1,13 @@
macro_rules! enum_to_tokens {
($enum:ident: $($variant:ident),*) => {
impl ToTokens for $enum {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(match self {
$(Self::$variant(variant) => quote! { #variant },)*
});
}
}
};
}
pub(crate) use enum_to_tokens;

174
macro/src/pipe.rs Normal file
View File

@@ -0,0 +1,174 @@
use quote::{quote, ToTokens};
use syn::{
parse::{discouraged::Speculative, Parse},
punctuated::Punctuated,
spanned::Spanned,
Error, Token,
};
use crate::{cmd::Value, macros::enum_to_tokens};
pub struct Pipe {
stdin: Option<Value>,
commands: Punctuated<CommandExpr, Token![|]>,
}
impl Parse for Pipe {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let stdin = match input.cursor().ident() {
Some((ident, _)) if ident == "stdin" && input.peek2(Token![=]) => {
_ = input.parse::<syn::Ident>()?;
_ = input.parse::<Token![=]>()?;
let stdin = input.parse()?;
_ = input.parse::<Token![;]>()?;
Some(stdin)
}
_ => None,
};
let commands = Punctuated::parse_separated_nonempty(input)?;
if commands.is_empty() {
return Err(Error::new_spanned(
commands,
"At least one command is required",
));
}
Ok(Self { stdin, commands })
}
}
impl ToTokens for Pipe {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let Self { stdin, commands } = self;
let command_count = commands.len();
let last_command_span = commands.last().unwrap().span();
let mut commands_iter = commands.iter();
let first_command = commands_iter.next().unwrap();
let initial = quote! {
let mut _c_0 = #first_command;
_c_0.stdout(::std::process::Stdio::piped());
_c_0.stdin(::std::process::Stdio::piped());
let mut _child_0 = _c_0.spawn()?;
if let Some(stdin) = stdin {
_child_0
.stdin
.as_mut()
.ok_or(::comlexr::ExecutorError::NoStdIn)?
.write_all(stdin.as_ref())?;
}
};
let stdin = stdin.as_ref().map_or_else(
|| {
quote! {
None::<&[u8]>
}
},
|stdin| {
quote! {
Some(#stdin)
}
},
);
let commands = commands_iter.enumerate().map(|(index, command)| {
let previous_span = if index == 0 {
first_command.span()
} else {
commands[index - 1].span()
};
let prev_com_ident = syn::Ident::new(&format!("_c_{index}"), previous_span);
let prev_child_ident = syn::Ident::new(&format!("_child_{index}"), previous_span);
let com_ident = syn::Ident::new(&format!("_c_{}", index + 1), command.span());
let child_ident = syn::Ident::new(&format!("_child_{}", index + 1), command.span());
quote! {
let _output = #prev_child_ident.wait_with_output()?;
if !_output.status.success() {
return Err(::comlexr::ExecutorError::FailedCommand{
command: #prev_com_ident,
exit_code: _output.status.code().unwrap_or(1),
});
}
let mut #com_ident = #command;
#com_ident.stdout(::std::process::Stdio::piped());
#com_ident.stdin(::std::process::Stdio::piped());
let mut #child_ident = #com_ident.spawn()?;
#child_ident
.stdin
.as_mut()
.ok_or(::comlexr::ExecutorError::NoStdIn)?
.write_all(&_output.stdout)?;
}
});
let last_child_ident =
syn::Ident::new(&format!("_child_{}", command_count - 1), last_command_span);
tokens.extend(quote! {
::comlexr::Executor::new(
#stdin,
|stdin| -> ::std::result::Result<
::std::process::Child,
::comlexr::ExecutorError,
> {
use ::std::io::Write;
#initial
#(#commands)*
Ok(#last_child_ident)
}
)
});
}
}
enum CommandExpr {
Macro(syn::ExprMacro),
Reference(syn::ExprReference),
Function(syn::ExprCall),
Block(syn::ExprBlock),
}
impl Parse for CommandExpr {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let fork = input.fork();
fork.parse()
.map(|value| {
input.advance_to(&fork);
Self::Macro(value)
})
.or_else(|_| {
let fork = input.fork();
let value = fork.parse()?;
input.advance_to(&fork);
Ok(Self::Function(value))
})
.or_else(|_: syn::Error| {
let fork = input.fork();
let value = fork.parse()?;
input.advance_to(&fork);
Ok(Self::Block(value))
})
.or_else(|_: syn::Error| {
let fork = input.fork();
let value = fork.parse()?;
input.advance_to(&fork);
Ok(Self::Reference(value))
})
.map_err(|_: syn::Error| {
syn::Error::new(
input.span(),
"Only references, function calls, macro calls, and blocks are allowed",
)
})
}
}
enum_to_tokens! {CommandExpr: Macro, Reference, Function, Block}

View File

@@ -1,103 +1,8 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
extern crate quote; extern crate comlexr_macro;
extern crate syn;
use quote::quote; pub use comlexr_macro::*;
use syn::parse_macro_input; pub use pipe::*;
mod cmd; mod pipe;
/// Generates a command expression by combining static strings, conditional logic, loops,
/// pattern matching, and closures to dynamically build and format command-line arguments.
///
/// The `cmd!` macro supports flexible syntax constructs such as:
/// - **Static arguments**: Basic string arguments.
/// - **Conditional inclusion**: Using `if` or `if let` to conditionally include arguments.
/// - **Iterative inclusion**: Using `for` loops to include multiple arguments from collections.
/// - **Pattern matching**: Using `match` expressions for dynamic argument selection.
/// - **Closures**: Dynamically generating arguments at runtime.
///
/// # Examples
///
/// ## Basic Usage
/// ```
/// use comlexr::cmd;
///
/// let command = cmd!("echo", "test");
/// assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string());
/// ```
///
/// ## Conditional Arguments
/// ```
/// use comlexr::cmd;
///
/// let include_arg = true;
///
/// let command = cmd!("echo", "test", if include_arg => "optional_arg");
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "optional_arg""#.to_string());
/// ```
///
/// ## Conditional Pattern Matching
/// ```
/// use comlexr::cmd;
///
/// let single_option = Some("single");
/// let multi_option: Option<&str> = None;
///
/// let command = cmd!(
/// "echo",
/// "test",
/// if let Some(arg) = single_option => arg,
/// if let Some(arg) = multi_option => [
/// "multi",
/// arg,
/// ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "single""#.to_string());
/// ```
///
/// ## Iterative Argument Inclusion
/// ```
/// use comlexr::cmd;
///
/// let args = &["arg1", "arg2"];
///
/// let command = cmd!("echo", for args);
/// assert_eq!(format!("{command:?}"), r#""echo" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Iteration with `for in`
/// ```
/// use comlexr::cmd;
///
/// let single_iter = &["arg1", "arg2"];
/// let multi_iter = &["multi1", "multi2"];
///
/// let command = cmd!(
/// "echo",
/// "test",
/// for arg in single_iter => arg,
/// for arg in multi_iter => [
/// "multi",
/// arg,
/// ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2" "multi" "multi1" "multi" "multi2""#.to_string());
/// ```
///
/// ## Dynamic Closures
/// ```
/// use comlexr::cmd;
///
/// let numbers = vec![1, 2, 3];
/// let multiplier = 2;
///
/// let command = cmd!("echo", || numbers.into_iter().map(|n| format!("{}", n * multiplier)));
/// assert_eq!(format!("{command:?}"), r#""echo" "2" "4" "6""#.to_string());
/// ```
#[proc_macro]
pub fn cmd(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let command = parse_macro_input!(input as cmd::Command);
quote! { #command }.into()
}

73
src/pipe.rs Normal file
View File

@@ -0,0 +1,73 @@
use std::{
ffi::OsStr,
process::Command,
process::{Child, ExitStatus, Output},
};
use thiserror::Error;
/// Errors that can be created when running the `PipeExecutor`
#[derive(Debug, Error)]
pub enum ExecutorError {
/// IO Error
#[error(transparent)]
Io(#[from] std::io::Error),
/// Failed Command Error
#[error("Failed to run command '{} {}', exit code {exit_code}",
.command
.get_program()
.to_string_lossy(),
.command
.get_args()
.map(OsStr::to_string_lossy)
.collect::<Vec<_>>()
.join(" "),
)]
FailedCommand { command: Command, exit_code: i32 },
/// No stdin Error
#[error("Unable to get mutable stdin")]
NoStdIn,
}
/// A lazy piped command executor.
pub struct Executor<'a, S>
where
S: AsRef<[u8]> + ?Sized,
{
stdin: Option<&'a S>,
piped_commands: Box<dyn FnMut(Option<&'a S>) -> Result<Child, ExecutorError> + 'a>,
}
impl<'a, S> Executor<'a, S>
where
S: AsRef<[u8]> + ?Sized,
{
/// Construct a `PipeExecutor`.
pub fn new(
stdin: Option<&'a S>,
piped_commands: impl FnMut(Option<&'a S>) -> Result<Child, ExecutorError> + 'a,
) -> Self {
Self {
stdin,
piped_commands: Box::new(piped_commands),
}
}
/// Retrieves the `ExitStatus` of the last command.
///
/// # Errors
/// Will error if the exit status of any chained commands fail.
pub fn status(&mut self) -> Result<ExitStatus, ExecutorError> {
Ok((self.piped_commands)(self.stdin)?.wait()?)
}
/// Retrieves the `Output` of the last command.
///
/// # Errors
/// Will error if the exit status of any chained commands fail.
pub fn output(&mut self) -> Result<Output, ExecutorError> {
Ok((self.piped_commands)(self.stdin)?.wait_with_output()?)
}
}

View File

@@ -11,6 +11,47 @@ fn expression() {
assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string()); assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string());
} }
#[test]
fn current_dir() {
let command = cmd!(
cd "~/";
"echo",
"test",
);
assert_eq!(format!("{command:?}"), r#"cd "~/" && "echo" "test""#);
}
#[test]
fn env_vars() {
let command = cmd!(
env {
"TEST": "test",
};
"echo",
"test",
);
assert_eq!(format!("{command:?}"), r#"TEST="test" "echo" "test""#);
}
#[test]
fn cd_env_vars() {
let command = cmd!(
cd "~/";
env {
"TEST": "test",
};
"echo",
"test",
);
assert_eq!(
format!("{command:?}"),
r#"cd "~/" && TEST="test" "echo" "test""#
);
}
#[rstest] #[rstest]
#[case(false, false, r#""echo" "test""#)] #[case(false, false, r#""echo" "test""#)]
#[case(true, false, r#""echo" "test" "single""#)] #[case(true, false, r#""echo" "test" "single""#)]
@@ -62,6 +103,31 @@ fn for_in(#[case] single_iter: &[&str], #[case] multi_iter: &[&str], #[case] exp
assert_eq!(format!("{command:?}"), expected.to_string()); assert_eq!(format!("{command:?}"), expected.to_string());
} }
struct TestStruct(&'static str);
#[rstest]
#[case(&[], &[], r#""echo" "test""#)]
#[case(&[TestStruct("1"), TestStruct("2")], &[], r#""echo" "test" "1" "2""#)]
#[case(&[], &[TestStruct("3"), TestStruct("4")], r#""echo" "test" "multi" "3" "multi" "4""#)]
#[case(&[TestStruct("1"), TestStruct("2")], &[TestStruct("3"), TestStruct("4")], r#""echo" "test" "1" "2" "multi" "3" "multi" "4""#)]
fn for_in_pat(
#[case] single_iter: &[TestStruct],
#[case] multi_iter: &[TestStruct],
#[case] expected: &str,
) {
let command = cmd!(
"echo",
"test",
for TestStruct(arg) in single_iter => arg,
for TestStruct(arg) in multi_iter => [
"multi",
arg,
],
);
assert_eq!(format!("{command:?}"), expected.to_string());
}
#[rstest] #[rstest]
#[case(None, None, r#""echo" "test""#)] #[case(None, None, r#""echo" "test""#)]
#[case(Some("arg"), None, r#""echo" "test" "arg""#)] #[case(Some("arg"), None, r#""echo" "test" "arg""#)]
@@ -105,11 +171,37 @@ fn match_statement(#[case] match_arg: TestArgs, #[case] expected: &str) {
assert_eq!(format!("{command:?}"), expected.to_string()); assert_eq!(format!("{command:?}"), expected.to_string());
} }
#[rstest]
#[case(TestArgs::Arg1, true, r#""echo" "test" "arg1""#)]
#[case(TestArgs::Arg1, false, r#""echo" "test""#)]
#[case(TestArgs::Arg2, true, r#""echo" "test" "arg1" "arg2""#)]
#[case(TestArgs::Arg2, false, r#""echo" "test""#)]
#[case(TestArgs::Arg3, true, r#""echo" "test" "arg1" "arg2" "arg3""#)]
#[case(TestArgs::Arg3, false, r#""echo" "test""#)]
fn match_statement_conditional(
#[case] match_arg: TestArgs,
#[case] flag: bool,
#[case] expected: &str,
) {
let command = cmd!(
"echo",
"test",
match match_arg {
TestArgs::Arg1 if flag => "arg1",
TestArgs::Arg2 if flag => ["arg1", "arg2"],
TestArgs::Arg3 if flag => ["arg1", "arg2", "arg3"],
_ => [],
}
);
assert_eq!(format!("{command:?}"), expected.to_string());
}
#[rstest] #[rstest]
#[case(None, None, r#""echo" "test""#)] #[case(None, None, r#""echo" "test""#)]
#[case(Some("arg"), None, r#""echo" "test" "arg""#)] #[case(Some("arg"), None, r#""echo" "test" "arg""#)]
#[case(None, Some("arg"), r#""echo" "test" "multi" "arg""#)] #[case(None, Some("arg"), r#""echo" "test" "multi" "arg""#)]
#[case(Some("1"), Some("2"), r#""echo" "test" "1" "multi" "2""#)] #[case(Some("1"), Some("2"), r#""echo" "test" "1" "multi=2""#)]
fn multi_match(#[case] single: Option<&str>, #[case] multi: Option<&str>, #[case] expected: &str) { fn multi_match(#[case] single: Option<&str>, #[case] multi: Option<&str>, #[case] expected: &str) {
let command = cmd!( let command = cmd!(
"echo", "echo",
@@ -118,7 +210,7 @@ fn multi_match(#[case] single: Option<&str>, #[case] multi: Option<&str>, #[case
(None, None) => [], (None, None) => [],
(Some(single), None) => single, (Some(single), None) => single,
(None, Some(multi)) => ["multi", multi], (None, Some(multi)) => ["multi", multi],
(Some(single), Some(multi)) => [single, "multi", multi], (Some(single), Some(multi)) => [single, format!("multi={multi}")],
}, },
); );

104
tests/pipe.rs Normal file
View File

@@ -0,0 +1,104 @@
use core::panic;
use std::ffi::OsStr;
use comlexr::{cmd, pipe};
use tempfile::tempdir;
#[test]
fn pipe_status() {
let dir = tempdir().unwrap();
let file = dir.path().join("out");
let mut pipe = pipe!(cmd!("echo", "test") | cmd!("tee", &file));
let status = pipe.status().unwrap();
assert!(status.success());
}
#[test]
fn pipe_stdin_output() {
let dir = tempdir().unwrap();
let file = dir.path().join("out");
let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|") | cmd!("tee", &file));
println!("{}", file.display());
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}
#[test]
fn pipe_stdin_output_single_command() {
let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|"));
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}
#[test]
fn pipe_expect_fail() {
let mut pipe = pipe!(stdin = "test"; cmd!("false") | cmd!("sed", "s|e|oa|"));
let error = pipe.output().unwrap_err();
match error {
comlexr::ExecutorError::FailedCommand { command, exit_code } => {
assert_eq!(command.get_program(), OsStr::new("false"));
assert_eq!(exit_code, 1);
}
err => panic!("Expected exit code, got: {err}"),
}
}
#[test]
fn pipe_expect_fail_command_not_exist() {
let mut pipe = pipe!(stdin = "test"; cmd!("no_command") | cmd!("sed", "s|e|oa|"));
let error = pipe.output().unwrap_err();
match error {
comlexr::ExecutorError::Io(err) => assert_eq!(err.raw_os_error().unwrap(), 2),
err => panic!("Expected IO Error, got: {err}"),
}
}
#[test]
fn pipe_block() {
let mut pipe = pipe!(stdin = "test"; {
let c = cmd!("sed", "s|e|oa|");
println!("{c:?}");
c
});
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}
#[test]
fn pipe_ref() {
let mut command = {
let c = cmd!("sed", "s|e|oa|");
println!("{c:?}");
c
};
let mut pipe = pipe!(stdin = "test"; &mut command);
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}
#[test]
fn pipe_fn() {
let command = || {
let c = cmd!("sed", "s|e|oa|");
println!("{c:?}");
c
};
let mut pipe = pipe!(stdin = "test"; command());
let output = pipe.output().unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}