sin_fast_blank 2.0.0-java → 2.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eeb9b11b9d94d52aa750db25c24b6f03aff5683df7de915585b45659aaa36532
-  data.tar.gz: 19303166df58b7b7cb15b97593c214acd802fa170fa99334921d5a054d0406e3
+  metadata.gz: 4125dc1615ec3cc184351ae211c6d3d5be9590b0d939dd892a5be87051c958a0
+  data.tar.gz: 00b8575eb8de3575323fa46f9bb529f6c3c2f34a07f919eeb0ba2a55b4dd1a95
 SHA512:
-  metadata.gz: 06eaa63aaa21b76d7deca1ed55cb1aad6a04c0bf5923159d6e7e235e563c1b2a772a57136541da2e7acc71fb213e0e78b78d56076785016f79b6f971ca46ecb5
-  data.tar.gz: 1283ffc9c079f99d1814e091dc0b42b36eaf5930a86d1aafbc34cfcc6d09f040150374378921596e72f682f1effe50d69664139bff8fc6b943e48c79943ddc99
+  metadata.gz: 5bc8f0ff4c7aa229d599567b18dc2ceda3af9d5a44e48ef790048c84cb83a2ea21e5c982f880adf1ae093ea7a83c4fd64302bb86c6c085397a53997beef369a5
+  data.tar.gz: c8ae664540a76c36537c3f895f52ee7776d2250b179fc53af417f5ce684aa8d56514ec7599c9bc5c7c6f11fcc17c4354686e1004b887b0317be156c99f743512

data/ext/java/sin_fast_blank/SinFastBlankLibrary.java

@@ -12,104 +12,148 @@ import org.jruby.util.StringSupport;
 import org.jruby.util.io.EncodingUtils;
 
 public class SinFastBlankLibrary implements Library {
-  public void load(Ruby runtime, boolean wrap) {
-    runtime.getString().defineAnnotatedMethods(SinFastBlankLibrary.class);
-  }
-
-  @JRubyMethod(name = "blank_as?")
-  public static IRubyObject blank_as_p(ThreadContext context, IRubyObject self) {
-    RubyString str = (RubyString) self;
-    if (str.size() == 0) return context.tru;
-
-    Ruby runtime = context.runtime;
-    ByteList sByteList = str.getByteList();
-    byte[] sBytes = sByteList.unsafeBytes();
-    int s = sByteList.begin();
-    int e = s + sByteList.realSize();
-    int[] len = {0};
-    Encoding enc = str.getEncoding();
-
-    while (s < e) {
-      int codepoint = EncodingUtils.encCodepointLength(runtime, sBytes, s, e, len, enc);
-
-      switch (codepoint) {
-        case 9:
-        case 0xa:
-        case 0xb:
-        case 0xc:
-        case 0xd:
-        case 0x20:
-        case 0x85:
-        case 0xa0:
-        case 0x1680:
-        case 0x2000:
-        case 0x2001:
-        case 0x2002:
-        case 0x2003:
-        case 0x2004:
-        case 0x2005:
-        case 0x2006:
-        case 0x2007:
-        case 0x2008:
-        case 0x2009:
-        case 0x200a:
-        case 0x2028:
-        case 0x2029:
-        case 0x202f:
-        case 0x205f:
-        case 0x3000:
-          break;
-        default:
-          return context.fals;
-      }
-
-      s += len[0];
+    @Override
+    public void load(Ruby runtime, boolean wrap) {
+        runtime.getString().defineAnnotatedMethods(SinFastBlankLibrary.class);
     }
 
-    return context.tru;
-  }
+    @JRubyMethod(name = "blank_as?")
+    public static IRubyObject blank_as_p(ThreadContext context, IRubyObject self) {
+        RubyString str = (RubyString) self;
+        if (str.size() == 0) {
+            return context.tru;
+        }
+
+        ByteList sByteList = str.getByteList();
+        byte[] sBytes = sByteList.unsafeBytes();
+        int s = sByteList.begin();
+        int e = s + sByteList.realSize();
+
+        if (str.getCodeRange() == StringSupport.CR_7BIT) {
+            for (int i = s; i < e; i++) {
+                byte c = sBytes[i];
+                if (!isAsciiBlankAs(c)) {
+                    return context.fals;
+                }
+            }
+
+            return context.tru;
+        }
+
+        return blankAsSlow(context, sBytes, s, e, str.getEncoding());
+    }
 
-  @JRubyMethod(name = "blank?")
-  public static IRubyObject blank_p(ThreadContext context, IRubyObject self) {
-    RubyString str = (RubyString) self;
-    if (str.size() == 0) return context.tru;
+    private static boolean isAsciiBlankAs(byte c) {
+        switch (c) {
+            case 0x9:
+            case 0xa:
+            case 0xb:
+            case 0xc:
+            case 0xd:
+            case 0x20:
+                return true;
+            default:
+                return false;
+        }
+    }
 
-    ByteList sByteList = str.getByteList();
-    byte[] sBytes = sByteList.unsafeBytes();
-    int s = sByteList.begin();
-    int e = s + sByteList.realSize();
+    private static IRubyObject blankAsSlow(ThreadContext context, byte[] bytes, int s, int e, Encoding enc) {
+        Ruby runtime = context.runtime;
+        int[] len = {0};
 
-    // Move to slower path if the string contains non 7-bit ASCII.
-    if (str.getCodeRange() != StringSupport.CR_7BIT) return blankSlow(context, sBytes, s, e, str.getEncoding());
+        while (s < e) {
+            int codepoint = EncodingUtils.encCodepointLength(runtime, bytes, s, e, len, enc);
 
-    for (int i = s; i < e; i++) {
-      if (!isSpace(sBytes[i])) return context.fals;
-    }
+            if (!isUnicodeBlankAs(codepoint)) {
+                return context.fals;
+            }
 
-    return context.tru;
-  }
+            s += len[0];
+        }
 
-  private static IRubyObject blankSlow(ThreadContext context, byte[] bytes, int s, int e, Encoding enc) {
-    Ruby runtime = context.runtime;
-    int[] len = {0};
+        return context.tru;
+    }
 
-    while (s < e) {
-      int codepoint = EncodingUtils.encCodepointLength(runtime, bytes, s, e, len, enc);
-      if (!isSpaceCodepoint(codepoint) && codepoint != 0) return context.fals;
+    private static boolean isUnicodeBlankAs(int codepoint) {
+        switch (codepoint) {
+            case 0x9:
+            case 0xa:
+            case 0xb:
+            case 0xc:
+            case 0xd:
+            case 0x20:
+            case 0x85:
+            case 0xa0:
+            case 0x1680:
+            case 0x2000:
+            case 0x2001:
+            case 0x2002:
+            case 0x2003:
+            case 0x2004:
+            case 0x2005:
+            case 0x2006:
+            case 0x2007:
+            case 0x2008:
+            case 0x2009:
+            case 0x200a:
+            case 0x2028:
+            case 0x2029:
+            case 0x202f:
+            case 0x205f:
+            case 0x3000:
+                return true;
+            default:
+                return false;
+        }
+    }
 
-      s += len[0];
+    @JRubyMethod(name = "blank?")
+    public static IRubyObject blank_p(ThreadContext context, IRubyObject self) {
+        RubyString str = (RubyString) self;
+        if (str.size() == 0) {
+            return context.tru;
+        }
+
+        ByteList sByteList = str.getByteList();
+        byte[] sBytes = sByteList.unsafeBytes();
+        int s = sByteList.begin();
+        int e = s + sByteList.realSize();
+
+        if (str.getCodeRange() == StringSupport.CR_7BIT) {
+            for (int i = s; i < e; i++) {
+                if (!isSpace(sBytes[i])) {
+                    return context.fals;
+                }
+            }
+
+            return context.tru;
+        }
+
+        return blankSlow(context, sBytes, s, e, str.getEncoding());
     }
 
-    return context.tru;
-  }
+    private static IRubyObject blankSlow(ThreadContext context, byte[] bytes, int s, int e, Encoding enc) {
+        Ruby runtime = context.runtime;
+        int[] len = {0};
+
+        while (s < e) {
+            int codepoint = EncodingUtils.encCodepointLength(runtime, bytes, s, e, len, enc);
 
-  // MRI: rb_isspace
-  private static boolean isSpaceCodepoint(int codepoint) {
-    long c = codepoint & 0xFFFFFFFF;
-    return c == ' ' || ('\t' <= c && c <= '\r');
-  }
+            if (codepoint != 0 && !isSpaceCodepoint(codepoint)) {
+                return context.fals;
+            }
 
-  private static boolean isSpace(byte c) {
-    return c == ' ' || ('\t' <= c && c <= '\r') || c == '\0';
-  }
+            s += len[0];
+        }
+
+        return context.tru;
+    }
+
+    private static boolean isSpaceCodepoint(int codepoint) {
+        return codepoint == ' ' || ('\t' <= codepoint && codepoint <= '\r');
+    }
+
+    private static boolean isSpace(byte c) {
+        return c == ' ' || ('\t' <= c && c <= '\r') || c == '\0';
+    }
 }

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: sin_fast_blank
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: java
 authors:
 - Masahiro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 2025-03-02 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Ruby extension library for fast blank string checking.
+  Ruby extension library for up to 3x faster blank string checking than fast_blank gem.
   Forked from FastBlank.
 email:
 - watanabe@cadenza-tech.com
@@ -21,15 +21,15 @@ extra_rdoc_files: []
 files:
 - ext/java/sin_fast_blank/SinFastBlankLibrary.java
 - lib/sin_fast_blank/sin_fast_blank.jar
-homepage: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.0.0
+homepage: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.0
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.0.0
-  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.0.0
-  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v2.0.0/CHANGELOG.md
+  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.0
+  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.0
+  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v2.2.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/cadenza-tech/sin_fast_blank/issues
-  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/2.0.0
+  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/2.2.0
   funding_uri: https://patreon.com/CadenzaTech
   rubygems_mfa_required: 'true'
   required_jruby_version: ">= 9.3.0.0"
@@ -53,5 +53,6 @@ requirements: []
 rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
-summary: Ruby extension library for fast blank string checking.
+summary: Ruby extension library for up to 3x faster blank string checking than fast_blank
+  gem.
 test_files: []