ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/rails_shim.rb

@@ -0,0 +1,190 @@
+module Shoulda
+  module Matchers
+    # @private
+    module RailsShim
+      class << self
+        def action_pack_version
+          Gem::Version.new(::ActionPack::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_record_version
+          Gem::Version.new(::ActiveRecord::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_model_version
+          Gem::Version.new(::ActiveModel::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_model_lt_7?
+          Gem::Requirement.new('< 7').satisfied_by?(active_model_version)
+        end
+
+        def active_record_gte_8_1?
+          Gem::Requirement.new('>= 8.1').satisfied_by?(active_record_version)
+        end
+
+        def generate_validation_message(
+          record,
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          if record && record.errors.respond_to?(:generate_message)
+            record.errors.generate_message(attribute.to_sym, type, options)
+          else
+            simply_generate_validation_message(
+              attribute,
+              type,
+              model_name,
+              options,
+            )
+          end
+        rescue RangeError
+          simply_generate_validation_message(
+            attribute,
+            type,
+            model_name,
+            options,
+          )
+        end
+
+        def serialized_attributes_for(model)
+          type_serialized_defined = Object.const_defined?('ActiveRecord::Type::Serialized')
+          attribute_types_for(model).
+            inject({}) do |hash, (attribute_name, attribute_type)|
+              if type_serialized_defined && attribute_type.is_a?(::ActiveRecord::Type::Serialized)
+                hash.merge!(attribute_name => attribute_type.coder)
+              else
+                hash
+              end
+            end
+        rescue NotImplementedError
+          {}
+        end
+
+        def attribute_serialization_coder_for(model, attribute_name)
+          serialized_attributes_for(model)[attribute_name.to_s]
+        end
+
+        def verb_for_update
+          :patch
+        end
+
+        def parent_of(mod)
+          if mod.respond_to?(:module_parent)
+            mod.module_parent
+          else
+            mod.parent
+          end
+        end
+
+        def has_secure_password?(record, attribute_name)
+          if secure_password_module
+            attribute_name == :password &&
+              record.class.ancestors.include?(secure_password_module)
+          else
+            record.respond_to?("authenticate_#{attribute_name}")
+          end
+        end
+
+        def digestible_attributes_in(record)
+          record.methods.inject([]) do |array, method_name|
+            match = method_name.to_s.match(
+              /\A(\w+)_(?:confirmation|digest)=\Z/,
+            )
+
+            if match
+              array.concat([match[1].to_sym])
+            else
+              array
+            end
+          end
+        end
+
+        def secure_password_module
+          ::ActiveModel::SecurePassword::InstanceMethodsOnActivation
+        rescue NameError
+          nil
+        end
+
+        def attribute_types_for(model)
+          if model.respond_to?(:attribute_types)
+            model.attribute_types
+          elsif model.respond_to?(:type_for_attribute)
+            model.columns.inject({}) do |hash, column|
+              key = column.name.to_s
+              value = model.type_for_attribute(column.name)
+              hash.merge!(key => value)
+            end
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def attribute_type_for(model, attribute_name)
+          attribute_types_for(model)[attribute_name.to_s]
+        rescue NotImplementedError
+          if model.respond_to?(:type_for_attribute)
+            model.type_for_attribute(attribute_name)
+          else
+            FakeAttributeType.new(model, attribute_name)
+          end
+        end
+
+        def supports_full_attributes_api?(model)
+          defined?(::ActiveModel::Attributes) &&
+            model.respond_to?(:attribute_types)
+        end
+
+        private
+
+        def simply_generate_validation_message(
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          default_translation_keys = [
+            :"activemodel.errors.models.#{model_name}.attributes.#{attribute}
+              .#{type}",
+            :"activemodel.errors.models.#{model_name}.#{type}",
+            :"activemodel.errors.messages.#{type}",
+            :"activerecord.errors.models.#{model_name}.attributes.#{attribute}
+              .#{type}",
+            :"activerecord.errors.models.#{model_name}.#{type}",
+            :"activerecord.errors.messages.#{type}",
+            :"errors.attributes.#{attribute}.#{type}",
+            :"errors.messages.#{type}",
+          ]
+          primary_translation_key = default_translation_keys.shift
+          translate_options =
+            { default: default_translation_keys }.merge!(options)
+          I18n.translate(primary_translation_key, translate_options)
+        end
+
+        # @private
+        class FakeAttributeType
+          def initialize(model, attribute_name)
+            @model = model
+            @attribute_name = attribute_name
+          end
+
+          def coder
+            nil
+          end
+
+          private
+
+          attr_reader :model, :attribute_name
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/routing.rb

@@ -0,0 +1,10 @@
+module Shoulda
+  module Matchers
+    # @private
+    module Routing
+      def route(method, path, port: nil)
+        ActionController::RouteMatcher.new(self, method, path, port:)
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/util/word_wrap.rb

@@ -0,0 +1,211 @@
+module Shoulda
+  module Matchers
+    # @private
+    module WordWrap
+      TERMINAL_WIDTH = 72
+
+      def word_wrap(document, options = {})
+        Document.new(document, **options).wrap
+      end
+    end
+
+    extend WordWrap
+
+    # @private
+    class Document
+      def initialize(document, indent: 0)
+        @document = document
+        @indent = indent
+      end
+
+      def wrap
+        wrapped_paragraphs.map { |lines| lines.join("\n") }.join("\n\n")
+      end
+
+      protected
+
+      attr_reader :document, :indent
+
+      private
+
+      def paragraphs
+        document.split(/\n{2,}/)
+      end
+
+      def wrapped_paragraphs
+        paragraphs.map do |paragraph|
+          Paragraph.new(paragraph, indent:).wrap
+        end
+      end
+    end
+
+    # @private
+    class Text < ::String
+      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/
+
+      def indented?
+        self =~ /\A +/
+      end
+
+      def list_item?
+        self =~ LIST_ITEM_REGEXP
+      end
+
+      def match_as_list_item
+        match(LIST_ITEM_REGEXP)
+      end
+    end
+
+    # @private
+    class Paragraph
+      def initialize(paragraph, indent: 0)
+        @paragraph = Text.new(paragraph)
+        @indent = indent
+      end
+
+      def wrap
+        if paragraph.indented?
+          lines
+        elsif paragraph.list_item?
+          wrap_list_item
+        else
+          wrap_generic_paragraph
+        end
+      end
+
+      protected
+
+      attr_reader :paragraph, :indent
+
+      private
+
+      def wrap_list_item
+        wrap_lines(combine_list_item_lines(lines))
+      end
+
+      def lines
+        paragraph.split("\n").map { |line| Text.new(line) }
+      end
+
+      def combine_list_item_lines(lines)
+        lines.inject([]) do |combined_lines, line|
+          if line.list_item?
+            combined_lines << line
+          else
+            combined_lines.last << " #{line}".squeeze(' ')
+          end
+
+          combined_lines
+        end
+      end
+
+      def wrap_lines(lines)
+        lines.map { |line| Line.new(line, indent:).wrap }
+      end
+
+      def wrap_generic_paragraph
+        Line.new(combine_paragraph_into_one_line, indent:).wrap
+      end
+
+      def combine_paragraph_into_one_line
+        paragraph.gsub(/\n/, ' ')
+      end
+    end
+
+    # @private
+    class Line
+      OFFSETS = { left: -1, right: +1 }.freeze
+
+      def initialize(line, indent: 0)
+        @indent = indent
+        @original_line = @line_to_wrap = Text.new(line)
+        @indentation = ' ' * indent
+        @indentation_read = false
+      end
+
+      def wrap
+        if line_to_wrap.indented?
+          [line_to_wrap]
+        else
+          lines = []
+
+          loop do
+            @previous_line_to_wrap = line_to_wrap
+            new_line = (indentation || '') + line_to_wrap
+            result = wrap_line(new_line)
+            lines << normalize_whitespace(result[:fitted_line])
+
+            unless @indentation_read
+              @indentation = read_indentation
+              @indentation_read = true
+            end
+
+            @line_to_wrap = result[:leftover]
+
+            if line_to_wrap.to_s.empty? || previous_line_to_wrap == line_to_wrap
+              break
+            end
+          end
+
+          lines
+        end
+      end
+
+      protected
+
+      attr_reader :indent, :original_line, :line_to_wrap, :indentation,
+        :previous_line_to_wrap
+
+      private
+
+      def read_indentation
+        initial_indentation = ' ' * indent
+        match = line_to_wrap.match_as_list_item
+
+        if match
+          initial_indentation + (' ' * match[1].length)
+        else
+          initial_indentation
+        end
+      end
+
+      def wrap_line(line)
+        index = nil
+
+        if line.length > Shoulda::Matchers::WordWrap::TERMINAL_WIDTH
+          index = determine_where_to_break_line(line, direction: :left)
+
+          if index == -1
+            index = determine_where_to_break_line(line, direction: :right)
+          end
+        end
+
+        if index.nil? || index == -1
+          fitted_line = line
+          leftover = ''
+        else
+          fitted_line = line[0..index].rstrip
+          leftover = line[index + 1..]
+        end
+
+        { fitted_line:, leftover: }
+      end
+
+      def determine_where_to_break_line(line, args)
+        direction = args.fetch(:direction)
+        index = Shoulda::Matchers::WordWrap::TERMINAL_WIDTH
+        offset = OFFSETS.fetch(direction)
+
+        while line[index] !~ /\s/ && (0...line.length).cover?(index)
+          index += offset
+        end
+
+        index
+      end
+
+      def normalize_whitespace(string)
+        indentation + string.strip.squeeze(' ')
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/util.rb

@@ -0,0 +1,110 @@
+require 'shoulda/matchers/util/word_wrap'
+
+module Shoulda
+  module Matchers
+    # @private
+    module Util
+      MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY = 500
+
+      def self.deconstantize(path)
+        if defined?(ActiveSupport::Inflector) &&
+           ActiveSupport::Inflector.respond_to?(:deconstantize)
+
+          ActiveSupport::Inflector.deconstantize(path)
+        else
+          path.to_s[0...(path.to_s.rindex('::') || 0)]
+        end
+      end
+
+      def self.safe_constantize(camel_cased_word)
+        if defined?(ActiveSupport::Inflector) &&
+           ActiveSupport::Inflector.respond_to?(:safe_constantize)
+
+          ActiveSupport::Inflector.safe_constantize(camel_cased_word)
+        else
+          begin
+            camel_cased_word.constantize
+          rescue NameError
+            nil
+          end
+        end
+      end
+
+      def self.indent(string, width)
+        return if !string
+
+        indentation = ' ' * width
+        string.split(/[\n\r]/).map { |line| indentation + line }.join("\n")
+      end
+
+      def self.a_or_an(next_word)
+        if next_word =~ /\A[aeiou]/i && next_word != 'unique'
+          "an #{next_word}"
+        else
+          "a #{next_word}"
+        end
+      end
+
+      def self.inspect_value(value)
+        case value
+        when Hash
+          inspect_hash(value)
+        when Range
+          inspect_range(value)
+        else
+          inspected_value = value.inspect
+          if inspected_value.length > MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY
+            "‹#{inspected_value[0, MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY]}...›"
+          else
+            "‹#{inspected_value}›"
+          end
+        end
+      end
+
+      def self.inspect_values(values)
+        values.map { |value| inspect_value(value) }
+      end
+
+      def self.inspect_range(range)
+        "#{inspect_value(range.begin)} to #{inspect_value(range.end)}"
+      end
+
+      def self.inspect_hash(hash)
+        String.new('‹{').tap do |output|
+          output << hash.map { |key, value|
+            if key.is_a?(Symbol)
+              "#{key}: #{value.inspect}"
+            else
+              "#{key.inspect} => #{value.inspect}"
+            end
+          }.join(', ')
+
+          output << '}›'
+        end
+      end
+
+      def self.dummy_value_for(column_type, array: false)
+        if array
+          [dummy_value_for(column_type, array: false)]
+        else
+          case column_type
+          when :integer
+            0
+          when :date
+            Date.new(2100, 1, 1)
+          when :datetime, :timestamp, :timestamptz
+            DateTime.new(2100, 1, 1)
+          when :time
+            Time.new(2000, 1, 1)
+          when :uuid
+            SecureRandom.uuid
+          when :boolean
+            true
+          else
+            'dummy value'
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/version.rb

@@ -0,0 +1,6 @@
+module Shoulda
+  module Matchers
+    # @private
+    VERSION = '8.0.1'.freeze
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/warn.rb

@@ -0,0 +1,28 @@
+module Shoulda
+  module Matchers
+    # @private
+    TERMINAL_MAX_WIDTH = 72
+
+    # @private
+    def self.warn(message)
+      header = 'Warning from shoulda-matchers:'
+      divider = '*' * TERMINAL_MAX_WIDTH
+      wrapped_message = word_wrap(message)
+      full_message = [
+        divider,
+        [header, wrapped_message.strip].join("\n\n"),
+        divider,
+      ].join("\n")
+
+      Kernel.warn(full_message)
+    end
+
+    # @private
+    def self.warn_about_deprecated_method(old_method, new_method)
+      warn <<EOT
+#{old_method} is deprecated and will be removed in the next major
+release. Please use #{new_method} instead.
+EOT
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers.rb

@@ -0,0 +1,25 @@
+require 'shoulda/matchers/configuration'
+require 'shoulda/matchers/doublespeak'
+require 'shoulda/matchers/error'
+require 'shoulda/matchers/independent'
+require 'shoulda/matchers/integrations'
+require 'shoulda/matchers/matcher_collection'
+require 'shoulda/matchers/matcher_context'
+require 'shoulda/matchers/rails_shim'
+require 'shoulda/matchers/util'
+require 'shoulda/matchers/version'
+require 'shoulda/matchers/warn'
+
+require 'shoulda/matchers/action_controller'
+require 'shoulda/matchers/active_model'
+require 'shoulda/matchers/active_record'
+require 'shoulda/matchers/routing'
+
+module Shoulda # :nodoc:
+  module Matchers # :nodoc:
+    class << self
+      # @private
+      attr_accessor :assertion_exception_class
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda-matchers.rb

@@ -0,0 +1 @@
+require 'shoulda/matchers'

data/shoulda-matchers-8.0.1/shoulda-matchers.gemspec

@@ -0,0 +1,43 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'shoulda/matchers/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'shoulda-matchers'
+  s.version     = Shoulda::Matchers::VERSION.dup
+  s.authors     = [
+    'Tammer Saleh',
+    'Joe Ferris',
+    'Ryan McGeary',
+    'Dan Croak',
+    'Matt Jankowski',
+    'Stafford Brunk',
+    'Elliot Winkler',
+  ]
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.email       = 'support@thoughtbot.com'
+  s.homepage    = 'https://matchers.shoulda.io/'
+  s.summary     = 'Simple one-liner tests for common Rails functionality'
+  s.license     = 'MIT'
+  s.description = <<~DESC.tr("\n", ' ').squeeze(' ')
+    Shoulda Matchers provides RSpec- and Minitest-compatible one-liners to test
+    common Rails functionality that, if written by hand, would be much
+    longer, more complex, and error-prone.
+  DESC
+
+  s.metadata = {
+    'bug_tracker_uri' => 'https://github.com/thoughtbot/shoulda-matchers/issues',
+    'changelog_uri' => 'https://github.com/thoughtbot/shoulda-matchers/blob/main/CHANGELOG.md',
+    'documentation_uri' => 'https://matchers.shoulda.io/docs',
+    'homepage_uri' => 'https://matchers.shoulda.io',
+    'source_code_uri' => 'https://github.com/thoughtbot/shoulda-matchers',
+    'rubygems_mfa_required' => 'true',
+  }
+
+  s.files = Dir['{docs,lib}/**/*', 'README.md', 'LICENSE',
+    'shoulda-matchers.gemspec',]
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 3.3'
+  s.add_dependency 'activesupport', '>= 7.2'
+  s.add_development_dependency 'mutex_m'
+end

data/ultra-fast-box.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "ultra-fast-box"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on shoulda-matchers"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/ultra-fast-box" }
+end