tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/lib/rspec/matchers/method_missing.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Matchers
+
+    private
+
+    def method_missing(method, *args, &block)
+      return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
+      return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/lib/rspec/matchers/operator_matcher.rb

@@ -0,0 +1,113 @@
+module RSpec
+  module Matchers
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def unregister(klass, operator)
+          registry[klass] && registry[klass].delete(operator)
+        end
+
+        def get(klass, operator)
+          klass.ancestors.each { |ancestor|
+            matcher = registry[ancestor] && registry[ancestor][operator]
+            return matcher if matcher
+          }
+
+          nil
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+              "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        RSpec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+
+    private
+
+      if Method.method_defined?(:owner) # 1.8.6 lacks Method#owner :-(
+        def uses_generic_implementation_of?(op)
+          Expectations.method_handle_for(@actual, op).owner == ::Kernel
+        rescue NameError
+          false
+        end
+      else
+        def uses_generic_implementation_of?(op)
+          # This is a bit of a hack, but:
+          #
+          # {}.method(:=~).to_s # => "#<Method: Hash(Kernel)#=~>"
+          #
+          # In the absence of Method#owner, this is the best we
+          # can do to see if the method comes from Kernel.
+          Expectations.method_handle_for(@actual, op).to_s.include?('(Kernel)')
+        rescue NameError
+          false
+        end
+      end
+
+      def eval_match(actual, operator, expected)
+        ::RSpec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+    end
+
+    module BuiltIn
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          elsif ['==','===', '=~'].include?(operator)
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})")
+          else
+            fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          end
+        end
+      end
+
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+          return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/lib/rspec/matchers/pretty.rb

@@ -0,0 +1,70 @@
+module RSpec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words)
+        return "" unless words
+        words = Array(words).map { |w| to_word(w) }
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+
+      def to_word(item)
+        is_matcher_with_description?(item) ? item.description : item.inspect
+      end
+
+      def name_to_sentence
+        split_words(name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected) if defined?(@expected)
+      end
+
+      def name
+        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
+      end
+
+      # Borrowed from ActiveSupport
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      private
+
+      def is_matcher_with_description?(object)
+        RSpec::Matchers.is_a_matcher?(object) && object.respond_to?(:description)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/lib/rspec/matchers/test_unit_integration.rb

@@ -0,0 +1,11 @@
+# Include Matchers for other test frameworks.  Note that MiniTest _must_
+# come before TU because on ruby 1.9, T::U::TC is a subclass of MT::U::TC
+# and a 1.9 bug can lead to infinite recursion from the `super` call in our
+# method_missing hook.  See this gist for more info:
+# https://gist.github.com/845896
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
+end
+if defined?(Test::Unit::TestCase)
+  Test::Unit::TestCase.send(:include, RSpec::Matchers)
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/spec/rspec/expectations/differ_spec.rb

@@ -0,0 +1,229 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'ostruct'
+
+module RSpec
+  module Expectations
+    describe Differ do
+      context "without --color" do
+
+      before { RSpec::Matchers.configuration.stub(:color? => false) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+        # color disabled context
+
+      describe '#diff_as_string' do
+        subject { differ.diff_as_string(@expected, @actual) }
+        it "outputs unified diff of two strings" do
+          @expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          @actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expect(subject).to eql(<<-'EOD')
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+        end
+        if RUBY_VERSION.to_f > 1.9
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION < '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql(<<-EOD.encode('UTF-16LE'))
+
+@@ -1,2 +1,2 @@
+-Tu avec carte {count} item has
++Tu avec carté {count} itém has
+EOD
+          end
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION >= '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql 'Could not produce a diff because of the encoding of the string (UTF-16LE)'
+          end
+          it 'handles differently encoded strings that are compatible' do
+            @expected = "강인철".encode('UTF-8')
+            @actual   = "abc".encode('us-ascii')
+            expect(subject).to eql "\n@@ -1,2 +1,2 @@\n-abc\n+강인철\n"
+          end
+          it 'outputs a message when encountering differently encoded strings' do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has"
+            expect(subject).to eql 'Could not produce a diff because the encoding of the actual string (UTF-8) differs from the encoding of the expected string (UTF-16LE)'
+          end
+        end
+      end
+
+      describe '#diff_as_object' do
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff message of two hashes with differing encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-"a" => "a"
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+"ö" => "ö"} : '+"\303\266" => "\303\266"' }
+}
+
+          diff = differ.diff_as_object({'ö' => 'ö'}, {'a' => 'a'})
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff message of two hashes with encoding different to key encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-:a => "a"
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+\"한글\" => \"한글2\"} : '+"\355\225\234\352\270\200" => "\355\225\234\352\270\2002"' }
+}
+
+          diff = differ.diff_as_object({ "한글" => "한글2"}, { :a => "a"})
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes with object keys" do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-["a", "c"] => "b"
++["d", "c"] => "b"
+}
+
+          diff = differ.diff_as_object({ ['d','c'] => 'b'}, { ['a','c'] => 'b' })
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of single line strings" do
+          expected = "this is one string"
+          actual   = "this is another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,2 +1,2 @@
+-"this is another string"
++"this is one string"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+      end
+    end
+
+    context "with --color" do
+      before { RSpec::Matchers.configuration.stub(:color? => true) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+      it "outputs colored diffs" do
+        expected = "foo bar baz"
+        actual = "foo bang baz"
+        expected_diff = "\n\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+
+        diff = differ.diff_as_string(expected,actual)
+        expect(diff).to eq expected_diff
+      end
+    end
+
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/spec/rspec/expectations/expectation_target_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    # so our examples below can set expectations about the target
+    ExpectationTarget.send(:attr_reader, :target)
+
+    describe ExpectationTarget do
+      context 'when constructed via #expect' do
+        it 'constructs a new instance targetting the given argument' do
+          expect(expect(7).target).to eq(7)
+        end
+
+        it 'constructs a new instance targetting the given block' do
+          block = lambda {}
+          expect(expect(&block).target).to be(block)
+        end
+
+        it 'raises an ArgumentError when given an argument and a block' do
+          expect {
+            expect(7) { }
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an ArgumentError when given neither an argument nor a block' do
+          expect {
+            expect
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'can be passed nil' do
+          expect(expect(nil).target).to be_nil
+        end
+
+        it 'passes a valid positive expectation' do
+          expect(5).to eq(5)
+        end
+
+        it 'passes a valid negative expectation' do
+          expect(5).not_to eq(4)
+        end
+
+        it 'passes a valid negative expectation with a split infinitive' do
+          expect(5).to_not eq(4)
+        end
+
+        it 'fails an invalid positive expectation' do
+          expect {
+            expect(5).to eq(4)
+          }.to fail_with(/expected: 4.*got: 5/m)
+        end
+
+        it 'fails an invalid negative expectation' do
+          message = /expected 5 not to be a kind of Fixnum/
+          expect {
+            expect(5).not_to be_a(Fixnum)
+          }.to fail_with(message)
+        end
+
+        it 'fails an invalid negative expectation with a split infinitive' do
+          message = /expected 5 not to be a kind of Fixnum/
+          expect {
+            expect(5).to_not be_a(Fixnum)
+          }.to fail_with(message)
+        end
+
+        it 'does not support operator matchers from #to' do
+          expect {
+            expect(3).to == 3
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'does not support operator matchers from #not_to' do
+          expect {
+            expect(3).not_to == 4
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end
+