regexp_parser 0.5.0 → 1.0.0

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

@@ -1,8 +1,16 @@
 module Regexp::Expression
-
   module Backreference
     class Base < Regexp::Expression::Base; end
 
+    class Number < Backreference::Base
+      attr_reader :number
+
+      def initialize(token, options = {})
+        @number = token.text[token.token.equal?(:number) ? 1..-1 : 3..-2].to_i
+        super
+      end
+    end
+
     class Name < Backreference::Base
       attr_reader :name
 
@@ -12,31 +20,28 @@ module Regexp::Expression
       end
     end
 
-    class Number < Backreference::Base
-      attr_reader :number
+    class NumberCall         < Backreference::Number; end
+    class NumberRelative     < Backreference::Number; end
+    class NumberCallRelative < Backreference::Number; end
+    class NameCall < Backreference::Name; end
+
+    class NumberRecursionLevel < Backreference::Base
+      attr_reader :number, :recursion_level
 
       def initialize(token, options = {})
-        @number = token.text[token.token.equal?(:number) ? 1..-1 : 3..-2]
+        @number, @recursion_level = token.text[3..-2].split(/(?=[+-])/).map(&:to_i)
         super
       end
     end
 
-    class NumberRelative      < Backreference::Number; end
-
-    class NameNestLevel       < Backreference::Base; end
-    class NumberNestLevel     < Backreference::Base; end
-
-    class NameCall < Backreference::Base
-      attr_reader :name
+    class NameRecursionLevel < Backreference::Base
+      attr_reader :name, :recursion_level
 
       def initialize(token, options = {})
-        @name = token.text[3..-2]
+        @name, recursion_level = token.text[3..-2].split(/(?=[+-])/)
+        @recursion_level = recursion_level.to_i
         super
       end
     end
-
-    class NumberCall          < Backreference::Base; end
-    class NumberCallRelative  < Backreference::Base; end
   end
-
 end

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

@@ -1,9 +1,23 @@
 module Regexp::Expression
-
   module EscapeSequence
-    class Base          < Regexp::Expression::Base; end
+    class Base < Regexp::Expression::Base
+      require 'yaml'
+
+      def char
+        # poor man's unescape without using eval
+        YAML.load(%Q(---\n"#{text}"\n))
+      end
 
-    class Literal       < EscapeSequence::Base; end
+      def codepoint
+        char.ord
+      end
+    end
+
+    class Literal < EscapeSequence::Base
+      def char
+        text[1..-1]
+      end
+    end
 
     class AsciiEscape   < EscapeSequence::Base; end
     class Backspace     < EscapeSequence::Base; end
@@ -11,17 +25,74 @@ module Regexp::Expression
     class FormFeed      < EscapeSequence::Base; end
     class Newline       < EscapeSequence::Base; end
     class Return        < EscapeSequence::Base; end
-    class Space         < EscapeSequence::Base; end
     class Tab           < EscapeSequence::Base; end
     class VerticalTab   < EscapeSequence::Base; end
 
-    class Octal         < EscapeSequence::Base; end
     class Hex           < EscapeSequence::Base; end
-    class HexWide       < EscapeSequence::Base; end
+    class Codepoint     < EscapeSequence::Base; end
 
-    class Control       < EscapeSequence::Base; end
-    class Meta          < EscapeSequence::Base; end
-    class MetaControl   < EscapeSequence::Base; end
-  end
+    class CodepointList < EscapeSequence::Base
+      def char
+        raise NoMethodError, 'CodepointList responds only to #chars'
+      end
+
+      def codepoint
+        raise NoMethodError, 'CodepointList responds only to #codepoints'
+      end
+
+      def chars
+        codepoints.map { |cp| cp.chr('utf-8') }
+      end
+
+      def codepoints
+        text.scan(/\h+/).map(&:hex)
+      end
+    end
+
+    class Octal < EscapeSequence::Base
+      def char
+        text[1..-1].to_i(8).chr('utf-8')
+      end
+    end
 
+    class AbstractMetaControlSequence < EscapeSequence::Base
+      def char
+        codepoint.chr('utf-8')
+      end
+
+      def codepoint
+        raise NotImplementedError, 'implement in subclass'
+      end
+
+      private
+
+      def control_sequence_to_s(control_sequence)
+        five_lsb = control_sequence.unpack('B*').first[-5..-1]
+        ["000#{five_lsb}"].pack('B*')
+      end
+
+      def meta_char_to_codepoint(meta_char)
+        byte_value = meta_char.ord
+        byte_value < 128 ? byte_value + 128 : byte_value
+      end
+    end
+
+    class Control < AbstractMetaControlSequence
+      def codepoint
+        control_sequence_to_s(text).ord
+      end
+    end
+
+    class Meta < AbstractMetaControlSequence
+      def codepoint
+        meta_char_to_codepoint(text[-1])
+      end
+    end
+
+    class MetaControl < AbstractMetaControlSequence
+      def codepoint
+        meta_char_to_codepoint(control_sequence_to_s(text))
+      end
+    end
+  end
 end

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

@@ -1,27 +1,27 @@
 module Regexp::Expression
-
   module Group
     class Base < Regexp::Expression::Subexpression
-      def capturing?
-        [:capture, :named].include?(token)
-      end
-
-      def comment?
-        type == :comment
-      end
-
       def to_s(format = :full)
         "#{text}#{expressions.join})#{quantifier_affix(format)}"
       end
+
+      def capturing?; false end
+
+      def comment?; false end
     end
 
-    class Atomic    < Group::Base; end
-    class Capture   < Group::Base; end
-    class Passive   < Group::Base; end
-    class Options   < Group::Base; end
-    class Absence   < Group::Base; end
+    class Atomic  < Group::Base; end
+    class Passive < Group::Base; end
+    class Options < Group::Base; end
+    class Absence < Group::Base; end
 
-    class Named     < Group::Capture
+    class Capture < Group::Base
+      attr_accessor :number, :number_at_level
+
+      def capturing?; true end
+    end
+
+    class Named < Group::Capture
       attr_reader :name
 
       def initialize(token, options = {})
@@ -29,10 +29,9 @@ module Regexp::Expression
         super
       end
 
-      def clone
-        copy = super
-        copy.instance_variable_set(:@name, name.dup)
-        copy
+      def initialize_clone(other)
+        other.instance_variable_set(:@name, name.dup)
+        super
       end
     end
 
@@ -40,6 +39,8 @@ module Regexp::Expression
       def to_s(_format = :full)
         text.dup
       end
+
+      def comment?; true end
     end
   end
 
@@ -52,5 +53,4 @@ module Regexp::Expression
     class Lookbehind          < Assertion::Base; end
     class NegativeLookbehind  < Assertion::Base; end
   end
-
 end

data/lib/regexp_parser/expression/classes/{character_class.rb → posix_class.rb}

@@ -1,7 +1,7 @@
 module Regexp::Expression
-  class CharacterClass < Regexp::Expression::Base
+  class PosixClass < Regexp::Expression::Base
     def negative?
-      type == :nonclass
+      type == :nonposixclass
     end
 
     def name

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

@@ -9,6 +9,10 @@ module Regexp::Expression
       def name
         text =~ /\A\\[pP]\{([^}]+)\}\z/; $1
       end
+
+      def shortcut
+        (Regexp::Scanner.short_prop_map.rassoc(token.to_s) || []).first
+      end
     end
 
     class Alnum         < Base; end
@@ -36,6 +40,7 @@ module Regexp::Expression
       class Base < UnicodeProperty::Base; end
 
       class Any         < Letter::Base; end
+      class Cased       < Letter::Base; end
       class Uppercase   < Letter::Base; end
       class Lowercase   < Letter::Base; end
       class Titlecase   < Letter::Base; end
@@ -47,6 +52,7 @@ module Regexp::Expression
       class Base < UnicodeProperty::Base; end
 
       class Any         < Mark::Base; end
+      class Combining   < Mark::Base; end
       class Nonspacing  < Mark::Base; end
       class Spacing     < Mark::Base; end
       class Enclosing   < Mark::Base; end

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

@@ -1,110 +1,27 @@
 module Regexp::Expression
+  class CharacterSet < Regexp::Expression::Subexpression
+    attr_accessor :closed, :negative
 
-  class CharacterSet < Regexp::Expression::Base
-    attr_accessor :members
+    alias :negative? :negative
+    alias :negated?  :negative
+    alias :closed?   :closed
 
     def initialize(token, options = {})
-      @members  = []
-      @negative = false
-      @closed   = false
+      self.negative = false
+      self.closed   = false
       super
     end
 
-    # Override base method to clone set members as well.
-    def clone
-      copy = super
-      copy.members = @members.map {|m| m.clone }
-      copy
-    end
-
-    def <<(member)
-      if @members.last.is_a?(CharacterSubSet) and not @members.last.closed?
-        @members.last << member
-      else
-        @members << member
-      end
-    end
-
-    def include?(member, directly = false)
-      @members.each do |m|
-        if m.is_a?(CharacterSubSet) and not directly
-          return true if m.include?(member)
-        else
-          return true if member == m.to_s
-        end
-      end; false
-    end
-
-    def each(&block)
-      @members.each {|m| yield m}
-    end
-
-    def each_with_index(&block)
-      @members.each_with_index {|m, i| yield m, i}
-    end
-
-    def length
-      @members.length
-    end
-
     def negate
-      if @members.last.is_a?(CharacterSubSet)
-        @members.last.negate
-      else
-        @negative = true
-      end
-    end
-
-    def negative?
-      @negative
+      self.negative = true
     end
-    alias :negated? :negative?
 
     def close
-      if @members.last.is_a?(CharacterSubSet) and not @members.last.closed?
-        @members.last.close
-      else
-        @closed = true
-      end
-    end
-
-    def closed?
-      @closed
-    end
-
-    # Returns an array of the members with any shorthand members like \d and \W
-    # expanded to either traditional form or unicode properties.
-    def expand_members(use_properties = false)
-      @members.map do |member|
-        case member
-        when "\\d"
-          use_properties ? '\p{Digit}'  : '0-9'
-        when "\\D"
-          use_properties ? '\P{Digit}'  : '^0-9'
-        when "\\w"
-          use_properties ? '\p{Word}'   : 'A-Za-z0-9_'
-        when "\\W"
-          use_properties ? '\P{Word}'   : '^A-Za-z0-9_'
-        when "\\s"
-          use_properties ? '\p{Space}'  : ' \t\f\v\n\r'
-        when "\\S"
-          use_properties ? '\P{Space}'  : '^ \t\f\v\n\r'
-        when "\\h"
-          use_properties ? '\p{Xdigit}' : '0-9A-Fa-f'
-        when "\\H"
-          use_properties ? '\P{Xdigit}' : '^0-9A-Fa-f'
-        else
-          member
-        end
-      end
+      self.closed = true
     end
 
     def to_s(format = :full)
-      "#{text}#{'^' if negative?}#{members.join}]#{quantifier_affix(format)}"
+      "#{text}#{'^' if negated?}#{expressions.join}]#{quantifier_affix(format)}"
     end
   end
-
-  class CharacterSubSet < CharacterSet
-  end
-
 end # module Regexp::Expression

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

@@ -0,0 +1,9 @@
+module Regexp::Expression
+  class CharacterSet < Regexp::Expression::Subexpression
+    class IntersectedSequence < Regexp::Expression::Sequence; end
+
+    class Intersection < Regexp::Expression::SequenceOperation
+      OPERAND = IntersectedSequence
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Regexp::Expression
+  class CharacterSet < Regexp::Expression::Subexpression
+    class Range < Regexp::Expression::Subexpression
+      def starts_at
+        expressions.first.starts_at
+      end
+      alias :ts :starts_at
+
+      def <<(exp)
+        complete? && raise("Can't add more than 2 expressions to a Range")
+        super
+      end
+
+      def complete?
+        count == 2
+      end
+
+      def to_s(_format = :full)
+        expressions.join(text)
+      end
+    end
+  end
+end

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

@@ -40,14 +40,16 @@ module Regexp::Expression
 
       part = {}
 
+      print_level = nesting_level > 0 ? nesting_level - 1 : nil
+
       # Order is important! Fields that use other fields in their
       # definition must appear before the fields they use.
       part_keys = %w{a m b o i l x s e S y k c q Q z Z t ~t T >}
       part.keys.each {|k| part[k] = "<?#{k}?>"}
 
-      part['>'] = level ? ('  ' * (level + indent_offset)) : ''
+      part['>'] = print_level ? ('  ' * (print_level + indent_offset)) : ''
 
-      part['l'] = level ? "#{'%d' % level}" : 'root'
+      part['l'] = print_level ? "#{'%d' % print_level}" : 'root'
       part['x'] = "#{'%d' % index}" if have_index
 
       part['s'] = starts_at
@@ -101,9 +103,9 @@ module Regexp::Expression
     def strfregexp_tree(format = '%a', include_self = true, separator = "\n")
       output = include_self ? [self.strfregexp(format)] : []
 
-      output += map {|exp, index|
+      output += flat_map do |exp, index|
         exp.strfregexp(format, (include_self ? 1 : 0), index)
-      }
+      end
 
       output.join(separator)
     end