ultra-fast-box 0.0.1

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

@@ -0,0 +1,104 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_implicit_order_column` matcher tests that the model has `implicit_order_column`
+      # assigned to one of the table columns.
+      #
+      #     class Product < ApplicationRecord
+      #       self.implicit_order_column = :created_at
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Product, type: :model do
+      #       it { should have_implicit_order_column(:created_at) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProductTest < ActiveSupport::TestCase
+      #       should have_implicit_order_column(:created_at)
+      #     end
+      #
+      # @return [HaveImplicitOrderColumnMatcher]
+      #
+      def have_implicit_order_column(column_name)
+        HaveImplicitOrderColumnMatcher.new(column_name)
+      end
+
+      # @private
+      class HaveImplicitOrderColumnMatcher
+        attr_reader :failure_message
+
+        def initialize(column_name)
+          @column_name = column_name
+        end
+
+        def matches?(subject)
+          @subject = subject
+          check_column_exists!
+          check_implicit_order_column_matches!
+          true
+        rescue SecondaryCheckFailedError => e
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, " +
+            "but that could not be proved: #{e.message}.",
+          )
+          false
+        rescue PrimaryCheckFailedError => e
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, but #{e.message}.",
+          )
+          false
+        end
+
+        def failure_message_when_negated
+          Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} not to #{expectation}, but it did.",
+          )
+        end
+
+        def description
+          expectation
+        end
+
+        private
+
+        attr_reader :column_name, :subject
+
+        def check_column_exists!
+          matcher = HaveDbColumnMatcher.new(column_name)
+
+          if !matcher.matches?(@subject)
+            raise SecondaryCheckFailedError.new(
+              "The :#{model.table_name} table does not have a " +
+              ":#{column_name} column",
+            )
+          end
+        end
+
+        def check_implicit_order_column_matches!
+          if model.implicit_order_column.to_s != column_name.to_s
+            message =
+              if model.implicit_order_column.nil?
+                'implicit_order_column is not set'
+              else
+                "it is :#{model.implicit_order_column}"
+              end
+
+            raise PrimaryCheckFailedError.new(message)
+          end
+        end
+
+        def model
+          subject.class
+        end
+
+        def expectation
+          "have an implicit_order_column of :#{column_name}"
+        end
+
+        class SecondaryCheckFailedError < StandardError; end
+        class PrimaryCheckFailedError < StandardError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_readonly_attribute` matcher tests usage of the
+      # `attr_readonly` macro.
+      #
+      #     class User < ActiveRecord::Base
+      #       attr_readonly :password
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_readonly_attribute(:password) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_readonly_attribute(:password)
+      #     end
+      #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User < ActiveRecord::Base
+      #       attr_readonly :name, :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_readonly_attribute(:name, :email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_readonly_attribute(:name, :email)
+      #     end
+      #
+      # @return [HaveReadonlyAttributeMatcher]
+      #
+      def have_readonly_attribute(*values)
+        MatcherCollection.build(values) { |value| HaveReadonlyAttributeMatcher.new(value) }
+      end
+
+      # @private
+      class HaveReadonlyAttributeMatcher
+        def initialize(attribute)
+          @attribute = attribute.to_s
+        end
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        def failure_reason
+          @failure_message
+        end
+
+        def matches?(subject)
+          @subject = subject
+          if readonly_attributes.include?(@attribute)
+            @failure_message_when_negated = "Did not expect #{@attribute}"\
+            ' to be read-only'
+            true
+          else
+            @failure_message =
+              if readonly_attributes.empty?
+                "#{class_name} attribute #{@attribute} " <<
+                  'is not read-only'
+              else
+                "#{class_name} is making " <<
+                  "#{readonly_attributes.to_a.to_sentence} " <<
+                  "read-only, but not #{@attribute}."
+              end
+            false
+          end
+        end
+
+        def description
+          "make #{@attribute} read-only"
+        end
+
+        private
+
+        def readonly_attributes
+          @_readonly_attributes ||= @subject.class.readonly_attributes || []
+        end
+
+        def class_name
+          @subject.class.name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_rich_text` matcher tests usage of the
+      # `has_rich_text` macro.
+      #
+      # #### Example
+      #
+      #     class Post < ActiveRecord
+      #       has_rich_text :content
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Post, type: :model do
+      #       it { should have_rich_text(:content) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostTest < ActiveSupport::TestCase
+      #       should have_rich_text(:content)
+      #     end
+      #
+      # @return [HaveRichTextMatcher]
+      #
+      def have_rich_text(rich_text_attribute)
+        HaveRichTextMatcher.new(rich_text_attribute)
+      end
+
+      # @private
+      class HaveRichTextMatcher
+        def initialize(rich_text_attribute)
+          @rich_text_attribute = rich_text_attribute
+        end
+
+        def description
+          "have configured :#{rich_text_attribute} as a "\
+          'ActionText::RichText association'
+        end
+
+        def failure_message
+          "Expected #{subject.class} to #{error_description}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{subject.class} to have ActionText::RichText"\
+          " :#{rich_text_attribute}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @error = run_checks
+          @error.nil?
+        end
+
+        private
+
+        attr_reader :error, :rich_text_attribute, :subject
+
+        def run_checks
+          if !has_attribute?
+            ":#{rich_text_attribute} does not exist"
+          elsif !has_expected_action_text?
+            :default
+          end
+        end
+
+        def has_attribute?
+          @subject.respond_to?(rich_text_attribute.to_s)
+        end
+
+        def has_expected_action_text?
+          defined?(ActionText::RichText) &&
+            @subject.send(rich_text_attribute).
+              is_a?(ActionText::RichText)
+        end
+
+        def error_description
+          error == :default ? description : "#{description} but #{error}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_secure_token` matcher tests usage of the
+      # `has_secure_token` macro.
+      #
+      #     class User < ActiveRecord
+      #       has_secure_token
+      #       has_secure_token :auth_token
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_token }
+      #       it { should have_secure_token(:auth_token) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_token
+      #       should have_secure_token(:auth_token)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### ignoring_check_for_db_index
+      #
+      # By default, this matcher tests that an index is defined on your token
+      # column. Use `ignoring_check_for_db_index` if this is not the case.
+      #
+      #     class User < ActiveRecord
+      #       has_secure_token :auth_token
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_token(:auth_token).ignoring_check_for_db_index }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_token(:auth_token).ignoring_check_for_db_index
+      #     end
+      #
+      # @return [HaveSecureToken]
+      #
+      def have_secure_token(token_attribute = :token)
+        HaveSecureTokenMatcher.new(token_attribute)
+      end
+
+      # @private
+      class HaveSecureTokenMatcher
+        attr_reader :token_attribute
+
+        def initialize(token_attribute)
+          @token_attribute = token_attribute
+          @options = { ignore_check_for_db_index: false }
+        end
+
+        def description
+          "have :#{token_attribute} as a secure token"
+        end
+
+        def failure_message
+          return if !@errors
+
+          "Expected #{@subject.class} to #{description} but the following " \
+          "errors were found: #{@errors.join(', ')}"
+        end
+
+        def failure_message_when_negated
+          return if !@errors
+
+          "Did not expect #{@subject.class} to have secure token " \
+          ":#{token_attribute}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @errors = run_checks
+          @errors.empty?
+        end
+
+        def ignoring_check_for_db_index
+          @options[:ignore_check_for_db_index] = true
+          self
+        end
+
+        private
+
+        def run_checks
+          @errors = []
+          if !has_expected_instance_methods?
+            @errors << 'missing expected class and instance methods'
+          end
+          if !has_expected_db_column?
+            @errors << "missing correct column #{token_attribute}:string"
+          end
+          if !@options[:ignore_check_for_db_index] && !has_expected_db_index?
+            @errors << "missing unique index for #{table_and_column}"
+          end
+          @errors
+        end
+
+        def has_expected_instance_methods?
+          @subject.respond_to?(token_attribute.to_s) &&
+            @subject.respond_to?("#{token_attribute}=") &&
+            @subject.respond_to?("regenerate_#{token_attribute}") &&
+            @subject.class.respond_to?(:generate_unique_secure_token)
+        end
+
+        def has_expected_db_column?
+          matcher = HaveDbColumnMatcher.new(token_attribute).of_type(:string)
+          matcher.matches?(@subject)
+        end
+
+        def has_expected_db_index?
+          matcher = HaveDbIndexMatcher.new(token_attribute).unique(true)
+          matcher.matches?(@subject)
+        end
+
+        def table_and_column
+          "#{table_name}.#{token_attribute}"
+        end
+
+        def table_name
+          @subject.class.table_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `normalize` matcher is used to ensure attribute normalizations
+      # are transforming attribute values as expected.
+      #
+      # Take this model for example:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, with: -> email { email.strip.downcase }
+      #     end
+      #
+      # You can use `normalize` providing an input and defining the expected
+      # normalization output:
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #     end
+      #
+      # You can use `normalize` to test multiple attributes at once:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, :handle, with: -> value { value.strip.downcase }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email, :handle).from(" Example\n").to("example")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email, :handle).from(" Example\n").to("example")
+      #     end
+      #
+      # If the normalization accepts nil values with the `apply_to_nil` option,
+      # you just need to use `.from(nil).to("Your expected value here")`.
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :name, with: -> name { name&.titleize || 'Untitled' },
+      #         apply_to_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should normalize(:name).from("jane doe").to("Jane Doe") }
+      #       it { should normalize(:name).from(nil).to("Untitled") }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:name).from("jane doe").to("Jane Doe")
+      #       should normalize(:name).from(nil).to("Untitled")
+      #     end
+      #
+      # @return [NormalizeMatcher]
+      #
+      def normalize(*attributes)
+        if attributes.empty?
+          raise ArgumentError, 'need at least one attribute'
+        else
+          NormalizeMatcher.new(*attributes)
+        end
+      end
+
+      # @private
+      class NormalizeMatcher
+        attr_reader :attributes, :from_value, :to_value, :failure_message,
+          :failure_message_when_negated
+
+        def initialize(*attributes)
+          @attributes = attributes
+        end
+
+        def description
+          %(
+            normalize #{attributes.to_sentence(last_word_connector: ' and ')} from
+            ‹#{from_value.inspect}› to ‹#{to_value.inspect}›
+          ).squish
+        end
+
+        def from(value)
+          @from_value = value
+
+          self
+        end
+
+        def to(value)
+          @to_value = value
+
+          self
+        end
+
+        def matches?(subject)
+          attributes.all? { |attribute| attribute_matches?(subject, attribute) }
+        end
+
+        def does_not_match?(subject)
+          attributes.all? { |attribute| attribute_does_not_match?(subject, attribute) }
+        end
+
+        private
+
+        def attribute_matches?(subject, attribute)
+          return true if normalize_attribute?(subject, attribute)
+
+          @failure_message = build_failure_message(
+            attribute,
+            subject.class.normalize_value_for(attribute, from_value),
+          )
+          false
+        end
+
+        def attribute_does_not_match?(subject, attribute)
+          return true unless normalize_attribute?(subject, attribute)
+
+          @failure_message_when_negated = build_failure_message_when_negated(attribute)
+          false
+        end
+
+        def normalize_attribute?(subject, attribute)
+          subject.class.normalize_value_for(attribute, from_value) == to_value
+        end
+
+        def build_failure_message(attribute, attribute_value)
+          %(
+            Expected to normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized to ‹#{attribute_value.inspect}›
+          ).squish
+        end
+
+        def build_failure_message_when_negated(attribute)
+          %(
+            Expected to not normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized
+          ).squish
+        end
+      end
+    end
+  end
+end