swift-pyrite 0.1.0

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/parsing_rule_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module ParsingRuleSpec
+  describe "a grammar with one parsing rule" do
+
+    testing_grammar %{
+      grammar Foo
+        rule bar
+          "baz"
+        end
+      end
+    }
+
+    it "stores and retrieves nodes in its node cache" do
+      parser = self.class.const_get(:FooParser).new
+      parser.send(:prepare_to_parse, 'baz')
+      node_cache = parser.send(:node_cache)
+    
+      node_cache[:bar][0].should be_nil
+    
+      parser._nt_bar
+    
+      cached_node = node_cache[:bar][0]        
+      cached_node.should be_an_instance_of(Runtime::SyntaxNode)
+      cached_node.text_value.should == 'baz'
+    
+      parser.instance_eval { @index = 0 }
+      parser._nt_bar.should equal(cached_node)
+      parser.index.should == cached_node.interval.end
+    end
+  end
+  
+  
+  describe "a grammar with choice that uses the cache and has a subsequent expression" do    
+    testing_grammar %{
+      grammar Logic
+        rule expression
+          value_plus
+          /
+          value
+        end
+
+        rule value_plus
+          value "something else"
+        end
+
+        rule value
+          [a-z]
+          /
+          "foobar" # the subsequent expression that needs cached.interval.end
+        end
+      end
+    }
+    
+    it "parses a single-character value and generates a node from the cache" do
+      result = parse('a')
+      result.should be_a(Treetop::Runtime::SyntaxNode)
+      result.elements.should be_nil
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/repeated_subrule_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module RepeatedSubruleSpec
+  describe "a repeated subrule" do
+    testing_grammar %{
+      grammar Foo
+        rule foo
+          a:'a' space b:'b' space 'cc'
+        end
+
+        rule space
+          ' '
+        end
+      end
+    }
+  
+    it "should produce a parser having sequence-numbered node accessor methods" do
+      parse("a b cc") do |result|
+        result.should_not be_nil
+        result.should respond_to(:space1)
+        result.should respond_to(:space2)
+        result.should_not respond_to(:space)
+        result.should respond_to(:a)
+        result.should respond_to(:b)
+        result.should_not respond_to(:c)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/semantic_predicate_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+module SemanticPredicateSpec
+  describe "An &-predicate block" do
+    testing_expression '& {|| $ok_to_succeed}'
+
+    it "succeeds if it returns true, returning an epsilon syntax node" do
+      $ok_to_succeed = true
+      parse('foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.interval.should == (0...0)
+      end
+    end
+
+    it "fails if it returns false" do
+      $ok_to_succeed = false
+      parse('foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+  end
+
+  describe "A sequence of a terminal and an &-predicate block" do
+    testing_expression '"prior " &{|s| $value = s[0].text_value; $ok_to_succeed }'
+
+    it "matches the input terminal and consumes it if the block returns true, seeing the terminal in the sequence" do
+      $ok_to_succeed = true
+      $value = nil
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.elements[0].text_value.should == "prior "
+        result.text_value.should == 'prior '
+        $value.should == 'prior '
+      end
+    end
+
+    it "fails if the block returns false, but sees the terminal in the sequence" do
+      $ok_to_succeed = false
+      $value = nil
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        $value.should == 'prior '
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+  end
+
+  describe "A sequence of an optional terminal and an &-predicate block" do
+    testing_expression '"prior "? &{|s| $value = s[0].text_value; $ok_to_succeed}'
+
+    it "matches the input terminal and consumes it if the block returns true" do
+      $ok_to_succeed = true
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.elements[0].text_value.should == "prior "
+        result.text_value.should == 'prior '
+        $value.should == 'prior '
+      end
+    end
+
+    it "fails with one terminal_failure if the block returns false" do
+      $ok_to_succeed = false
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        $value.should == 'prior '
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+    it "fail and return the expected optional preceeding terminal as expected input if the block returns false" do
+      $ok_to_succeed = false
+      parse('foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+	# We should get "prior " failed, and also the predicate block
+        terminal_failures.size.should == 2
+        terminal_failures[0].index.should == 0
+        terminal_failures[0].expected_string.should == '"prior "'
+        terminal_failures[1].index.should == 0
+        terminal_failures[1].expected_string.should == '<semantic predicate>'
+      end
+    end
+
+  end
+
+  describe "A !-predicate block" do
+    testing_expression '! {|| $ok_to_succeed}'
+
+    it "succeeds if it returns false, returning an epsilon syntax node" do
+      $ok_to_succeed = false
+      parse('foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.interval.should == (0...0)
+      end
+    end
+
+    it "fails if it returns true" do
+      $ok_to_succeed = true
+      parse('foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+  end
+
+  describe "A sequence of a terminal and an !-predicate block" do
+    testing_expression '"prior " !{|s| $value = s[0].text_value; $ok_to_succeed }'
+
+    it "matches the input terminal and consumes it if the block returns false, seeing the terminal in the sequence" do
+      $ok_to_succeed = false
+      $value = nil
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.elements[0].text_value.should == "prior "
+        result.text_value.should == 'prior '
+        $value.should == 'prior '
+      end
+    end
+
+    it "fails if the block returns true, but sees the terminal in the sequence" do
+      $ok_to_succeed = true
+      $value = nil
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        $value.should == 'prior '
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+  end
+
+  describe "A sequence of an optional terminal and an !-predicate block" do
+    testing_expression '"prior "? !{|s| $value = s[0].text_value; $ok_to_succeed}'
+
+    it "matches the input terminal and consumes it if the block returns false" do
+      $ok_to_succeed = false
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.elements[0].text_value.should == "prior "
+        result.text_value.should == 'prior '
+        $value.should == 'prior '
+      end
+    end
+
+    it "fails with one terminal_failure if the block returns true" do
+      $ok_to_succeed = true
+      parse('prior foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        $value.should == 'prior '
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+
+    it "fail and return the expected optional preceeding terminal as expected input if the block returns true" do
+      $ok_to_succeed = true
+      parse('foo', :consume_all_input => false) do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 2
+        terminal_failures[0].index.should == 0
+        terminal_failures[0].expected_string.should == '"prior "'
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/sequence_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+module SequenceSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "a sequence of labeled terminal symbols followed by a node class declaration and a block" do
+    testing_expression 'foo:"foo" bar:"bar" baz:"baz" <SequenceSpec::Foo> { def a_method; end }'
+
+    it "upon successfully matching input, instantiates an instance of the declared node class with element accessor methods and the method from the inline module" do
+      parse('foobarbaz') do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.foo.text_value.should == 'foo'
+        result.bar.text_value.should == 'bar'
+        result.baz.text_value.should == 'baz'
+      end
+    end
+
+    it "successfully matches at a non-zero index" do
+      parse('---foobarbaz', :index => 3) do |result|
+        result.should_not be_nil
+        result.should be_nonterminal
+        (result.elements.map {|elt| elt.text_value}).join.should == 'foobarbaz'
+      end
+    end
+
+    it "fails to match non-matching input, recording the parse failure of first non-matching terminal" do
+      parse('---foobazbaz', :index => 3) do |result|
+        result.should be_nil
+        parser.index.should == 3
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 6
+        failure.expected_string.should == '"bar"'
+      end
+    end
+  end
+
+  module ModFoo
+  def mod_method; end
+  end
+
+  describe "a sequence of labeled terminal symbols followed by a node module declaration and a block" do
+    testing_expression 'foo:"foo" bar:"bar" baz:"baz" <SequenceSpec::ModFoo> { def a_method; end }'
+
+    it "upon successfully matching input, instantiates a syntax node and extends it with the declared module, element accessor methods, and the method from the inline module" do
+      parse('foobarbaz') do |result|
+        result.should_not be_nil
+        result.should respond_to(:mod_method)
+        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+        result.should be_a_kind_of(ModFoo)
+        result.should respond_to(:a_method)
+        result.foo.text_value.should == 'foo'
+        result.bar.text_value.should == 'bar'
+        result.baz.text_value.should == 'baz'
+      end
+    end
+  end
+
+  describe "a labeled single element sequence followed by a node module declaration and a block" do
+    testing_expression 'foo:"foo"+ <SequenceSpec::ModFoo> { def a_method; end }'
+    it "upon successfully matching input, instantiates a syntax node and extends it with the declared module, element accessor methods, and the method from the inline module" do
+      parse('foofoofoo') do |result|
+        result.should_not be_nil
+        result.should respond_to(:mod_method)
+        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+        result.should be_a_kind_of(ModFoo)
+        result.should respond_to(:a_method)
+        result.foo.text_value.should == 'foofoofoo'
+      end
+    end
+  end
+
+  describe "a sequence of non-terminals" do
+    testing_grammar %{
+      grammar TestGrammar
+        rule sequence
+          foo bar baz {
+            def baz
+              'override' + super.text_value
+            end
+          }
+        end
+
+        rule foo 'foo' end
+        rule bar 'bar' end
+        rule baz 'baz' end
+      end
+    }
+
+    it "defines accessors for non-terminals automatically that can be overridden in the inline block" do
+      parse('foobarbaz') do |result|
+        result.foo.text_value.should == 'foo'
+        result.bar.text_value.should == 'bar'
+        result.baz.should == 'overridebaz'
+      end
+    end
+  end
+
+  describe "Compiling a sequence containing various white-space errors" do
+    it "should succeed on a valid sequence" do
+      compiling_expression('foo:"foo" "bar" <SequenceSpec::Foo> { def a_method; end }').should_not raise_error
+    end
+
+    it "rejects space after a label" do
+      compiling_expression('foo :"foo" "bar"').should raise_error(RuntimeError)
+    end
+
+    it "rejects space after label's colon" do
+      compiling_expression('foo: "foo" "bar"').should raise_error(RuntimeError)
+    end
+
+    it "rejects missing space after a primary" do
+      compiling_expression('foo:"foo""bar"').should raise_error(RuntimeError)
+    end
+
+    it "rejects missing space before node class declaration" do
+      compiling_expression('foo:"foo" "bar"<SequenceSpec::Foo>').should raise_error(RuntimeError)
+    end
+    
+    it "rejects missing space before inline module" do
+      compiling_expression('foo:"foo" "bar" <SequenceSpec::Foo>{def a_method; end}').should raise_error(RuntimeError)
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/terminal_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+module TerminalSymbolSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "a terminal symbol" do
+    testing_expression "'Foo'"
+
+    it "matches the input string" do
+      parse "Foo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'Foo'
+      end
+    end
+
+    it "fails to match the input string other than at the start" do
+      parse " Foo", :index => 0 do |result|
+        result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+
+    it "fails to match the input string in the wrong case" do
+      parse "foo", :index => 0 do |result|
+        result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  describe "a terminal symbol with case-insensitive matching" do
+    testing_expression "'Foo'i"
+
+    it "matches the input string in the same case" do
+      parse "Foo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'Foo'
+      end
+    end
+
+    it "matches the input string in varied case" do
+      parse "foO", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'foO'
+      end
+    end
+  end
+
+  describe "a terminal symbol followed by a node class declaration and a block" do
+    testing_expression "'foo' <TerminalSymbolSpec::Foo> { def a_method; end }"
+
+    it "correctly parses matching input prefixes at various indices, returning an instance of the declared class that can respond to methods defined in the inline module" do
+      parse "foo", :index => 0 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (0...3)
+        result.text_value.should == 'foo'
+      end
+
+      parse "xfoo", :index => 1 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (1...4)
+        result.text_value.should == 'foo'
+      end
+    
+      parse "---foo", :index => 3 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (3...6)
+        result.text_value.should == 'foo'
+      end
+    end
+
+    it "fails to parse nonmatching input at the index even if a match occurs later" do
+      parse(" foo", :index =>  0) do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  module ModFoo
+  end
+
+  describe "a terminal symbol followed by a node class declaration and a block" do
+    testing_expression "'foo' <TerminalSymbolSpec::ModFoo> { def a_method; end }"
+
+    it "correctly parses matching input prefixes at various indices, returning an instance of SyntaxNode extended with the declared module that can respond to methods defined in the inline module" do
+      parse "foo", :index => 0 do |result|
+        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+        result.should be_a_kind_of(ModFoo)
+        result.should respond_to(:a_method)
+        result.interval.should == (0...3)
+        result.text_value.should == 'foo'
+      end
+
+      parse "xfoo", :index => 1 do |result|
+        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+        result.should be_a_kind_of(ModFoo)
+        result.should respond_to(:a_method)
+        result.interval.should == (1...4)
+        result.text_value.should == 'foo'
+      end
+    
+      parse "---foo", :index => 3 do |result|
+        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+        result.should be_a_kind_of(ModFoo)
+        result.should respond_to(:a_method)
+        result.interval.should == (3...6)
+        result.text_value.should == 'foo'
+      end
+    end
+  end
+
+  describe "a terminal regexp" do
+    testing_expression "'Fo+'r"
+
+    it "matches the input string" do
+      parse "Fooo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...4)
+        result.text_value.should == 'Fooo'
+      end
+    end
+
+    it "fails to match the input string other than at the start" do
+      parse " Foo", :index => 0 do |result|
+        result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+
+    it "fails to match the input string in the wrong case" do
+      parse "foo", :index => 0 do |result|
+        result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  describe "a case-insensitive terminal regexp" do
+    testing_expression "'Fo+'ri"
+
+    it "matches the input string in the same case" do
+      parse "Fooo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...4)
+        result.text_value.should == 'Fooo'
+      end
+    end
+
+    it "matches the input string in the same case" do
+      parse "foOo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...4)
+        result.text_value.should == 'foOo'
+      end
+    end
+  end
+
+#  Transient symbols were part of some idea of Nathan's that I no longer recall
+#  describe "a transient terminal symbol" do
+#    testing_expression "~'foo'"
+#
+#    it "returns true upon parsing matching input prefixes at various indices" do
+#      pending "transient terminal expressions"
+#      parse("foo", :index => 0).should be_true
+#      parse("-foo", :index => 1).should be_true
+#      parse("---foo", :index => 3).should be_true
+#    end
+#  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/terminal_symbol_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module TerminalSymbolSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "a terminal symbol followed by a node class declaration and a block" do
+    testing_expression "'foo' <TerminalSymbolSpec::Foo> { def a_method; end }"
+
+    it "correctly parses matching input prefixes at various indices, returning an instance of the declared class that can respond to methods defined in the inline module" do
+      parse "foo", :index => 0 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (0...3)
+        result.text_value.should == 'foo'
+      end
+
+      parse "xfoo", :index => 1 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (1...4)
+        result.text_value.should == 'foo'
+      end
+    
+      parse "---foo", :index => 3 do |result|
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (3...6)
+        result.text_value.should == 'foo'
+      end
+    end
+
+    it "fails to parse nonmatching input at the index even if a match occurs later" do
+      parse(" foo", :index =>  0) do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/test_grammar.treetop

@@ -0,0 +1,7 @@
+module Test
+  grammar Grammar
+    rule foo
+      'foo'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/test_grammar.tt

@@ -0,0 +1,7 @@
+module Test
+  grammar Grammar
+    rule foo
+      'foo'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/test_grammar_do.treetop

@@ -0,0 +1,7 @@
+module Test
+  grammar Grammar do
+    rule foo do
+      'foo'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/test_grammar_magic_coding.treetop

@@ -0,0 +1,8 @@
+# coding: UTF-8
+module Test
+  grammar Grammar do
+    rule foo do
+      'foo'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/compiler/test_grammar_magic_encoding.treetop

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+module Test
+  grammar Grammar do
+    rule foo do
+      'foo'
+    end
+  end
+end