vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/deprecation.rb

@@ -1,31 +0,0 @@
-module RSpec
-  module Expectations
-    module Deprecation
-     RSPEC_LIBS = %w[
-        core
-        mocks
-        expectations
-        matchers
-        rails
-      ]
-
-      ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
-
-      LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
-
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def deprecate(deprecated, options={})
-        call_site = caller.find { |line| line !~ LIB_REGEX }
-
-        message = "DEPRECATION: #{deprecated} is deprecated."
-        message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{call_site}."
-        warn message
-      end
-    end
-  end
-
-  extend(Expectations::Deprecation) unless respond_to?(:deprecate)
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/differ.rb

@@ -1,154 +0,0 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'pp'
-
-module RSpec
-  module Expectations
-    class Differ
-
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(input_data_new, input_data_old)
-        encoding = pick_encoding input_data_new, input_data_old
-        output = matching_encoding("", encoding)
-        data_old = input_data_old.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        data_new = input_data_new.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(
-              data_old, data_new, piece, context_lines, file_length_difference
-            )
-            file_length_difference = hunk.file_length_difference
-            next unless oldhunk
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              if hunk.respond_to?(:merge)
-                # diff-lcs 1.2.x
-                hunk.merge(oldhunk)
-              else
-                # diff-lcs 1.1.3
-                hunk.unshift(oldhunk)
-              end
-            else
-              output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-            end
-          ensure
-            oldhunk = hunk
-            output << matching_encoding("\n", encoding)
-          end
-        end
-        #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-        output << matching_encoding("\n", encoding)
-        color_diff output
-      rescue Encoding::CompatibilityError
-        if input_data_new.encoding != input_data_old.encoding
-          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
-          "differs from the encoding of the expected string (#{input_data_new.encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
-        end
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        if diff = diff_as_string(actual_as_string, expected_as_string)
-          color_diff diff
-        end
-      end
-
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text)
-        color(text, 31)
-      end
-
-      def green(text)
-        color(text, 32)
-      end
-
-      def blue(text)
-        color(text, 34)
-      end
-
-      def color_diff(diff)
-        return diff unless RSpec::Matchers.configuration.color?
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : line
-          else
-            line
-          end
-        }.join
-      end
-
-      def object_to_string(object)
-        case object
-        when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |key|
-            pp_key   = PP.singleline_pp(key, "")
-            pp_value = PP.singleline_pp(object[key], "")
-
-            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
-            #
-            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
-            # <# a: b: c:> not <# c: a: b:>
-            encoding = pick_encoding pp_key, pp_value
-            matching_encoding("#{pp_key} => #{pp_value}", encoding)
-          end.join(",\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
-        end
-      end
-
-    private
-
-      if String.method_defined?(:encoding)
-        def pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-
-        def matching_encoding(string, encoding)
-          string.encode encoding
-        rescue Encoding::UndefinedConversionError
-          string.encode(encoding, :undef => :replace)
-        end
-      else
-        def pick_encoding(source_a, source_b)
-        end
-
-        def matching_encoding(string, encoding)
-          string
-        end
-      end
-    end
-
-  end
-end
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/errors.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Expectations
-    if defined?(Test::Unit::AssertionFailedError)
-      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
-    else
-      class ExpectationNotMetError < ::StandardError; end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/expectation_target.rb

@@ -1,87 +0,0 @@
-module RSpec
-  module Expectations
-    # Wraps the target of an expectation.
-    # @example
-    #   expect(something) # => ExpectationTarget wrapping something
-    #
-    #   # used with `to`
-    #   expect(actual).to eq(3)
-    #
-    #   # with `not_to`
-    #   expect(actual).not_to eq(3)
-    class ExpectationTarget
-      class << self
-        attr_accessor :deprecated_should_enabled
-        alias deprecated_should_enabled? deprecated_should_enabled
-      end
-
-      # @api private
-      def initialize(target)
-        @target = target
-      end
-
-      # Runs the given expectation, passing if `matcher` returns true.
-      # @example
-      #   expect(value).to eq(5)
-      #   expect { perform }.to raise_error
-      # @param [Matcher]
-      #   matcher
-      # @param [String] message optional message to display when the expectation fails
-      # @return [Boolean] true if the expectation succeeds (else raises)
-      # @see RSpec::Matchers
-      def to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to, matcher)
-        RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
-      end
-
-      # Runs the given expectation, passing if `matcher` returns false.
-      # @example
-      #   expect(value).not_to eq(5)
-      # @param [Matcher]
-      #   matcher
-      # @param [String] message optional message to display when the expectation fails
-      # @return [Boolean] false if the negative expectation succeeds (else raises)
-      # @see RSpec::Matchers
-      def not_to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:not_to, matcher)
-        RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
-      end
-      alias to_not not_to
-
-      def self.enable_deprecated_should
-        return if deprecated_should_enabled?
-
-        def should(*args)
-          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
-          @target.should(*args)
-        end
-
-        def should_not(*args)
-          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
-          @target.should_not(*args)
-        end
-
-        self.deprecated_should_enabled = true
-      end
-
-      def self.disable_deprecated_should
-        return unless deprecated_should_enabled?
-
-        remove_method :should
-        remove_method :should_not
-
-        self.deprecated_should_enabled = false
-      end
-
-    private
-
-      def prevent_operator_matchers(verb, matcher)
-        return if matcher
-
-        raise ArgumentError, "The expect syntax does not support operator matchers, " +
-                             "so you must pass a matcher to `##{verb}`."
-      end
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/extensions.rb

@@ -1,2 +0,0 @@
-require 'rspec/expectations/extensions/array'
-require 'rspec/expectations/extensions/object'

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/extensions/array.rb

@@ -1,9 +0,0 @@
-# @private
-class Array
-  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
-    # Supports +none?+ on early patch levels of Ruby 1.8.6
-    def none?(&block)
-      !any?(&block)
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/extensions/object.rb

@@ -1,29 +0,0 @@
-module RSpec
-  module Expectations
-    module DeprecatedConstants
-      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
-      # delegates to super.
-      def const_missing(name)
-        case name
-        when :Rspec, :Spec
-          RSpec.deprecate(name.to_s, :replacement => "RSpec")
-          RSpec
-        else
-          begin
-            super
-          rescue Exception => e
-            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
-            raise e
-          end
-        end
-      end
-    end
-
-    # @deprecated (no replacement)
-    def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
-    end
-  end
-end
-
-extend RSpec::Expectations::DeprecatedConstants

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/fail_with.rb

@@ -1,79 +0,0 @@
-module RSpec
-  module Expectations
-    class << self
-      # @private
-      def differ
-        @differ ||= Differ.new
-      end
-
-      # Raises an RSpec::Expectations::ExpectationNotMetError with message.
-      # @param [String] message
-      # @param [Object] expected
-      # @param [Object] actual
-      #
-      # Adds a diff to the failure message when `expected` and `actual` are
-      # both present.
-      def fail_with(message, expected=nil, actual=nil)
-        if !message
-          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
-                               "appropriate failure_message_for_* method to return a string?"
-        end
-
-        if actual && expected
-          if all_strings?(actual, expected)
-            if any_multiline_strings?(actual, expected)
-              message << "\nDiff:" << differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
-            end
-          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            message << "\nDiff:" << differ.diff_as_object(actual, expected)
-          end
-        end
-
-        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
-      end
-
-    private
-
-      def no_procs?(*args)
-        args.flatten.none? {|a| Proc === a}
-      end
-
-      def all_strings?(*args)
-        args.flatten.all? {|a| String === a}
-      end
-
-      def any_multiline_strings?(*args)
-        all_strings?(*args) && args.flatten.any? { |a| multiline?(a) }
-      end
-
-      def no_numbers?(*args)
-        args.flatten.none? {|a| Numeric === a}
-      end
-
-      def coerce_to_string(string_or_array)
-        return string_or_array unless Array === string_or_array
-        diffably_stringify(string_or_array).join("\n")
-      end
-
-      def diffably_stringify(array)
-        array.map do |entry|
-          if Array === entry
-            entry.inspect
-          else
-            entry.to_s.gsub("\n", "\\n")
-          end
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def multiline?(string)
-          string.include?("\n".encode(string.encoding))
-        end
-      else
-        def multiline?(string)
-          string.include?("\n")
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/lib/rspec/expectations/handler.rb

@@ -1,68 +0,0 @@
-module RSpec
-  module Expectations
-
-    class ExpectationHandler
-      def self.check_message(msg)
-        unless msg.nil? || msg.respond_to?(:to_str) || msg.respond_to?(:call)
-          ::Kernel.warn [
-            "WARNING: ignoring the provided expectation message argument (",
-            msg.inspect,
-            ") since it is not a string or a proc."
-          ].join
-        end
-      end
-    end
-
-    class PositiveExpectationHandler < ExpectationHandler
-
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        check_message(message)
-        ::RSpec::Matchers.last_should = :should
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.matches?(actual, &block)
-        return match if match
-
-        message = message.call if message.respond_to?(:call)
-
-        message ||= matcher.respond_to?(:failure_message_for_should) ?
-                    matcher.failure_message_for_should :
-                    matcher.failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-
-    class NegativeExpectationHandler < ExpectationHandler
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        check_message(message)
-        ::RSpec::Matchers.last_should = :should_not
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.respond_to?(:does_not_match?) ?
-                !matcher.does_not_match?(actual, &block) :
-                matcher.matches?(actual, &block)
-        return match unless match
-
-        message = message.call if message.respond_to?(:call)
-
-        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
-                    matcher.failure_message_for_should_not :
-                    matcher.negative_failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-  end
-end
-