tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/formatters/text_mate_formatter_spec.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rspec/core/formatters/text_mate_formatter'
+require 'nokogiri'
+
+module RSpec
+  module Core
+    module Formatters
+      describe TextMateFormatter do
+        let(:suffix) {
+          if ::RUBY_PLATFORM == 'java'
+            "-jruby"
+          elsif defined?(Rubinius)
+            "-rbx"
+          else
+            ""
+          end
+        }
+
+        let(:root) { File.expand_path("#{File.dirname(__FILE__)}/../../../..") }
+        let(:expected_file) do
+          "#{File.dirname(__FILE__)}/text_mate_formatted-#{::RUBY_VERSION}#{suffix}.html"
+        end
+
+        let(:generated_html) do
+          options = RSpec::Core::ConfigurationOptions.new(
+            %w[spec/rspec/core/resources/formatter_specs.rb --format textmate --order default]
+          )
+          options.parse_options
+
+          err, out = StringIO.new, StringIO.new
+          err.set_encoding("utf-8") if err.respond_to?(:set_encoding)
+          out.set_encoding("utf-8") if out.respond_to?(:set_encoding)
+
+          command_line = RSpec::Core::CommandLine.new(options)
+          command_line.instance_variable_get("@configuration").backtrace_cleaner.inclusion_patterns = []
+          command_line.run(err, out)
+          out.string.gsub(/\d+\.\d+(s| seconds)/, "n.nnnn\\1")
+        end
+
+        let(:expected_html) do
+          unless File.file?(expected_file)
+            raise "There is no HTML file with expected content for this platform: #{expected_file}"
+          end
+          File.read(expected_file)
+        end
+
+        before do
+          RSpec.configuration.stub(:load_spec_files) do
+            RSpec.configuration.files_to_run.map {|f| load File.expand_path(f) }
+          end
+        end
+
+        # Uncomment this group temporarily in order to overwrite the expected
+        # with actual.  Use with care!!!
+        describe "file generator", :if => ENV['GENERATE'] do
+          it "generates a new comparison file" do
+            Dir.chdir(root) do
+              File.open(expected_file, 'w') {|io| io.write(generated_html)}
+            end
+          end
+        end
+
+        it "produces HTML identical to the one we designed manually" do
+          Dir.chdir(root) do
+            actual_doc = Nokogiri::HTML(generated_html)
+            backtrace_lines = actual_doc.search("div.backtrace a")
+            actual_doc.search("div.backtrace").remove
+
+            expected_doc = Nokogiri::HTML(expected_html)
+            expected_doc.search("div.backtrace").remove
+
+            expect(actual_doc.inner_html).to eq(expected_doc.inner_html)
+
+            backtrace_lines.each do |backtrace_line|
+              expect(backtrace_line['href']).to include("txmt://open?url=")
+            end
+          end
+        end
+
+        it "has a backtrace line from the raw erb evaluation" do
+          Dir.chdir(root) do
+            actual_doc = Nokogiri::HTML(generated_html)
+
+            expect(actual_doc.inner_html).to include('(erb):1')
+          end
+        end
+
+        it "has a backtrace line from a erb source file we forced to appear" do
+          expect(generated_html).to include('open?url=file:///foo.html.erb')
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/hooks_filtering_spec.rb

@@ -0,0 +1,227 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe "config block hook filtering" do
+    describe "unfiltered hooks" do
+      it "is run" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all) { filters << "before all in config"}
+          c.around(:each) {|example| filters << "around each in config"; example.run}
+          c.before(:each) { filters << "before each in config"}
+          c.after(:each) { filters << "after each in config"}
+          c.after(:all) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+    end
+
+    describe "hooks with single filters" do
+
+      context "with no scope specified" do
+        it "is run around|before|after :each if the filter matches the example group's filter" do
+          filters = []
+          RSpec.configure do |c|
+            c.around(:match => true) {|example| filters << "around each in config"; example.run}
+            c.before(:match => true) { filters << "before each in config"}
+            c.after(:match => true)  { filters << "after each in config"}
+          end
+          group = ExampleGroup.describe(:match => true)
+          group.example("example") {}
+          group.run
+          expect(filters).to eq([
+            "around each in config",
+            "before each in config",
+            "after each in config"
+          ])
+        end
+      end
+
+      it "is run if the filter matches the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => true) { filters << "before all in config"}
+          c.around(:each, :match => true) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => true) { filters << "before each in config"}
+          c.after(:each,  :match => true) { filters << "after each in config"}
+          c.after(:all,   :match => true) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:match => true)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "runs before|after :all hooks on matching nested example groups" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = nil
+
+        group = ExampleGroup.describe "group" do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+          end
+        end
+        group.run
+
+        expect(example_1_filters).to be_empty
+        expect(example_2_filters).to eq([:before_all])
+        expect(filters).to eq([:before_all, :after_all])
+      end
+
+      it "runs before|after :all hooks only on the highest level group that matches the filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = example_3_filters = nil
+
+        group = ExampleGroup.describe "group", :match => true do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+            describe "sub-subgroup", :match => true do
+              it("example 3") { example_3_filters = filters.dup }
+            end
+          end
+        end
+        group.run
+
+        expect(example_1_filters).to eq([:before_all])
+        expect(example_2_filters).to eq([:before_all])
+        expect(example_3_filters).to eq([:before_all])
+
+        expect(filters).to eq([:before_all, :after_all])
+      end
+
+      it "does not run if the filter doesn't match the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => false) { filters << "before all in config"}
+          c.around(:each, :match => false) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => false) { filters << "before each in config"}
+          c.after(:each,  :match => false) { filters << "after each in config"}
+          c.after(:all,   :match => false) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:match => true)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([])
+      end
+
+      context "when the hook filters apply to individual examples instead of example groups" do
+        let(:each_filters) { [] }
+        let(:all_filters) { [] }
+
+        let(:group) do
+          md = example_metadata
+          ExampleGroup.describe do
+            it("example", md) { }
+          end
+        end
+
+        def filters
+          each_filters + all_filters
+        end
+
+        before(:each) do
+          af, ef = all_filters, each_filters
+
+          RSpec.configure do |c|
+            c.before(:all,  :foo => :bar) { af << "before all in config"}
+            c.around(:each, :foo => :bar) {|example| ef << "around each in config"; example.run}
+            c.before(:each, :foo => :bar) { ef << "before each in config"}
+            c.after(:each,  :foo => :bar) { ef << "after each in config"}
+            c.after(:all,   :foo => :bar) { af << "after all in config"}
+          end
+
+          group.run
+        end
+
+        describe 'an example with matching metadata' do
+          let(:example_metadata) { { :foo => :bar } }
+
+          it "runs the `:each` hooks" do
+            expect(each_filters).to eq([
+              'around each in config',
+              'before each in config',
+              'after each in config'
+            ])
+          end
+
+          it "does not run the `:all` hooks" do
+            expect(all_filters).to be_empty
+          end
+        end
+
+        describe 'an example without matching metadata' do
+          let(:example_metadata) { { :foo => :bazz } }
+
+          it "does not run any of the hooks" do
+            expect(filters).to be_empty
+          end
+        end
+      end
+    end
+
+    describe "hooks with multiple filters" do
+      it "is run if all hook filters match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :one => 1)              {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2)              { filters << "before each in config"}
+          c.after(:each,  :one => 1, :two => 2, :three => 3) { filters << "after each in config"}
+          c.after(:all,   :one => 1, :three => 3)            { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "does not run if some hook filters don't match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1, :four => 4)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :four => 4)                         {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2, :four => 4)              { filters << "before each in config"}
+          c.after(:each,  :one => 1, :two => 2, :three => 3, :four => 4) { filters << "after each in config"}
+          c.after(:all,   :one => 1, :three => 3, :four => 4)            { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([])
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/hooks_spec.rb

@@ -0,0 +1,267 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe Hooks do
+    class HooksHost
+      include Hooks
+    end
+
+    [:before, :after, :around].each do |type|
+      [:each, :all].each do |scope|
+        next if type == :around && scope == :all
+
+        describe "##{type}(#{scope})" do
+          it_behaves_like "metadata hash builder" do
+            define_method :metadata_hash do |*args|
+              instance = HooksHost.new
+              args.unshift scope if scope
+              hooks = instance.send(type, *args) {}
+              hooks.first.options
+            end
+          end
+        end
+      end
+
+      [true, false].each do |config_value|
+        context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
+          before(:each) do
+            Kernel.stub(:warn)
+            RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
+          end
+
+          describe "##{type}(no scope)" do
+            let(:instance) { HooksHost.new }
+
+            it "defaults to :each scope if no arguments are given" do
+              hooks = instance.send(type) {}
+              hook = hooks.first
+              expect(instance.hooks[type][:each]).to include(hook)
+            end
+
+            it "defaults to :each scope if the only argument is a metadata hash" do
+              hooks = instance.send(type, :foo => :bar) {}
+              hook = hooks.first
+              expect(instance.hooks[type][:each]).to include(hook)
+            end
+
+            it "raises an error if only metadata symbols are given as arguments" do
+              expect { instance.send(type, :foo, :bar) {} }.to raise_error(ArgumentError)
+            end
+          end
+        end
+      end
+    end
+
+    [:before, :after].each do |type|
+      [:each, :all, :suite].each do |scope|
+        [true, false].each do |config_value|
+          context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
+            before(:each) do
+              RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
+            end
+
+            describe "##{type}(#{scope.inspect})" do
+              let(:instance) { HooksHost.new }
+              let!(:hook) do
+                hooks = instance.send(type, scope) {}
+                hooks.first
+              end
+
+              it "does not make #{scope.inspect} a metadata key" do
+                expect(hook.options).to be_empty
+              end
+
+              it "is scoped to #{scope.inspect}" do
+                expect(instance.hooks[type][scope]).to include(hook)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe "#around" do
+      context "when not running the example within the around block" do
+        it "does not run the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do |example|
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          expect(examples).to have(0).example
+        end
+      end
+
+      context "when running the example within the around block" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do |example|
+              example.run
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          expect(examples).to have(1).example
+        end
+      end
+
+      context "when running the example within a block passed to a method" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            def yielder
+              yield
+            end
+
+            around do |example|
+              yielder { example.run }
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          expect(examples).to have(1).example
+        end
+      end
+    end
+
+    [:all, :each].each do |scope|
+      describe "prepend_before(#{scope})" do
+        it "adds to the front of the list of before(:#{scope}) hooks" do
+          messages = []
+
+          RSpec.configure { |config| config.before(scope)         { messages << "config 3" } }
+          RSpec.configure { |config| config.prepend_before(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.before(scope)         { messages << "config 4" } }
+          RSpec.configure { |config| config.prepend_before(scope) { messages << "config 1" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.before(scope)         { messages << "group 3" }
+          group.prepend_before(scope) { messages << "group 2" }
+          group.before(scope)         { messages << "group 4" }
+          group.prepend_before(scope) { messages << "group 1" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'config 1',
+            'config 2',
+            'config 3',
+            'config 4',
+            'group 3',
+            'group 4'
+          ])
+        end
+      end
+
+      describe "append_before(#{scope})" do
+        it "adds to the back of the list of before(:#{scope}) hooks (same as `before`)" do
+          messages = []
+
+          RSpec.configure { |config| config.before(scope)        { messages << "config 1" } }
+          RSpec.configure { |config| config.append_before(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.before(scope)        { messages << "config 3" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.before(scope)        { messages << "group 1" }
+          group.append_before(scope) { messages << "group 2" }
+          group.before(scope)        { messages << "group 3" }
+
+          group.run
+
+          expect(messages).to eq([
+            'config 1',
+            'config 2',
+            'config 3',
+            'group 1',
+            'group 2',
+            'group 3'
+          ])
+        end
+      end
+
+      describe "prepend_after(#{scope})" do
+        it "adds to the front of the list of after(:#{scope}) hooks (same as `after`)" do
+          messages = []
+
+          RSpec.configure { |config| config.after(scope)         { messages << "config 3" } }
+          RSpec.configure { |config| config.prepend_after(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.after(scope)         { messages << "config 1" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.after(scope)         { messages << "group 3" }
+          group.prepend_after(scope) { messages << "group 2" }
+          group.after(scope)         { messages << "group 1" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'group 3',
+            'config 1',
+            'config 2',
+            'config 3'
+          ])
+        end
+      end
+
+      describe "append_after(#{scope})" do
+        it "adds to the back of the list of after(:#{scope}) hooks" do
+          messages = []
+
+          RSpec.configure { |config| config.after(scope)        { messages << "config 2" } }
+          RSpec.configure { |config| config.append_after(scope) { messages << "config 3" } }
+          RSpec.configure { |config| config.after(scope)        { messages << "config 1" } }
+          RSpec.configure { |config| config.append_after(scope) { messages << "config 4" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.after(scope)        { messages << "group 2" }
+          group.append_after(scope) { messages << "group 3" }
+          group.after(scope)        { messages << "group 1" }
+          group.append_after(scope) { messages << "group 4" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'config 1',
+            'config 2',
+            'config 3',
+            'config 4',
+            'group 3',
+            'group 4'
+          ])
+        end
+      end
+    end
+
+    describe "lambda" do
+      it "can be used as a hook" do
+        messages = []
+        count = 0
+        hook = lambda {|e| messages << "hook #{count = count + 1}"; e.run }
+
+        RSpec.configure do |c|
+          c.around(:each, &hook)
+          c.around(:each, &hook)
+        end
+
+        group = ExampleGroup.describe { example { messages << "example" } }
+        group.run
+        expect(messages).to eq ["hook 1", "hook 2", "example"]
+      end
+    end
+  end
+end