swift-pyrite 0.1.0

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/infix.rb

@@ -0,0 +1,121 @@
+class Parslet::Atoms::Infix < Parslet::Atoms::Base
+  attr_reader :element, :operations
+
+  def initialize(element, operations)
+    super()
+
+    @element = element
+    @operations = operations
+  end
+  
+  def try(source, context, consume_all)
+    return catch_error {
+      return succ(
+        produce_tree(
+          precedence_climb(source, context, consume_all)))
+    }
+  end
+
+  # Turns an array of the form ['1', '+', ['2', '*', '3']] into a hash that
+  # reflects the same structure.
+  #
+  def produce_tree(ary)
+    return ary unless ary.kind_of? Array
+
+    left = ary.shift
+
+    until ary.empty?
+      op, right = ary.shift(2)
+
+      # p [left, op, right]
+
+      if right.kind_of? Array
+        # Subexpression -> Subhash
+        left = {l: left, o: op, r: produce_tree(right)}
+      else
+        left = {l: left, o: op, r: right}
+      end
+    end
+
+    left
+  end
+
+  # A precedence climbing algorithm married to parslet, as described here
+  #   http://eli.thegreenplace.net/2012/08/02/parsing-expressions-by-precedence-climbing/
+  # 
+  # @note Error handling in this routine is done by throwing :error and 
+  #       as a value the error to return to parslet. This avoids cluttering
+  #       the recursion logic here with parslet error handling. 
+  #
+  def precedence_climb(source, context, consume_all, current_prec=1, needs_element=false)
+    result = []
+
+    # To even begin parsing an arithmetic expression, there needs to be 
+    # at least one @element. 
+    success, value = @element.apply(source, context, false)
+    
+    unless success
+      abort context.err(self, source, "#{@element.inspect} was expected", [value])
+    end
+
+    result << flatten(value, true)
+
+    # Loop until we fail on operator matching or until input runs out.
+    loop do
+      op_pos = source.bytepos
+      op_match, prec, assoc = match_operation(source, context, false)
+
+      # If no operator could be matched here, one of several cases 
+      # applies: 
+      #
+      # - end of file
+      # - end of expression
+      # - syntax error
+      # 
+      # We abort matching the expression here. 
+      break unless op_match
+
+      if prec >= current_prec
+        next_prec = (assoc == :left) ? prec+1 : prec
+
+        result << op_match
+        result << precedence_climb(
+          source, context, consume_all, next_prec, true)
+      else
+        source.bytepos = op_pos
+        return unwrap(result)
+      end
+    end
+
+    return unwrap(result)
+  end
+
+  def unwrap expr
+    expr.size == 1 ? expr.first : expr
+  end
+
+  def match_operation(source, context, consume_all)
+    errors = []
+    @operations.each do |op_atom, prec, assoc|
+      success, value = op_atom.apply(source, context, consume_all)
+      return flatten(value, true), prec, assoc if success
+
+      # assert: this was in fact an error, accumulate
+      errors << value
+    end
+
+    return nil
+  end
+
+  def abort(error)
+    throw :error, error
+  end
+  def catch_error
+    catch(:error) { yield }
+  end
+
+  def to_s_inner(prec)
+    ops = @operations.map { |o, _, _| o.inspect }.join(', ')
+    "infix_expression(#{@element.inspect}, [#{ops}])"
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/lookahead.rb

@@ -0,0 +1,50 @@
+# Either positive or negative lookahead, doesn't consume its input. 
+#
+# Example: 
+#
+#   str('foo').present? # matches when the input contains 'foo', but leaves it
+#
+class Parslet::Atoms::Lookahead < Parslet::Atoms::Base
+  attr_reader :positive
+  attr_reader :bound_parslet
+  
+  def initialize(bound_parslet, positive=true)
+    super()
+    
+    # Model positive and negative lookahead by testing this flag.
+    @positive = positive
+    @bound_parslet = bound_parslet
+    
+    @error_msgs = {
+      :positive => ["Input should start with ", bound_parslet], 
+      :negative => ["Input should not start with ", bound_parslet]
+    }
+  end
+  
+  def try(source, context, consume_all)
+    rewind_pos  = source.bytepos
+    error_pos   = source.pos
+
+    success, value = bound_parslet.apply(source, context, consume_all)
+    
+    if positive
+      return succ(nil) if success
+      return context.err_at(self, source, @error_msgs[:positive], error_pos)
+    else
+      return succ(nil) unless success
+      return context.err_at(self, source, @error_msgs[:negative], error_pos)
+    end
+    
+  # This is probably the only parslet that rewinds its input in #try.
+  # Lookaheads NEVER consume their input, even on success, that's why. 
+  ensure 
+    source.bytepos = rewind_pos
+  end
+  
+  precedence LOOKAHEAD
+  def to_s_inner(prec)
+    char = positive ? '&' : '!'
+    
+    "#{char}#{bound_parslet.to_s(prec)}"
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/named.rb

@@ -0,0 +1,32 @@
+# Names a match to influence tree construction. 
+#
+# Example: 
+#
+#   str('foo')            # will return 'foo', 
+#   str('foo').as(:foo)   # will return :foo => 'foo'
+#
+class Parslet::Atoms::Named < Parslet::Atoms::Base
+  attr_reader :parslet, :name
+  def initialize(parslet, name)
+    super()
+
+    @parslet, @name = parslet, name
+  end
+  
+  def apply(source, context, consume_all)
+    success, value = result = parslet.apply(source, context, consume_all)
+
+    return result unless success
+    succ(
+      produce_return_value(
+        value))
+  end
+  
+  def to_s_inner(prec)
+    "#{name}:#{parslet.to_s(prec)}"
+  end
+private
+  def produce_return_value(val)
+    { name => flatten(val, true) }
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/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, consume_all)
+    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/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/repetition.rb

@@ -0,0 +1,83 @@
+
+# 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()
+
+    raise ArgumentError, 
+      "Asking for zero repetitions of a parslet. (#{parslet.inspect} repeating #{min},#{max})" \
+      if max == 0
+
+
+    @parslet = parslet
+    @min, @max = min, max
+    @tag = tag
+    @error_msgs = {
+      :minrep  => "Expected at least #{min} of #{parslet.inspect}", 
+      :unconsumed => "Extra input after last repetition"
+    }
+  end
+  
+  def try(source, context, consume_all)
+    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, false)
+
+      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 successes) is >= min.
+    return context.err_at(
+      self, 
+      source, 
+      @error_msgs[:minrep], 
+      start_pos, 
+      [break_on]) if occ < min
+      
+    # consume_all is true, that means that we're inside the part of the parser
+    # that should consume the input completely. Repetition failing here means
+    # probably that we didn't. 
+    #
+    # We have a special clause to create an error here because otherwise
+    # break_on would get thrown away. It turns out, that contains very
+    # interesting information in a lot of cases. 
+    #
+    return context.err(
+      self, 
+      source, 
+      @error_msgs[:unconsumed], 
+      [break_on]) if consume_all && source.chars_left>0
+      
+    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/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/scope.rb

@@ -0,0 +1,26 @@
+# Starts a new scope in the parsing process. Please also see the #captures
+# method. 
+#
+class Parslet::Atoms::Scope < Parslet::Atoms::Base
+  attr_reader :block
+  def initialize(block)
+    super()
+
+    @block = block
+  end
+  
+  def cached?
+    false
+  end
+  
+  def apply(source, context, consume_all)
+    context.scope do
+      parslet = block.call
+      return parslet.apply(source, context, consume_all)
+    end
+  end
+  
+  def to_s_inner(prec)
+    "scope { #{block.call.to_s(prec)} }"
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/sequence.rb

@@ -0,0 +1,45 @@
+# 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, consume_all)
+    # Presize an array
+    result = Array.new(parslets.size + 1)
+    result[0] = :sequence
+    
+    parslets.each_with_index do |p, idx|
+      child_consume_all = consume_all && (idx == parslets.size-1)
+      success, value = p.apply(source, context, child_consume_all) 
+
+      unless success
+        return context.err(self, source, @error_msgs[:failed], [value]) 
+      end
+
+      result[idx+1] = value
+    end
+    
+    return succ(result)
+  end
+      
+  precedence SEQUENCE
+  def to_s_inner(prec)
+    parslets.map { |p| p.to_s(prec) }.join(' ')
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms/str.rb

@@ -0,0 +1,39 @@
+# 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
+    @pat = Regexp.new(Regexp.escape(str))
+    @len = str.size
+    @error_msgs = {
+      :premature  => "Premature end of input", 
+      :failed     => "Expected #{str.inspect}, but got "
+    }
+  end
+  
+  def try(source, context, consume_all)
+    return succ(source.consume(@len)) if source.matches?(@pat)
+    
+    # Input ending early:
+    return context.err(self, source, @error_msgs[:premature]) \
+      if source.chars_left<@len
+    
+    # Expected something, but got something else instead:  
+    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/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/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/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/atoms.rb

@@ -0,0 +1,35 @@
+
+# This is where parslets name comes from: Small parser atoms.
+#
+module Parslet::Atoms
+  # The precedence module controls parenthesis during the #inspect printing
+  # of parslets. It is not relevant to other aspects of the parsing. 
+  #
+  module Precedence
+    prec = 0
+    BASE       = (prec+=1)    # everything else
+    LOOKAHEAD  = (prec+=1)    # &SOMETHING
+    REPETITION = (prec+=1)    # 'a'+, 'a'?
+    SEQUENCE   = (prec+=1)    # 'a' 'b'
+    ALTERNATE  = (prec+=1)    # 'a' | 'b'
+    OUTER      = (prec+=1)    # printing is done here.
+  end
+  
+  require 'parslet/atoms/can_flatten'
+  require 'parslet/atoms/context'
+  require 'parslet/atoms/dsl'
+  require 'parslet/atoms/base'
+  require 'parslet/atoms/named'
+  require 'parslet/atoms/lookahead'
+  require 'parslet/atoms/alternative'
+  require 'parslet/atoms/sequence'
+  require 'parslet/atoms/repetition'
+  require 'parslet/atoms/re'
+  require 'parslet/atoms/str'
+  require 'parslet/atoms/entity'
+  require 'parslet/atoms/capture'
+  require 'parslet/atoms/dynamic'
+  require 'parslet/atoms/scope'
+  require 'parslet/atoms/infix'
+end
+

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/cause.rb

@@ -0,0 +1,101 @@
+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
+
+    # Update error message to include context provided by label
+    # Update all child causes too (the same context applies to all causes)
+    def set_label(l)
+      @context = " when parsing #{l}"
+      children.each { |c| c.set_label(l) }
+    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}#{@context}."
+    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

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/lib/parslet/context.rb

@@ -0,0 +1,35 @@
+require 'blankslate'
+
+# Provides a context for tree transformations to run in. The context allows
+# accessing each of the bindings in the bindings hash as local method.
+#
+# Example: 
+#
+#   ctx = Context.new(:a => :b)
+#   ctx.instance_eval do 
+#     a # => :b
+#   end
+#
+# @api private
+class Parslet::Context < BlankSlate
+  reveal :methods
+  reveal :respond_to?
+  reveal :inspect
+  reveal :to_s
+  reveal :instance_variable_set
+
+  include Parslet
+  
+  def meta_def(name, &body)
+    metaclass = class << self; self; end
+
+    metaclass.send(:define_method, name, &body)
+  end
+  
+  def initialize(bindings)
+    bindings.each do |key, value|
+      meta_def(key.to_sym) { value }
+      instance_variable_set("@#{key}", value)
+    end
+  end
+end