swift-pyrite 0.1.0

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "An expression for braces surrounding zero or more letters followed by semicolons" do
+  testing_expression "'{' ([a-z] ';')* '}'"
+  
+  it "parses matching input successfully" do
+    parse('{a;b;c;}').should_not be_nil
+  end
+  
+  it "fails to parse input with an expression that is missing a semicolon, reporting the terminal failure occurring at the maximum index" do
+    parse('{a;b;c}') do |result|
+      result.should be_nil
+      
+      terminal_failures = parser.terminal_failures
+      terminal_failures.size.should == 1      
+      failure = terminal_failures[0]
+      failure.index.should == 6
+      failure.expected_string.should == "';'"
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe Compiler::GrammarCompiler do
+  attr_reader :compiler, :source_path_with_treetop_extension, :source_path_with_tt_extension, :target_path, :alternate_target_path
+  before do
+    @compiler = Compiler::GrammarCompiler.new
+
+    dir = File.dirname(__FILE__)
+    @tmpdir = Dir.tmpdir
+
+    @source_path_with_treetop_extension = "#{dir}/test_grammar.treetop"
+    @source_path_with_do = "#{dir}/test_grammar_do.treetop"
+    @source_path_with_tt_extension = "#{dir}/test_grammar.tt"
+    @source_path_with_magic_coding = "#{dir}/test_grammar_magic_coding.treetop"
+    @source_path_with_magic_encoding = "#{dir}/test_grammar_magic_encoding.treetop"
+    @target_path = "#{@tmpdir}/test_grammar.rb"
+    @target_path_with_do = "#{@tmpdir}/test_grammar_do.rb"
+    @target_path_with_magic_coding = "#{@tmpdir}/test_grammar_magic_coding.rb"
+    @target_path_with_magic_encoding = "#{@tmpdir}/test_grammar_magic_encoding.rb"
+    @alternate_target_path = "#{@tmpdir}/test_grammar_alt.rb"
+    delete_target_files
+  end
+
+  after do
+    delete_target_files
+    Object.class_eval do
+      remove_const(:Test) if const_defined?(:Test)
+    end
+  end
+
+  specify "compilation of a single file to a default file name" do
+    src_copy = "#{@tmpdir}/test_grammar.treetop"
+    File.open(source_path_with_treetop_extension) { |f| File.open(src_copy,'w'){|o|o.write(f.read)} }
+    File.exists?(target_path).should be_falsey
+    compiler.compile(src_copy)
+    File.exists?(target_path).should be_truthy
+    require target_path
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+  specify "compilation of a single file to an explicit file name" do
+    File.exists?(alternate_target_path).should be_falsy
+    compiler.compile(source_path_with_treetop_extension, alternate_target_path)
+    File.exists?(alternate_target_path).should be_truthy
+    require alternate_target_path
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+  specify "compilation of a single file without writing it to an output file" do
+    compiler.ruby_source(source_path_with_treetop_extension).should_not be_nil
+  end
+  
+  specify "ruby_source_from_string compiles a grammar stored in string" do
+    compiler.ruby_source_from_string(File.read(source_path_with_treetop_extension)).should_not be_nil
+  end
+
+  specify "Treetop.load_from_string compiles and evaluates a source grammar stored in string" do
+    Treetop.load_from_string File.read(source_path_with_treetop_extension)
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+  specify "Treetop.load compiles and evaluates a source grammar with a .treetop extension" do    
+    Treetop.load source_path_with_treetop_extension
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+  
+  specify "Treetop.load compiles and evaluates a source grammar with a .tt extension" do
+    path_without_extension = source_path_with_tt_extension
+    Treetop.load path_without_extension
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+
+  specify "Treetop.load compiles and evaluates source grammar with no extension" do
+    path_without_extension = source_path_with_treetop_extension.gsub(/\.treetop\Z/, '')
+    Treetop.load path_without_extension
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+  specify "grammars with 'do' compile" do
+    src_copy = "#{@tmpdir}/test_grammar_do.treetop"
+    File.open(@source_path_with_do) { |f| File.open(src_copy,'w'){|o|o.write(f.read)} }
+    compiler.compile(src_copy)
+    require @target_path_with_do
+    Test::GrammarParser.new.parse('foo').should_not be_nil
+  end
+
+  specify "grammars with magic 'encoding' comments keep those comments at the top" do
+    src_copy = "#{@tmpdir}/test_grammar_magic_encoding.treetop"
+    File.open(@source_path_with_magic_encoding) do |f|
+      File.open(src_copy,'w'){|o|o.write(f.read)}
+    end
+    compiler.compile(src_copy)
+    File.open(@target_path_with_magic_encoding).readline.should == "# encoding: UTF-8\n"
+  end
+
+  specify "grammars with magic 'coding' comments keep those comments at the top" do
+    src_copy = "#{@tmpdir}/test_grammar_magic_coding.treetop"
+    File.open(@source_path_with_magic_coding) do |f|
+      File.open(src_copy,'w'){|o|o.write(f.read)}
+    end
+    compiler.compile(src_copy)
+    File.open(@target_path_with_magic_coding).readline.should == "# coding: UTF-8\n"
+  end
+
+  def delete_target_files
+    File.delete(target_path) if File.exists?(target_path)
+    File.delete(@target_path_with_do) if File.exists?(@target_path_with_do)
+    File.delete(alternate_target_path) if File.exists?(alternate_target_path)
+  end
+end
+

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module GrammarSpec
+  module Bar
+  end
+
+  describe "a grammar" do
+    testing_grammar %{
+      grammar Foo
+              # This comment should not cause a syntax error, nor should the following empty one
+              #
+        include GrammarSpec::Bar
+
+        rule foo
+          bar / baz
+        end
+
+        rule bar
+          'bar' 'bar'
+        end
+
+        rule baz
+          'baz' 'baz'
+        end
+      end
+    }
+
+    it "parses matching input" do
+      parse('barbar').should_not be_nil
+      parse('bazbaz').should_not be_nil
+    end
+
+    it "fails if it does not parse all input" do
+      parse('barbarbazbaz') do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+
+    it "mixes in included modules" do
+      self.class.const_get(:Foo).ancestors.should include(GrammarSpec::Bar)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module MultibyteCharsSpec
+  describe "an anything symbol", :multibyte => true do
+    testing_expression '.'
+    it "matches an UTF-8 character" do
+      parse_multibyte("ø").should_not be_nil
+    end
+  end
+
+  describe "A character class containing UTF-8 characters", :multibyte => true  do
+    testing_expression "[æøå]"
+    it "recognizes the UTF-8 characters" do
+      parse_multibyte("ø").should_not be_nil
+    end
+  end
+
+  describe( "a character class repetition containing UTF-8 characters mixed with other expressions",
+    :multibyte => true
+  ) do
+    testing_expression '[æøå]+ "a"'
+    it "lazily instantiates a node for the character" do
+      result = parse_multibyte('æøåa')
+      pending "Multibyte support is not supported in Ruby 1.8.6" if RUBY_VERSION =~ /^1\.8.6/
+      result.elements[0].instance_variable_get("@elements").should include(true)
+      result.elements[0].elements.should_not include(true)
+      result.elements[0].elements.size.should == 3
+      result.elements.size.should == 2
+      result.elements[0].text_value.should == "æøå"
+      result.elements[0].elements[0].text_value.should == "æ"
+      result.elements[0].elements[1].text_value.should == "ø"
+      result.elements[0].elements[2].text_value.should == "å"
+      result.elements[1].text_value == "a"
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module NamespaceSpec
+
+  describe "a grammar" do
+    class_eval("module Foo; end")
+    testing_grammar %{
+      module Foo::Bar
+        module Baz
+          grammar Bat
+            rule foo
+              bar / baz
+            end
+
+            rule bar
+              'bar' 'bar'
+            end
+
+            rule baz
+              'baz' 'baz'
+            end
+          end
+        end
+      end
+    }
+
+    it "parses matching input" do
+      parse('barbar').should_not be_nil
+      parse('bazbaz').should_not be_nil
+    end
+
+    it "mixes in included modules" do
+      foo = self.class.const_get(:Foo)
+      bar = foo.const_get(:Bar)
+      baz = bar.const_get(:Baz)
+      baz.class.should == Module
+      bat = baz.const_get(:Bat)
+      bat.class.should == Module
+      baz.const_get(:BatParser).class.should == Class
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module NonterminalSymbolSpec
+  describe "A nonterminal symbol followed by a block" do
+    testing_expression 'foo { def a_method; end }'
+  
+    parser_class_under_test.class_eval do
+      def _nt_foo
+        '_nt_foo called'
+      end
+    end
+  
+    it "compiles to a method call, extending its results with the anonymous module for the block" do
+      result = parse('')
+      result.should == '_nt_foo called'
+      result.should respond_to(:a_method)
+    end
+  end
+
+  module TestModule
+    def a_method
+    end
+  end
+
+  describe "a non-terminal followed by a module declaration" do
+    testing_expression 'foo <NonterminalSymbolSpec::TestModule>'
+  
+    parser_class_under_test.class_eval do
+      def _nt_foo
+        '_nt_foo called'
+      end
+    end
+  
+    it "compiles to a method call, extending its results with the anonymous module for the block" do
+      result = parse('')
+      result.should == '_nt_foo called'
+      result.should respond_to(:a_method)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module NotPredicateSpec
+  describe "A !-predicated terminal symbol" do
+    testing_expression '!"foo"'
+
+    it "fails to parse input matching the terminal symbol" do
+      parse('foo') do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  describe "A !-predicated character class symbol" do
+    testing_expression '![aeiou]'
+
+    it "fails to parse input matching the terminal symbol" do
+      parse('e') do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  describe "A sequence of a terminal and an and another !-predicated terminal" do
+    testing_expression '"foo" !"bar"'
+
+    it "fails to match input matching both terminals" do
+      parse('foobar').should be_nil
+    end
+  
+    it "successfully parses input matching the first terminal and not the second, reporting the parse failure of the second terminal" do
+      parse('foo') do |result|
+        result.should_not be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+  end
+
+  describe "A !-predicated sequence" do
+    testing_expression '!("a" "b" "cc")'
+
+    it "fails to parse matching input" do
+      parse('abcc') 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/occurrence_range_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+module OccurrenceRangeSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "zero to two of a terminal symbol followed by a node class declaration and a block" do
+    testing_expression '"foo"..2 <OccurrenceRangeSpec::Foo> { def a_method; end }'
+
+    it "successfully parses epsilon, reporting a failure" do
+      parse('') do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+
+    it "successfully parses epsilon, returning an instance declared node class and recording a terminal failure" do
+      parse('') do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+
+    it "successfully parses one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
+      parse("foo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+
+    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
+      parse("foofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+
+    it "fails to parses two of that terminal but fails because of an extra one" do
+      parse("foofoofoo") do |result|
+        result.should be_nil
+
+	parser.terminal_failures.size.should == 1
+      end
+    end
+
+    it "parses two of three of that terminal, reporting no failure" do
+      parse("foofoofoo", :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.elements.size.should == 2
+
+	parser.terminal_failures.size.should == 0
+      end
+    end
+
+  end
+
+  describe "two to four of a terminal symbol followed by a node class declaration and a block" do
+    testing_expression '"foo" 2..4 <OccurrenceRangeSpec::Foo> { def a_method; end }'
+
+    it "fails to parse epsilon, reporting a failure" do
+      parse('') do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 0
+        failure.expected_string.should == '"foo"'
+      end
+    end
+
+    it "fails to parse one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
+      parse("foo") do |result|
+        result.should be_nil
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 3
+        failure.expected_string.should == '"foo"'
+      end
+    end
+
+    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
+      parse("foofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 0
+      end
+    end
+
+    it "successfully parses four of that terminal, returning an instance of the declared node class and reporting no failure" do
+      parse("foofoofoofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 0
+      end
+    end
+
+    it "fails to parses four of that terminal because there's an extra unconsumed one" do
+      parse("foofoofoofoofoo") do |result|
+        result.should be_nil
+
+        terminal_failures = parser.terminal_failures
+	terminal_failures.size.should == 1
+      end
+    end
+  end
+
+  describe "two to any number of a terminal symbol followed by a node class declaration and a block" do
+    testing_expression '"foo" 2.. <OccurrenceRangeSpec::Foo> { def a_method; end }'
+
+    it "fails to parse epsilon, reporting a failure" do
+      parse('') do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 0
+        failure.expected_string.should == '"foo"'
+      end
+    end
+
+    it "fails to parse one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
+      parse("foo") do |result|
+        result.should be_nil
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 3
+        failure.expected_string.should == '"foo"'
+      end
+    end
+
+    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
+      parse("foofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 6
+        failure.expected_string.should == '"foo"'
+      end
+    end
+
+    it "successfully parses four of that terminal, returning an instance of the declared node class and reporting a failure on the fifth" do
+      parse("foofoofoofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 12
+        failure.expected_string.should == '"foo"'
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module OneOrMoreSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "one or more of a terminal symbol followed by a node class declaration and a block" do
+    testing_expression '"foo"+ <OneOrMoreSpec::Foo> { def a_method; end }'
+
+    it "fails to parse epsilon, reporting a failure" do
+      parse('') do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 0
+        failure.expected_string.should == '"foo"'
+      end
+    end
+  
+    it "successfully parses two of that terminal in a row, returning an instance of the declared node class and reporting the failure the third parsing attempt" do
+      parse("foofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 6
+        failure.expected_string.should == '"foo"'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module OptionalSpec
+  describe "An optional terminal symbol" do
+    testing_expression '"foo"?'
+  
+    it "parses input matching the terminal" do
+      parse('foo').should_not be_nil
+    end
+  
+    it "parses epsilon, recording a failure" do
+      parse('') do |result|
+        result.should_not be_nil
+        result.interval.should == (0...0)
+        
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 0
+        failure.expected_string.should == '"foo"'
+      end
+    end
+  
+    it "parses input not matching the terminal, returning an epsilon result and recording a failure" do
+      parse('bar', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.interval.should == (0...0)
+        
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures.first
+        failure.index.should == 0
+        failure.expected_string.should == '"foo"'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module ParenthesizedExpressionSpec
+  describe "An unadorned expression inside of parentheses" do
+    testing_expression '("foo")'
+  
+    it "should behave as normal" do
+      parse('foo').should_not be_nil
+    end
+  end
+
+  describe "A prefixed-expression inside of parentheses" do
+    testing_expression '(!"foo")'
+  
+    it "should behave as normal" do
+      parse('foo') do |result|
+	result.should be_nil
+	parser.terminal_failures.size.should == 1
+      end
+    end
+  end
+end