strscan 3.1.7 → 3.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd2dcf02f3109bb80e827faa389189e0418661d1ad3e2891b3427de98ff91fb2
-  data.tar.gz: cdb3b869dd71609de50939b362ab5d9817222ed01d1c6993ac9a68bab898526b
+  metadata.gz: 144c87f4e5774d19bf10d74cdac87182c3c74d61d8bcee8abf8e4f499a151000
+  data.tar.gz: 735cd2043e82b4174dffed842d1d81c530fb3c782ae416d8c4985a40fdaa6f1c
 SHA512:
-  metadata.gz: d4157babafccbe1e81200a97fbc700ea17d4d6ed7f9853d2b3eae8d7ed1a8092d8178819de820c001f922f95ea31283b14e262a60041039323c1c2aa8743fb83
-  data.tar.gz: 53eb84583f0e59b3dd866b1811c8e7481bb0e505bb152fffe157aa08938779cd37e82d8153a82eb57f0f3c858235966a8ee2b5912dfa70576c9624d483816b32
+  metadata.gz: d99add3c119e1bfdb95f2a6c4dd3a1b3d1f321de66d0a3bd7a40e437d8520b81ec0da2c37ac74c4acd5d16af921fcf773a7e708a36a368a311aa25f59cccbd92
+  data.tar.gz: 6aef751e0fe071d1c9eaca9ca5be1569c5ce7f296e31ad4a70f834fc82ea931f536ba097692aab6c76d722573a82dee06574076f79237067de284e26411611c5

data/doc/strscan/link_refs.txt

@@ -1,5 +1,5 @@
 [1]: rdoc-ref:StringScanner@Stored+String
-[2]: rdoc-ref:StringScanner@Byte+Position+-28Position-29
+[2]: rdoc-ref:StringScanner@Byte+Position+Position
 [3]: rdoc-ref:StringScanner@Target+Substring
 [4]: rdoc-ref:StringScanner@Setting+the+Target+Substring
 [5]: rdoc-ref:StringScanner@Traversing+the+Target+Substring

data/doc/strscan/methods/skip_until.md

@@ -2,12 +2,13 @@ call-seq:
   skip_until(pattern) -> matched_substring_size or nil
 
 Attempts to [match][17] the given `pattern`
-anywhere (at any [position][2]) in the [target substring][3];
-does not modify the positions.
+anywhere (at any [position][2]) in the [target substring][3].
 
 If the match attempt succeeds:
 
 - Sets [match values][9].
+- Sets the [byte position][2] to the end of the matched substring;
+  may adjust the [character position][7].
 - Returns the size of the matched substring.
 
 ```rb
@@ -42,6 +43,7 @@ If the match attempt fails:
 
 - Clears match values.
 - Returns `nil`.
+- Does not update positions.
 
 ```rb
 scanner.skip_until(/nope/)     # => nil

data/doc/strscan/strscan.md

@@ -37,7 +37,7 @@ Some examples here assume that certain helper methods are defined:
 - `match_values_cleared?(scanner)`:
   Returns whether the scanner's [match values][9] are cleared.
 
-See examples at [helper methods](helper_methods.md).
+See examples at [helper methods](doc/strscan/helper_methods.md).
 
 ## The `StringScanner` \Object
 

data/ext/strscan/extconf.rb

@@ -5,6 +5,8 @@ if RUBY_ENGINE == 'ruby'
   have_func("onig_region_memsize(NULL)")
   have_func("rb_reg_onig_match", "ruby/re.h")
   have_func("rb_deprecate_constant")
+  have_func("rb_gc_location", "ruby.h") # RUBY_VERSION >= 2.7
+  have_const("RUBY_TYPED_EMBEDDABLE", "ruby.h") # RUBY_VERSION >= 3.3
   create_makefile 'strscan'
 else
   File.write('Makefile', dummy_makefile("").join)

data/ext/strscan/strscan.c

@@ -22,7 +22,7 @@ extern size_t onig_region_memsize(const struct re_registers *regs);
 
 #include <stdbool.h>
 
-#define STRSCAN_VERSION "3.1.7"
+#define STRSCAN_VERSION "3.1.8"
 
 
 #ifdef HAVE_RB_DEPRECATE_CONSTANT
@@ -182,12 +182,35 @@ extract_beg_len(struct strscanner *p, long beg_i, long len)
                                Constructor
    ======================================================================= */
 
+#ifdef RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+#else
+# ifdef HAVE_CONST_RUBY_TYPED_EMBEDDABLE
+#  define RUBY_TYPED_EMBEDDABLE RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+# else
+#  define RUBY_TYPED_EMBEDDABLE 0
+# endif
+#endif
+
+#ifdef HAVE_RB_GC_LOCATION
+static void
+strscan_compact(void *ptr)
+{
+    struct strscanner *p = ptr;
+    p->str = rb_gc_location(p->str);
+    p->regex = rb_gc_location(p->regex);
+}
+#else
+#define rb_gc_mark_movable rb_gc_mark
+#endif
+
 static void
 strscan_mark(void *ptr)
 {
     struct strscanner *p = ptr;
-    rb_gc_mark(p->str);
-    rb_gc_mark(p->regex);
+    rb_gc_mark_movable(p->str);
+    rb_gc_mark_movable(p->regex);
 }
 
 static void
@@ -195,24 +218,37 @@ strscan_free(void *ptr)
 {
     struct strscanner *p = ptr;
     onig_region_free(&(p->regs), 0);
+#ifndef HAVE_RUBY_TYPED_EMBEDDABLE
     ruby_xfree(p);
+#endif
 }
 
 static size_t
 strscan_memsize(const void *ptr)
 {
-    const struct strscanner *p = ptr;
-    size_t size = sizeof(*p) - sizeof(p->regs);
+    size_t size = 0;
+#ifndef HAVE_RUBY_TYPED_EMBEDDABLE
+    size += sizeof(struct strscanner);
+#endif
+
 #ifdef HAVE_ONIG_REGION_MEMSIZE
-    size += onig_region_memsize(&p->regs);
+    const struct strscanner *p = ptr;
+    size += onig_region_memsize(&p->regs) - sizeof(p->regs);
 #endif
     return size;
 }
 
 static const rb_data_type_t strscanner_type = {
-    "StringScanner",
-    {strscan_mark, strscan_free, strscan_memsize},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+    .wrap_struct_name = "StringScanner",
+    .function = {
+        .dmark = strscan_mark,
+        .dfree = strscan_free,
+        .dsize = strscan_memsize,
+#ifdef HAVE_RB_GC_LOCATION
+        .dcompact = strscan_compact,
+#endif
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
 };
 
 static VALUE
@@ -1261,16 +1297,17 @@ strscan_parse_integer(struct strscanner *p, int base, long len)
 }
 
 static inline bool
-strscan_ascii_compat_fastpath(VALUE str) {
+strscan_ascii_compat_fastpath(VALUE str)
+{
     int encindex = ENCODING_GET_INLINED(str);
-    // The overwhelming majority of strings are in one of these 3 encodings.
+    /* The overwhelming majority of strings are in one of these 3 encodings. */
     return encindex == utf8_encindex || encindex == binary_encindex || encindex == usascii_encindex;
 }
 
 static inline void
 strscan_must_ascii_compat(VALUE str)
 {
-    // The overwhelming majority of strings are in one of these 3 encodings.
+    /* The overwhelming majority of strings are in one of these 3 encodings. */
     if (RB_LIKELY(strscan_ascii_compat_fastpath(str))) {
         return;
     }
@@ -2299,6 +2336,4 @@ Init_strscan(void)
     rb_define_method(StringScanner, "fixed_anchor?", strscan_fixed_anchor_p, 0);
 
     rb_define_method(StringScanner, "named_captures", strscan_named_captures, 0);
-
-    rb_require("strscan/strscan");
 }

data/lib/strscan/truffleruby.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+# truffleruby_primitives: true
+
+class StringScanner
+  class Error < StandardError
+  end
+  # :stopdoc:
+  unless ::Object.const_defined?(:ScanError)
+    ::Object::ScanError = Error
+    ::Object.deprecate_constant :ScanError
+  end
+
+  Version = '3.1.8'
+  Id = '$Id$'
+
+  def self.must_C_version = self
+  # :startdoc:
+
+  attr_reader :string, :pos
+  alias_method :pointer, :pos
+
+  def initialize(string, options = nil, fixed_anchor: false)
+    @string = Primitive.convert_with_to_str(string)
+    @fixed_anchor = Primitive.as_boolean(fixed_anchor)
+    @pos = 0
+    @last_match = nil
+  end
+
+  def inspect
+    return "#<#{Primitive.class(self)} (uninitialized)>" unless @string
+    return "#<#{Primitive.class(self)} fin>" if eos?
+
+    before =
+      if @pos == 0
+        ''
+      elsif @pos < 5
+        "#{@string.byteslice(0, @pos).inspect} "
+      else
+        "#{('...' + @string.byteslice(@pos - 5, 5)).inspect} "
+      end
+
+    after =
+      if @pos >= @string.bytesize - 5
+        " #{@string.byteslice(@pos..).inspect}"
+      else
+        " #{(@string.byteslice(@pos, 5) + '...').inspect}"
+      end
+
+    "#<#{Primitive.class(self)} #{@pos}/#{@string.bytesize} #{before}@#{after}>"
+  end
+
+  def pos=(new_pos)
+    if new_pos < 0
+      new_pos += @string.bytesize
+    end
+    raise RangeError, 'index out of range' if new_pos < 0
+    raise RangeError, 'index out of range' if new_pos > @string.bytesize
+    @pos = new_pos
+  end
+  alias_method :pointer=, :pos=
+
+  def charpos = Primitive.string_byte_index_to_character_index(@string, @pos)
+
+  def rest = @string.byteslice(@pos, @string.bytesize)
+
+  def rest_size = @string.bytesize - @pos
+
+  def concat(more_string)
+    @string.concat(Primitive.convert_with_to_str(more_string))
+    self
+  end
+  alias_method :<<, :concat
+
+  def string=(other_string)
+    @string = Primitive.convert_with_to_str(other_string)
+    @pos = 0
+    @last_match = nil
+    other_string
+  end
+
+  def reset
+    @pos = 0
+    @last_match = nil
+    self
+  end
+
+  def terminate
+    @pos = @string.bytesize
+    @last_match = nil
+    self
+  end
+
+  def unscan
+    if @last_match
+      @pos = Primitive.match_data_byte_begin(@last_match, 0)
+      @last_match = nil
+      self
+    else
+      raise Error, 'unscan failed: previous match record not exist'
+    end
+  end
+
+  # Predicates
+
+  def fixed_anchor? = @fixed_anchor
+
+  def beginning_of_line?
+    @pos == 0 or @string.byteslice(@pos-1, 1) == "\n"
+  end
+  alias_method :bol?, :beginning_of_line?
+
+  def eos?
+    @pos >= @string.bytesize
+  end
+
+  def rest?
+    !eos?
+  end
+
+  # MatchData-like methods
+
+  def matched? = !Primitive.nil?(@last_match)
+
+  def matched = @last_match&.to_s
+
+  def [](group)
+    raise TypeError, 'no implicit conversion of Range into Integer' if Primitive.is_a?(group, Range)
+
+    if @last_match
+      @last_match[group]
+    else
+      nil
+    end
+  end
+
+  def values_at(*groups) = @last_match&.values_at(*groups)
+
+  def captures = @last_match&.captures
+
+  def size = @last_match&.size
+
+  def pre_match = @last_match&.pre_match
+
+  def post_match = @last_match&.post_match
+
+  def named_captures = @last_match&.named_captures || {}
+
+  def matched_size
+    if @last_match
+      Primitive.match_data_byte_end(@last_match, 0) - Primitive.match_data_byte_begin(@last_match, 0)
+    end
+  end
+
+  # Scan-like methods
+
+  def peek(length)
+    raise ArgumentError, 'negative string size (or size too big)' if length < 0
+    @string.byteslice(@pos, length)
+  end
+
+  def peek_byte = @string.getbyte(@pos)
+
+  def get_byte
+    return nil if eos?
+
+    byte = @string.byteslice(@pos, 1)
+    to = @pos + 1
+    @last_match = Primitive.matchdata_create_single_group(byte, @string, @pos, to)
+    @pos = to
+    byte
+  end
+
+  def scan_byte
+    return nil if eos?
+
+    byte_value = @string.getbyte(@pos)
+    get_byte
+    byte_value
+  end
+
+  def getch = scan(/./m)
+
+  def scan_integer(base: 10)
+    case base
+    when 10
+      scan(/[+-]?\d+/)&.to_i
+    when 16
+      scan(/[+-]?(0x)?[0-9a-fA-F]+/)&.to_i(16)
+    else
+      raise ArgumentError, "Unsupported integer base: #{base.inspect}, expected 10 or 16"
+    end
+  end
+
+  def scan_full(pattern, advance_pointer, return_string)
+    if advance_pointer
+      if return_string
+        scan(pattern)
+      else
+        skip(pattern)
+      end
+    else
+      if return_string
+        check(pattern)
+      else
+        match?(pattern)
+      end
+    end
+  end
+  Primitive.always_split self, :scan_full
+
+  def search_full(pattern, advance_pointer, return_string)
+    if advance_pointer
+      if return_string
+        scan_until(pattern)
+      else
+        skip_until(pattern)
+      end
+    else
+      if return_string
+        check_until(pattern)
+      else
+        exist?(pattern)
+      end
+    end
+  end
+  Primitive.always_split self, :search_full
+
+  # Keep the following 8 methods in sync, they are small variations of one another
+
+  # Matches at start methods
+
+  # Matches at start, returns matched string, does not advance position
+  def check(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_match_at_start(pattern, @string, prev, start)
+      if @last_match
+        @last_match.to_s
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if rest.start_with?(pattern)
+        to = prev + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, prev, to)
+        pattern
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :check
+
+  # Matches at start, returns matched string, advances position
+  def scan(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_match_at_start(pattern, @string, prev, start)
+      if @last_match
+        @pos = Primitive.match_data_byte_end(@last_match, 0)
+        @last_match.to_s
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if rest.start_with?(pattern)
+        to = prev + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, prev, to)
+        @pos = to
+        pattern
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :scan
+
+  # Matches at start, returns matched bytesize, does not advance position
+  def match?(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_match_at_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        to - prev
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if rest.start_with?(pattern)
+        to = prev + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, prev, to)
+        to - prev
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :match?
+
+  # Matches at start, returns matched bytesize, advances position
+  def skip(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_match_at_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        @pos = to
+        to - prev
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if rest.start_with?(pattern)
+        to = prev + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, prev, to)
+        @pos = to
+        to - prev
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :skip
+
+  # Matches anywhere methods
+
+  # Matches anywhere, returns matched string, does not advance position
+  def check_until(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_search_with_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        @string.byteslice(prev, to - prev)
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if from = @string.byteindex(pattern, prev)
+        to = from + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, from, to)
+        @string.byteslice(prev, to - prev)
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :check_until
+
+  # Matches anywhere, returns matched string, advances position
+  def scan_until(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_search_with_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        @pos = to
+        @string.byteslice(prev, to - prev)
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if from = @string.byteindex(pattern, prev)
+        to = from + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, from, to)
+        @pos = to
+        @string.byteslice(prev, to - prev)
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :scan_until
+
+  # Matches anywhere, returns matched bytesize, does not advance position
+  def exist?(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_search_with_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        to - prev
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if from = @string.byteindex(pattern, prev)
+        to = from + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, from, to)
+        to - prev
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :exist?
+
+  # Matches anywhere, returns matched bytesize, advances position
+  def skip_until(pattern)
+    prev = @pos
+    if Primitive.is_a?(pattern, Regexp)
+      start = @fixed_anchor ? 0 : prev
+      @last_match = Primitive.regexp_search_with_start(pattern, @string, prev, start)
+      if @last_match
+        to = Primitive.match_data_byte_end(@last_match, 0)
+        @pos = to
+        to - prev
+      end
+    else
+      pattern = Primitive.convert_with_to_str(pattern)
+      if from = @string.byteindex(pattern, prev)
+        to = from + pattern.bytesize
+        @last_match = Primitive.matchdata_create_single_group(pattern, @string, from, to)
+        @pos = to
+        to - prev
+      else
+        @last_match = nil
+      end
+    end
+  end
+  Primitive.always_split self, :skip_until
+end

data/lib/strscan.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+case RUBY_ENGINE
+when 'ruby'
+  require 'strscan.so'
+  require_relative 'strscan/strscan'
+when 'jruby'
+  require 'strscan.jar'
+  JRuby::Util.load_ext('org.jruby.ext.strscan.StringScannerLibrary')
+  require_relative 'strscan/strscan'
+when 'truffleruby'
+  if RUBY_ENGINE_VERSION.to_i >= 34
+    require 'strscan/truffleruby'
+  else
+    $LOAD_PATH.delete __dir__
+    require 'strscan'
+  end
+else
+  raise NotImplementedError, "Unknown Ruby: #{RUBY_ENGINE}"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strscan
 version: !ruby/object:Gem::Version
-  version: 3.1.7
+  version: 3.1.8
 platform: ruby
 authors:
 - Minero Aoki
@@ -53,7 +53,9 @@ files:
 - doc/strscan/strscan.md
 - ext/strscan/extconf.rb
 - ext/strscan/strscan.c
+- lib/strscan.rb
 - lib/strscan/strscan.rb
+- lib/strscan/truffleruby.rb
 homepage: https://github.com/ruby/strscan
 licenses:
 - Ruby
@@ -74,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Provides lexical scanning operations on a String.
 test_files: []