regexp-examples 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96c7fa5e2bb981f8a2bb79debed55724f7c2bf57
-  data.tar.gz: abbc72305949312b0b3847c583b13c4b5dd09b8a
+  metadata.gz: aa40a179d06f78f6bb791ebda870b8f82b027d4e
+  data.tar.gz: 2abbd95ec396bb61b69d10035e9fd61e0d851fff
 SHA512:
-  metadata.gz: c18e91f5585b7ba5d494c0a26af766c0e7c7e39a9244e3a211d23ad2ec96b512046d01cf8f4e11839bfb15717dc24215661644a8de33095b9ce929e483b37429
-  data.tar.gz: 5661b852fb34cd1c7c2948c5558d4263520b996645e806cdd2635ea08466d019365a7998f0f8eedf7681dd107c5bdf5e909a09a16ebed640e83be38eadd71f5c
+  metadata.gz: 368a793ed4f68e60449525e4d1ce539da4513f83e4a8b301dfcf909643b9b6ca865752962d2f8d344485820ca2621a7ea2e30ee6cde7baf4930d220dcf4d4b87
+  data.tar.gz: 79475ed89f948dec9731457af73fec7fa6b5f87f50f5c75f3fd9ba7f2c5508a7876d4778804f0c4b64a68c6d5bfda2a75036bda73cf394656304cbddc48d041b

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Max: 90

data/.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
 rvm:
   - 2.0.0-p598
-  - 2.1.5
+  - 2.1.6
   - 2.2.0
+  - 2.2.2
+  - ruby-head
+matrix:
+  allow_failures:
     # One (ruby 2.3-dev) test fails, due to a change of behaviour in Array#delete_if,
     # but I don't know if this is intentional. I'll fix it once the behaviour change is documented.
     # For now, I don't really care if 2.3-dev tests all pass.
-    #  - ruby-head
+    - rvm: ruby-head

data/README.md

@@ -2,6 +2,7 @@
 [![Gem Version](https://badge.fury.io/rb/regexp-examples.svg)](http://badge.fury.io/rb/regexp-examples)
 [![Build Status](https://travis-ci.org/tom-lord/regexp-examples.svg?branch=master)](https://travis-ci.org/tom-lord/regexp-examples/builds)
 [![Coverage Status](https://coveralls.io/repos/tom-lord/regexp-examples/badge.svg?branch=master)](https://coveralls.io/r/tom-lord/regexp-examples?branch=master)
+[![Code Climate](https://codeclimate.com/github/tom-lord/regexp-examples/badges/gpa.svg)](https://codeclimate.com/github/tom-lord/regexp-examples)
 
 Extends the Regexp class with the methods: `Regexp#examples` and `Regexp#random_example`
 
@@ -111,7 +112,7 @@ Some of the most obscure regexp features are not even mentioned in the ruby docs
 ## Impossible features ("illegal syntax")
 
 The following features in the regex language can never be properly implemented into this gem because, put simply, they are not technically "regular"!
-If you'd like to understand this in more detail, check out what I had to say in [my blog post](http://tom-lord.weebly.com/blog/reverse-engineering-regular-expressions) about this gem!
+If you'd like to understand this in more detail, check out what I had to say in [my blog post](http://tom-lord.weebly.com/blog/reverse-engineering-regular-expressions) about this gem.
 
 Using any of the following will raise a RegexpExamples::IllegalSyntax exception:
 

data/lib/regexp-examples/chargroup_parser.rb

@@ -25,29 +25,11 @@ module RegexpExamples
       until next_char == ']'
         case next_char
         when '['
-          @current_position += 1
-          sub_group_parser = self.class.new(rest_of_string, is_sub_group: true)
-          @charset.concat sub_group_parser.result
-          @current_position += sub_group_parser.length
+          parse_sub_group_concat
         when '-'
-          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
+          parse_after_hyphen
         when '&'
-          if regexp_string[@current_position + 1] == '&'
-            @current_position += 2
-            sub_group_parser = self.class.new(rest_of_string, is_sub_group: @is_sub_group)
-            @charset &= sub_group_parser.result
-            @current_position += (sub_group_parser.length - 1)
-          else
-            @charset << '&'
-            @current_position += 1
-          end
+          parse_after_ampersand
         else
           @charset.concat parse_checking_backlash
           @current_position += 1
@@ -79,14 +61,22 @@ module RegexpExamples
         @charset << next_char
         @current_position += 1
       when /\A:(\^?)([^:]+):\]/ # e.g. [[:alpha:]] - POSIX group
-        if @is_sub_group
-          chars = Regexp.last_match(1).empty? ? POSIXCharMap[Regexp.last_match(2)] : (CharSets::Any - POSIXCharMap[Regexp.last_match(2)])
-          @charset.concat chars
-          @current_position += (Regexp.last_match(1).length + Regexp.last_match(2).length + 2)
-        end
+        parse_posix_group(Regexp.last_match(1), Regexp.last_match(2)) if @is_sub_group
       end
     end
 
+    def parse_posix_group(negation_flag, name)
+      chars = if negation_flag.empty?
+                POSIXCharMap[name]
+              else
+                CharSets::Any - POSIXCharMap[name]
+              end
+      @charset.concat chars
+      @current_position += (negation_flag.length + # 0 or 1, if '^' is present
+                            name.length +
+                            2) # Length of opening and closing colons (always 2)
+    end
+
     # Always returns an Array, for consistency
     def parse_checking_backlash
       if next_char == '\\'
@@ -108,6 +98,40 @@ module RegexpExamples
       end
     end
 
+    def parse_sub_group_concat
+      @current_position += 1
+      sub_group_parser = self.class.new(rest_of_string, is_sub_group: true)
+      @charset.concat sub_group_parser.result
+      @current_position += sub_group_parser.length
+    end
+
+    def parse_after_ampersand
+      if regexp_string[@current_position + 1] == '&'
+        parse_sub_group_intersect
+      else
+        @charset << '&'
+        @current_position += 1
+      end
+    end
+
+    def parse_sub_group_intersect
+      @current_position += 2
+      sub_group_parser = self.class.new(rest_of_string, is_sub_group: true)
+      @charset &= sub_group_parser.result
+      @current_position += (sub_group_parser.length - 1)
+    end
+
+    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
+    end
+
     def rest_of_string
       regexp_string[@current_position..-1]
     end

data/lib/regexp-examples/groups.rb

@@ -21,12 +21,18 @@ module RegexpExamples
     end
   end
 
+  # A helper method for mixing in to Group classes...
+  # Needed because sometimes (for performace) group results are lazy enumerators;
+  # Meanwhile other times (again, for performance!) group results are just arrays
   module ForceLazyEnumerators
     def force_if_lazy(arr_or_enum)
       arr_or_enum.respond_to?(:force) ? arr_or_enum.force : arr_or_enum
     end
   end
 
+  # A helper method for mixing in to Group classes...
+  # Needed for generating a complete results set when the ignorecase
+  # regexp option has been set
   module GroupWithIgnoreCase
     include ForceLazyEnumerators
     attr_reader :ignorecase
@@ -43,6 +49,9 @@ module RegexpExamples
     end
   end
 
+  # A helper method for mixing in to Group classes...
+  # Uses Array#sample to randomly choose one result from all
+  # possible examples
   module RandomResultBySample
     include ForceLazyEnumerators
     def random_result
@@ -50,6 +59,8 @@ module RegexpExamples
     end
   end
 
+  # The most "basic" possible group.
+  # For example, /x/ contains one SingleCharGroup
   class SingleCharGroup
     include RandomResultBySample
     prepend GroupWithIgnoreCase
@@ -74,6 +85,11 @@ module RegexpExamples
     end
   end
 
+  # The most generic type of group, which contains 0 or more characters.
+  # Technically, this is the ONLY type of group that is truly necessary
+  # However, having others both improves performance through various optimisations,
+  # and clarifies the code's intention.
+  # The most common example of CharGroups is: /[abc]/
   class CharGroup
     include RandomResultBySample
     prepend GroupWithIgnoreCase
@@ -89,6 +105,8 @@ module RegexpExamples
     end
   end
 
+  # A special case of CharGroup, for the pattern /./
+  # (For example, we never need to care about ignorecase here!)
   class DotGroup
     include RandomResultBySample
     attr_reader :multiline
@@ -104,6 +122,9 @@ module RegexpExamples
     end
   end
 
+  # A collection of other groups. Basically any regex that contains
+  # brackets will be parsed using one of these. The simplest example is:
+  # /(a)/ - Which is a MultiGroup, containing one SingleCharGroup
   class MultiGroup
     attr_reader :group_id
     def initialize(groups, group_id)
@@ -131,10 +152,18 @@ module RegexpExamples
     end
   end
 
+  # A boolean "or" group.
+  # The implementation is to pass in 2 set of (repeaters of) groups.
+  # The simplest example is: /a|b/
+  # If you have more than one boolean "or" operator, then this is initially
+  # parsed as an OrGroup containing another OrGroup. However, in order to avoid
+  # probability distribution issues in Regexp#random_example, this then gets
+  # simplified down to one OrGroup containing 3+ repeaters.
   class OrGroup
+    attr_reader :repeaters_list
+
     def initialize(left_repeaters, right_repeaters)
-      @left_repeaters = left_repeaters
-      @right_repeaters = right_repeaters
+      @repeaters_list = [left_repeaters, *merge_if_orgroup(right_repeaters)]
     end
 
     def result
@@ -142,25 +171,36 @@ module RegexpExamples
     end
 
     def random_result
-      # TODO: This logic is flawed in terms of choosing a truly "random" example!
-      # E.g. /a|b|c|d/.random_example will choose a letter with the following probabilities:
-      # a = 50%, b = 25%, c = 12.5%, d = 12.5%
-      # In order to fix this, I must either apply some weighted selection logic,
-      # or change how the OrGroup examples are generated - i.e. make this class work with >2 repeaters
       result_by_method(:map_random_result).sample(1)
     end
 
     private
 
     def result_by_method(method)
-      left_result = RegexpExamples.public_send(method, @left_repeaters)
-      right_result = RegexpExamples.public_send(method, @right_repeaters)
-      left_result.concat(right_result).flatten.uniq.map do |result|
-        GroupResult.new(result)
+      repeaters_list.map do |repeaters|
+        RegexpExamples.public_send(method, repeaters)
+      end
+        .inject(:concat)
+        .map do |result|
+          GroupResult.new(result)
+        end
+        .uniq
+    end
+
+    def merge_if_orgroup(repeaters)
+      if repeaters.size == 1 && repeaters.first.is_a?(OrGroup)
+        repeaters.first.repeaters_list
+      else
+        [repeaters]
       end
     end
   end
 
+  # This is a bit magic...
+  # We substitute backreferences with PLACEHOLDERS. These are then, later,
+  # replaced by the appropriate value. (See BackReferenceReplacer)
+  # The simplest example is /(a) \1/ - So, we temporarily treat the "result"
+  # of /\1/ as being "__1__". It later gets updated.
   class BackReferenceGroup
     include RandomResultBySample
     attr_reader :id

data/lib/regexp-examples/parser.rb

@@ -15,7 +15,7 @@ module RegexpExamples
       repeaters = []
       until end_of_regexp
         group = parse_group(repeaters)
-        return [OneTimeRepeater.new(group)] if group.is_a? OrGroup
+        return [group] if group.is_a? OrGroup
         @current_position += 1
         repeaters << parse_repeater(group)
       end
@@ -120,7 +120,7 @@ module RegexpExamples
         group = parse_single_char_group(parse_control_character(Regexp.last_match(2)))
       when rest_of_string =~ /\Ax(\h{1,2})/ # Escape sequence
         @current_position += Regexp.last_match(1).length
-        group = parse_single_char_group(parse_escape_sequence(Regexp.last_match(1)))
+        group = parse_single_char_group(parse_unicode_sequence(Regexp.last_match(1)))
       when rest_of_string =~ /\Au(\h{4}|\{\h{1,4}\})/ # Unicode sequence
         @current_position += Regexp.last_match(1).length
         sequence = Regexp.last_match(1).match(/\h{1,4}/)[0] # Strip off "{" and "}"
@@ -148,7 +148,7 @@ module RegexpExamples
         ) # Using "\r\n" as one character is little bit hacky...
       when next_char == 'g' # Subexpression call
         fail IllegalSyntaxError,
-          'Subexpression calls (\\g) cannot be supported, as they are not regular'
+             'Subexpression calls (\\g) cannot be supported, as they are not regular'
       when next_char =~ /[bB]/ # Anchors
         raise_anchors_exception!
       when next_char =~ /[AG]/ # Start of string
@@ -159,6 +159,7 @@ module RegexpExamples
         end
       when next_char =~ /[zZ]/ # End of string
         if @current_position == (regexp_string.length - 1)
+          # TODO: /\Z/ should be treated as /\n?/
           group = PlaceHolderGroup.new
         else
           raise_anchors_exception!
@@ -212,10 +213,10 @@ module RegexpExamples
             end
           when %w(! =).include?(match[2]) # e.g. /(?=lookahead)/, /(?!neglookahead)/
             fail IllegalSyntaxError,
-              'Lookaheads are not regular; cannot generate examples'
+                 'Lookaheads are not regular; cannot generate examples'
           when %w(! =).include?(match[3]) # e.g. /(?<=lookbehind)/, /(?<!neglookbehind)/
             fail IllegalSyntaxError,
-              'Lookbehinds are not regular; cannot generate examples'
+                 'Lookbehinds are not regular; cannot generate examples'
           else # e.g. /(?<name>namedgroup)/
             @current_position += (match[3].length + 3)
             group_id = match[3]
@@ -237,12 +238,14 @@ module RegexpExamples
     end
 
     def regexp_options_toggle(on, off)
-      @ignorecase = true if on.include? 'i'
-      @ignorecase = false if off.include? 'i'
-      @multiline = true if on.include? 'm'
-      @multiline = false if off.include? 'm'
-      @extended = true if on.include? 'x'
-      @extended = false if off.include? 'x'
+      regexp_option_toggle(on, off, '@ignorecase', 'i')
+      regexp_option_toggle(on, off, '@multiline', 'm')
+      regexp_option_toggle(on, off, '@extended', 'x')
+    end
+
+    def regexp_option_toggle(on, off, var, char)
+      instance_variable_set(var, true) if on.include? char
+      instance_variable_set(var, false) if off.include? char
     end
 
     def parse_char_group
@@ -276,12 +279,8 @@ module RegexpExamples
       # eval "?\\C-#{char.chr}" # Doesn't work for e.g. char = "?"
     end
 
-    def parse_escape_sequence(match)
-      eval "?\\x#{match}"
-    end
-
     def parse_unicode_sequence(match)
-      eval "?\\u{#{match}}"
+      [match.to_i(16)].pack('U')
     end
 
     def parse_star_repeater(group)
@@ -331,7 +330,7 @@ module RegexpExamples
 
     def raise_anchors_exception!
       fail IllegalSyntaxError,
-        "Anchors ('#{next_char}') cannot be supported, as they are not regular"
+           "Anchors ('#{next_char}') cannot be supported, as they are not regular"
     end
 
     def parse_one_time_repeater(group)

data/lib/regexp-examples/unicode_char_ranges.rb

@@ -39,7 +39,7 @@ module RegexpExamples
     end
 
     def hex_to_unicode(hex)
-      eval("?\\u{#{hex}}")
+      [hex.to_i(16)].pack('U')
     end
   end
 end

data/lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
 end

data/scripts/unicode_lister.rb

@@ -45,7 +45,7 @@ def calculate_ranges(matching_codes)
 end
 
 count = 0
-filename = RegexpExamples::UnicodeCharRanges::STORE_FILENAME
+filename = "./db/#{RegexpExamples::UnicodeCharRanges::STORE_FILENAME}"
 store = PStore.new(filename)
 store.transaction do
   NamedGroups.each do |name|
@@ -54,11 +54,11 @@ store.transaction do
     # (I have tried this with generating ALL examples, and it makes the ruby gem
     # painfully slow and bloated... Especially the test suite.)
     matching_codes = [(0..55_295), (57_344..65_535)].map(&:to_a).flatten.lazy
-                     .find { |x| /\p{#{name}}/ =~ eval("?\\u{#{x.to_s(16)}}") }
-    (128)
+                     .select { |x| /\p{#{name}}/ =~ eval("?\\u{#{x.to_s(16)}}") }
+                     .first(128)
     store[name.downcase] = calculate_ranges(matching_codes)
     puts "(#{count}/#{NamedGroups.length}) Finished property: #{name}"
   end
   puts '*' * 50
-  puts "Finished! Result stored in: ./db/#{filename}"
+  puts "Finished! Result stored in: #{filename}"
 end

data/spec/regexp-examples_spec.rb

@@ -4,8 +4,12 @@ RSpec.describe Regexp, '#examples' do
       it "examples for /#{regexp.source}/" do
         regexp_examples = regexp.examples(max_group_results: 99_999)
 
-        expect(regexp_examples).not_to be_empty, "No examples were generated for regexp: /#{regexp.source}/"
-        regexp_examples.each { |example| expect(example).to match(/\A(?:#{regexp.source})\z/) }
+        expect(regexp_examples)
+          .not_to be_empty,
+            "No examples were generated for regexp: /#{regexp.source}/"
+        regexp_examples.each do |example|
+          expect(example).to match(/\A(?:#{regexp.source})\z/)
+        end
         # Note: /\A...\z/ is used to prevent misleading examples from passing the test.
         # For example, we don't want things like:
         # /a*/.examples to include "xyz"
@@ -121,7 +125,7 @@ RSpec.describe Regexp, '#examples' do
         /(ref1) (ref2) \1 \2/,
         /((ref2)ref1) \1 \2/,
         /((ref1and2)) \1 \2/,
-        /(one)(two)(three)(four)(five)(six)(seven)(eight)(nine)(ten) \10\9\8\7\6\5\4\3\2\1/,
+        /(1)(2)(3)(4)(5)(6)(7)(8)(9)(10) \10\9\8\7\6\5\4\3\2\1/,
         /(a?(b?(c?(d?(e?)))))/,
         /(a)? \1/,
         /(a|(b)) \2/,
@@ -186,30 +190,36 @@ RSpec.describe Regexp, '#examples' do
         /\P{Ll}/, # Negation syntax type 2
         /\P{^Ll}/ # Double negation!! (Should cancel out)
       )
-      # An exhaustive set of tests for all named properties!!!
-      # This is useful for verifying the PStore contains correct values for all ruby versions
+      # An exhaustive set of tests for all named properties!!! This is useful
+      # for verifying the PStore contains correct values for all ruby versions
       %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 Balinese Bengali Bopomofo Braille Buginese Buhid Canadian_Aboriginal Cham Cherokee
-        Common Coptic Cyrillic Devanagari Ethiopic Georgian Glagolitic Greek Gujarati Gurmukhi Han Hangul
-        Hanunoo Hebrew Hiragana Inherited Kannada Katakana Kayah_Li Khmer Lao Latin Lepcha Limbu Malayalam
-        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
+        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
+        Balinese Bengali Bopomofo Braille Buginese Buhid Canadian_Aboriginal
+        Cham Cherokee Common Coptic Cyrillic Devanagari Ethiopic Georgian
+        Glagolitic Greek Gujarati Gurmukhi Han Hangul Hanunoo Hebrew Hiragana
+        Inherited Kannada Katakana Kayah_Li Khmer Lao Latin Lepcha Limbu Malayalam
+        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|
         it "examples for /\p{#{property}}/" do
           regexp_examples = /\p{#{property}}/.examples(max_group_results: 99_999)
-          expect(regexp_examples).not_to be_empty, "No examples were generated for regexp: /\p{#{property}}/"
+          expect(regexp_examples)
+            .not_to be_empty,
+              "No examples were generated for regexp: /\p{#{property}}/"
           # Just do one big check, for test system performance (~30% faster)
-          # (Otherwise, we are doing up to 128 regex expectations for every single property!!)
+          # (Otherwise, we're doing up to 128 checks on 123 properties!!!)
           expect(regexp_examples.join('')).to match(/\A\p{#{property}}+\z/)
         end
       end
 
       # The following seem to genuinely have no matching examples (!!??!!?!)
-      %w(Cs Carian Cuneiform Cypriot Deseret Gothic Kharoshthi Linear_B Lycian
-         Lydian Old_Italic Old_Persian Osmanya Phoenician Shavian Ugaritic).each do |property|
+      %w(
+        Cs Carian Cuneiform Cypriot Deseret Gothic Kharoshthi Linear_B Lycian
+        Lydian Old_Italic Old_Persian Osmanya Phoenician Shavian Ugaritic
+      ).each do |property|
         examples_are_empty(/\p{#{property}}/)
       end
     end
@@ -293,6 +303,10 @@ RSpec.describe Regexp, '#examples' do
         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 ['a', 'b'] }
+        it { expect(/[ccdd]/.examples).to match_array ['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
@@ -324,7 +338,10 @@ RSpec.describe Regexp, '#examples' do
 
       context 'case insensitive' do
         it { expect(/ab/i.examples).to match_array %w(ab aB Ab AB) }
-        it { expect(/a+/i.examples).to match_array %w(a A aa aA Aa AA aaa aaA aAa aAA Aaa AaA AAa AAA) }
+        it do
+          expect(/a+/i.examples)
+            .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) }
       end
 
@@ -351,7 +368,8 @@ RSpec.describe Regexp, '#examples' 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(/(?m)./.examples(max_group_results: 999)).to include "\n" }
-          it { expect(/(?i)(a)-\1/.examples).to match_array %w(a-a A-A) } # Toggle "groups" should not increase backref group count
+          # Toggle "groups" should not increase backref group count:
+          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) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Tom Lord
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2015-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -46,6 +46,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -54,6 +55,7 @@ files:
 - db/unicode_ranges_2.0.pstore
 - db/unicode_ranges_2.1.pstore
 - db/unicode_ranges_2.2.pstore
+- db/unicode_ranges_2.3.pstore
 - lib/core_extensions/regexp/examples.rb
 - lib/regexp-examples.rb
 - lib/regexp-examples/backreferences.rb