giga-safe-box 0.0.1

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

@@ -0,0 +1,228 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `set_flash` matcher is used to make assertions about the
+      # `flash` hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #
+      #       def destroy
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_flash }
+      #       end
+      #
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should_not set_flash }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :index }
+      #
+      #         should set_flash
+      #       end
+      #
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should_not set_flash
+      #       end
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### []
+      #
+      # Use `[]` to narrow the scope of the matcher to a particular key.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_flash[:foo] }
+      #         it { should_not set_flash[:bar] }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_flash[:foo]
+      #         should_not set_flash[:bar]
+      #       end
+      #     end
+      #
+      # ##### to
+      #
+      # Use `to` to assert that some key was set to a particular value, or that
+      # some key matches a particular regex.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_flash.to('A candy bar') }
+      #         it { should set_flash.to(/bar/) }
+      #         it { should set_flash[:foo].to('bar') }
+      #         it { should_not set_flash[:foo].to('something else') }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_flash.to('A candy bar')
+      #         should set_flash.to(/bar/)
+      #         should set_flash[:foo].to('bar')
+      #         should_not set_flash[:foo].to('something else')
+      #       end
+      #     end
+      #
+      # ##### now
+      #
+      # Use `now` to change the scope of the matcher to use the "now" hash
+      # instead of the usual "future" hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         flash.now[:foo] = 'bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should set_flash.now }
+      #         it { should set_flash.now[:foo] }
+      #         it { should set_flash.now[:foo].to('bar') }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_flash.now
+      #         should set_flash.now[:foo]
+      #         should set_flash.now[:foo].to('bar')
+      #       end
+      #     end
+      #
+      # @return [SetFlashMatcher]
+      #
+      def set_flash
+        SetFlashMatcher.new.in_context(self)
+      end
+
+      # @private
+      class SetFlashMatcher
+        extend Forwardable
+
+        def_delegators :underlying_matcher,
+          :description,
+          :matches?,
+          :failure_message,
+          :failure_message_when_negated
+        alias_method \
+          :failure_message_for_should,
+          :failure_message
+        alias_method \
+          :failure_message_for_should_not,
+          :failure_message_when_negated
+
+        def initialize
+          store = FlashStore.future
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
+        end
+
+        def now
+          if key || expected_value
+            raise QualifierOrderError
+          end
+
+          store = FlashStore.now
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
+          self
+        end
+
+        def in_context(context)
+          underlying_matcher.in_context(context)
+          self
+        end
+
+        def [](key)
+          @key = key
+          underlying_matcher[key]
+          self
+        end
+
+        def to(expected_value = nil, &block)
+          @expected_value = expected_value
+          underlying_matcher.to(expected_value, &block)
+          self
+        end
+
+        protected
+
+        attr_reader :underlying_matcher, :key, :expected_value
+
+        # @private
+        class QualifierOrderError < StandardError
+          def message
+            <<-MESSAGE.strip
+Using `set_flash` with the `now` qualifier and specifying `now` after other
+qualifiers is no longer allowed.
+
+You'll want to use `now` immediately after `set_flash`. For instance:
+
+    # Valid
+    should set_flash.now[:foo]
+    should set_flash.now[:foo].to('bar')
+
+    # Invalid
+    should set_flash[:foo].now
+    should set_flash[:foo].to('bar').now
+            MESSAGE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `set_session` matcher is used to make assertions about the
+      # `session` hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         session[:foo] = 'A candy bar'
+      #       end
+      #
+      #       def destroy
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_session }
+      #       end
+      #
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should_not set_session }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :index }
+      #
+      #         should set_session
+      #       end
+      #
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should_not set_session
+      #       end
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### []
+      #
+      # Use `[]` to narrow the scope of the matcher to a particular key.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         session[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_session[:foo] }
+      #         it { should_not set_session[:bar] }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_session[:foo]
+      #         should_not set_session[:bar]
+      #       end
+      #     end
+      #
+      # ##### to
+      #
+      # Use `to` to assert that some key was set to a particular value, or that
+      # some key matches a particular regex.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         session[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PostsController, type: :controller do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_session.to('A candy bar') }
+      #         it { should set_session.to(/bar/) }
+      #         it { should set_session[:foo].to('bar') }
+      #         it { should_not set_session[:foo].to('something else') }
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_session.to('A candy bar')
+      #         should set_session.to(/bar/)
+      #         should set_session[:foo].to('bar')
+      #         should_not set_session[:foo].to('something else')
+      #       end
+      #     end
+      #
+      # @return [SetSessionMatcher]
+      #
+      def set_session
+        SetSessionMatcher.new.in_context(self)
+      end
+
+      # @private
+      class SetSessionMatcher
+        extend Forwardable
+
+        def_delegators :underlying_matcher,
+          :description,
+          :matches?,
+          :failure_message,
+          :failure_message_when_negated
+        alias_method \
+          :failure_message_for_should,
+          :failure_message
+        alias_method \
+          :failure_message_for_should_not,
+          :failure_message_when_negated
+
+        def initialize
+          store = SessionStore.new
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
+        end
+
+        def in_context(context)
+          underlying_matcher.in_context(context)
+          self
+        end
+
+        def [](key)
+          underlying_matcher[key]
+          self
+        end
+
+        def to(expected_value = nil, &block)
+          underlying_matcher.to(expected_value, &block)
+          self
+        end
+
+        protected
+
+        attr_reader :underlying_matcher
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class SetSessionOrFlashMatcher
+        def initialize(store)
+          @store = store
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def [](key)
+          @key = key
+          self
+        end
+
+        def to(expected_value = nil, &block)
+          if block
+            unless context_set?
+              message = 'When specifying a value as a block, a context must be'\
+                ' specified beforehand,'\
+                " e.g., #{store.name}.in_context(context).to { ... }"
+              raise ArgumentError, message
+            end
+
+            @expected_value = context.instance_eval(&block)
+          else
+            @expected_value = expected_value
+          end
+
+          self
+        end
+
+        def description
+          "should #{expectation_description}"
+        end
+
+        def matches?(controller)
+          @controller = store.controller = controller
+          !store.empty? && key_matches? && expected_value_matches?
+        end
+
+        def failure_message
+          "Expected #{controller.class} to #{expectation_description},"\
+          ' but it did not'
+        end
+        alias_method :failure_message_for_should, :failure_message
+
+        def failure_message_when_negated
+          "Expected #{controller.class} not to #{expectation_description},"\
+          ' but it did'
+        end
+        alias_method :failure_message_for_should_not,
+          :failure_message_when_negated
+
+        protected
+
+        attr_reader :store, :context, :key, :expected_value, :controller
+
+        private
+
+        def context_set?
+          defined?(@context)
+        end
+
+        def key_set?
+          defined?(@key)
+        end
+
+        def expected_value_set?
+          defined?(@expected_value)
+        end
+
+        def key_matches?
+          !key_set? || store.has_key?(key)
+        end
+
+        def expected_value_matches?
+          !expected_value_set? || store.has_value?(expected_value)
+        end
+
+        def expectation_description
+          String.new('set').tap do |string|
+            string <<
+              if key_set?
+                " #{store.name}[#{key.inspect}]"
+              else
+                " any key in #{store.name}"
+              end
+
+            if expected_value_set?
+              string <<
+                if expected_value.is_a?(Regexp)
+                  " to a value matching #{expected_value.inspect}"
+                else
+                  " to #{expected_value.inspect}"
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'shoulda/matchers/action_controller/filter_param_matcher'
+require 'shoulda/matchers/action_controller/route_params'
+require 'shoulda/matchers/action_controller/set_flash_matcher'
+require 'shoulda/matchers/action_controller/render_with_layout_matcher'
+require 'shoulda/matchers/action_controller/respond_with_matcher'
+require 'shoulda/matchers/action_controller/set_session_matcher'
+require 'shoulda/matchers/action_controller/route_matcher'
+require 'shoulda/matchers/action_controller/redirect_to_matcher'
+require 'shoulda/matchers/action_controller/render_template_matcher'
+require 'shoulda/matchers/action_controller/rescue_from_matcher'
+require 'shoulda/matchers/action_controller/callback_matcher'
+require 'shoulda/matchers/action_controller/permit_matcher'
+require 'shoulda/matchers/action_controller/set_session_or_flash_matcher'
+require 'shoulda/matchers/action_controller/flash_store'
+require 'shoulda/matchers/action_controller/session_store'
+
+module Shoulda
+  module Matchers
+    # This module provides matchers that are used to test behavior within
+    # controllers.
+    module ActionController
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_changed_value_error.rb

@@ -0,0 +1,45 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeChangedValueError < Shoulda::Matchers::Error
+          attr_accessor :matcher_name, :model, :attribute_name, :value_written,
+            :value_read
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+The #{matcher_name} matcher attempted to set :#{attribute_name} on
+#{model.name} to #{value_written.inspect}, but when the attribute was
+read back, it had stored #{value_read.inspect} instead.
+
+This creates a problem because it means that the model is behaving in a
+way that is interfering with the test -- there's a mismatch between the
+test that you wrote and test that we actually ran.
+
+There are a couple of reasons why this could be happening:
+
+* ActiveRecord is typecasting the incoming value.
+* The writer method for :#{attribute_name} has been overridden so that
+  incoming values are changed in some way.
+
+If this exception makes sense to you and you wish to bypass it, try
+adding the `ignoring_interference_by_writer` qualifier onto the end of
+your matcher. If the test still does not pass after that, then you may
+need to do something different.
+
+If you need help, feel free to ask a question on the shoulda-matchers
+issues list:
+
+https://github.com/thoughtbot/shoulda-matchers/issues
+            MESSAGE
+          end
+
+          def successful?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_does_not_exist_error.rb

@@ -0,0 +1,23 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeDoesNotExistError < Shoulda::Matchers::Error
+          attr_accessor :model, :attribute_name, :value
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+The matcher attempted to set :#{attribute_name} on the #{model.name} to
+#{value.inspect}, but that attribute does not exist.
+            MESSAGE
+          end
+
+          def successful?
+            false
+          end
+        end
+      end
+    end
+  end
+end