regexp-examples 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47da78b8a954d0a3cc88910fffd716e34675d953
-  data.tar.gz: 69705d5fa7a10b0e4980fd6036b8aa8b29486947
+  metadata.gz: d049ada3d2ac8bd900ed9b1d03066b28f805ae72
+  data.tar.gz: b68954dec1f8db36d531244ddb3dbbbb2a6edd92
 SHA512:
-  metadata.gz: 224d21492ee5097eac3700ea168866f04f32e62e0bb8a2e2fd955a2398df27e5ff97daf9907ed0e27e3523238b020ef676243ecc9bc888dc24aad49565d4fae0
-  data.tar.gz: 91c0d6413d6f7ef35e8cb3a20dda797eb33b26ec4e6da88e23afad5c02e0f61fea3fceeb8afd2727980efbbe7667051e6c0df92e8f2e576cbc99354113d7f18b
+  metadata.gz: a2db5421c17dfc6eec5e99caa78c95320432f8d1ace3d5647d02e8d8356518d360bd6409ec69ee8290e6da51b0ee1fbc30ca63dfe22855262ea0ba43e2e31e65
+  data.tar.gz: e9bb1f444f866dff086953c0e851846f54f9cdf2139e94bfa51f7430277c8201c79c34eaaf459cc6d6f637e0e0f53ac1ecbd2144f6ae7edeaa2a1d2334bef8d7

data/.travis.yml

@@ -5,3 +5,6 @@ rvm:
   - 2.2.4
   - 2.3.0
   - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/README.md

@@ -4,7 +4,7 @@
 [![Coverage Status](https://coveralls.io/repos/tom-lord/regexp-examples/badge.svg?branch=master)](https://coveralls.io/r/tom-lord/regexp-examples?branch=master)
 [![Code Climate](https://codeclimate.com/github/tom-lord/regexp-examples/badges/gpa.svg)](https://codeclimate.com/github/tom-lord/regexp-examples)
 
-Extends the Regexp class with the methods: `Regexp#examples` and `Regexp#random_example`
+Extends the `Regexp` class with the methods: `Regexp#examples` and `Regexp#random_example`
 
 `Regexp#examples` generates a list of all\* strings that will match the given regular expression.
 
@@ -19,6 +19,8 @@ If you'd like to understand how/why this gem works, please check out my [blog po
 
 ## Usage
 
+#### Regexp#examples
+
 ```ruby
 /a*/.examples #=> ['', 'a', 'aa']
 /ab+/.examples #=> ['ab', 'abb', 'abbb']
@@ -36,11 +38,15 @@ If you'd like to understand how/why this gem works, please check out my [blog po
   |
   \u{28}\u2310\u25a0\u{5f}\u25a0\u{29}
 /x.examples #=> ["(•_•)", "( •_•)>⌐■-■ ", "(⌐■_■)"]
+```
 
-###################################################################################
+#### Regexp#random_example
 
-# Obviously, you will get different results if you try these yourself!
+Obviously, you will get different (random) results if you try these yourself!
+
+```ruby
 /\w{10}@(hotmail|gmail)\.com/.random_example #=> "TTsJsiwzKS@gmail.com"
+/5[1-5][0-9]{14}/.random_example #=> "5224028604559821" (A valid MasterCard number)
 /\p{Greek}{80}/.random_example
   #=> "ΖΆΧͷᵦμͷηϒϰΟᵝΔ΄θϔζΌψΨεκᴪΓΕπι϶ονϵΓϹᵦΟπᵡήϴϜΦϚϴϑ͵ϴΉϺ͵ϹϰϡᵠϝΤΏΨϹϊϻαώΞΰϰΑͼΈΘͽϙͽξΆΆΡΡΉΓς"
 /written by tom lord/i.random_example #=> "WrITtEN bY tOM LORD"
@@ -109,7 +115,7 @@ Long answer:
 * Octal characters, e.g. `/\10/`, `/\177/`
 * 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")
-  * ...Even between different ruby versions!! (e.g. `/\p{Arabic}/.examples(max\_group\_results: 999)` will give you a different answer in ruby v2.1.x and v2.2.x)
+  * ...Even between different ruby versions!! (e.g. `/\p{Arabic}/.examples(max_group_results: 999)` will give you a different answer in ruby v2.1.x and v2.2.x)
 * **Arbitrarily complex combinations of all the above!**
 
 * Regexp options can also be used:
@@ -118,81 +124,88 @@ Long answer:
   * Extended form examples: `/line1 #comment \n line2/x.examples #=> ["line1line2"]`
   * Options toggling supported: `/before(?imx-imx)after/`, `/before(?imx-imx:subexpr)after/`
 
-## 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...
-
-Since the Regexp language is so vast, it's quite likely I've missed something (please raise an issue if you find something)! The only missing feature that I'm currently aware of is:
-* Conditional capture groups, e.g. `/(group1)? (?(1)yes|no)/.examples` (which *should* return: `["group1 yes", " no"]`)
-
-Some of the most obscure regexp features are not even mentioned in the ruby docs. However, 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).
-
-## 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"!
-If you'd like to understand this in more detail, check out what I had to say in [my blog post](http://tom-lord.weebly.com/blog/reverse-engineering-regular-expressions) about this gem.
-
-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 (`\g`), e.g. `/(?<name> ... \g<name>\* )/`
-
-(Note: Backreferences are not really "regular" either, but I got these to work with a bit of hackery.)
-
 ##Configuration Options
 
 When generating examples, the gem uses 3 configurable values to limit how many examples are listed:
 
-* `max\_repeater\_variance` (default = `2`) restricts how many examples to return for each repeater. For example:
-  * `.\*` is equivalent to `.{0,2}`
+* `max_repeater_variance` (default = `2`) restricts how many examples to return for each repeater. For example:
+  * `.*` 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}`
 
-* `max\_group\_results` (default = `5`) restricts how many characters to return for each "set". For example:
+* `max_group_results` (default = `5`) restricts how many characters to return for each "set". For example:
   * `\d` is equivalent to `[01234]`
   * `\w` is equivalent to `[abcde]`
   * `[h-s]` is equivalent to `[hijkl]`
   * `(1|2|3|4|5|6|7|8)` is equivalent to `[12345]`
 
-* `max\_results\_limit` (default = `10000`) restricts the maximum number of results that can possibly be generated. For example:
-  * `/(crazy){1,999} B\*I\*G\* regex/.examples.length <= 10000` -- Attempting this will NOT freeze your system
+* `max_results_limit` (default = `10000`) restricts the maximum number of results that can possibly be generated. For example:
+  * `/c+r+a+z+y+ * B+I+G+ * r+e+g+e+x+/i.examples.length <= 10000` -- Attempting this will NOT freeze your system, even though
+  (by the above rules) this "should" attempt to generate **117546246144** examples.
 
-`Rexexp#examples` makes use of *all* these options; `Rexexp#random\_example` only uses `max\_repeater\_variance`, since the other options are redundant.
+`Rexexp#examples` makes use of *all* these options; `Rexexp#random_example` only uses `max_repeater_variance`, since the other options are redundant.
 
 To use an alternative value, simply pass the configuration option as follows:
 
 ```ruby
-/a*/.examples(max\_repeater\_variance: 5)
+/a*/.examples(max_repeater_variance: 5)
   #=> [''. 'a', 'aa', 'aaa', 'aaaa' 'aaaaa']
-/[F-X]/.examples(max\_group\_results: 10)
+/[F-X]/.examples(max_group_results: 10)
   #=> ['F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']
-/[ab]{10}/.examples(max\_results\_limit: 64).length == 64 # NOT 1024
-/[slow]{9}/.examples(max\_results\_limit: 9999999).length == 4 \*\* 9 == 262144 # Warning - this will take a while!
-/.\*/.random\_example(max\_repeater\_variance: 50)
+/[ab]{10}/.examples(max_results_limit: 64).length == 64 # NOT 1024
+/[slow]{9}/.examples(max_results_limit: 9999999).length == 4 ** 9 == 262144 # Warning - this will take a while!
+/.*/.random_example(max_repeater_variance: 50)
   #=> "A very unlikely result!"
 ```
 
 A sensible use case might be, for example, to generate all 1-5 digit strings:
 
 ```ruby
-/\d{1,5}/.examples(max\_repeater\_variance: 4, max\_group\_results: 10, max\_results\_limit: 100000)
+/\d{1,5}/.examples(max_repeater_variance: 4, max_group_results: 10, max_results_limit: 100000)
   #=> ['0', '1', '2', ..., '99998', '99999']
 ```
 
-Due to code optimisation, `Regexp#random\_example` runs pretty fast even on very complex patterns.
-(I.e. It's a _lot_ faster than using `/pattern/.exammples.sample(1)`.)
+Due to code optimisation, `Regexp#random_example` runs pretty fast even on very complex patterns.
+(I.e. It's typically a _lot_ faster than using `/pattern/.examples.sample(1)`.)
 For instance, the following takes no more than ~ 1 second on my machine:
 
-`/.\*\w+\d{100}/.random\_example(max\_repeater\_variance: 1000)`
+`/.*\w+\d{100}/.random_example(max_repeater_variance: 1000)`
+
+## Bugs and TODOs
+
+There are no known major bugs with this library. However, there are a few obscure issues that you *may* encounter:
+
+* Conditional capture groups, e.g. `/(group1)? (?(1)yes|no)/.examples` are not yet supported. (This example *should* return: `["group1 yes", " no"]`)
+* `\Z` should be interpreted like `\n?\z`; it's currently just interpreted like `\z`. (This basically just means you'll be missing a few examples.)
+* Ideally, `regexp#examples` should always return up to `max_results_limit`. Currenty, it usually "aborts" before this limit is reached.
+ (I.e. the exact number of examples generated can be hard to predict, for complex patterns.)
+* 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...
+* Nested repeat operators are incorrectly parsed, e.g. `/b{2}{3}/` - which *should* be interpreted like `/b{6}/`. (However, there is probably no reason
+ to ever write regexes like this!)
+
+Some of the most obscure regexp features are not even mentioned in [the ruby docs](ruby-doc.org/core/Regexp.html).
+However, 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).
+
+## 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"!
+If you'd like to understand this in more detail, check out what I had to say in [my blog post](http://tom-lord.weebly.com/blog/reverse-engineering-regular-expressions) about this gem.
 
-## TODO
+Using any of the following will raise a `RegexpExamples::IllegalSyntax` exception:
 
-* Make regexp#examples always return up to `max\_results\_limit` - currenty, it usually "aborts" before this limit is reached.
-* `\z` should be interpreted like `\n?\z`, not just `\z` like it is currently.
+* 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/`
+  * Anchors are really just special cases of lookarounds!
+  * 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 (`\g`), e.g. `/(?<name> ... \g<name>* )/`
+
+(Note: Backreferences are not really "regular" either, but I got these to work with a bit of hackery.)
 
 ## Contributing
 

data/db/unicode_ranges_2.1.pstore

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

data/lib/core_extensions/regexp/examples.rb

@@ -17,7 +17,7 @@ module CoreExtensions
         RegexpExamples::ResultCountLimiters.configure!(
           max_repeater_variance: config_options[:max_repeater_variance]
         )
-        examples_by_method(:random_result).first
+        examples_by_method(:random_result).sample(1).first
       end
 
       private

data/lib/regexp-examples/groups.rb

@@ -20,27 +20,17 @@ module RegexpExamples
     end
   end
 
-  # A helper method for mixing in to Group classes...
-  # Needed because sometimes (for performace) group results are lazy enumerators;
-  # Meanwhile other times (again, for performance!) group results are just arrays
-  module ForceLazyEnumerators
-    def force_if_lazy(arr_or_enum)
-      arr_or_enum.respond_to?(:force) ? arr_or_enum.force : arr_or_enum
-    end
-  end
-
   # A helper method for mixing in to Group classes...
   # Needed for generating a complete results set when the ignorecase
   # regexp option has been set
   module GroupWithIgnoreCase
-    include ForceLazyEnumerators
     attr_reader :ignorecase
     def result
       group_result = super
       if ignorecase
-        group_result_array = force_if_lazy(group_result)
-        group_result_array
-          .concat(group_result_array.map(&:swapcase))
+        group_result
+          .to_a # In case of lazy enumerator
+          .concat(group_result.to_a.map(&:swapcase))
           .uniq
       else
         group_result
@@ -52,9 +42,10 @@ module RegexpExamples
   # Uses Array#sample to randomly choose one result from all
   # possible examples
   module RandomResultBySample
-    include ForceLazyEnumerators
     def random_result
-      force_if_lazy(result).sample(1)
+      result
+        .to_a # In case of lazy enumerator
+        .sample(1)
     end
   end
 

data/lib/regexp-examples/version.rb

@@ -1,4 +1,4 @@
 # Gem version
 module RegexpExamples
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Tom Lord
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Extends the Regexp class with '#examples' and '#random_example'