xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/matchers/built_in/have_attributes.rb

@@ -0,0 +1,114 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `have_attributes`.
+      # Not intended to be instantiated directly.
+      class HaveAttributes < BaseMatcher
+        # @private
+        attr_reader :respond_to_failed
+
+        def initialize(expected)
+          @expected = expected
+          @values = {}
+          @respond_to_failed = false
+          @negated = false
+        end
+
+        # @private
+        def actual
+          @values
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          @actual = actual
+          @negated = false
+          return false unless respond_to_attributes?
+          perform_match(:all?)
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          @actual = actual
+          @negated = true
+          return false unless respond_to_attributes?
+          perform_match(:none?)
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          described_items = surface_descriptions_in(expected)
+          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !@respond_to_failed && !@negated
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          respond_to_failure_message_or do
+            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
+          end
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
+        end
+
+      private
+
+        def cache_all_values
+          @values = {}
+          expected.each do |attribute_key, _attribute_value|
+            actual_value = @actual.__send__(attribute_key)
+            @values[attribute_key] = actual_value
+          end
+        end
+
+        def perform_match(predicate)
+          cache_all_values
+          expected.__send__(predicate) do |attribute_key, attribute_value|
+            actual_has_attribute?(attribute_key, attribute_value)
+          end
+        end
+
+        def actual_has_attribute?(attribute_key, attribute_value)
+          values_match?(attribute_value, @values.fetch(attribute_key))
+        end
+
+        def respond_to_attributes?
+          matches = respond_to_matcher.matches?(@actual)
+          @respond_to_failed = !matches
+          matches
+        end
+
+        def respond_to_matcher
+          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments
+        end
+
+        def respond_to_failure_message_or
+          if respond_to_failed
+            respond_to_matcher.failure_message
+          else
+            improve_hash_formatting(yield)
+          end
+        end
+
+        def formatted_values
+          values = RSpec::Support::ObjectFormatter.format(@values)
+          improve_hash_formatting(values)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/matchers/built_in/include.rb

@@ -0,0 +1,149 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `include`.
+      # Not intended to be instantiated directly.
+      class Include < BaseMatcher
+        # @private
+        attr_reader :expecteds
+
+        def initialize(*expecteds)
+          @expecteds = expecteds
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          actual = actual.to_hash if convert_to_hash?(actual)
+          perform_match(actual) { |v| v }
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          actual = actual.to_hash if convert_to_hash?(actual)
+          perform_match(actual) { |v| !v }
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          improve_hash_formatting("include#{readable_list_of(expecteds)}")
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          format_failure_message("to") { super }
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          format_failure_message("not to") { super }
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !diff_would_wrongly_highlight_matched_item?
+        end
+
+        # @api private
+        # @return [Array, Hash]
+        def expected
+          if expecteds.one? && Hash === expecteds.first
+            expecteds.first
+          else
+            expecteds
+          end
+        end
+
+      private
+
+        def format_failure_message(preposition)
+          if actual.respond_to?(:include?)
+            improve_hash_formatting("expected #{description_of @actual} #{preposition} include#{readable_list_of @divergent_items}")
+          else
+            improve_hash_formatting(yield) + ", but it does not respond to `include?`"
+          end
+        end
+
+        def readable_list_of(items)
+          described_items = surface_descriptions_in(items)
+          if described_items.all? { |item| item.is_a?(Hash) }
+            " #{described_items.inject(:merge).inspect}"
+          else
+            EnglishPhrasing.list(described_items)
+          end
+        end
+
+        def perform_match(actual, &block)
+          @actual = actual
+          @divergent_items = excluded_from_actual(&block)
+          actual.respond_to?(:include?) && @divergent_items.empty?
+        end
+
+        def excluded_from_actual
+          return [] unless @actual.respond_to?(:include?)
+
+          expecteds.inject([]) do |memo, expected_item|
+            if comparing_hash_to_a_subset?(expected_item)
+              expected_item.each do |(key, value)|
+                memo << { key => value } unless yield actual_hash_includes?(key, value)
+              end
+            elsif comparing_hash_keys?(expected_item)
+              memo << expected_item unless yield actual_hash_has_key?(expected_item)
+            else
+              memo << expected_item unless yield actual_collection_includes?(expected_item)
+            end
+            memo
+          end
+        end
+
+        def comparing_hash_to_a_subset?(expected_item)
+          actual.is_a?(Hash) && expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_includes?(expected_key, expected_value)
+          actual_value = actual.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+
+        def comparing_hash_keys?(expected_item)
+          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_has_key?(expected_key)
+          # We check `key?` first for perf:
+          # `key?` is O(1), but `any?` is O(N).
+          actual.key?(expected_key) ||
+          actual.keys.any? { |key| values_match?(expected_key, key) }
+        end
+
+        def actual_collection_includes?(expected_item)
+          return true if actual.include?(expected_item)
+
+          # String lacks an `any?` method...
+          return false unless actual.respond_to?(:any?)
+
+          actual.any? { |value| values_match?(expected_item, value) }
+        end
+
+        def diff_would_wrongly_highlight_matched_item?
+          return false unless actual.is_a?(String) && expected.is_a?(Array)
+
+          lines = actual.split("\n")
+          expected.any? do |str|
+            actual.include?(str) && lines.none? { |line| line == str }
+          end
+        end
+
+        def convert_to_hash?(obj)
+          !(::Hash === obj) && obj.respond_to?(:to_hash)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/matchers/built_in/match.rb

@@ -0,0 +1,106 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `match`.
+      # Not intended to be instantiated directly.
+      class Match < BaseMatcher
+        def initialize(expected)
+          super(expected)
+
+          @expected_captures = nil
+        end
+        # @api private
+        # @return [String]
+        def description
+          if @expected_captures && @expected.match(actual)
+            "match #{surface_descriptions_in(expected).inspect} with captures #{surface_descriptions_in(@expected_captures).inspect}"
+          else
+            "match #{surface_descriptions_in(expected).inspect}"
+          end
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+        # Used to specify the captures we match against
+        # @return [self]
+        def with_captures(*captures)
+          @expected_captures = captures
+          self
+        end
+
+      private
+
+        def match(expected, actual)
+          return match_captures(expected, actual) if @expected_captures
+          return true if values_match?(expected, actual)
+          return false unless can_safely_call_match?(expected, actual)
+          actual.match(expected)
+        end
+
+        def can_safely_call_match?(expected, actual)
+          return false unless actual.respond_to?(:match)
+
+          !(RSpec::Matchers.is_a_matcher?(expected) &&
+            (String === actual || Regexp === actual))
+        end
+
+        def match_captures(expected, actual)
+          match = actual.match(expected)
+          if match
+            match = ReliableMatchData.new(match)
+            if match.names.empty?
+              values_match?(@expected_captures, match.captures)
+            else
+              expected_matcher = @expected_captures.last
+              values_match?(expected_matcher, Hash[match.names.zip(match.captures)]) ||
+                values_match?(expected_matcher, Hash[match.names.map(&:to_sym).zip(match.captures)]) ||
+                values_match?(@expected_captures, match.captures)
+            end
+          else
+            false
+          end
+        end
+      end
+
+      # @api private
+      # Used to wrap match data and make it reliable for 1.8.7
+      class ReliableMatchData
+        def initialize(match_data)
+          @match_data = match_data
+        end
+
+        if RUBY_VERSION == "1.8.7"
+          # @api private
+          # Returns match data names for named captures
+          # @return Array
+          def names
+            []
+          end
+        else
+          # @api private
+          # Returns match data names for named captures
+          # @return Array
+          def names
+            match_data.names
+          end
+        end
+
+        # @api private
+        # returns an array of captures from the match data
+        # @return Array
+        def captures
+          match_data.captures
+        end
+
+      protected
+
+        attr_reader :match_data
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/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/ruby/2.5.0/gems/rspec-expectations-3.8.1/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