tuktuk-rails 0.0.6 → 0.0.7

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

@@ -0,0 +1,127 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RaiseError
+        def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+          @block = block
+          @actual_error = nil
+          case expected_error_or_message
+          when String, Regexp
+            @expected_error, @expected_message = Exception, expected_error_or_message
+          else
+            @expected_error, @expected_message = expected_error_or_message, expected_message
+          end
+        end
+
+        def matches?(given_proc, negative_expectation = false)
+          if negative_expectation && (expecting_specific_exception? || @expected_message)
+            what_to_deprecate = if expecting_specific_exception? && @expected_message
+                                  "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                                elsif expecting_specific_exception?
+                                  "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                                elsif @expected_message
+                                  "`expect { }.not_to raise_error(message)`"
+                                end
+
+            RSpec.deprecate(
+              what_to_deprecate,
+              :replacement => "`expect { }.not_to raise_error` (with no args)"
+            )
+          end
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+          unless given_proc.respond_to?(:call)
+            ::Kernel.warn "`raise_error` was called with non-proc object #{given_proc.inspect}"
+            return false
+          end
+          begin
+            given_proc.call
+          rescue Exception => @actual_error
+            if @actual_error == @expected_error || @expected_error === @actual_error
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
+          end
+
+          unless negative_expectation
+            eval_block if @raised_expected_error && @with_expected_message && @block
+          end
+        ensure
+          return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+        end
+        alias == matches?
+
+        def does_not_match?(given_proc)
+          !matches?(given_proc, :negative_expectation)
+        end
+
+        def eval_block
+          @eval_block = true
+          begin
+            @block[@actual_error]
+            @eval_block_passed = true
+          rescue Exception => err
+            @actual_error = err
+          end
+        end
+
+        def verify_message
+          case @expected_message
+          when nil
+            true
+          when Regexp
+            @expected_message =~ @actual_error.message
+          else
+            @expected_message == @actual_error.message
+          end
+        end
+
+        def failure_message_for_should
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        def failure_message_for_should_not
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        def description
+          "raise #{expected_error}"
+        end
+
+        private
+
+        def expected_error
+          case @expected_message
+          when nil
+            @expected_error.inspect
+          when Regexp
+            "#{@expected_error} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_error} with #{@expected_message.inspect}"
+          end
+        end
+
+        def format_backtrace(backtrace)
+          formatter = Matchers.configuration.backtrace_formatter
+          formatter.format_backtrace(backtrace)
+        end
+
+        def given_error
+          return " but nothing was raised" unless @actual_error
+
+          backtrace = format_backtrace(@actual_error.backtrace)
+          [
+            ", got #{@actual_error.inspect} with backtrace:",
+            *backtrace
+          ].join("\n  # ")
+        end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RespondTo
+        def initialize(*names)
+          @names = names
+          @expected_arity = nil
+        end
+
+        def matches?(actual)
+          find_failing_method_names(actual, :reject).empty?
+        end
+        alias == matches?
+
+        def does_not_match?(actual)
+          find_failing_method_names(actual, :select).empty?
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        end
+
+        def failure_message_for_should_not
+          failure_message_for_should.sub(/to respond to/, 'not to respond to')
+        end
+
+        def description
+          "respond to #{pp_names}#{with_arity}"
+        end
+
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        def argument
+          self
+        end
+        alias :arguments :argument
+
+        private
+
+        def find_failing_method_names(actual, filter_method)
+          @actual = actual
+          @failing_method_names = @names.__send__(filter_method) do |name|
+            @actual.respond_to?(name) && matches_arity?(actual, name)
+          end
+        end
+
+        def matches_arity?(actual, name)
+          return true unless @expected_arity
+
+          actual_arity = actual.method(name).arity
+          if actual_arity < 0
+            # ~ inverts the one's complement and gives us the number of required args
+            ~actual_arity <= @expected_arity
+          else
+            actual_arity == @expected_arity
+          end
+        end
+
+        def with_arity
+          @expected_arity.nil?? "" :
+            " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def pp_names
+          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+          @names.length == 1 ? "##{@names.first}" : @names.inspect
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Satisfy
+        def initialize(&block)
+          @block = block
+        end
+
+        def matches?(actual, &block)
+          @block = block if block
+          @actual = actual
+          @block.call(actual)
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected #{@actual} to satisfy block"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual} not to satisfy block"
+        end
+
+        def description
+          "satisfy block"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class StartAndEndWith < BaseMatcher
+        def initialize(*expected)
+          @expected = expected.length == 1 ? expected.first : expected
+        end
+
+        def matches?(actual)
+          @actual = actual.respond_to?(:[]) ? actual : (raise ArgumentError.new("#{actual.inspect} does not respond to :[]"))
+          begin
+            @expected.respond_to?(:length) ? subset_matches?(@expected, @actual) : element_matches?(@expected, @actual)
+          rescue ArgumentError
+            raise ArgumentError.new("#{actual.inspect} does not have ordered elements")
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} not to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+      end
+
+      class StartWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[0, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          @actual[0] == @expected
+        end
+      end
+
+      class EndWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[-expected.length, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          actual[-1] == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class ThrowSymbol
+        def initialize(expected_symbol = nil, expected_arg=nil)
+          @expected_symbol = expected_symbol
+          @expected_arg = expected_arg
+          @caught_symbol = @caught_arg = nil
+        end
+
+        def matches?(given_proc)
+          begin
+            if @expected_symbol.nil?
+              given_proc.call
+            else
+              @caught_arg = catch :proc_did_not_throw_anything do
+                catch @expected_symbol do
+                  given_proc.call
+                  throw :proc_did_not_throw_anything, :nothing_thrown
+                end
+              end
+
+              if @caught_arg == :nothing_thrown
+                @caught_arg = nil
+              else
+                @caught_symbol = @expected_symbol
+              end
+            end
+
+            # Ruby 1.8 uses NameError with `symbol'
+            # Ruby 1.9 uses ArgumentError with :symbol
+          rescue NameError, ArgumentError => e
+            unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+              other_exception = e
+              raise
+            end
+            @caught_symbol = $2.to_sym
+          rescue => other_exception
+            raise
+          ensure
+            unless other_exception
+              if @expected_symbol.nil?
+                return !@caught_symbol.nil?
+              else
+                if @expected_arg.nil?
+                  return @caught_symbol == @expected_symbol
+                else
+                  return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+                end
+              end
+            end
+          end
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected #{expected} to be thrown, got #{caught}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+        end
+
+        def description
+          "throw #{expected}"
+        end
+
+        private
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
+        end
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
+        end
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+                              " with #{arg.inspect}"
+                            elsif @expected_arg && @caught_symbol == @expected_symbol
+                              " with no argument"
+                            else
+                              ""
+                            end
+
+          symbol_description + arg_description
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,296 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class YieldProbe
+        def self.probe(block)
+          probe = new
+          assert_valid_expect_block!(block)
+          block.call(probe)
+          probe.assert_used!
+          probe
+        end
+
+        attr_accessor :num_yields, :yielded_args
+
+        def initialize
+          @used = false
+          self.num_yields, self.yielded_args = 0, []
+        end
+
+        def to_proc
+          @used = true
+
+          probe = self
+          Proc.new do |*args|
+            probe.num_yields += 1
+            probe.yielded_args << args
+          end
+        end
+
+        def single_yield_args
+          yielded_args.first
+        end
+
+        def yielded_once?(matcher_name)
+          case num_yields
+          when 1 then true
+          when 0 then false
+          else
+            raise "The #{matcher_name} matcher is not designed to be used with a " +
+                  "method that yields multiple times. Use the yield_successive_args " +
+                  "matcher for that case."
+          end
+        end
+
+        def successive_yield_args
+          yielded_args.map do |arg_array|
+            arg_array.size == 1 ? arg_array.first : arg_array
+          end
+        end
+
+        def assert_used!
+          return if @used
+          raise "You must pass the argument yielded to your expect block on " +
+                "to the method-under-test as a block. It acts as a probe that " +
+                "allows the matcher to detect whether or not the method-under-test " +
+                "yields, and, if so, how many times, and what the yielded arguments " +
+                "are."
+        end
+
+        def self.assert_valid_expect_block!(block)
+          return if block.arity == 1
+          raise "Your expect block must accept an argument to be used with this " +
+                "matcher. Pass the argument as a block on to the method you are testing."
+        end
+      end
+
+      class YieldControl < BaseMatcher
+        def initialize
+          @expectation_type = nil
+          @expected_yields_count = nil
+        end
+
+        def matches?(block)
+          probe = YieldProbe.probe(block)
+
+          if @expectation_type
+            probe.num_yields.send(@expectation_type, @expected_yields_count)
+          else
+            probe.yielded_once?(:yield_control)
+          end
+        end
+
+        def once
+          exactly(1)
+          self
+        end
+
+        def twice
+          exactly(2)
+          self
+        end
+
+        def exactly(number)
+          set_expected_yields_count(:==, number)
+          self
+        end
+
+        def at_most(number)
+          set_expected_yields_count(:<=, number)
+          self
+        end
+
+        def at_least(number)
+          set_expected_yields_count(:>=, number)
+          self
+        end
+
+        def times
+          self
+        end
+
+        def failure_message_for_should
+          'expected given block to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        def failure_message_for_should_not
+          'expected given block not to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        private
+
+        def set_expected_yields_count(relativity, n)
+          @expectation_type = relativity
+          @expected_yields_count = case n
+                                   when Numeric then n
+                                   when :once then 1
+                                   when :twice then 2
+                                   end
+        end
+
+        def relativity_failure_message
+          return '' unless @expected_yields_count
+          " #{human_readable_expecation_type}#{human_readable_count}"
+        end
+
+        def human_readable_expecation_type
+          case @expectation_type
+          when :<= then 'at most '
+          when :>= then 'at least '
+          else ''
+          end
+        end
+
+        def human_readable_count
+          case @expected_yields_count
+          when 1 then "once"
+          when 2 then "twice"
+          else "#{@expected_yields_count} times"
+          end
+        end
+      end
+
+      class YieldWithNoArgs < BaseMatcher
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
+        end
+
+        def failure_message_for_should
+          "expected given block to yield with no arguments, but #{failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with no arguments, but did"
+        end
+
+      private
+
+        def failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            "yielded with arguments: #{@probe.single_yield_args.inspect}"
+          end
+        end
+      end
+
+      class YieldWithArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.single_yield_args
+          @probe.yielded_once?(:yield_with_args) && args_match?
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected given block to yield with arguments, but #{positive_failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with arguments, but #{negative_failure_reason}"
+        end
+
+        def description
+          desc = "yield with args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" unless @expected.empty?
+          desc
+        end
+
+      private
+
+        def positive_failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            @positive_args_failure
+          end
+        end
+
+        def negative_failure_reason
+          if all_args_match?
+            "yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+          else
+            "did"
+          end
+        end
+
+        def args_match?
+          if @expected.empty? # expect {...}.to yield_with_args
+            @positive_args_failure = "yielded with no arguments" if @actual.empty?
+            return !@actual.empty?
+          end
+
+          unless match = all_args_match?
+            @positive_args_failure = "yielded with unexpected arguments" +
+              "\nexpected: #{@expected.inspect}" +
+              "\n     got: #{@actual.inspect} (compared using === and ==)"
+          end
+
+          match
+        end
+
+        def all_args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+
+      class YieldSuccessiveArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.successive_yield_args
+          args_match?
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
+            "\nexpected: #{@expected.inspect}" +
+            "\n     got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def description
+          desc = "yield successive args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
+          desc
+        end
+
+      private
+
+        def args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+    end
+  end
+end
+