pad_character 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/base_matcher.rb

@@ -0,0 +1,198 @@
+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
+
+        # @private
+        def supports_value_expectations?
+          true
+        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/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/be.rb

@@ -0,0 +1,191 @@
+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)
+          perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
+        end
+
+        def does_not_match?(actual)
+          !perform_match(actual)
+        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
+
+      private
+
+        def perform_match(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/be_between.rb

@@ -0,0 +1,77 @@
+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/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/be_instance_of.rb

@@ -0,0 +1,26 @@
+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/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/be_kind_of.rb

@@ -0,0 +1,20 @@
+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/ruby/2.6.0/gems/rspec-expectations-3.12.0/lib/rspec/matchers/built_in/be_within.rb

@@ -0,0 +1,72 @@
+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 = @expected.abs * @delta / 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_formatted}"
+        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