sin_fast_blank 2.1.0-java → 2.2.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dfb51b781203256e9e6f7b3b8e9fc80613b392fadcd1f7fb8ff3d4b9e154a6d
-  data.tar.gz: da6c6172b1fd46bec2815eecc9daece7f3a9386a6ebb836a636f28de383700f4
+  metadata.gz: 0cb9e8a93a0051213bd80b9c47b8247847a4d389e239715856c58335758dcbf8
+  data.tar.gz: b9b7d48920cd5c68dfd02e2ca3b87f98dffe3a45b195ac682429054aaed2b84b
 SHA512:
-  metadata.gz: c707acc7821c40d9ea36443b2031cb777aef00db9bd72c7c1175413ecb35787e8e4a7b4e8a170869df982c692b42fca4da357a837826fb0de83c8952b7f82cb2
-  data.tar.gz: 3e53e42b7a3b126e3d4e0db3da7542b5d5619980c058cf4fb85a387f54f556b92b57a37e74bb232f7151b9f9c2ef3330114f28a96d94fb07c16985546554dced
+  metadata.gz: 00a76dcb482ecac9e61e7df4f675aec5863685652cc3adfc2cb0b35f8aee7b2b5e50bd3daa470d6bb94dddba59585df4ab6a6d2da63f130ce9ccc06d2c4c6b1c
+  data.tar.gz: 5999b81de14b1f220d3a6552d5c587c5d6dc5fbccd186978591ba6be1a9de16ebc533fabf428efa68700ff8e444daaae872bde5eec1f087ade27a0b51385b330

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.1.0
+  version: 2.2.1
 platform: java
 authors:
 - Masahiro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-17 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Ruby extension library for fast blank string checking.
+  Ruby extension library for up to 9x 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.1.0
+homepage: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.1
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.1.0
-  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.1.0
-  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v2.1.0/CHANGELOG.md
+  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.1
+  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v2.2.1
+  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v2.2.1/CHANGELOG.md
   bug_tracker_uri: https://github.com/cadenza-tech/sin_fast_blank/issues
-  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/2.1.0
+  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/2.2.1
   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 9x faster blank string checking than fast_blank
+  gem.
 test_files: []