character_set 1.0.0

data/lib/character_set/ruby_fallback/set_methods.rb

@@ -0,0 +1,103 @@
+class CharacterSet
+  module RubyFallback
+    module SetMethods
+      Enumerable.instance_methods.concat(%w[empty? length size]).each do |mthd|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{mthd}(*args, &block)
+            @__set.#{mthd}(*args, &block)
+          end
+        RUBY
+      end
+
+      %w[< <= > >= disjoint? intersect? proper_subset? proper_superset?
+         subset? superset?].each do |mthd|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{mthd}(enum, &block)
+            if enum.is_a?(CharacterSet) || enum.is_a?(CharacterSet::Pure)
+              enum = enum.instance_variable_get(:@__set)
+            end
+            @__set.#{mthd}(enum, &block)
+          end
+        RUBY
+      end
+
+      %w[<< === add add? clear collect! delete delete? delete_if
+         each filter! hash include? map! member? keep_if reject!
+         select! subtract].each do |mthd|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{mthd}(*args, &block)
+            result = @__set.#{mthd}(*args, &block)
+            result.is_a?(Set) ? self : result
+          end
+        RUBY
+      end
+
+      %w[& + - ^ | difference intersection union].each do |mthd|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{mthd}(enum, &block)
+            if enum.respond_to?(:map)
+              enum = enum.map { |el| el.is_a?(String) ? el.ord : el }
+            end
+            self.class.new(@__set.#{mthd}(enum, &block).to_a)
+          end
+        RUBY
+      end
+
+      %w[taint untaint].each do |mthd|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{mthd}
+            @__set.#{mthd}
+            super
+          end
+        RUBY
+      end
+
+      unless RUBY_PLATFORM[/java/i]
+        def freeze
+          @__set.to_a
+          @__set.freeze
+          super
+        end
+      end
+
+      def merge(other)
+        raise ArgumentError, 'pass an Enumerable' unless other.respond_to?(:each)
+        # pass through #add to use the checks in SetMethodAdapters
+        other.each { |e| add(e) }
+        self
+      end
+
+      def ==(other)
+        if equal?(other)
+          true
+        elsif other.instance_of?(self.class)
+          @__set == other.instance_variable_get(:@__set)
+        elsif other.is_a?(self.class) && size == other.size
+          other.all? { |cp| @__set.include?(cp) }
+        else
+          false
+        end
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+        @__set.eql?(other.instance_variable_get(:@__set))
+      end
+
+      def initialize_dup(orig)
+        super
+        @__set = orig.instance_variable_get(:@__set).dup
+      end
+
+      def initialize_clone(orig)
+        super
+        @__set = orig.instance_variable_get(:@__set).clone
+      end
+
+      def to_a(stringify = false)
+        result = @__set.to_a
+        stringify ? result.map { |cp| cp.chr('utf-8') } : result
+      end
+    end
+  end
+end

data/lib/character_set/ruby_fallback.rb

@@ -0,0 +1,21 @@
+require 'set'
+require 'character_set/ruby_fallback/set_methods'
+require 'character_set/ruby_fallback/plane_methods'
+require 'character_set/ruby_fallback/character_set_methods'
+
+class CharacterSet
+  module RubyFallback
+    include CharacterSet::RubyFallback::SetMethods
+    include CharacterSet::RubyFallback::PlaneMethods
+    include CharacterSet::RubyFallback::CharacterSetMethods
+
+    def self.prepended(klass)
+      klass.extend CharacterSet::RubyFallback::CharacterSetMethods::ClassMethods
+    end
+
+    def initialize(enum = [])
+      @__set = SortedSet.new
+      super
+    end
+  end
+end

data/lib/character_set/set_method_adapters.rb

@@ -0,0 +1,39 @@
+class CharacterSet
+  module SetMethodAdapters
+    # Allow some methods to work with String in addition to Integer args
+    # (the internal representation is geared towards codepoint Integers).
+    %w[add add? << delete delete? include? member? ===].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(arg)
+          case arg
+          when String
+            super(arg.ord)
+          when Integer
+            if arg < 0 || arg > 0x10FFFF
+              raise ArgumentError, 'pass an Integer between 0 and 0x10FFFF'
+            end
+            super(arg)
+          else
+            raise ArgumentError, 'pass a String or an Integer'
+          end
+        end
+      RUBY
+    end
+
+    # Allow some methods to take an Enum just as well as another CharacterSet.
+    # Tested by ruby-spec.
+    %w[& + - ^ | difference intersection subtract union].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(arg)
+          if arg.is_a?(CharacterSet)
+            super
+          elsif arg.respond_to?(:each)
+            super(CharacterSet.new(arg.to_a))
+          else
+            raise ArgumentError, 'pass an enumerable'
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/character_set/shared_methods.rb

@@ -0,0 +1,155 @@
+#
+# Various methods shared by the pure-Ruby and the extended implementation.
+#
+# Many of these methods are hotspots, so they are defined directly on
+# the including classes for better performance.
+#
+class CharacterSet
+  module SharedMethods
+    def self.included(klass)
+      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.[](*args)
+          new(Array(args))
+        end
+
+        def self.parse(string)
+          codepoints = Parser.codepoints_from_bracket_expression(string)
+          result = new(codepoints)
+          string.start_with?('[^') ? result.inversion : result
+        end
+
+        def self.of_property(property_name)
+          @regexp_property_values_required ||= require 'regexp_property_values'
+
+          property = RegexpPropertyValues[property_name.to_s]
+          from_ranges(*property.matched_ranges)
+        end
+
+        def self.of_regexp(regexp)
+          @regexp_parser_required ||= require 'regexp_parser'
+
+          root = ::Regexp::Parser.parse(regexp)
+          of_expression(root)
+        end
+
+        def self.of_expression(expression)
+          ExpressionConverter.convert(expression)
+        end
+
+        def initialize(enumerable = [])
+          merge(Parser.codepoints_from_enumerable(enumerable))
+        end
+
+        def replace(enum)
+          unless [Array, CharacterSet, Range].include?(enum.class)
+            enum = self.class.new(enum)
+          end
+          clear
+          merge(enum)
+        end
+
+        # stringification methods
+
+        def to_s(opts = {}, &block)
+          Writer.write(ranges, opts, &block)
+        end
+
+        def to_s_with_surrogate_alternation
+          Writer.write_surrogate_alternation(bmp_part.ranges, astral_part.ranges)
+        end
+
+        def inspect
+          len = length
+          "#<CharacterSet: {\#{first(5) * ', '}\#{'...' if len > 5}} (size: \#{len})>"
+        end
+
+        # unicode-plane-related methods
+
+        def bmp_part?
+          !bmp_part.empty?
+        end
+
+        def astral_part?
+          !astral_part.empty?
+        end
+
+        def bmp_ratio
+          bmp_part.count / count.to_f
+        end
+
+        def astral_ratio
+          astral_part.count / count.to_f
+        end
+
+        #
+        # The following methods are here for `Set` compatibility, but they are
+        # comparatively slow. Prefer others.
+        #
+        def map!
+          block_given? or return enum_for(__method__) { size }
+          arr = []
+          each { |cp| arr << yield(cp) }
+          replace(arr)
+        end
+        alias collect! map!
+
+        def reject!(&block)
+          block_given? or return enum_for(__method__) { size }
+          old_size = size
+          delete_if(&block)
+          self if size != old_size
+        end
+
+        def select!(&block)
+          block_given? or return enum_for(__method__) { size }
+          old_size = size
+          keep_if(&block)
+          self if size != old_size
+        end
+        alias filter! select!
+
+        def classify
+          block_given? or return enum_for(__method__) { size }
+          each_with_object({}) { |cp, h| (h[yield(cp)] ||= self.class.new).add(cp) }
+        end
+
+        def divide(&func)
+          block_given? or return enum_for(__method__) { size }
+          require 'set'
+
+          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 do |u|
+              dig[u] = a = []
+              each{ |v| a << v if yield(u, v) }
+            end
+
+            set = Set.new
+            dig.each_strongly_connected_component do |css|
+              set.add(self.class.new(css))
+            end
+            set
+          else
+            Set.new(classify(&func).values)
+          end
+        end
+
+        # C-extension adapter method. Needs overriding in pure fallback.
+        # Parsing kwargs in C is slower, verbose, and kinda deprecated.
+        def inversion(include_surrogates: false, upto: 0x10FFFF)
+          ext_inversion(include_surrogates, upto)
+        end
+      RUBY
+    end
+  end
+end

data/lib/character_set/version.rb

@@ -0,0 +1,3 @@
+class CharacterSet
+  VERSION = '1.0.0'
+end

data/lib/character_set/writer.rb

@@ -0,0 +1,37 @@
+class CharacterSet
+  module Writer
+    module_function
+
+    def write(codepoint_ranges, opts = {}, &block)
+      content = codepoint_ranges.map do |range|
+        if range.size > 2 && opts[:abbreviate] != false
+          range.minmax.map { |cp| Character.new(cp).escape(opts, &block) }.join('-')
+        else
+          range.map { |cp| Character.new(cp).escape(opts, &block) }.join
+        end
+      end.join
+      opts[:in_brackets] ? "[#{content}]" : content
+    end
+
+    def write_surrogate_alternation(bmp_ranges, astral_ranges)
+      bmp_set = write(bmp_ranges, format: :js, in_brackets: true)
+      if astral_ranges.empty?
+        bmp_set
+      else
+        surrogate_pairs = surrogate_pairs(astral_ranges)
+        "(?:#{((bmp_ranges.any? ? [bmp_set] : []) + surrogate_pairs) * '|'})"
+      end
+    end
+
+    def surrogate_pairs(astral_ranges)
+      astral_ranges.flat_map { |range| range.map { |cp| surrogate_pair(cp) } }
+    end
+
+    def surrogate_pair(astral_codepoint)
+      base = astral_codepoint - 0x10000
+      high = ((base / 1024).floor + 0xD800).to_s(16)
+      low  = (base % 1024 + 0xDC00).to_s(16)
+      "\\u#{high}\\u#{low}"
+    end
+  end
+end

data/lib/character_set.rb

@@ -0,0 +1,21 @@
+require 'character_set/character'
+require 'character_set/common_sets'
+require 'character_set/expression_converter'
+require 'character_set/parser'
+require 'character_set/set_method_adapters'
+require 'character_set/shared_methods'
+require 'character_set/version'
+require 'character_set/writer'
+
+class CharacterSet
+  begin
+    require 'character_set/character_set'
+  rescue LoadError
+    require 'character_set/ruby_fallback'
+    prepend RubyFallback
+  end
+  prepend SetMethodAdapters
+  include Enumerable
+  include SharedMethods
+  extend CommonSets
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: character_set
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Janosch Müller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: range_compressor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: regexp_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: regexp_property_values
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- janosch84@gmail.com
+executables: []
+extensions:
+- ext/character_set/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- BENCHMARK.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/cover.rb
+- benchmarks/delete_in.rb
+- benchmarks/keep_in.rb
+- benchmarks/shared.rb
+- benchmarks/used_by.rb
+- bin/console
+- bin/setup
+- character_set.gemspec
+- ext/character_set/character_set.c
+- ext/character_set/extconf.rb
+- ext/character_set/unicode_casefold_table.h
+- lib/character_set.rb
+- lib/character_set/character.rb
+- lib/character_set/common_sets.rb
+- lib/character_set/core_ext.rb
+- lib/character_set/core_ext/regexp_ext.rb
+- lib/character_set/core_ext/string_ext.rb
+- lib/character_set/expression_converter.rb
+- lib/character_set/parser.rb
+- lib/character_set/pure.rb
+- lib/character_set/ruby_fallback.rb
+- lib/character_set/ruby_fallback/character_set_methods.rb
+- lib/character_set/ruby_fallback/plane_methods.rb
+- lib/character_set/ruby_fallback/set_methods.rb
+- lib/character_set/set_method_adapters.rb
+- lib/character_set/shared_methods.rb
+- lib/character_set/version.rb
+- lib/character_set/writer.rb
+homepage: https://github.com/janosch-x/character_set
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Build, read, write and compare sets of Unicode codepoints.
+test_files: []