swift-pyrite 0.1.0

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

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+# Example contributed by Hal Brodigan (postmodern). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+require 'parslet/convenience'
+
+class EmailParser < Parslet::Parser
+  rule(:space) { match('\s').repeat(1) }
+  rule(:space?) { space.maybe }
+  rule(:dash?) { match['_-'].maybe }
+
+  rule(:at) {
+    str('@') |
+    (dash? >> (str('at') | str('AT')) >> dash?)
+  }
+  rule(:dot) {
+    str('.') |
+    (dash? >> (str('dot') | str('DOT')) >> dash?)
+  }
+
+  rule(:word) { match('[a-z0-9]').repeat(1).as(:word) >> space? }
+  rule(:separator) { dot.as(:dot) >> space? | space }
+  rule(:words) { word >> (separator >> word).repeat }
+
+  rule(:email) {
+    (words.as(:username) >> space? >> at >> space? >> words).as(:email)
+  }
+
+  root(:email)
+end
+
+class EmailSanitizer < Parslet::Transform
+  rule(:dot => simple(:dot), :word => simple(:word)) { ".#{word}" }
+  rule(:word => simple(:word)) { word }
+
+  rule(:username => sequence(:username)) { username.join + "@" }
+  rule(:username => simple(:username)) { username.to_s + "@" }
+
+  rule(:email => sequence(:email)) { email.join }
+end
+
+parser = EmailParser.new
+sanitizer = EmailSanitizer.new
+
+input = ARGV[0] || begin
+  default = "a.b.c.d@gmail.com"
+  STDERR.puts "usage: #{$0} \"EMAIL_ADDR\""
+  STDOUT.puts "since you haven't specified any EMAIL_ADDR, for testing purposes we're using #{default}"
+  default
+end
+
+p sanitizer.apply(parser.parse_with_debug(input))

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

@@ -0,0 +1,13 @@
+# Basically just demonstrates that you can leave rules empty and get a nice
+# NotImplementedError. A way to quickly spec out your parser rules?
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+
+class Parser < Parslet::Parser
+  rule(:empty) { }
+end
+
+
+Parser.new.empty.parslet

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

@@ -0,0 +1,47 @@
+# Example that demonstrates how a simple erb-like parser could be constructed. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+
+class ErbParser < Parslet::Parser
+  rule(:ruby) { (str('%>').absent? >> any).repeat.as(:ruby) }
+  
+  rule(:expression) { (str('=') >> ruby).as(:expression) }
+  rule(:comment) { (str('#') >> ruby).as(:comment) }
+  rule(:code) { ruby.as(:code) }
+  rule(:erb) { expression | comment | code }
+  
+  rule(:erb_with_tags) { str('<%') >> erb >> str('%>') }
+  rule(:text) { (str('<%').absent? >> any).repeat(1) }
+  
+  rule(:text_with_ruby) { (text.as(:text) | erb_with_tags).repeat.as(:text) }
+  root(:text_with_ruby)
+end
+
+parser = ErbParser.new
+p parser.parse "The value of x is <%= x %>."
+p parser.parse "<% 1 + 2 %>"
+p parser.parse "<%# commented %>"
+ 
+
+evaluator = Parslet::Transform.new do
+  
+  erb_binding = binding
+  
+  rule(:code => { :ruby => simple(:ruby) }) { eval(ruby, erb_binding); '' }  
+  rule(:expression => { :ruby => simple(:ruby) }) { eval(ruby, erb_binding) }
+  rule(:comment => { :ruby => simple(:ruby) }) { '' }
+  
+  rule(:text => simple(:text)) { text }
+  rule(:text => sequence(:texts)) { texts.join }
+  
+end
+
+puts evaluator.apply(parser.parse(<<-ERB
+The <% a = 2 %>not printed result of "a = 2".
+The <%# a = 1 %>not printed non-evaluated comment "a = 1", see the value of a below.
+The <%= 'nicely' %> printed result.
+The <% b = 3 %>value of a is <%= a %>, and b is <%= b %>.
+ERB
+))

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

@@ -0,0 +1,33 @@
+# A small example on how to make parslet ignore parts of the parse tree. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+
+class IgnoreParslet < Parslet::Atoms::Base
+  def initialize(parslet)
+    @parslet = parslet
+  end
+  def to_s_inner(prec)
+    @parslet.to_s(prec)
+  end
+  def try(source, context, consume_all)
+    success, value = result = @parslet.try(source, context, consume_all)
+    
+    return succ(nil) if success
+    return result
+  end
+  
+end
+module IgnoreDSL
+  def ignore
+    IgnoreParslet.new(self)
+  end
+end
+
+class Parslet::Atoms::Base
+  include IgnoreDSL
+end
+
+include Parslet
+p (str('a') >> str('b').ignore >> str('c')).
+  parse('abc')

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

@@ -0,0 +1,125 @@
+# This example is heavily inspired by citrus' ip.citrus. Have a look at both
+# of these to get some choice!
+
+# The grammars in this file conform to the ABNF given in Appendix A of RFC 3986
+# Uniform Resource Identifier (URI): Generic Syntax.
+#
+# See http://tools.ietf.org/html/rfc3986#appendix-A for more information.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+module IPv4
+  include Parslet
+  
+  # A host identified by an IPv4 literal address is represented in
+  # dotted-decimal notation (a sequence of four decimal numbers in the range 0
+  # to 255, separated by "."), as described in [RFC1123] by reference to
+  # [RFC0952].  Note that other forms of dotted notation may be interpreted on
+  # some platforms, as described in Section 7.4, but only the dotted-decimal
+  # form of four octets is allowed by this grammar.
+  rule(:ipv4) {
+    (dec_octet >> str('.') >> dec_octet >> str('.') >>
+      dec_octet >> str('.') >> dec_octet).as(:ipv4)
+  }
+  
+  rule(:dec_octet) {
+    str('25') >> match("[0-5]") |
+    str('2') >> match("[0-4]") >> digit |
+    str('1') >> digit >> digit |
+    match('[1-9]') >> digit |
+    digit
+  }
+  
+  rule(:digit) {
+    match('[0-9]')
+  }
+end
+
+# Must be used in concert with IPv4
+module IPv6 
+  include Parslet
+  
+  rule(:colon) { str(':') }
+  rule(:dcolon) { colon >> colon }
+  
+  # h16 :
+  def h16r(times)
+    (h16 >> colon).repeat(times, times)
+  end
+  
+  # : h16
+  def h16l(times)
+    (colon >> h16).repeat(0,times)
+  end
+  
+  # A 128-bit IPv6 address is divided into eight 16-bit pieces. Each piece is
+  # represented numerically in case-insensitive hexadecimal, using one to four
+  # hexadecimal digits (leading zeroes are permitted). The eight encoded
+  # pieces are given most-significant first, separated by colon characters.
+  # Optionally, the least-significant two pieces may instead be represented in
+  # IPv4 address textual format. A sequence of one or more consecutive
+  # zero-valued 16-bit pieces within the address may be elided, omitting all
+  # their digits and leaving exactly two consecutive colons in their place to
+  # mark the elision.
+  rule(:ipv6) {
+    (
+      (
+        h16r(6) |
+        dcolon >> h16r(5) | 
+        h16.maybe >> dcolon >> h16r(4) |
+        (h16 >> h16l(1)).maybe >> dcolon >> h16r(3) |
+        (h16 >> h16l(2)).maybe >> dcolon >> h16r(2) |
+        (h16 >> h16l(3)).maybe >> dcolon >> h16r(1) |
+        (h16 >> h16l(4)).maybe >> dcolon
+      ) >> ls32 |
+      (h16 >> h16l(5)).maybe >> dcolon >> h16 |
+      (h16 >> h16l(6)).maybe >> dcolon
+    ).as(:ipv6)
+  }
+  
+  rule(:h16) {
+    hexdigit.repeat(1,4)
+  }
+  
+  rule(:ls32) {
+    (h16 >> colon >> h16) |
+    ipv4
+  }
+
+  rule(:hexdigit) {
+    digit | match("[a-fA-F]")
+  }
+end
+
+class Parser
+  include IPv4
+  include IPv6
+  
+  def parse(str)
+    (ipv4 | ipv6).parse(str)
+  end
+end
+
+%W(
+  0.0.0.0
+  255.255.255.255
+  255.255.255
+  1:2:3:4:5:6:7:8
+  12AD:34FC:A453:1922::
+  12AD::34FC
+  12AD::
+  ::
+  1:2
+).each do |address|
+  parser = Parser.new
+  printf "%30s -> ", address
+  begin
+    result = parser.parse(address)
+    puts result.inspect
+  rescue Parslet::ParseFailed => m
+    puts "Failed: #{m}"
+  end
+end

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

@@ -0,0 +1,128 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+#
+# MIT License - (c) 2011 John Mettraux
+#
+
+require 'rubygems'
+require 'parslet' # gem install parslet
+
+
+module MyJson
+
+  class Parser < Parslet::Parser
+
+    rule(:spaces) { match('\s').repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+
+    rule(:comma) { spaces? >> str(',') >> spaces? }
+    rule(:digit) { match('[0-9]') }
+
+    rule(:number) {
+      (
+        str('-').maybe >> (
+          str('0') | (match('[1-9]') >> digit.repeat)
+        ) >> (
+          str('.') >> digit.repeat(1)
+        ).maybe >> (
+          match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+        ).maybe
+      ).as(:number)
+    }
+
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any | str('"').absent? >> any
+      ).repeat.as(:string) >> str('"')
+    }
+
+    rule(:array) {
+      str('[') >> spaces? >>
+      (value >> (comma >> value).repeat).maybe.as(:array) >>
+      spaces? >> str(']')
+    }
+
+    rule(:object) {
+      str('{') >> spaces? >>
+      (entry >> (comma >> entry).repeat).maybe.as(:object) >>
+      spaces? >> str('}')
+    }
+
+    rule(:value) {
+      string | number |
+      object | array |
+      str('true').as(:true) | str('false').as(:false) |
+      str('null').as(:null)
+    }
+
+    rule(:entry) {
+      (
+         string.as(:key) >> spaces? >>
+         str(':') >> spaces? >>
+         value.as(:val)
+      ).as(:entry)
+    }
+
+    rule(:attribute) { (entry | value).as(:attribute) }
+
+    rule(:top) { spaces? >> value >> spaces? }
+
+    root(:top)
+  end
+
+  class Transformer < Parslet::Transform
+
+    class Entry < Struct.new(:key, :val); end
+
+    rule(:array => subtree(:ar)) {
+      ar.is_a?(Array) ? ar : [ ar ]
+    }
+    rule(:object => subtree(:ob)) {
+      (ob.is_a?(Array) ? ob : [ ob ]).inject({}) { |h, e| h[e.key] = e.val; h }
+    }
+
+    rule(:entry => { :key => simple(:ke), :val => simple(:va) }) {
+      Entry.new(ke, va)
+    }
+
+    rule(:string => simple(:st)) {
+      st.to_s
+    }
+    rule(:number => simple(:nb)) {
+      nb.match(/[eE\.]/) ? Float(nb) : Integer(nb)
+    }
+
+    rule(:null => simple(:nu)) { nil }
+    rule(:true => simple(:tr)) { true }
+    rule(:false => simple(:fa)) { false }
+  end
+
+  def self.parse(s)
+
+    parser = Parser.new
+    transformer = Transformer.new
+
+    tree = parser.parse(s)
+    puts; p tree; puts
+    out = transformer.apply(tree)
+
+    out
+  end
+end
+
+
+s = %{
+  [ 1, 2, 3, null,
+    "asdfasdf asdfds", { "a": -1.2 }, { "b": true, "c": false },
+    0.1e24, true, false, [ 1 ] ]
+}
+
+out = MyJson.parse(s)
+
+p out; puts
+
+out == [
+  1, 2, 3, nil,
+  "asdfasdf asdfds", { "a" => -1.2 }, { "b" => true, "c" => false },
+  0.1e24, true, false, [ 1 ]
+] || raise("MyJson is a failure")

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

@@ -0,0 +1,34 @@
+
+# An exploration of two ideas: 
+#   a) Constructing a whole parser inline, without the artificial class around
+#      it. 
+# and:
+#   b) Constructing non-greedy or non-blind parsers by transforming the 
+#      grammar.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+include Parslet
+
+a =  str('a').repeat >> str('aa')
+
+# E1% E2
+# 
+# S = E2 | E1 S 
+
+def this(name, &block); return Parslet::Atoms::Entity.new(name, &block) end
+def epsilon; any.absent? end 
+
+# Traditional repetition will try as long as the pattern can be matched and 
+# then give up. This is greedy and blind. 
+a = str('a').as(:e) >> this('a') { a }.as(:rec) | epsilon
+
+# Here's a pattern match that is greedy and non-blind. The first pattern
+# 'a'* will be tried as many times as possible, while still matching the 
+# end pattern 'aa'.
+b = str('aa').as(:e2) >> epsilon | str('a').as(:e1) >> this('b') { b }.as(:rec)
+
+p a.parse('aaaa')
+p b
+p b.parse('aaaa')

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

@@ -0,0 +1,44 @@
+# Demonstrates that we have a compatibility fix to mathn's weird idea of 
+# integer mathematics. 
+# This was contributed by Jonathan Hinkle (https://github.com/hynkle). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+require 'parslet/convenience'
+include Parslet
+
+def attempt_parse
+  possible_whitespace = match['\s'].repeat
+
+  cephalopod =
+    str('octopus') |
+    str('squid')
+
+  parenthesized_cephalopod =
+    str('(') >>
+    possible_whitespace >>
+    cephalopod >>
+    possible_whitespace >>
+    str(')')
+
+  parser =
+    possible_whitespace >>
+    parenthesized_cephalopod >>
+    possible_whitespace
+
+  # This parse fails, but that is not the point. When mathn is in the current
+  # ruby environment, it modifies integer division in a way that makes 
+  # parslet loop indefinitely.
+  parser.parse %{(\nsqeed)\n}
+rescue Parslet::ParseFailed
+end
+
+attempt_parse 
+puts 'it terminates before we require mathn'
+
+puts "requiring mathn now"
+require 'mathn'
+puts "and trying again (will hang without the fix)"
+attempt_parse # but it doesn't terminate after requiring mathn
+puts "okay!"

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

@@ -0,0 +1,94 @@
+# Reproduces [1] using parslet. 
+# [1] http://thingsaaronmade.com/blog/a-quick-intro-to-writing-a-parser-using-treetop.html
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+require 'parslet/convenience'
+
+module MiniLisp
+  class Parser < Parslet::Parser
+    root :expression
+    rule(:expression) {
+      space? >> str('(') >> space? >> body >> str(')') >> space?
+    }
+    
+    rule(:body) {
+      (expression | identifier | float | integer | string).repeat.as(:exp)
+    }
+    
+    rule(:space) {
+      match('\s').repeat(1)
+    }
+    rule(:space?) {
+      space.maybe
+    }
+    
+    rule(:identifier) { 
+      (match('[a-zA-Z=*]') >> match('[a-zA-Z=*_]').repeat).as(:identifier) >> space?
+    }
+    
+    rule(:float) { 
+      (
+        integer >> (
+          str('.') >> match('[0-9]').repeat(1) |
+          str('e') >> match('[0-9]').repeat(1)
+        ).as(:e)
+      ).as(:float) >> space?
+    }
+    
+    rule(:integer) {
+      ((str('+') | str('-')).maybe >> match("[0-9]").repeat(1)).as(:integer) >> space?
+    }
+    
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any |
+        str('"').absent? >> any 
+      ).repeat.as(:string) >> str('"') >> space?
+    }
+  end
+  
+  class Transform
+    include Parslet
+    
+    attr_reader :t
+    def initialize
+      @t = Parslet::Transform.new
+      
+      # To understand these, take a look at what comes out of the parser. 
+      t.rule(:identifier => simple(:ident)) { ident.to_sym }
+        
+      t.rule(:string => simple(:str))       { str }
+        
+      t.rule(:integer => simple(:int))      { Integer(int) }
+        
+      t.rule(:float=>{:integer=> simple(:a), :e=> simple(:b)}) { Float(a + b) }
+        
+      t.rule(:exp => subtree(:exp))         { exp }
+    end
+    
+    def do(tree)
+      t.apply(tree)
+    end
+  end
+end
+
+parser = MiniLisp::Parser.new
+transform = MiniLisp::Transform.new
+
+result = parser.parse_with_debug %Q{
+  (define test (lambda ()
+    (begin
+      (display "something")
+      (display 1)
+      (display 3.08))))
+}
+
+# Transform the result
+pp transform.do(result) if result
+
+# Thereby reducing it to the earlier problem: 
+# http://github.com/kschiess/toylisp
+

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

@@ -0,0 +1,47 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require "parslet"
+
+# Demonstrates modular parsers, split out over many classes. Please look at
+# ip_address.rb as well.
+
+module ALanguage
+  include Parslet
+    
+  # Parslet rules are really a special kind of method. Mix them into your
+  # classes!
+  rule(:a_language) { str('aaa') }
+end
+
+# Parslet parsers are parslet atoms as well. Create an instance and chain them
+# to your other rules. 
+#
+class BLanguage < Parslet::Parser
+  root :blang
+  
+  rule(:blang) { str('bbb') }
+end
+
+# Parslet atoms are really Ruby values, pass them around. 
+c_language = Parslet.str('ccc')
+  
+class Language < Parslet::Parser
+  def initialize(c_language)
+    @c_language = c_language
+    super()
+  end
+  
+  root :root
+
+  include ALanguage
+  
+  rule(:root) { str('a(') >> a_language >> str(')') >> space |
+                str('b(') >> BLanguage.new >> str(')') >> space | 
+                str('c(') >> @c_language >> str(')') >> space }
+  rule(:space) { str(' ').maybe }
+end
+
+Language.new(c_language).parse('a(aaa)')
+Language.new(c_language).parse('b(bbb)')
+Language.new(c_language).parse('c(ccc)')