regexp-examples 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa40a179d06f78f6bb791ebda870b8f82b027d4e
-  data.tar.gz: 2abbd95ec396bb61b69d10035e9fd61e0d851fff
+  metadata.gz: 43bddf0ebdc30ee2ae0e7ed35722165921d25c93
+  data.tar.gz: 3e52ef064a6dd7c484f06814c15135997f7fb19d
 SHA512:
-  metadata.gz: 368a793ed4f68e60449525e4d1ce539da4513f83e4a8b301dfcf909643b9b6ca865752962d2f8d344485820ca2621a7ea2e30ee6cde7baf4930d220dcf4d4b87
-  data.tar.gz: 79475ed89f948dec9731457af73fec7fa6b5f87f50f5c75f3fd9ba7f2c5508a7876d4778804f0c4b64a68c6d5bfda2a75036bda73cf394656304cbddc48d041b
+  metadata.gz: 9e53baeb48bce1a0e5d00e610b0ea933bc5a014d1fe0ea5b9678875c63b5507aaa32baab9f339e60610ce1b9c97e4173729a89340b8b75530912a6560352ca19
+  data.tar.gz: e63cf93bfb1ec76e4aa710bb15da91bd61e27f259c30d6011e0805c64f3b219420b20cbe2343cf6736ba2e7e40c7cc413b6b8a04779eb4cf7438cad3e4aa04cf

data/.rubocop.yml

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

data/.travis.yml

@@ -5,9 +5,3 @@ rvm:
   - 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.
-    - rvm: ruby-head

data/db/unicode_ranges_2.1.pstore

@@ -0,0 +1 @@
+unicode_ranges_2.0.pstore

data/lib/core_extensions/regexp/examples.rb

@@ -1,5 +1,8 @@
 module CoreExtensions
   module Regexp
+    # A wrapper module to namespace/isolate the Regexp#examples and Regexp#random_exanple
+    # monkey patches.
+    # No core classes are extended in any way, other than the above two methods.
     module Examples
       def examples(**config_options)
         RegexpExamples::ResultCountLimiters.configure!(

data/lib/regexp-examples/backreferences.rb

@@ -1,24 +1,40 @@
 module RegexpExamples
+  # A helper class to fill-in backrefences AFTER the example(s) have been generated.
+  # In a nutshell, this works by doing the following:
+  # * Given a regex that contains a capute group and backreference, e.g. `/(a|b) \1/`
+  # * After generating examples, the backreference is tored as a placeholder:
+  #   `["a __1__", "b __1__"]`
+  # * This class is used to fill in each placeholder accordingly:
+  #   `["a a", "b b"]`
+  # * Also, beware of octal groups and cases where the backref invalidates the example!!
   class BackReferenceReplacer
-    BackrefNotFound = Class.new(StandardError)
+    # Named capture groups can only contain alphanumeric chars, and hyphens
+    PLACEHOLDER_REGEX = Regexp.new(
+      RegexpExamples::BackReferenceGroup::PLACEHOLDER_FORMAT % '([a-zA-Z0-9-]+)'
+    )
 
     def substitute_backreferences(full_examples)
       full_examples.map do |full_example|
-        begin
-          while full_example.match(/__(\w+?)__/)
-            full_example.sub!(/__(\w+?)__/, find_backref_for(full_example, Regexp.last_match(1)))
-          end
-          full_example
-        rescue BackrefNotFound
-          # For instance, one "full example" from /(a|(b)) \2/: "a __2__"
-          # should be rejected because the backref (\2) does not exist
-          nil
+        # For instance, one "full example" from /(a|(b)) \2/: "a __2__"
+        # should be rejected because the backref (\2) does not exist
+        catch(:backref_not_found) do
+          substitute_backrefs_one_at_a_time(full_example)
         end
       end.compact
     end
 
     private
 
+    def substitute_backrefs_one_at_a_time(full_example)
+      while full_example.match(PLACEHOLDER_REGEX)
+        full_example.sub!(
+          PLACEHOLDER_REGEX,
+          find_backref_for(full_example, Regexp.last_match(1))
+        )
+      end
+      full_example
+    end
+
     def find_backref_for(full_example, group_id)
       full_example.all_subgroups.detect do |subgroup|
         subgroup.group_id == group_id
@@ -26,11 +42,11 @@ module RegexpExamples
     end
 
     def octal_char_for(octal_chars)
-      # For octal characters in the range \10 - \177
-      if octal_chars =~ /\A[01]?[0-7]{1,2}\z/ && octal_chars.to_i >= 10
+      # For octal characters in the range \00 - \177
+      if octal_chars =~ /\A[01]?[0-7]{1,2}\z/ && octal_chars.length > 1
         Integer(octal_chars, 8).chr
       else
-        fail(BackrefNotFound)
+        throw :backref_not_found
       end
     end
   end

data/lib/regexp-examples/chargroup_parser.rb

@@ -1,3 +1,5 @@
+require_relative 'parser_helpers/charset_negation_helper'
+
 module RegexpExamples
   # A "sub-parser", for char groups in a regular expression
   # Some examples of what this class needs to parse:
@@ -7,20 +9,23 @@ module RegexpExamples
   # [^abc]         - negated group
   # [[a][bc]]      - sub-groups (should match "a", "b" or "c")
   # [[:lower:]]    - POSIX group
-  # [[a-f]&&[d-z]] - set intersection (should match "d", "f" or "f")
+  # [[a-f]&&[d-z]] - set intersection (should match "d", "e" or "f")
   # [[^:alpha:]&&[\n]a-c] - all of the above!!!! (should match "\n")
   class ChargroupParser
-    attr_reader :regexp_string
+    include CharsetNegationHelper
+
+    attr_reader :regexp_string, :current_position
+    alias_method :length, :current_position
+
     def initialize(regexp_string, is_sub_group: false)
       @regexp_string = regexp_string
       @is_sub_group = is_sub_group
       @current_position = 0
-      parse
+      @charset = []
+      @negative = false
     end
 
     def parse
-      @charset = []
-      @negative = false
       parse_first_chars
       until next_char == ']'
         case next_char
@@ -40,12 +45,8 @@ module RegexpExamples
       @current_position += 1 # To account for final "]"
     end
 
-    def length
-      @current_position
-    end
-
     def result
-      @negative ? (CharSets::Any - @charset) : @charset
+      negate_if(@charset, @negative)
     end
 
     private
@@ -66,12 +67,7 @@ module RegexpExamples
     end
 
     def parse_posix_group(negation_flag, name)
-      chars = if negation_flag.empty?
-                POSIXCharMap[name]
-              else
-                CharSets::Any - POSIXCharMap[name]
-              end
-      @charset.concat chars
+      @charset.concat negate_if(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)
@@ -101,6 +97,7 @@ module RegexpExamples
     def parse_sub_group_concat
       @current_position += 1
       sub_group_parser = self.class.new(rest_of_string, is_sub_group: true)
+      sub_group_parser.parse
       @charset.concat sub_group_parser.result
       @current_position += sub_group_parser.length
     end
@@ -117,6 +114,7 @@ module RegexpExamples
     def parse_sub_group_intersect
       @current_position += 2
       sub_group_parser = self.class.new(rest_of_string, is_sub_group: true)
+      sub_group_parser.parse
       @charset &= sub_group_parser.result
       @current_position += (sub_group_parser.length - 1)
     end
@@ -127,7 +125,7 @@ module RegexpExamples
         @current_position += 1
       else
         @current_position += 1
-        @charset.concat (@charset.last..parse_checking_backlash.first).to_a
+        @charset.concat((@charset.last..parse_checking_backlash.first).to_a)
         @current_position += 1
       end
     end

data/lib/regexp-examples/constants.rb

@@ -1,4 +1,6 @@
+# :nodoc:
 module RegexpExamples
+  # Configuration settings to limit the number/length of Regexp examples generated
   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:
@@ -7,30 +9,32 @@ module RegexpExamples
     # .{2,} is equivalent to .{2,4}
     # .{,3} is equivalent to .{0,2}
     # .{3,8} is equivalent to .{3,5}
-    MaxRepeaterVarianceDefault = 2
+    MAX_REPEATER_VARIANCE_DEFAULT = 2
 
     # Maximum number of characters returned from a char set, to reduce output spam
     # For example, if @@max_group_results = 5 then:
     # \d is equivalent to [01234]
     # \w is equivalent to [abcde]
-    MaxGroupResultsDefault = 5
+    MAX_GROUP_RESULTS_DEFAULT = 5
 
     class << self
       attr_reader :max_repeater_variance, :max_group_results
       def configure!(max_repeater_variance, max_group_results = nil)
-        @max_repeater_variance = (max_repeater_variance || MaxRepeaterVarianceDefault)
-        @max_group_results = (max_group_results || MaxGroupResultsDefault)
+        @max_repeater_variance = (max_repeater_variance || MAX_REPEATER_VARIANCE_DEFAULT)
+        @max_group_results = (max_group_results || MAX_GROUP_RESULTS_DEFAULT)
       end
     end
   end
 
-  def self.MaxRepeaterVariance
+  def self.max_repeater_variance
     ResultCountLimiters.max_repeater_variance
   end
-  def self.MaxGroupResults
+  def self.max_group_results
     ResultCountLimiters.max_group_results
   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')

data/lib/regexp-examples/groups.rb

@@ -6,13 +6,12 @@ module RegexpExamples
     attr_reader :group_id, :subgroups
     def initialize(result, group_id = nil, subgroups = [])
       @group_id = group_id
-      @subgroups = subgroups
-      @subgroups = result.all_subgroups if result.respond_to?(:group_id)
+      @subgroups = result.respond_to?(:group_id) ? result.all_subgroups : subgroups
       super(result)
     end
 
     def all_subgroups
-      [self, subgroups].flatten.reject { |subgroup| subgroup.group_id.nil? }
+      [self, subgroups].flatten.keep_if(&:group_id)
     end
 
     def swapcase
@@ -132,24 +131,16 @@ module RegexpExamples
       @group_id = group_id
     end
 
-    def result
-      result_by_method(:result)
-    end
-
-    def random_result
-      result_by_method(:random_result)
-    end
-
-    private
-
     # Generates the result of each contained group
     # and adds the filled group of each result to itself
-    def result_by_method(method)
-      strings = @groups.map { |repeater| repeater.public_send(method) }
+    def result
+      strings = @groups.map { |repeater| repeater.public_send(__method__) }
       RegexpExamples.permutations_of_strings(strings).map do |result|
         GroupResult.new(result, group_id)
       end
     end
+
+    alias_method :random_result, :result
   end
 
   # A boolean "or" group.
@@ -177,13 +168,10 @@ module RegexpExamples
     private
 
     def result_by_method(method)
-      repeaters_list.map do |repeaters|
-        RegexpExamples.public_send(method, repeaters)
-      end
+      repeaters_list
+        .map { |repeaters| RegexpExamples.public_send(method, repeaters) }
         .inject(:concat)
-        .map do |result|
-          GroupResult.new(result)
-        end
+        .map { |result| GroupResult.new(result) }
         .uniq
     end
 
@@ -203,13 +191,14 @@ module RegexpExamples
   # of /\1/ as being "__1__". It later gets updated.
   class BackReferenceGroup
     include RandomResultBySample
+    PLACEHOLDER_FORMAT = '__%s__'
     attr_reader :id
     def initialize(id)
       @id = id
     end
 
     def result
-      [GroupResult.new("__#{@id}__")]
+      [GroupResult.new(PLACEHOLDER_FORMAT % @id)]
     end
   end
 end

data/lib/regexp-examples/helpers.rb

@@ -1,3 +1,4 @@
+# :nodoc:
 module RegexpExamples
   # Given an array of arrays of strings, returns all possible perutations
   # for strings, created by joining one element from each array
@@ -14,15 +15,13 @@ module RegexpExamples
   end
 
   def self.join_preserving_capture_groups(result)
-    result.flatten!
+    # Only save the LAST group from repeated capture groups, e.g. /([ab]){2}/
+    # (Hence the need for "reverse"!)
     subgroups = result
-                .map(&:all_subgroups)
-                .flatten
+                .flat_map(&:all_subgroups)
+                .reverse
+                .uniq(&:group_id)
 
-    # Only save the LAST group from repeated capture groups, e.g. /([ab]){2}/
-    subgroups.delete_if do |subgroup|
-      subgroups.count { |other_subgroup| other_subgroup.group_id == subgroup.group_id } > 1
-    end
     GroupResult.new(result.join, nil, subgroups)
   end