husc 0.2.1 → 0.2.2

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/base_matcher.rb

@@ -1,193 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      #
-      # Used _internally_ as a base class for matchers that ship with
-      # rspec-expectations and rspec-rails.
-      #
-      # ### Warning:
-      #
-      # This class is for internal use, and subject to change without notice.
-      # We strongly recommend that you do not base your custom matchers on this
-      # class. If/when this changes, we will announce it and remove this warning.
-      class BaseMatcher
-        include RSpec::Matchers::Composable
-
-        # @api private
-        # Used to detect when no arg is passed to `initialize`.
-        # `nil` cannot be used because it's a valid value to pass.
-        UNDEFINED = Object.new.freeze
-
-        # @private
-        attr_reader :actual, :expected, :rescued_exception
-
-        # @private
-        attr_writer :matcher_name
-
-        def initialize(expected=UNDEFINED)
-          @expected = expected unless UNDEFINED.equal?(expected)
-        end
-
-        # @api private
-        # Indicates if the match is successful. Delegates to `match`, which
-        # should be defined on a subclass. Takes care of consistently
-        # initializing the `actual` attribute.
-        def matches?(actual)
-          @actual = actual
-          match(expected, actual)
-        end
-
-        # @api private
-        # Used to wrap a block of code that will indicate failure by
-        # raising one of the named exceptions.
-        #
-        # This is used by rspec-rails for some of its matchers that
-        # wrap rails' assertions.
-        def match_unless_raises(*exceptions)
-          exceptions.unshift Exception if exceptions.empty?
-          begin
-            yield
-            true
-          rescue *exceptions => @rescued_exception
-            false
-          end
-        end
-
-        # @api private
-        # Generates a description using {EnglishPhrasing}.
-        # @return [String]
-        def description
-          desc = EnglishPhrasing.split_words(self.class.matcher_name)
-          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
-          desc
-        end
-
-        # @api private
-        # Matchers are not diffable by default. Override this to make your
-        # subclass diffable.
-        def diffable?
-          false
-        end
-
-        # @api private
-        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
-        # rather than block matchers (i.e. meant to work with `expect { }`), so
-        # this defaults to false. Block matchers must override this to return true.
-        def supports_block_expectations?
-          false
-        end
-
-        # @api private
-        def expects_call_stack_jump?
-          false
-        end
-
-        # @private
-        def expected_formatted
-          RSpec::Support::ObjectFormatter.format(@expected)
-        end
-
-        # @private
-        def actual_formatted
-          RSpec::Support::ObjectFormatter.format(@actual)
-        end
-
-        # @private
-        def self.matcher_name
-          @matcher_name ||= underscore(name.split('::').last)
-        end
-
-        # @private
-        def matcher_name
-          if defined?(@matcher_name)
-            @matcher_name
-          else
-            self.class.matcher_name
-          end
-        end
-
-        # @private
-        # Borrowed from ActiveSupport.
-        def self.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_class_method :underscore
-
-      private
-
-        def assert_ivars(*expected_ivars)
-          return unless (expected_ivars - present_ivars).any?
-          ivar_list = EnglishPhrasing.list(expected_ivars)
-          raise "#{self.class.name} needs to supply#{ivar_list}"
-        end
-
-        if RUBY_VERSION.to_f < 1.9
-          # :nocov:
-          def present_ivars
-            instance_variables.map(&:to_sym)
-          end
-          # :nocov:
-        else
-          alias present_ivars instance_variables
-        end
-
-        # @private
-        module HashFormatting
-          # `{ :a => 5, :b => 2 }.inspect` produces:
-          #
-          #     {:a=>5, :b=>2}
-          #
-          # ...but it looks much better as:
-          #
-          #     {:a => 5, :b => 2}
-          #
-          # This is idempotent and safe to run on a string multiple times.
-          def improve_hash_formatting(inspect_string)
-            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
-          end
-          module_function :improve_hash_formatting
-        end
-
-        include HashFormatting
-
-        # @api private
-        # Provides default implementations of failure messages, based on the `description`.
-        module DefaultFailureMessages
-          # @api private
-          # Provides a good generic failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message
-            "expected #{description_of @actual} to #{description}".dup
-          end
-
-          # @api private
-          # Provides a good generic negative failure message. Based on `description`.
-          # When subclassing, if you are not satisfied with this failure message
-          # you often only need to override `description`.
-          # @return [String]
-          def failure_message_when_negated
-            "expected #{description_of @actual} not to #{description}".dup
-          end
-
-          # @private
-          def self.has_default_failure_messages?(matcher)
-            matcher.method(:failure_message).owner == self &&
-              matcher.method(:failure_message_when_negated).owner == self
-          rescue NameError
-            false
-          end
-        end
-
-        include DefaultFailureMessages
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/be.rb

@@ -1,288 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_truthy`.
-      # Not intended to be instantiated directly.
-      class BeTruthy < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: truthy value\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: falsey value\n     got: #{actual_formatted}"
-        end
-
-      private
-
-        def match(_, actual)
-          !!actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be_falsey`.
-      # Not intended to be instantiated directly.
-      class BeFalsey < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: falsey value\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: truthy value\n     got: #{actual_formatted}"
-        end
-
-      private
-
-        def match(_, actual)
-          !actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be_nil`.
-      # Not intended to be instantiated directly.
-      class BeNil < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: nil\n     got: #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected: not nil\n     got: nil"
-        end
-
-      private
-
-        def match(_, actual)
-          actual.nil?
-        end
-      end
-
-      # @private
-      module BeHelpers
-      private
-
-        def args_to_s
-          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
-        end
-
-        def parenthesize(string)
-          "(#{string})"
-        end
-
-        def inspected_args
-          @args.map { |a| RSpec::Support::ObjectFormatter.format(a) }
-        end
-
-        def expected_to_sentence
-          EnglishPhrasing.split_words(@expected)
-        end
-
-        def args_to_sentence
-          EnglishPhrasing.list(@args)
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `be`.
-      # Not intended to be instantiated directly.
-      class Be < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args)
-          @args = args
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to evaluate to true"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} to evaluate to false"
-        end
-
-        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
-          define_method operator do |operand|
-            BeComparedTo.new(operand, operator)
-          end
-        end
-
-      private
-
-        def match(_, actual)
-          !!actual
-        end
-      end
-
-      # @api private
-      # Provides the implementation of `be <operator> value`.
-      # Not intended to be instantiated directly.
-      class BeComparedTo < BaseMatcher
-        include BeHelpers
-
-        def initialize(operand, operator)
-          @expected = operand
-          @operator = operator
-          @args = []
-        end
-
-        def matches?(actual)
-          @actual = actual
-          @actual.__send__ @operator, @expected
-        rescue ArgumentError, NoMethodError
-          false
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected: #{@operator} #{expected_formatted}\n" \
-          "     got: #{@operator.to_s.gsub(/./, ' ')} #{actual_formatted}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          message = "`expect(#{actual_formatted}).not_to " \
-                    "be #{@operator} #{expected_formatted}`"
-          if [:<, :>, :<=, :>=].include?(@operator)
-            message + " not only FAILED, it is a bit confusing."
-          else
-            message
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
-        end
-      end
-
-      # @api private
-      # Provides the implementation of `be_<predicate>`.
-      # Not intended to be instantiated directly.
-      class BePredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
-        end
-
-        def matches?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        def does_not_match?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && !predicate_matches?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          failure_message_expecting(true)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message_expecting(false)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-        end
-
-      private
-
-        def predicate_accessible?
-          actual.respond_to?(predicate) || actual.respond_to?(present_tense_predicate)
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          # :nocov:
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-          # :nocov:
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_matches?
-          method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
-          @predicate_matches = actual.__send__(method_name, *@args, &@block)
-        end
-
-        def predicate
-          :"#{@expected}?"
-        end
-
-        def present_tense_predicate
-          :"#{@expected}s?"
-        end
-
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
-        end
-
-        def prefix_and_expected(symbol)
-          Matchers::BE_PREDICATE_REGEX.match(symbol.to_s).captures.compact
-        end
-
-        def prefix_to_sentence
-          EnglishPhrasing.split_words(@prefix)
-        end
-
-        def failure_message_expecting(value)
-          validity_message ||
-            "expected `#{actual_formatted}.#{predicate}#{args_to_s}` to return #{value}, got #{description_of @predicate_matches}"
-        end
-
-        def validity_message
-          return nil if predicate_accessible?
-
-          msg = "expected #{actual_formatted} to respond to `#{predicate}`".dup
-
-          if private_predicate?
-            msg << " but `#{predicate}` is a private method"
-          elsif predicate == :true?
-            msg << " or perhaps you meant `be true` or `be_truthy`"
-          elsif predicate == :false?
-            msg << " or perhaps you meant `be false` or `be_falsey`"
-          end
-
-          msg
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/be_between.rb

@@ -1,77 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_between`.
-      # Not intended to be instantiated directly.
-      class BeBetween < BaseMatcher
-        def initialize(min, max)
-          @min, @max = min, max
-          inclusive
-        end
-
-        # @api public
-        # Makes the between comparison inclusive.
-        #
-        # @example
-        #   expect(3).to be_between(2, 3).inclusive
-        #
-        # @note The matcher is inclusive by default; this simply provides
-        #       a way to be more explicit about it.
-        def inclusive
-          @less_than_operator = :<=
-          @greater_than_operator = :>=
-          @mode = :inclusive
-          self
-        end
-
-        # @api public
-        # Makes the between comparison exclusive.
-        #
-        # @example
-        #   expect(3).to be_between(2, 4).exclusive
-        def exclusive
-          @less_than_operator = :<
-          @greater_than_operator = :>
-          @mode = :exclusive
-          self
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          @actual = actual
-          comparable? && compare
-        rescue ArgumentError
-          false
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "#{super}#{not_comparable_clause}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "be between #{description_of @min} and #{description_of @max} (#{@mode})"
-        end
-
-      private
-
-        def comparable?
-          @actual.respond_to?(@less_than_operator) && @actual.respond_to?(@greater_than_operator)
-        end
-
-        def not_comparable_clause
-          ", but it does not respond to `#{@less_than_operator}` and `#{@greater_than_operator}`" unless comparable?
-        end
-
-        def compare
-          @actual.__send__(@greater_than_operator, @min) && @actual.__send__(@less_than_operator, @max)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/be_instance_of.rb

@@ -1,26 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_an_instance_of`.
-      # Not intended to be instantiated directly.
-      class BeAnInstanceOf < BaseMatcher
-        # @api private
-        # @return [String]
-        def description
-          "be an instance of #{expected}"
-        end
-
-      private
-
-        def match(expected, actual)
-          actual.instance_of?(expected)
-        rescue NoMethodError
-          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
-                                 "the actual object responds to #instance_of? method " \
-                                 "but a `NoMethodError` was encountered instead."
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/be_kind_of.rb

@@ -1,20 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_a_kind_of`.
-      # Not intended to be instantiated directly.
-      class BeAKindOf < BaseMatcher
-      private
-
-        def match(expected, actual)
-          actual.kind_of?(expected)
-        rescue NoMethodError
-          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
-                                 "the actual object responds to #kind_of? method " \
-                                 "but a `NoMethodError` was encountered instead."
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rspec-expectations-3.9.0/lib/rspec/matchers/built_in/be_within.rb

@@ -1,72 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `be_within`.
-      # Not intended to be instantiated directly.
-      class BeWithin < BaseMatcher
-        def initialize(delta)
-          @delta = delta
-        end
-
-        # @api public
-        # Sets the expected value.
-        def of(expected)
-          @expected  = expected
-          @tolerance = @delta
-          @unit      = ''
-          self
-        end
-
-        # @api public
-        # Sets the expected value, and makes the matcher do
-        # a percent comparison.
-        def percent_of(expected)
-          @expected  = expected
-          @tolerance = @delta * @expected.abs / 100.0
-          @unit      = '%'
-          self
-        end
-
-        # @private
-        def matches?(actual)
-          @actual = actual
-          raise needs_expected unless defined? @expected
-          numeric? && (@actual - @expected).abs <= @tolerance
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to #{description}#{not_numeric_clause}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} not to #{description}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "be within #{@delta}#{@unit} of #{@expected}"
-        end
-
-      private
-
-        def numeric?
-          @actual.respond_to?(:-)
-        end
-
-        def needs_expected
-          ArgumentError.new "You must set an expected value using #of: be_within(#{@delta}).of(expected_value)"
-        end
-
-        def not_numeric_clause
-          ", but it could not be treated as a numeric value" unless numeric?
-        end
-      end
-    end
-  end
-end