regexp-examples 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7ea454116c6367dba39b57fb8ca5fdd6b1e5062
-  data.tar.gz: a41c56176c0bbf007e99780790f3e196d4605190
+  metadata.gz: c9d287717179b54b2ee8426c8519609cc839ab06
+  data.tar.gz: d9f2f1c463927507aef8a199788ee136bff4d23e
 SHA512:
-  metadata.gz: 41f307047bbd5ca1539d6eda5d4035b91649187fdb015c449c2f56a64353c601911b1da465df0e891d01fed3344e70b3bc1efbfeaa8bfd61d371b0e1a0bf5c12
-  data.tar.gz: 2c126a5b52842b9c2b5b13fbf3243e09f6ae29d0d290561e050566bf6fa94401fa3d33a6d492bdec177ce1be9bacd49cee363ff0ce552b2986b1e0da22eea9ce
+  metadata.gz: 7624a0d9392ca22ee8706a96c2ea7a06fe7476602e05dd121b56609d13f5cea53a6b026b3475bd7178ad2db426d469c5813b6d47fafb5b56cb9afe5ee268fab7
+  data.tar.gz: 236752b70d1d56bb5534c4c6786237194d624991f8763ec5fb14639f232163494b755c881c5f4084582570258df7cc59fb8f310c5a8a845dceb61821f5837694

data/.rubocop.yml

@@ -1,5 +1,5 @@
 Metrics/LineLength:
   Max: 90
 
-Style/FileName:
+Naming/FileName:
   Enabled: false

data/lib/regexp-examples.rb

@@ -1,6 +1,7 @@
 require_relative 'regexp-examples/unicode_char_ranges'
 require_relative 'regexp-examples/chargroup_parser'
-require_relative 'regexp-examples/constants'
+require_relative 'regexp-examples/config'
+require_relative 'regexp-examples/char_sets'
 require_relative 'regexp-examples/groups'
 require_relative 'regexp-examples/backreferences'
 require_relative 'regexp-examples/max_results_limiter'

data/lib/regexp-examples/char_sets.rb

@@ -0,0 +1,59 @@
+# :nodoc:
+module RegexpExamples
+  # Definitions of various special characters, used in regular expressions.
+  # For example, `/\h/.examples` will return the value of `Hex` in this module
+  module CharSets
+    Lower        = Array('a'..'z')
+    Upper        = Array('A'..'Z')
+    Digit        = Array('0'..'9')
+    Punct        = %w[! " # % & ' ( ) * , - . / : ; ? @ [ \\ ] _ { }] \
+                     | (RUBY_VERSION >= '2.4.0' ? %w[$ + < = > ^ ` | ~] : [])
+    Hex          = Array('a'..'f') | Array('A'..'F') | Digit
+    Word         = Lower | Upper | Digit | ['_']
+    Whitespace   = [' ', "\t", "\n", "\r", "\v", "\f"].freeze
+    Control      = (0..31).map(&:chr) | ["\x7f"]
+    # Ensure that the "common" characters appear first in the array
+    # Also, ensure "\n" comes first, to make it obvious when included
+    Any          = ["\n"] | Lower | Upper | Digit | Punct | (0..127).map(&:chr)
+    AnyNoNewLine = Any - ["\n"]
+
+    # Map of special regex characters, to their associated character sets
+    BackslashCharMap = {
+      'd' => Digit,
+      'D' => Any - Digit,
+      'w' => Word,
+      'W' => Any - Word,
+      's' => Whitespace,
+      'S' => Any - Whitespace,
+      'h' => Hex,
+      'H' => Any - Hex,
+
+      't' => ["\t"], # tab
+      'n' => ["\n"], # new line
+      'r' => ["\r"], # carriage return
+      'f' => ["\f"], # form feed
+      'a' => ["\a"], # alarm
+      'v' => ["\v"], # vertical tab
+      'e' => ["\e"], # escape
+    }.freeze
+
+    POSIXCharMap = {
+      'alnum'  => Upper | Lower | Digit,
+      'alpha'  => Upper | Lower,
+      'blank'  => [' ', "\t"],
+      'cntrl'  => Control,
+      'digit'  => Digit,
+      'graph'  => (Any - Control) - [' '], #  Visible chars
+      'lower'  => Lower,
+      'print'  => Any - Control,
+      'punct'  => Punct,
+      'space'  => Whitespace,
+      'upper'  => Upper,
+      'xdigit' => Hex,
+      'word'   => Word,
+      'ascii'  => Any
+    }.freeze
+
+    NamedPropertyCharMap = UnicodeCharRanges.instance
+  end.freeze
+end

data/lib/regexp-examples/chargroup_parser.rb

@@ -67,7 +67,7 @@ module RegexpExamples
     end
 
     def parse_posix_group(negation_flag, name)
-      @charset.concat negate_if(POSIXCharMap[name], !negation_flag.empty?)
+      @charset.concat negate_if(CharSets::POSIXCharMap[name], !negation_flag.empty?)
       @current_position += (negation_flag.length + # 0 or 1, if '^' is present
                             name.length +
                             2) # Length of opening and closing colons (always 2)
@@ -84,13 +84,10 @@ module RegexpExamples
     end
 
     def parse_after_backslash
-      case next_char
-      when 'b'
+      if next_char == 'b'
         ["\b"]
-      when *BackslashCharMap.keys
-        BackslashCharMap[next_char]
       else
-        [next_char]
+        CharSets::BackslashCharMap.fetch(next_char, [next_char])
       end
     end
 
@@ -122,12 +119,11 @@ module RegexpExamples
     def parse_after_hyphen
       if regexp_string[@current_position + 1] == ']' # e.g. /[abc-]/ -- not a range!
         @charset << '-'
-        @current_position += 1
       else
         @current_position += 1
         @charset.concat((@charset.last..parse_checking_backlash.first).to_a)
-        @current_position += 1
       end
+      @current_position += 1
     end
 
     def rest_of_string

data/lib/regexp-examples/config.rb

@@ -0,0 +1,64 @@
+# :nodoc:
+module RegexpExamples
+  # Configuration settings to limit the number/length of Regexp examples generated
+  class Config
+    # The maximum variance for any given repeater, to prevent a huge/infinite number of
+    # examples from being listed. For example, if self.max_repeater_variance = 2 then:
+    # .* is equivalent to .{0,2}
+    # .+ is equivalent to .{1,3}
+    # .{2,} is equivalent to .{2,4}
+    # .{,3} is equivalent to .{0,2}
+    # .{3,8} is equivalent to .{3,5}
+    MAX_REPEATER_VARIANCE_DEFAULT = 2
+
+    # Maximum number of characters returned from a char set, to reduce output spam
+    # For example, if self.max_group_results = 5 then:
+    # \d is equivalent to [01234]
+    # \w is equivalent to [abcde]
+    MAX_GROUP_RESULTS_DEFAULT = 5
+
+    # Maximum number of results to be generated, for Regexp#examples
+    # This is to prevent the system "freezing" when given instructions like:
+    # /[ab]{30}/.examples
+    # (Which would attempt to generate 2**30 == 1073741824 examples!!!)
+    MAX_RESULTS_LIMIT_DEFAULT = 10_000
+    class << self
+      def with_configuration(**new_config)
+        original_config = config.dup
+
+        begin
+          self.config = new_config
+          result = yield
+        ensure
+          self.config = original_config
+        end
+
+        result
+      end
+
+      # Thread-safe getters and setters
+      %i[max_repeater_variance max_group_results max_results_limit].each do |m|
+        define_method(m) do
+          config[m]
+        end
+        define_method("#{m}=") do |value|
+          config[m] = value
+        end
+      end
+
+      private
+
+      def config=(**args)
+        Thread.current[:regexp_examples_config].merge!(args)
+      end
+
+      def config
+        Thread.current[:regexp_examples_config] ||= {
+          max_repeater_variance: MAX_REPEATER_VARIANCE_DEFAULT,
+          max_group_results: MAX_GROUP_RESULTS_DEFAULT,
+          max_results_limit: MAX_RESULTS_LIMIT_DEFAULT
+        }
+      end
+    end
+  end
+end

data/lib/regexp-examples/max_results_limiter.rb

@@ -17,11 +17,11 @@ module RegexpExamples
     end
 
     def cumulate_total(new_results_count, cumulator_method)
-      if @results_count.zero?
-        @results_count = new_results_count
-      else
-        @results_count = @results_count.public_send(cumulator_method, new_results_count)
-      end
+      @results_count = if @results_count.zero?
+                         new_results_count
+                       else
+                         @results_count.public_send(cumulator_method, new_results_count)
+                       end
     end
 
     def results_allowed_from(partial_results, limiter_method)

data/lib/regexp-examples/parser.rb

@@ -29,7 +29,7 @@ module RegexpExamples
     end
 
     def parse
-      repeaters = []
+      repeaters = [PlaceHolderGroup.new]
       until end_of_regexp
         group = parse_group(repeaters)
         return [group] if group.is_a? OrGroup

data/lib/regexp-examples/parser_helpers/parse_after_backslash_group_helper.rb

@@ -9,7 +9,7 @@ module RegexpExamples
         parse_regular_backreference_group(Regexp.last_match(1))
       elsif rest_of_string =~ /\Ak['<]([\w-]+)['>]/
         parse_named_backreference_group(Regexp.last_match(1))
-      elsif BackslashCharMap.keys.include?(next_char)
+      elsif CharSets::BackslashCharMap.keys.include?(next_char)
         parse_backslash_special_char
       elsif rest_of_string =~ /\A(c|C-)(.)/
         parse_backslash_control_char(Regexp.last_match(1), Regexp.last_match(2))
@@ -60,7 +60,7 @@ module RegexpExamples
 
     def parse_backslash_special_char
       CharGroup.new(
-        BackslashCharMap[next_char].dup,
+        CharSets::BackslashCharMap[next_char].dup,
         @ignorecase
       )
     end
@@ -97,7 +97,7 @@ module RegexpExamples
       # Beware of double negatives! E.g. /\P{^Space}/
       is_negative = (p_negation == 'P') ^ (caret_negation == '^')
       CharGroup.new(
-        negate_if(NamedPropertyCharMap[property_name.downcase], is_negative),
+        negate_if(CharSets::NamedPropertyCharMap[property_name.downcase], is_negative),
         @ignorecase
       )
     end

data/lib/regexp-examples/repeaters.rb

@@ -80,13 +80,13 @@ module RegexpExamples
     def initialize(group, min, has_comma, max)
       super(group)
       @min_repeats = min || 0
-      @max_repeats = if !has_comma
-                       @min_repeats
-                     else
+      @max_repeats = if has_comma # e.g. a{1,}, a{,3} or a{1,3}
                        [
                          max,
                          @min_repeats + RegexpExamples::Config.max_repeater_variance
                        ].compact.min
+                     else # e.g. a{1}
+                       @min_repeats
                      end
     end
   end

data/lib/regexp-examples/unicode_char_ranges.rb

@@ -1,4 +1,5 @@
 require 'pstore'
+require 'singleton'
 
 module RegexpExamples
   # Interface to the retrieve the character sets that match a regex named property.
@@ -6,6 +7,7 @@ module RegexpExamples
   # These matching values are stored, compressed, in a PStore. They are specific to
   # the ruby minor version.
   class UnicodeCharRanges
+    include Singleton
     # These values were generated by: scripts/unicode_lister.rb
     # Note: Only the first 128 results are listed, for performance.
     # Also, some groups seem to have no matches (weird!)

data/lib/regexp-examples/version.rb

@@ -1,4 +1,4 @@
 # Gem version
 module RegexpExamples
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.4.1'.freeze
 end

data/spec/config_spec.rb

@@ -1,18 +1,17 @@
 RSpec.describe RegexpExamples::Config do
-
   describe 'max_repeater_variance' do
     context 'as a passed parameter' do
       it 'with low limit' do
         expect(/[A-Z]/.examples(max_results_limit: 5))
-          .to match_array %w(A B C D E)
+          .to match_array %w[A B C D E]
       end
       it 'with (default) high limit' do
         expect(/[ab]{14}/.examples.length)
-          .to be <= 10000 # NOT 2**14 == 16384, because it's been limited
+          .to be <= 10_000 # NOT 2**14 == 16384, because it's been limited
       end
       it 'with (custom) high limit' do
-        expect(/[ab]{14}/.examples(max_results_limit: 20000).length)
-          .to eq 16384 # NOT 10000, because it's below the limit
+        expect(/[ab]{14}/.examples(max_results_limit: 20_000).length)
+          .to eq 16_384 # NOT 10000, because it's below the limit
       end
       it 'for boolean or groups' do
         expect(/[ab]{3}|[cd]{3}/.examples(max_results_limit: 10).length)
@@ -47,7 +46,7 @@ RSpec.describe RegexpExamples::Config do
 
       it 'sets limit without passing explicitly' do
         expect(/[A-Z]/.examples)
-          .to match_array %w(A B C D E)
+          .to match_array %w[A B C D E]
       end
     end
   end # describe 'max_results_limit'
@@ -56,11 +55,11 @@ RSpec.describe RegexpExamples::Config do
     context 'as a passed parameter' do
       it 'with a larger value' do
         expect(/a+/.examples(max_repeater_variance: 5))
-          .to match_array %w(a aa aaa aaaa aaaaa aaaaaa)
+          .to match_array %w[a aa aaa aaaa aaaaa aaaaaa]
       end
       it 'with a lower value' do
         expect(/a{4,8}/.examples(max_repeater_variance: 0))
-          .to eq %w(aaaa)
+          .to eq %w[aaaa]
       end
     end
 
@@ -75,7 +74,7 @@ RSpec.describe RegexpExamples::Config do
 
       it 'sets limit without passing explicitly' do
         expect(/a+/.examples)
-          .to match_array %w(a aa aaa aaaa aaaaa aaaaaa)
+          .to match_array %w[a aa aaa aaaa aaaaa aaaaaa]
       end
     end
   end # describe 'max_repeater_variance'
@@ -84,11 +83,11 @@ RSpec.describe RegexpExamples::Config do
     context 'as a passed parameter' do
       it 'with a larger value' do
         expect(/\d/.examples(max_group_results: 10))
-          .to match_array %w(0 1 2 3 4 5 6 7 8 9)
+          .to match_array %w[0 1 2 3 4 5 6 7 8 9]
       end
       it 'with a lower value' do
         expect(/\d/.examples(max_group_results: 3))
-          .to match_array %w(0 1 2)
+          .to match_array %w[0 1 2]
       end
     end
 
@@ -103,7 +102,7 @@ RSpec.describe RegexpExamples::Config do
 
       it 'sets limit without passing explicitly' do
         expect(/\d/.examples)
-          .to match_array %w(0 1 2 3 4 5 6 7 8 9)
+          .to match_array %w[0 1 2 3 4 5 6 7 8 9]
       end
     end
   end # describe 'max_group_results'
@@ -112,24 +111,23 @@ RSpec.describe RegexpExamples::Config do
     it 'uses thread-local global config values' do
       thread = Thread.new do
         RegexpExamples::Config.max_group_results = 1
-        expect(/\d/.examples).to eq %w(0)
+        expect(/\d/.examples).to eq %w[0]
       end
       sleep 0.1 # Give the above thread time to run
-      expect(/\d/.examples).to eq %w(0 1 2 3 4)
+      expect(/\d/.examples).to eq %w[0 1 2 3 4]
       thread.join
     end
 
     it 'uses thread-local block config values' do
       thread = Thread.new do
         RegexpExamples::Config.with_configuration(max_group_results: 1) do
-          expect(/\d/.examples).to eq %w(0)
+          expect(/\d/.examples).to eq %w[0]
           sleep 0.2 # Give the below thread time to run while this block is open
         end
       end
       sleep 0.1 # Give the above thread time to run
-      expect(/\d/.examples).to eq %w(0 1 2 3 4)
+      expect(/\d/.examples).to eq %w[0 1 2 3 4]
       thread.join
     end
   end # describe 'thread safety'
-
 end

data/spec/regexp-examples_spec.rb

@@ -100,7 +100,7 @@ RSpec.describe Regexp, '#examples' do
 
     context 'for escaped characters' do
       all_letters = Array('a'..'z') | Array('A'..'Z')
-      special_letters = %w(b c g p u x z A B C G M P Z)
+      special_letters = %w[b c g p u x z A B C G M P Z]
       valid_letters = all_letters - special_letters
 
       valid_letters.each do |char|
@@ -185,7 +185,7 @@ RSpec.describe Regexp, '#examples' do
       )
       # An exhaustive set of tests for all named properties!!! This is useful
       # for verifying the PStore contains correct values for all ruby versions
-      %w(
+      %w[
         Alnum Alpha Blank Cntrl Digit Graph Lower Print Punct Space Upper XDigit
         Word ASCII Any Assigned L Ll Lm Lo Lt Lu M Mn Mc Me N Nd Nl No P Pc Pd
         Ps Pe Pi Pf Po S Sm Sc Sk So Z Zs Zl Zp C Cc Cf Cn Co Arabic Armenian
@@ -196,7 +196,7 @@ RSpec.describe Regexp, '#examples' do
         Mongolian Myanmar New_Tai_Lue Nko Ogham Ol_Chiki Oriya Phags_Pa Rejang
         Runic Saurashtra Sinhala Sundanese Syloti_Nagri Syriac Tagalog Tagbanwa
         Tai_Le Tamil Telugu Thaana Thai Tibetan Tifinagh Vai Yi
-      ).each do |property|
+      ].each do |property|
         it "examples for /\p{#{property}}/" do
           regexp_examples = /\p{#{property}}/.examples(max_group_results: 99_999)
           expect(regexp_examples)
@@ -209,10 +209,10 @@ RSpec.describe Regexp, '#examples' do
       end
 
       # The following seem to genuinely have no matching examples (!!??!!?!)
-      %w(
+      %w[
         Cs Carian Cuneiform Cypriot Deseret Gothic Kharoshthi Linear_B Lycian
         Lydian Old_Italic Old_Persian Osmanya Phoenician Shavian Ugaritic
-      ).each do |property|
+      ].each do |property|
         examples_are_empty(/\p{#{property}}/)
       end
     end
@@ -261,6 +261,10 @@ RSpec.describe Regexp, '#examples' do
       )
     end
 
+    context 'for empty regex' do
+      it { expect(//.examples).to eq [''] }
+    end
+
     context 'for comment groups' do
       examples_exist_and_match(
         /a(?#comment)b/,
@@ -292,21 +296,21 @@ RSpec.describe Regexp, '#examples' do
       # More rigorous tests to assert that ALL examples are being listed
       context 'default config options' do
         # Simple examples
-        it { expect(/[ab]{2}/.examples).to match_array %w(aa ab ba bb) }
-        it { expect(/(a|b){2}/.examples).to match_array %w(aa ab ba bb) }
+        it { expect(/[ab]{2}/.examples).to match_array %w[aa ab ba bb] }
+        it { expect(/(a|b){2}/.examples).to match_array %w[aa ab ba bb] }
         it { expect(/a+|b?/.examples).to match_array ['a', 'aa', 'aaa', '', 'b'] }
 
         # Only display unique examples:
-        it { expect(/a|a|b|b/.examples).to match_array %w(a b) }
-        it { expect(/[ccdd]/.examples).to match_array %w(c d) }
+        it { expect(/a|a|b|b/.examples).to match_array %w[a b] }
+        it { expect(/[ccdd]/.examples).to match_array %w[c d] }
 
         # a{1}? should be equivalent to (?:a{1})?, i.e. NOT a "non-greedy quantifier"
         it { expect(/a{1}?/.examples).to match_array ['', 'a'] }
       end
 
       context 'end of string' do
-        it { expect(/test\z/.examples).to match_array %w(test) }
-        it { expect(/test\Z/.examples).to match_array ['test', "test\n"] }
+        it { expect(/test\z/.examples).to match_array %w[test] }
+        it { expect(/test\Z/.examples).to match_array %W[test test\n] }
       end
 
       context 'backreferences and escaped octal combined' do
@@ -317,12 +321,12 @@ RSpec.describe Regexp, '#examples' do
       end
 
       context 'case insensitive' do
-        it { expect(/ab/i.examples).to match_array %w(ab aB Ab AB) }
+        it { expect(/ab/i.examples).to match_array %w[ab aB Ab AB] }
         it do
           expect(/a+/i.examples)
-            .to match_array %w(a A aa aA Aa AA aaa aaA aAa aAA Aaa AaA AAa AAA)
+            .to match_array %w[a A aa aA Aa AA aaa aaA aAa aAA Aaa AaA AAa AAA]
         end
-        it { expect(/([ab])\1/i.examples).to match_array %w(aa bb AA BB) }
+        it { expect(/([ab])\1/i.examples).to match_array %w[aa bb AA BB] }
       end
 
       context 'multiline' do
@@ -331,30 +335,30 @@ RSpec.describe Regexp, '#examples' do
       end
 
       context 'exteded form' do
-        it { expect(/a b c/x.examples).to eq %w(abc) }
-        it { expect(/a#comment/x.examples).to eq %w(a) }
+        it { expect(/a b c/x.examples).to eq %w[abc] }
+        it { expect(/a#comment/x.examples).to eq %w[a] }
         it do
           expect(
             /
               line1 #comment
               line2 #comment
             /x.examples
-          ).to eq %w(line1line2)
+          ).to eq %w[line1line2]
         end
       end
 
       context 'options toggling' do
         context 'rest of string' do
-          it { expect(/a(?i)b(?-i)c/.examples).to match_array %w(abc aBc) }
-          it { expect(/a(?x)   b(?-x) c/.examples).to eq %w(ab\ c) }
+          it { expect(/a(?i)b(?-i)c/.examples).to match_array %w[abc aBc] }
+          it { expect(/a(?x)   b(?-x) c/.examples).to eq %w[ab\ c] }
           it { expect(/(?m)./.examples(max_group_results: 999)).to include "\n" }
           # Toggle "groups" should not increase backref group count:
-          it { expect(/(?i)(a)-\1/.examples).to match_array %w(a-a A-A) }
+          it { expect(/(?i)(a)-\1/.examples).to match_array %w[a-a A-A] }
         end
         context 'subexpression' do
-          it { expect(/a(?i:b)c/.examples).to match_array %w(abc aBc) }
-          it { expect(/a(?i:b(?-i:c))/.examples).to match_array %w(abc aBc) }
-          it { expect(/a(?-i:b)c/i.examples).to match_array %w(abc abC Abc AbC) }
+          it { expect(/a(?i:b)c/.examples).to match_array %w[abc aBc] }
+          it { expect(/a(?i:b(?-i:c))/.examples).to match_array %w[abc aBc] }
+          it { expect(/a(?-i:b)c/i.examples).to match_array %w[abc abC Abc AbC] }
         end
       end
     end # context 'exact examples match'

data/spec/spec_helper.rb

@@ -8,7 +8,7 @@ require 'pry'
 # Several of these tests (intentionally) use "weird" regex patterns,
 # that spam annoying warnings when running.
 # E.g. warning: invalid back reference: /\k/
-# and  warning: character class has ']' without escape: /[]]/ 
+# and  warning: character class has ']' without escape: /[]]/
 # This config disables those warnings.
 $VERBOSE = nil
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Tom Lord
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-15 00:00:00.000000000 Z
+date: 2017-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,8 +60,9 @@ files:
 - lib/core_extensions/regexp/examples.rb
 - lib/regexp-examples.rb
 - lib/regexp-examples/backreferences.rb
+- lib/regexp-examples/char_sets.rb
 - lib/regexp-examples/chargroup_parser.rb
-- lib/regexp-examples/constants.rb
+- lib/regexp-examples/config.rb
 - lib/regexp-examples/groups.rb
 - lib/regexp-examples/helpers.rb
 - lib/regexp-examples/max_results_limiter.rb

data/lib/regexp-examples/constants.rb

@@ -1,121 +0,0 @@
-# :nodoc:
-module RegexpExamples
-  # Configuration settings to limit the number/length of Regexp examples generated
-  class Config
-    class << self
-      def with_configuration(**new_config)
-        original_config = config.dup
-
-        begin
-          self.config = new_config
-          result = yield
-        ensure
-          self.config = original_config
-        end
-
-        result
-      end
-
-      # Thread-safe getters and setters
-      %i[max_repeater_variance max_group_results max_results_limit].each do |m|
-        define_method(m) do
-          config[m]
-        end
-        define_method("#{m}=") do |value|
-          config[m] = value
-        end
-      end
-
-      private
-
-      def config=(**args)
-        Thread.current[:regexp_examples_config].merge!(args)
-      end
-
-      def config
-        Thread.current[:regexp_examples_config] ||= {
-          max_repeater_variance: MAX_REPEATER_VARIANCE_DEFAULT,
-          max_group_results: MAX_GROUP_RESULTS_DEFAULT,
-          max_results_limit: MAX_RESULTS_LIMIT_DEFAULT
-        }
-      end
-    end
-    # The maximum variance for any given repeater, to prevent a huge/infinite number of
-    # examples from being listed. For example, if self.max_repeater_variance = 2 then:
-    # .* is equivalent to .{0,2}
-    # .+ is equivalent to .{1,3}
-    # .{2,} is equivalent to .{2,4}
-    # .{,3} is equivalent to .{0,2}
-    # .{3,8} is equivalent to .{3,5}
-    MAX_REPEATER_VARIANCE_DEFAULT = 2
-
-    # Maximum number of characters returned from a char set, to reduce output spam
-    # For example, if self.max_group_results = 5 then:
-    # \d is equivalent to [01234]
-    # \w is equivalent to [abcde]
-    MAX_GROUP_RESULTS_DEFAULT = 5
-
-    # Maximum number of results to be generated, for Regexp#examples
-    # This is to prevent the system "freezing" when given instructions like:
-    # /[ab]{30}/.examples
-    # (Which would attempt to generate 2**30 == 1073741824 examples!!!)
-    MAX_RESULTS_LIMIT_DEFAULT = 10_000
-  end
-
-  # Definitions of various special characters, used in regular expressions.
-  # For example, `/\h/.examples` will return the value of `Hex` in this module
-  module CharSets
-    Lower        = Array('a'..'z')
-    Upper        = Array('A'..'Z')
-    Digit        = Array('0'..'9')
-    Punct        = %w[! " # % & ' ( ) * , - . / : ; ? @ [ \\ ] _ { }] \
-                     | (RUBY_VERSION >= '2.4.0' ? %w[$ + < = > ^ ` | ~] : [])
-    Hex          = Array('a'..'f') | Array('A'..'F') | Digit
-    Word         = Lower | Upper | Digit | ['_']
-    Whitespace   = [' ', "\t", "\n", "\r", "\v", "\f"].freeze
-    Control      = (0..31).map(&:chr) | ["\x7f"]
-    # Ensure that the "common" characters appear first in the array
-    # Also, ensure "\n" comes first, to make it obvious when included
-    Any          = ["\n"] | Lower | Upper | Digit | Punct | (0..127).map(&:chr)
-    AnyNoNewLine = Any - ["\n"]
-  end.freeze
-
-  # Map of special regex characters, to their associated character sets
-  BackslashCharMap = {
-    'd' => CharSets::Digit,
-    'D' => CharSets::Any - CharSets::Digit,
-    'w' => CharSets::Word,
-    'W' => CharSets::Any - CharSets::Word,
-    's' => CharSets::Whitespace,
-    'S' => CharSets::Any - CharSets::Whitespace,
-    'h' => CharSets::Hex,
-    'H' => CharSets::Any - CharSets::Hex,
-
-    't' => ["\t"], # tab
-    'n' => ["\n"], # new line
-    'r' => ["\r"], # carriage return
-    'f' => ["\f"], # form feed
-    'a' => ["\a"], # alarm
-    'v' => ["\v"], # vertical tab
-    'e' => ["\e"], # escape
-  }.freeze
-
-  POSIXCharMap = {
-    'alnum'  => CharSets::Upper | CharSets::Lower | CharSets::Digit,
-    'alpha'  => CharSets::Upper | CharSets::Lower,
-    'blank'  => [' ', "\t"],
-    'cntrl'  => CharSets::Control,
-    'digit'  => CharSets::Digit,
-    'graph'  => (CharSets::Any - CharSets::Control) - [' '], #  Visible chars
-    'lower'  => CharSets::Lower,
-    'print'  => CharSets::Any - CharSets::Control,
-    'punct'  => CharSets::Punct,
-    'space'  => CharSets::Whitespace,
-    'upper'  => CharSets::Upper,
-    'xdigit' => CharSets::Hex,
-    'word'   => CharSets::Word,
-    'ascii'  => CharSets::Any
-  }.freeze
-
-  NamedPropertyCharMap = UnicodeCharRanges.new
-end