regexp-examples 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39d4ef9f2ee3e17541118580954e0a9f137f969b
-  data.tar.gz: 9e573acd0b5cdcf700bfe4f49a838933e6a01737
+  metadata.gz: fc845182adb1adaeed70de6139d27711a69dc81f
+  data.tar.gz: 3d1850382acaf7ee4c96c9acf924a585cec6939b
 SHA512:
-  metadata.gz: 50ee2b66ced2a4878309566088a493b8cc7654d44db6b91458c0f04f4015cbc9a2e437b7444670b28a78475a5df715d89dd8a81fa1e9d508095c234da830c782
-  data.tar.gz: 4785f7967bc3549629c2fbb5f74f0d7343076a028d33265344b9f1cb0b74c39df2c4f402ab97baeb42fb536dbd31132eb3fb69d462cab5a3ffb0f568ae91bed5
+  metadata.gz: 0b2a8ff8619ba8bc4186a27491dac7140ff8e0d7e4cb87ccfd8e9047b0f392c7152e2988666edaf4df6a1d2db0961ac1dfdc0af32b9d50c3ddbda6ff60814c97
+  data.tar.gz: f3690a8f6d2089b57a57246d9ec2b25252a2bee5972536ef095bf45358348ce1c322e3d3b04b69121e8530e155c2c9c4542f5f48cdc6a83ea6366eb246af3f94

data/README.md

@@ -15,7 +15,7 @@ For more detail on this, see [configuration options](#configuration-options).
 ## Usage
 
 ```ruby
-/a*/.examples #=> [''. 'a', 'aa']
+/a*/.examples #=> ['', 'a', 'aa']
 /ab+/.examples #=> ['ab', 'abb', 'abbb']
 /this|is|awesome/.examples #=> ['this', 'is', 'awesome']
 /https?:\/\/(www\.)?github\.com/.examples #=> ['http://github.com',
@@ -23,7 +23,8 @@ For more detail on this, see [configuration options](#configuration-options).
 /(I(N(C(E(P(T(I(O(N)))))))))*/.examples #=> ["", "INCEPTION", "INCEPTIONINCEPTION"]
 /\x74\x68\x69\x73/.examples #=> ["this"]
 /\u6829/.examples #=> ["栩"]
-/what about (backreferences\?) \1/.examples #=> ['what about backreferences? backreferences?']
+/what about (backreferences\?) \1/.examples
+  #=> ['what about backreferences? backreferences?']
 ```
 
 ## Installation
@@ -45,9 +46,9 @@ Or install it yourself as:
 ## Supported syntax
 
 * All forms of repeaters (quantifiers), e.g. `/a*/`, `/a+/`, `/a?/`, `/a{1,4}/`, `/a{3,}/`, `/a{,2}/`
-  * Reluctant and possissive repeaters work fine, too - e.g. `/a*?/`, `/a*+/`
+  * Reluctant and possissive repeaters work fine, too, e.g. `/a*?/`, `/a*+/`
 * Boolean "Or" groups, e.g. `/a|b|c/`
-* Character sets e.g. `/[abc]/` - including:
+* Character sets, e.g. `/[abc]/` - including:
   * Ranges, e.g.`/[A-Z0-9]/`
   * Negation, e.g. `/[^a-z]/`
   * Escaped characters, e.g. `/[\w\s\b]/`
@@ -57,14 +58,15 @@ Or install it yourself as:
 * Capture groups, e.g. `/(group)/`
   * Including named groups, e.g. `/(?<name>group)/`
   * ...And backreferences(!!!), e.g. `/(this|that) \1/` `/(?<name>foo) \k<name>/`
-  * Groups work fine, even if nested or optional e.g. `/(even(this(works?))) \1 \2 \3/`, `/what about (this)? \1/`
+  * 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)/`
   * Comment groups, e.g. `/foo(?#comment)bar/`
 * Control characters, e.g. `/\ca/`, `/\cZ/`, `/\C-9/`
 * Escape sequences, e.g. `/\x42/`, `/\x5word/`, `/#{"\x80".force_encoding("ASCII-8BIT")}/`
 * Unicode characters, e.g. `/\u0123/`, `/\uabcd/`, `/\u{789}/`
 * Octal characters, e.g. `/\10/`, `/\177/`
-* Named properties, e.g. `/\p{L}/` ("Letter"), `/\p{Arabic}/` ("Arabic character"), `/\p{^Ll}/` ("Not a lowercase letter")
+* Named properties, e.g. `/\p{L}/` ("Letter"), `/\p{Arabic}/` ("Arabic character")
+, `/\p{^Ll}/` ("Not a lowercase letter"), `\P{^Canadian_Aboriginal}` ("Not not a Canadian aboriginal character")
 * **Arbitrarily complex combinations of all the above!**
 
 * Regexp options can also be used:
@@ -76,11 +78,12 @@ Or install it yourself as:
 ## Bugs and Not-Yet-Supported syntax
 
 * There are some (rare) edge cases where backreferences do not work properly, e.g. `/(a*)a* \1/.examples` - which includes "aaaa aa". This is because each repeater is not context-aware, so the "greediness" logic is flawed. (E.g. in this case, the second `a*` should always evaluate to an empty string, because the previous `a*` was greedy! However, patterns like this are highly unusual...
-* Some named properties, e.g. `/\p{Arabic}/`, list non-matching examples for ruby 2.0/2.1 (as the definitions changed in ruby 2.2). This would be "easy" to fix, but I can't be bothered... Feel free to make a pull request!
+* Some named properties, e.g. `/\p{Arabic}/`, list non-matching examples for ruby 2.0/2.1 (as the definitions changed in ruby 2.2). This will be fixed in version 1.1.0 (see the pending pull request)!
 
-There are also some various (increasingly obscure) unsupported bits of syntax, which I cannot be bothered to write out fully here. Full documentation on all the intricate obscurities in the ruby (version 2.x) regexp parser can be found [here](https://raw.githubusercontent.com/k-takata/Onigmo/master/doc/RE). To name a couple:
+There are also some various (increasingly obscure) unsupported bits of syntax; some of which I haven't yet investigated. Much of this is not even mentioned in the ruby docs! Full documentation on all the intricate obscurities in the ruby (version 2.x) regexp parser can be found [here](https://raw.githubusercontent.com/k-takata/Onigmo/master/doc/RE). To name a few:
 * Conditional capture groups, e.g. `/(group1)? (?(1)yes|no)/.examples` (which *should* return: `["group1 yes", " no"]`)
-* Back reference by relatve group number, e.g. `/(a)(b)(c)(d) \k<-2>/.examples` (which *should* return: `["abcd c"]`)
+* Back reference by relative group number, e.g. `/(a)(b)(c)(d) \k<-2>/.examples` (which *should* return: `["abcd c"]`)
+* Back reference using single quotes, and for group numbers, e.g. `/(a) \k'1'/.examples` (which is really just alternative syntax for `/(a) \1/`!)
 
 ## Impossible features ("illegal syntax")
 
@@ -92,7 +95,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 `^`, `\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.
-* Subexpression calls, e.g. `/(?<name> ... \g<name>* )/`
+* Subexpression calls (`\g`), e.g. `/(?<name> ... \g<name>* )/`
 
 (Note: Backreferences are not really "regular" either, but I got these to work with a bit of hackery!)
 
@@ -137,8 +140,9 @@ A more sensible use case might be, for example, to generate one random 1-4 digit
 ## TODO
 
 * Performance improvements:
-  * Use of lambdas/something (in [constants.rb](lib/regexp-examples/constants.rb)) to improve the library load time.
-  * (Maybe?) add a `max_examples` configuration option and use lazy evaluation, to ensure the method never "freezes"
+  * Use of lambdas/something (in [constants.rb](lib/regexp-examples/constants.rb)) to improve the library load time. See the pending pull request.
+  * (Maybe?) add a `max_examples` configuration option and use lazy evaluation, to ensure the method never "freezes".
+* Potential future feature: `Regexp#random_example` - but implementing this properly is non-trivial, due to performance issues that need addressing first!
 * Write a blog post about how this amazing gem works! :)
 
 ## Contributing

data/lib/regexp-examples/parser.rb

@@ -99,13 +99,14 @@ module RegexpExamples
         @current_position += $1.length
         sequence = $1.match(/\h{1,4}/)[0] # Strip off "{" and "}"
         group = parse_single_char_group( parse_unicode_sequence(sequence) )
-      when rest_of_string =~ /\Ap\{(\^?)([^}]+)\}/ # Named properties
-        @current_position += ($1.length + $2.length + 2)
+      when rest_of_string =~ /\A(p)\{(\^?)([^}]+)\}/i # Named properties
+        @current_position += ($2.length + $3.length + 2)
+        is_negative = ($1 == "P") ^ ($2 == "^") # Beware of double negatives! E.g. /\P{^Space}/
         group = CharGroup.new(
-          if($1 == "^")
-            CharSets::Any.dup - NamedPropertyCharMap[$2.downcase]
+          if is_negative
+            CharSets::Any.dup - NamedPropertyCharMap[$3.downcase]
           else
-            NamedPropertyCharMap[$2.downcase]
+            NamedPropertyCharMap[$3.downcase]
           end,
           @ignorecase
         )
@@ -114,7 +115,7 @@ module RegexpExamples
       when next_char == 'R' # Linebreak
         group = CharGroup.new(["\r\n", "\n", "\v", "\f", "\r"], @ignorecase) # A bit hacky...
       when next_char == 'g' # Subexpression call
-        raise IllegalSyntaxError, "Subexpression calls (\g) are not yet supported"
+        raise IllegalSyntaxError, "Subexpression calls (\\g) cannot be supported, as they are not regular"
       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

data/lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/spec/regexp-examples_spec.rb

@@ -80,6 +80,8 @@ RSpec.describe Regexp, "#examples" do
         /[\\\]]/,
         /[\n-\r]/,
         /[\-]/,
+        /[-abc]/,
+        /[abc-]/,
         /[%-+]/, # This regex is "supposed to" match some surprising things!!!
         /['-.]/, # Test to ensure no "infinite loop" on character set expansion
         /[[abc]]/, # Nested groups
@@ -180,7 +182,9 @@ RSpec.describe Regexp, "#examples" do
         /\p{L}/,
         /\p{Space}/,
         /\p{AlPhA}/, # Checking case insensitivity
-        /\p{^Ll}/
+        /\p{^Ll}/,
+        /\P{Ll}/,
+        /\P{^Ll}/ # Double negative!!
       )
 
     end

metadata

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