regexp_parser 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 467bef34ff29198ccbde0063f1b2f62f03cf8237c46fe59be8f06e974c00c367
-  data.tar.gz: b876e662f889449954f0beeddedded8e462b4daec5fbb4692b65f9f7a012fec8
+  metadata.gz: 20ba21704667276107a1041b3bb5943bbbec0078f706cf0d7db85110631dfe8d
+  data.tar.gz: 87886f6cad480ebc62f3e1f243d9b61170097e5419fc8b3972cd3348e5d8d7e0
 SHA512:
-  metadata.gz: b2064de034cf83f157da79225fc587374f744884f37934fd1828e4f3127bc45f899d62986495d9344fd4a5f2e96f7b2cf90c7961c0895fd0ee52ab8e24428d67
-  data.tar.gz: 146440a8fc9e2c48bb1bdedad539f6883ecbc5874276eb3e56876df7b74e42630ec789f6cc6b4ca7e79d5e6b2e986b5a2f5b2fc0be4d273c02d8ff62fa2cd35c
+  metadata.gz: '0678640973741b2ea63053c058809fa075b3b465756bddee9a1914f67f7181a3681d3592662d4eadf5a60e844c550950b371577239924c4d3ce7f07f9fdfefa6'
+  data.tar.gz: 3bf18d0d7989c1f9eef010d1579ac78537c6c083c9b7c7c2f0cda094c0f973e1fdcc17c5992ae35d823720d2cdb10a60424876e08bd4b2b60b125c8b107a62bf

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.2.0] - 2018-09-28 - [Janosch Müller](mailto:janosch84@gmail.com)
+
+### Added
+
+- `Subexpression` (branch node) includes `Enumerable`, allowing to `#select` children etc.
+
+### Fixed
+
+- Fixed missing quantifier in `Conditional::Expression` methods `#to_s`, `#to_re`
+- `Conditional::Condition` no longer lives outside the recursive `#expressions` tree
+  - it used to be the only expression stored in a custom ivar, complicating traversal
+  - its setter and getter (`#condition=`, `#condition`) still work as before
+
 ## [1.1.0] - 2018-09-17 - [Janosch Müller](mailto:janosch84@gmail.com)
 
 ### Added

data/README.md

@@ -2,14 +2,14 @@
 
 [![Gem Version](https://badge.fury.io/rb/regexp_parser.svg)](http://badge.fury.io/rb/regexp_parser) [![Build Status](https://secure.travis-ci.org/ammar/regexp_parser.svg?branch=master)](http://travis-ci.org/ammar/regexp_parser) [![Code Climate](https://codeclimate.com/github/ammar/regexp_parser.svg)](https://codeclimate.com/github/ammar/regexp_parser/badges)
 
-A ruby gem for tokenizing, parsing, and transforming regular expressions.
+A Ruby gem for tokenizing, parsing, and transforming regular expressions.
 
 * Multilayered
-  * A scanner/tokenizer based on [ragel](http://www.colm.net/open-source/ragel/)
+  * A scanner/tokenizer based on [Ragel](http://www.colm.net/open-source/ragel/)
   * A lexer that produces a "stream" of token objects.
   * A parser that produces a "tree" of Expression objects (OO API)
-* Runs on ruby 1.9, 2.x, and jruby (1.9 mode) runtimes.
-* Recognizes ruby 1.8, 1.9, and 2.x regular expressions [See Supported Syntax](#supported-syntax)
+* Runs on Ruby 1.9, 2.x, and JRuby (1.9 mode) runtimes.
+* Recognizes Ruby 1.8, 1.9, and 2.x regular expressions [See Supported Syntax](#supported-syntax)
 
 
 _For examples of regexp_parser in use, see [Example Projects](#example-projects)._
@@ -46,7 +46,7 @@ The three main modules are **Scanner**, **Lexer**, and **Parser**. Each of them
 provides a single method that takes a regular expression (as a RegExp object or
 a string) and returns its results. The **Lexer** and the **Parser** accept an
 optional second argument that specifies the syntax version, like 'ruby/2.0',
-which defaults to the host ruby version (using RUBY_VERSION).
+which defaults to the host Ruby version (using RUBY_VERSION).
 
 Here are the basic usage examples:
 
@@ -77,7 +77,7 @@ called with the results as follows:
 ## Components
 
 ### Scanner
-A ragel generated scanner that recognizes the cumulative syntax of all
+A Ragel-generated scanner that recognizes the cumulative syntax of all
 supported syntax versions. It breaks a given expression's text into the
 smallest parts, and identifies their type, token, text, and start/end
 offsets within the pattern.
@@ -123,7 +123,7 @@ Regexp::Scanner.scan( /(cat?([bhm]at)){3,5}/ ).map {|token| token[2]}
     balancing punctuation and premature end of pattern. Flavor validity checks
     are performed in the lexer, which uses a syntax object.
 
-  * If the input is a ruby **Regexp** object, the scanner calls #source on it to
+  * If the input is a Ruby **Regexp** object, the scanner calls #source on it to
     get its string representation. #source does not include the options of
     the expression (m, i, and x). To include the options in the scan, #to_s
     should be called on the **Regexp** before passing it to the scanner or the
@@ -188,7 +188,7 @@ ruby_18.implements? :conditional, :condition               # => false
 Sits on top of the scanner and performs lexical analysis on the tokens that
 it emits. Among its tasks are; breaking quantified literal runs, collecting the
 emitted token attributes into Token objects, calculating their nesting depth,
-normalizing tokens for the parser, and checkng if the tokens are implemented by
+normalizing tokens for the parser, and checking if the tokens are implemented by
 the given syntax version.
 
 See the [Token Objects](https://github.com/ammar/regexp_parser/wiki/Token-Objects)
@@ -196,7 +196,7 @@ wiki page for more information on Token objects.
 
 
 #### Example
-The following example lexes the given pattern, checks it against the ruby 1.9
+The following example lexes the given pattern, checks it against the Ruby 1.9
 syntax, and prints the token objects' text indented to their level.
 
 ```ruby
@@ -224,7 +224,7 @@ end
 
 A one-liner that returns an array of the textual parts of the given pattern.
 Compare the output with that of the one-liner example of the **Scanner**; notably
-how the sequence 'cat' is treated. The 't' is seperated because it's followed
+how the sequence 'cat' is treated. The 't' is separated because it's followed
 by a quantifier that only applies to it.
 
 ```ruby
@@ -233,7 +233,7 @@ Regexp::Lexer.scan( /(cat?([b]at)){3,5}/ ).map {|token| token.text}
 ```
 
 #### Notes
-  * The syntax argument is optional. It defaults to the version of the ruby
+  * The syntax argument is optional. It defaults to the version of the Ruby
     interpreter in use, as returned by RUBY_VERSION.
 
   * The lexer normalizes some tokens, as noted in the Syntax section above.
@@ -308,8 +308,8 @@ Expression class. See the next section for details._
 
 
 ## Supported Syntax
-The three modules support all the regular expression syntax features of Ruby 1.8
-, 1.9, and 2.x:
+The three modules support all the regular expression syntax features of Ruby 1.8,
+1.9, and 2.x:
 
 _Note that not all of these are available in all versions of Ruby_
 
@@ -318,7 +318,7 @@ _Note that not all of these are available in all versions of Ruby_
 | ------------------------------------- | ------------------------------------------------------- |:--------:|
 | **Alternation**                       | `a\|b\|c`                                               | ✓ |
 | **Anchors**                           | `\A`, `^`, `\b`                                         | ✓ |
-| **Character Classes**                 | `[abc]`, `[^\\]`, `[a-d&&g-h]`, `[a=e=b]`               | ✓ |
+| **Character Classes**                 | `[abc]`, `[^\\]`, `[a-d&&aeiou]`, `[a=e=b]`             | ✓ |
 | **Character Types**                   | `\d`, `\H`, `\s`                                        | ✓ |
 | **Cluster Types**                     | `\R`, `\X`                                              | ✓ |
 | **Conditional Exps.**                 | `(?(cond)yes-subexp)`, `(?(cond)yes-subexp\|no-subexp)` | ✓ |
@@ -362,9 +362,9 @@ _Note that not all of these are available in all versions of Ruby_
 |   _**Blocks**_              | `\p{InArmenian}`, `\P{InKhmer}`, `\p{^InThai}`          | ✓ |
 |   _**Classes**_             | `\p{Alpha}`, `\P{Space}`, `\p{^Alnum}`                  | ✓ |
 |   _**Derived**_             | `\p{Math}`, `\P{Lowercase}`, `\p{^Cased}`               | ✓ |
-|   _**General Categories**_  | `\p{Lu}`, `\P{Cs}`, \p{^sc}                             | ✓ |
-|   _**Scripts**_             | `\p{Arabic}`, `\P{Hiragana}`, \p{^Greek}                | ✓ |
-|   _**Simple**_              | `\p{Dash}`, `\p{Extender}`, \p{^Hyphen}                 | ✓ |
+|   _**General Categories**_  | `\p{Lu}`, `\P{Cs}`, `\p{^sc}`                           | ✓ |
+|   _**Scripts**_             | `\p{Arabic}`, `\P{Hiragana}`, `\p{^Greek}`              | ✓ |
+|   _**Simple**_              | `\p{Dash}`, `\p{Extender}`, `\p{^Hyphen}`               | ✓ |
 
 ##### Inapplicable Features
 
@@ -389,9 +389,9 @@ or incorrectly return tokens/objects as literals._
 ## Testing
 To run the tests simply run rake from the root directory, as 'test' is the default task.
 
-It generates the scanner's code from the ragel source files and runs all the tests, thus it requires ragel to be installed.
+It generates the scanner's code from the Ragel source files and runs all the tests, thus it requires Ragel to be installed.
 
-The tests use ruby's test/unit. They can also be run with:
+The tests use Ruby's test/unit. They can also be run with:
 
 ```
 bin/test
@@ -409,16 +409,16 @@ It is sometimes helpful during development to focus on a specific test case, for
 bin/test test/expression/test_base.rb -n test_expression_to_re
 ```
 
-Note that changes to ragel files will not be reflected when using `bin/test`, so you might want to run:
+Note that changes to Ragel files will not be reflected when using `bin/test`, so you might want to run:
 
 ```
 rake ragel:rb && bin/test test/scanner/test_properties.rb
 ```
 
 ## Building
-Building the scanner and the gem requires [ragel](http://www.colm.net/open-source/ragel/) to be
+Building the scanner and the gem requires [Ragel](http://www.colm.net/open-source/ragel/) to be
 installed. The build tasks will automatically invoke the 'ragel:rb' task to generate the
-ruby scanner code.
+Ruby scanner code.
 
 
 The project uses the standard rubygems package tasks, so:

data/lib/regexp_parser/expression.rb

@@ -127,7 +127,7 @@ module Regexp::Expression
     end
     alias :=~ :match
 
-    def to_h
+    def attributes
       {
         type:              type,
         token:             token,
@@ -141,6 +141,7 @@ module Regexp::Expression
         quantifier:        quantified? ? quantifier.to_h : nil,
       }
     end
+    alias :to_h :attributes
   end
 
   def self.parsed(exp)

data/lib/regexp_parser/expression/classes/conditional.rb

@@ -18,13 +18,6 @@ module Regexp::Expression
     class Branch < Regexp::Expression::Sequence; end
 
     class Expression < Regexp::Expression::Subexpression
-      attr_reader :condition
-
-      def condition=(exp)
-        @condition = exp
-        expressions << exp
-      end
-
       def <<(exp)
         expressions.last << exp
       end
@@ -35,16 +28,25 @@ module Regexp::Expression
       end
       alias :branch :add_sequence
 
+      def condition=(exp)
+        expressions.delete(condition)
+        expressions.unshift(exp)
+      end
+
+      def condition
+        find { |subexp| subexp.is_a?(Condition) }
+      end
+
       def branches
-        expressions - [condition]
+        select { |subexp| subexp.is_a?(Sequence) }
       end
 
       def reference
         condition.reference
       end
 
-      def to_s(_format = :full)
-        text + condition.text + branches.join('|') + ')'
+      def to_s(format = :full)
+        "#{text}#{condition}#{branches.join('|')})#{quantifier_affix(format)}"
       end
     end
   end

data/lib/regexp_parser/expression/subexpression.rb

@@ -1,6 +1,8 @@
 module Regexp::Expression
 
   class Subexpression < Regexp::Expression::Base
+    include Enumerable
+
     attr_accessor :expressions
 
     def initialize(token, options = {})
@@ -24,8 +26,7 @@ module Regexp::Expression
       end
     end
 
-    %w[[] all? any? at collect count each each_with_index empty?
-       fetch find first index join last length map values_at].each do |method|
+    %w[[] at each empty? fetch index join last length values_at].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{method}(*args, &block)
           expressions.#{method}(*args, &block)
@@ -51,7 +52,7 @@ module Regexp::Expression
     end
 
     def to_h
-      super.merge({
+      attributes.merge({
         text:        to_s(:base),
         expressions: expressions.map(&:to_h)
       })

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.1.0'
+    VERSION = '1.2.0'
   end
 end

data/test/parser/test_conditionals.rb

@@ -157,7 +157,8 @@ class TestParserConditionals < Test::Unit::TestCase
     conditional = root[1]
 
     assert conditional.quantified?
-    assert_equal '{42}', conditional.quantifier.text
+    assert_equal '{42}',              conditional.quantifier.text
+    assert_equal '(?(1)\d|(\w)){42}', conditional.to_s
     refute conditional.branches.any?(&:quantified?)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ammar Ali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-17 00:00:00.000000000 Z
+date: 2018-09-28 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email: