swift-pyrite 0.1.0

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

@@ -0,0 +1,224 @@
+require 'digest/sha1'
+require 'tmpdir'
+
+# ensure the Kernel.system and Kernel.open's always use the correct tt and
+# Treetop library versions, not a previously installed gem
+ENV['PATH'] = File.expand_path(File.dirname(__FILE__) + '../../../bin' +
+                              File::PATH_SEPARATOR + ENV['PATH'])
+$LOAD_PATH.unshift(File.expand_path('../../../../lib', __FILE__))
+
+describe "The 'tt' comand line compiler" do
+  before(:each) do
+    @tmpdir = Dir.tmpdir
+  end
+
+  context 'when processing a single grammar file' do
+    before(:each) do
+      # create a fresh but dumb grammar file for each example
+      @test_base = "dumb-#{rand(1000)}"
+      @test_path = "#{@tmpdir}/#{@test_base}"
+      @test_grammar = "#{@test_path}.tt"
+      @test_ruby = "#{@test_path}.rb"
+      File.open(@test_grammar, 'w+') do |f|
+        f.print("# Encoding: UTF-8\n")
+        f.print("grammar Dumb\n")
+        f.print("end\n")
+      end unless File.exists?(@test_grammar)
+    end
+
+    after(:each) do
+      # cleanup test grammar and parser output files
+      File.delete(@test_grammar) if File.exists?(@test_grammar)
+      File.delete(@test_ruby) if File.exists?(@test_ruby)
+    end
+
+    it 'can compile a grammar file' do
+      # puts %q{emulate 'tt dumb.tt'}
+      system("ruby -S tt #{@test_grammar}").should be_truthy
+
+      File.exists?(@test_ruby).should be_truthy
+      File.zero?(@test_ruby).should_not be_truthy
+    end
+
+    it 'can compile a relative pathed grammar file' do
+      dir = File.basename(File.expand_path(File.dirname(@test_grammar)))
+
+      # puts %q{emulate 'tt "../<current_dir>/dumb.tt"'}
+      system("cd #{@tmpdir}/..; ruby -S tt \"./#{dir}/#{@test_base}.tt\"").should be_truthy
+
+      File.exists?(@test_ruby).should be_truthy
+      File.zero?(@test_ruby).should_not be_truthy
+    end
+
+    it 'can compile an absolute pathed grammar file' do
+      # puts %q{emulate 'tt "/path/to/dumb.tt"'}
+      system("ruby -S tt \"#{File.expand_path(@test_grammar)}\"").should be_truthy
+
+      File.exists?(@test_ruby).should be_truthy
+      File.zero?(@test_ruby).should_not be_truthy
+    end
+
+    it 'can compile without explicit file extensions' do
+      # puts %q{emulate 'tt dumb'}
+      system("ruby -S tt #{@test_path}").should be_truthy
+
+      File.exists?(@test_ruby).should be_truthy
+      File.zero?(@test_ruby).should_not be_truthy
+    end
+
+    it 'skips nonexistent grammar file without failing or creating bogus output' do
+      # puts %q{emulate 'tt dumb.bad'}
+      Kernel.open("|ruby -S tt #{@test_base}.bad") do |io|
+        (io.read =~ /ERROR.*?not exist.*?continuing/).should_not be_nil
+      end
+
+      File.exists?("#{@test_base}.rb").should be_falsy
+    end
+
+    it 'can compile to a specified parser source file' do
+      # puts %q{emulate 'tt -o my_dumb_test_parser.rb dumb'}
+      pf = "#{@tmpdir}/my_dumb_test_parser.rb"
+      begin
+        system("ruby -S tt -o #{pf} #{@test_path}").should be_truthy
+
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+      ensure
+        File.delete(pf) if File.exists?(pf)
+      end
+    end
+
+    it 'by default, does not overwrite an existing file without an autogenerated header' do
+      # puts %q{emulate 'tt -o must_save_parser.rb dumb'}
+      pf = "#{@tmpdir}/must_save_parser.rb"
+      begin
+        system("ruby -S tt -o #{pf} #{@test_path}").should be_truthy
+
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+
+        # Check that the magic comment is preserved:
+        written = File.open(pf, "r") { |f| s = f.read }
+        written.should =~ /\A# Encoding: UTF-8/
+
+        # Modify the file's auto-generated comment and make sure it doesn't get overwritten:
+        written.sub!(/generated/, 'broken');
+        File.open(pf, "w") { |f| f.write(written) }
+        # File.open(pf, "r+") { |f| s = f.read; s.sub!(/generated/, 'broken'); f.rewind; f.write(s) }
+        orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
+
+        Kernel.open("|ruby -S tt -o #{pf} #{@test_path}") do |io|
+          (io.read =~ /ERROR.*?already exists.*?skipping/).should_not be_nil
+        end
+
+        Digest::SHA1.hexdigest(File.read(pf)).should == orig_file_hash
+      ensure
+        File.delete(pf) if File.exists?(pf)
+      end
+    end
+
+    it 'by default, overwrites a changed file with an intact autogenerated header' do
+      # puts %q{emulate 'tt -o must_save_parser.rb dumb'}
+      pf = "#{@tmpdir}/must_save_parser.rb"
+      begin
+        system("ruby -S tt -o #{pf} #{@test_path}").should be_truthy
+
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+        orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
+
+        # Modify the file and make sure it gets reverted:
+        File.open(pf, "r+") { |f| f.gets; f.write("#") }
+
+        system("ruby -S tt -o #{pf} #{@test_path}").should be_truthy
+        Digest::SHA1.hexdigest(File.read(pf)).should == orig_file_hash
+      ensure
+        File.delete(pf) if File.exists?(pf)
+      end
+    end
+
+    it 'can be forced to overwrite existing file #{@test_path}' do
+      pf = "#{@test_path}.rb"
+      system("echo some junk >#{pf}").should be_truthy
+
+      File.exists?(pf).should be_truthy
+      File.zero?(pf).should_not be_truthy
+      orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
+
+      system("ruby -S tt -f #{@test_path}").should be_truthy
+      Digest::SHA1.hexdigest(File.read(pf)).should_not == orig_file_hash
+    end
+
+  end
+
+  context 'when processing multiple grammar files' do
+
+    before(:each) do
+      # provide fresh but dumb grammar files for each test
+      @test_bases = []
+      @test_grammars = []
+
+      %w[dumb1 dumb2].each do |e|
+        base = "#{@tmpdir}/#{e}-#{rand(1000)}"
+        grammar_file = "#{base}.tt"
+        @test_bases << base
+        @test_grammars << grammar_file
+
+        File.open(grammar_file, 'w+') do |f|
+          f.print("grammar #{e.capitalize}\n")
+          f.print("end\n")
+        end unless File.exists?(grammar_file)
+      end
+    end
+
+    after(:each) do
+      # cleanup test grammar and output parser files
+      @test_grammars.each { |f| File.delete(f) if File.exists?(f) }
+      @test_bases.each { |f| File.delete("#{f}.rb") if File.exists?("#{f}.rb") }
+    end
+ 
+    it 'can compile them in one invocation' do
+      # puts %q{emulate 'tt dumb1.tt dumb2.tt'}
+      system("ruby -S tt #{@test_grammars.join(' ')}").should be_truthy
+
+      @test_bases.each do |f|
+        pf = "#{f}.rb"
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+      end
+    end
+
+    it 'can compile them without explicit file extenstions' do
+      # puts %q{emulate 'tt dumb1 dumb2'}
+      system("ruby -S tt #{@test_bases.join(' ')}").should be_truthy
+
+      @test_bases.each do |f|
+        pf = "#{f}.rb"
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+      end
+    end
+
+    it 'can skip nonexistent and invalid extension named grammar files' do
+      # puts %q{emulate 'tt not_here bad_ext.ttg dumb1 dumb2'}
+      system("ruby -S tt not_here bad_ext.ttg #{@test_bases.join(' ')} >/dev/null 2>&1").should be_truthy
+
+      File.exists?('not_here.rb').should_not be_truthy
+      File.exists?('bad_ext.rb').should_not be_truthy
+
+      @test_bases.each do |f|
+        pf = "#{f}.rb"
+        File.exists?(pf).should be_truthy
+        File.zero?(pf).should_not be_truthy
+      end
+    end
+
+    it 'can not specify an output file' do
+      # puts %q{emulate 'tt -o my_bogus_test_parser.rb dumb1 dumb2'}
+      pf = 'my_bogus_test_parser.rb'
+      system("ruby -S tt -o #{pf} #{@test_bases.join(' ')} >/dev/null 2>&1").should be_falsy
+      File.exists?(pf).should be_falsy
+    end
+  end
+
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module ZeroOrMoreSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "zero or more of a terminal symbol followed by a node class declaration and a block" do
+    testing_expression '"foo"* <ZeroOrMoreSpec::Foo> { def a_method; 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 == 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 recording a failure representing the third attempt " do
+      parse("foofoo") do |result|
+        result.should_not be_nil
+        result.should be_an_instance_of(Foo)
+
+        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
+
+  describe "Zero or more of a sequence" do
+    testing_expression '("foo" "bar")*'
+
+    it "resets the index appropriately following partially matcing input" do
+      parse('foobarfoo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.interval.should == (0...6)
+      end
+    end
+  end
+
+  describe "Zero or more of a choice" do
+    testing_expression '("a" / "bb")*'
+
+    it "successfully parses matching input" do
+      parse('abba').should_not be_nil
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/a.treetop

@@ -0,0 +1,11 @@
+module Test
+  grammar A
+    rule a
+      'a'
+    end
+    
+    rule inherit
+      'super'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/b.treetop

@@ -0,0 +1,11 @@
+module Test
+  grammar B
+    rule b
+      'bb'
+    end
+    
+    rule inherit
+      super 'keyword'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/c.treetop

@@ -0,0 +1,10 @@
+module Test
+  grammar C
+    include A
+    include B
+    
+    rule c
+      a b 'c'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/d.treetop

@@ -0,0 +1,10 @@
+module Test
+  grammar D
+    include A
+    include B
+    
+    rule inherit
+      super 'works'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/f.treetop

@@ -0,0 +1,17 @@
+
+require "a"
+
+require	File.dirname(__FILE__) + "/b"
+require File.dirname(__FILE__) + "/subfolder/e_includes_c"
+
+module Test
+  grammar F
+    include A
+    include B
+    include E
+    
+    rule f
+      c e 'f'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/grammar_composition_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module GrammarCompositionSpec
+  describe "several composed grammars" do
+    before do
+      dir = File.dirname(__FILE__)
+      Treetop.load File.join(dir, 'a')
+      Treetop.load File.join(dir, 'b')
+      Treetop.load File.join(dir, 'c')
+      # Check that polyglot finds d.treetop and loads it:
+      $: << dir
+      require 'd'
+  
+      @c = ::Test::CParser.new
+      @d = ::Test::DParser.new
+    end
+
+    specify "rules in C have access to rules defined in A and B" do
+      @c.parse('abbc').should_not be_nil
+    end
+
+    specify "rules in C can override rules in A and B with super semantics" do
+      @d.parse('superkeywordworks').should_not be_nil
+    end
+  end
+  
+  describe "composed grammar chaining with require" do
+    before do
+      # Load f with polyglot without using the load path:
+      require File.dirname(__FILE__) + '/f'
+  
+      @f = ::Test::FParser.new
+    end
+    
+    specify "rules in F have access to rule defined in E" do
+      @f.parse('abbcef').should_not be_nil
+    end
+    
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/composition/subfolder/e_includes_c.treetop

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../c"
+
+module Test
+  grammar E
+    include C
+    
+    rule e
+      'e'
+    end
+    
+    rule inherit
+      'super'
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/ruby_extensions/string_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe String do
+  before do
+    @string = %{
+      0123456789
+      012345
+      01234567
+      0123
+    }.tabto(0).strip
+  end
+  
+  it "can translate indices to column numbers" do
+    @string.column_of(0).should == 1
+    @string.column_of(5).should == 6
+    @string.column_of(10).should == 11
+    @string.column_of(11).should == 1
+    @string.column_of(17).should == 7
+    @string.column_of(18).should == 1
+    @string.column_of(24).should == 7
+  end
+  
+  it "can translate indices to line numbers" do
+    @string.line_of(0).should == 1
+    @string.line_of(5).should == 1
+    @string.line_of(10).should == 1
+    @string.line_of(11).should == 2
+    @string.line_of(17).should == 2
+    @string.line_of(18).should == 3
+    @string.line_of(24).should == 3
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/spec/runtime/compiled_parser_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+module CompiledParserSpec
+  describe Runtime::CompiledParser, "for a grammar with two rules" do
+    attr_reader :parser
+
+    testing_grammar %{
+      grammar TwoRules
+        rule a
+          'a'
+        end
+
+        rule b
+          'bb'
+        end
+      end
+    }
+
+    before do
+      @parser = parser_class_under_test.new
+    end
+
+    it "allows its root to be specified" do
+      parser.parse('a').should_not be_nil
+      parser.parse('b').should be_nil
+
+      # Check that the temporary-override works:
+      parser.parse('bb', :root => :b).should_not be_nil
+      parser.parse('a', :root => :b).should be_nil
+
+      # Check that the temporary-override isn't sticky:
+      parser.parse('a').should_not be_nil
+
+      # Try a permanent override:
+      parser.root = :b
+      parser.parse('bb').should_not be_nil
+      parser.parse('a').should be_nil
+    end
+
+    it "allows the requirement that all input be consumed to be disabled" do
+      parser.parse('ab').should be_nil
+
+      # Try a temporary override, and check it's not sticky:
+      result = parser.parse('ab', :consume_all_input => false)
+      result.should_not be_nil
+      result.interval.should == (0...1)
+      parser.parse('ab').should be_nil
+
+      # Now a permanent override:
+      parser.consume_all_input = false
+      result = parser.parse('ab')
+      result.should_not be_nil
+      result.interval.should == (0...1)
+    end
+
+    it "allows input to be parsed at a given index" do
+      parser.parse('ba').should be_nil
+      parser.parse('ba', :index => 1).should_not be_nil
+      # Check that the index defaults again to zero:
+      parser.parse('a').should_not be_nil
+
+      result = parser.parse('ba', :consume_all_input => false, :index => 1)
+      result.should_not be_nil
+      result.interval.should == (1...2)
+    end
+
+  end
+
+  describe Runtime::CompiledParser, "for a grammar with a choice between terminals" do
+    attr_reader :parser
+
+    testing_grammar %{
+      grammar Choice
+        rule choice
+          'a' / 'b' / 'c'
+        end
+      end
+    }
+
+    before do
+      @parser = parser_class_under_test.new
+    end
+
+    it "provides #failure_reason, #failure_column, and #failure_line when there is a parse failure" do
+      parser.parse('z').should be_nil
+      parser.failure_reason.should == "Expected one of 'a', 'b', 'c' at line 1, column 1 (byte 1)"
+      parser.failure_line.should == 1
+      parser.failure_column.should == 1
+    end
+  end
+
+  describe Runtime::CompiledParser,  "#terminal_failures" do
+    attr_reader:parser
+
+    testing_grammar %{
+      grammar SequenceOfTerminals
+        rule foo
+          'a' 'b' 'c'
+        end
+      end
+    }
+
+    before do
+      @parser = parser_class_under_test.new
+    end
+
+    it "is reset between parses" do
+      parser.parse('ac')
+      terminal_failures = parser.terminal_failures
+      terminal_failures.size.should == 1
+      failure = terminal_failures.first
+      failure.index.should == 1
+      failure.expected_string.should == "'b'"
+
+      parser.parse('b')
+      terminal_failures = parser.terminal_failures
+      terminal_failures.size.should == 1
+      failure = terminal_failures.first
+      failure.index.should == 0
+      failure.expected_string.should == "'a'"
+    end
+  end
+
+  describe "a SyntaxNode" do
+    attr_reader :parser
+
+    testing_grammar %{
+      grammar Alternates
+        rule main
+          aa &{|s| s[0].elements[0].parent.should == s[0] }
+	  / ab &{|s| s[0].elements[0].parent.should == s[0] }
+        end
+
+	rule aa
+	  'a' 'a'
+	end
+
+	rule ab
+	  'a' 'b'
+	end
+      end
+    }
+
+    before do
+      @parser = parser_class_under_test.new
+    end
+
+    it "should have its parent set and reset" do
+      parser.parse('ab')
+    end
+  end
+
+end