abnc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7c05ad333b974b34b0617122a98072125248024
+  data.tar.gz: f0f184042cb6c275da5c848d804e2469fb856909
+SHA512:
+  metadata.gz: 910af8ee601a03a3fa18eb2ba21bc25c4db181d03c6d6aa28975aca59b2a1b81da4a6dbf079d7efdcf663b089500f04f083de6073188a2c742a3236fad87c2fb
+  data.tar.gz: dc9dea38fd3c4b62ac8e72bdfd8addb93fc51d0df776b45b3ed499c29dd342e147b23ae4d7afc7729c91d8d583321452cffb83139bbad3d3f05e2c607191df36

data/abnc.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = "abnc"
+  s.version = "0.1.0"
+  s.summary = "RFC 5234+7405 ABNF compiler-let"
+  s.description = %q{Shifty support for tools based on IETF's ABNF}
+  s.author = "Carsten Bormann"
+  s.email = "cabo@tzi.org"
+  s.license = "Apache 2.0"
+  s.homepage = "http://github.com/cabo/abnc"
+  s.has_rdoc = false
+  s.files = Dir['lib/**/*.rb'] + %w(abnc.gemspec)
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.require_paths = ["lib"]
+end

data/lib/abnc.rb

@@ -0,0 +1,176 @@
+require 'parse/parser'
+require 'parse/builder'
+require 'parse/ast'
+
+module Peggy
+
+  # Implements the RFC 4234 ABNF, one of several grammars supported.
+  #
+  # Keep in mind, though, that the ABNF semantics is that of a BNF,
+  # i.e., non-deterministic; while the packrat parser underlying peggy
+  # is a PEG parser, which cuts decision points once a successful
+  # parse is made.  You may have to exchange alternatives, e.g., for
+  # parsing ABNF itself using ABNF, you have to change RFC 4234's rule
+  #   repeat         =  1*DIGIT / (*DIGIT "*" *DIGIT)
+  # into
+  #   repeat         =  (*DIGIT "*" *DIGIT) / 1*DIGIT
+  # as otherwise "1*(...)" will start to parse as the first
+  # alternative and never try the second.
+
+  class ABNF < Builder
+
+    class ABNFParser < Builder
+
+      def initialize
+        super
+        build
+      end
+
+    private
+
+      def build
+        self.ignore_productions = [:ws, :s]
+
+        grammar{seq{many{prod}; eof}}
+        prodname{lit /[A-Za-z][-A-Za-z0-9]*/}
+        ws{lit /(?:[ \t\n]|;[^\n]*\n)+/}
+        s{opt{ws}}
+        prod{seq{prodname; s; lit '='; s; prodalt; s}}
+        prodalt{seq{
+            prodterm
+            many{seq{s; lit '/'; s; prodterm}}
+          }}
+        prodterm{seq{
+            prodatom
+            many{
+              seq {s; prodatom}
+            }
+          }}
+        prodatom{
+          alt {
+            numlit
+            casese
+            seq{opt{lit "%i"}; casein}
+            seq{prodname; neg{seq{s; lit '='}}}
+            optgroup
+            repgroup            # XXX: specific repetition is missing
+            group
+          }
+        }
+        numlit{alt{
+            lit /%x[0-9A-Fa-f][0-9A-Fa-f]([-.][0-9A-Fa-f][0-9A-Fa-f])*/
+            lit /%d[0-9]+([-.][0-9]+)*/
+          }}
+        casein{lit /"[^"]+"/} # "
+        casese{lit /%s"[^"]+"/} # "
+        optgroup{seq{lit "["; s; prodalt; s; lit "]"}}
+        group{seq{lit "("; s; prodalt; s; lit ")"}}
+        repgroup{seq{repspec; prodatom}}
+        repspec{lit /[0-9]*\*[0-9]*/}
+      end
+    end # ABNFParser
+
+    def compile! text, options={}
+      reset!
+      compiler = ABNFParser.new
+# puts compiler
+      # compiler.debug_flag = true
+      result = compiler.parse? :grammar, text
+#pp compiler.parse_results
+      # raise "Invalid ABNF grammar" unless result
+      grammar = compiler.ast? :ignore=>:s #options
+###puts grammar
+      raise "Invalid ABNF grammar at char #{compiler.parse_results.keys.max}" unless result
+      grammar.each :prod do |definition|
+        send(symbolize(definition.prodname.to_s)) do
+          build_prodalt definition.prodalt
+        end
+      end
+#puts to_s
+    end
+
+    private
+
+    def symbolize name
+      name = name.downcase.gsub(/-/, "_")
+      if (Node.methods.include? name)
+        name = "p_" + name
+      end
+      name.to_sym
+    end
+
+    def build_prodalt prodalt
+      if prodalt._count(:prodterm) == 1
+        build_prodterm prodalt.prodterm
+      else
+        alt do
+          prodalt.each :prodterm do |prodterm|
+            build_prodterm prodterm
+          end
+        end
+      end
+    end
+
+    def build_prodterm prodterm
+      if prodterm._count(:prodatom) == 1
+        build_prodatom prodterm.prodatom
+      else
+        seq do
+          prodterm.each :prodatom do |prodatom|
+            build_prodatom prodatom
+          end
+        end
+      end
+    end
+
+    def build_prodatom prodatom
+      if c = prodatom.numlit
+        /^%([xd])([0-9A-Fa-f]+)(.*)/ =~ c.to_s
+        m = {"x" => :hex, "d" => :to_i}[$1];
+        r = $2.send(m).chr
+        s = $3
+        if s != ''
+          if s[0..0] == '.'
+            r += s[1..-1].split('.').map{ |x| x.send(m).chr}.join('')
+          else                  # XXX: need to barf if more than one...
+            t = s[1..-1].send(m).chr
+            r = /[#{r}-#{t}]/
+          end
+        end
+        lit r
+      elsif c = prodatom.casein
+        lit /(?i:#{Regexp.escape(c.to_s[1..-2])})/
+      elsif c = prodatom.casese
+        lit /#{Regexp.escape(c.to_s[3..-2])}/
+      elsif c = prodatom.prodname
+        send(symbolize(c.to_s))
+      elsif c = prodatom.optgroup
+        opt {
+          build_prodalt c.prodalt
+        }
+      elsif c = prodatom.repgroup
+        /^([0-9]*)\*([0-9]*)/ =~ c.repspec.to_s
+        minr = $1 == "" ? 0 : $1.to_i
+        maxr = $2 == "" ? nil : $2.to_i
+        case [minr, maxr]
+        when [1, nil]
+          m = :some
+        when [0, nil]
+          m = :many
+        when [0, 1]
+          m = :opt
+        else             # This needs a better way to access Multiple!
+          raise "repgroup -- not implemented: #{c.repspec.to_s}"
+        end
+        send(m) {
+          build_prodatom c.prodatom
+        }
+      elsif c = prodatom.group
+        build_prodalt c.prodalt
+      else
+        raise "prodatom strangeness"
+      end
+    end
+
+  end #ABNF
+end # Peggy

data/lib/parse/ast.rb

@@ -0,0 +1,226 @@
+# Peggy packrat parster for Ruby
+# 
+# ast.rb - Abstract Syntax Tree
+#
+# Copyright (c) 2006 Troy Heninger
+#
+# Peggy is copyrighted free software by Troy Heninger.
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+module Peggy
+
+  # A node in an Abstract Syntax Tree. Every node in the tree maps to a production 
+  # found in the parse. You can navigate to the node's parent, first child, or next 
+  # sibling. Nodes know their range of the source text.
+  class Node
+    include Enumerable
+  
+    attr_accessor :_name, :_first, :_next, :_parent, :_range, :_source
+    
+    # Constructor
+    def initialize name
+      self._name = name
+    end
+    
+    # Add a child.
+    def << child
+      child._parent = self
+#puts "#{_name}[first #{_first} last #{_last}] << child #{child._name}"
+      if _first
+        _last._next = child
+      else
+        self._first = child
+      end
+    end
+    
+    # Iterate over each child. If name is supplied only nodes matching the name are iterated.
+    def each name=nil
+      child = _first
+      while child
+        yield child if name.nil? || name == child._name
+        child = child._next
+      end
+    end
+
+    def children name=nil
+      a = []
+      each(name) do |node|
+        a << node
+      end
+      a
+    end
+
+    # Count the children. If name is supplied only nodes matching the name are counted.
+    def _count name=nil
+      c = 0
+      each do |node|
+        c += 1 if name.nil? || name == node._name
+      end
+      c
+    end
+    
+    # Get the number of nodes up to the root.
+    def _depth
+      depth = 0
+      node = self
+      depth += 1 while node=node._parent
+      depth
+    end
+    
+    # Get the root node.
+    def _root
+      node = self
+      while (n2 = node._parent)
+        node = n2
+      end
+      node
+    end
+    
+    # Get an option set when tree was created.
+    def _option option, default=nil
+      options = _root._options
+      return nil unless options
+      options[option] || options[option.to_sym] || default
+    end
+    
+    # Get the length of the range.
+    def _length
+      _range.last - _range.first
+    end
+
+    # Get some or all of the source text covered by this node, depending on the length.
+    def _sample
+      return nil if _length == 0
+      str = _source[_range]
+      (str.length >= 40 ? str[0, 37] + '...' : str).inspect
+    end
+    
+    # Format the node pretty printing.
+    def _format
+      result = "#{'  '*_depth}#{_name} #{_sample}\n"
+      each do |node|
+        result << node._format
+      end
+      result
+    end
+    
+    # Get the last child.
+    def _last
+      node = _first
+      return nil unless node
+      while (n2 = node._next)
+        node = n2
+      end
+      node
+    end
+    
+    # Get the contents for inspection.
+    def inspect
+      "#{_name ? _name : self.class}[#{_range}] #{to_s.inspect}"
+    end
+    
+    # Get the source text minus any ignored nodes.
+    def _strip
+      return @str if @str
+      str0 = str = _source[_range]
+      return @str = str unless (ignore = _option :ignore) && _first
+      remove = find_all{|node| node._name == ignore}
+      remove.reverse_each do |node|
+        from = node._range.first - _range.first
+        str = str[0, from] + str[from + node._length..-1]
+      end
+# puts "before #{str0.inspect}, after #{str.inspect}" unless remove.empty?
+      @str = str
+    end
+    
+    # Get the source text covered by this node.
+    def to_s
+      _source[_range]
+    end
+    
+    # Get the stripped text as a Symbol.
+    def to_sym
+      _strip.to_sym
+    end
+    
+    # Get the first node of the given name as a Symbol.
+    def [] name
+      method_missing name.to_sym
+    end
+
+    def method_missing name, *args
+      find {|node| name == node._name}
+    end
+
+  end
+  
+  # The root node of an Abstract Syntax Tree. Every node in the tree maps to a production 
+  # found in the parse.
+  class AST < Node
+  
+    attr_reader :_options
+    
+    def initialize source, results, options={}
+      super nil
+      @results = results
+      @_options = options
+      @ignore = Array(options[:ignore]) # XXX: turn to set
+      self._source = source
+      build_left nil, 0, self
+    end
+
+    def to_s
+      _format
+    end
+    
+  private
+
+    def build_left parent, index, node=nil
+      result = parent ? parent._range.last : index
+      row = @results[index]
+      return result unless row
+      order = row[:found_order]
+      return result unless order
+      order.reverse_each do |name|
+        continue if @ignore.include? name
+        to = row[name]
+        if node
+          node._name = name
+        else
+          node = Node.new name
+        end
+        node._range = index...to
+        node._source = _source
+#puts "Built #{node.to_s}"
+        parent << node if parent
+        build_children parent, to if parent && to > index && to < parent._range.last
+        parent = node
+        node = nil
+      end
+      result
+    end
+
+    def build_children parent, index
+      while index < parent._range.last
+        i2 = build_left parent, index
+        break if i2 <= index
+        index = i2
+      end
+    end
+
+  end
+  
+  class Parser
+
+    # Create an Abstract Syntax Tree from the parse results. You must call parse?() prior to
+    # this. Valid options:
+    # * :ignore=>[symbol of element to ignore]
+    def ast? options={}
+      ast = AST.new source_text, parse_results, options
+#puts ast
+      ast
+    end
+
+  end
+
+end # Peggy

data/lib/parse/builder.rb

@@ -0,0 +1,460 @@
+# Peggy packrat parser for Ruby
+# 
+# builder.rb - parser builder
+#
+# Copyright (c) 2006 Troy Heninger
+#
+# Peggy is copyrighted free software by Troy Heninger.
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'parse/parser'
+
+module Peggy
+
+  # Base syntax element class.
+  class Element
+    # Create an element.
+    def self::build *args
+      new *args
+    end
+    
+    # Test to see if there is a match of this element at the current index.
+    # Return's the index following if match is found, or NO_MATCH if not
+    def match parser, index
+      raise "Must override match"
+    end
+    
+    # Used for debugging.
+    def report index
+      # puts "#{to_s} #{index}"
+      index
+    end
+  end
+  
+  # An element with a single child element.
+  module OneChild
+    # The single child
+    attr_accessor :child
+    
+    # synonym for child=(element)
+    alias :<< :child=
+    
+    # Convert to String.
+    def to_s
+      wrap
+    end
+    
+    # Enclose child in parentheses if appropriate.
+    def wrap
+      result = child.respond_to?(:each) ? "(#{child})" : child.to_s
+    end
+  end
+
+  # An element that matches a sequence of elements.  All must match for the sequence to match.
+  class Sequence < Element
+    # Add a child element.
+    def add element
+      @list = [] unless @list
+      @list << element
+    end
+
+    # Synonym for add(element)
+    alias :<< :add
+    
+    # Reference a child by index.
+    def [] index
+      @list[index]
+    end
+    
+    # Child iterator.
+    def each &blk
+      @list.each &blk
+    end
+    
+    # Match each child in sequence. If any fail this returns NO_MATCH. If all succeed this 
+    # returns the end index of the last.
+    def match parser, index
+      raise "no children added to sequence" unless @list
+      each do |element|
+        index = element.match parser, index
+        return NO_MATCH unless index
+      end
+      report index
+    end
+    
+    # Convert element to String.
+    def to_s
+      @list.map{|el| el.to_s}.join ' '
+    end
+  end
+  
+  # An element which matches any one of its children. The children are tested in order. The first
+  # to match wins.
+  class Alternatives < Sequence
+    # Match any one of the children. The children are tried in order. The first to match wins.
+    # The result is the end index of the first matching child. If none match this returns NO_MATCH.
+    def match parser, index
+      raise "no children added to alternate" unless @list
+      each do |element|
+        found = element.match parser, index
+        return report(found) if found
+      end
+      report NO_MATCH
+    end
+    
+    # Convert element to String.
+    def to_s
+      @list.map{|el| el.to_s}.join ' | '
+    end
+  end
+  
+  # An element which tries its single child multiple times. It is greedy, meaning it will continue 
+  # to match as long as possible, unless the range specifies a maximum number of matches.
+  class Multiple < Element
+    include OneChild
+    
+    # A big number
+    MANY = 32767
+    # The minimum and maximum number of tries
+    attr_accessor :range
+
+    # Init the range
+    def initialize range
+      @range = range
+    end
+    
+    # Matches the child multiple times. The range specifies the least and most number of matches.
+    # If the number of matches is less than the minimim of the range then NO_MATCH is returned.
+    # If equal or more than the minimim then the end index of the last match is returned.
+    def match parser, index
+      raise "multiple element child not set" unless child
+      raise "multiple element range not set" unless range
+      count = 0
+      while count < range.last
+        found = child.match parser, index
+        break unless found
+        index = found
+        count += 1
+      end
+      report range === count ? index : NO_MATCH
+    end
+    
+    # Convert element to String.
+    def to_s
+      "#{wrap}{#{range.min}..#{range.max}}"
+    end
+  end
+  
+  # Matcher of 0 or more times.
+  class AnyNumber < Multiple
+    def initialize
+      super 0..MANY
+    end
+    
+    # Convert element to String.
+    def to_s
+      "#{wrap}*"
+    end
+  end
+  
+  # Matcher of 1 or more times.
+  class AtLeastOne < Multiple
+    def initialize
+      super 1..MANY
+    end
+    
+    # Convert element to String.
+    def to_s
+      "#{wrap}+"
+    end
+  end
+  
+  # Matcher of 0 or 1 time.
+  class Optional < Multiple
+    def initialize
+      super 0..1
+    end
+    
+    # Convert element to String.
+    def to_s
+      "#{wrap}?"
+    end
+  end
+  
+  # An element which tries its single child but does not advance the index if found.
+  # Predicates control parse decisions.
+  class Predicate < Element
+    include OneChild
+  end
+    
+  # Positive Predicate.
+  # If found the original index is returned. If not NO_MATCH is returned.
+  class Positive < Predicate
+   
+    # Matches the child once. If found the original index is returned.
+    # If not found NO_MATCH is returned.
+    def match parser, index
+      raise "positive element child not set" unless child
+      found = child.match parser, index
+      found ? index : NO_MATCH
+    end
+    
+    # Convert element to String.
+    def to_s
+      "&#{wrap}"
+    end
+  end
+  
+  # Negative Predicate.
+  # If not found the original index is returned. If found NO_MATCH is returned.
+  class Negative < Predicate
+   
+    # Matches the child once. If not found the original index is returned.
+    # If found NO_MATCH is returned.
+    def match parser, index
+      raise "negative element child not set" unless child
+      found = child.match parser, index
+      found ? NO_MATCH : index
+    end
+    
+    # Convert element to String.
+    def to_s
+      "!#{wrap}"
+    end
+  end
+  
+  # Match another production in the grammar.
+  class Reference < Element
+    # The name of the production to lookup and match.
+    attr_reader :name
+
+    # Init the name
+    def initialize name=nil
+      self.name = name
+    end
+
+    # Set the name of production to match.
+    def name= value
+      @name = value.to_sym
+    end
+
+    # Match the entire production from the parser grammar. If it matches
+    # the end index is returned. If not, NO_MATCH is returned.
+    def match parser, index
+      raise "reference name not set" unless name
+      parser.match? name, index
+    end
+    
+    # Convert element to String.
+    def to_s
+      @name
+    end
+  end
+  
+  # Matcher of a grammar production. The one and only child defines the production.
+  class Production < Reference
+    include OneChild
+    
+    # The production definition.
+    attr_accessor :child
+
+    # Init the name and child.
+    def initialize name=nil, child=nil
+      super name
+      @child = child
+    end
+
+    # Synonym of child=(element)
+    alias :<< :child=
+    
+    # Match the production one time. If it matches the end index is returned. If not,
+    # NO_MATCH is returned.
+    def match parser, index
+      raise "production name not set" unless name
+      raise "production child not set" unless child
+      report @child.match(parser, index)
+    end
+    
+    # Convert element to String.
+    def to_s
+      "#{name}: #{child}"
+    end
+  end
+  
+  # Matcher of a literal string or regular expression.
+  class Literal < Element
+    # Value to match.
+    attr_reader :value
+    
+    # Init the value.
+    def initialize value=nil
+      @value = value
+    end
+
+    # Set the value to match.
+    def value= literal
+      # Make sure regular expressions check at the beginnig of the string
+      literal = correct_regexp literal if literal.is_a? Regexp
+      @value = literal
+    end
+    
+    # Match the literal value. If it matches the end index is returned.
+    # If no, NO_MATCH is returned.
+    def match parser, index
+      report parser.literal?(value, index)
+    end
+    
+    # Convert element to String.
+    def to_s
+      value.inspect
+    end
+  end
+
+  # Parser builder. The built in methods create syntax elements. Any other
+  # method called on this object create references to production, or actual
+  # productions, if called at the top level.
+  # Todo: Change to a class and separate from Parser.
+  class Builder < Parser
+    # Productions to build
+    attr_reader :productions
+    # Current parent being built
+    attr_reader :parent
+    
+    # Constructor
+    def initialize
+      reset!
+    end
+    
+    # Clear the parser and prepare it for a new parse.
+    def reset!
+      @building = true
+      @productions = {}
+    end
+
+    # Reference a production by its name index.
+    def [] index
+      productions[index]
+    end
+    
+    # Create a production if at the top level, or a reference to a production a 
+    # production is being built.
+    def method_missing name, *args
+      if @building
+        if @parent
+          ref = Reference.new name
+          @parent << ref
+        elsif block_given?
+          prod = Production.new name
+          @parent = prod
+          yield
+          @parent = nil
+          @productions[name] = prod
+        else
+          super
+        end
+      else
+        prod = @productions[name]
+# pp name.inspect, @productions.keys unless prod
+        super unless prod
+# puts "matching #{name} at #{args.first}"
+        prod.match self, args.first
+      end
+    end
+
+    # Build an Alternatives element.
+    def alt &blk
+      build_piece Alternatives, blk
+    end
+    # Synonym for alt().
+    alias :one :alt
+  
+    # Build or match the end of file element. If currently building, a Reference to eof 
+    # is built. Otherwise eof is matched. 
+    def eof *args
+      if @building
+        method_missing :eof, *args
+      else
+        super args.first
+      end
+    end
+    
+    # Build a Sequence element.
+    def seq &blk
+      build_piece Sequence, blk
+    end
+    # Synonym for each()
+    alias :each :seq
+  
+    # Add an Literal element to the parent.
+    def lit *values
+      if values.size == 1
+        build_piece Literal, nil, values.first
+      else
+        one{
+          for v in values
+            build_piece Literal, nil, v
+          end
+        }
+      end
+    end
+  
+    # Build an AnyNumber element.
+    def many &blk
+      build_piece AnyNumber, blk
+    end
+  
+    # Build an Optional element.
+    def opt &blk
+      build_piece Optional, blk
+    end
+  
+    # Build an AtLeastOne element.
+    def some &blk
+      build_piece AtLeastOne, blk
+    end
+
+    # Build a negative predicate. Use when you want to make sure the enclosed element is not present.
+    # The cursor is not advanced for predicates.
+    def neg &blk
+      build_piece Negative, blk
+    end
+
+    # Build a positive predicate. Use when you want to make sure the enclosed element is present.
+    # If matched the cursor is not advanced.
+    def pos &blk
+      build_piece Positive, blk
+    end
+
+    # Invokes the parser from the beginning of the source on the given production goal.
+    # You may provide the source here or you can set source_text prior to calling.
+    # If index is provided the parser will ignore characters previous to it.
+    def parse? goal, source=nil, index=0
+      @building = nil
+      super
+    end
+    
+    # Convert productions to Peggy grammar. This is notable to out put any Ruby parse methods, 
+    # only grammars built with Builder methods.
+    def to_s
+      productions.values.join "\n"
+    end
+
+  private
+    
+    # Add an object of klass to the parent and yield to its block. If 
+    # value is specified it is passed to the klass constructor.
+    def build_piece klass, blk=nil, value=nil
+# puts "building #{klass.name} with #{value.inspect}"
+      elem = value ? klass.new(value) : klass.new
+      @parent << elem
+      if blk
+        parent = @parent
+        @parent = elem
+        blk.call
+        @parent = parent
+      end
+    end
+    
+  end # Builder
+
+end # Peggy

data/lib/parse/parser.rb

@@ -0,0 +1,252 @@
+# Peggy packrat parster for Ruby
+# 
+# parser.rb - packrat parser
+#
+# Copyright (c) 2006 Troy Heninger
+#
+# Peggy is copyrighted free software by Troy Heninger.
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'pp'
+
+# Peggy is a packrat parsing engine. Packrat parsers memoize every production so that 
+# parses can happen in linear time. No production needs to be processed more than once for 
+# a given position of the source. See http://pdos.csail.mit.edu/~baford/packrat/ for
+# more details. 
+# 
+# Peggy also incorporates Parsing Expression Grammar (PEG) as proposed by Bryan Ford,
+# as one of several input grammars. PEG is a formalized grammar specification needing 
+# no separate lexer/scanner step. See http://pdos.csail.mit.edu/~baford/packrat/popl04/
+# 
+# As good as packrat parsers are, they have a few limitations. They cannot handle left
+# recursion of a production, meaning a production cannot reference itself as the first
+# element in a sequence. Also memoizing of production results means than memory consumption
+# increasses with the size of the source being parsed. This is not usually a concern, execpt
+# when attempting to parse multi-megabyte source files, such as a huge XML database.
+module Peggy
+
+  # Returned when a production did not match
+  NO_MATCH = false
+  # Used to prevent infinite (left) recursions
+  IN_USE = true
+  
+#  class OrderedHash < Hash
+#    alias_method :store, :[]=
+#    alias_method :each_pair, :each
+#
+#    def initialize
+#      @keys = []
+#      super
+#    end
+#
+#    def []=(key, val)
+#      @keys << key
+#      super
+#    end
+#
+#    def delete(key)
+#      @keys.delete(key)
+#      super
+#    end
+#
+#    def each
+#      @keys.sort.each { |k| yield k, self[k] }
+#    end
+#
+#    def each_key
+#      @keys.sort.each { |k| yield k }
+#    end
+#
+#    def each_value
+#      @keys.sort.each { |k| yield self[k] }
+#    end
+#  end
+  
+  # Packrat parser class. Note all methods have a trailing exclamation (!) or question 
+  # mark (?), or have long names with underscores (_). This is because productions are 
+  # methods and we need to avoid name collisions. To use this class you must subclass 
+  # Parser and provide your productions as methods. Your productions must call match? 
+  # or one of the protected convenience routines to perform parsing. Productions must 
+  # never call another production directly, or results will not get memoized and you 
+  # will slow down your parse conciderably, and possibly risk getting into an infinite 
+  # recursion (until the stack blows its top). Note, as a conveience in writting 
+  # productions, you can call any match? function multiple times, passing each returned 
+  # index, such as in a sequence, without checking the results of each production.
+  class Parser
+    
+    # Tells parser to print intermediate results if set.
+    attr_accessor :debug_flag
+
+    # The source to parse, can be set prior to calling parse!().
+    attr_accessor :source_text
+    
+    # The results of the parse. A hash (keys of indexs) of hashes (keys of production 
+    # symbols and values of end indexes.
+    attr_reader :parse_results
+
+    # The productions to ignore.
+    attr_accessor :ignore_productions
+
+    # Return a range (or character) of the source_text.
+    def [] range
+      raise "source_text not set" if source_text.nil?
+      source_text[range]
+    end
+
+    # Invokes the parser from the beginning of the source on the given production goal.
+    # You may provide the source here or you can set source_text prior to calling.
+    # If index is provided the parser will ignore characters previous to it.
+    def parse? goal, source = nil, index = 0
+      self.source_text = source unless source.nil?
+        # Hash of automatic hashes
+      @parse_results = Hash.new {|h1, k1| h1[k1] = {}} # OrderedHash.new {|h1, k1| h1[k1] = {}}
+      @keys = nil
+      index = match? goal, index
+      pp(parse_results) if debug_flag
+      index
+    end
+
+    # Queries the parse results for a heirarchy of production matches. An array of 
+    # index ranges is returned, or an empny array if none are found. This can only be 
+    # called after parse_results have been set by a parse.
+    def query? *args
+      raise "You must first call parse!" unless parse_results
+      @keys = @parse_results.keys.sort unless @keys
+      found_list = []
+      index = 0
+      args.each do |arg|
+        index = find? arg, index
+      end
+    end
+    
+    # Try to match a production from the given index. Returns the end index if found 
+    # or start index if not found.
+    def allow? goal, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      found = match? goal, index
+      found == NO_MATCH ? index : found
+    end
+    
+    # Try to match a production from the given index then backtrack. Returns index if 
+    # found or NO_MATCH if not.
+    def check? goal, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      found = match? goal, index
+      found == NO_MATCH ? NO_MATCH : index
+    end
+    
+    # Try not to match a production from the given index then backtrack. Returns index 
+    # if not found or NO_MATCH if found.
+    def dissallow? goal, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      found = match? goal, index
+      found == NO_MATCH ? index : NO_MATCH
+    end
+    
+    # Special production that only matches the end of source_text. Note, this function
+    # does not end in (?) or (!) because it is meant be used as a normal production.
+    def eof index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      index >= source_text.length ? index : NO_MATCH
+    end
+    
+    # Match a production from the given index. Returns the end index if found or NO_MATCH
+    # if not found.
+    def match? goal, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      index = ignore? index unless @ignoring
+      goal = goal.to_sym
+      position = parse_results[index]
+      found = position.fetch(goal) do
+        position[goal] = IN_USE # used to prevent inifinite recursion in case user attemts 
+                                # a left recursion
+        _memoize goal, index, send(goal, index), position
+      end
+      puts "found #{goal} at #{index}...#{found} #{source_text[index...found].inspect}" if found && debug_flag
+      raise "Parser cannot handle infinite (left) recursions. Please rewrite usage of '#{goal}'." if found == IN_USE
+      found
+    end
+    
+    # Record the results of the parse in the parse_results memo.
+    def _memoize goal, index, result, position = parse_results[index]
+      if result
+        position[:found_order] = [] unless position.has_key?(:found_order)
+        position[:found_order] << goal
+position[goal.to_s] = source_text[index...result] if result - index < 40 && goal.is_a?(Symbol)
+      end
+      position[goal] = result if result || goal.is_a?(Symbol)
+      result
+    end
+
+    # Match tokens that should be ignored. Used by match?(). Returns end index if found 
+    # or start index if not found. Subclasses should override this method if they wish 
+    # to ignore other text, such as comments.
+    def ignore? index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      return index if @ignoring || ignore_productions.nil?
+      @ignoring = true
+      ignore_productions.each do |prod|
+        index = allow? prod, index
+      end
+      @ignoring = nil
+      index
+    end
+
+    # Match a literal string or regular expression from the given index. Returns 
+    # the end index if found or NO_MATCH if not found.
+    def literal? value, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      case value
+      when String
+        string? value, index
+      when Regexp
+        regexp? value, index
+      else
+        raise "Unknown literal: #{value.inspect}"
+      end
+    end
+
+    # Match a string from the given index. Returns the end index if found 
+    # or NO_MATCH if not found.
+    def string? value, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      value = value.to_s
+      index = ignore? index unless @ignoring
+      i2 = index + value.length
+# puts source_text[index...i2].inspect + ' ' + value.inspect
+      _memoize(value, index, source_text[index...i2] == value ? i2 : NO_MATCH)
+    end
+
+    # Match a regular expression from the given index. Returns the end index 
+    # if found or NO_MATCH if not found.
+    def regexp? value, index
+      return NO_MATCH if index == NO_MATCH # allow users to not check results of a sequence
+      value = correct_regexp! value
+      index = ignore? index unless @ignoring
+      found = value.match source_text[index..-1]
+# puts "#{value.inspect} ~= #{found[0].inspect}" if found
+      _memoize(value, index, found ? found.end(0) + index : NO_MATCH)
+    end
+    
+    # Make sure regular expressions match the beginning of the string, actually from 
+    # the string from the given index.
+    def correct_regexp! re
+      source = re.source
+      source[0..1] == '\\A' ? re : Regexp.new("\\A(#{source})", re.options)
+    end
+    
+  protected
+    
+    # Create an index of the parse results. Todo: unfinished.
+    def index_results!
+      raise "You must first call parse!" unless parse_results
+      @index = new Hash {|h, k| h[k] = []}
+      parse_results.each_pair do |index, prod_map|
+        prod_map[:found_order].reverse_each
+        prod_map.each_value
+        @index[prod]
+      end
+    end
+  end # Parser
+
+end # Peggy

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: abnc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carsten Bormann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-25 00:00:00.000000000 Z
+dependencies: []
+description: Shifty support for tools based on IETF's ABNF
+email: cabo@tzi.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- abnc.gemspec
+- lib/abnc.rb
+- lib/parse/ast.rb
+- lib/parse/builder.rb
+- lib/parse/parser.rb
+homepage: http://github.com/cabo/abnc
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: RFC 5234+7405 ABNF compiler-let
+test_files: []
+has_rdoc: false