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

{ry_cli-0.2.0 → ry_cli-0.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.3.0](https://github.com/karpetrosyan/ry/compare/v0.2.0...v0.3.0) (2026-04-10)
+
+
+### Features
+
+* make rule's id optional ([7c2d7a5](https://github.com/karpetrosyan/ry/commit/7c2d7a54cae7dbf810383127c0262e08bc648b0f))
+
 ## [0.2.0](https://github.com/karpetrosyan/ry/compare/v0.1.0...v0.2.0) (2026-04-09)
 
 

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

@@ -375,7 +375,7 @@ dependencies = [
 
 [[package]]
 name = "ry"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "clap",
  "glob",

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

@@ -1,6 +1,6 @@
 [package]
 name = "ry"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 readme = "README.md"
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ry-cli
-Version: 0.2.0
+Version: 0.3.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.3.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.3.0}/src/config.rs

@@ -34,7 +34,8 @@ 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>,
     pub kind: RuleKind,
     #[serde(rename = "match")]
     pub match_pattern: String,
@@ -88,10 +89,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 +99,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.3.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.3.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(),