regexp_parser 0.1.0

data/lib/regexp_parser/expression/property.rb

@@ -0,0 +1,108 @@
+module Regexp::Expression
+
+  module UnicodeProperty 
+    class Base < Regexp::Expression::Base
+      def negative?
+        @type == :nonproperty
+      end
+
+      def name
+        @text =~ /\A\\[pP]\{([^}]+)\}\z/; $1
+      end
+    end
+
+    class Alnum         < Base; end
+    class Alpha         < Base; end
+    class Any           < Base; end
+    class Ascii         < Base; end
+    class Blank         < Base; end
+    class Cntrl         < Base; end
+    class Digit         < Base; end
+    class Graph         < Base; end
+    class Lower         < Base; end
+    class Newline       < Base; end
+    class Print         < Base; end
+    class Punct         < Base; end
+    class Space         < Base; end
+    class Upper         < Base; end
+    class Word          < Base; end
+    class Xdigit        < Base; end
+
+    module Letter
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Letter::Base; end
+      class Uppercase   < Letter::Base; end
+      class Lowercase   < Letter::Base; end
+      class Titlecase   < Letter::Base; end
+      class Modifier    < Letter::Base; end
+      class Other       < Letter::Base; end
+    end
+
+    module Mark
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Mark::Base; end
+      class Nonspacing  < Mark::Base; end
+      class Spacing     < Mark::Base; end
+      class Enclosing   < Mark::Base; end
+    end
+
+    module Number
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Number::Base; end
+      class Decimal     < Number::Base; end
+      class Letter      < Number::Base; end
+      class Other       < Number::Base; end
+    end
+
+    module Punctuation
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Punctuation::Base; end
+      class Connector   < Punctuation::Base; end
+      class Dash        < Punctuation::Base; end
+      class Open        < Punctuation::Base; end
+      class Close       < Punctuation::Base; end
+      class Initial     < Punctuation::Base; end
+      class Final       < Punctuation::Base; end
+      class Other       < Punctuation::Base; end
+    end
+
+    module Separator
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Separator::Base; end
+      class Space       < Separator::Base; end
+      class Line        < Separator::Base; end
+      class Paragraph   < Separator::Base; end
+    end
+
+    module Symbol
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Symbol::Base; end
+      class Math        < Symbol::Base; end
+      class Currency    < Symbol::Base; end
+      class Modifier    < Symbol::Base; end
+      class Other       < Symbol::Base; end
+    end
+
+    module Codepoint
+      class Base < UnicodeProperty::Base; end
+
+      class Any         < Codepoint::Base; end
+      class Control     < Codepoint::Base; end
+      class Format      < Codepoint::Base; end
+      class Surrogate   < Codepoint::Base; end
+      class PrivateUse  < Codepoint::Base; end
+      class Unassigned  < Codepoint::Base; end
+    end
+
+    class Age     < UnicodeProperty::Base; end
+    class Derived < UnicodeProperty::Base; end
+    class Script  < UnicodeProperty::Base; end
+  end
+
+end # module Regexp::Expression

data/lib/regexp_parser/expression/set.rb

@@ -0,0 +1,59 @@
+module Regexp::Expression
+
+  class CharacterSet < Regexp::Expression::Base
+    attr_accessor :members
+
+    def initialize(token)
+      @members = []
+      @negative = false
+      super
+    end
+
+    def <<(member)
+      if @members.last.is_a?(CharacterSubSet)
+        @members.last << member
+      else
+        @members << member
+      end
+    end
+
+    def include?(member)
+      @members.each do |m|
+        if m.is_a?(CharacterSubSet)
+          return true if m.include?(member)
+        else
+          return true if member == m.to_s
+        end
+      end; false
+    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 to_s
+      s = @text
+      s << '^' if negative?
+      s << @members.join
+      s << ']'
+      s << @quantifier.to_s if quantified?
+      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.rb

@@ -0,0 +1,287 @@
+module Regexp::Expression
+  class Base
+    attr_reader :type, :token, :text
+    attr_reader :quantifier
+    attr_reader :expressions
+
+    attr_accessor :options
+
+    def initialize(token)
+      @type         = token.type
+      @token        = token.token
+      @text         = token.text
+      @options      = nil
+      @expressions  = []
+    end
+
+    def to_s
+      s = @text
+      s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
+      s << @quantifier if quantified?
+      s
+    end
+
+    def <<(exp)
+      @expressions << exp
+    end
+
+    def each(&block)
+      @expressions.each {|e| yield e}
+    end
+
+    def [](index)
+      @expressions[index]
+    end
+
+    def quantify(token, text, min = nil, max = nil, mode = :greedy)
+      @quantifier = Quantifier.new(token, text, min, max, mode)
+    end
+
+    def quantified?
+      not @quantifier.nil?
+    end
+
+    def quantity
+      [@quantifier.min, @quantifier.max]
+    end
+
+    def greedy?
+      @quantifier.mode == :greedy
+    end
+
+    def reluctant?
+      @quantifier.mode == :reluctant
+    end
+    alias :lazy? :reluctant?
+
+    def possessive?
+      @quantifier.mode == :possessive
+    end
+
+    def multiline?
+      (@options and @options[:m]) ? true : false
+    end
+    alias :m? :multiline?
+
+    def case_insensitive?
+      (@options and @options[:i]) ? true : false
+    end
+    alias :i? :case_insensitive?
+    alias :ignore_case? :case_insensitive?
+
+    def free_spacing?
+      (@options and @options[:x]) ? true : false
+    end
+    alias :x? :free_spacing?
+    alias :extended? :free_spacing?
+  end
+
+  class Root < Regexp::Expression::Base
+    def initialize
+      super Regexp::Token.new(:expression, :root, '')
+    end
+
+    def multiline?
+      @expressions[0].m?
+    end
+    alias :m? :multiline?
+
+    def case_insensitive?
+      @expressions[0].i?
+    end
+    alias :i? :case_insensitive?
+
+    def free_spacing?
+      @expressions[0].x?
+    end
+    alias :x? :free_spacing?
+  end
+
+  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 to_s
+      @text
+    end
+    alias :to_str :to_s
+  end
+
+  class Literal < Regexp::Expression::Base; end
+
+  module Backreference
+    class Base < Regexp::Expression::Base; end
+
+    class Name                < Backreference::Base; end
+    class Number              < Backreference::Base; end
+    class NumberRelative      < Backreference::Base; end
+
+    class NameNestLevel       < Backreference::Base; end
+    class NumberNestLevel     < Backreference::Base; end
+
+    class NameCall            < Backreference::Base; end
+    class NumberCall          < Backreference::Base; end
+    class NumberCallRelative  < Backreference::Base; end
+  end
+
+  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
+
+  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
+
+  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
+
+  class Alternation < Regexp::Expression::Base
+    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)
+      @expressions.last.last.quantify(token, text, min, max, mode)
+    end
+
+    def to_s
+      @expressions.map{|e| e.to_s}.join('|')
+    end
+  end
+
+  # a sequence of expressions, used by alternations
+  class Sequence < Regexp::Expression::Base
+    def initialize
+      super Regexp::Token.new(:expression, :sequence, '')
+    end
+
+    def <<(exp)
+      @expressions << exp
+    end
+
+    def insert(exp)
+      @expressions.insert 0, exp
+    end
+
+    def first
+      @expressions.first
+    end
+
+    def last
+      @expressions.last
+    end
+
+    def quantify(token, text, min = nil, max = nil, mode = :greedy)
+      last.quantify(token, text, min, max, mode)
+    end
+  end
+
+  module Group
+    class Base < Regexp::Expression::Base
+      def capturing?
+        [:capture, :named].include? @token
+      end
+
+      def comment?; @type == :comment end
+
+      def to_s
+        s = @text
+        s << @expressions.join
+        s << ')'
+        s << @quantifier.to_s if quantified?
+        s
+      end
+    end
+
+    class Atomic    < Group::Base; end
+    class Capture   < Group::Base; end
+    class Named     < Group::Base; end
+    class Passive   < Group::Base; end
+
+    class Options   < Group::Base; end
+
+    class Comment   < Group::Base
+      def to_s; @text end
+    end
+  end
+
+  class 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 # module Regexp::Expression
+
+%w{property set}.each do|file|
+  require File.expand_path("../expression/#{file}", __FILE__)
+end