peglite 0.0.1

data/.gemspec

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+GemSpec = Gem::Specification.new do |gem|
+  gem.name = 'peglite'
+  gem.version = '0.0.1'
+  gem.license = 'MIT'
+  gem.required_ruby_version = '>= 1.9.1'
+
+  gem.authors << 'Ingy döt Net'
+  gem.email = 'ingy@ingy.net'
+  gem.summary = 'Simple PEG Parsing Framework'
+  gem.description = <<-'.'
+PegLite is a very simple framework for creating your own PEG parsers.
+.
+  gem.homepage = 'http://pegex.org'
+
+  gem.files = `git ls-files`.lines.map{|l|l.chomp}
+end

data/CHANGELOG.yaml

@@ -0,0 +1,3 @@
+- version: 0.0.1
+  date:    Wed Jan  2 14:51:35 PST 2013
+  changes: Ported from Pegex.pm CPAN module.

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright © 2013 Ingy döt Net
+
+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 NON-INFRINGEMENT. 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.rdoc

@@ -0,0 +1,38 @@
+= PegLite - Simple PEG Parsing Framework
+
+PegLite is a very easy way to make a PEG parser by simply writing a PegLite
+subclass and a few regexes.
+
+= Synopsis
+
+    require 'peglite'
+    class MyParser < PegLite
+      def top
+        match rule "( comment | assignment )*"
+      end
+      token comment: /\s*#.*\s*\n/
+      def assignment
+        m = match "id WS* EQUAL WS* value WS* EOL"
+        return { 'var' => m[0], 'value' => m[1] }
+      end
+    end
+
+    puts YAML.dump MyParser.new.parse <<'...'
+    # This is a comment. Below is an assignment statement:
+    foo = 123
+
+    # A string assignment:
+    bar = 'O HAI'
+    ...
+
+The above program, defines a parser, uses it to parse a text into a data tree,
+and then prints the tree in YAML:
+
+    - var: foo
+      value: 123
+    - var: bar
+      value: O HAI
+
+Pretty simple, right?
+
+

data/Rakefile

@@ -0,0 +1,67 @@
+# Load Gem constants from the gemspec
+GemSpecFile = '.gemspec'
+load GemSpecFile
+GemName = GemSpec.name
+GemVersion = GemSpec.version
+GemDir = "#{GemName}-#{GemVersion}"
+GemFile = "#{GemDir}.gem"
+DevNull = '2>/dev/null'
+
+# Require the Rake libraries
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+if File.exists? 'test/testml.yaml'
+  require 'rake/testml'
+end
+
+task :default => 'help'
+
+CLEAN.include GemDir, GemFile, 'data.tar.gz', 'metadata.gz'
+
+desc 'Run the tests'
+task :test do
+  Rake::TestTask.new do |t|
+    t.verbose = true
+    t.test_files = FileList['test/*.rb']
+  end
+end
+
+desc 'Build the gem'
+task :build => [:clean, :test] do
+  sh "gem build #{GemSpecFile}"
+end
+
+desc 'Install the gem'
+task :install => [:build] do
+  sh "gem install #{GemFile}"
+end
+
+desc 'Build, unpack and inspect the gem'
+task :distdir => [:build] do
+  sh "tar xf #{GemFile} #{DevNull}"
+  Dir.mkdir GemDir
+  Dir.chdir GemDir
+  sh "tar xzf ../data.tar.gz #{DevNull}"
+  puts "\n>>> Entering sub-shell for #{GemDir}..."
+  system ENV['SHELL']
+end
+
+desc 'Build and push the gem'
+task :release => [:build] do
+  sh "gem push #{GemFile}"
+end
+
+desc 'Print a description of the gem'
+task :desc do
+  puts "Gem: '#{GemName}' (version #{GemVersion})"
+  puts
+  puts GemSpec.description.gsub /^/, '  '
+end
+
+desc 'List the Rakefile tasks'
+task :help do
+  puts 'The following rake tasks are available:'
+  puts
+  puts `rake -T`.gsub /^/, '  '
+end

data/lib/peglite/compiler.rb

@@ -0,0 +1,125 @@
+class PegLite;end
+
+#------------------------------------------------------------------------------
+class PegLite::Compiler
+  def initialize peglite_rule
+    tokenize peglite_rule
+  end
+
+  def compile
+    fail if @tokens.empty?
+    if @tokens[0] == '('
+      @tokens.shift
+      got = compile
+      fail if (@tokens.empty? or not @tokens.shift.match /^\)([\?\*\+]?)/)
+      got.merge! compile_limits $1
+    elsif @tokens.size > 1
+      if @tokens[1] == '|'
+        got = compile_any
+      else
+        got = compile_all
+      end
+    else
+      fail @tokens.to_s
+    end
+    return got
+  end
+
+  def compile_all
+    fail if @tokens.empty?
+    all = []
+    until @tokens.empty?
+      if @tokens[0] == '('
+        all.push compile
+      elsif @tokens[0].match /^\)/
+        break
+      elsif @tokens[0].match /^\w/
+        all.push compile_ref
+      else
+        fail
+      end
+    end
+    return {
+      'type' => 'all',
+      'rule' => all,
+      'min' => 1,
+      'max' => 1,
+    }
+  end
+
+  def compile_any
+    fail if @tokens.empty?
+    any = []
+    until @tokens.empty?
+      if @tokens[0] == '('
+        any.push compile
+      elsif @tokens[0].match /^\)/
+        break
+      elsif @tokens[0].match /^\w/
+        any.push compile_ref
+        if not @tokens.empty?
+          if @tokens[0] == '|'
+            @tokens.shift
+          elsif not @tokens[0].match /^\)/
+            fail
+          end
+        end
+      else
+        fail
+      end
+    end
+    return {
+      'type' => 'any',
+      'rule' => any,
+      'min' => 1,
+      'max' => 1,
+    }
+  end
+
+  def compile_ref
+    fail if @tokens.empty?
+    token = @tokens.shift
+    token.match(/^(\w+)([\?\*\+]?)$/) or fail
+    rule, quantifier = $1, $2
+    ref = {
+      'type' => 'ref',
+      'rule' => rule,
+    }
+    return ref.merge! compile_limits(quantifier)
+  end
+
+  def compile_limits quantifier
+    case quantifier
+    when '?'; { 'min' => 0, 'max' => 1 }
+    when '*'; { 'min' => 0, 'max' => 0 }
+    when '+'; { 'min' => 1, 'max' => 0 }
+    else; { 'min' => 1, 'max' => 1 }
+    end
+  end
+
+  def tokenize text
+    input = text.clone
+    @tokens = []
+    while (token = get_token input)
+      @tokens.concat token
+    end
+  end
+
+  def get_token input
+    return if input.empty?
+    patterns = [
+      /\A\s+/,
+      /\A(\()/,
+      /\A(\w+[\?\*\+]?)/,
+      /\A(\|)/,
+      /\A(\)[\?\*\+]?)/,
+    ]
+    patterns.each do |r|
+      if m = input.match(r)
+        input.sub! r, ''
+        return m.captures
+      end
+    end
+    fail "Failed to find next token in '#{input}'"
+  end
+end

data/lib/peglite.rb

@@ -0,0 +1,202 @@
+require 'peglite/compiler'
+
+require 'yaml'; def XXX *args; args.each \
+  {|a|puts YAML.dump a};puts caller.first; exit; end
+require 'yaml'; def YYY *args; args.each \
+  {|a|puts YAML.dump a};puts caller.first;return args[0]; end
+
+#------------------------------------------------------------------------------
+class PegLite
+  $PegLiteRules = {}         # XXX global variable smell
+  def self.rule args
+    name, rule = args.first
+    name = name.to_s
+    $PegLiteTopRule ||= name
+    if rule.kind_of? Regexp
+      fail "Regexp for '#{name}' must begin with '\\A'" \
+        unless rule.to_s.match /\A\(\?-mix:\\A/
+      $PegLiteRules[name] = {
+        'type' => 'rgx',
+        'rule' => rule,
+        'min' => 1,
+        'max' => 1,
+      }
+    elsif rule.kind_of? String
+      $PegLiteRules[name] = PegLite::Compiler.new(rule).compile
+    else
+      fail "Don't know how to make rule '#{name}' from '#{rule}'"
+    end
+  end
+
+  rule _: (/\A\s*/)
+  rule __: (/\A\s+/)
+  rule EQUAL: (/\A=/)
+  rule COMMA: (/\A,/)
+  rule NL: (/\A\n/)
+  $PegLiteTopRule = nil
+
+  attr_accessor :got
+  attr_accessor :wrap
+  attr_accessor :debug
+  def initialize attrs={}
+    @got = nil
+    @wrap = false
+    @debug = false
+
+    attrs.each { |k,v| self.send "#{k}=", v }
+
+    @pos = 0
+    @far = 0
+    @rules = $PegLiteRules
+    yield self if block_given?
+  end
+
+  def parse input, top=($PegLiteTopRule || 'top')
+    fail "PegLite parse() method requires an input string" \
+      unless input.kind_of? String
+    @input = input
+    got = match_ref top
+    failure if @pos < @input.length
+    return @got || got[0]
+  end
+
+  def match rule=nil
+    if not rule.kind_of? Hash
+      rule ||= caller.first.scan(/(\w+)/).last.first
+      rule_name = rule
+      if rule.kind_of? String
+        rule = @rules[rule]
+      end
+      fail "Can't find rule for '#{rule_name}'" \
+        if not(rule and rule.kind_of? Hash)
+    end
+
+    pos, count, matched, type, child, min, max =
+      @pos, 0, [], *(rule.values_at *%w(type rule min max))
+
+    while (result = self.method("match_#{type}").call(child))
+      pos = @pos
+      count += 1
+      if result.kind_of? Array
+        matched.concat result
+      else
+        matched << result
+      end
+      break if max == 1
+    end
+
+    if count >= min and (max == 0 or count <= max)
+      return matched
+    else
+      @pos = pos
+      return
+    end
+  end
+
+  def match_all all
+    pos, set, count = @pos, [], 0
+    all.each do |elem|
+      if (m = match elem)
+        set.concat m
+        count += 1
+      else
+        if (@pos = pos) > @far
+          @far = pos
+        end
+        return
+      end
+    end
+    set = [ set ] if count > 1
+    return set
+  end
+
+  def match_any any
+    any.each do |elem|
+      if (m = match elem)
+        return m
+      end
+    end
+    return
+  end
+
+  # TODO move trace/debug out of default match_ref method
+  def match_ref ref
+    trace "Try #{ref}" if @debug
+    begin
+      m = self.method(ref).call
+    rescue NameError => e
+      if @rules[ref]
+        m = match @rules[ref]
+      else
+        fail "No rule defined for '#{ref}'"
+      end
+    end
+    if m
+      m = (@wrap and not m.empty?) ? [{ref => m}] : m
+      trace "Got #{ref}" if @debug
+    else
+      trace "Not #{ref}" if @debug
+    end
+    return m
+  end
+
+  def match_rgx regex
+    m = @input[@pos..-1].match(regex)
+    return unless m
+    @pos += m[0].length
+    match = m.captures
+    # XXX not sure about this:
+    match = [ match ] if m.length > 2
+    @far = @pos if @pos > @far
+    return match
+  end
+
+  #----------------------------------------------------------------------------
+  # Debugging and error reporting support methods
+  #----------------------------------------------------------------------------
+  def trace action
+    indent = !!action.match(/^Try /)
+    @indent ||= 0
+    @indent -= 1 unless indent
+    $stderr.print ' ' * @indent
+    @indent += 1 if indent
+    snippet = @input[@pos..-1]
+    snippet = snippet[0..30] + '...' if snippet.length > 30;
+    snippet.gsub! /\n/, "\\n"
+    $stderr.printf "%-30s", action
+    $stderr.print indent ? " >#{snippet}<\n" : "\n"
+  end
+
+  def failure
+    msg = "Parse failed for some reason"
+    raise PegexParseError, format_error(msg)
+  end
+
+  class PegexParseError < RuntimeError;end
+  def format_error msg
+    buffer = @input
+    position = @far
+    real_pos = @pos
+
+    line = buffer[0, position].scan(/\n/).size + 1
+    column = position - (buffer.rindex("\n", position) || -1)
+
+    pretext = @input[
+      position < 50 ? 0 : position - 50,
+      position < 50 ? position : 50
+    ]
+    context = @input[position, 50]
+    pretext.gsub! /.*\n/m, ''
+    context.gsub! /\n/, "\\n"
+
+    return <<"..."
+Error parsing Pegex document:
+  message:  #{msg}
+  line:     #{line}
+  column:   #{column}
+  position: #{position}
+  context:  #{pretext}#{context}
+  #{' ' * (pretext.length + 10)}^
+...
+  end
+end

data/test/address.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'peglite'
+
+$address1 = <<'...'
+John Doe
+123 Main St
+Los Angeles, CA 90009
+...
+
+$parse_plain = <<'...'
+---
+- John Doe
+- 123 Main St
+- - Los Angeles
+  - CA
+  - '90009'
+...
+
+$parse_wrap = <<'...'
+---
+address:
+- - name:
+    - John Doe
+  - street:
+    - 123 Main St
+  - place:
+    - - city:
+        - Los Angeles
+      - state:
+        - CA
+      - zip:
+        - '90009'
+...
+
+class Test::Unit::TestCase
+  def test_plain
+    parser = AddressParser.new
+    result = parser.parse $address1
+    assert_equal YAML.dump(result), $parse_plain, "Plain parse works"
+  end
+  def test_wrap
+    parser = AddressParser.new wrap: true
+    result = parser.parse $address1
+    assert_equal YAML.dump(result), $parse_wrap, "Wrapping parse works"
+  end
+end
+
+class AddressParser < PegLite
+  rule address: "name street place"
+  rule name: (/\A(.*?)\n/)
+  rule street: (/\A(.*?)\n/)
+  rule place: "city COMMA _ state __ zip NL"
+  rule city: (/\A(\w+(?: \w+)?)/)
+  rule state: (/\A(WA|OR|CA)/)  # Left Coast Rulez
+  rule zip: (/\A(\d{5})/)
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: peglite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ingy döt Net
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-02 00:00:00.000000000 Z
+dependencies: []
+description: ! 'PegLite is a very simple framework for creating your own PEG parsers.
+
+'
+email: ingy@ingy.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gemspec
+- CHANGELOG.yaml
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/peglite.rb
+- lib/peglite/compiler.rb
+- test/address.rb
+homepage: http://pegex.org
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple PEG Parsing Framework
+test_files: []