ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/assertions.rb

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/enumerable"
-
-module ActiveSupport
-  module Testing
-    module Assertions
-      UNTRACKED = Object.new # :nodoc:
-
-      # Asserts that an expression is not truthy. Passes if <tt>object</tt> is
-      # +nil+ or +false+. "Truthy" means "considered true in a conditional"
-      # like <tt>if foo</tt>.
-      #
-      #   assert_not nil    # => true
-      #   assert_not false  # => true
-      #   assert_not 'foo'  # => Expected "foo" to be nil or false
-      #
-      # An error message can be specified.
-      #
-      #   assert_not foo, 'foo should be false'
-      def assert_not(object, message = nil)
-        message ||= "Expected #{mu_pp(object)} to be nil or false"
-        assert !object, message
-      end
-
-      # Assertion that the block should not raise an exception.
-      #
-      # Passes if evaluated code in the yielded block raises no exception.
-      #
-      #   assert_nothing_raised do
-      #     perform_service(param: 'no_exception')
-      #   end
-      def assert_nothing_raised
-        yield
-      rescue => error
-        raise Minitest::UnexpectedError.new(error)
-      end
-
-      # Test numeric difference between the return value of an expression as a
-      # result of what is evaluated in the yielded block.
-      #
-      #   assert_difference 'Article.count' do
-      #     post :create, params: { article: {...} }
-      #   end
-      #
-      # An arbitrary expression is passed in and evaluated.
-      #
-      #   assert_difference 'Article.last.comments(:reload).size' do
-      #     post :create, params: { comment: {...} }
-      #   end
-      #
-      # An arbitrary positive or negative difference can be specified.
-      # The default is <tt>1</tt>.
-      #
-      #   assert_difference 'Article.count', -1 do
-      #     post :delete, params: { id: ... }
-      #   end
-      #
-      # An array of expressions can also be passed in and evaluated.
-      #
-      #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
-      #     post :create, params: { article: {...} }
-      #   end
-      #
-      # A hash of expressions/numeric differences can also be passed in and evaluated.
-      #
-      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
-      #     post :create, params: { article: {...} }
-      #   end
-      #
-      # A lambda or a list of lambdas can be passed in and evaluated:
-      #
-      #   assert_difference ->{ Article.count }, 2 do
-      #     post :create, params: { article: {...} }
-      #   end
-      #
-      #   assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
-      #     post :create, params: { article: {...} }
-      #   end
-      #
-      # An error message can be specified.
-      #
-      #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
-      #     post :delete, params: { id: ... }
-      #   end
-      def assert_difference(expression, *args, &block)
-        expressions =
-          if expression.is_a?(Hash)
-            message = args[0]
-            expression
-          else
-            difference = args[0] || 1
-            message = args[1]
-            Array(expression).index_with(difference)
-          end
-
-        exps = expressions.keys.map { |e|
-          e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
-        }
-        before = exps.map(&:call)
-
-        retval = assert_nothing_raised(&block)
-
-        expressions.zip(exps, before) do |(code, diff), exp, before_value|
-          error  = "#{code.inspect} didn't change by #{diff}"
-          error  = "#{message}.\n#{error}" if message
-          assert_equal(before_value + diff, exp.call, error)
-        end
-
-        retval
-      end
-
-      # Assertion that the numeric result of evaluating an expression is not
-      # changed before and after invoking the passed in block.
-      #
-      #   assert_no_difference 'Article.count' do
-      #     post :create, params: { article: invalid_attributes }
-      #   end
-      #
-      # A lambda can be passed in and evaluated.
-      #
-      #   assert_no_difference -> { Article.count } do
-      #     post :create, params: { article: invalid_attributes }
-      #   end
-      #
-      # An error message can be specified.
-      #
-      #   assert_no_difference 'Article.count', 'An Article should not be created' do
-      #     post :create, params: { article: invalid_attributes }
-      #   end
-      #
-      # An array of expressions can also be passed in and evaluated.
-      #
-      #   assert_no_difference [ 'Article.count', -> { Post.count } ] do
-      #     post :create, params: { article: invalid_attributes }
-      #   end
-      def assert_no_difference(expression, message = nil, &block)
-        assert_difference expression, 0, message, &block
-      end
-
-      # Assertion that the result of evaluating an expression is changed before
-      # and after invoking the passed in block.
-      #
-      #   assert_changes 'Status.all_good?' do
-      #     post :create, params: { status: { ok: false } }
-      #   end
-      #
-      # You can pass the block as a string to be evaluated in the context of
-      # the block. A lambda can be passed for the block as well.
-      #
-      #   assert_changes -> { Status.all_good? } do
-      #     post :create, params: { status: { ok: false } }
-      #   end
-      #
-      # The assertion is useful to test side effects. The passed block can be
-      # anything that can be converted to string with #to_s.
-      #
-      #   assert_changes :@object do
-      #     @object = 42
-      #   end
-      #
-      # The keyword arguments :from and :to can be given to specify the
-      # expected initial value and the expected value after the block was
-      # executed.
-      #
-      #   assert_changes :@object, from: nil, to: :foo do
-      #     @object = :foo
-      #   end
-      #
-      # An error message can be specified.
-      #
-      #   assert_changes -> { Status.all_good? }, 'Expected the status to be bad' do
-      #     post :create, params: { status: { incident: true } }
-      #   end
-      def assert_changes(expression, message = nil, from: UNTRACKED, to: UNTRACKED, &block)
-        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
-
-        before = exp.call
-        retval = assert_nothing_raised(&block)
-
-        unless from == UNTRACKED
-          error = "Expected change from #{from.inspect}"
-          error = "#{message}.\n#{error}" if message
-          assert from === before, error
-        end
-
-        after = exp.call
-
-        error = "#{expression.inspect} didn't change"
-        error = "#{error}. It was already #{to}" if before == to
-        error = "#{message}.\n#{error}" if message
-        assert_not_equal before, after, error
-
-        unless to == UNTRACKED
-          error = "Expected change to #{to}\n"
-          error = "#{message}.\n#{error}" if message
-          assert to === after, error
-        end
-
-        retval
-      end
-
-      # Assertion that the result of evaluating an expression is not changed before
-      # and after invoking the passed in block.
-      #
-      #   assert_no_changes 'Status.all_good?' do
-      #     post :create, params: { status: { ok: true } }
-      #   end
-      #
-      # An error message can be specified.
-      #
-      #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
-      #     post :create, params: { status: { ok: false } }
-      #   end
-      def assert_no_changes(expression, message = nil, &block)
-        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
-
-        before = exp.call
-        retval = assert_nothing_raised(&block)
-        after = exp.call
-
-        error = "#{expression.inspect} changed"
-        error = "#{message}.\n#{error}" if message
-
-        if before.nil?
-          assert_nil after, error
-        else
-          assert_equal before, after, error
-        end
-
-        retval
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/autorun.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-gem "minitest"
-
-require "minitest"
-
-Minitest.autorun

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/constant_lookup.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/inflector"
-
-module ActiveSupport
-  module Testing
-    # Resolves a constant from a minitest spec name.
-    #
-    # Given the following spec-style test:
-    #
-    #   describe WidgetsController, :index do
-    #     describe "authenticated user" do
-    #       describe "returns widgets" do
-    #         it "has a controller that exists" do
-    #           assert_kind_of WidgetsController, @controller
-    #         end
-    #       end
-    #     end
-    #   end
-    #
-    # The test will have the following name:
-    #
-    #   "WidgetsController::index::authenticated user::returns widgets"
-    #
-    # The constant WidgetsController can be resolved from the name.
-    # The following code will resolve the constant:
-    #
-    #   controller = determine_constant_from_test_name(name) do |constant|
-    #     Class === constant && constant < ::ActionController::Metal
-    #   end
-    module ConstantLookup
-      extend ::ActiveSupport::Concern
-
-      module ClassMethods  # :nodoc:
-        def determine_constant_from_test_name(test_name)
-          names = test_name.split "::"
-          while names.size > 0 do
-            names.last.sub!(/Test$/, "")
-            begin
-              constant = names.join("::").safe_constantize
-              break(constant) if yield(constant)
-            ensure
-              names.pop
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/declarative.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module Testing
-    module Declarative
-      unless defined?(Spec)
-        # Helper to define a test method using a String. Under the hood, it replaces
-        # spaces with underscores and defines the test method.
-        #
-        #   test "verify something" do
-        #     ...
-        #   end
-        def test(name, &block)
-          test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
-          defined = method_defined? test_name
-          raise "#{test_name} is already defined in #{self}" if defined
-          if block_given?
-            define_method(test_name, &block)
-          else
-            define_method(test_name) do
-              flunk "No implementation provided for #{name}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/deprecation.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/deprecation"
-
-module ActiveSupport
-  module Testing
-    module Deprecation #:nodoc:
-      def assert_deprecated(match = nil, deprecator = nil, &block)
-        result, warnings = collect_deprecations(deprecator, &block)
-        assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
-        if match
-          match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
-          assert warnings.any? { |w| match.match?(w) }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
-        end
-        result
-      end
-
-      def assert_not_deprecated(deprecator = nil, &block)
-        result, deprecations = collect_deprecations(deprecator, &block)
-        assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
-        result
-      end
-
-      def collect_deprecations(deprecator = nil)
-        deprecator ||= ActiveSupport::Deprecation
-        old_behavior = deprecator.behavior
-        deprecations = []
-        deprecator.behavior = Proc.new do |message, callstack|
-          deprecations << message
-        end
-        result = yield
-        [result, deprecations]
-      ensure
-        deprecator.behavior = old_behavior
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/file_fixtures.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-module ActiveSupport
-  module Testing
-    # Adds simple access to sample files called file fixtures.
-    # File fixtures are normal files stored in
-    # <tt>ActiveSupport::TestCase.file_fixture_path</tt>.
-    #
-    # File fixtures are represented as +Pathname+ objects.
-    # This makes it easy to extract specific information:
-    #
-    #   file_fixture("example.txt").read # get the file's content
-    #   file_fixture("example.mp3").size # get the file size
-    module FileFixtures
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :file_fixture_path, instance_writer: false
-      end
-
-      # Returns a +Pathname+ to the fixture file named +fixture_name+.
-      #
-      # Raises +ArgumentError+ if +fixture_name+ can't be found.
-      def file_fixture(fixture_name)
-        path = Pathname.new(File.join(file_fixture_path, fixture_name))
-
-        if path.exist?
-          path
-        else
-          msg = "the directory '%s' does not contain a file named '%s'"
-          raise ArgumentError, msg % [file_fixture_path, fixture_name]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/isolation.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module Testing
-    module Isolation
-      require "thread"
-
-      def self.included(klass) #:nodoc:
-        klass.class_eval do
-          parallelize_me!
-        end
-      end
-
-      def self.forking_env?
-        !ENV["NO_FORK"] && Process.respond_to?(:fork)
-      end
-
-      def run
-        serialized = run_in_isolation do
-          super
-        end
-
-        Marshal.load(serialized)
-      end
-
-      module Forking
-        def run_in_isolation(&blk)
-          read, write = IO.pipe
-          read.binmode
-          write.binmode
-
-          pid = fork do
-            read.close
-            yield
-            begin
-              if error?
-                failures.map! { |e|
-                  begin
-                    Marshal.dump e
-                    e
-                  rescue TypeError
-                    ex = Exception.new e.message
-                    ex.set_backtrace e.backtrace
-                    Minitest::UnexpectedError.new ex
-                  end
-                }
-              end
-              test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
-              result = Marshal.dump(test_result)
-            end
-
-            write.puts [result].pack("m")
-            exit!
-          end
-
-          write.close
-          result = read.read
-          Process.wait2(pid)
-          result.unpack1("m")
-        end
-      end
-
-      module Subprocess
-        ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
-
-        # Crazy H4X to get this working in windows / jruby with
-        # no forking.
-        def run_in_isolation(&blk)
-          require "tempfile"
-
-          if ENV["ISOLATION_TEST"]
-            yield
-            test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
-            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump(test_result)].pack("m")
-            end
-            exit!
-          else
-            Tempfile.open("isolation") do |tmpfile|
-              env = {
-                "ISOLATION_TEST" => self.class.name,
-                "ISOLATION_OUTPUT" => tmpfile.path
-              }
-
-              test_opts = "-n#{self.class.name}##{name}"
-
-              load_path_args = []
-              $-I.each do |p|
-                load_path_args << "-I"
-                load_path_args << File.expand_path(p)
-              end
-
-              child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
-
-              begin
-                Process.wait(child.pid)
-              rescue Errno::ECHILD # The child process may exit before we wait
-                nil
-              end
-
-              return tmpfile.read.unpack1("m")
-            end
-          end
-        end
-      end
-
-      include forking_env? ? Forking : Subprocess
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/method_call_assertions.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "minitest/mock"
-
-module ActiveSupport
-  module Testing
-    module MethodCallAssertions # :nodoc:
-      private
-        def assert_called(object, method_name, message = nil, times: 1, returns: nil)
-          times_called = 0
-
-          object.stub(method_name, proc { times_called += 1; returns }) { yield }
-
-          error = "Expected #{method_name} to be called #{times} times, " \
-            "but was called #{times_called} times"
-          error = "#{message}.\n#{error}" if message
-          assert_equal times, times_called, error
-        end
-
-        def assert_called_with(object, method_name, args, returns: nil)
-          mock = Minitest::Mock.new
-
-          if args.all? { |arg| arg.is_a?(Array) }
-            args.each { |arg| mock.expect(:call, returns, arg) }
-          else
-            mock.expect(:call, returns, args)
-          end
-
-          object.stub(method_name, mock) { yield }
-
-          mock.verify
-        end
-
-        def assert_not_called(object, method_name, message = nil, &block)
-          assert_called(object, method_name, message, times: 0, &block)
-        end
-
-        def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
-          times_called = 0
-          klass.define_method("stubbed_#{method_name}") do |*|
-            times_called += 1
-
-            returns
-          end
-
-          klass.alias_method "original_#{method_name}", method_name
-          klass.alias_method method_name, "stubbed_#{method_name}"
-
-          yield
-
-          error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
-          error = "#{message}.\n#{error}" if message
-
-          assert_equal times, times_called, error
-        ensure
-          klass.alias_method method_name, "original_#{method_name}"
-          klass.undef_method "original_#{method_name}"
-          klass.undef_method "stubbed_#{method_name}"
-        end
-
-        def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
-          assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
-        end
-
-        def stub_any_instance(klass, instance: klass.new)
-          klass.stub(:new, instance) { yield instance }
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/testing/parallelization/server.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "drb"
-require "drb/unix" unless Gem.win_platform?
-
-module ActiveSupport
-  module Testing
-    class Parallelization # :nodoc:
-      class Server
-        include DRb::DRbUndumped
-
-        def initialize
-          @queue = Queue.new
-          @active_workers = Concurrent::Map.new
-          @in_flight = Concurrent::Map.new
-        end
-
-        def record(reporter, result)
-          raise DRb::DRbConnError if result.is_a?(DRb::DRbUnknown)
-
-          @in_flight.delete([result.klass, result.name])
-
-          reporter.synchronize do
-            reporter.record(result)
-          end
-        end
-
-        def <<(o)
-          o[2] = DRbObject.new(o[2]) if o
-          @queue << o
-        end
-
-        def pop
-          if test = @queue.pop
-            @in_flight[[test[0].to_s, test[1]]] = test
-            test
-          end
-        end
-
-        def start_worker(worker_id)
-          @active_workers[worker_id] = true
-        end
-
-        def stop_worker(worker_id)
-          @active_workers.delete(worker_id)
-        end
-
-        def active_workers?
-          @active_workers.size > 0
-        end
-
-        def shutdown
-          # Wait for initial queue to drain
-          while @queue.length != 0
-            sleep 0.1
-          end
-
-          @queue.close
-
-          # Wait until all workers have finished
-          while active_workers?
-            sleep 0.1
-          end
-
-          @in_flight.values.each do |(klass, name, reporter)|
-            result = Minitest::Result.from(klass.new(name))
-            error = RuntimeError.new("result not reported")
-            error.set_backtrace([""])
-            result.failures << Minitest::UnexpectedError.new(error)
-            reporter.synchronize do
-              reporter.record(result)
-            end
-          end
-        end
-      end
-    end
-  end
-end