ry-cli 0.2.0__tar.gz → 0.4.0__tar.gz

ry_cli-0.4.0/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## [0.4.0](https://github.com/karpetrosyan/ry/compare/v0.2.0...v0.4.0) (2026-04-18)
+
+
+### Features
+
+* make rule's id optional ([7c2d7a5](https://github.com/karpetrosyan/ry/commit/7c2d7a54cae7dbf810383127c0262e08bc648b0f))
+* make rule's kind optional, default to regex ([920565f](https://github.com/karpetrosyan/ry/commit/920565feef93590c4dc7a9154172ae69d39a4876))
+* show diff with expected sync code in verbose mode ([622e95d](https://github.com/karpetrosyan/ry/commit/622e95d94e4822a9f40cf467bb40e371d8513b3e))
+
+
+### Miscellaneous Chores
+
+* release 0.4.0 ([35887e3](https://github.com/karpetrosyan/ry/commit/35887e3442e9040275a9c976e16a5228dacf4482))
+
+## [0.2.0](https://github.com/karpetrosyan/ry/compare/v0.1.0...v0.2.0) (2026-04-09)
+
+
+### Features
+
+* add support for passing multiple PATHs ([27f91f7](https://github.com/karpetrosyan/ry/commit/27f91f7a5b5db7b6bb803a6e896fe09c96456f36))
+
+
+### Bug Fixes
+
+* remove redundant generation file ([fe9dbc4](https://github.com/karpetrosyan/ry/commit/fe9dbc4a66392c96019799746c09bd0992dd4d53))
+
+## 0.1.0 (2026-04-08)
+
+
+### Features
+
+* first release ([e1aed91](https://github.com/karpetrosyan/ry/commit/e1aed91f6370bb3832b72be8164c4591e456d0da))

{ry_cli-0.2.0 → ry_cli-0.4.0}/Cargo.lock

@@ -375,7 +375,7 @@ dependencies = [
 
 [[package]]
 name = "ry"
-version = "0.2.0"
+version = "0.4.0"
 dependencies = [
  "clap",
  "glob",
@@ -383,6 +383,7 @@ dependencies = [
  "regex",
  "serde",
  "serde_yaml",
+ "similar",
  "tempfile",
  "tree-sitter",
  "tree-sitter-python",
@@ -462,6 +463,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
 [[package]]
 name = "streaming-iterator"
 version = "0.1.9"

{ry_cli-0.2.0 → ry_cli-0.4.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ry"
-version = "0.2.0"
+version = "0.4.0"
 edition = "2021"
 readme = "README.md"
 
@@ -16,6 +16,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
 regex = "1.10"
 glob = "0.3"
+similar = "2"
 
 [dev-dependencies]
 tempfile = "3.8"

{ry_cli-0.2.0 → ry_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ry-cli
-Version: 0.2.0
+Version: 0.4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -30,6 +30,12 @@ Ry transforms the Python code using regex rules. Originally built to simplify ma
 
 Comes with a package system where you can define reusable sets of rules. Have a built-in `std` package with all standard rules (like `async def` to `def`, etc), and you can create your own packages for your specific transformations.
 
+## Installation
+
+```bash
+pip install ry-cli
+```
+
 ## Inline Transformations
 
 Ry can transform not only whole files, but also specific lines or blocks of code based on inline comments.

{ry_cli-0.2.0 → ry_cli-0.4.0}/README.md

@@ -10,6 +10,12 @@ Ry transforms the Python code using regex rules. Originally built to simplify ma
 
 Comes with a package system where you can define reusable sets of rules. Have a built-in `std` package with all standard rules (like `async def` to `def`, etc), and you can create your own packages for your specific transformations.
 
+## Installation
+
+```bash
+pip install ry-cli
+```
+
 ## Inline Transformations
 
 Ry can transform not only whole files, but also specific lines or blocks of code based on inline comments.

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/config.rs

@@ -34,7 +34,9 @@ pub struct Package {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Rule {
-    pub id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default)]
     pub kind: RuleKind,
     #[serde(rename = "match")]
     pub match_pattern: String,
@@ -47,6 +49,12 @@ pub enum RuleKind {
     Regex,
 }
 
+impl Default for RuleKind {
+    fn default() -> Self {
+        RuleKind::Regex
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum TargetVariant {
@@ -88,10 +96,9 @@ impl Config {
 
     pub fn get_effective_rules_from_defaults(&self) -> Vec<Rule> {
         let mut rules = Vec::new();
-        let mut seen_ids = HashMap::new();
 
         for package_ref in &self.defaults.include {
-            self.add_package_rules(&mut rules, &mut seen_ids, package_ref);
+            self.add_package_rules(&mut rules, package_ref);
         }
 
         rules
@@ -99,40 +106,34 @@ impl Config {
 
     pub fn get_effective_rules(&self, target: &Target) -> Vec<Rule> {
         let mut rules = Vec::new();
-        let mut seen_ids = HashMap::new();
 
         if target.inherit_defaults {
             for package_ref in &self.defaults.include {
-                self.add_package_rules(&mut rules, &mut seen_ids, package_ref);
+                self.add_package_rules(&mut rules, package_ref);
             }
         }
 
         for package_ref in &target.include {
-            self.add_package_rules(&mut rules, &mut seen_ids, package_ref);
+            self.add_package_rules(&mut rules, package_ref);
         }
 
         for rule in &target.rules {
-            if !seen_ids.contains_key(&rule.id) {
-                seen_ids.insert(rule.id.clone(), rules.len());
-                rules.push(rule.clone());
-            }
+            rules.push(rule.clone());
         }
 
         rules
     }
 
-    fn add_package_rules(
-        &self,
-        rules: &mut Vec<Rule>,
-        seen_ids: &mut HashMap<String, usize>,
-        package_ref: &PackageRef,
-    ) {
+    fn add_package_rules(&self, rules: &mut Vec<Rule>, package_ref: &PackageRef) {
         let package = crate::packages::get_package(&package_ref.package, &self.packages);
 
         if let Some(pkg) = package {
             for rule in &pkg.rules {
-                if !package_ref.exclude.contains(&rule.id) && !seen_ids.contains_key(&rule.id) {
-                    seen_ids.insert(rule.id.clone(), rules.len());
+                let should_exclude = rule
+                    .id
+                    .as_ref()
+                    .map_or(false, |id| package_ref.exclude.contains(id));
+                if !should_exclude {
                     rules.push(rule.clone());
                 }
             }

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/diagnostics.rs

@@ -27,6 +27,7 @@ pub enum DiagnosticKind {
         generate_end_byte: usize,
         generated_end_byte: Option<usize>,
         transformed_code: String,
+        actual_code: String,
         indentation: usize,
         source_line: usize,
     },

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/inline.rs

@@ -297,6 +297,7 @@ fn validate_generate_node(
                         generate_end_byte,
                         generated_end_byte: Some(next.end_byte()),
                         transformed_code: transformed,
+                        actual_code: next_text.to_string(),
                         indentation,
                         source_line: start_line + 1,
                     },

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/lib.rs

@@ -29,7 +29,8 @@ pub fn apply_rules(source: &str, rules: &[Rule]) -> String {
                 } else {
                     eprintln!(
                         "Warning: Invalid regex pattern in rule '{}': {}",
-                        rule.id, rule.match_pattern
+                        rule.id.as_deref().unwrap_or("<unnamed>"),
+                        rule.match_pattern
                     );
                 }
             }

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/main.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
 use glob::glob;
 use ry::config::Config;
-use ry::diagnostics::{Diagnostic, Severity};
+use ry::diagnostics::{Diagnostic, DiagnosticKind, Severity};
 use ry::inline::process_file_inline;
 use ry::module::process_all_file_targets;
 use std::path::{Path, PathBuf};
@@ -105,13 +105,40 @@ fn main() {
     diagnostics.extend(files_diagnostics);
     fixed_diagnostics.extend(files_fixed);
 
-    print_summary(&paths_to_process, &diagnostics, &fixed_diagnostics);
+    print_summary(&paths_to_process, &diagnostics, &fixed_diagnostics, cli.verbose);
+
+    if diagnostics
+        .iter()
+        .any(|d| matches!(d.severity, Severity::Error))
+    {
+        std::process::exit(1)
+    }
+}
+
+fn print_diff(actual: &str, expected: &str) {
+    use similar::{ChangeTag, TextDiff};
+    use std::io::IsTerminal;
+    let colors = std::io::stderr().is_terminal();
+    let diff = TextDiff::from_lines(actual, expected);
+    for change in diff.iter_all_changes() {
+        let (sign, color, reset) = match change.tag() {
+            ChangeTag::Delete => ("-", "\x1b[31m", "\x1b[0m"),
+            ChangeTag::Insert => ("+", "\x1b[32m", "\x1b[0m"),
+            ChangeTag::Equal => (" ", "", ""),
+        };
+        if colors {
+            eprint!("{}{}{}{}", color, sign, change, reset);
+        } else {
+            eprint!("{}{}", sign, change);
+        }
+    }
 }
 
 fn print_summary(
     paths_to_process: &[PathBuf],
     diagnostics: &[Diagnostic],
     fixed_diagnostics: &[Diagnostic],
+    verbose: bool,
 ) {
     let error_count = diagnostics
         .iter()
@@ -123,6 +150,15 @@ fn print_summary(
         .count();
     let fixed_count = fixed_diagnostics.len();
 
+    if verbose {
+        for diagnostic in diagnostics {
+            if let DiagnosticKind::OutDatedGeneratedCode { actual_code, transformed_code, .. } = &diagnostic.kind {
+                eprintln!("diff for {}:{}:", diagnostic.location.file, diagnostic.location.line);
+                print_diff(actual_code, transformed_code);
+            }
+        }
+    }
+
     if fixed_count > 0 {
         println!(
             "Processed {} file(s) with {} error(s), {} warning(s), and fixed {} diagnostic(s)",

{ry_cli-0.2.0 → ry_cli-0.4.0}/src/packages.rs

@@ -13,139 +13,139 @@ fn create_std_package() -> Package {
     Package {
         rules: vec![
             Rule {
-                id: "async-def".to_string(),
+                id: Some("async-def".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\basync\s+def\b".to_string(),
                 replace: "def".to_string(),
             },
             Rule {
-                id: "async-with".to_string(),
+                id: Some("async-with".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\basync\s+with\b".to_string(),
                 replace: "with".to_string(),
             },
             Rule {
-                id: "async-for".to_string(),
+                id: Some("async-for".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\basync\s+for\b".to_string(),
                 replace: "for".to_string(),
             },
             Rule {
-                id: "strip-await".to_string(),
+                id: Some("strip-await".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\bawait\s+".to_string(),
                 replace: "".to_string(),
             },
             Rule {
-                id: "dunder-anext".to_string(),
+                id: Some("dunder-anext".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\b__anext__\b".to_string(),
                 replace: "__next__".to_string(),
             },
             Rule {
-                id: "dunder-aenter".to_string(),
+                id: Some("dunder-aenter".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\b__aenter__\b".to_string(),
                 replace: "__enter__".to_string(),
             },
             Rule {
-                id: "dunder-aexit".to_string(),
+                id: Some("dunder-aexit".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\b__aexit__\b".to_string(),
                 replace: "__exit__".to_string(),
             },
             Rule {
-                id: "dunder-aiter".to_string(),
+                id: Some("dunder-aiter".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\b__aiter__\b".to_string(),
                 replace: "__iter__".to_string(),
             },
             Rule {
-                id: "aiter".to_string(),
+                id: Some("aiter".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\baiter\b".to_string(),
                 replace: "iter".to_string(),
             },
             Rule {
-                id: "async-iterator".to_string(),
+                id: Some("async-iterator".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\bAsyncIterator\b".to_string(),
                 replace: "Iterator".to_string(),
             },
             Rule {
-                id: "asynccontextmanager".to_string(),
+                id: Some("asynccontextmanager".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\basynccontextmanager\b".to_string(),
                 replace: "contextmanager".to_string(),
             },
             Rule {
-                id: "abstract-async-context-manager".to_string(),
+                id: Some("abstract-async-context-manager".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\bAbstractAsyncContextManager\b".to_string(),
                 replace: "AbstractContextManager".to_string(),
             },
             Rule {
-                id: "from-asyncio-sleep".to_string(),
+                id: Some("from-asyncio-sleep".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"from asyncio import sleep".to_string(),
                 replace: "from time import sleep".to_string(),
             },
             Rule {
-                id: "from-asyncio-condition".to_string(),
+                id: Some("from-asyncio-condition".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"from asyncio import Condition".to_string(),
                 replace: "from threading import Condition".to_string(),
             },
             Rule {
-                id: "from-asyncio-semaphore".to_string(),
+                id: Some("from-asyncio-semaphore".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"from asyncio import Semaphore".to_string(),
                 replace: "from threading import Semaphore".to_string(),
             },
             Rule {
-                id: "from-asyncio-lock".to_string(),
+                id: Some("from-asyncio-lock".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"from asyncio import Lock".to_string(),
                 replace: "from threading import Lock".to_string(),
             },
             Rule {
-                id: "import-asyncio-to-threading".to_string(),
+                id: Some("import-asyncio-to-threading".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"import asyncio".to_string(),
                 replace: "import threading".to_string(),
             },
             Rule {
-                id: "asyncio-condition".to_string(),
+                id: Some("asyncio-condition".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"asyncio\.Condition".to_string(),
                 replace: "threading.Condition".to_string(),
             },
             Rule {
-                id: "asyncio-lock".to_string(),
+                id: Some("asyncio-lock".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"asyncio\.Lock".to_string(),
                 replace: "threading.Lock".to_string(),
             },
             Rule {
-                id: "asyncio-semaphore".to_string(),
+                id: Some("asyncio-semaphore".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"asyncio\.Semaphore".to_string(),
                 replace: "threading.Semaphore".to_string(),
             },
             Rule {
-                id: "asyncio-timeout-error".to_string(),
+                id: Some("asyncio-timeout-error".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"asyncio\.TimeoutError".to_string(),
                 replace: "TimeoutError".to_string(),
             },
             Rule {
-                id: "pytest-mark-asyncio".to_string(),
+                id: Some("pytest-mark-asyncio".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"@pytest\.mark\.asyncio".to_string(),
                 replace: "".to_string(),
             },
             Rule {
-                id: "stop-async-iteration".to_string(),
+                id: Some("stop-async-iteration".to_string()),
                 kind: RuleKind::Regex,
                 match_pattern: r"\bStopAsyncIteration\b".to_string(),
                 replace: "StopIteration".to_string(),

ry_cli-0.4.0/tests/fixtures/basic_async_to_sync/output.txt

@@ -0,0 +1,2 @@
+input.py:1:0: error: Generate marker @sync must be followed by a generated node
+Processed 1 file(s) with 1 error(s) and 0 warning(s)

ry_cli-0.4.0/tests/fixtures/outdated_generated_code/expected.py

@@ -0,0 +1,7 @@
+async def fetch_data():  # unasync: generate @sync
+    result = await get_data()
+    return result
+
+def fetch_data():  # unasync: generated @sync
+    result = get_data()
+    return result

ry_cli-0.4.0/tests/fixtures/outdated_generated_code/input.py

@@ -0,0 +1,7 @@
+async def fetch_data():  # unasync: generate @sync
+    result = await get_data()
+    return result
+
+async def fetch_data():  # unasync: generated @sync
+    result = await get_data()
+    return result

ry_cli-0.4.0/tests/fixtures/outdated_generated_code/output.txt

@@ -0,0 +1,8 @@
+input.py:1:0: error: Generated code @sync is out of sync with generate marker
+diff for input.py:1:
+-async def fetch_data():  # unasync: generated @sync
+-    result = await get_data()
++def fetch_data():  # unasync: generated @sync
++    result = get_data()
+     return result
+Processed 1 file(s) with 1 error(s) and 0 warning(s)

ry_cli-0.4.0/tests/fixtures/outdated_generated_code/ry.yml

@@ -0,0 +1,8 @@
+version: 1
+
+defaults:
+  include:
+    - package: std
+
+targets:
+  - tag: sync

ry_cli-0.4.0/tests/fixtures/tag_rules/output.txt

@@ -0,0 +1,2 @@
+input.py:1:0: error: Generate marker @mytag must be followed by a generated node
+Processed 1 file(s) with 1 error(s) and 0 warning(s)

{ry_cli-0.2.0 → ry_cli-0.4.0}/tests/fixtures.rs

@@ -3,6 +3,7 @@ use ry::config::Config;
 use ry::inline::process_file_inline;
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use tempfile::TempDir;
 
 fn get_fixture_dirs() -> Vec<PathBuf> {
@@ -77,6 +78,42 @@ fn run_fixture_test(fixture_dir: &Path) {
             fixture_name
         );
     }
+
+    let output_path = fixture_dir.join("output.txt");
+
+    let temp_check = temp_dir.path().join("check_input.py");
+    fs::copy(&input_path, &temp_check).unwrap();
+
+    let bin = env!("CARGO_BIN_EXE_ry");
+    let output = Command::new(bin)
+        .args([
+            "--config",
+            config_path.to_str().unwrap(),
+            "--verbose",
+            temp_check.to_str().unwrap(),
+        ])
+        .output()
+        .expect("failed to run ry binary");
+
+    let temp_str = temp_check.to_str().unwrap();
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stderr),
+        String::from_utf8_lossy(&output.stdout),
+    )
+    .replace(temp_str, "input.py");
+
+    if update_fixtures || !output_path.exists() {
+        fs::write(&output_path, &combined).unwrap();
+        println!("Fixture '{}': Generated output.txt", fixture_name);
+    } else {
+        let expected_output = fs::read_to_string(&output_path).unwrap();
+        assert_eq!(
+            combined, expected_output,
+            "Fixture '{}': Output does not match output.txt",
+            fixture_name
+        );
+    }
 }
 
 #[test]

ry_cli-0.4.0/uv.lock

@@ -0,0 +1,7 @@
+version = 1
+revision = 3
+requires-python = ">=3.8"
+
+[[package]]
+name = "ry-cli"
+source = { editable = "." }

ry_cli-0.2.0/CHANGELOG.md

@@ -1,20 +0,0 @@
-# Changelog
-
-## [0.2.0](https://github.com/karpetrosyan/ry/compare/v0.1.0...v0.2.0) (2026-04-09)
-
-
-### Features
-
-* add support for passing multiple PATHs ([27f91f7](https://github.com/karpetrosyan/ry/commit/27f91f7a5b5db7b6bb803a6e896fe09c96456f36))
-
-
-### Bug Fixes
-
-* remove redundant generation file ([fe9dbc4](https://github.com/karpetrosyan/ry/commit/fe9dbc4a66392c96019799746c09bd0992dd4d53))
-
-## 0.1.0 (2026-04-08)
-
-
-### Features
-
-* first release ([e1aed91](https://github.com/karpetrosyan/ry/commit/e1aed91f6370bb3832b72be8164c4591e456d0da))