guesswhat 0.1.0

data/vendor/bundle/gems/rspec-expectations-3.4.0/lib/rspec/matchers/built_in/operators.rb

@@ -0,0 +1,128 @@
+require 'rspec/support'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for operator matchers.
+      # Not intended to be instantiated directly.
+      # Only available for use with `should`.
+      class OperatorMatcher
+        class << self
+          # @private
+          def registry
+            @registry ||= {}
+          end
+
+          # @private
+          def register(klass, operator, matcher)
+            registry[klass] ||= {}
+            registry[klass][operator] = matcher
+          end
+
+          # @private
+          def unregister(klass, operator)
+            registry[klass] && registry[klass].delete(operator)
+          end
+
+          # @private
+          def get(klass, operator)
+            klass.ancestors.each do |ancestor|
+              matcher = registry[ancestor] && registry[ancestor][operator]
+              return matcher if matcher
+            end
+
+            nil
+          end
+        end
+
+        register Enumerable, '=~', BuiltIn::ContainExactly
+
+        def initialize(actual)
+          @actual = actual
+        end
+
+        # @private
+        def self.use_custom_matcher_or_delegate(operator)
+          define_method(operator) do |expected|
+            if !has_non_generic_implementation_of?(operator) && (matcher = OperatorMatcher.get(@actual.class, operator))
+              @actual.__send__(::RSpec::Matchers.last_expectation_handler.should_method, 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_expectation_handler.opposite_should_method
+              raise "RSpec does not support `#{::RSpec::Matchers.last_expectation_handler.should_method} #{negative_operator} expected`.  " \
+                "Use `#{opposite_should} #{operator} expected` instead."
+            end
+          end
+        end
+
+        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+          use_custom_matcher_or_delegate operator
+        end
+
+        # @private
+        def fail_with_message(message)
+          RSpec::Expectations.fail_with(message, @expected, @actual)
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "#{@operator} #{RSpec::Support::ObjectFormatter.format(@expected)}"
+        end
+
+      private
+
+        def has_non_generic_implementation_of?(op)
+          Support.method_handle_for(@actual, op).owner != ::Kernel
+        rescue NameError
+          false
+        end
+
+        def eval_match(actual, operator, expected)
+          ::RSpec::Matchers.last_matcher = self
+          @operator, @expected = operator, expected
+          __delegate_operator(actual, operator, expected)
+        end
+      end
+
+      # @private
+      # Handles operator matcher for `should`.
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          else
+            expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+            actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+            if ['==', '===', '=~'].include?(operator)
+              fail_with_message("expected: #{expected_formatted}\n     got: #{actual_formatted} (using #{operator})")
+            else
+              fail_with_message("expected: #{operator} #{expected_formatted}\n     got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
+            end
+          end
+        end
+      end
+
+      # @private
+      # Handles operator matcher for `should_not`.
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+
+          expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+          actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+          fail_with_message("expected not: #{operator} #{expected_formatted}\n         got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-3.4.0/lib/rspec/matchers/built_in/output.rb

@@ -0,0 +1,200 @@
+require 'stringio'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `output`.
+      # Not intended to be instantiated directly.
+      class Output < BaseMatcher
+        def initialize(expected)
+          @expected        = expected
+          @actual          = ""
+          @block           = nil
+          @stream_capturer = NullCapture
+        end
+
+        def matches?(block)
+          @block = block
+          return false unless Proc === block
+          @actual = @stream_capturer.capture(block)
+          @expected ? values_match?(@expected, @actual) : captured?
+        end
+
+        def does_not_match?(block)
+          !matches?(block) && Proc === block
+        end
+
+        # @api public
+        # Tells the matcher to match against stdout.
+        # Works only when the main Ruby process prints to stdout
+        def to_stdout
+          @stream_capturer = CaptureStdout
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        # Works only when the main Ruby process prints to stderr
+        def to_stderr
+          @stream_capturer = CaptureStderr
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stdout.
+        # Works when subprocesses print to stdout as well.
+        # This is significantly (~30x) slower than `to_stdout`
+        def to_stdout_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stdout", $stdout)
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        # Works when subprocesses print to stderr as well.
+        # This is significantly (~30x) slower than `to_stderr`
+        def to_stderr_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stderr", $stderr)
+          self
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected block to #{description}, but #{positive_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected block to not #{description}, but #{negative_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          if @expected
+            "output #{description_of @expected} to #{@stream_capturer.name}"
+          else
+            "output to #{@stream_capturer.name}"
+          end
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+        # @api private
+        # Indicates this matcher matches against a block.
+        # @return [True]
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def captured?
+          @actual.length > 0
+        end
+
+        def positive_failure_reason
+          return "was not a block" unless Proc === @block
+          return "output #{actual_output_description}" if @expected
+          "did not"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless Proc === @block
+          "output #{actual_output_description}"
+        end
+
+        def actual_output_description
+          return "nothing" unless captured?
+          actual_formatted
+        end
+      end
+
+      # @private
+      module NullCapture
+        def self.name
+          "some stream"
+        end
+
+        def self.capture(_block)
+          raise "You must chain `to_stdout` or `to_stderr` off of the `output(...)` matcher."
+        end
+      end
+
+      # @private
+      module CaptureStdout
+        def self.name
+          'stdout'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stdout
+          $stdout = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stdout = original_stream
+        end
+      end
+
+      # @private
+      module CaptureStderr
+        def self.name
+          'stderr'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stderr
+          $stderr = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stderr = original_stream
+        end
+      end
+
+      # @private
+      class CaptureStreamToTempfile < Struct.new(:name, :stream)
+        def capture(block)
+          # We delay loading tempfile until it is actually needed because
+          # we want to minimize stdlibs loaded so that users who use a
+          # portion of the stdlib can't have passing specs while forgetting
+          # to load it themselves. `CaptureStreamToTempfile` is rarely used
+          # and `tempfile` pulls in a bunch of things (delegate, tmpdir,
+          # thread, fileutils, etc), so it's worth delaying it until this point.
+          require 'tempfile'
+
+          original_stream = stream.clone
+          captured_stream = Tempfile.new(name)
+
+          begin
+            captured_stream.sync = true
+            stream.reopen(captured_stream)
+            block.call
+            captured_stream.rewind
+            captured_stream.read
+          ensure
+            stream.reopen(original_stream)
+            captured_stream.close
+            captured_stream.unlink
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-3.4.0/lib/rspec/matchers/built_in/raise_error.rb

@@ -0,0 +1,228 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `raise_error`.
+      # Not intended to be instantiated directly.
+      # rubocop:disable ClassLength
+      # rubocop:disable RescueException
+      class RaiseError
+        include Composable
+
+        def initialize(expected_error_or_message=nil, expected_message=nil, &block)
+          @block = block
+          @actual_error = nil
+          @warn_about_bare_error = warn_about_potential_false_positives? && expected_error_or_message.nil?
+
+          case expected_error_or_message
+          when nil
+            @expected_error = Exception
+            @expected_message = expected_message
+          when String
+            @expected_error = Exception
+            @expected_message = expected_error_or_message
+          else
+            @expected_error = expected_error_or_message
+            @expected_message = expected_message
+          end
+        end
+
+        # @api public
+        # Specifies the expected error message.
+        def with_message(expected_message)
+          raise_message_already_set if @expected_message
+          @warn_about_bare_error = false
+          @expected_message = expected_message
+          self
+        end
+
+        # rubocop:disable MethodLength
+        # @private
+        def matches?(given_proc, negative_expectation=false, &block)
+          @given_proc = given_proc
+          @block ||= block
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+
+          return false unless Proc === given_proc
+
+          begin
+            given_proc.call
+          rescue Exception => @actual_error
+            if values_match?(@expected_error, @actual_error) ||
+               values_match?(@expected_error, @actual_error.message)
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
+          end
+
+          warn_about_bare_error if warning_about_bare_error && !negative_expectation
+          eval_block if !negative_expectation && ready_to_eval_block?
+
+          expectation_matched?
+        end
+        # rubocop:enable MethodLength
+
+        # @private
+        def does_not_match?(given_proc)
+          warn_for_false_positives
+          !matches?(given_proc, :negative_expectation) && Proc === given_proc
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        def expects_call_stack_jump?
+          true
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "raise #{expected_error}"
+        end
+
+      private
+
+        def expectation_matched?
+          error_and_message_match? && block_matches?
+        end
+
+        def error_and_message_match?
+          @raised_expected_error && @with_expected_message
+        end
+
+        def block_matches?
+          @eval_block ? @eval_block_passed : true
+        end
+
+        def ready_to_eval_block?
+          @raised_expected_error && @with_expected_message && @block
+        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
+          return true if @expected_message.nil?
+          values_match?(@expected_message, @actual_error.message.to_s)
+        end
+
+        def warn_for_false_positives
+          return unless warn_about_potential_false_positives?
+          expression = 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
+
+          return unless expression
+
+          warn_about_negative_false_positive expression
+        end
+
+        def warn_about_potential_false_positives?
+          RSpec::Expectations.configuration.warn_about_potential_false_positives?
+        end
+
+        def warning_about_bare_error
+          @warn_about_bare_error && @block.nil?
+        end
+
+        def warn_about_bare_error
+          RSpec.warning("Using the `raise_error` matcher without providing a specific " \
+                        "error or message risks false positives, since `raise_error` " \
+                        "will match when Ruby raises a `NoMethodError`, `NameError` or " \
+                        "`ArgumentError`, potentially allowing the expectation to pass " \
+                        "without even executing the method you are intending to call. " \
+                        "#{warning}"\
+                        "Instead consider providing a specific error class or message. " \
+                        "This message can be supressed by setting: " \
+                        "`RSpec::Expectations.configuration.warn_about_potential_false_positives = false`")
+        end
+
+        def warn_about_negative_false_positive(expression)
+          RSpec.warning("Using #{expression} risks false positives, since literally " \
+                        "any other error would cause the expectation to pass, " \
+                        "including those raised by Ruby (e.g. NoMethodError, NameError " \
+                        "and ArgumentError), meaning the code you are intending to test " \
+                        "may not even get reached. Instead consider using " \
+                        "`expect {}.not_to raise_error`. This message can be supressed by setting: " \
+                        "`RSpec::Expectations.configuration.warn_about_potential_false_positives = false`")
+        end
+
+        def expected_error
+          case @expected_message
+          when nil
+            if RSpec::Support.is_a_matcher?(@expected_error)
+              "Exception with #{description_of(@expected_error)}"
+            else
+              description_of(@expected_error)
+            end
+          when Regexp
+            "#{@expected_error} with message matching #{description_of(@expected_message)}"
+          else
+            "#{@expected_error} with #{description_of(@expected_message)}"
+          end
+        end
+
+        def format_backtrace(backtrace)
+          formatter = Matchers.configuration.backtrace_formatter
+          formatter.format_backtrace(backtrace)
+        end
+
+        def given_error
+          return " but was not given a block" unless Proc === @given_proc
+          return " but nothing was raised" unless @actual_error
+
+          backtrace = format_backtrace(@actual_error.backtrace)
+          [
+            ", got #{description_of(@actual_error)} with backtrace:",
+            *backtrace
+          ].join("\n  # ")
+        end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
+
+        def raise_message_already_set
+          raise "`expect { }.to raise_error(message).with_message(message)` is not valid. " \
+                'The matcher only allows the expected message to be specified once'
+        end
+
+        def warning
+          warning = "Actual error raised was #{description_of(@actual_error)}. "
+          warning if @actual_error
+        end
+      end
+      # rubocop:enable RescueException
+      # rubocop:enable ClassLength
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-3.4.0/lib/rspec/matchers/built_in/respond_to.rb

@@ -0,0 +1,90 @@
+RSpec::Support.require_rspec_support "method_signature_verifier"
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `respond_to`.
+      # Not intended to be instantiated directly.
+      class RespondTo < BaseMatcher
+        def initialize(*names)
+          @names = names
+          @expected_arity = nil
+        end
+
+        # @api public
+        # Specifies the number of expected arguments.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        # @api public
+        # No-op. Intended to be used as syntactic sugar when using `with`.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def argument
+          self
+        end
+        alias :arguments :argument
+
+        # @private
+        def matches?(actual)
+          find_failing_method_names(actual, :reject).empty?
+        end
+
+        # @private
+        def does_not_match?(actual)
+          find_failing_method_names(actual, :select).empty?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to respond to #{@failing_method_names.map { |name| description_of(name) }.join(', ')}#{with_arity}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          failure_message.sub(/to respond to/, 'not to respond to')
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "respond to #{pp_names}#{with_arity}"
+        end
+
+      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
+
+          signature = Support::MethodSignature.new(Support.method_handle_for(actual, name))
+          Support::StrictSignatureVerifier.new(signature, Array.new(@expected_arity)).valid?
+        end
+
+        def with_arity
+          return "" unless @expected_arity
+          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def pp_names
+          @names.length == 1 ? "##{@names.first}" : description_of(@names)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-3.4.0/lib/rspec/matchers/built_in/satisfy.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `satisfy`.
+      # Not intended to be instantiated directly.
+      class Satisfy < BaseMatcher
+        # @private
+        attr_reader :description
+
+        def initialize(description="satisfy block", &block)
+          @description = description
+          @block = block
+        end
+
+        # @private
+        def matches?(actual, &block)
+          @block = block if block
+          @actual = actual
+          @block.call(actual)
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to #{description}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} not to #{description}"
+        end
+      end
+    end
+  end
+end