primary_connect_proto 0.4.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/contain_exactly.rb

@@ -1,302 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # rubocop:disable ClassLength
-      # @api private
-      # Provides the implementation for `contain_exactly` and `match_array`.
-      # Not intended to be instantiated directly.
-      class ContainExactly < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          if Array === actual
-            generate_failure_message
-          else
-            "expected a collection that can be converted to an array with " \
-            "`#to_ary` or `#to_a`, but got #{actual_formatted}"
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          list = EnglishPhrasing.list(surface_descriptions_in(expected))
-          "expected #{actual_formatted} not to contain exactly#{list}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          list = EnglishPhrasing.list(surface_descriptions_in(expected))
-          "contain exactly#{list}"
-        end
-
-      private
-
-        def generate_failure_message
-          message = expected_collection_line
-          message += actual_collection_line
-          message += missing_elements_line unless missing_items.empty?
-          message += extra_elements_line unless extra_items.empty?
-          message
-        end
-
-        def expected_collection_line
-          message_line('expected collection contained', expected, true)
-        end
-
-        def actual_collection_line
-          message_line('actual collection contained', actual)
-        end
-
-        def missing_elements_line
-          message_line('the missing elements were', missing_items, true)
-        end
-
-        def extra_elements_line
-          message_line('the extra elements were', extra_items)
-        end
-
-        def describe_collection(collection, surface_descriptions=false)
-          if surface_descriptions
-            "#{description_of(safe_sort(surface_descriptions_in collection))}\n"
-          else
-            "#{description_of(safe_sort(collection))}\n"
-          end
-        end
-
-        def message_line(prefix, collection, surface_descriptions=false)
-          "%-32s%s" % [prefix + ':',
-                       describe_collection(collection, surface_descriptions)]
-        end
-
-        def match(_expected, _actual)
-          return false unless convert_actual_to_an_array
-          match_when_sorted? || (extra_items.empty? && missing_items.empty?)
-        end
-
-        # This cannot always work (e.g. when dealing with unsortable items,
-        # or matchers as expected items), but it's practically free compared to
-        # the slowness of the full matching algorithm, and in common cases this
-        # works, so it's worth a try.
-        def match_when_sorted?
-          values_match?(safe_sort(expected), safe_sort(actual))
-        end
-
-        def convert_actual_to_an_array
-          if actual.respond_to?(:to_ary)
-            @actual = actual.to_ary
-          elsif actual.respond_to?(:to_a) && !to_a_disallowed?(actual)
-            @actual = actual.to_a
-          else
-            false
-          end
-        end
-
-        def safe_sort(array)
-          array.sort
-        rescue Support::AllExceptionsExceptOnesWeMustNotRescue
-          array
-        end
-
-        if RUBY_VERSION == "1.8.7"
-          def to_a_disallowed?(object)
-            case object
-            when NilClass, String then true
-            else Kernel == RSpec::Support.method_handle_for(object, :to_a).owner
-            end
-          end
-        else
-          def to_a_disallowed?(object)
-            NilClass === object
-          end
-        end
-
-        def missing_items
-          @missing_items ||= best_solution.unmatched_expected_indexes.map do |index|
-            expected[index]
-          end
-        end
-
-        def extra_items
-          @extra_items ||= best_solution.unmatched_actual_indexes.map do |index|
-            actual[index]
-          end
-        end
-
-        def best_solution
-          @best_solution ||= pairings_maximizer.find_best_solution
-        end
-
-        def pairings_maximizer
-          @pairings_maximizer ||= begin
-            expected_matches = Hash[Array.new(expected.size) { |i| [i, []] }]
-            actual_matches   = Hash[Array.new(actual.size)   { |i| [i, []] }]
-
-            expected.each_with_index do |e, ei|
-              actual.each_with_index do |a, ai|
-                next unless values_match?(e, a)
-
-                expected_matches[ei] << ai
-                actual_matches[ai] << ei
-              end
-            end
-
-            PairingsMaximizer.new(expected_matches, actual_matches)
-          end
-        end
-
-        # Once we started supporting composing matchers, the algorithm for this matcher got
-        # much more complicated. Consider this expression:
-        #
-        #   expect(["fool", "food"]).to contain_exactly(/foo/, /fool/)
-        #
-        # This should pass (because we can pair /fool/ with "fool" and /foo/ with "food"), but
-        # the original algorithm used by this matcher would pair the first elements it could
-        # (/foo/ with "fool"), which would leave /fool/ and "food" unmatched.  When we have
-        # an expected element which is a matcher that matches a superset of actual items
-        # compared to another expected element matcher, we need to consider every possible pairing.
-        #
-        # This class is designed to maximize the number of actual/expected pairings -- or,
-        # conversely, to minimize the number of unpaired items. It's essentially a brute
-        # force solution, but with a few heuristics applied to reduce the size of the
-        # problem space:
-        #
-        #   * Any items which match none of the items in the other list are immediately
-        #     placed into the `unmatched_expected_indexes` or `unmatched_actual_indexes` array.
-        #     The extra items and missing items in the matcher failure message are derived
-        #     from these arrays.
-        #   * Any items which reciprocally match only each other are paired up and not
-        #     considered further.
-        #
-        # What's left is only the items which match multiple items from the other list
-        # (or vice versa). From here, it performs a brute-force depth-first search,
-        # looking for a solution which pairs all elements in both lists, or, barring that,
-        # that produces the fewest unmatched items.
-        #
-        # @private
-        class PairingsMaximizer
-          # @private
-          Solution = Struct.new(:unmatched_expected_indexes,     :unmatched_actual_indexes,
-                                :indeterminate_expected_indexes, :indeterminate_actual_indexes) do
-            def worse_than?(other)
-              unmatched_item_count > other.unmatched_item_count
-            end
-
-            def candidate?
-              indeterminate_expected_indexes.empty? &&
-              indeterminate_actual_indexes.empty?
-            end
-
-            def ideal?
-              candidate? && (
-                unmatched_expected_indexes.empty? ||
-                unmatched_actual_indexes.empty?
-              )
-            end
-
-            def unmatched_item_count
-              unmatched_expected_indexes.count + unmatched_actual_indexes.count
-            end
-
-            def +(derived_candidate_solution)
-              self.class.new(
-                unmatched_expected_indexes + derived_candidate_solution.unmatched_expected_indexes,
-                unmatched_actual_indexes   + derived_candidate_solution.unmatched_actual_indexes,
-                # Ignore the indeterminate indexes: by the time we get here,
-                # we've dealt with all indeterminates.
-                [], []
-              )
-            end
-          end
-
-          attr_reader :expected_to_actual_matched_indexes, :actual_to_expected_matched_indexes, :solution
-
-          def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes)
-            @expected_to_actual_matched_indexes = expected_to_actual_matched_indexes
-            @actual_to_expected_matched_indexes = actual_to_expected_matched_indexes
-
-            unmatched_expected_indexes, indeterminate_expected_indexes =
-              categorize_indexes(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes)
-
-            unmatched_actual_indexes, indeterminate_actual_indexes =
-              categorize_indexes(actual_to_expected_matched_indexes, expected_to_actual_matched_indexes)
-
-            @solution = Solution.new(unmatched_expected_indexes,     unmatched_actual_indexes,
-                                     indeterminate_expected_indexes, indeterminate_actual_indexes)
-          end
-
-          def find_best_solution
-            return solution if solution.candidate?
-            best_solution_so_far = NullSolution
-
-            expected_index = solution.indeterminate_expected_indexes.first
-            actuals = expected_to_actual_matched_indexes[expected_index]
-
-            actuals.each do |actual_index|
-              solution = best_solution_for_pairing(expected_index, actual_index)
-              return solution if solution.ideal?
-              best_solution_so_far = solution if best_solution_so_far.worse_than?(solution)
-            end
-
-            best_solution_so_far
-          end
-
-        private
-
-          # @private
-          # Starting solution that is worse than any other real solution.
-          NullSolution = Class.new do
-            def self.worse_than?(_other)
-              true
-            end
-          end
-
-          def categorize_indexes(indexes_to_categorize, other_indexes)
-            unmatched     = []
-            indeterminate = []
-
-            indexes_to_categorize.each_pair do |index, matches|
-              if matches.empty?
-                unmatched << index
-              elsif !reciprocal_single_match?(matches, index, other_indexes)
-                indeterminate << index
-              end
-            end
-
-            return unmatched, indeterminate
-          end
-
-          def reciprocal_single_match?(matches, index, other_list)
-            return false unless matches.one?
-            other_list[matches.first] == [index]
-          end
-
-          def best_solution_for_pairing(expected_index, actual_index)
-            modified_expecteds = apply_pairing_to(
-              solution.indeterminate_expected_indexes,
-              expected_to_actual_matched_indexes, actual_index)
-
-            modified_expecteds.delete(expected_index)
-
-            modified_actuals = apply_pairing_to(
-              solution.indeterminate_actual_indexes,
-              actual_to_expected_matched_indexes, expected_index)
-
-            modified_actuals.delete(actual_index)
-
-            solution + self.class.new(modified_expecteds, modified_actuals).find_best_solution
-          end
-
-          def apply_pairing_to(indeterminates, original_matches, other_list_index)
-            indeterminates.inject({}) do |accum, index|
-              accum[index] = original_matches[index] - [other_list_index]
-              accum
-            end
-          end
-        end
-      end
-      # rubocop:enable ClassLength
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/count_expectation.rb

@@ -1,169 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Asbtract class to implement `once`, `at_least` and other
-      # count constraints.
-      module CountExpectation
-        # @api public
-        # Specifies that the method is expected to match once.
-        def once
-          exactly(1)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match twice.
-        def twice
-          exactly(2)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match thrice.
-        def thrice
-          exactly(3)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match the given number of times.
-        def exactly(number)
-          set_expected_count(:==, number)
-          self
-        end
-
-        # @api public
-        # Specifies the maximum number of times the method is expected to match
-        def at_most(number)
-          set_expected_count(:<=, number)
-          self
-        end
-
-        # @api public
-        # Specifies the minimum number of times the method is expected to match
-        def at_least(number)
-          set_expected_count(:>=, number)
-          self
-        end
-
-        # @api public
-        # No-op. Provides syntactic sugar.
-        def times
-          self
-        end
-
-      protected
-        # @api private
-        attr_reader :count_expectation_type, :expected_count
-
-      private
-
-        if RUBY_VERSION.to_f > 1.8
-          def cover?(count, number)
-            count.cover?(number)
-          end
-        else
-          def cover?(count, number)
-            number >= count.first && number <= count.last
-          end
-        end
-
-        def expected_count_matches?(actual_count)
-          @actual_count = actual_count
-          return @actual_count > 0 unless count_expectation_type
-          return cover?(expected_count, actual_count) if count_expectation_type == :<=>
-
-          @actual_count.__send__(count_expectation_type, expected_count)
-        end
-
-        def has_expected_count?
-          !!count_expectation_type
-        end
-
-        def set_expected_count(relativity, n)
-          raise_unsupported_count_expectation if unsupported_count_expectation?(relativity)
-
-          count = count_constraint_to_number(n)
-
-          if count_expectation_type == :<= && relativity == :>=
-            raise_impossible_count_expectation(count) if count > expected_count
-            @count_expectation_type = :<=>
-            @expected_count = count..expected_count
-          elsif count_expectation_type == :>= && relativity == :<=
-            raise_impossible_count_expectation(count) if count < expected_count
-            @count_expectation_type = :<=>
-            @expected_count = expected_count..count
-          else
-            @count_expectation_type = relativity
-            @expected_count = count
-          end
-        end
-
-        def raise_impossible_count_expectation(count)
-          text =
-            case count_expectation_type
-            when :<= then "at_least(#{count}).at_most(#{expected_count})"
-            when :>= then "at_least(#{expected_count}).at_most(#{count})"
-            end
-          raise ArgumentError, "The constraint #{text} is not possible"
-        end
-
-        def raise_unsupported_count_expectation
-          text =
-            case count_expectation_type
-            when :<= then "at_least"
-            when :>= then "at_most"
-            when :<=> then "at_least/at_most combination"
-            else "count"
-            end
-          raise ArgumentError, "Multiple #{text} constraints are not supported"
-        end
-
-        def count_constraint_to_number(n)
-          case n
-          when Numeric then n
-          when :once then 1
-          when :twice then 2
-          when :thrice then 3
-          else
-            raise ArgumentError, "Expected a number, :once, :twice or :thrice," \
-              " but got #{n}"
-          end
-        end
-
-        def unsupported_count_expectation?(relativity)
-          return true if count_expectation_type == :==
-          return true if count_expectation_type == :<=>
-          (count_expectation_type == :<= && relativity == :<=) ||
-            (count_expectation_type == :>= && relativity == :>=)
-        end
-
-        def count_expectation_description
-          "#{human_readable_expectation_type}#{human_readable_count(expected_count)}"
-        end
-
-        def count_failure_reason(action)
-          "#{count_expectation_description}" \
-          " but #{action}#{human_readable_count(@actual_count)}"
-        end
-
-        def human_readable_expectation_type
-          case count_expectation_type
-          when :<= then ' at most'
-          when :>= then ' at least'
-          when :<=> then ' between'
-          else ''
-          end
-        end
-
-        def human_readable_count(count)
-          case count
-          when Range then " #{count.first} and #{count.last} times"
-          when nil then ''
-          when 1 then ' once'
-          when 2 then ' twice'
-          else " #{count} times"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/cover.rb

@@ -1,24 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `cover`.
-      # Not intended to be instantiated directly.
-      class Cover < BaseMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        def matches?(range)
-          @actual = range
-          @expected.all? { |e| range.cover?(e) }
-        end
-
-        def does_not_match?(range)
-          @actual = range
-          expected.none? { |e| range.cover?(e) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/eq.rb

@@ -1,40 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `eq`.
-      # Not intended to be instantiated directly.
-      class Eq < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "\nexpected: #{expected_formatted}\n     got: #{actual_formatted}\n\n(compared using ==)\n"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "\nexpected: value != #{expected_formatted}\n     got: #{actual_formatted}\n\n(compared using ==)\n"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "eq #{expected_formatted}"
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          true
-        end
-
-      private
-
-        def match(expected, actual)
-          actual == expected
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/eql.rb

@@ -1,34 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `eql`.
-      # Not intended to be instantiated directly.
-      class Eql < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          "\nexpected: #{expected_formatted}\n     got: #{actual_formatted}\n\n(compared using eql?)\n"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "\nexpected: value != #{expected_formatted}\n     got: #{actual_formatted}\n\n(compared using eql?)\n"
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          true
-        end
-
-      private
-
-        def match(expected, actual)
-          actual.eql? expected
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/equal.rb

@@ -1,81 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `equal`.
-      # Not intended to be instantiated directly.
-      class Equal < BaseMatcher
-        # @api private
-        # @return [String]
-        def failure_message
-          if expected_is_a_literal_singleton?
-            simple_failure_message
-          else
-            detailed_failure_message
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          <<-MESSAGE
-
-expected not #{inspect_object(actual)}
-         got #{inspect_object(expected)}
-
-Compared using equal?, which compares object identity.
-
-MESSAGE
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          !expected_is_a_literal_singleton?
-        end
-
-      private
-
-        def match(expected, actual)
-          actual.equal? expected
-        end
-
-        LITERAL_SINGLETONS = [true, false, nil]
-
-        def expected_is_a_literal_singleton?
-          LITERAL_SINGLETONS.include?(expected)
-        end
-
-        def actual_inspected
-          if LITERAL_SINGLETONS.include?(actual)
-            actual_formatted
-          else
-            inspect_object(actual)
-          end
-        end
-
-        def simple_failure_message
-          "\nexpected #{expected_formatted}\n     got #{actual_inspected}\n"
-        end
-
-        def detailed_failure_message
-          <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`expect(actual).to eq(expected)` if you don't care about
-object identity in this example.
-
-MESSAGE
-        end
-
-        def inspect_object(o)
-          "#<#{o.class}:#{o.object_id}> => #{RSpec::Support::ObjectFormatter.format(o)}"
-        end
-      end
-    end
-  end
-end