rust_regexp 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b40dce5345e9d2dddf0899c5967ed4804c7ed37ff9c7c9dabd7fd0071690fcc1
-  data.tar.gz: ea50b0251c8c8b1be2fc0ebe2bd368185e7f01107d0747ac694b615565cf53e0
+  metadata.gz: 3fa462b537e9c799b5939981d347a240e31d6cf982cee50d3c63dff6f2fbc98b
+  data.tar.gz: bf19b0f1a052b8961645f216e4b2ce9ee4168f2447311752e1c7550f57f64286
 SHA512:
-  metadata.gz: 7a7307c4f68f3e56a2574ec531610f410681df01af682cf04592f6a9393318e5c820eed11c9fb90009ea0a5e08e4dfeb5a07be6f7a8c513809ac8000fecfcd50
-  data.tar.gz: 17565b8d2ee5f841fd4cb10d4d37c4feedfd3bd40db8c40a2437287f558abc213de5c67f586e5771c0830153d41102f436d831655056a52d79d31214fcaf3c2f
+  metadata.gz: 4cf864254f850c217dfb4c74a861c59748de044306a43a702c9c4fc677fa5a2afef9e9231a24e47f6bbce6ee6ae382f370463fafa8782e290e15d24728d1c932
+  data.tar.gz: 3e8f831f749e1ff403d4b72b5e49ad07ae7603a878086cd192cbe396760cb3682a02715f43cdcce49a4ef2a545255225ab8db33af91c9de17e89f23e53327c82

data/README.md

@@ -114,6 +114,28 @@ RustRegexp::Set.new(["abc", "def"]).patterns
 # => ["abc", "def"]
 ```
 
+## Encoding
+
+Currently, `rust_regexp` expects the haystack to be an UTF-8 string.
+
+It also supports parsing of strings with invalid UTF-8 characters by default. It's achieved via using `regex::bytes` instead of plain `regex` under the hood, so any byte sequence can be matched. The output match is encoded as UTF-8 string.
+
+In case unicode awarness of matchers should be disabled, both `RustRegexp` and `RustRegexp::Set` support `unicode: false` option:
+
+```ruby
+RustRegexp.new('\w+').match('ю٤夏')
+# => ["ю٤夏"]
+
+RustRegexp.new('\w+', unicode: false).match('ю٤夏')
+# => []
+
+RustRegexp::Set.new(['\w', '\d', '\s']).match("ю٤\u2000")
+# => [0, 1, 2]
+
+RustRegexp::Set.new(['\w', '\d', '\s'], unicode: false).match("ю٤\u2000")
+# => []
+```
+
 ## Development
 
 ```sh

data/ext/rust_regexp/src/lib.rs

@@ -1,28 +1,29 @@
 use magnus::{
-    class,
-    define_class,
+    class, define_class,
     encoding::RbEncoding,
-    exception,
-    function,
-    method,
-    prelude::*,
-    scan_args::scan_args,
-    Value,
-    Error,
-    RString,
-    RArray,
+    exception, function, method,
+    scan_args::{get_kwargs, scan_args},
+    Error, Module, Object, RArray, RHash, RString, Value,
 };
-use regex::bytes::{Regex, RegexSet, Match};
+use regex::bytes::{Match, Regex, RegexBuilder, RegexSet, RegexSetBuilder};
 
 #[magnus::wrap(class = "RustRegexp", free_immediately, size)]
 pub struct RustRegexp(Regex);
 
 impl RustRegexp {
     pub fn new(args: &[Value]) -> Result<Self, Error> {
-        let args = scan_args::<(String,), (), (), (), (), ()>(args)?;
+        let args = scan_args::<(String,), (), (), (), RHash, ()>(args)?;
+        let kwargs = get_kwargs::<_, (), (Option<bool>,), ()>(args.keywords, &[], &["unicode"])?;
+
         let pattern = args.required.0;
+        let (unicode,) = kwargs.optional;
+        let unicode = unicode.unwrap_or_else(|| true);
 
-        let regex = Regex::new(&pattern).map_err(|e| Error::new(exception::arg_error(), e.to_string()))?;
+        let mut builder = RegexBuilder::new(&pattern);
+        let regex = builder
+            .unicode(unicode)
+            .build()
+            .map_err(|e| Error::new(exception::arg_error(), e.to_string()))?;
 
         Ok(Self(regex))
     }
@@ -90,9 +91,7 @@ impl RustRegexp {
                     }
                 }
 
-                result
-                    .push(group)
-                    .expect("Non-frozen array");
+                result.push(group).expect("Non-frozen array");
             }
         }
 
@@ -113,10 +112,7 @@ impl RustRegexp {
     }
 
     fn capture_to_ruby_string(capture: &Match) -> RString {
-        RString::enc_new(
-            capture.as_bytes(),
-            RbEncoding::utf8()
-        )
+        RString::enc_new(capture.as_bytes(), RbEncoding::utf8())
     }
 }
 
@@ -125,10 +121,18 @@ pub struct RustRegexpSet(RegexSet);
 
 impl RustRegexpSet {
     pub fn new(args: &[Value]) -> Result<Self, Error> {
-        let args = scan_args::<(Vec<String>,), (), (), (), (), ()>(args)?;
+        let args = scan_args::<(Vec<String>,), (), (), (), RHash, ()>(args)?;
+        let kwargs = get_kwargs::<_, (), (Option<bool>,), ()>(args.keywords, &[], &["unicode"])?;
+
         let patterns = args.required.0;
+        let (unicode,) = kwargs.optional;
+        let unicode = unicode.unwrap_or_else(|| true);
 
-        let set = RegexSet::new(patterns).map_err(|e| Error::new(exception::arg_error(), e.to_string()))?;
+        let mut builder = RegexSetBuilder::new(patterns);
+        let set = builder
+            .unicode(unicode)
+            .build()
+            .map_err(|e| Error::new(exception::arg_error(), e.to_string()))?;
 
         Ok(Self(set))
     }
@@ -137,7 +141,7 @@ impl RustRegexpSet {
         let set = &self.0;
         let haystack = unsafe { haystack.as_slice() };
 
-        set.matches(haystack).into_iter().collect()
+        set.matches(haystack).iter().collect()
     }
 
     pub fn is_match(&self, haystack: RString) -> bool {

data/lib/rust_regexp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class RustRegexp
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rust_regexp
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Dmytro Horoshko