swift-pyrite 0.1.0

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/seasons.rb

@@ -0,0 +1,46 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+require 'pp'
+
+tree = {:bud => {:stem => []}}
+
+class Spring < Parslet::Transform
+  rule(:stem => sequence(:branches)) {
+    {:stem => (branches + [{:branch => :leaf}])}
+  }
+end
+class Summer < Parslet::Transform
+  rule(:stem => subtree(:branches)) {
+    new_branches = branches.map { |b| {:branch => [:leaf, :flower]} }
+    {:stem => new_branches}
+  }
+end
+class Fall < Parslet::Transform
+  rule(:branch => sequence(:x)) {
+    x.each { |e| puts "Fruit!" if e==:flower }
+    x.each { |e| puts "Falling Leaves!" if e==:leaf }
+    {:branch => []}
+  }
+end
+class Winter < Parslet::Transform
+  rule(:stem => subtree(:x)) {
+    {:stem => []}
+  }
+end
+
+def do_seasons(tree)
+  [Spring, Summer, Fall, Winter].each do |season|
+    p "And when #{season} comes"
+    tree = season.new.apply(tree)
+    pp tree
+    puts
+  end
+  tree
+end
+
+# What marvel of life!
+tree = do_seasons(tree)
+tree = do_seasons(tree)
+
+

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/sentence.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+# A small example contributed by John Mettraux (jmettraux) that demonstrates
+# working with Unicode. This only works on Ruby 1.9.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+
+class Parser < Parslet::Parser
+  rule(:sentence) { (match('[^。]').repeat(1) >> str("。")).as(:sentence) }
+  rule(:sentences) { sentence.repeat }
+  root(:sentences)
+end
+
+class Transformer < Parslet::Transform
+  rule(:sentence => simple(:sen)) { sen.to_s }
+end
+
+string =
+  "RubyKaigi2009のテーマは、「変わる／変える」です。 前回の" +
+  "RubyKaigi2008のテーマであった「多様性」の言葉の通り、 " +
+  "2008年はRubyそのものに関しても、またRubyの活躍する舞台に関しても、 " +
+  "ますます多様化が進みつつあります。RubyKaigi2008は、そのような " +
+  "Rubyの生態系をあらためて認識する場となりました。 しかし、" +
+  "こうした多様化が進む中、異なる者同士が単純に距離を 置いたままでは、" +
+  "その違いを認識したところであまり意味がありません。 異なる実装、" +
+  "異なる思想、異なる背景といった、様々な多様性を理解しつつ、 " +
+  "すり合わせるべきものをすり合わせ、変えていくべきところを " +
+  "変えていくことが、豊かな未来へとつながる道に違いありません。"
+
+parser = Parser.new
+transformer = Transformer.new
+
+tree = parser.parse(string)
+p transformer.apply(tree)

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/simple.lit

@@ -0,0 +1,3 @@
+123
+12345
+" Some String with \"escapes\""

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/simple_xml.rb

@@ -0,0 +1,54 @@
+# A simple xml parser. It is simple in the respect as that it doesn't address
+# any of the complexities of XML. This is ruby 1.9.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+class XML < Parslet::Parser
+  root :document
+  
+  rule(:document) {
+    tag(close: false).as(:o) >> document.as(:i) >> tag(close: true).as(:c) |
+    text
+  }
+  
+  # Perhaps we could have some syntax sugar to make this more easy?
+  #
+  def tag(opts={})
+    close = opts[:close] || false
+    
+    parslet = str('<')
+    parslet = parslet >> str('/') if close
+    parslet = parslet >> (str('>').absent? >> match("[a-zA-Z]")).repeat(1).as(:name)
+    parslet = parslet >> str('>')
+    
+    parslet
+  end
+  
+  rule(:text) {
+    match('[^<>]').repeat(0)
+  }
+end
+
+def check(xml)
+  r = XML.new.parse(xml)
+
+  # We'll validate the tree by reducing valid pairs of tags into simply the
+  # string "verified". If the transformation ends on a string, then the
+  # document was 'valid'. 
+  #
+  t = Parslet::Transform.new do
+    rule(
+      o: {name: simple(:tag)}, 
+      c: {name: simple(:tag)}, 
+      i: simple(:t)
+    ) { 'verified' } 
+  end
+
+  t.apply(r)
+end
+
+pp check("<a><b>some text in the tags</b></a>")
+pp check("<b><b>some text in the tags</b></a>")

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/string_parser.rb

@@ -0,0 +1,77 @@
+# A more complex parser that illustrates how a compiler might be constructed.
+# The parser recognizes strings and integer literals and constructs almost a
+# useful AST from the file contents. 
+
+require 'pp'
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+
+include Parslet
+
+class LiteralsParser < Parslet::Parser
+  rule :space do
+    (match '[ ]').repeat(1)
+  end
+  
+  rule :literals do
+    (literal >> eol).repeat
+  end
+  
+  rule :literal do
+    (integer | string).as(:literal) >> space.maybe
+  end
+  
+  rule :string do
+    str('"') >> 
+    (
+      (str('\\') >> any) |
+      (str('"').absent? >> any)
+    ).repeat.as(:string) >> 
+    str('"')
+  end
+  
+  rule :integer do
+    match('[0-9]').repeat(1).as(:integer)
+  end
+  
+  rule :eol do
+    line_end.repeat(1)
+  end
+  
+  rule :line_end do
+    crlf >> space.maybe
+  end
+  
+  rule :crlf do
+    match('[\r\n]').repeat(1)
+  end
+
+  root :literals
+end
+
+input_name = File.join(File.dirname(__FILE__), 'simple.lit')
+file = File.read(input_name)
+
+parsetree = LiteralsParser.new.parse(file)
+  
+class Lit < Struct.new(:text)
+  def to_s
+    text.inspect
+  end
+end
+class StringLit < Lit
+end
+class IntLit < Lit
+  def to_s
+    text
+  end
+end
+
+transform = Parslet::Transform.new do
+  rule(:literal => {:integer => simple(:x)}) { IntLit.new(x) }
+  rule(:literal => {:string => simple(:s)}) { StringLit.new(s) }
+end
+  
+ast = transform.apply(parsetree)
+pp ast

data/vendor/bundle/ruby/2.0.0/gems/parslet-1.7.1/example/test.lit

@@ -0,0 +1,4 @@
+"THis is a string"
+"This is another string"
+"This string is escaped \"embedded quoted stuff \" "
+12 // an integer literal and a comment

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

@@ -0,0 +1,62 @@
+
+# @api private
+module Parslet::Accelerator
+  class Application
+    def initialize atom, rules
+      @atom = atom
+      @rules = rules
+    end
+
+    def call
+      @atom.accept(self)
+    end
+
+    def visit_parser(root)
+      transform root.accept(self)
+    end
+    def visit_entity(name, block)
+      transform Parslet::Atoms::Entity.new(name) { block.call.accept(self) }
+    end
+    def visit_named(name, atom)
+      transform Parslet::Atoms::Named.new(atom.accept(self), name)
+    end
+    def visit_repetition(tag, min, max, atom)
+      transform Parslet::Atoms::Repetition.new(atom.accept(self), min, max, tag)
+    end
+    def visit_alternative(alternatives)
+      transform Parslet::Atoms::Alternative.new(
+        *alternatives.map { |atom| atom.accept(self) })
+    end
+    def visit_sequence(sequence)
+      transform Parslet::Atoms::Sequence.new(
+        *sequence.map { |atom| atom.accept(self) })
+    end
+    def visit_lookahead(positive, atom)
+      transform Parslet::Atoms::Lookahead.new(atom, positive)
+    end
+    def visit_re(regexp)
+      transform Parslet::Atoms::Re.new(regexp)
+    end
+    def visit_str(str)
+      transform Parslet::Atoms::Str.new(str)
+    end
+
+    def transform atom
+      @rules.each do |expr, action|
+        # Try and match each rule in turn
+        binding = Parslet::Accelerator.match(atom, expr)
+        if binding
+          # On a successful match, allow the rule action to transform the
+          # parslet into something new. 
+          ctx = Parslet::Context.new(binding)
+          return ctx.instance_eval(&action)
+        end
+      end # rules.each 
+
+      # If no rule matches, this is the fallback - a clean new parslet atom.
+      return atom
+    end
+  end
+end
+
+require 'parslet/context'

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

@@ -0,0 +1,112 @@
+
+require 'parslet/atoms/visitor'
+
+module Parslet::Accelerator
+  # @api private
+  class Apply
+    def initialize(engine, expr)
+      @engine = engine
+      @expr = expr
+    end
+
+    def visit_parser(root)
+      false
+    end
+    def visit_entity(name, block)
+      false
+    end
+    def visit_named(name, atom)
+      match(:as) do |key|
+        @engine.try_bind(key, name)
+      end
+    end
+    def visit_repetition(tag, min, max, atom)
+      match(:rep) do |e_min, e_max, expr|
+        e_min == min && e_max == max && @engine.match(atom, expr)
+      end
+    end
+    def visit_alternative(alternatives)
+      match(:alt) do |*expressions|
+        return false if alternatives.size != expressions.size
+
+        alternatives.zip(expressions).all? do |atom, expr|
+          @engine.match(atom, expr)
+        end
+      end
+    end
+    def visit_sequence(sequence)
+      match(:seq) do |*expressions|
+        return false if sequence.size != expressions.size
+
+        sequence.zip(expressions).all? do |atom, expr|
+          @engine.match(atom, expr)
+        end
+      end
+    end
+    def visit_lookahead(positive, atom)
+      match(:absent) do |expr|
+        return positive == false && @engine.match(atom, expr)
+      end
+      match(:present) do |expr|
+        return positive == true && @engine.match(atom, expr)
+      end
+    end
+    def visit_re(regexp)
+      match(:re) do |*bind_conditions|
+        bind_conditions.all? { |bind_cond| 
+          @engine.try_bind(bind_cond, regexp) }
+      end
+    end
+    def visit_str(str)
+      match(:str) do |*bind_conditions|
+        bind_conditions.all? { |bind_cond| 
+          @engine.try_bind(bind_cond, str) }
+      end
+    end
+
+    def match(type_tag)
+      expr_tag = @expr.type
+      if expr_tag == type_tag
+        yield *@expr.args
+      end
+    end
+  end
+
+  # @api private
+  class Engine
+    attr_reader :bindings
+
+    def initialize 
+      @bindings = {}
+    end
+
+    def match(atom, expr)
+      atom.accept(
+        Apply.new(self, expr))
+    end
+
+    def try_bind(variable, value)
+      if bound? variable
+        return value == lookup(variable)
+      else
+        case variable
+          when Symbol
+            bind(variable, value)
+        else
+          # This does not look like a variable - let's try matching it against
+          # the value: 
+          variable === value
+        end    
+      end
+    end
+    def bound? var
+      @bindings.has_key? var
+    end
+    def lookup var
+      @bindings[var]
+    end
+    def bind var, val
+      @bindings[var] = val
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+
+
+# Optimizes the parsers by pattern matching on the parser atoms and replacing
+# matches with better versions. See the file qed/accelerators.md for a more
+# in-depth description.
+#
+# Example: 
+#   quote = str('"')
+#   parser = quote >> (quote.absent? >> any).repeat >> quote
+#
+#   A = Accelerator # for making what follows a bit shorter
+#   optimized_parser = A.apply(parser, 
+#     A.rule( (A.str(:x).absent? >> A.any).repeat ) { GobbleUp.new(x) })
+#
+#   optimized_parser.parse('"Parsing is now fully optimized! (tm)"')
+#
+module Parslet::Accelerator
+
+  # An expression to match against a tree of parser atoms. Normally, an
+  # expression is produced by Parslet::Accelerator.any, 
+  # Parslet::Accelerator.str or Parslet::Accelerator.re.
+  #
+  # Expressions can be chained much like parslet atoms can be: 
+  #
+  #   expr.repeat(1)      # matching repetition
+  #   expr.absent?        # matching absent?
+  #   expr.present?       # matching present?
+  #   expr1 >> expr2      # matching a sequence
+  #   expr1 | expr2       # matching an alternation
+  # 
+  # @see Parslet::Accelerator.str
+  # @see Parslet::Accelerator.re
+  # @see Parslet::Accelerator.any
+  #
+  # @see Parslet::Accelerator
+  # 
+  class Expression
+    attr_reader :type
+    attr_reader :args
+
+    def initialize(type, *args)
+      @type = type
+      @args = args
+    end
+
+    # @return [Expression]
+    def >> other_expr
+      join_or_new :seq, other_expr
+    end
+
+    # @return [Expression]
+    def | other_expr
+      join_or_new :alt, other_expr
+    end
+
+    # @return [Expression]
+    def absent?
+      Expression.new(:absent, self)
+    end
+    # @return [Expression]
+    def present?
+      Expression.new(:present, self)
+    end
+
+    # @return [Expression]
+    def repeat min=0, max=nil
+      Expression.new(:rep, min, max, self)
+    end
+
+    # @return [Expression]
+    def as name
+      Expression.new(:as, name)
+    end
+
+    # @api private
+    # @return [Expression]
+    def join_or_new tag, other_expr
+      if type == tag
+        @args << other_expr
+      else
+        Expression.new(tag, self, other_expr)
+      end
+    end
+  end
+
+module_function 
+  # Returns a match expression that will match `str` parslet atoms.
+  #
+  # @return [Parslet::Accelerator::Expression]
+  #
+  def str variable, *constraints
+    Expression.new(:str, variable, *constraints)
+  end
+
+  # Returns a match expression that will match `match` parslet atoms.
+  #
+  # @return [Parslet::Accelerator::Expression]
+  #
+  def re variable, *constraints
+    Expression.new(:re, variable, *constraints)
+  end
+
+  # Returns a match expression that will match `any` parslet atoms.
+  #
+  # @return [Parslet::Accelerator::Expression]
+  #
+  def any
+    Expression.new(:re, ".")
+  end
+
+  # Given a parslet atom and an expression, will determine if the expression
+  # matches the atom. If successful, returns the bindings into the pattern
+  # that were made. If no bindings had to be made to make the match successful, 
+  # the empty hash is returned. 
+  #
+  # @param atom [Parslet::Atoms::Base] parslet atom to match against
+  # @param expr [Parslet::Accelerator::Expression] expression to match
+  # @return [nil, Hash] bindings for the match, nil on failure
+  #
+  def match atom, expr
+    engine = Engine.new
+
+    return engine.bindings if engine.match(atom, expr)
+  end
+
+  # Constructs an accelerator rule. A rule is a matching expression and the
+  # code that should be executed once the expression could be bound to a 
+  # parser. 
+  #
+  # Example: 
+  #   Accelerator.rule(Accelerator.any) { Parslet.match('.') }
+  #
+  def rule expression, &action
+    [expression, action]
+  end
+
+  # Given a parslet atom and a set of rules, tries to match the rules 
+  # recursively through the parslet atom. Once a rule could be matched, 
+  # its action block will be called.
+  #
+  # Example: 
+  #   quote = str('"')
+  #   parser = quote >> (quote.absent? >> any).repeat >> quote
+  #
+  #   A = Accelerator # for making what follows a bit shorter
+  #   optimized_parser = A.apply(parser, 
+  #     A.rule( (A.str(:x).absent? >> A.any).repeat ) { GobbleUp.new(x) })
+  #
+  #   optimized_parser.parse('"Parsing is now fully optimized! (tm)"')
+  #
+  # @param atom [Parslet::Atoms::Base] a parser to optimize
+  # @param *rules [Parslet::Accelerator::Rule] rules produced by .rule
+  # @return [Parslet::Atoms::Base] optimized parser
+  #
+  def apply atom, *rules
+    Application.new(atom, rules).call
+  end
+end
+
+require 'parslet/accelerator/engine'
+require 'parslet/accelerator/application'

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

@@ -0,0 +1,50 @@
+
+# Alternative during matching. Contains a list of parslets that is tried each
+# one in turn. Only fails if all alternatives fail. 
+#
+# Example: 
+# 
+#   str('a') | str('b')   # matches either 'a' or 'b'
+#
+class Parslet::Atoms::Alternative < Parslet::Atoms::Base
+  attr_reader :alternatives
+  
+  # Constructs an Alternative instance using all given parslets in the order
+  # given. This is what happens if you call '|' on existing parslets, like 
+  # this: 
+  #
+  #   str('a') | str('b')
+  #
+  def initialize(*alternatives)
+    super()
+    
+    @alternatives = alternatives
+    @error_msg = "Expected one of #{alternatives.inspect}"
+  end
+
+  #---
+  # Don't construct a hanging tree of Alternative parslets, instead store them
+  # all here. This reduces the number of objects created.
+  #+++
+  def |(parslet)
+    self.class.new(*@alternatives + [parslet])
+  end
+  
+  def try(source, context, consume_all)
+    errors = alternatives.map { |a|
+      success, value = result = a.apply(source, context, consume_all)
+      return result if success
+      
+      # Aggregate all errors
+      value
+    }
+    
+    # If we reach this point, all alternatives have failed. 
+    context.err(self, source, @error_msg, errors)
+  end
+
+  precedence ALTERNATE
+  def to_s_inner(prec)
+    alternatives.map { |a| a.to_s(prec) }.join(' / ')
+  end
+end