Merge branch 'master' of github.com:tom-lord/regexp-examples

Conflicts:
	lib/regexp-examples/backreferences.rb

README.md

@@ -76,7 +76,7 @@ Using any of the following will raise a RegexpExamples::IllegalSyntax exception:
 
 * Lookarounds, e.g. `/foo(?=bar)/`, `/foo(?!bar)/`, `/(?<=foo)bar/`, `/(?<!foo)bar/`
 * [Anchors](http://ruby-doc.org/core-2.2.0/Regexp.html#class-Regexp-label-Anchors) (`\b`, `\B`, `\G`, `^`, `\A`, `$`, `\z`, `\Z`), e.g. `/\bword\b/`, `/line1\n^line2/`
-  * However, a special case has been made to allow `^` and `\A` at the start of a pattern; and to allow `$`, `\z` and `\Z` at the end of pattern. In such cases, the characters are effectively just ignored.
+  * However, a special case has been made to allow `^`, `\A` and `\G` at the start of a pattern; and to allow `$`, `\z` and `\Z` at the end of pattern. In such cases, the characters are effectively just ignored.
 
 (Note: Backreferences are not really "regular" either, but I got these to work with a bit of hackery!)
 

lib/regexp-examples/groups.rb

@@ -48,6 +48,16 @@ def result
     end
   end
 
+  # Used as a workaround for when a grep is expected to be returned,
+  # but there are no results for the group.
+  # i.e. PlaceHolderGroup.new.result == '' == SingleCharGroup.new('').result
+  # (But using PlaceHolderGroup makes it clearer what the intention is!)
+  class PlaceHolderGroup
+    def result
+      [GroupResult.new('')]
+    end
+  end
+
   class CharGroup
     prepend GroupWithIgnoreCase
     def initialize(chars, ignorecase)

lib/regexp-examples/parser.rb

@@ -44,22 +44,22 @@ def parse_group(repeaters)
         group = parse_or_group(repeaters)
       when '\\'
         group = parse_after_backslash_group
-      when '^', 'A'
+      when '^'
         if @current_position == 0
-          group = parse_single_char_group('') # Ignore the "illegal" character
+          group = PlaceHolderGroup.new # Ignore the "illegal" character
         else
-          raise IllegalSyntaxError, "Anchors cannot be supported, as they are not regular"
+          raise IllegalSyntaxError, "Anchors ('#{next_char}') cannot be supported, as they are not regular"
         end
-      when '$', 'z', 'Z'
+      when '$'
         if @current_position == (regexp_string.length - 1)
-          group = parse_single_char_group('') # Ignore the "illegal" character
+          group = PlaceHolderGroup.new # Ignore the "illegal" character
         else
-          raise IllegalSyntaxError, "Anchors cannot be supported, as they are not regular"
+          raise IllegalSyntaxError, "Anchors ('#{next_char}') cannot be supported, as they are not regular"
         end
       when /[#\s]/
         if @extended
           parse_extended_whitespace
-          group = parse_single_char_group('') # Ignore the whitespace/comment
+          group = PlaceHolderGroup.new # Ignore the whitespace/comment
         else
           group = parse_single_char_group(next_char)
         end
@@ -103,22 +103,26 @@ def parse_after_backslash_group
       when rest_of_string =~ /\Ap\{([^}]+)\}/ # Named properties
         @current_position += ($1.length + 2)
         raise UnsupportedSyntaxError, "Named properties ({\\p#{$1}}) are not yet supported"
-      when rest_of_string =~ /\Ag/ # Subexpression call
+      when next_char == 'K' # Keep (special lookbehind that CAN be supported safely!)
+        group = PlaceHolderGroup.new
+      when next_char == 'R' # Linebreak
+        group = CharGroup.new(["\r\n", "\n", "\v", "\f", "\r"], @ignorecase) # A bit hacky...
+      when next_char == 'g' # Subexpression call
         # TODO: Should this be IllegalSyntaxError ?
         raise UnsupportedSyntaxError, "Subexpression calls (\g) are not yet supported"
-      when rest_of_string =~ /\A[GbB]/ # Anchors
-        raise IllegalSyntaxError, "Anchors cannot be supported, as they are not regular"
-      when rest_of_string =~ /\AA/ # Start of string
+      when next_char =~ /[bB]/ # Anchors
+        raise IllegalSyntaxError, "Anchors ('\\#{next_char}') cannot be supported, as they are not regular"
+      when next_char =~ /[AG]/ # Start of string
         if @current_position == 1
-          group = parse_single_char_group('') # Ignore the "illegal" character
+          group = PlaceHolderGroup.new
         else
-          raise IllegalSyntaxError, "Anchors cannot be supported, as they are not regular"
+          raise IllegalSyntaxError, "Anchors ('\\#{next_char}') cannot be supported, as they are not regular"
         end
-      when rest_of_string =~ /\A[zZ]/ # End of string
+      when next_char =~ /[zZ]/ # End of string
         if @current_position == (regexp_string.length - 1)
-          group = parse_single_char_group('') # Ignore the "illegal" character
+          group = PlaceHolderGroup.new
         else
-          raise IllegalSyntaxError, "Anchors cannot be supported, as they are not regular"
+          raise IllegalSyntaxError, "Anchors ('\\#{next_char}') cannot be supported, as they are not regular"
         end
       else
         group = parse_single_char_group( next_char )
@@ -182,7 +186,7 @@ def parse_multi_group
           if next_char == ':' # e.g. /(?i:subexpr)/
             @current_position += 1
           else
-            return parse_single_char_group('')
+            return PlaceHolderGroup.new
           end
         when %w(! =).include?(match[2]) # e.g. /(?=lookahead)/, /(?!neglookahead)/
           raise IllegalSyntaxError, "Lookaheads are not regular; cannot generate examples"

lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '0.5.2'
+  VERSION = '0.5.3'
 end

spec/regexp-examples_spec.rb

@@ -103,23 +103,15 @@ def self.examples_are_empty(*regexps)
     end
 
     context "for escaped characters" do
-      examples_exist_and_match(
-        /\w/,
-        /\W/,
-        /\s/,
-        /\S/,
-        /\d/,
-        /\D/,
-        /\h/,
-        /\H/,
-        /\t/,
-        /\n/,
-        /\f/,
-        /\a/,
-        /\v/,
-        /\e/,
-        /[\b]/
-      )
+      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)
+      valid_letters = all_letters - special_letters
+
+      valid_letters.each do |char|
+        backslash_char = "\\#{char}"
+        examples_exist_and_match( /#{backslash_char}/ )
+      end
+      examples_exist_and_match( /[\b]/ )
     end
 
     context "for backreferences" do
@@ -165,7 +157,6 @@ def self.examples_are_empty(*regexps)
         /(?<!neglookbehind)/,
         /\bword-boundary/,
         /no\Bn-word-boundary/,
-        /\Glast-match/,
         /start-of\A-string/,
         /start-of^-line/,
         /end-of\Z-string/,
@@ -177,6 +168,7 @@ def self.examples_are_empty(*regexps)
     context "ignore start/end anchors if at start/end" do
       examples_exist_and_match(
         /\Astart/,
+        /\Glast-match/,
         /^start/,
         /end$/,
         /end\z/,