regexp_parser 0.1.1 → 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d3544709ae86e53530ef7cbe037dcab48690c2c
+  data.tar.gz: fb96ce92b21303ec32e88103d708a508c80588fc
+SHA512:
+  metadata.gz: d4191f06120c4e5abe9f0fc6b7eb466aab12a61b37c4cb7c33204f2c2dba9907866d42317320cf3916146f59e12ff3c027db76300321342b1615270d7085ade9
+  data.tar.gz: 8d0173c9d02e4e26eae291e0dbedd48fb7d9995629b761f47ab696ad9b2955efa542c6a3360fa711f27c0d7f4cc5df6f293f89685e47aacd4e9a2f8eab6d336f

data/ChangeLog

@@ -1,3 +1,48 @@
+Tue Jan 14 13:14:24 2014 Ammar Ali <ammarabuali@gmail.com>
+
+	* Released version 0.1.5, with a correct ChangeLog.
+
+Tue Jan 14 13:14:24 2014 Ammar Ali <ammarabuali@gmail.com>
+
+	* Released version 0.1.4, after accidental yank of last version.
+
+Tue Jan 14 13:05:13 2014 Ammar Ali <ammarabuali@gmail.com>
+
+	* Released version 0.1.3, adds missing VERSION.yml file.
+
+Tue Jan 14 12:41:52 2014 Ammar Ali <ammarabuali@gmail.com>
+
+	* Released version 0.1.2
+
+	* Added syntax stubs for ruby versions 2.0 and 2.1
+
+Sat Feb 9 12:27:13 2010 Ammar Ali <ammarabuali@gmail.com>
+
+	* Added clone methods for deep copying expressions.
+
+	* Added optional format argument for to_s on expressions to return the
+	  text of the expression with (:full, the default) or without (:base)
+		its quantifier.
+
+	* Renamed the :beginning_of_line and :end_of_line tokens to :bol and
+		:eol.
+
+	* Fixed a bug where alternations with more than two alternatives and
+	  one of them ending in a group were being incorrectly nested.
+
+	* Improved EOF handling in general and especially from sequences like
+	  hex and control escapes.
+
+	* Fixed a bug where named groups with an empty name would return a
+	  blank token [].
+
+	* Fixed a bug where member of a parent set where being added to its
+	  last subset.
+
+	* Various code cleanups in scanner.rl
+
+	* Fixed a few mutable string bugs by calling dup on the originals.
+
 Tue Nov 23 11:35:56 2010 Ammar Ali <ammarabuali@gmail.com>
 
 	* Made ruby 1.8.6 the base for all 1.8 syntax, and the 1.8 name a pointer

data/Rakefile

@@ -1,26 +1,15 @@
 require 'rake'
-require 'yaml'
 require 'rake/testtask'
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
+require 'yaml'
 
 task :default => [:test]
 
-
 RAGEL_SOURCE_DIR = File.expand_path '../lib/regexp_parser/scanner', __FILE__
 RAGEL_OUTPUT_DIR = File.expand_path '../lib/regexp_parser', __FILE__
 
 RAGEL_SOURCE_FILES = %w{scanner}
 
-RP_ROOT = File.expand_path '../', __FILE__
-
-def regexp_parser_version
-  v = YAML.load(File.read("#{RP_ROOT}/VERSION.yml"))
-  v[:build] ? "#{v[:major]}.#{v[:minor]}.#{v[:patch]}.#{v[:build]}" :
-              "#{v[:major]}.#{v[:minor]}.#{v[:patch]}"
-end
-
-RP_VERSION  = regexp_parser_version
-
 desc "Find and run all unit tests under test/ directory"
 Rake::TestTask.new("test") do |t|
   t.libs << "test"
@@ -30,28 +19,11 @@ end
 task :test
 
 namespace :test do
-  desc "Run all scanner tests"
-  Rake::TestTask.new("scanner") do |t|
-    t.libs << "test"
-    t.test_files = ['test/scanner/test_all.rb']
-  end
-
-  desc "Run all lexer tests"
-  Rake::TestTask.new("lexer") do |t|
-    t.libs << "test"
-    t.test_files = ['test/lexer/test_all.rb']
-  end
-
-  desc "Run all parser tests"
-  Rake::TestTask.new("parser") do |t|
-    t.libs << "test"
-    t.test_files = ['test/parser/test_all.rb']
-  end
-
-  desc "Run all syntax tests"
-  Rake::TestTask.new("syntax") do |t|
-    t.libs << "test"
-    t.test_files = ['test/syntax/test_all.rb']
+  %w{scanner lexer parser expression syntax}.each do |component|
+    Rake::TestTask.new(component) do |t|
+      t.libs << "test"
+      t.test_files = ["test/#{component}/test_all.rb"]
+    end
   end
 end
 
@@ -74,8 +46,8 @@ end
 
 spec = Gem::Specification.new do |gem|
   gem.name = 'regexp_parser'
-  gem.version = '0.1.1'
-  gem.date = '2010-11-23'
+  gem.version = YAML.load(File.read('VERSION.yml')).values.compact.join('.')
+  gem.date = '2014-01-14'
 
   gem.license = 'MIT'
   gem.summary = %q{Scanner, lexer, parser for ruby's regular expressions}
@@ -91,7 +63,7 @@ spec = Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.files = Dir.glob("{lib,test}/**/*.rb") + Dir.glob("lib/**/*.rl") +
-              %w(Rakefile LICENSE README.rdoc ChangeLog)
+              %w(VERSION.yml Rakefile LICENSE README.rdoc ChangeLog)
 
   gem.test_files = Dir.glob("test/**/*.rb")
 
@@ -99,7 +71,7 @@ spec = Gem::Specification.new do |gem|
     gem.respond_to? :required_rubygems_version=
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
+Gem::PackageTask.new(spec) do |pkg|
   pkg.need_zip = true
   pkg.need_tar = true
 end
@@ -108,11 +80,7 @@ namespace :gem do
   desc "Release the gem to rubygems.org"
   task :release do |t|
     Rake::Task['ragel:rb'].execute
-
-    Rake::Task['gem'].invoke("#{RP_ROOT}/pkg/regexp_parser-#{RP_VERSION}")
-
     Rake::Task['repackage'].execute
-
-    sh "gem push #{RP_ROOT}/pkg/regexp_parser-#{RP_VERSION}.gem"
+    #sh "gem push"
   end
 end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 5
+:build: 

data/lib/regexp_parser.rb

@@ -1,45 +1,12 @@
-class Regexp
+require 'yaml'
 
+class Regexp
   module Parser
-    VERSION = '0.0.1'
+    VERFILE = File.expand_path('../../VERSION.yml', __FILE__)
+    VERSION = YAML.load(File.read(VERFILE)).values.compact.join('.')
   end
-
-  TOKEN_KEYS = [:type, :token, :text, :ts, :te, :depth, :set_depth].freeze
-  Token = Struct.new(*TOKEN_KEYS) do
-    def offset
-      [self.ts, self.te]
-    end
-
-    def length
-      self.te - self.ts
-    end
-
-    def to_h
-      hash = {}
-      members.each do |member|
-        hash[member.to_sym] = self.send(member.to_sym)
-      end; hash
-    end
-
-    def next(exp = nil)
-      if exp
-        @next = exp
-      else
-        @next
-      end
-    end
-
-    def previous(exp = nil)
-      if exp
-        @previous = exp
-      else
-        @previous
-      end
-    end
-  end
-
 end
 
-%w{ctype scanner syntax lexer parser}.each do |file|
+%w{token ctype scanner syntax lexer parser}.each do |file|
   require File.expand_path("../regexp_parser/#{file}", __FILE__)
 end

data/lib/regexp_parser/expression.rb

@@ -1,36 +1,67 @@
 module Regexp::Expression
+
   class Base
-    attr_reader :type, :token, :text
-    attr_reader :quantifier
-    attr_reader :expressions
+    attr_accessor :type, :token
+    attr_accessor :level, :text, :ts
 
+    attr_accessor :quantifier
     attr_accessor :options
 
     def initialize(token)
       @type         = token.type
       @token        = token.token
       @text         = token.text
+      @ts           = token.ts
+      @level        = token.level
       @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
+    def clone
+      copy = self.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
     end
 
-    def <<(exp)
-      @expressions << exp
+    def to_re(format = :full)
+      ::Regexp.new(to_s(format))
     end
 
-    def each(&block)
-      @expressions.each {|e| yield e}
+    def starts_at
+      @ts
     end
 
-    def [](index)
-      @expressions[index]
+    def full_length
+      to_s.length
+    end
+
+    def offset
+      [starts_at, full_length]
+    end
+
+    def coded_offset
+      '@%d+%d' % offset
+    end
+
+    def to_s(format = :full)
+      s = ''
+
+      case format
+      when :base
+        s << @text.dup
+      else
+        s << @text.dup
+        s << @quantifier if quantified?
+      end
+
+      s
+    end
+
+    def terminal?
+      !respond_to?(:expressions)
     end
 
     def quantify(token, text, min = nil, max = nil, mode = :greedy)
@@ -42,20 +73,21 @@ module Regexp::Expression
     end
 
     def quantity
+      return [nil,nil] unless quantified?
       [@quantifier.min, @quantifier.max]
     end
 
     def greedy?
-      @quantifier.mode == :greedy
+      quantified? and @quantifier.mode == :greedy
     end
 
     def reluctant?
-      @quantifier.mode == :reluctant
+      quantified? and @quantifier.mode == :reluctant
     end
     alias :lazy? :reluctant?
 
     def possessive?
-      @quantifier.mode == :possessive
+      quantified? and @quantifier.mode == :possessive
     end
 
     def multiline?
@@ -76,212 +108,27 @@ module Regexp::Expression
     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
+  def self.parsed(exp)
+    case exp
+    when String
+      Regexp::Parser.parse(exp)
+    when Regexp
+      Regexp::Parser.parse(exp.source)
+    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}."
     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__)
+
+[ # Order is important
+  '/expression/*.rb',
+  '/expression/classes/*.rb',
+].each do |path|
+  Dir[File.join(File.dirname(__FILE__), path)].each {|f| require f }
 end