character_set 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 778cea0208adb290e09f454e3f88c021531decede99604cf2b67f48c9ab3bcd8
-  data.tar.gz: 43672f0afce2846bec846791e7445c9614605194967e061b1d9f0be305298be4
+  metadata.gz: ebb6792f685df02534f1ef04a92d7f0c5fdcb482e5aaa4856d7a39726e17f007
+  data.tar.gz: c6630aab9b6506c46a970ba83c257cd753f8f76760b6ce8d2639f51efba83eeb
 SHA512:
-  metadata.gz: 635f9fb21c973b03b9a0556f2b6cf2c608753acb73616aa8681a5bada3418f955ec887164a03fd2add4edae8a60292eb6e4b681d11a8cf33d1083499afe83815
-  data.tar.gz: 6a80f4f7f3f6c2357d84dc71bb5086f273471a8ae5af4e09abc502dc9893da90962d49527b40564de664af0a910f2e99720062dd41ba53427882ecb36e1a40a0
+  metadata.gz: 4c773a0546d05939d0b295e50355c6efe870a1ed74901d63c24097ff598d4a43bcd00ce2d03fb492a48fd9c03968a79ee78b789d92836843d6621dca3e8f313c
+  data.tar.gz: 560d3c3aa3f7e4daac3b6d2c89fb9dd6840777fa4d5896fb33564023ef745d81a7e4d0e51fe0ba42f6cd4504bc0b088657cd4ef1ab15d213aa1bb096ba404542

data/.github/workflows/gouteur.yml

@@ -11,7 +11,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 2.7
+          ruby-version: 3.3
       - name: Prepare
         run: |
           bundle install --jobs 4

data/.github/workflows/lint.yml

@@ -13,7 +13,7 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.7
+        ruby-version: 3.3
     - name: Cache gems
       uses: actions/cache@v1
       with:

data/.github/workflows/tests.yml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        ruby: [ '2.2', '2.7', '3.0', '3.1', 'ruby-head', 'jruby-head' ]
+        ruby: [ '2.4', '2.7', '3.0', '3.1', '3.2', '3.3', 'ruby-head', 'jruby-head' ]
 
     steps:
       - uses: actions/checkout@v2
@@ -24,3 +24,5 @@ jobs:
         run: bundle install --jobs 4
       - name: Test with Rake
         run: bundle exec rake
+      - uses: codecov/codecov-action@v3
+        if: matrix.ruby == '3.2'

data/.rubocop.yml

@@ -15,3 +15,6 @@ Lint/AmbiguousOperatorPrecedence:
 
 Lint/AmbiguousRegexpLiteral:
   Enabled: false
+
+Metrics:
+  Enabled: false

data/CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [1.8.0] - 2024-01-07
+
+### Added
+
+- support for `#<=>` and `#join`, which were added to `set` in the meantime
+- support for getting the (overall) character set of a Regexp with multiple expressions
+- support for global and local case-insensitivity in Regexp inputs
+- `Regexp#{covered_by_character_set?,uses_character_set?}` methods (if core ext is used)
+
 ## [1.7.0] - 2023-05-12
 
 ### Added

data/Gemfile

@@ -7,14 +7,15 @@ gemspec
 
 gem 'benchmark-ips', '~> 2.7'
 gem 'get_process_mem', '~> 0.2.3'
-gem 'rake', '~> 13.0'
+gem 'rake', '~> 13.1'
 gem 'rake-compiler', '~> 1.1'
 gem 'range_compressor', '~> 1.0'
-gem 'regexp_parser', '~> 2.1'
-gem 'regexp_property_values', '~> 1.0'
+gem 'regexp_parser', '~> 2.9'
+gem 'regexp_property_values', '~> 1.5'
 gem 'rspec', '~> 3.8'
-if RUBY_VERSION.to_f >= 2.7
-  gem 'codecov', '~> 0.2.12'
+gem 'warning', '~> 1.3'
+if RUBY_VERSION.to_f >= 3.0
   gem 'gouteur', '~> 1.0.0'
-  gem 'rubocop', '~> 1.8'
+  gem 'rubocop', '~> 1.59'
+  gem 'simplecov-cobertura', require: false
 end

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Janosch Müller
+Copyright (c) 2018-2023 Janosch Müller
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -3,7 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/character_set.svg)](http://badge.fury.io/rb/character_set)
 [![Build Status](https://github.com/jaynetics/character_set/workflows/tests/badge.svg)](https://github.com/jaynetics/character_set/actions)
 [![Build Status](https://github.com/jaynetics/character_set/workflows/gouteur/badge.svg)](https://github.com/jaynetics/character_set/actions)
-[![codecov](https://codecov.io/gh/jaynetics/character_set/branch/master/graph/badge.svg)](https://codecov.io/gh/jaynetics/character_set)
+[![Coverage](https://codecov.io/gh/jaynetics/character_set/branch/main/graph/badge.svg?token=oY7gcWNbIN)](https://codecov.io/gh/jaynetics/character_set)
 
 This is a C-extended Ruby gem to work with sets of Unicode codepoints.
 
@@ -43,7 +43,7 @@ CharacterSet.parse('[a-c]')
 CharacterSet.parse('\U00000061-\U00000063')
 ```
 
-If the gems [`regexp_parser`](https://github.com/ammar/regexp_parser) and [`regexp_property_values`](https://github.com/jaynetics/regexp_property_values) are installed, `Regexp` and unicode property names can also be read. Regexp intersections, negations, and set nesting are covered, but the `i`-flag is ignored; call `#case_insensitive` on the result if needed.
+If the gems [`regexp_parser`](https://github.com/ammar/regexp_parser) and [`regexp_property_values`](https://github.com/jaynetics/regexp_property_values) are installed, `Regexp` instances and unicode property names can also be read.
 
 ```ruby
 CharacterSet.of(/./) # => #<CharacterSet (size: 1112064)>

data/ext/character_set/character_set.c

@@ -675,6 +675,18 @@ cs_method_proper_superset_p(VALUE self, VALUE other)
   return (is_superset && is_proper) ? Qtrue : Qfalse;
 }
 
+static VALUE
+cs_method_spaceship_operator(VALUE self, VALUE other)
+{
+  if (cs_method_eql_p(self, other))
+    return INT2FIX(0);
+  if (cs_method_proper_subset_p(self, other))
+    return INT2FIX(-1);
+  if (cs_method_proper_superset_p(self, other))
+    return INT2FIX(1);
+  return Qnil;
+}
+
 // *******************************
 // `CharacterSet`-specific methods
 // *******************************
@@ -1324,6 +1336,7 @@ void Init_character_set()
   rb_define_method(cs, ">=", cs_method_superset_p, 1);
   rb_define_method(cs, "proper_superset?", cs_method_proper_superset_p, 1);
   rb_define_method(cs, ">", cs_method_proper_superset_p, 1);
+  rb_define_method(cs, "<=>", cs_method_spaceship_operator, 1);
 
   // `CharacterSet`-specific methods
 

data/lib/character_set/core_ext/regexp_ext.rb

@@ -4,6 +4,14 @@ class CharacterSet
       def character_set
         CharacterSet.of_regexp(self)
       end
+
+      def covered_by_character_set?(other)
+        other.superset?(character_set)
+      end
+
+      def uses_character_set?(other)
+        other.intersect?(character_set)
+      end
     end
   end
 end

data/lib/character_set/expression_converter.rb

@@ -4,86 +4,61 @@ class CharacterSet
 
     Error = Class.new(ArgumentError)
 
-    def convert(expression, to = CharacterSet)
+    def convert(expression, to = CharacterSet, acc = [])
       CharacterSet.require_optional_dependency('regexp_parser', __method__)
 
       case expression
-      when Regexp::Expression::Root
-        if expression.count != 1
-          raise Error, 'Pass a Regexp with exactly one expression, e.g. /[a-z]/'
-        end
-        convert(expression[0], to)
-
       when Regexp::Expression::CharacterSet
-        content = expression.map { |subexp| convert(subexp, to) }.reduce(:+)
-        content ||= to[]
-        expression.negative? ? content.inversion : content
+        content = expression.map { |subexp| convert(subexp, to) }.reduce(:+) || to[]
+        acc << (expression.negative? ? content.inversion : content)
 
       when Regexp::Expression::CharacterSet::Intersection
-        expression.map { |subexp| convert(subexp, to) }.reduce(:&)
-
-      when Regexp::Expression::CharacterSet::IntersectedSequence
-        expression.map { |subexp| convert(subexp, to) }.reduce(:+) || to[]
+        acc << expression.map { |subexp| convert(subexp, to) }.reduce(:&)
 
       when Regexp::Expression::CharacterSet::Range
         start, finish = expression.map { |subexp| convert(subexp, to) }
-        to.new((start.min)..(finish.max))
+        acc << to.new((start.min)..(finish.max))
+
+      when Regexp::Expression::Subexpression # root, group, alternation, etc.
+        expression.each { |subexp| convert(subexp, to, acc) }
 
       when Regexp::Expression::CharacterType::Any
-        to.unicode
+        acc << to.unicode
 
       when Regexp::Expression::CharacterType::Base
         /(?<negative>non)?(?<base_name>.+)/ =~ expression.token
         content =
           if expression.unicode_classes?
-            # in u-mode, type shortcuts match the same as \p{<long type name>}
-            to.of_property(base_name)
+            # in u-mode, most type shortcuts match the same as \p{<long type name>}
+            if base_name == 'linebreak'
+              to.from_ranges(10..13, 133..133, 8232..8233)
+            else
+              to.of_property(base_name)
+            end
           else
             # in normal mode, types match only ascii chars
             case base_name.to_sym
-            when :digit then to.from_ranges(48..57)
-            when :hex   then to.from_ranges(48..57, 65..70, 97..102)
-            when :space then to.from_ranges(9..13, 32..32)
-            when :word  then to.from_ranges(48..57, 65..90, 95..95, 97..122)
+            when :digit     then to.from_ranges(48..57)
+            when :hex       then to.from_ranges(48..57, 65..70, 97..102)
+            when :linebreak then to.from_ranges(10..13)
+            when :space     then to.from_ranges(9..13, 32..32)
+            when :word      then to.from_ranges(48..57, 65..90, 95..95, 97..122)
             else raise Error, "Unsupported CharacterType #{base_name}"
             end
           end
-        negative ? content.inversion : content
+        acc << (negative ? content.inversion : content)
 
       when Regexp::Expression::EscapeSequence::CodepointList
-        to.new(expression.codepoints)
+        content = to.new(expression.codepoints)
+        acc << (expression.i? ? content.case_insensitive : content)
 
       when Regexp::Expression::EscapeSequence::Base
-        to[expression.codepoint]
-
-      when Regexp::Expression::Group::Capture,
-           Regexp::Expression::Group::Passive,
-           Regexp::Expression::Group::Named,
-           Regexp::Expression::Group::Atomic,
-           Regexp::Expression::Group::Options
-        case expression.count
-        when 0 then to[]
-        when 1 then convert(expression.first, to)
-        else
-          raise Error, 'Groups must contain exactly one expression, e.g. ([a-z])'
-        end
-
-      when Regexp::Expression::Alternation # rubocop:disable Lint/DuplicateBranch
-        expression.map { |subexp| convert(subexp, to) }.reduce(:+)
-
-      when Regexp::Expression::Alternative
-        case expression.count
-        when 0 then to[]
-        when 1 then convert(expression.first, to)
-        else
-          raise Error, 'Alternatives must contain exactly one expression'
-        end
+        content = to[expression.codepoint]
+        acc << (expression.i? ? content.case_insensitive : content)
 
       when Regexp::Expression::Literal
-        if expression.set_level == 0 && expression.text.size != 1
-          raise Error, 'Literal runs outside of sets are codepoint *sequences*'
-        end
-        to[expression.text.ord]
+        content = to[*expression.text.chars]
+        acc << (expression.i? ? content.case_insensitive : content)
 
       when Regexp::Expression::UnicodeProperty::Base,
            Regexp::Expression::PosixClass
@@ -91,14 +66,22 @@ class CharacterSet
         if expression.type == :posixclass && expression.ascii_classes?
           content = content.ascii_part
         end
-        expression.negative? ? content.inversion : content
+        acc << (expression.negative? ? content.inversion : content)
+
+      when Regexp::Expression::Anchor::Base,
+           Regexp::Expression::Backreference::Base,
+           Regexp::Expression::Keep::Mark,
+           Regexp::Expression::Quantifier
+        # ignore zero-length and repeat expressions
 
       when Regexp::Expression::Base
         raise Error, "Unsupported expression class `#{expression.class}`"
 
       else
-        raise Error, "Pass an expression (result of Regexp::Parser.parse)"
+        raise Error, 'Pass an expression (result of Regexp::Parser.parse)'
       end
+
+      acc.reduce(:+) || to[]
     end
   end
 end

data/lib/character_set/ruby_fallback/character_set_methods.rb

@@ -122,10 +122,6 @@ class CharacterSet
         raise ArgumentError, 'pass a String' unless obj.respond_to?(:codepoints)
         obj.encode('utf-8')
       end
-
-      def make_new_str(original, &block)
-        utf8_str!(original).each_codepoint.with_object('', &block)
-      end
     end
   end
 end

data/lib/character_set/ruby_fallback/set_methods.rb

@@ -11,7 +11,7 @@ class CharacterSet
         RUBY
       end
 
-      %i[< <= > >= === disjoint? include? intersect? member?
+      %i[< <= <=> > >= === disjoint? include? intersect? member?
          proper_subset? proper_superset? subset? superset?].each do |mthd|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{mthd}(enum, &block)
@@ -23,9 +23,8 @@ class CharacterSet
         RUBY
       end
 
-      %i[<< add add? clear collect! delete delete? delete_if
-         each filter! map! keep_if reject!
-         select! subtract].each do |mthd|
+      %i[<< add add? clear delete delete? delete_if each filter! keep_if
+         reject! select! subtract].each do |mthd|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{mthd}(*args, &block)
             result = @__set.#{mthd}(*args, &block)

data/lib/character_set/ruby_fallback/vendored_set_classes.rb

@@ -1,492 +1,385 @@
-# set and sorted_set are vendored due to various dependency issues:
-#
-# - issues with default vs. installed gems such as [#2]
-# - issues with the sorted_set dependency rb_tree
-# - long-standing issues in recent versions of sorted_set
-#
-# The RubyFallback (and thus these set classes), are only used for testing,
-# and for exotic rubies which use neither C nor Java.
-
-class CharacterSet
-  module RubyFallback
-    if RUBY_PLATFORM[/java/i]
-      # Vendoring is not needed for JRuby which has sorted_set in the stdlib.
-      require 'set'
-
-      Set       = ::Set
-      SortedSet = ::SortedSet
-    else
-      # set, vendored from https://github.com/ruby/set/blob/master/lib/set.rb,
-      # with comments removed and linted.
-      class Set
-        include Enumerable
-
-        def self.[](*ary)
-          new(ary)
-        end
-
-        def initialize(enum = nil, &block)
-          @hash = Hash.new(false)
-
-          enum.nil? and return
-
-          if block
-            do_with_enum(enum) { |o| add(block[o]) }
-          else
-            merge(enum)
-          end
-        end
-
-        def compare_by_identity
-          if @hash.respond_to?(:compare_by_identity)
-            @hash.compare_by_identity
-            self
-          else
-            raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
-          end
-        end
+# set, vendored from https://github.com/ruby/set/blob/master/lib/set.rb,
+# with comments removed and linted.
+class CharacterSet::RubyFallback::Set
+  Set = self
+  include Enumerable
+
+  def self.[](*ary)
+    new(ary)
+  end
 
-        def compare_by_identity?
-          @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
-        end
+  def initialize(enum = nil, &block)
+    @hash = Hash.new(false)
 
-        def do_with_enum(enum, &block)
-          if enum.respond_to?(:each_entry)
-            enum.each_entry(&block) if block
-          elsif enum.respond_to?(:each)
-            enum.each(&block) if block
-          else
-            raise ArgumentError, "value must be enumerable"
-          end
-        end
-        private :do_with_enum
-
-        def initialize_dup(orig)
-          super
-          @hash = orig.instance_variable_get(:@hash).dup
-        end
+    enum.nil? and return
 
-        if Kernel.instance_method(:initialize_clone).arity != 1
-          def initialize_clone(orig, **options)
-            super
-            @hash = orig.instance_variable_get(:@hash).clone(**options)
-          end
-        else
-          def initialize_clone(orig)
-            super
-            @hash = orig.instance_variable_get(:@hash).clone
-          end
-        end
-
-        def freeze
-          @hash.freeze
-          super
-        end
+    if block
+      do_with_enum(enum) { |o| add(block[o]) }
+    else
+      merge(enum)
+    end
+  end
 
-        def size
-          @hash.size
-        end
-        alias length size
+  def do_with_enum(enum, &block)
+    if enum.respond_to?(:each_entry)
+      enum.each_entry(&block) if block
+    elsif enum.respond_to?(:each)
+      enum.each(&block) if block
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+  private :do_with_enum
 
-        def empty?
-          @hash.empty?
-        end
+  def initialize_dup(orig)
+    super
+    @hash = orig.instance_variable_get(:@hash).dup
+  end
 
-        def clear
-          @hash.clear
-          self
-        end
+  if Kernel.instance_method(:initialize_clone).arity != 1
+    def initialize_clone(orig, **options)
+      super
+      @hash = orig.instance_variable_get(:@hash).clone(**options)
+    end
+  else
+    def initialize_clone(orig)
+      super
+      @hash = orig.instance_variable_get(:@hash).clone
+    end
+  end
 
-        def replace(enum)
-          if enum.instance_of?(self.class)
-            @hash.replace(enum.instance_variable_get(:@hash))
-            self
-          else
-            do_with_enum(enum)
-            clear
-            merge(enum)
-          end
-        end
+  def freeze
+    @hash.freeze
+    super
+  end
 
-        def to_a
-          @hash.keys
-        end
+  def size
+    @hash.size
+  end
+  alias length size
 
-        def to_set(klass = Set, *args, &block)
-          return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
-          klass.new(self, *args, &block)
-        end
+  def empty?
+    @hash.empty?
+  end
 
-        def flatten_merge(set, seen = Set.new)
-          set.each { |e|
-            if e.is_a?(Set)
-              if seen.include?(e_id = e.object_id)
-                raise ArgumentError, "tried to flatten recursive Set"
-              end
-
-              seen.add(e_id)
-              flatten_merge(e, seen)
-              seen.delete(e_id)
-            else
-              add(e)
-            end
-          }
-
-          self
-        end
-        protected :flatten_merge
+  def clear
+    @hash.clear
+    self
+  end
 
-        def flatten
-          self.class.new.flatten_merge(self)
-        end
+  def to_a
+    @hash.keys
+  end
 
-        def flatten!
-          replace(flatten()) if any? { |e| e.is_a?(Set) }
-        end
+  def include?(o)
+    @hash[o]
+  end
+  alias member? include?
+
+  def superset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:>=)
+      @hash >= set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size >= set.size && set.all? { |o| include?(o) }
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias >= superset?
+
+  def proper_superset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:>)
+      @hash > set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size > set.size && set.all? { |o| include?(o) }
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias > proper_superset?
+
+  def subset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:<=)
+      @hash <= set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size <= set.size && all? { |o| set.include?(o) }
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias <= subset?
+
+  def proper_subset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:<)
+      @hash < set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size < set.size && all? { |o| set.include?(o) }
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias < proper_subset?
 
-        def include?(o)
-          @hash[o]
-        end
-        alias member? include?
-
-        def superset?(set)
-          case
-          when set.instance_of?(self.class) && @hash.respond_to?(:>=)
-            @hash >= set.instance_variable_get(:@hash)
-          when set.is_a?(Set)
-            size >= set.size && set.all? { |o| include?(o) }
-          else
-            raise ArgumentError, "value must be a set"
-          end
-        end
-        alias >= superset?
-
-        def proper_superset?(set)
-          case
-          when set.instance_of?(self.class) && @hash.respond_to?(:>)
-            @hash > set.instance_variable_get(:@hash)
-          when set.is_a?(Set)
-            size > set.size && set.all? { |o| include?(o) }
-          else
-            raise ArgumentError, "value must be a set"
-          end
-        end
-        alias > proper_superset?
-
-        def subset?(set)
-          case
-          when set.instance_of?(self.class) && @hash.respond_to?(:<=)
-            @hash <= set.instance_variable_get(:@hash)
-          when set.is_a?(Set)
-            size <= set.size && all? { |o| set.include?(o) }
-          else
-            raise ArgumentError, "value must be a set"
-          end
-        end
-        alias <= subset?
-
-        def proper_subset?(set)
-          case
-          when set.instance_of?(self.class) && @hash.respond_to?(:<)
-            @hash < set.instance_variable_get(:@hash)
-          when set.is_a?(Set)
-            size < set.size && all? { |o| set.include?(o) }
-          else
-            raise ArgumentError, "value must be a set"
-          end
-        end
-        alias < proper_subset?
+  def <=>(set)
+    return unless set.is_a?(Set)
 
-        def <=>(set)
-          return unless set.is_a?(Set)
+    case size <=> set.size
+    when -1 then -1 if proper_subset?(set)
+    when +1 then +1 if proper_superset?(set)
+    else 0 if self.==(set)
+    end
+  end
 
-          case size <=> set.size
-          when -1 then -1 if proper_subset?(set)
-          when +1 then +1 if proper_superset?(set)
-          else 0 if self.==(set)
-          end
-        end
+  def intersect?(set)
+    case set
+    when Set
+      if size < set.size
+        any? { |o| set.include?(o) }
+      else
+        set.any? { |o| include?(o) }
+      end
+    when Enumerable
+      set.any? { |o| include?(o) }
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
 
-        def intersect?(set)
-          case set
-          when Set
-            if size < set.size
-              any? { |o| set.include?(o) }
-            else
-              set.any? { |o| include?(o) }
-            end
-          when Enumerable
-            set.any? { |o| include?(o) }
-          else
-            raise ArgumentError, "value must be enumerable"
-          end
-        end
+  def disjoint?(set)
+    !intersect?(set)
+  end
 
-        def disjoint?(set)
-          !intersect?(set)
-        end
+  def each(&block)
+    block_given? or return enum_for(__method__) { size }
+    @hash.each_key(&block)
+    self
+  end
 
-        def each(&block)
-          block_given? or return enum_for(__method__) { size }
-          @hash.each_key(&block)
-          self
-        end
+  def add(o)
+    @hash[o] = true
+    self
+  end
+  alias << add
 
-        def add(o)
-          @hash[o] = true
-          self
-        end
-        alias << add
+  def add?(o)
+    add(o) unless include?(o)
+  end
 
-        def add?(o)
-          add(o) unless include?(o)
-        end
+  def delete(o)
+    @hash.delete(o)
+    self
+  end
 
-        def delete(o)
-          @hash.delete(o)
-          self
-        end
+  def delete?(o)
+    delete(o) if include?(o)
+  end
 
-        def delete?(o)
-          delete(o) if include?(o)
-        end
+  def delete_if
+    block_given? or return enum_for(__method__) { size }
+    select { |o| yield o }.each { |o| @hash.delete(o) }
+    self
+  end
 
-        def delete_if
-          block_given? or return enum_for(__method__) { size }
-          select { |o| yield o }.each { |o| @hash.delete(o) }
-          self
-        end
+  def keep_if
+    block_given? or return enum_for(__method__) { size }
+    reject { |o| yield o }.each { |o| @hash.delete(o) }
+    self
+  end
 
-        def keep_if
-          block_given? or return enum_for(__method__) { size }
-          reject { |o| yield o }.each { |o| @hash.delete(o) }
-          self
-        end
+  def reject!(&block)
+    block_given? or return enum_for(__method__) { size }
+    n = size
+    delete_if(&block)
+    self if size != n
+  end
 
-        def collect!
-          block_given? or return enum_for(__method__) { size }
-          set = self.class.new
-          each { |o| set << yield(o) }
-          replace(set)
-        end
-        alias map! collect!
+  def select!(&block)
+    block_given? or return enum_for(__method__) { size }
+    n = size
+    keep_if(&block)
+    self if size != n
+  end
 
-        def reject!(&block)
-          block_given? or return enum_for(__method__) { size }
-          n = size
-          delete_if(&block)
-          self if size != n
-        end
+  alias filter! select!
 
-        def select!(&block)
-          block_given? or return enum_for(__method__) { size }
-          n = size
-          keep_if(&block)
-          self if size != n
-        end
+  def merge(*enums, **_rest)
+    enums.each do |enum|
+      if enum.instance_of?(self.class)
+        @hash.update(enum.instance_variable_get(:@hash))
+      else
+        do_with_enum(enum) { |o| add(o) }
+      end
+    end
 
-        alias filter! select!
+    self
+  end
 
-        def merge(*enums, **_rest)
-          enums.each do |enum|
-            if enum.instance_of?(self.class)
-              @hash.update(enum.instance_variable_get(:@hash))
-            else
-              do_with_enum(enum) { |o| add(o) }
-            end
-          end
+  def subtract(enum)
+    do_with_enum(enum) { |o| delete(o) }
+    self
+  end
 
-          self
-        end
+  def |(enum)
+    dup.merge(enum)
+  end
+  alias + |
+  alias union |
 
-        def subtract(enum)
-          do_with_enum(enum) { |o| delete(o) }
-          self
-        end
+  def -(enum)
+    dup.subtract(enum)
+  end
+  alias difference -
+
+  def &(enum)
+    n = self.class.new
+    if enum.is_a?(Set)
+      if enum.size > size
+        each { |o| n.add(o) if enum.include?(o) }
+      else
+        enum.each { |o| n.add(o) if include?(o) }
+      end
+    else
+      do_with_enum(enum) { |o| n.add(o) if include?(o) }
+    end
+    n
+  end
+  alias intersection &
 
-        def |(enum)
-          dup.merge(enum)
-        end
-        alias + |
-        alias union |
+  def ^(enum)
+    n = Set.new(enum)
+    each { |o| n.add(o) unless n.delete?(o) }
+    n
+  end
 
-        def -(enum)
-          dup.subtract(enum)
-        end
-        alias difference -
-
-        def &(enum)
-          n = self.class.new
-          if enum.is_a?(Set)
-            if enum.size > size
-              each { |o| n.add(o) if enum.include?(o) }
-            else
-              enum.each { |o| n.add(o) if include?(o) }
-            end
-          else
-            do_with_enum(enum) { |o| n.add(o) if include?(o) }
-          end
-          n
-        end
-        alias intersection &
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
+  end
 
-        def ^(enum)
-          n = Set.new(enum)
-          each { |o| n.add(o) unless n.delete?(o) }
-          n
-        end
+  def hash
+    @hash.hash
+  end
 
-        def ==(other)
-          if self.equal?(other)
-            true
-          elsif other.instance_of?(self.class)
-            @hash == other.instance_variable_get(:@hash)
-          elsif other.is_a?(Set) && self.size == other.size
-            other.all? { |o| @hash.include?(o) }
-          else
-            false
-          end
-        end
+  def eql?(o)
+    return false unless o.is_a?(Set)
+    @hash.eql?(o.instance_variable_get(:@hash))
+  end
 
-        def hash
-          @hash.hash
-        end
+  alias === include?
 
-        def eql?(o)
-          return false unless o.is_a?(Set)
-          @hash.eql?(o.instance_variable_get(:@hash))
-        end
+  def classify
+    block_given? or return enum_for(__method__) { size }
 
-        def reset
-          if @hash.respond_to?(:rehash)
-            @hash.rehash
-          else
-            raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
-          end
-          self
-        end
-        alias === include?
+    h = {}
 
-        def classify
-          block_given? or return enum_for(__method__) { size }
+    each { |i|
+      (h[yield(i)] ||= self.class.new).add(i)
+    }
 
-          h = {}
+    h
+  end
 
-          each { |i|
-            (h[yield(i)] ||= self.class.new).add(i)
-          }
+  def divide(&func)
+    func or return enum_for(__method__) { size }
 
-          h
-        end
+    if func.arity == 2
+      require 'tsort'
 
-        def divide(&func)
-          func or return enum_for(__method__) { size }
-
-          if func.arity == 2
-            require 'tsort'
-
-            class << dig = {}
-              include TSort
-
-              alias tsort_each_node each_key
-              def tsort_each_child(node, &block)
-                fetch(node).each(&block)
-              end
-            end
-
-            each { |u|
-              dig[u] = a = []
-              each{ |v| func.call(u, v) and a << v }
-            }
-
-            set = Set.new()
-            dig.each_strongly_connected_component { |css|
-              set.add(self.class.new(css))
-            }
-            set
-          else
-            Set.new(classify(&func).values)
-          end
-        end
+      class << dig = {}
+        include TSort
 
-        def join(separator=nil)
-          to_a.join(separator)
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
         end
       end
 
-      # sorted_set without rbtree dependency, vendored from
-      # https://github.com/ruby/set/blob/72f08c4/lib/set.rb#L731-L800
-      class SortedSet < Set
-        def initialize(*args)
-          @keys = nil
-          super
-        end
+      each { |u|
+        dig[u] = a = []
+        each{ |v| func.call(u, v) and a << v }
+      }
 
-        def clear
-          @keys = nil
-          super
-        end
+      set = Set.new()
+      dig.each_strongly_connected_component { |css|
+        set.add(self.class.new(css))
+      }
+      set
+    else
+      Set.new(classify(&func).values)
+    end
+  end
+end
 
-        def replace(enum)
-          @keys = nil
-          super
-        end
+# sorted_set without rbtree dependency, vendored from
+# https://github.com/ruby/set/blob/72f08c4/lib/set.rb#L731-L800
+class CharacterSet::RubyFallback::SortedSet < CharacterSet::RubyFallback::Set
+  def initialize(*args)
+    @keys = nil
+    super
+  end
 
-        def add(o)
-          o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
-          @keys = nil
-          super
-        end
-        alias << add
+  def clear
+    @keys = nil
+    super
+  end
 
-        def delete(o)
-          @keys = nil
-          @hash.delete(o)
-          self
-        end
+  def add(o)
+    @keys = nil
+    super
+  end
+  alias << add
 
-        def delete_if
-          block_given? or return enum_for(__method__) { size }
-          n = @hash.size
-          super
-          @keys = nil if @hash.size != n
-          self
-        end
+  def delete(o)
+    @keys = nil
+    @hash.delete(o)
+    self
+  end
 
-        def keep_if
-          block_given? or return enum_for(__method__) { size }
-          n = @hash.size
-          super
-          @keys = nil if @hash.size != n
-          self
-        end
+  def delete_if
+    block_given? or return enum_for(__method__) { size }
+    n = @hash.size
+    super
+    @keys = nil if @hash.size != n
+    self
+  end
 
-        def merge(enum)
-          @keys = nil
-          super
-        end
+  def keep_if
+    block_given? or return enum_for(__method__) { size }
+    n = @hash.size
+    super
+    @keys = nil if @hash.size != n
+    self
+  end
 
-        def each(&block)
-          block or return enum_for(__method__) { size }
-          to_a.each(&block)
-          self
-        end
+  def merge(enum)
+    @keys = nil
+    super
+  end
 
-        def to_a
-          (@keys = @hash.keys).sort! unless @keys
-          @keys.dup
-        end
+  def each(&block)
+    block or return enum_for(__method__) { size }
+    to_a.each(&block)
+    self
+  end
 
-        def freeze
-          to_a
-          super
-        end
+  def to_a
+    (@keys = @hash.keys).sort! unless @keys
+    @keys.dup
+  end
 
-        def rehash
-          @keys = nil
-          super
-        end
-      end
-    end
+  def freeze
+    to_a
+    super
   end
 end

data/lib/character_set/ruby_fallback.rb

@@ -1,6 +1,5 @@
 require 'character_set/ruby_fallback/set_methods'
 require 'character_set/ruby_fallback/character_set_methods'
-require 'character_set/ruby_fallback/vendored_set_classes'
 
 class CharacterSet
   module RubyFallback
@@ -17,3 +16,20 @@ class CharacterSet
     end
   end
 end
+
+if RUBY_PLATFORM[/java/i]
+  # JRuby has sorted_set in the stdlib.
+  require 'set'
+  CharacterSet::RubyFallback::Set       = ::Set
+  CharacterSet::RubyFallback::SortedSet = ::SortedSet
+else
+  # For other rubies, set/sorted_set are vendored due to dependency issues:
+  #
+  # - issues with default vs. installed gems such as [#2]
+  # - issues with the sorted_set dependency rb_tree
+  # - long-standing issues in recent versions of sorted_set
+  #
+  # The RubyFallback, and thus these set classes, are only used for testing,
+  # and for exotic rubies which use neither C nor Java.
+  require 'character_set/ruby_fallback/vendored_set_classes'
+end

data/lib/character_set/set_method_adapters.rb

@@ -22,7 +22,7 @@ class CharacterSet
 
     # Allow some methods to take an Enum just as well as another CharacterSet.
     # Tested by ruby-spec.
-    %w[& + - ^ | difference disjoint? intersect? intersection
+    %w[& + - ^ | <=> difference disjoint? intersect? intersection
        subtract union].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{method}(arg)

data/lib/character_set/shared_methods.rb

@@ -165,9 +165,13 @@ class CharacterSet
         end
 
         def divide(&func)
-          require 'character_set/ruby_fallback/vendored_set_classes'
+          require 'character_set/ruby_fallback'
           CharacterSet::RubyFallback::Set.new(to_a).divide(&func)
         end
+
+        def join(separator = '')
+          to_a(true).join(separator)
+        end
       RUBY
 
       # CharacterSet-specific section methods

data/lib/character_set/version.rb

@@ -1,3 +1,3 @@
 class CharacterSet
-  VERSION = '1.7.0'
+  VERSION = '1.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: character_set
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-12 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.0.dev
 signing_key:
 specification_version: 4
 summary: Build, read, write and compare sets of Unicode codepoints.