regexp-examples 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 460970b9b7691fe163a9334542ccd57c71241c2a
-  data.tar.gz: 0c4ce5df7f59e72af6de41b8538d72b52c40939d
+  metadata.gz: ff205ed61ad0ca0c2dc2383afd17930110763b44
+  data.tar.gz: a13f23a7d56b9b7d7e4323380d705276793e6e4f
 SHA512:
-  metadata.gz: 5932e6ea64e3008dad054d67f906863244366324e28cf1d280a222966b77dc1bc816760d6af1d9f023518b40ccfbdd8ad9c634060d2811ca5d687e333604e268
-  data.tar.gz: fd2c136a9457aac2e953fe77c972925a6af9f420f025ca9f7500a8252636ebf1ba2b1104232d17719de5b1c53cf8e1a4316c52e789bed113b6589b8cf71c7dda
+  metadata.gz: 068c7dbd13945c0487b91c61e9cae304323775adc82cd4e80092ab32505eb46f31aaf98736f5a353eb1ad06a471864f9432ce3d203097f2dcfc6e696dba07e12
+  data.tar.gz: c2014a4055874af1edbdc3fbee60e58b3f182ba37278f5f0738f4699256a0669b84e8b7d731494c5493e04fb249c3135cb31e5a716e687cd677fd3f9fa1a8da9

data/README.md

@@ -39,15 +39,16 @@ For more detail on this, see [configuration options](#configuration-options).
   * Groups work fine, even if nested or optional e.g. `/(even(this(works?))) \1 \2 \3/`, `/what about (this)? \1/`
   * Non-capture groups, e.g. `/(?:foo)/`
 * Control characters, e.g. `/\ca/`, `/\cZ/`, `/\C-9/`
-* Escape sequences, e.g. `/\x42/`, `/\x3D/`, `/\x5word/`, `/#{"\x80".force_encoding("ASCII-8BIT")}/`
+* Escape sequences, e.g. `/\x42/`, `/\x5word/`, `/#{"\x80".force_encoding("ASCII-8BIT")}/`
 * Unicode characters, e.g. `/\u0123/`, `/\uabcd/`, `/\u{789}/`
 * **Arbitrarily complex combinations of all the above!**
 
-## Bugs and Not-Yet-Supported syntax
+* Regexp options can also be used:
+  * Case insensitive examples: `/cool/i.examples #=> ["cool", "cooL", "coOl", "coOL", ...]`
+  * Multiline examples: `/./m.examples(max_group_results: 999) #=> ["a", "b", "c", ..., "\n"]`
+  * Extended form examples: `/line1 #comment \n line2/x.examples #=> ["line1line2"]`
 
-* Other options (besides ingnorecase), will currently just be ignored, for example:
-  * `/white  space/x.examples` will not strip out the whitespace from the pattern, i.e. this incorrectly returns `["white  space"]` rather than `["whitespace"]`
-  * `/./m.examples(max_group_results: 999)` will not include `"\n"`
+## Bugs and Not-Yet-Supported syntax
 
 * Nested character classes, and the use of set intersection ([See here](http://www.ruby-doc.org/core-2.2.0/Regexp.html#class-Regexp-label-Character+Classes) for the official documentation on this.) For example:
   * `/[[abc]]/.examples`  (which _should_ return `["a", "b", "c"]`)
@@ -60,14 +61,14 @@ For more detail on this, see [configuration options](#configuration-options).
 
 * The patterns: `/\10/` ... `/\77/` should match the octal representation of their character code, if there is no nth grouped subexpression. For example, `/\10/.examples` should return `["\x08"]`. Funnily enough, I did not think of this when writing my regexp parser.
 
-There are loads more (increasingly obscure) unsupported bits of syntax, which I cannot be bothered to write out here. Full documentation on all the various other obscurities in the ruby (version 2.x) regexp parser can be found [here](https://raw.githubusercontent.com/k-takata/Onigmo/master/doc/RE).
-
 Using any of the following will raise a RegexpExamples::UnsupportedSyntax exception (until such time as they are implemented!):
 
 * POSIX bracket expressions, e.g. `/[[:alnum:]]/`, `/[[:space:]]/`
 * Named properties, e.g. `/\p{L}/` ("Letter"), `/\p{Arabic}/` ("Arabic character"), `/\p{^Ll}/` ("Not a lowercase letter")
 * Subexpression calls, e.g. `/(?<name> ... \g<name>* )/` (Note: These could get _really_ ugly to implement, and may even be impossible, so I highly doubt it's worth the effort!)
 
+There are loads more (increasingly obscure) unsupported bits of syntax, which I cannot be bothered to write out here. Full documentation on all the various other obscurities in the ruby (version 2.x) regexp parser can be found [here](https://raw.githubusercontent.com/k-takata/Onigmo/master/doc/RE).
+
 ## 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"!

data/lib/regexp-examples/groups.rb

@@ -23,11 +23,11 @@ module RegexpExamples
     end
   end
 
-  module GroupWithOptions
-    attr_reader :options
+  module GroupWithIgnoreCase
+    attr_reader :ignorecase
     def result
       group_result = super
-      if options[:ignorecase]
+      if ignorecase
         group_result
           .concat( group_result.map(&:swapcase) )
           .uniq
@@ -38,10 +38,10 @@ module RegexpExamples
   end
 
   class SingleCharGroup
-    prepend GroupWithOptions
-    def initialize(char, options)
+    prepend GroupWithIgnoreCase
+    def initialize(char, ignorecase)
       @char = char
-      @options = options
+      @ignorecase = ignorecase
     end
     def result
       [GroupResult.new(@char)]
@@ -49,10 +49,10 @@ module RegexpExamples
   end
 
   class CharGroup
-    prepend GroupWithOptions
-    def initialize(chars, options)
+    prepend GroupWithIgnoreCase
+    def initialize(chars, ignorecase)
       @chars = chars
-      @options = options
+      @ignorecase = ignorecase
       if chars[0] == "^"
         @negative = true
         @chars = @chars[1..-1]
@@ -119,25 +119,27 @@ module RegexpExamples
   end
 
   class DotGroup
-    prepend GroupWithOptions
-    def initialize(options={})
-      @options = options
+    attr_reader :multiline
+    def initialize(multiline)
+      @multiline = multiline
     end
 
     def result
-      CharSets::Any.map do |result|
+      chars = CharSets::Any
+      chars |= ["\n"] if multiline
+      chars.map do |result|
         GroupResult.new(result)
       end
     end
   end
 
   class MultiGroup
-    prepend GroupWithOptions
+    prepend GroupWithIgnoreCase
     attr_reader :group_id
-    def initialize(groups, group_id, options)
+    def initialize(groups, group_id, ignorecase)
       @groups = groups
       @group_id = group_id
-      @options = options
+      @ignorecase = ignorecase
     end
 
     # Generates the result of each contained group

data/lib/regexp-examples/parser.rb

@@ -3,10 +3,12 @@ module RegexpExamples
     attr_reader :regexp_string
     def initialize(regexp_string, regexp_options, config_options={})
       @regexp_string = regexp_string
-      @ignorecase = ( regexp_options & Regexp::IGNORECASE == 1 )
+      @ignorecase = !(regexp_options & Regexp::IGNORECASE).zero?
+      @multiline = !(regexp_options & Regexp::MULTILINE).zero?
+      @extended = !(regexp_options & Regexp::EXTENDED).zero?
       @num_groups = 0
       @current_position = 0
-      RegexpExamples::ResultCountLimiters.configure!(
+      ResultCountLimiters.configure!(
         config_options[:max_repeater_variance],
         config_options[:max_group_results]
       )
@@ -28,10 +30,6 @@ module RegexpExamples
 
     private
 
-    def regexp_options
-      {ignorecase: @ignorecase}
-    end
-
     def parse_group(repeaters)
       case next_char
       when '('
@@ -58,12 +56,24 @@ module RegexpExamples
         else
           raise IllegalSyntaxError, "Anchors 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
+        else
+          group = parse_single_char_group(next_char)
+        end
       else
         group = parse_single_char_group(next_char)
       end
       group
     end
 
+    def parse_extended_whitespace
+      whitespace_chars = rest_of_string.match(/#.*|\s+/)[0]
+      @current_position += whitespace_chars.length - 1
+    end
+
     def parse_after_backslash_group
       @current_position += 1
       case
@@ -78,7 +88,7 @@ module RegexpExamples
           # Note: The `.dup` is important, as it prevents modifying the constant, in
           # CharGroup#init_ranges (where the '-' is moved to the front)
           BackslashCharMap[next_char].dup,
-          regexp_options
+          @ignorecase
         )
       when rest_of_string =~ /\A(c|C-)(.)/ # Control character
         @current_position += $1.length
@@ -153,7 +163,7 @@ module RegexpExamples
         end
       end
       groups = parse
-      MultiGroup.new(groups, group_id, regexp_options)
+      MultiGroup.new(groups, group_id, @ignorecase)
     end
 
     def parse_multi_end_group
@@ -181,11 +191,11 @@ module RegexpExamples
         chars << next_char
         @current_position += 1
       end
-      CharGroup.new(chars, regexp_options)
+      CharGroup.new(chars, @ignorecase)
     end
 
     def parse_dot_group
-      DotGroup.new(regexp_options)
+      DotGroup.new(@multiline)
     end
 
     def parse_or_group(left_repeaters)
@@ -196,7 +206,7 @@ module RegexpExamples
 
 
     def parse_single_char_group(char)
-      SingleCharGroup.new(char, regexp_options)
+      SingleCharGroup.new(char, @ignorecase)
     end
 
     def parse_backreference_group(match)

data/lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/spec/regexp-examples_spec.rb

@@ -233,7 +233,7 @@ RSpec.describe Regexp, "#examples" do
 
     context "exact examples match" do
       # More rigorous tests to assert that ALL examples are being listed
-      context "default options" do
+      context "default config options" do
         # Simple examples
         it { expect(/[ab]{2}/.examples).to eq ["aa", "ab", "ba", "bb"] }
         it { expect(/(a|b){2}/.examples).to eq ["aa", "ab", "ba", "bb"] }
@@ -243,7 +243,7 @@ RSpec.describe Regexp, "#examples" do
         it { expect(/a{1}?/.examples).to eq ["", "a"] }
       end
 
-      context "max_repeater_variance option" do
+      context "max_repeater_variance config option" do
         it do
           expect(/a+/.examples(max_repeater_variance: 5))
             .to eq %w(a aa aaa aaaa aaaaa aaaaaa)
@@ -254,7 +254,7 @@ RSpec.describe Regexp, "#examples" do
         end
       end
 
-      context "max_group_results option" do
+      context "max_group_results config option" do
         it do
           expect(/\d/.examples(max_group_results: 10))
             .to eq %w(0 1 2 3 4 5 6 7 8 9)
@@ -266,6 +266,24 @@ RSpec.describe Regexp, "#examples" do
         it { expect(/a+/i.examples).to eq %w(a A aa aA Aa AA aaa aaA aAa aAA Aaa AaA AAa AAA) }
         it { expect(/([ab])\1/i.examples).to eq %w(aa bb AA BB) }
       end
+
+      context "multiline" do
+        it { expect(/./.examples(max_group_results: 999)).not_to include "\n" }
+        it { expect(/./m.examples(max_group_results: 999)).to include "\n" }
+      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 do
+          expect(
+            /
+              line1 #comment
+              line2 #comment
+            /x.examples
+          ).to eq %w(line1line2)
+        end
+      end
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Tom Lord
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler