regexp-examples 0.3.2 → 0.4.0

data/lib/regexp-examples/backreferences.rb

@@ -2,18 +2,24 @@ module RegexpExamples
   class BackReferenceReplacer
     def substitute_backreferences(full_examples)
       full_examples.map do |full_example|
-        while full_example.match(/__(\w+?)__/)
-          full_example.sub!(/__(\w+?)__/, find_backref_for(full_example, $1))
+        begin
+          while full_example.match(/__(\w+?)__/)
+            full_example.sub!(/__(\w+?)__/, find_backref_for(full_example, $1))
+          end
+          full_example
+        rescue RegexpExamples::BackrefNotFound
+          # For instance, one "full example" from /(a|(b)) \2/: "a __2__"
+          # should be rejected because the backref (\2) does not exist
+          nil
         end
-        full_example
-      end
+      end.compact
     end
 
     private
     def find_backref_for(full_example, group_id)
       full_example.all_subgroups.detect do |subgroup|
         subgroup.group_id == group_id
-      end
+      end || raise(RegexpExamples::BackrefNotFound)
     end
 
   end

data/lib/regexp-examples/constants.rb

@@ -1,18 +1,35 @@
 module RegexpExamples
-  # The maximum variance for any given repeater, to prevent a huge/infinite number of
-  # examples from being listed. For example, if MaxRepeaterVariance = 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}
-  MaxRepeaterVariance = 2
+  class ResultCountLimiters
+    # The maximum variance for any given repeater, to prevent a huge/infinite number of
+    # examples from being listed. For example, if @@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}
+    MaxRepeaterVarianceDefault = 2
 
-  # Maximum number of characters returned from a char set, to reduce output spam
-  # For example:
-  # If MaxGroupResults = 5, then
-  # \d = [0, 1, 2, 3, 4]
-  MaxGroupResults = 5
+    # Maximum number of characters returned from a char set, to reduce output spam
+    # For example, if @@max_group_results = 5 then:
+    # \d = ["0", "1", "2", "3", "4"]
+    # \w = ["a", "b", "c", "d", "e"]
+    MaxGroupResultsDefault = 5
+
+    class << self
+      attr_reader :max_repeater_variance, :max_group_results
+      def configure!(max_repeater_variance, max_group_results)
+        @max_repeater_variance = (max_repeater_variance || MaxRepeaterVarianceDefault)
+        @max_group_results = (max_group_results || MaxGroupResultsDefault)
+      end
+    end
+  end
+
+  def self.MaxRepeaterVariance
+    ResultCountLimiters.max_repeater_variance
+  end
+  def self.MaxGroupResults
+    ResultCountLimiters.max_group_results
+  end
 
   module CharSets
     Lower      = Array('a'..'z')

data/lib/regexp-examples/exceptions.rb

@@ -2,4 +2,5 @@ module RegexpExamples
   class Error < StandardError; end
   class UnsupportedSyntaxError < Error; end
   class IllegalSyntaxError < Error; end
+  class BackrefNotFound < Error; end
 end

data/lib/regexp-examples/groups.rb

@@ -16,12 +16,6 @@ module RegexpExamples
     def all_subgroups
       [self, subgroups].flatten.reject { |subgroup| subgroup.group_id.nil? }
     end
-
-    # Overridden in order to preserve the @group_id and @subgroups
-    # Used by BaseGroup (which, in turn, is used by all Group objects)
-    def *(int)
-      self.class.new(super.to_s, group_id, subgroups)
-    end
   end
 
   class SingleCharGroup
@@ -120,7 +114,7 @@ module RegexpExamples
     # itself
     def result
       strings = @groups.map {|repeater| repeater.result}
-      RegexpExamples::permutations_of_strings(strings).map do |result|
+      RegexpExamples.permutations_of_strings(strings).map do |result|
         GroupResult.new(result, group_id)
       end
     end
@@ -137,8 +131,8 @@ module RegexpExamples
 
 
     def result
-      left_result = RegexpExamples::map_results(@left_repeaters)
-      right_result = RegexpExamples::map_results(@right_repeaters)
+      left_result = RegexpExamples.map_results(@left_repeaters)
+      right_result = RegexpExamples.map_results(@right_repeaters)
       left_result.concat(right_result).flatten.uniq.map do |result|
         GroupResult.new(result)
       end

data/lib/regexp-examples/helpers.rb

@@ -27,7 +27,7 @@ module RegexpExamples
     repeaters
       .map {|repeater| repeater.result}
       .instance_eval do |partial_results|
-        RegexpExamples::permutations_of_strings(partial_results)
+        RegexpExamples.permutations_of_strings(partial_results)
       end
   end
 end

data/lib/regexp-examples/parser.rb

@@ -1,10 +1,14 @@
 module RegexpExamples
   class Parser
     attr_reader :regexp_string
-    def initialize(regexp_string)
+    def initialize(regexp_string, options={})
       @regexp_string = regexp_string
       @num_groups = 0
       @current_position = 0
+      RegexpExamples::ResultCountLimiters.configure!(
+        options[:max_repeater_variance],
+        options[:max_group_results]
+      )
     end
 
     def parse

data/lib/regexp-examples/regexp_extensions.rb

@@ -1,8 +1,8 @@
 class Regexp
   module Examples
-    def examples
-      full_examples = RegexpExamples::map_results(
-        RegexpExamples::Parser.new(source).parse
+    def examples(options={})
+      full_examples = RegexpExamples.map_results(
+        RegexpExamples::Parser.new(source, options).parse
       )
       RegexpExamples::BackReferenceReplacer.new.substitute_backreferences(full_examples)
     end

data/lib/regexp-examples/repeaters.rb

@@ -6,14 +6,18 @@ module RegexpExamples
     end
 
     def result(min_repeats, max_repeats)
-      group_results = @group.result[0 .. MaxGroupResults-1]
+      group_results = @group.result[0 .. RegexpExamples.MaxGroupResults-1]
       results = []
       min_repeats.upto(max_repeats) do |repeats|
-        group_results.each do |group_result|
-          results << group_result * repeats
+        if repeats.zero?
+          results << [ GroupResult.new('') ]
+        else
+          results << RegexpExamples.permutations_of_strings(
+            [group_results] * repeats
+          )
         end
       end
-      results.uniq
+      results.flatten.uniq
     end
   end
 
@@ -33,7 +37,7 @@ module RegexpExamples
     end
 
     def result
-      super(0, MaxRepeaterVariance)
+      super(0, RegexpExamples.MaxRepeaterVariance)
     end
   end
 
@@ -43,7 +47,7 @@ module RegexpExamples
     end
 
     def result
-      super(1, MaxRepeaterVariance + 1)
+      super(1, RegexpExamples.MaxRepeaterVariance + 1)
     end
   end
 
@@ -63,9 +67,9 @@ module RegexpExamples
       @min = min || 0
       if max
         # Prevent huge number of results in case of e.g. /.{1,100}/.examples
-        @max = smallest(max, @min + MaxRepeaterVariance)
+        @max = smallest(max, @min + RegexpExamples.MaxRepeaterVariance)
       elsif has_comma
-        @max = @min + MaxRepeaterVariance
+        @max = @min + RegexpExamples.MaxRepeaterVariance
       else
         @max = @min
       end

data/lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end

data/spec/regexp-examples_spec.rb

@@ -115,7 +115,9 @@ RSpec.describe Regexp, "#examples" do
         /((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/,
-        /(a?(b?(c?(d?(e?)))))/
+        /(a?(b?(c?(d?(e?)))))/,
+        /(a)? \1/,
+        /(a|(b)) \2/
       )
     end
 
@@ -208,12 +210,36 @@ RSpec.describe Regexp, "#examples" do
         /[^\h\H]/,
         /[^\D0-9]/,
         /[^\Wa-zA-Z0-9_]/,
-        /[^\d\D]*/,
         /[^\d\D]+/,
         /[^\d\D]{2}/,
         /[^\d\D]word/
       )
     end
 
+    context "exact examples match" do
+      # More rigorous tests to assert that ALL examples are being listed
+      context "default options" do
+        it { expect(/[ab]{2}/.examples).to eq ["aa", "ab", "ba", "bb"] }
+        it { expect(/(a|b){2}/.examples).to eq ["aa", "ab", "ba", "bb"] }
+        it { expect(/a+|b?/.examples).to eq ["a", "aa", "aaa", "", "b"] }
+      end
+      context "max_repeater_variance option" do
+        it do
+          expect(/a+/.examples(max_repeater_variance: 5))
+            .to eq %w(a aa aaa aaaa aaaaa aaaaaa)
+        end
+        it do
+          expect(/a{4,8}/.examples(max_repeater_variance: 0))
+            .to eq %w(aaaa)
+        end
+      end
+      context "max_group_results option" do
+        it do
+          expect(/\d/.examples(max_group_results: 10))
+            .to eq %w(0 1 2 3 4 5 6 7 8 9)
+        end
+      end
+    end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Tom Lord
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-24 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler