xaiml 0.1.3 → 0.1.4

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/expectations/handler.rb

@@ -1,170 +0,0 @@
-module RSpec
-  module Expectations
-    # @private
-    module ExpectationHelper
-      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
-
-      # Returns an RSpec-3+ compatible matcher, wrapping a legacy one
-      # in an adapter if necessary.
-      #
-      # @private
-      def self.modern_matcher_from(matcher)
-        LegacyMatcherAdapter::RSpec2.wrap(matcher) ||
-        LegacyMatcherAdapter::RSpec1.wrap(matcher) || matcher
-      end
-
-      def self.with_matcher(handler, matcher, message)
-        check_message(message)
-        matcher = modern_matcher_from(matcher)
-        yield matcher
-      ensure
-        ::RSpec::Matchers.last_expectation_handler = handler
-        ::RSpec::Matchers.last_matcher = matcher
-      end
-
-      def self.handle_failure(matcher, message, failure_message_method)
-        message = message.call if message.respond_to?(:call)
-        message ||= matcher.__send__(failure_message_method)
-
-        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
-
-    # @private
-    class PositiveExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        ExpectationHelper.with_matcher(self, initial_matcher, message) do |matcher|
-          return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) unless initial_matcher
-          matcher.matches?(actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message)
-        end
-      end
-
-      def self.verb
-        "should"
-      end
-
-      def self.should_method
-        :should
-      end
-
-      def self.opposite_should_method
-        :should_not
-      end
-    end
-
-    # @private
-    class NegativeExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        ExpectationHelper.with_matcher(self, initial_matcher, message) do |matcher|
-          return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) unless initial_matcher
-          does_not_match?(matcher, actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message_when_negated)
-        end
-      end
-
-      def self.does_not_match?(matcher, actual, &block)
-        if matcher.respond_to?(:does_not_match?)
-          matcher.does_not_match?(actual, &block)
-        else
-          !matcher.matches?(actual, &block)
-        end
-      end
-
-      def self.verb
-        "should not"
-      end
-
-      def self.should_method
-        :should_not
-      end
-
-      def self.opposite_should_method
-        :should
-      end
-    end
-
-    # Wraps a matcher written against one of the legacy protocols in
-    # order to present the current protocol.
-    #
-    # @private
-    class LegacyMatcherAdapter < Matchers::MatcherDelegator
-      def initialize(matcher)
-        super
-        ::RSpec.warn_deprecation(<<-EOS.gsub(/^\s+\|/, ''), :type => "legacy_matcher")
-          |#{matcher.class.name || matcher.inspect} implements a legacy RSpec matcher
-          |protocol. For the current protocol you should expose the failure messages
-          |via the `failure_message` and `failure_message_when_negated` methods.
-          |(Used from #{CallerFilter.first_non_rspec_line})
-        EOS
-      end
-
-      def self.wrap(matcher)
-        new(matcher) if interface_matches?(matcher)
-      end
-
-      # Starting in RSpec 1.2 (and continuing through all 2.x releases),
-      # the failure message protocol was:
-      #   * `failure_message_for_should`
-      #   * `failure_message_for_should_not`
-      # @private
-      class RSpec2 < self
-        def failure_message
-          base_matcher.failure_message_for_should
-        end
-
-        def failure_message_when_negated
-          base_matcher.failure_message_for_should_not
-        end
-
-        def self.interface_matches?(matcher)
-          (
-            !matcher.respond_to?(:failure_message) &&
-            matcher.respond_to?(:failure_message_for_should)
-          ) || (
-            !matcher.respond_to?(:failure_message_when_negated) &&
-            matcher.respond_to?(:failure_message_for_should_not)
-          )
-        end
-      end
-
-      # Before RSpec 1.2, the failure message protocol was:
-      #   * `failure_message`
-      #   * `negative_failure_message`
-      # @private
-      class RSpec1 < self
-        def failure_message
-          base_matcher.failure_message
-        end
-
-        def failure_message_when_negated
-          base_matcher.negative_failure_message
-        end
-
-        # Note: `failure_message` is part of the RSpec 3 protocol
-        # (paired with `failure_message_when_negated`), so we don't check
-        # for `failure_message` here.
-        def self.interface_matches?(matcher)
-          !matcher.respond_to?(:failure_message_when_negated) &&
-          matcher.respond_to?(:negative_failure_message)
-        end
-      end
-    end
-
-    # RSpec 3.0 was released with the class name misspelled. For SemVer compatibility,
-    # we will provide this misspelled alias until 4.0.
-    # @deprecated Use LegacyMatcherAdapter instead.
-    # @private
-    LegacyMacherAdapter = LegacyMatcherAdapter
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/expectations/minitest_integration.rb

@@ -1,58 +0,0 @@
-require 'rspec/expectations'
-
-Minitest::Test.class_eval do
-  include ::RSpec::Matchers
-
-  # This `expect` will only be called if the user is using Minitest < 5.6
-  # or if they are _not_ using Minitest::Spec on 5.6+. Minitest::Spec on 5.6+
-  # defines its own `expect` and will have the assertions incremented via our
-  # definitions of `to`/`not_to`/`to_not` below.
-  def expect(*a, &b)
-    self.assertions += 1
-    super
-  end
-
-  # Convert a `MultipleExpectationsNotMetError` to a `Minitest::Assertion` error so
-  # it gets counted in minitest's summary stats as a failure rather than an error.
-  # It would be nice to make `MultipleExpectationsNotMetError` subclass
-  # `Minitest::Assertion`, but Minitest's implementation does not treat subclasses
-  # the same, so this is the best we can do.
-  def aggregate_failures(*args, &block)
-    super
-  rescue RSpec::Expectations::MultipleExpectationsNotMetError => e
-    assertion_failed = Minitest::Assertion.new(e.message)
-    assertion_failed.set_backtrace e.backtrace
-    raise assertion_failed
-  end
-end
-
-# Older versions of Minitest (e.g. before 5.6) do not define
-# `Minitest::Expectation`.
-if defined?(::Minitest::Expectation)
-  Minitest::Expectation.class_eval do
-    include RSpec::Expectations::ExpectationTarget::InstanceMethods
-
-    def to(*args)
-      ctx.assertions += 1
-      super
-    end
-
-    def not_to(*args)
-      ctx.assertions += 1
-      super
-    end
-
-    def to_not(*args)
-      ctx.assertions += 1
-      super
-    end
-  end
-end
-
-module RSpec
-  module Expectations
-    remove_const :ExpectationNotMetError
-    # Exception raised when an expectation fails.
-    const_set :ExpectationNotMetError, ::Minitest::Assertion
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/expectations/syntax.rb

@@ -1,132 +0,0 @@
-module RSpec
-  module Expectations
-    # @api private
-    # Provides methods for enabling and disabling the available
-    # syntaxes provided by rspec-expectations.
-    module Syntax
-      module_function
-
-      # @api private
-      # Determines where we add `should` and `should_not`.
-      def default_should_host
-        @default_should_host ||= ::Object.ancestors.last
-      end
-
-      # @api private
-      # Instructs rspec-expectations to warn on first usage of `should` or `should_not`.
-      # Enabled by default. This is largely here to facilitate testing.
-      def warn_about_should!
-        @warn_about_should = true
-      end
-
-      # @api private
-      # Generates a deprecation warning for the given method if no warning
-      # has already been issued.
-      def warn_about_should_unless_configured(method_name)
-        return unless @warn_about_should
-
-        RSpec.deprecate(
-          "Using `#{method_name}` from rspec-expectations' old `:should` syntax without explicitly enabling the syntax",
-          :replacement => "the new `:expect` syntax or explicitly enable `:should` with `config.expect_with(:rspec) { |c| c.syntax = :should }`"
-        )
-
-        @warn_about_should = false
-      end
-
-      # @api private
-      # Enables the `should` syntax.
-      def enable_should(syntax_host=default_should_host)
-        @warn_about_should = false if syntax_host == default_should_host
-        return if should_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          def should(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(::Kernel.__method__)
-            ::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
-          end
-
-          def should_not(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(::Kernel.__method__)
-            ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
-          end
-        end
-      end
-
-      # @api private
-      # Disables the `should` syntax.
-      def disable_should(syntax_host=default_should_host)
-        return unless should_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          undef should
-          undef should_not
-        end
-      end
-
-      # @api private
-      # Enables the `expect` syntax.
-      def enable_expect(syntax_host=::RSpec::Matchers)
-        return if expect_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          def expect(value=::RSpec::Expectations::ExpectationTarget::UndefinedValue, &block)
-            ::RSpec::Expectations::ExpectationTarget.for(value, block)
-          end
-        end
-      end
-
-      # @api private
-      # Disables the `expect` syntax.
-      def disable_expect(syntax_host=::RSpec::Matchers)
-        return unless expect_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          undef expect
-        end
-      end
-
-      # @api private
-      # Indicates whether or not the `should` syntax is enabled.
-      def should_enabled?(syntax_host=default_should_host)
-        syntax_host.method_defined?(:should)
-      end
-
-      # @api private
-      # Indicates whether or not the `expect` syntax is enabled.
-      def expect_enabled?(syntax_host=::RSpec::Matchers)
-        syntax_host.method_defined?(:expect)
-      end
-    end
-  end
-end
-
-if defined?(BasicObject)
-  # The legacy `:should` syntax adds the following methods directly to
-  # `BasicObject` so that they are available off of any object. Note, however,
-  # that this syntax does not always play nice with delegate/proxy objects.
-  # We recommend you use the non-monkeypatching `:expect` syntax instead.
-  class BasicObject
-    # @method should(matcher, message)
-    # Passes if `matcher` returns true.  Available on every `Object`.
-    # @example
-    #   actual.should eq expected
-    #   actual.should match /expression/
-    # @param [Matcher]
-    #   matcher
-    # @param [String] message optional message to display when the expectation fails
-    # @return [Boolean] true if the expectation succeeds (else raises)
-    # @note This is only available when you have enabled the `:should` syntax.
-    # @see RSpec::Matchers
-
-    # @method should_not(matcher, message)
-    # Passes if `matcher` returns false.  Available on every `Object`.
-    # @example
-    #   actual.should_not eq expected
-    # @param [Matcher]
-    #   matcher
-    # @param [String] message optional message to display when the expectation fails
-    # @return [Boolean] false if the negative expectation succeeds (else raises)
-    # @note This is only available when you have enabled the `:should` syntax.
-    # @see RSpec::Matchers
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-expectations-3.8.1/lib/rspec/expectations/version.rb

@@ -1,8 +0,0 @@
-module RSpec
-  module Expectations
-    # @private
-    module Version
-      STRING = '3.8.1'
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-require 'rspec/support'
-RSpec::Support.require_rspec_support "caller_filter"
-RSpec::Support.require_rspec_support "warnings"
-RSpec::Support.require_rspec_support "object_formatter"
-
-require 'rspec/matchers'
-
-RSpec::Support.define_optimized_require_for_rspec(:expectations) { |f| require_relative(f) }
-
-%w[
-  expectation_target
-  configuration
-  fail_with
-  handler
-  version
-].each { |file| RSpec::Support.require_rspec_expectations(file) }
-
-module RSpec
-  # RSpec::Expectations provides a simple, readable API to express
-  # the expected outcomes in a code example. To express an expected
-  # outcome, wrap an object or block in `expect`, call `to` or `to_not`
-  # (aliased as `not_to`) and pass it a matcher object:
-  #
-  #     expect(order.total).to eq(Money.new(5.55, :USD))
-  #     expect(list).to include(user)
-  #     expect(message).not_to match(/foo/)
-  #     expect { do_something }.to raise_error
-  #
-  # The last form (the block form) is needed to match against ruby constructs
-  # that are not objects, but can only be observed when executing a block
-  # of code. This includes raising errors, throwing symbols, yielding,
-  # and changing values.
-  #
-  # When `expect(...).to` is invoked with a matcher, it turns around
-  # and calls `matcher.matches?(<object wrapped by expect>)`.  For example,
-  # in the expression:
-  #
-  #     expect(order.total).to eq(Money.new(5.55, :USD))
-  #
-  # ...`eq(Money.new(5.55, :USD))` returns a matcher object, and it results
-  # in the equivalent of `eq.matches?(order.total)`. If `matches?` returns
-  # `true`, the expectation is met and execution continues. If `false`, then
-  # the spec fails with the message returned by `eq.failure_message`.
-  #
-  # Given the expression:
-  #
-  #     expect(order.entries).not_to include(entry)
-  #
-  # ...the `not_to` method (also available as `to_not`) invokes the equivalent of
-  # `include.matches?(order.entries)`, but it interprets `false` as success, and
-  # `true` as a failure, using the message generated by
-  # `include.failure_message_when_negated`.
-  #
-  # rspec-expectations ships with a standard set of useful matchers, and writing
-  # your own matchers is quite simple.
-  #
-  # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
-  # built-in matchers that ship with rspec-expectations, and how to write your
-  # own custom matchers.
-  module Expectations
-    # Exception raised when an expectation fails.
-    #
-    # @note We subclass Exception so that in a stub implementation if
-    # the user sets an expectation, it can't be caught in their
-    # code by a bare `rescue`.
-    # @api public
-    class ExpectationNotMetError < Exception
-    end
-
-    # Exception raised from `aggregate_failures` when multiple expectations fail.
-    #
-    # @note The constant is defined here but the extensive logic of this class
-    #   is lazily defined when `FailureAggregator` is autoloaded, since we do
-    #   not need to waste time defining that functionality unless
-    #   `aggregate_failures` is used.
-    class MultipleExpectationsNotMetError < ExpectationNotMetError
-    end
-
-    autoload :BlockSnippetExtractor, "rspec/expectations/block_snippet_extractor"
-    autoload :FailureAggregator,     "rspec/expectations/failure_aggregator"
-  end
-end

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

@@ -1,116 +0,0 @@
-module RSpec
-  module Matchers
-    # Decorator that wraps a matcher and overrides `description`
-    # using the provided block in order to support an alias
-    # of a matcher. This is intended for use when composing
-    # matchers, so that you can use an expression like
-    # `include( a_value_within(0.1).of(3) )` rather than
-    # `include( be_within(0.1).of(3) )`, and have the corresponding
-    # description read naturally.
-    #
-    # @api private
-    class AliasedMatcher < MatcherDelegator
-      def initialize(base_matcher, description_block)
-        @description_block = description_block
-        super(base_matcher)
-      end
-
-      # Forward messages on to the wrapped matcher.
-      # Since many matchers provide a fluent interface
-      # (e.g. `a_value_within(0.1).of(3)`), we need to wrap
-      # the returned value if it responds to `description`,
-      # so that our override can be applied when it is eventually
-      # used.
-      def method_missing(*)
-        return_val = super
-        return return_val unless RSpec::Matchers.is_a_matcher?(return_val)
-        self.class.new(return_val, @description_block)
-      end
-
-      # Provides the description of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The description is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def description
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message
-        @description_block.call(super)
-      end
-
-      # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers
-      # are designed to behave identically to the original matcher except
-      # for the description and failure messages. The failure_message_when_negated is different
-      # to reflect the aliased name.
-      #
-      # @api private
-      def failure_message_when_negated
-        @description_block.call(super)
-      end
-    end
-
-    # Decorator used for matchers that have special implementations of
-    # operators like `==` and `===`.
-    # @private
-    class AliasedMatcherWithOperatorSupport < AliasedMatcher
-      # We undef these so that they get delegated via `method_missing`.
-      undef ==
-      undef ===
-    end
-
-    # @private
-    class AliasedNegatedMatcher < AliasedMatcher
-      def matches?(*args, &block)
-        if @base_matcher.respond_to?(:does_not_match?)
-          @base_matcher.does_not_match?(*args, &block)
-        else
-          !super
-        end
-      end
-
-      def does_not_match?(*args, &block)
-        @base_matcher.matches?(*args, &block)
-      end
-
-      def failure_message
-        optimal_failure_message(__method__, :failure_message_when_negated)
-      end
-
-      def failure_message_when_negated
-        optimal_failure_message(__method__, :failure_message)
-      end
-
-    private
-
-      DefaultFailureMessages = BuiltIn::BaseMatcher::DefaultFailureMessages
-
-      # For a matcher that uses the default failure messages, we prefer to
-      # use the override provided by the `description_block`, because it
-      # includes the phrasing that the user has expressed a preference for
-      # by going through the effort of defining a negated matcher.
-      #
-      # However, if the override didn't actually change anything, then we
-      # should return the opposite failure message instead -- the overriden
-      # message is going to be confusing if we return it as-is, as it represents
-      # the non-negated failure message for a negated match (or vice versa).
-      def optimal_failure_message(same, inverted)
-        if DefaultFailureMessages.has_default_failure_messages?(@base_matcher)
-          base_message = @base_matcher.__send__(same)
-          overriden    = @description_block.call(base_message)
-          return overriden if overriden != base_message
-        end
-
-        @base_matcher.__send__(inverted)
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `all`.
-      # Not intended to be instantiated directly.
-      class All < BaseMatcher
-        # @private
-        attr_reader :matcher, :failed_objects
-
-        def initialize(matcher)
-          @matcher = matcher
-          @failed_objects = {}
-        end
-
-        # @private
-        def does_not_match?(_actual)
-          raise NotImplementedError, '`expect().not_to all( matcher )` is not supported.'
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          unless iterable?
-            return "#{improve_hash_formatting(super)}, but was not iterable"
-          end
-
-          all_messages = [improve_hash_formatting(super)]
-          failed_objects.each do |index, matcher_failure_message|
-            all_messages << failure_message_for_item(index, matcher_failure_message)
-          end
-          all_messages.join("\n\n")
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          improve_hash_formatting "all #{description_of matcher}"
-        end
-
-      private
-
-        def match(_expected, _actual)
-          return false unless iterable?
-
-          index_failed_objects
-          failed_objects.empty?
-        end
-
-        def index_failed_objects
-          actual.each_with_index do |actual_item, index|
-            cloned_matcher = matcher.clone
-            matches = cloned_matcher.matches?(actual_item)
-            failed_objects[index] = cloned_matcher.failure_message unless matches
-          end
-        end
-
-        def failure_message_for_item(index, failure_message)
-          failure_message = indent_multiline_message(add_new_line_if_needed(failure_message))
-          indent_multiline_message("object at index #{index} failed to match:#{failure_message}")
-        end
-
-        def add_new_line_if_needed(message)
-          message.start_with?("\n") ? message : "\n#{message}"
-        end
-
-        def indent_multiline_message(message)
-          message = message.sub(/\n+\z/, '')
-          message.lines.map do |line|
-            line =~ /\S/ ? '   ' + line : line
-          end.join
-        end
-
-        def initialize_copy(other)
-          @matcher = @matcher.clone
-          super
-        end
-
-        def iterable?
-          @actual.respond_to?(:each_with_index)
-        end
-      end
-    end
-  end
-end