regexp_parser 0.1.1 → 0.1.5

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

@@ -0,0 +1,47 @@
+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
+    def starts_at
+      @expressions.first.starts_at
+    end
+
+    def <<(exp)
+      @expressions.last << exp
+    end
+
+    def alternative(exp = nil)
+      @expressions << (exp ? exp : Sequence.new)
+    end
+
+    def alternatives
+      @expressions
+    end
+
+    def quantify(token, text, min = nil, max = nil, mode = :greedy)
+      alternatives.last.last.quantify(token, text, min, max, mode)
+    end
+
+    def to_s(format = :full)
+      alternatives.map{|e| e.to_s(format)}.join('|')
+    end
+  end
+
+  # A sequence of expressions, used by alternations as one alternative.
+  # TODO: perhaps rename this to Alternative?
+  class Sequence < Regexp::Expression::Subexpression
+    def initialize
+      super Regexp::Token.new(:expression, :sequence, '')
+    end
+
+    def starts_at
+      @expressions.first.starts_at
+    end
+
+    def quantify(token, text, min = nil, max = nil, mode = :greedy)
+      last.quantify(token, text, min, max, mode)
+    end
+  end
+
+end

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

@@ -0,0 +1,26 @@
+module Regexp::Expression
+
+  module Anchor
+    class Base < Regexp::Expression::Base; end
+
+    class BeginningOfLine               < Anchor::Base; end
+    class EndOfLine                     < Anchor::Base; end
+
+    class BeginningOfString             < Anchor::Base; end
+    class EndOfString                   < Anchor::Base; end
+
+    class EndOfStringOrBeforeEndOfLine  < Anchor::Base; end
+
+    class WordBoundary                  < Anchor::Base; end
+    class NonWordBoundary               < Anchor::Base; end
+
+    class MatchStart                    < Anchor::Base; end
+
+    BOL      = BeginningOfLine
+    EOL      = EndOfLine
+    BOS      = BeginningOfString
+    EOS      = EndOfString
+    EOSobEOL = EndOfStringOrBeforeEndOfLine
+  end
+
+end

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

@@ -0,0 +1,42 @@
+module Regexp::Expression
+
+  module Backreference
+    class Base < Regexp::Expression::Base; end
+
+    class Name < Backreference::Base
+      attr_reader :name
+
+      def initialize(token)
+        @name = token.text[3..-2]
+        super(token)
+      end
+    end
+
+    class Number < Backreference::Base
+      attr_reader :number
+
+      def initialize(token)
+        @number = token.text[3..-2]
+        super(token)
+      end
+    end
+
+    class NumberRelative      < Backreference::Number; end
+
+    class NameNestLevel       < Backreference::Base; end
+    class NumberNestLevel     < Backreference::Base; end
+
+    class NameCall < Backreference::Base
+      attr_reader :name
+
+      def initialize(token)
+        @name = token.text[3..-2]
+        super(token)
+      end
+    end
+
+    class NumberCall          < Backreference::Base; end
+    class NumberCallRelative  < Backreference::Base; end
+  end
+
+end

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

@@ -0,0 +1,27 @@
+module Regexp::Expression
+
+  module EscapeSequence
+    class Base          < Regexp::Expression::Base; end
+
+    class Literal       < EscapeSequence::Base; end
+
+    class AsciiEscape   < EscapeSequence::Base; end
+    class Backspace     < EscapeSequence::Base; end
+    class Bell          < EscapeSequence::Base; end
+    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 Control       < EscapeSequence::Base; end
+    class Meta          < EscapeSequence::Base; end
+    class MetaControl   < EscapeSequence::Base; end
+  end
+
+end

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

@@ -0,0 +1,67 @@
+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)
+        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
+      end
+    end
+
+    class Atomic    < Group::Base; end
+    class Capture   < Group::Base; end
+    class Passive   < Group::Base; end
+    class Options   < Group::Base; end
+
+    class Named     < Group::Capture
+      attr_reader :name
+
+      def initialize(token)
+        @name = token.text[3..-2]
+        super(token)
+      end
+
+      def clone
+        copy = super
+        copy.instance_variable_set(:@name, @name.dup)
+        copy
+      end
+    end
+
+    class Comment   < Group::Base
+      def to_s(format = :full)
+        @text.dup
+      end
+    end
+  end
+
+  module Assertion
+    class Base < Regexp::Expression::Group::Base; end
+
+    class Lookahead           < Assertion::Base; end
+    class NegativeLookahead   < Assertion::Base; end
+
+    class Lookbehind          < Assertion::Base; end
+    class NegativeLookbehind  < Assertion::Base; end
+  end
+
+end

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

@@ -0,0 +1,7 @@
+module Regexp::Expression
+
+  class Literal < Regexp::Expression::Base
+    # Obviously nothing special here, yet.
+  end
+
+end

data/lib/regexp_parser/expression/{property.rb → classes/property.rb}

@@ -1,6 +1,6 @@
 module Regexp::Expression
 
-  module UnicodeProperty 
+  module UnicodeProperty
     class Base < Regexp::Expression::Base
       def negative?
         @type == :nonproperty

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

@@ -0,0 +1,26 @@
+module Regexp::Expression
+
+  class Root < Regexp::Expression::Subexpression
+    def initialize
+      super Regexp::Token.new(:expression, :root, '', 0)
+    end
+
+    def multiline?
+      @expressions[0].m?
+    end
+    alias :m? :multiline?
+
+    def case_insensitive?
+      @expressions[0].i?
+    end
+    alias :i? :case_insensitive?
+    alias :ignore_case? :case_insensitive?
+
+    def free_spacing?
+      @expressions[0].x?
+    end
+    alias :x? :free_spacing?
+    alias :extended? :free_spacing?
+  end
+
+end

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

@@ -0,0 +1,100 @@
+module Regexp::Expression
+
+  class CharacterSet < Regexp::Expression::Base
+    attr_accessor :members
+
+    def initialize(token)
+      @members  = []
+      @negative = false
+      @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
+    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
+
+    def to_s(format = :full)
+      s = ''
+
+      s << @text.dup
+      s << '^' if negative?
+      s << @members.join
+      s << ']'
+
+      case format
+      when :base
+      else
+        s << @quantifier.to_s if quantified?
+      end
+
+      s
+    end
+
+    def matches?(input)
+      input =~ /#{to_s}/ ? true : false
+    end
+  end
+
+  class CharacterSubSet < CharacterSet
+  end
+
+end # module Regexp::Expression

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

@@ -0,0 +1,17 @@
+module Regexp::Expression
+
+  module CharacterType
+    class Base < Regexp::Expression::Base; end
+
+    class Any         < CharacterType::Base; end
+    class Digit       < CharacterType::Base; end
+    class NonDigit    < CharacterType::Base; end
+    class Hex         < CharacterType::Base; end
+    class NonHex      < CharacterType::Base; end
+    class Word        < CharacterType::Base; end
+    class NonWord     < CharacterType::Base; end
+    class Space       < CharacterType::Base; end
+    class NonSpace    < CharacterType::Base; end
+  end
+
+end

data/lib/regexp_parser/expression/quantifier.rb

@@ -0,0 +1,26 @@
+module Regexp::Expression
+
+  class Quantifier
+    attr_reader   :token, :text, :min, :max, :mode
+
+    def initialize(token, text, min, max, mode)
+      @token = token
+      @text  = text
+      @mode  = mode
+      @min   = min
+      @max   = max
+    end
+
+    def clone
+      copy = self.dup
+      copy.instance_variable_set(:@text, @text.dup)
+      copy
+    end
+
+    def to_s
+      @text.dup
+    end
+    alias :to_str :to_s
+  end
+
+end

data/lib/regexp_parser/expression/subexpression.rb

@@ -0,0 +1,69 @@
+module Regexp::Expression
+
+  class Subexpression < Regexp::Expression::Base
+    attr_accessor :expressions
+
+    def initialize(token)
+      super(token)
+
+      @expressions = []
+    end
+
+    # Override base method to clone the expressions as well.
+    def clone
+      copy = super
+      copy.expressions = @expressions.map {|e| e.clone }
+      copy
+    end
+
+    def <<(exp)
+      @expressions << exp
+    end
+
+    def insert(exp)
+      @expressions.insert 0, exp
+    end
+
+    def each(&block)
+      @expressions.each {|e| yield e}
+    end
+
+    def each_with_index(&block)
+      @expressions.each_with_index {|e, i| yield e, i}
+    end
+
+    def first
+      @expressions.first
+    end
+
+    def last
+      @expressions.last
+    end
+
+    def [](index)
+      @expressions[index]
+    end
+
+    def length
+      @expressions.length
+    end
+
+    def to_s(format = :full)
+      s = ''
+
+      # Note: the format does not get passed down to subexpressions.
+      case format
+      when :base
+        s << @text.dup
+        s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
+      else
+        s << @text.dup
+        s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
+        s << @quantifier if quantified?
+      end
+
+      s
+    end
+  end
+
+end