pegex 0.0.2 → 0.0.3

data/.gemspec

@@ -2,7 +2,7 @@
 
 GemSpec = Gem::Specification.new do |gem|
   gem.name = 'pegex'
-  gem.version = '0.0.2'
+  gem.version = '0.0.3'
   gem.license = 'MIT'
   gem.required_ruby_version = '>= 1.9.1'
 
@@ -17,5 +17,5 @@ that will work equivalently in lots of programming languages!
 
   gem.files = `git ls-files`.lines.map{|l|l.chomp}
 
-  gem.add_development_dependency 'testml-lite', '>= 0.0.1'
+  gem.add_development_dependency 'testml', '>= 0.0.2'
 end

data/.profile

@@ -0,0 +1,2 @@
+export RUBYLIB=../testml-rb/lib
+export RUBYOPT=-rxxx

data/CHANGELOG.yaml

@@ -1,3 +1,6 @@
+- version: 0.0.3
+  date:    Sat Apr 20 07:03:20 CST 2013
+  changes: Major refactoring release
 - version: 0.0.2
   date:    Wed Dec 19 23:58:14 PST 2012
   changes: Fixed a regex bug

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright © 2012 Ingy döt Net
+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

data/README.rdoc

@@ -1,4 +1,4 @@
-= Pegex - Acmeist PEG Parsing Framework
+= pegex - Acmeist PEG Parsing Framework
 
 Pegex is a Acmeist parser framework. It allows you to easily create
 parsers that will work equivalently in lots of programming languages!
@@ -29,35 +29,37 @@ or more explicitly:
 
 = Description
 
-Pegex is a Acmeist parser framework. It allows you to easily create parsers
-that will work equivalently in lots of programming languages!
+Pegex is a Acmeist parser framework. It allows you to easily create
+parsers that will work equivalently in lots of programming languages!
 
-Pegex gets it name by combining Parsing Expression Grammars (PEG), with
-Regular Expessions (Regex). That's actually what Pegex does.
+Pegex gets it name by combining Parsing Expression Grammars (PEG),
+with Regular Expessions (Regex). That's actually what Pegex does.
 
-PEG is the cool new way to elegantly specify recursive descent grammars. The
-Perl 6 language is defined in terms of a self modifying PEG language called
-*Perl 6 Rules*. Regexes are familiar to programmers of most modern
-programming languages. Pegex defines a simple PEG syntax, where all the
-terminals are regexes. This means that Pegex can be quite fast and powerful.
+PEG is the cool new way to elegantly specify recursive descent
+grammars. The Perl 6 language is defined in terms of a self modifying
+PEG language called *Perl 6 Rules*. Regexes are familiar to
+programmers of most modern programming languages. Pegex defines a
+simple PEG syntax, where all the terminals are regexes. This means
+that Pegex can be quite fast and powerful.
 
-Pegex attempts to be the simplest way to define new (or old) Domain Specific
-Languages (DSLs) that need to be used in several programming languages and
-environments.
+Pegex attempts to be the simplest way to define new (or old) Domain
+Specific Languages (DSLs) that need to be used in several programming
+languages and environments.
 
 = Usage
 
-The +pegex.rb+ module itself is just a trivial way to use the
-Pegex framework. It is only intended for the simplest of uses.
+The +pegex.rb+ module itself is just a trivial way to use the Pegex
+framework. It is only intended for the simplest of uses.
 
-+pegex.rb+ defines a single function, +pegex+, which takes a Pegex grammar
-string as input. You may also pass in a receiver class or object.
++pegex.rb+ defines a single function, +pegex+, which takes a Pegex
+grammar string as input. You may also pass in a receiver class or
+object.
 
     parser = pegex(grammar, MyReceiver)
 
-The +pegex+ function returns a Pegex::Parser object, on which you would
-typically call the +parse()+ method, which (on success) will return a data
-structure of the parsed data.
+The +pegex+ function returns a Pegex::Parser object, on which you
+would typically call the +parse()+ method, which (on success) will
+return a data structure of the parsed data.
 
 See Pegex::API for more details.
 
@@ -66,10 +68,10 @@ See Pegex::API for more details.
 This Pegex library was ported to Ruby from the Perl module:
 http://search.cpan.org/dist/Pegex/
 
-The code and tests were fully ported from Perl to Ruby. Pegex should work
-exactly the same in both languages. The documentation and examples have not yet
-been fully ported, but they will be soon enough. For now, refer to the Perl
-docs.
+The code and tests were fully ported from Perl to Ruby. Pegex should
+work exactly the same in both languages. The documentation and
+examples have not yet been fully ported, but they will be soon enough.
+For now, refer to the Perl docs.
 
 You can start here: http://search.cpan.org/dist/Pegex/lib/Pegex.pod
 

data/Rakefile

@@ -11,6 +11,12 @@ DevNull = '2>/dev/null'
 require 'rake'
 require 'rake/testtask'
 require 'rake/clean'
+if File.exists? 'test/testml.yaml'
+  if File.exists? 'lib/rake/testml.rb'
+    $:.unshift "#{Dir.getwd}/lib"
+  end
+  require 'rake/testml'
+end
 
 task :default => 'help'
 
@@ -18,9 +24,12 @@ CLEAN.include GemDir, GemFile, 'data.tar.gz', 'metadata.gz'
 
 desc 'Run the tests'
 task :test do
+  load '.env' if File.exists? '.env'
   Rake::TestTask.new do |t|
     t.verbose = true
-    t.test_files = FileList['test/*.rb']
+    t.test_files = ENV['DEV_TEST_FILES'] &&
+      FileList[ENV['DEV_TEST_FILES'].split] ||
+      FileList['test/**/*.rb'].sort
   end
 end
 

data/ToDo

@@ -1,3 +1,6 @@
+- Support grammar inheritance
+
+- Use pp tree instead of JSON in pegex/pegex/grammar
 - Finish porting tests from perl
 - Support grammar self compile:
   > ruby -Ilib -rfoo/grammar -ecompile

data/lib/pegex.rb

@@ -3,15 +3,14 @@ module Pegex;end
 require 'pegex/parser'
 require 'pegex/grammar'
 
-def pegex grammar_text, receiver=nil
-  unless receiver
+def pegex grammar, receiver=nil
+  if not receiver
     require 'pegex/tree/wrap'
     receiver = Pegex::Tree::Wrap.new
   end
-  receiver = receiver.new \
-    if receiver.class == Class
+  receiver = receiver.new if receiver.class == Class
   return Pegex::Parser.new do |p|
-    p.grammar = Pegex::Grammar.new {|g| g.text = grammar_text}
+    p.grammar = Pegex::Grammar.new {|g| g.text = grammar}
     p.receiver = receiver
   end
 end

data/lib/pegex/grammar.rb

@@ -1,6 +1,7 @@
 require 'pegex'
 class Pegex::Grammar
   attr_accessor :text
+  attr_accessor :tree
 
   def initialize
     yield self if block_given?

data/lib/pegex/input.rb

@@ -2,6 +2,7 @@ require 'pegex'
 
 class Pegex::Input
   attr_accessor :string
+  attr_accessor :file
 
   def initialize
     @is_eof = false

data/lib/pegex/parser.rb

@@ -1,11 +1,15 @@
 require 'pegex/input'
 
-$pegex_nil = []
-$dummy = [1]
+module Pegex::Constant
+  Null = []
+  Dummy = []
+end
 
 class Pegex::Parser
   attr_accessor :grammar
   attr_accessor :receiver
+  attr_accessor :input
+
   attr_accessor :parent
   attr_accessor :rule
   attr_accessor :debug
@@ -14,18 +18,16 @@ class Pegex::Parser
     @position = 0
     @farthest = 0
     @optimized = false
-    @debug = false
     @throw_on_error = true
-    # @debug = true
+    @debug = ENV['RUBY_PEGEX_DEBUG'] || $PegexParserDebug || false
     yield self if block_given?
   end
 
   def parse input, start=nil
     @position = 0
-    if input.kind_of? String
-      input = Pegex::Input.new do |i|
-        i.string = input
-      end
+
+    if not input.kind_of? Pegex::Input
+      input = Pegex::Input.new {|i| i.string = input}
     end
     @input = input
     @input.open unless @input.open?
@@ -40,18 +42,20 @@ class Pegex::Parser
       (@tree['TOP'] ? 'TOP' : nil) or
         fail "No starting rule for Pegex::Parser::parse"
 
-    optimize_grammar start_rule_ref
+    optimize_grammar(start_rule_ref)
 
-    fail  "No 'receiver'. Can't parse" unless @receiver
+    fail "No 'receiver'. Can't parse" unless @receiver
 
-    # XXX does ruby have problems with circulat references
+    # XXX does ruby have problems with circulat references?
     @receiver.parser = self
 
     if @receiver.respond_to? 'initial'
-      @rule, @parent = $start_rule_ref, {}
+      @rule = start_rule_ref
+      @parent = {}
+      @receiver.initial
     end
 
-    match = match_ref start_rule_ref, {}
+    match = match_ref(start_rule_ref, {})
 
     @input.close
 
@@ -61,7 +65,8 @@ class Pegex::Parser
     end
 
     if @receiver.respond_to? 'final'
-      @rule, @parent = start_rule_ref, {}
+      @rule = start_rule_ref
+      @parent = {}
       match = [ @receiver.final(match.first) ]
     end
 
@@ -72,9 +77,9 @@ class Pegex::Parser
     return if @optimized
     @tree.each_pair do |name, node|
       next if node.kind_of? String
-      optimize_node node
+      optimize_node(node)
     end
-    optimize_node '.ref' => start
+    optimize_node('.ref' => start)
     @optimized = true
   end
 
@@ -88,8 +93,8 @@ class Pegex::Parser
       end
     end
     min, max = node.values_at '+min', '+max'
-    node['+min'] ||= max == nil ? 1 : 0
-    node['+max'] ||= min == nil ? 1 : 0
+    node['+min'] ||= max.nil? ? 1 : 0
+    node['+max'] ||= min.nil? ? 1 : 0
     node['+asr'] ||= nil
     node['+min'] = node['+min'].to_i
     node['+max'] = node['+max'].to_i
@@ -111,12 +116,12 @@ class Pegex::Parser
       node['rule'] = Regexp.new "\\A#{node['.rgx']}"
     end
     if sep = node['.sep']
-      optimize_node sep
+      optimize_node(sep)
     end
   end
 
   def match_next next_
-    return match_next_with_sep next_ if next_['.sep']
+    return match_next_with_sep(next_) if next_['.sep']
 
     rule, method, kind, min, max, assertion =
       next_.values_at 'rule', 'method', 'kind', '+min', '+max', '+asr'
@@ -126,7 +131,7 @@ class Pegex::Parser
     while return_ = method.call(rule, next_)
       position = @position unless assertion
       count += 1
-      match.concat return_ unless return_.equal? $pegex_nil
+      match.concat return_
       break if max == 1
     end
     if max != 1
@@ -134,7 +139,7 @@ class Pegex::Parser
       @farthest = position if (@position = position) > @farthest
     end
     result = (count >= min and (max == 0 or count <= max)) ^ (assertion == -1)
-    if not result or assertion
+    if not(result) or assertion
       @farthest = position if (@position = position) > @farthest
     end
 
@@ -146,53 +151,52 @@ class Pegex::Parser
       next_.values_at 'rule', 'method', 'kind', '+min', '+max', '.sep'
 
     position, match, count, scount, smin, smax =
-      @position, [], 0, 0, sep.values_at('+min', '+max')
-
+      @position, [], 0, 0, *(sep.values_at('+min', '+max'))
     while return_ = method.call(rule, next_)
       position = @position
       count += 1
-      match.concat return_
+      match.concat(return_)
       return_ = match_next(sep) or break
-      match.concat return_
+      match.concat(smax == 1 ? return_ : return_[0]) if !return_.empty?
       scount += 1
     end
-    if max != 1
-      match = [match]
-    end
+    match = [match] if max != 1
     result = count >= min and (max == 0 or count <= max)
     if count == scount and not sep['+eok']
       @farthest = position if (@position = position) > @farthest
     end
 
-    return result ? next_['-skip'] ? [] : match : false
+    return(result ? next_['-skip'] ? [] : match : false)
   end
 
   def match_ref ref, parent
     rule = @tree[ref]
     match = match_next(rule) or return false
-    return $dummy unless rule['action']
+    return Pegex::Constant::Dummy unless rule['action']
     @rule, @parent = ref, parent
     result = rule['action'].call(match.first)
-    return (result.equal? $pegex_nil) ? result : [result]
+    return (result.equal? Pegex::Constant::Null) ? result : [result]
   end
 
   def match_rgx regexp, parent=nil
-    position = @position
-    string = @buffer[position .. -1]
-    (m = string.match regexp) or return false
-    position += m[0].length
+    buffer = @buffer[@position .. -1]
+    (m = buffer.match regexp) or return false
+    @position += m[0].length
+    # TODO use m.captures
     match = m[1..-1]
     match = [ match ] if m.length > 2
-    @farthest = position if (@position = position) > @farthest
+    @farthest = @position if @position > @farthest
     return match
   end
 
   def match_all list, parent=nil
-    position, set, len = @position, [], 0
+    position = @position
+    set = []
+    len = 0
     list.each do |elem|
       if match = match_next(elem)
-        if !elem['+asr'] and !elem['-skip']
-          set.concat match
+        if !(elem['+asr'] or elem['-skip'])
+          set.concat(match)
           len += 1
         end
       else
@@ -206,7 +210,7 @@ class Pegex::Parser
 
   def match_any list, parent=nil
     list.each do |elem|
-      if (match = match_next elem)
+      if (match = match_next(elem))
         return match
       end
     end
@@ -214,18 +218,18 @@ class Pegex::Parser
   end
 
   def match_err error, parent=nil
-    throw_error error
+    throw_error(error)
   end
 
   def match_ref_trace ref, parent
     rule = @tree[ref]
-    trace_on = ! rule['+asr']
-    trace "try_#{ref}" if trace_on
+    trace = ! rule['+asr']
+    trace("try_#{ref}") if trace
     result = nil
-    if (result = match_ref ref, parent)
-      trace "got_#{ref}" if trace_on
+    if (result = match_ref(ref, parent))
+      trace("got_#{ref}") if trace
     else
-      trace "not_#{ref}" if trace_on
+      trace("not_#{ref}") if trace
     end
     return result
   end
@@ -243,13 +247,7 @@ class Pegex::Parser
     $stderr.print indent ? " >#{snippet}<\n" : "\n"
   end
 
-  def throw_error msg
-    raise msg
-  end
-
-  class PegexParseError < RuntimeError
-
-  end
+  class PegexParseError < RuntimeError;end
 
   def throw_error msg
     @error = format_error msg

data/lib/pegex/pegex/ast.rb

@@ -57,20 +57,20 @@ class Pegex::Pegex::AST < Pegex::Tree
       group[@prefixes[prefix]] = 1
     end
     unless suffix.empty?
-      set_quantity group, suffix
+      set_quantity(group, suffix)
     end
     return group
   end
 
   def got_all_group got
-    list = get_group got
+    list = get_group(got)
     fail unless list.length > 0
     return list.first if list.length == 1
     return '.all' => list
   end
 
   def got_any_group got
-    list = get_group got
+    list = get_group(got)
     fail unless list.length > 0
     return list.first if list.length == 1
     return '.any' => list
@@ -96,10 +96,10 @@ class Pegex::Pegex::AST < Pegex::Tree
     if (regex = @atoms[ref])
       @extra_rules[ref] = {'.rgx' => regex}
     end
-    unless suffix.empty?
-      set_quantity node, suffix
+    if !suffix.empty?
+      set_quantity(node, suffix)
     end
-    unless prefix.empty?
+    if !prefix.empty?
       if @prefixes[prefix].kind_of? Array
         key, val = @prefixes[prefix]
       else