ghazel-parslet 1.4.0.1

data/lib/parslet/atoms/re.rb

@@ -0,0 +1,38 @@
+# Matches a special kind of regular expression that only ever matches one
+# character at a time. Useful members of this family are: <code>character
+# ranges, \\w, \\d, \\r, \\n, ...</code>
+#
+# Example: 
+#
+#   match('[a-z]')  # matches a-z
+#   match('\s')     # like regexps: matches space characters
+#
+class Parslet::Atoms::Re < Parslet::Atoms::Base
+  attr_reader :match, :re
+  def initialize(match)
+    super()
+
+    @match = match.to_s
+    @re    = Regexp.new(self.match, Regexp::MULTILINE)
+    @error_msgs = {
+      :premature  => "Premature end of input", 
+      :failed     => "Failed to match #{match.inspect[1..-2]}"
+    }
+  end
+
+  def try(source, context)
+    return succ(source.consume(1)) if source.matches?(re)
+    
+    # No string could be read
+    return context.err(self, source, @error_msgs[:premature]) \
+      if source.chars_left < 1
+        
+    # No match
+    return context.err(self, source, @error_msgs[:failed])
+  end
+
+  def to_s_inner(prec)
+    match.inspect[1..-2]
+  end
+end
+

data/lib/parslet/atoms/repetition.rb

@@ -0,0 +1,63 @@
+
+# Matches a parslet repeatedly. 
+#
+# Example: 
+#
+#   str('a').repeat(1,3)  # matches 'a' at least once, but at most three times
+#   str('a').maybe        # matches 'a' if it is present in the input (repeat(0,1))
+#
+class Parslet::Atoms::Repetition < Parslet::Atoms::Base  
+  attr_reader :min, :max, :parslet
+  def initialize(parslet, min, max, tag=:repetition)
+    super()
+
+    @parslet = parslet
+    @min, @max = min, max
+    @tag = tag
+    @error_msgs = {
+      :minrep  => "Expected at least #{min} of #{parslet.inspect}"
+    }
+  end
+  
+  def try(source, context)
+    occ = 0
+    accum = [@tag]   # initialize the result array with the tag (for flattening)
+    start_pos = source.pos
+    
+    break_on = nil
+    loop do
+      success, value = parslet.apply(source, context)
+
+      break_on = value
+      break unless success
+
+      occ += 1
+      accum << value
+      
+      # If we're not greedy (max is defined), check if that has been reached. 
+      return succ(accum) if max && occ>=max
+    end
+    
+    # Last attempt to match parslet was a failure, failure reason in break_on.
+    
+    # Greedy matcher has produced a failure. Check if occ (which will
+    # contain the number of sucesses) is >= min.
+    return context.err_at(
+      self, 
+      source, 
+      @error_msgs[:minrep], 
+      start_pos, 
+      [break_on]) if occ < min
+      
+    return succ(accum)
+  end
+  
+  precedence REPETITION
+  def to_s_inner(prec)
+    minmax = "{#{min}, #{max}}"
+    minmax = '?' if min == 0 && max == 1
+
+    parslet.to_s(prec) + minmax
+  end
+end
+

data/lib/parslet/atoms/rule.rb

@@ -0,0 +1,12 @@
+
+class Parslet::Atoms::Rule < Parslet::Atoms::Entity
+  alias_method :eval_rule_body, :try
+
+  def try(source, context)
+    Position.new(source.pos, source, context, self).apply_rule
+  end
+
+end
+
+require 'parslet/atoms/rule/position'
+

data/lib/parslet/atoms/rule/position.rb

@@ -0,0 +1,143 @@
+# Update/fetch parsed entry at a given position in source
+# Eval rule body at a given position in source and cache the result
+class Parslet::Atoms::Rule::Position < Struct.new(:pos, :source, :context, :rule)
+  class MemoEntry < Struct.new(:answer, :pos)
+  end
+
+  # A LR is info holder for left recursion
+  #   seed: the last left recursion exp parse result
+  #   rule: the rule starting left recursion
+  #   head: when left recursion detected, head holds info to re-eval involved rules
+  class LR < Struct.new(:seed, :rule, :pos, :head)
+    class Head < Struct.new(:rule, :involved_rules, :eval_rules)
+      def involved?(rule)
+        self.rule == rule || self.involved_rules.include?(rule)
+      end
+
+      def eval?(rule)
+        eval_rules.include?(rule)
+      end
+
+      def exclude_eval_rule!(rule)
+        eval_rules.delete(rule)
+      end
+
+      def reset_eval_rules
+        self.eval_rules = self.involved_rules.dup
+      end
+    end
+
+    alias :answer :seed
+
+    def detected?
+      self.head != nil
+    end
+
+    def setup_for_re_eval_involved_rules(lr_stack)
+      self.head ||= Head.new(rule, [], [])
+      lr_stack.top_down do |lr|
+        return if lr.head == self.head
+        lr.head = self.head
+        self.head.involved_rules.push lr.rule
+      end
+    end
+  end
+
+  module Context
+    def entry=(entry)
+      context.set rule, pos, entry
+    end
+
+    def entry
+      context.lookup(rule, pos)
+    end
+
+    def head
+      context.heads[pos]
+    end
+
+    def head=(h)
+      context.heads[pos] = h
+    end
+
+    def lr_stack
+      context.lr_stack
+    end
+  end
+
+  include Context
+
+  def apply_rule
+    result = recall
+    if result.nil?
+      # Eval rule body with LR supported by
+      # placing a LR flag before eval rule body
+      # and growing LR seed after detected LR
+      lr = LR.new(fail('left recursion detected'), self.rule, self.pos)
+      lr_stack.push(lr)
+      self.entry = lr
+      self.entry = eval_rule_body
+      lr_stack.pop
+      if self.entry.first && lr.detected?
+        grow_lr(lr.head)
+      end
+      result = self.entry
+    elsif result.is_a?(LR)
+      # Find out all involved lrs in stack
+      # Collect rules of involved lrs
+      # And set head of involved lrs for re-eval
+      # rules in recall process
+      result.setup_for_re_eval_involved_rules(lr_stack)
+    end
+    source.pos = result.pos
+    result.answer
+  end
+
+  private
+  def recall
+    # if not growing a seed parse, just return what is stored
+    # in the memo table
+    return self.entry if self.head.nil?
+    # do not evaluate any rule that is not involved in this
+    # left recursion
+    # question: why self.entry.nil?
+    if self.entry.nil? && !self.head.involved?(self.rule)
+      return fail('not involved in head left recursion')
+    end
+
+    # allow involved rules to be evaluated, but only once
+    # during a seed-growing iteration
+    if self.head.eval?(self.rule)
+      self.head.exclude_eval_rule!(self.rule)
+      self.entry = eval_rule_body
+    end
+    self.entry
+  end
+
+  # Tries to grow the parse of rule at given position
+  def grow_lr(h)
+    self.head = h
+    loop do
+      h.reset_eval_rules
+      entry = eval_rule_body
+      break if !entry.first || no_progress?(entry)
+      self.entry = entry
+    end
+    self.head = nil
+  end
+
+  def eval_rule_body
+    source.pos = self.pos
+    answer = rule.eval_rule_body(source, context)
+    MemoEntry.new(answer, source.pos)
+  end
+
+  def no_progress?(entry)
+    entry.pos <= self.entry.pos
+  end
+
+  def fail(message)
+    MemoEntry.new(context.err(rule, source, message), self.pos)
+  end
+
+end

data/lib/parslet/atoms/sequence.rb

@@ -0,0 +1,38 @@
+# A sequence of parslets, matched from left to right. Denoted by '>>'
+#
+# Example: 
+#
+#   str('a') >> str('b')  # matches 'a', then 'b'
+#
+class Parslet::Atoms::Sequence < Parslet::Atoms::Base
+  attr_reader :parslets
+  def initialize(*parslets)
+    super()
+
+    @parslets = parslets
+    @error_msgs = {
+      :failed  => "Failed to match sequence (#{self.inspect})"
+    }
+  end
+  
+  def >>(parslet)
+    self.class.new(* @parslets+[parslet])
+  end
+  
+  def try(source, context)
+    succ([:sequence]+parslets.map { |p| 
+      success, value = p.apply(source, context) 
+
+      unless success
+        return context.err(self, source, @error_msgs[:failed], [value]) 
+      end
+      
+      value
+    })
+  end
+      
+  precedence SEQUENCE
+  def to_s_inner(prec)
+    parslets.map { |p| p.to_s(prec) }.join(' ')
+  end
+end

data/lib/parslet/atoms/str.rb

@@ -0,0 +1,37 @@
+# Matches a string of characters. 
+#
+# Example: 
+# 
+#   str('foo') # matches 'foo'
+#
+class Parslet::Atoms::Str < Parslet::Atoms::Base
+  attr_reader :str
+  def initialize(str)
+    super()
+
+    @str = str.to_s
+    @len = str.size
+    @error_msgs = {
+      :premature  => "Premature end of input", 
+      :failed     => "Expected #{str.inspect}, but got "
+    }
+  end
+  
+  def try(source, context)
+    return succ(source.consume(@len)) if source.matches?(str)
+    
+    # Failures: 
+    return context.err(self, source, @error_msgs[:premature]) \
+      if source.chars_left<@len
+      
+    error_pos = source.pos  
+    return context.err_at(
+      self, source, 
+      [@error_msgs[:failed], source.consume(@len)], error_pos) 
+  end
+  
+  def to_s_inner(prec)
+    "'#{str}'"
+  end
+end
+

data/lib/parslet/atoms/visitor.rb

@@ -0,0 +1,89 @@
+# Augments all parslet atoms with an accept method that will call back 
+# to the visitor given.
+
+# 
+module Parslet::Atoms
+  class Base
+    def accept(visitor)
+      raise NotImplementedError, "No #accept method on #{self.class.name}."
+    end
+  end
+  
+  class Str
+    # Call back visitors #visit_str method. See parslet/export for an example.
+    #
+    def accept(visitor)
+      visitor.visit_str(str)
+    end
+  end
+  
+  class Entity
+    # Call back visitors #visit_entity method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_entity(name, block)
+    end
+  end
+  
+  class Named
+    # Call back visitors #visit_named method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_named(name, parslet)
+    end
+  end
+  
+  class Sequence
+    # Call back visitors #visit_sequence method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_sequence(parslets)
+    end
+  end
+  
+  class Repetition
+    # Call back visitors #visit_repetition method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_repetition(@tag, min, max, parslet)
+    end
+  end
+  
+  class Alternative
+    # Call back visitors #visit_alternative method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_alternative(alternatives)
+    end
+  end
+  
+  class Lookahead
+    # Call back visitors #visit_lookahead method. See parslet/export for an
+    # example. 
+    #
+    def accept(visitor)
+      visitor.visit_lookahead(positive, bound_parslet)
+    end
+  end
+  
+  class Re
+    # Call back visitors #visit_re method. See parslet/export for an example. 
+    #
+    def accept(visitor)
+      visitor.visit_re(match)
+    end
+  end
+end
+
+class Parslet::Parser
+  # Call back visitors #visit_parser method. 
+  #
+  def accept(visitor)
+    visitor.visit_parser(root)
+  end
+end

data/lib/parslet/cause.rb

@@ -0,0 +1,94 @@
+module Parslet
+  # Represents a cause why a parse did fail. A lot of these objects are
+  # constructed - not all of the causes turn out to be failures for the whole
+  # parse. 
+  #
+  class Cause
+    def initialize(message, source, pos, children)
+      @message, @source, @pos, @children = 
+        message, source, pos, children
+    end
+    
+    # @return [String, Array] A string or an array of message pieces that 
+    #   provide failure information. Use #to_s to get a formatted string.
+    attr_reader :message
+    
+    # @return [Parslet::Source] Source that was parsed when this error 
+    #   happend. Mainly used for line number information.
+    attr_reader :source
+    
+    # Location of the error. 
+    #
+    # @return [Fixnum] Position where the error happened. (character offset)
+    attr_reader :pos 
+    
+    # When this cause is part of a tree of error causes: child nodes for this
+    # node. Very often carries the reasons for this cause. 
+    #
+    # @return [Array<Parslet::Cause>] A list of reasons for this cause. 
+    def children
+      @children ||= []
+    end
+    
+    # Appends 'at line LINE char CHAR' to the string given. Use +pos+ to
+    # override the position of the +source+. This method returns an object
+    # that can be turned into a string using #to_s.
+    #
+    # @param source [Parslet::Source] source that was parsed when this error
+    #   happened 
+    # @param pos [Fixnum] position of error
+    # @param str [String, Array<String>] message parts
+    # @param children [Array<Parslet::Cause>] child nodes for this error tree
+    # @return [Parslet::Cause] a new instance of {Parslet::Cause}
+    #
+    def self.format(source, pos, str, children=[])
+      self.new(str, source, pos, children)
+    end
+    
+    def to_s
+      line, column = source.line_and_column(pos)
+      # Allow message to be a list of objects. Join them here, since we now
+      # really need it. 
+      Array(message).map { |o| 
+        o.respond_to?(:to_slice) ? 
+          o.str.inspect : 
+          o.to_s }.join + " at line #{line} char #{column}."
+    end
+    
+    # Signals to the outside that the parse has failed. Use this in
+    # conjunction with .format for nice error messages. 
+    #
+    def raise(exception_klass=Parslet::ParseFailed)
+      exception = exception_klass.new(self.to_s, self)
+      Kernel.raise exception
+    end
+
+    # Returns an ascii tree representation of the causes of this node and its
+    # children. 
+    #
+    def ascii_tree
+      StringIO.new.tap { |io| 
+        recursive_ascii_tree(self, io, [true]) }.
+        string
+    end
+
+  private
+    def recursive_ascii_tree(node, stream, curved)
+      append_prefix(stream, curved)
+      stream.puts node.to_s
+
+      node.children.each do |child|
+        last_child = (node.children.last == child)
+
+        recursive_ascii_tree(child, stream, curved + [last_child])
+      end
+    end
+    def append_prefix(stream, curved)
+      return if curved.size < 2
+      curved[1..-2].each do |c|
+        stream.print c ? "   " : "|  "
+      end
+      stream.print curved.last ? "`- " : "|- "
+    end
+  end
+end