regexp_parser 0.4.13 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b99c449ebf12572a7d538da6339b77d12a10523af0cc9f48f224254e363343ad
-  data.tar.gz: ce40298434963eb5cd1246938eda7f88a2d4482a4494e98e1df1a517d10ce8bf
+  metadata.gz: f854518e5bf9e75b67ee68dd5ee895a24c176e9639d18734b883ed966989c68a
+  data.tar.gz: 5bf74000e06ec2a9b0e0c6f917d23125d191e5e79eb0dd5451c24c71e6f2e8ce
 SHA512:
-  metadata.gz: b2dd61664c530476a4bfa36f80736b5f77569afb209210be844972ba7fe3af9f7556c864501fb76dcf0c8b5f26b99a18a5abcf3d96ac7a35c4de134f268c525d
-  data.tar.gz: 10f2704069cb9a16b3c366fea576e14371f9588e5d4b134c4f47f06641a4dcb0c6779a0b260589408f114361b5d30cbed7963db2c72912f3097f60cfaaf16e1e
+  metadata.gz: 90bf54b0b86929d49ba3033389e5d0928afd829bf841c28e270124d6c2df05c93884e49a7bec48e2a3d191c996ba9522361fc804edc61ef38e8a5ed892de96b9
+  data.tar.gz: aa0fc2fcdebac4117e8611bcc107004d167ab45026fc696586b1940680de863f1712e0e38d38bf97784de07af7b65befb5e9fdd984f664521eff395fec51d99c

data/ChangeLog

@@ -1,3 +1,18 @@
+Sun Apr 29 2018 Janosch Müller <janosch84@gmail.com>
+
+	* Changed handling of Ruby versions (PR #53)
+	  - New Ruby versions are now supported by default
+	  - Some deep-lying APIs have changed, which should not affect most users:
+	    - `Regexp::Syntax::VERSIONS` is gone
+	    - Syntax version names have changed from `Regexp::Syntax::Ruby::Vnnn`
+	      to `Regexp::Syntax::Vn_n_n`
+	    - Syntax version classes for Ruby versions without regex feature changes
+	      are no longer predefined and are now only created on demand / lazily
+	    - `Regexp::Syntax::supported?` returns true for any argument >= 1.8.6
+	* Fixed some use cases of Expression methods #strfregexp and #to_h (@e738107)
+	* Added full signature support to collection methods of Expressions (@aa7c55a)
+	* Bumped version to 0.5.0
+
 Tue Apr 4 2018 ammarabuali@gmail.com <ammarabuali@gmail.com>
 
 	* Added ruby version files for 2.2.10 and 2.3.7

data/lib/regexp_parser/expression.rb

@@ -9,23 +9,23 @@ module Regexp::Expression
     attr_accessor :options
 
     def initialize(token, options = {})
-      @type               = token.type
-      @token              = token.token
-      @text               = token.text
-      @ts                 = token.ts
-      @level              = token.level
-      @set_level          = token.set_level
-      @conditional_level  = token.conditional_level
-      @quantifier         = nil
-      @options            = options
+      self.type              = token.type
+      self.token             = token.token
+      self.text              = token.text
+      self.ts                = token.ts
+      self.level             = token.level
+      self.set_level         = token.set_level
+      self.conditional_level = token.conditional_level
+      self.quantifier        = nil
+      self.options           = options
     end
 
     def clone
-      copy = self.dup
+      copy = dup
 
-      copy.text       = (self.text        ? self.text.dup         : nil)
-      copy.options    = (self.options     ? self.options.dup      : nil)
-      copy.quantifier = (self.quantifier  ? self.quantifier.clone : nil)
+      copy.text       = (text        ? text.dup         : nil)
+      copy.options    = (options     ? options.dup      : nil)
+      copy.quantifier = (quantifier  ? quantifier.clone : nil)
 
       copy
     end
@@ -34,9 +34,7 @@ module Regexp::Expression
       ::Regexp.new(to_s(format))
     end
 
-    def starts_at
-      @ts
-    end
+    alias :starts_at :ts
 
     def full_length
       to_s.length
@@ -51,17 +49,11 @@ module Regexp::Expression
     end
 
     def to_s(format = :full)
-      s = ''
-
-      case format
-      when :base
-        s << @text.dup
-      else
-        s << @text.dup
-        s << @quantifier if quantified?
-      end
+      "#{text}#{quantifier_affix(format)}"
+    end
 
-      s
+    def quantifier_affix(expression_format)
+      quantifier.to_s if quantified? && expression_format != :base
     end
 
     def terminal?
@@ -69,61 +61,61 @@ module Regexp::Expression
     end
 
     def quantify(token, text, min = nil, max = nil, mode = :greedy)
-      @quantifier = Quantifier.new(token, text, min, max, mode)
+      self.quantifier = Quantifier.new(token, text, min, max, mode)
     end
 
     def quantified?
-      not @quantifier.nil?
+      !quantifier.nil?
     end
 
     def quantity
       return [nil,nil] unless quantified?
-      [@quantifier.min, @quantifier.max]
+      [quantifier.min, quantifier.max]
     end
 
     def greedy?
-      quantified? and @quantifier.mode == :greedy
+      quantified? and quantifier.mode == :greedy
     end
 
     def reluctant?
-      quantified? and @quantifier.mode == :reluctant
+      quantified? and quantifier.mode == :reluctant
     end
     alias :lazy? :reluctant?
 
     def possessive?
-      quantified? and @quantifier.mode == :possessive
+      quantified? and quantifier.mode == :possessive
     end
 
     def multiline?
-      @options[:m] == true
+      options[:m] == true
     end
     alias :m? :multiline?
 
     def case_insensitive?
-      @options[:i] == true
+      options[:i] == true
     end
     alias :i? :case_insensitive?
     alias :ignore_case? :case_insensitive?
 
     def free_spacing?
-      @options[:x] == true
+      options[:x] == true
     end
     alias :x? :free_spacing?
     alias :extended? :free_spacing?
 
     if RUBY_VERSION >= '2.0'
       def default_classes?
-        @options[:d] == true
+        options[:d] == true
       end
       alias :d? :default_classes?
 
       def ascii_classes?
-        @options[:a] == true
+        options[:a] == true
       end
       alias :a? :ascii_classes?
 
       def unicode_classes?
-        @options[:u] == true
+        options[:u] == true
       end
       alias :u? :unicode_classes?
     end
@@ -139,16 +131,16 @@ module Regexp::Expression
 
     def to_h
       {
-        :type               => @type,
-        :token              => @token,
-        :text               => to_s(:base),
-        :starts_at          => @ts,
-        :length             => full_length,
-        :level              => @level,
-        :set_level          => @set_level,
-        :conditional_level  => @conditional_level,
-        :options            => @options,
-        :quantifier         => quantified? ? @quantifier.to_h : nil
+        type:              type,
+        token:             token,
+        text:              to_s(:base),
+        starts_at:         ts,
+        length:            full_length,
+        level:             level,
+        set_level:         set_level,
+        conditional_level: conditional_level,
+        options:           options,
+        quantifier:        quantified? ? quantifier.to_h : nil,
       }
     end
   end
@@ -162,9 +154,9 @@ module Regexp::Expression
     when Regexp::Expression
       exp
     else
-      raise "Expression.parsed accepts a String, Regexp, or " +
-            "a Regexp::Expression as a value for exp, but it " +
-            "was given #{exp.class.name}."
+      raise ArgumentError, 'Expression.parsed accepts a String, Regexp, or '\
+                           'a Regexp::Expression as a value for exp, but it '\
+                           "was given #{exp.class.name}."
     end
   end
 

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

@@ -3,20 +3,19 @@ module Regexp::Expression
   # This is not a subexpression really, but considering it one simplifies
   # the API when it comes to handling the alternatives.
   class Alternation < Regexp::Expression::Subexpression
+    alias :alternatives :expressions
+
     def starts_at
-      @expressions.first.starts_at
+      expressions.first.starts_at
     end
+    alias :ts :starts_at
 
     def <<(exp)
-      @expressions.last << exp
+      expressions.last << exp
     end
 
     def alternative(exp = nil)
-      @expressions << (exp ? exp : Alternative.new(level, set_level, conditional_level))
-    end
-
-    def alternatives
-      @expressions
+      expressions << (exp ? exp : Alternative.new(level, set_level, conditional_level))
     end
 
     def quantify(token, text, min = nil, max = nil, mode = :greedy)

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

@@ -0,0 +1,11 @@
+module Regexp::Expression
+  class CharacterClass < Regexp::Expression::Base
+    def negative?
+      type == :nonclass
+    end
+
+    def name
+      token.to_s
+    end
+  end
+end

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

@@ -11,45 +11,37 @@ module Regexp::Expression
     class Branch    < Regexp::Expression::Sequence; end
 
     class Expression < Regexp::Expression::Subexpression
+      attr_reader :branches, :condition
+
       def initialize(token, options = {})
         super
-
-        @condition = nil
         @branches  = []
       end
 
-      def condition(exp = nil)
-        return @condition unless exp
+      def condition=(exp)
         @condition = exp
-        @expressions << exp
+        expressions << exp
       end
 
       def <<(exp)
-        @expressions.last << exp
+        expressions.last << exp
       end
 
       def branch(exp = nil)
-        raise TooManyBranches.new if @branches.length == 2
+        raise TooManyBranches.new if branches.length == 2
 
         sequence = Branch.new(level, set_level, conditional_level + 1)
 
-        @expressions << sequence
-        @branches << @expressions.last
-      end
-
-      def branches
-        @branches
+        expressions << sequence
+        branches << expressions.last
       end
 
       def quantify(token, text, min = nil, max = nil, mode = :greedy)
         branches.last.last.quantify(token, text, min, max, mode)
       end
 
-      def to_s
-        s = @text.dup
-        s << @condition.text
-        s << branches.map{|e| e.to_s}.join('|')
-        s << ')'
+      def to_s(_format = :full)
+        text + condition.text + branches.join('|') + ')'
       end
     end
   end

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

@@ -10,7 +10,7 @@ module Regexp::Expression
 
   class WhiteSpace < Regexp::Expression::FreeSpace
     def merge(exp)
-      @text << exp.text
+      text << exp.text
     end
   end
 

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

@@ -3,27 +3,15 @@ module Regexp::Expression
   module Group
     class Base < Regexp::Expression::Subexpression
       def capturing?
-        [:capture, :named].include? @token
+        [:capture, :named].include?(token)
       end
 
-      def comment?; @type == :comment end
+      def comment?
+        type == :comment
+      end
 
       def to_s(format = :full)
-        s = ''
-
-        case format
-        when :base
-          s << @text.dup
-          s << @expressions.join
-          s << ')'
-        else
-          s << @text.dup
-          s << @expressions.join
-          s << ')'
-          s << @quantifier.to_s if quantified?
-        end
-
-        s
+        "#{text}#{expressions.join})#{quantifier_affix(format)}"
       end
     end
 
@@ -43,14 +31,14 @@ module Regexp::Expression
 
       def clone
         copy = super
-        copy.instance_variable_set(:@name, @name.dup)
+        copy.instance_variable_set(:@name, name.dup)
         copy
       end
     end
 
-    class Comment   < Group::Base
-      def to_s(format = :full)
-        @text.dup
+    class Comment < Group::Base
+      def to_s(_format = :full)
+        text.dup
       end
     end
   end

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

@@ -3,11 +3,11 @@ module Regexp::Expression
   module UnicodeProperty
     class Base < Regexp::Expression::Base
       def negative?
-        @type == :nonproperty
+        type == :nonproperty
       end
 
       def name
-        @text =~ /\A\\[pP]\{([^}]+)\}\z/; $1
+        text =~ /\A\\[pP]\{([^}]+)\}\z/; $1
       end
     end
 

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

@@ -100,18 +100,7 @@ module Regexp::Expression
     end
 
     def to_s(format = :full)
-      s = ''
-
-      s << @text.dup
-      s << '^' if negative?
-      s << @members.join
-      s << ']'
-
-      unless format == :base
-        s << @quantifier.to_s if quantified?
-      end
-
-      s
+      "#{text}#{'^' if negative?}#{members.join}]#{quantifier_affix(format)}"
     end
   end
 

data/lib/regexp_parser/expression/methods/traverse.rb

@@ -7,7 +7,7 @@ module Regexp::Expression
     #
     # The event argument is passed as follows:
     #
-    # - For subexpressions, :enter upon entrering the subexpression, and
+    # - For subexpressions, :enter upon entering the subexpression, and
     #   :exit upon exiting it.
     #
     # - For terminal expressions, :visit is called once.

data/lib/regexp_parser/expression/quantifier.rb

@@ -1,7 +1,7 @@
 module Regexp::Expression
 
   class Quantifier
-    attr_reader   :token, :text, :min, :max, :mode
+    attr_reader :token, :text, :min, :max, :mode
 
     def initialize(token, text, min, max, mode)
       @token = token
@@ -12,23 +12,23 @@ module Regexp::Expression
     end
 
     def clone
-      copy = self.dup
-      copy.instance_variable_set(:@text, @text.dup)
+      copy = dup
+      copy.instance_variable_set(:@text, text.dup)
       copy
     end
 
     def to_s
-      @text.dup
+      text.dup
     end
     alias :to_str :to_s
 
     def to_h
       {
-        :token => token,
-        :text  => text,
-        :mode  => mode,
-        :min   =>  min,
-        :max   =>  max
+        token: token,
+        text:  text,
+        mode:  mode,
+        min:   min,
+        max:   max,
       }
     end
   end