pegarus 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Brian Ford. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,24 @@
+Pegarus is, broadly, an implementation of LPEG on Rubinius. LPEG implements a
+Parsing Expression Grammar using a parsing machine rather than the Packrat
+algorithm. (See "A Text Pattern-Matching Tool based on Parsing Expression
+Grammars" by Roberto Ierusalimschy.)
+
+Pegarus actually implements an abstract syntax tree (AST) for the PEG. There
+are various options to execute the AST against a subject string. One option is
+a simple AST-walking evaluator. A second option is an implementation of the
+LPEG parsing machine. A third option is a compiler that targets Rubinius
+bytecode.
+
+
+1. Running the specs
+
+Pegarus uses the mspec gem because of the facilities for tags and easily
+defining custom matchers and guards, since Pegarus targets more than one Ruby
+implementation.
+
+To run the specs, use the following steps:
+
+1. Install the mspec gem
+2. If you plan to use Rubinius, ensure 'rbx' is on your path
+3. Run 'rake' to run the specs with $RUBY or 'rbx'
+4. Set the environment variable RUBY to the name of the Ruby to use

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rake/gempackagetask'
+
+task :default => :spec
+
+BASE_DIR = File.expand_path('../', __FILE__)
+RUBY = ENV["RUBY"] || "rbx"
+
+def spec(target)
+  sh("mspec -t #{target} -T -I#{BASE_DIR} spec") { |ok, res|  }
+end
+
+desc "Run the specs with $RUBY or 'rbx' (default)"
+task :spec do
+  spec RUBY
+end
+
+namespace :spec do
+  desc "Run the specs with Rubinius"
+  task :rbx do
+    spec "rbx"
+  end
+
+  desc "Run the specs with the 'ruby' on $PATH"
+  task :ruby do
+    spec "ruby"
+  end
+
+  desc "Run the specs with all engines"
+  task :all => [:rbx, :ruby]
+end
+
+spec = Gem::Specification.new do |s|
+  require File.expand_path('../lib/pegarus/version', __FILE__)
+
+  s.name                      = "pegarus"
+  s.version                   = Pegarus::VERSION.to_s
+
+  s.specification_version     = 2 if s.respond_to? :specification_version=
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors                   = ["Brian Ford"]
+  s.date                      = %q{2010-10-24}
+  s.email                     = %q{brixen@gmail.com}
+  s.has_rdoc                  = true
+  s.extra_rdoc_files          = %w[ README LICENSE ]
+  s.executables               = []
+  s.files                     = FileList[ '{bin,lib,spec}/**/*.{yaml,txt,rb}', 'Rakefile', *s.extra_rdoc_files ]
+  s.homepage                  = %q{http://github.com/brixen/pegarus}
+  s.require_paths             = ["lib"]
+  s.rubygems_version          = %q{1.3.5}
+  s.summary                   = "Pegarus is an implementation of LPEG in Ruby."
+  s.description               = <<EOS
+Pegarus is, broadly, an implementation of LPEG on Rubinius. LPEG implements a
+Parsing Expression Grammar using a parsing machine rather than the Packrat
+algorithm. (See "A Text Pattern-Matching Tool based on Parsing Expression
+Grammars" by Roberto Ierusalimschy.)
+
+Pegarus actually implements an abstract syntax tree (AST) for the PEG. There
+are various options to execute the AST against a subject string. One option is
+a simple AST-walking evaluator. A second option is an implementation of the
+LPEG parsing machine. A third option is a compiler that targets Rubinius
+bytecode.
+EOS
+
+  s.rdoc_options << '--title' << 'Pegarus Gem' <<
+                   '--main' << 'README' <<
+                   '--line-numbers'
+end
+
+Rake::GemPackageTask.new(spec){ |pkg| pkg.gem_spec = spec }

data/lib/pegarus/ast/always.rb

@@ -0,0 +1,7 @@
+module Pegarus
+  class Always < Pattern
+    def visit(visitor)
+      visitor.always self
+    end
+  end
+end

data/lib/pegarus/ast/any.rb

@@ -0,0 +1,13 @@
+module Pegarus
+  class Any < Pattern
+    attr_accessor :count
+
+    def initialize(count)
+      @count = count
+    end
+
+    def visit(visitor)
+      visitor.any self
+    end
+  end
+end

data/lib/pegarus/ast/any_range.rb

@@ -0,0 +1,13 @@
+module Pegarus
+  class AnyRange < Pattern
+    attr_accessor :range
+
+    def initialize(range)
+      @range = range
+    end
+
+    def visit(visitor)
+      visitor.any_range self
+    end
+  end
+end

data/lib/pegarus/ast/character.rb

@@ -0,0 +1,13 @@
+module Pegarus
+  class Character < Pattern
+    attr_accessor :string
+
+    def initialize(string)
+      @string = string
+    end
+
+    def visit(visitor)
+      visitor.character self
+    end
+  end
+end

data/lib/pegarus/ast/character_range.rb

@@ -0,0 +1,13 @@
+module Pegarus
+  class CharacterRange < Pattern
+    attr_accessor :range
+
+    def initialize(range)
+      @range = range
+    end
+
+    def visit(visitor)
+      visitor.character_range self
+    end
+  end
+end

data/lib/pegarus/ast/choice.rb

@@ -0,0 +1,7 @@
+module Pegarus
+  class Choice < BinaryOp
+    def visit(visitor)
+      visitor.choice self
+    end
+  end
+end

data/lib/pegarus/ast/concatenation.rb

@@ -0,0 +1,7 @@
+module Pegarus
+  class Concatenation < BinaryOp
+    def visit(visitor)
+      visitor.concatenation self
+    end
+  end
+end

data/lib/pegarus/ast/difference.rb

@@ -0,0 +1,7 @@
+module Pegarus
+  class Difference < BinaryOp
+    def visit(visitor)
+      visitor.difference self
+    end
+  end
+end

data/lib/pegarus/ast/grammar.rb

@@ -0,0 +1,56 @@
+module Pegarus
+  def grammar(spec=nil, pattern=nil)
+    case spec
+    when Symbol
+      Grammar.new Variable.new(spec, pattern)
+    when Variable
+      Grammar.new spec
+    when Pattern
+      Grammar.new Variable.new(:S, spec)
+    when nil
+      Grammar.new
+    else
+      Grammar.new Variable.new(:S, pattern)
+    end
+  end
+  module_function :grammar
+
+  class Grammar < Pattern
+    attr_accessor :start
+
+    def initialize(variable=nil)
+      if variable
+        @start = variable.name
+        set_variable variable.name, variable.pattern
+      end
+    end
+
+    def set_variable(name, *pattern)
+      variable = get_variable name
+      variable.pattern = *pattern
+      variable
+    end
+
+    def get_variable(name)
+      if metaclass.method_defined? name
+        variable = send name
+      else
+        vname = name.to_sym
+        variable = Variable.new vname
+        metaclass.thunk_method vname, variable
+      end
+
+      variable
+    end
+
+    def method_missing(sym, *args)
+      name = sym.to_s
+
+      if name[-1] == ?=
+        set_variable name[0..-2], *args
+      else
+        get_variable name
+      end
+    end
+  end
+end

data/lib/pegarus/ast/if.rb

@@ -0,0 +1,9 @@
+module Pegarus
+  # Implements &patt in a PEG. The pattern succeeds if
+  # patt matches. Does not consume any input.
+  class If < UnaryOp
+    def visit(visitor)
+      visitor.if self
+    end
+  end
+end

data/lib/pegarus/ast/never.rb

@@ -0,0 +1,7 @@
+module Pegarus
+  class Never < Pattern
+    def visit(visitor)
+      visitor.never self
+    end
+  end
+end

data/lib/pegarus/ast/pattern.rb

@@ -0,0 +1,127 @@
+module Pegarus
+  # Accepts a Ruby object representation of simple PEG "atoms" and returns an
+  # AST node.
+  def pattern(spec)
+    case spec
+    when Array
+      Set.new spec.join
+    when Integer
+      Any.new spec
+    when String
+      Character.new spec
+    when Range
+      case spec.first
+      when Integer
+        AnyRange.new spec
+      when String
+        CharacterRange.new spec
+      end
+    when Symbol
+      variable spec
+    when Pattern
+      spec
+    when true
+      Always.new
+    when false
+      Never.new
+    when nil
+      nil
+    else
+      raise ParseError, "unknown specification type for Pattern: #{spec.inspect}"
+    end
+  end
+  module_function :pattern
+
+
+  # Class Pattern is the base class for all nodes used to represent the AST
+  # for a PEG. Following LPEG, the base is a pattern and not a grammar.
+  class Pattern
+    # Executes the PEG pattern on subject. If the pattern matches a prefix of
+    # subject, returns the index one character past the last matching
+    # character. Otherwise, returns nil.
+    #
+    # The pattern AST is purely a representation. By default, it includes no
+    # machinery to execute the pattern over the subject. All execution is
+    # provided by other facilities, for example, the AST evaluator and the
+    # parsing machine compiler and interpreter. These facilities are called
+    # "engines".
+    #
+    # The Pattern class defaults to the AST Evaluator engine. The protocol
+    # requires the engine class to respond to .new_exector taking the AST root
+    # node and the subject as arguments. The default Pattern#match method is
+    # essentially a trampoline. It calls new_executor and expects that method
+    # to replace #match on the root node and then tail call to the new #match
+    # method installed by the engine.
+
+    def match(subject)
+      Pattern.engine.new_executor self, subject
+    end
+
+    def self.engine
+      unless @engine
+        require 'pegarus/evaluator'
+        @engine = Evaluator
+      end
+
+      @engine
+    end
+
+    def self.select_engine(klass)
+      @engine = klass
+    end
+
+    def graph
+      if defined? Rubinius
+        Rubinius::AST::AsciiGrapher.new(self, Pattern).print
+      else
+        inspect
+      end
+    end
+
+    def visit(visitor)
+    end
+
+    # Pattern operators
+
+    def /(other)
+      Choice.new self, other
+    end
+
+    def +(other)
+      Concatenation.new self, other
+    end
+
+    def -(other)
+      Difference.new self, other
+    end
+
+    def *(other)
+      Product.new self, other
+    end
+
+    def +@
+      If.new self
+    end
+
+    def -@
+      Unless.new self
+    end
+  end
+
+  class UnaryOp < Pattern
+    attr_accessor :pattern
+
+    def initialize(pattern)
+      @pattern = Pegarus.pattern pattern
+    end
+  end
+
+  class BinaryOp < Pattern
+    attr_accessor :first, :second
+
+    def initialize(first, second)
+      @first = Pegarus.pattern first
+      @second = Pegarus.pattern second
+    end
+  end
+end

data/lib/pegarus/ast/product.rb

@@ -0,0 +1,12 @@
+module Pegarus
+  class Product < BinaryOp
+    def initialize(first, second)
+      @first = Pegarus.pattern first
+      @second = Type.coerce_to second, Integer, :to_int
+    end
+
+    def visit(visitor)
+      visitor.product self
+    end
+  end
+end

data/lib/pegarus/ast/set.rb

@@ -0,0 +1,13 @@
+module Pegarus
+  class Set < Pattern
+    attr_accessor :characters
+
+    def initialize(characters)
+      @characters = characters
+    end
+
+    def visit(visitor)
+      visitor.set self
+    end
+  end
+end

data/lib/pegarus/ast/unless.rb

@@ -0,0 +1,9 @@
+module Pegarus
+  # Implements !patt in a PEG. The pattern succeeds if
+  # patt does not match. Does not consume any input.
+  class Unless < UnaryOp
+    def visit(visitor)
+      visitor.unless self
+    end
+  end
+end

data/lib/pegarus/ast/variable.rb

@@ -0,0 +1,15 @@
+module Pegarus
+  def variable(name, pattern=nil)
+    Pegarus::Variable.new name, pattern
+  end
+  module_function :variable
+
+  class Variable < Pattern
+    attr_accessor :name, :pattern
+
+    def initialize(name, pattern=nil)
+      @name = name.to_sym
+      @pattern = Pegarus.pattern pattern
+    end
+  end
+end

data/lib/pegarus/ast.rb

@@ -0,0 +1,16 @@
+require 'pegarus/ast/pattern'
+require 'pegarus/ast/always'
+require 'pegarus/ast/any'
+require 'pegarus/ast/any_range'
+require 'pegarus/ast/character'
+require 'pegarus/ast/character_range'
+require 'pegarus/ast/choice'
+require 'pegarus/ast/concatenation'
+require 'pegarus/ast/difference'
+require 'pegarus/ast/if'
+require 'pegarus/ast/never'
+require 'pegarus/ast/product'
+require 'pegarus/ast/set'
+require 'pegarus/ast/unless'
+require 'pegarus/ast/grammar'
+require 'pegarus/ast/variable'

data/lib/pegarus/compatibility.rb

@@ -0,0 +1,25 @@
+class Module
+  unless method_defined? :thunk_method
+    def thunk_method(name, value)
+      define_method(name) { return value }
+    end
+  end
+end
+
+unless defined?(Type)
+  module Type
+    def self.coerce_to(obj, cls, meth)
+      return obj if obj.kind_of? cls
+
+      begin
+        ret = obj.__send__(meth)
+      rescue Exception
+        raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed"
+      end
+
+      return ret if ret.kind_of? cls
+
+      raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})"
+    end
+  end
+end

data/lib/pegarus/evaluator.rb

@@ -0,0 +1,93 @@
+module Pegarus
+  class Evaluator
+    def self.new_executor(pattern, subject)
+      pattern.instance_variable_set :@evaluator, new
+
+      class << pattern
+        class_eval <<-eval
+          def match(subject)
+            @evaluator.match self, subject
+          end
+        eval
+      end
+
+      pattern.match subject
+    end
+
+    def match(pattern, subject)
+      @subject  = subject
+      @failure  = false
+      @index    = 0
+
+      pattern.visit self
+
+      failure? ? nil : @index
+    end
+
+    def failure
+      @failure = true
+    end
+
+    def failure?
+      @failure
+    end
+
+    def always(pattern)
+      failure
+    end
+
+    def any(pattern)
+      if @subject.size > @index + pattern.count
+        @index += pattern.count
+      else
+        failure
+      end
+    end
+
+    def any_range(pattern)
+      failure
+    end
+
+    def character(pattern)
+      failure
+    end
+
+    def character_range(pattern)
+      failure
+    end
+
+    def choice(pattern)
+      failure
+    end
+
+    def concatenation(pattern)
+      failure
+    end
+
+    def difference(pattern)
+      failure
+    end
+
+    def if(pattern)
+      failure
+    end
+
+    def never(pattern)
+      failure
+    end
+
+    def product(pattern)
+      failure
+    end
+
+    def set(pattern)
+      failure
+    end
+
+    def unless(pattern)
+      failure
+    end
+  end
+end
+
+Pegarus::Pattern.select_engine Pegarus::Evaluator

data/lib/pegarus/machine/compiler.rb

@@ -0,0 +1,18 @@
+module Pegarus
+  module Machine
+    class Compiler
+      def compile(pattern)
+        program = []
+        pattern.instance_variable_set :@program, program
+
+        class << pattern
+          class_eval <<-eval
+            def match(subject)
+              Pegarus::Machine.execute @program, subject
+            end
+          eval
+        end
+      end
+    end
+  end
+end

data/lib/pegarus/machine/generator.rb

@@ -0,0 +1,8 @@
+module Pegarus
+  module ParsingMachine
+    class Generator
+      def initialize
+      end
+    end
+  end
+end