ghazel-parslet 1.4.0.1

data/lib/parslet/parser.rb

@@ -0,0 +1,67 @@
+
+# The base class for all your parsers. Use as follows: 
+#
+#   require 'parslet'
+#        
+#   class MyParser < Parslet::Parser
+#     rule(:a) { str('a').repeat }
+#     root(:a)        
+#   end
+#        
+#   pp MyParser.new.parse('aaaa')   # => 'aaaa'
+#   pp MyParser.new.parse('bbbb')   # => Parslet::Atoms::ParseFailed: 
+#                                   #    Don't know what to do with bbbb at line 1 char 1.
+#
+# Parslet::Parser is also a grammar atom. This means that you can mix full 
+# fledged parsers freely with small parts of a different parser. 
+#
+# Example: 
+#   class ParserA < Parslet::Parser
+#     root :aaa
+#     rule(:aaa) { str('a').repeat(3,3) }
+#   end
+#   class ParserB < Parslet::Parser
+#     root :expression
+#     rule(:expression) { str('b') >> ParserA.new >> str('b') }
+#   end
+#
+# In the above example, ParserB would parse something like 'baaab'. 
+#
+class Parslet::Parser < Parslet::Atoms::Base
+  include Parslet
+
+  class <<self # class methods
+    # Define the parsers #root function. This is the place where you start 
+    # parsing; if you have a rule for 'file' that describes what should be 
+    # in a file, this would be your root declaration: 
+    #
+    #   class Parser
+    #     root :file
+    #     rule(:file) { ... }
+    #   end
+    #
+    # #root declares a 'parse' function that works just like the parse 
+    # function that you can call on a simple parslet, taking a string as input
+    # and producing parse output. 
+    #
+    # In a way, #root is a shorthand for: 
+    #
+    #   def parse(str)
+    #     your_parser_root.parse(str)
+    #   end
+    #
+    def root(name)
+      define_method(:root) do
+        self.send(name)
+      end
+    end
+  end
+  
+  def try(source, context)
+    root.try(source, context)
+  end
+  
+  def to_s_inner(prec)
+    root.to_s(prec)
+  end
+end

data/lib/parslet/pattern.rb

@@ -0,0 +1,114 @@
+# Matches trees against expressions. Trees are formed by arrays and hashes
+# for expressing membership and sequence. The leafs of the tree are other
+# classes. 
+#
+# A tree issued by the parslet library might look like this: 
+#
+#   { 
+#     :function_call => {
+#       :name => 'foobar', 
+#       :args => [1, 2, 3]
+#     }
+#   }
+#
+# A pattern that would match against this tree would be: 
+#
+#   { :function_call => { :name => simple(:name), :args => sequence(:args) }}
+#
+# Note that Parslet::Pattern only matches at a given subtree; it wont try 
+# to match recursively. To do that, please use Parslet::Transform. 
+#
+class Parslet::Pattern  
+  def initialize(pattern)
+    @pattern = pattern
+  end
+
+  # Decides if the given subtree matches this pattern. Returns the bindings
+  # made on a successful match or nil if the match fails. If you specify 
+  # bindings to be a hash, the mappings in it will be treated like bindings
+  # made during an attempted match. 
+  #
+  #   Pattern.new('a').match('a', :foo => 'bar') # => { :foo => 'bar' }
+  #
+  # @param subtree [String, Hash, Array] poro subtree returned by a parse
+  # @param bindings [Hash] variable bindings to be verified
+  # @return [Hash, nil] On success: variable bindings that allow a match. On 
+  #   failure: nil
+  #
+  def match(subtree, bindings=nil)
+    bindings = bindings && bindings.dup || Hash.new
+    return bindings if element_match(subtree, @pattern, bindings)
+  end
+  
+  # Returns true if the tree element given by +tree+ matches the expression
+  # given by +exp+. This match must respect bindings already made in
+  # +bindings+. Note that bindings is carried along and modified. 
+  #
+  # @api private
+  #
+  def element_match(tree, exp, bindings) 
+    # p [:elm, tree, exp]
+    case [tree, exp].map { |e| e.class }
+      when [Hash,Hash]
+        return element_match_hash(tree, exp, bindings)
+      when [Array,Array]
+        return element_match_ary_single(tree, exp, bindings)
+    else
+      # If elements match exactly, then that is good enough in all cases
+      return true if tree == exp
+      
+      # If exp is a bind variable: Check if the binding matches
+      if exp.respond_to?(:can_bind?) && exp.can_bind?(tree)
+        return element_match_binding(tree, exp, bindings)
+      end
+                  
+      # Otherwise: No match (we don't know anything about the element
+      # combination)
+      return false
+    end
+  end
+  
+  # @api private
+  #
+  def element_match_binding(tree, exp, bindings)
+    var_name = exp.variable_name
+
+    # TODO test for the hidden :_ feature.
+    if var_name && bound_value = bindings[var_name]
+      return bound_value == tree
+    end
+    
+    # New binding: 
+    bindings.store var_name, tree
+    
+    return true
+  end
+  
+  # @api private
+  #
+  def element_match_ary_single(sequence, exp, bindings)
+    return false if sequence.size != exp.size
+    
+    return sequence.zip(exp).all? { |elt, subexp|
+      element_match(elt, subexp, bindings) }
+  end
+  
+  # @api private
+  #
+  def element_match_hash(tree, exp, bindings)
+    # Early failure when one hash is bigger than the other
+    return false unless exp.size == tree.size
+    
+    # We iterate over expected pattern, since we demand that the keys that
+    # are there should be in tree as well.
+    exp.each do |expected_key, expected_value|
+      return false unless tree.has_key? expected_key
+      
+      # Recurse into the value and stop early on failure
+      value = tree[expected_key]
+      return false unless element_match(value, expected_value, bindings)
+    end
+    
+    return true
+  end  
+end

data/lib/parslet/pattern/binding.rb

@@ -0,0 +1,49 @@
+
+# Used internally for representing a bind placeholder in a Parslet::Transform
+# pattern. This is the superclass for all bindings. 
+#
+# It defines the most permissive kind of bind, the one that matches any subtree
+# whatever it looks like. 
+#
+class Parslet::Pattern::SubtreeBind < Struct.new(:symbol)
+  def variable_name
+    symbol
+  end
+  
+  def inspect
+    "#{bind_type_name}(#{symbol.inspect})"
+  end
+  
+  def can_bind?(subtree)
+    true
+  end
+
+private 
+  def bind_type_name 
+    if md=self.class.name.match(/(\w+)Bind/)
+      md.captures.first.downcase
+    else
+      # This path should never be used, but since this is for inspection only, 
+      # let's not raise.
+      'unknown_bind'
+    end
+  end
+end
+
+# Binds a symbol to a simple subtree, one that is not either a sequence of
+# elements or a collection of attributes. 
+#
+class Parslet::Pattern::SimpleBind < Parslet::Pattern::SubtreeBind
+  def can_bind?(subtree)
+    not [Hash, Array].include?(subtree.class)
+  end
+end
+
+# Binds a symbol to a sequence of simple leafs ([element1, element2, ...])
+#
+class Parslet::Pattern::SequenceBind < Parslet::Pattern::SubtreeBind
+  def can_bind?(subtree)
+    subtree.kind_of?(Array) &&
+      (not subtree.any? { |el| [Hash, Array].include?(el.class) })
+  end
+end

data/lib/parslet/rig/rspec.rb

@@ -0,0 +1,51 @@
+RSpec::Matchers.define(:parse) do |input, opts|
+  as = block = nil
+  result = trace = nil
+  match do |parser|
+    begin
+      result = parser.parse(input)
+      block ? 
+        block.call(result) : 
+        (as == result || as.nil?)
+    rescue Parslet::ParseFailed => ex
+      trace = ex.cause.ascii_tree if opts && opts[:trace]
+      false
+    end
+  end
+
+  failure_message_for_should do |is|
+    if block
+      "expected output of parsing #{input.inspect}" <<
+      " with #{is.inspect} to meet block conditions, but it didn't"
+    else
+      "expected " << 
+        (as ? 
+          "output of parsing #{input.inspect}"<<
+          " with #{is.inspect} to equal #{as.inspect}, but was #{result.inspect}" : 
+          "#{is.inspect} to be able to parse #{input.inspect}") << 
+        (trace ? 
+          "\n"+trace : 
+          '')
+    end
+  end
+
+  failure_message_for_should_not do |is|
+    if block
+      "expected output of parsing #{input.inspect} with #{is.inspect} not to meet block conditions, but it did"
+    else
+      "expected " << 
+        (as ? 
+          "output of parsing #{input.inspect}"<<
+          " with #{is.inspect} not to equal #{as.inspect}" :
+          
+          "#{is.inspect} to not parse #{input.inspect}, but it did")
+    end
+  end
+
+  # NOTE: This has a nodoc tag since the rdoc parser puts this into 
+  # Object, a thing I would never allow. 
+  chain :as do |expected_output, &block|
+    as = expected_output
+    block = block
+  end
+end

data/lib/parslet/slice.rb

@@ -0,0 +1,101 @@
+
+# A slice is a small part from the parse input. A slice mainly behaves like
+# any other string, except that it remembers where it came from (offset in
+# original input).
+#
+# == Extracting line and column
+#
+# Using the #line_and_column method, you can extract the line and column in
+# the original input where this slice starts.
+#
+# Example:
+#   slice.line_and_column # => [1, 13]
+#   slice.offset          # => 12
+#
+# == Likeness to strings
+#
+# Parslet::Slice behaves in many ways like a Ruby String. This likeness
+# however is not complete - many of the myriad of operations String supports
+# are not yet in Slice. You can always extract the internal string instance by
+# calling #to_s.
+#
+# These omissions are somewhat intentional. Rather than maintaining a full
+# delegation, we opt for a partial emulation that gets the job done.
+#
+class Parslet::Slice
+  attr_reader :str, :offset
+  attr_reader :line_cache
+
+  # Construct a slice using a string, an offset and an optional line cache. 
+  # The line cache should be able to answer to the #line_and_column message. 
+  #
+  def initialize(string, offset, line_cache=nil)
+    @str, @offset = string, offset
+    @line_cache = line_cache
+  end
+
+  # Compares slices to other slices or strings.
+  #
+  def == other
+    str == other
+  end
+
+  # Match regular expressions.
+  #
+  def match(regexp)
+    str.match(regexp)
+  end
+
+  # Returns the slices size in characters.
+  #
+  def size
+    str.size
+  end
+  
+  # Concatenate two slices; it is assumed that the second slice begins 
+  # where the first one ends. The offset of the resulting slice is the same
+  # as the one of this slice. 
+  #
+  def +(other)
+    self.class.new(str + other.to_s, offset, line_cache)
+  end
+
+  # Returns a <line, column> tuple referring to the original input.
+  #
+  def line_and_column
+    raise ArgumentError, "No line cache was given, cannot infer line and column." \
+      unless line_cache
+
+    line_cache.line_and_column(self.offset)
+  end
+
+
+  # Conversion operators -----------------------------------------------------
+  def to_str
+    str
+  end
+  alias to_s to_str
+
+  def to_slice
+    self
+  end
+  def to_sym
+    str.to_sym
+  end
+  def to_int
+    Integer(str)
+  end
+  def to_i
+    str.to_i
+  end
+  def to_f
+    str.to_f
+  end
+
+  # Inspection & Debugging ---------------------------------------------------
+
+  # Prints the slice as <code>"string"@offset</code>.
+  def inspect
+    str.inspect << "@#{offset}"
+  end
+end

data/lib/parslet/source.rb

@@ -0,0 +1,62 @@
+
+require 'stringio'
+
+require 'parslet/source/line_cache'
+
+module Parslet
+  # Wraps the input string for parslet. 
+  #
+  class Source
+    def initialize(str)
+      raise ArgumentError unless str.respond_to?(:to_str)
+    
+      @pos = 0
+      @str = str
+      
+      @line_cache = LineCache.new
+      @line_cache.scan_for_line_endings(0, @str)
+    end
+  
+    # Checks if the given pattern matches at the current input position. 
+    #
+    # @param pattern [Regexp, String] pattern to check for
+    # @return [Boolean] true if the pattern matches at #pos
+    #
+    def matches?(pattern)
+      @str.index(pattern, @pos) == @pos
+    end
+    alias match matches?
+    
+    # Consumes n characters from the input, returning them as a slice of the
+    # input. 
+    #
+    def consume(n)
+      slice_str = @str.slice(@pos, n)
+      slice = Parslet::Slice.new(
+        slice_str, 
+        pos,
+        @line_cache)
+      
+      @pos += slice_str.size
+      return slice
+    end
+    
+    # Returns how many chars remain in the input. 
+    #
+    def chars_left
+      @str.size - @pos
+    end
+    
+    # Position of the parse as a character offset into the original string. 
+    # @note: Encodings...
+    attr_accessor :pos
+
+    # Returns a <line, column> tuple for the given position. If no position is
+    # given, line/column information is returned for the current position
+    # given by #pos. 
+    #
+    def line_and_column(position=nil)
+      @line_cache.line_and_column(position || self.pos)
+    end
+  end
+end