scimitar 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f44cfce4b49e3f386b14081151dc38bf5bf857939fefbad36b507770d1de2e9
-  data.tar.gz: ba7fe68d41eb204a84f71e23931ed85a497645671170994043abab4e1b7dba73
+  metadata.gz: 95a2166cc921a400959f9d8d4398f6bf8ecb772f8d7a0a0a73950892e85d808a
+  data.tar.gz: cdf5aab3812f10f69c96304e738a150f4208850267527b66d36eeb99548d7b1f
 SHA512:
-  metadata.gz: 1b267f42755f9fc94280ea7c84d08762056e95dd967a6d17535cefd9275e04f60e3abc1a20a7849ab7f3bbd8fa508047586f23cb33ed6d7bec56bc6c2d3fcf7d
-  data.tar.gz: facdf0cb0566d0b323181abb0d4707c2036f85b2f958f29dc0df0471a6244595c6147a7887895b7a96689288edea3c684cbf3d32c7119959ff70c28abc610d9e
+  metadata.gz: f0925517599b107e44fd93db9be142aebe608892c2c5069c50d22b353c51238290710474b062a002fdb010be3d783c4dea3b314f72f47b4aca3c2385a8fc1377
+  data.tar.gz: eef6eebfc64bb2d4adabfca110f26e3a6c9e227f47387da6fb384925899ddf0ae260cf68176f24040a6bb356cf34f6576c920bd44264d4a1fee415aeadc237e6

data/app/controllers/scimitar/active_record_backed_resources_controller.rb

@@ -131,8 +131,8 @@ module Scimitar
         raise NotImplementedError
       end
 
-      # Find a RIP user record. Subclasses can override this if they need
-      # special lookup behaviour.
+      # Find a record by ID. Subclasses can override this if they need special
+      # lookup behaviour.
       #
       # +record_id+:: Record ID (SCIM schema 'id' value - "our" ID).
       #

data/app/models/scimitar/complex_types/base.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Scimitar
   module ComplexTypes
 
@@ -22,8 +24,48 @@ module Scimitar
       include Scimitar::Schema::DerivedAttributes
       include Scimitar::Errors
 
+      # Instantiates with attribute values - see ActiveModel::Model#initialize.
+      #
+      # Allows case-insensitive attributes given in options, by enumerating all
+      # instance methods that exist in the subclass (at the point where this
+      # method runs, 'self' is a subclass, unless someone instantiated this
+      # base class directly) and subtracting methods in the base class. Usually
+      # this leaves just the attribute accessors, with not much extra.
+      #
+      # Map a normalized case version of those names to the actual method names
+      # then for each key in the inbound options, normalize it and see if one
+      # of the actual case method names is available. If so, use that instead.
+      #
+      # Unmapped option keys will most likely have no corresponding writer
+      # method in the subclass and NoMethodError will therefore arise.
+      #
       def initialize(options={})
-        super
+        normalized_method_map     = HashWithIndifferentAccess.new
+        corrected_options         = {}
+        probable_accessor_methods = self.class.instance_methods - self.class.superclass.instance_methods
+
+        unless options.empty?
+          probable_accessor_methods.each do | method_name |
+            next if method_name.end_with?('=')
+            normalized_method_map[method_name.downcase] = method_name
+          end
+
+          options.each do | ambiguous_case_name, value |
+            normalized_name = ambiguous_case_name.downcase
+            corrected_name  = normalized_method_map[normalized_name]
+
+            if corrected_name.nil?
+              corrected_options[ambiguous_case_name] = value # Probably will lead to NoMethodError
+            else
+              corrected_options[corrected_name] = value
+            end
+          end
+
+          options = corrected_options
+        end
+
+        super # Calls into ActiveModel::Model
+
         @errors = ActiveModel::Errors.new(self)
       end
 

data/app/models/scimitar/errors.rb

@@ -1,6 +1,6 @@
 module Scimitar
   module Errors
-    def add_errors_from_hash(errors_hash, prefix: nil)
+    def add_errors_from_hash(errors_hash:, prefix: nil)
       errors_hash.each_pair do |key, value|
         new_key = prefix.nil? ? key : "#{prefix}.#{key}".to_sym
         if value.is_a?(Array)

data/app/models/scimitar/resources/base.rb

@@ -11,10 +11,27 @@ module Scimitar
       validate :validate_resource
 
       def initialize(options = {})
-        flattended_attributes = flatten_extension_attributes(options)
-        attributes = flattended_attributes.with_indifferent_access.slice(*self.class.all_attributes)
-        super(attributes)
-        constantize_complex_types(attributes)
+        flattened_attributes = flatten_extension_attributes(options)
+        ci_all_attributes    = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
+        camel_attributes     = {}
+
+        # Create a map where values are the schema-correct-case attribute names
+        # and the values are set the same, but since the ci_all_attributes data
+        # type is HashWithIndifferentCaseInsensitiveAccess, lookups in this are
+        # case insensitive. Thus, arbitrary case input data can be mapped to
+        # the case correctness required for ActiveModel's attribute accessors.
+        #
+        self.class.all_attributes.each { |attr| ci_all_attributes[attr] = attr }
+
+        flattened_attributes.each do | key, value |
+          if ci_all_attributes.key?(key)
+            camel_attributes[ci_all_attributes[key]] = value
+          end
+        end
+
+        super(camel_attributes)
+        constantize_complex_types(camel_attributes)
+
         @errors = ActiveModel::Errors.new(self)
       end
 
@@ -109,6 +126,7 @@ module Scimitar
       def constantize_complex_types(hash)
         hash.with_indifferent_access.each_pair do |attr_name, attr_value|
           scim_attribute = self.class.complex_scim_attributes[attr_name].try(:first)
+
           if scim_attribute && scim_attribute.complexType
             if scim_attribute.multiValued
               self.send("#{attr_name}=", attr_value.map {|attr_for_each_item| complex_type_from_hash(scim_attribute, attr_for_each_item)})

data/app/models/scimitar/resources/mixin.rb

@@ -404,10 +404,10 @@ module Scimitar
         # Call ONLY for PATCH. For POST and PUT, see #from_scim!.
         #
         def from_scim_patch!(patch_hash:)
-          patch_hash.freeze()
-          scim_hash = self.to_scim(location: '(unused)').as_json()
+          frozen_ci_patch_hash = patch_hash.with_indifferent_case_insensitive_access().freeze()
+          ci_scim_hash         = self.to_scim(location: '(unused)').as_json().with_indifferent_case_insensitive_access()
 
-          patch_hash['Operations'].each do |operation|
+          frozen_ci_patch_hash['operations'].each do |operation|
             nature   = operation['op'   ]&.downcase
             path_str = operation['path' ]
             value    = operation['value']
@@ -440,22 +440,22 @@ module Scimitar
             if path_str.blank?
               extract_root = true
               path_str     = 'root'
-              scim_hash    = { 'root' => scim_hash }
+              ci_scim_hash = { 'root' => ci_scim_hash }.with_indifferent_case_insensitive_access()
             end
 
             self.from_patch_backend!(
               nature:        nature,
               path:          (path_str || '').split('.'),
               value:         value,
-              altering_hash: scim_hash
+              altering_hash: ci_scim_hash
             )
 
             if extract_root
-              scim_hash = scim_hash['root']
+              ci_scim_hash = ci_scim_hash['root']
             end
           end
 
-          self.from_scim!(scim_hash: scim_hash)
+          self.from_scim!(scim_hash: ci_scim_hash)
           return self
         end
 
@@ -542,20 +542,20 @@ module Scimitar
           #   ::scim_attributes_map.
           #
           #     {                                                     | {
-          #       "userName": "foo",                                  |   "id": "id",
-          #       "name": {                                           |   "externalId": :scim_uid",
-          #         "givenName": "Foo",                               |   "userName": :username",
-          #         "familyName": "Bar"                               |   "name": {
-          #       },                                                  |     "givenName": :first_name",
-          #       "active": true,                                     |     "familyName": :last_name"
+          #       "userName": "foo",                                  |   'id': :id,
+          #       "name": {                                           |   'externalId': :scim_uid,
+          #         "givenName": "Foo",                               |   'userName': :username,
+          #         "familyName": "Bar"                               |   'name': {
+          #       },                                                  |     'givenName': :first_name,
+          #       "active": true,                                     |     'familyName': :last_name
           #       "emails": [                                         |   },
-          #         {                                                 |   "emails": [
+          #         {                                                 |   'emails': [
           #           "type": "work",                  <------\       |     {
-          #           "primary": true,                         \------+---    "match": "type",
-          #           "value": "foo.bar@test.com"                     |       "with": "work",
-          #         }                                                 |       "using": {
-          #       ],                                                  |         "value": :work_email_address",
-          #       "phoneNumbers": [                                   |         "primary": true
+          #           "primary": true,                         \------+---    'match': 'type',
+          #           "value": "foo.bar@test.com"                     |       'with': 'work',
+          #         }                                                 |       'using': {
+          #       ],                                                  |         'value': :work_email_address,
+          #       "phoneNumbers": [                                   |         'primary': true
           #         {                                                 |       }
           #           "type": "work",                                 |     }
           #           "primary": false,                               |   ],
@@ -568,7 +568,7 @@ module Scimitar
           #         "location": "https://test.com/mock_users/42",     |       }
           #         "resourceType": "User"                            |     }
           #       },                                                  |   ],
-          #       "schemas": [                                        |   "active": :is_active"
+          #       "schemas": [                                        |   'active': :is_active
           #         "urn:ietf:params:scim:schemas:core:2.0:User"      | }
           #       ]                                                   |
           #     }                                                     |
@@ -600,7 +600,7 @@ module Scimitar
             scim_hash_or_leaf_value:,
             path: []
           )
-            attrs_map_or_leaf_value = attrs_map_or_leaf_value.with_indifferent_access() if attrs_map_or_leaf_value.instance_of?(Hash)
+            scim_hash_or_leaf_value = scim_hash_or_leaf_value.with_indifferent_case_insensitive_access() if scim_hash_or_leaf_value.is_a?(Hash)
 
             # We get the schema via this instance's class's resource type, even
             # if we end up in collections of other types - because it's *this*
@@ -668,7 +668,7 @@ module Scimitar
                 end # "map_entry&.each do | mapped_array_entry |"
 
               when Symbol # Setter/getter method at leaf position in attribute map
-                if path == ['externalId'] # Special case held only in schema base class
+                if path.length == 1 && path.first&.to_s&.downcase == 'externalid' # Special case held only in schema base class
                   mutable = true
                 else
                   attribute = resource_class.find_attribute(*path)
@@ -706,7 +706,8 @@ module Scimitar
           #
           # +altering_hash+:: The Hash to operate on at the current +path+. For
           #                   recursive calls, this will be some way down into
-          #                   the SCIM representation of 'self'.
+          #                   the SCIM representation of 'self'. MUST be a
+          #                   HashWithIndifferentCaseInsensitiveAccess.
           #
           # Note that SCIM PATCH operations permit *no* path for 'replace' and
           # 'add' operations, meaning "apply to whole object". To avoid special
@@ -715,6 +716,7 @@ module Scimitar
           # interest and supply this key as the sole array entry in +path+.
           #
           def from_patch_backend!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
 
             # These all throw exceptions if data is not as expected / required,
             # any of which are rescued below.
@@ -752,6 +754,8 @@ module Scimitar
           # Happily throws exceptions if data is not as expected / required.
           #
           def from_patch_backend_traverse!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
+
             path_component, filter = extract_filter_from(path_component: path.first)
 
             # https://tools.ietf.org/html/rfc7644#section-3.5.2.1
@@ -766,7 +770,7 @@ module Scimitar
             #
             # Harmless in this context for 'remove'.
             #
-            altering_hash[path_component] ||= {}
+            altering_hash[path_component] ||= Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
 
             # Unless the PATCH is bad, inner data is an Array or Hash always as
             # by definition this method is only called at path positions above
@@ -784,7 +788,7 @@ module Scimitar
               # Same reason as section 3.5.2.1 / 3.5.2.3 RFC quotes above.
               #
               if nature != 'remove' && matched_hashes.empty?
-                new_hash = {}
+                new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
                 altering_hash[path_component] = [new_hash]
                 matched_hashes                = [new_hash]
               end
@@ -815,6 +819,8 @@ module Scimitar
           # Happily throws exceptions if data is not as expected / required.
           #
           def from_patch_backend_apply!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
+
             path_component, filter = extract_filter_from(path_component: path.first)
             current_data_at_path   = altering_hash[path_component]
 
@@ -968,7 +974,9 @@ module Scimitar
             value = value[1..-2] if value.start_with?('"') && value.end_with?('"')
 
             within_array.each.with_index do | hash, index |
-              matched = hash.key?(attribute) && hash[attribute]&.to_s == value&.to_s
+              ci_hash = hash.with_indifferent_case_insensitive_access()
+              matched = ci_hash.key?(attribute) && ci_hash[attribute]&.to_s == value&.to_s
+
               yield(hash, index) if matched
             end
           end

data/app/models/scimitar/schema/attribute.rb

@@ -88,7 +88,7 @@ module Scimitar
         end
         value.class.schema.valid?(value)
         return true if value.errors.empty?
-        add_errors_from_hash(value.errors.to_hash, prefix: self.name)
+        add_errors_from_hash(errors_hash: value.errors.to_hash, prefix: self.name)
         false
       end
 

data/app/models/scimitar/schema/base.rb

@@ -26,7 +26,9 @@ module Scimitar
       #
       def self.valid?(resource)
         cloned_scim_attributes.each do |scim_attribute|
-          resource.add_errors_from_hash(scim_attribute.errors.to_hash) unless scim_attribute.valid?(resource.send(scim_attribute.name))
+          unless scim_attribute.valid?(resource.send(scim_attribute.name))
+            resource.add_errors_from_hash(errors_hash: scim_attribute.errors.to_hash)
+          end
         end
       end
 
@@ -62,8 +64,10 @@ module Scimitar
           current_path_entry = path.shift()
           next if current_path_entry.is_a?(Integer) # Skip array indicies arising from multi-value attributes
 
+          current_path_entry = current_path_entry.to_s.downcase
+
           found_attribute = current_attributes.find do | attribute_to_check |
-            attribute_to_check.name == current_path_entry
+            attribute_to_check.name.to_s.downcase == current_path_entry
           end
 
           if found_attribute && path.present? # Any sub-attributes to check?...

data/config/initializers/scimitar.rb

@@ -2,81 +2,85 @@
 #
 # For supporting information and rationale, please see README.md.
 
-# =============================================================================
-# SERVICE PROVIDER CONFIGURATION
-# =============================================================================
-#
-# This is a Ruby abstraction over a SCIM entity that declares the capabilities
-# supported by a particular implementation.
-#
-# Typically this is used to declare parts of the standard unsupported, if you
-# don't need them and don't want to provide subclass support.
-#
-Scimitar.service_provider_configuration = Scimitar::ServiceProviderConfiguration.new({
+Rails.application.config.to_prepare do # (required for >= Rails 7 / Zeitwerk)
 
-  # See https://tools.ietf.org/html/rfc7643#section-8.5 for properties.
+  # ===========================================================================
+  # SERVICE PROVIDER CONFIGURATION
+  # ===========================================================================
   #
-  # See Gem source file 'app/models/scimitar/service_provider_configuration.rb'
-  # for defaults. Define Hash keys here that override defaults; e.g. to declare
-  # that filters are not supported so that calling clients shouldn't use them:
+  # This is a Ruby abstraction over a SCIM entity that declares the
+  # capabilities supported by a particular implementation.
   #
-  #   filter: Scimitar::Supported.unsupported
+  # Typically this is used to declare parts of the standard unsupported, if you
+  # don't need them and don't want to provide subclass support.
+  #
+  Scimitar.service_provider_configuration = Scimitar::ServiceProviderConfiguration.new({
 
-})
+    # See https://tools.ietf.org/html/rfc7643#section-8.5 for properties.
+    #
+    # See Gem file 'app/models/scimitar/service_provider_configuration.rb'
+    # for defaults. Define Hash keys here that override defaults; e.g. to
+    # declare that filters are not supported so that calling clients shouldn't
+    # use them:
+    #
+    #   filter: Scimitar::Supported.unsupported
 
-# =============================================================================
-# ENGINE CONFIGURATION
-# =============================================================================
-#
-# This is where you provide callbacks for things like authorisation or mixins
-# that get included into all Scimitar-derived controllers (for things like
-# before-actions that apply to all Scimitar controller-based routes).
-#
-Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
+  })
 
-  # If you have filters you want to run for any Scimitar action/route, you can
-  # define them here. For example, you might use a before-action to set up some
-  # multi-tenancy related state, or skip Rails CSRF token verification/
-  #
-  # For example:
+  # ===========================================================================
+  # ENGINE CONFIGURATION
+  # ===========================================================================
   #
-  #     application_controller_mixin: Module.new do
-  #       def self.included(base)
-  #         base.class_eval do
+  # This is where you provide callbacks for things like authorisation or mixins
+  # that get included into all Scimitar-derived controllers (for things like
+  # before-actions that apply to all Scimitar controller-based routes).
   #
-  #           # Anything here is written just as you'd write it at the top of
-  #           # one of your controller classes, but it gets included in all
-  #           # Scimitar classes too.
-  #
-  #           skip_before_action    :verify_authenticity_token
-  #           prepend_before_action :setup_some_kind_of_multi_tenancy_data
-  #         end
-  #       end
-  #     end, # ...other configuration entries might follow...
+  Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
 
-  # If you want to support username/password authentication:
-  #
-  #     basic_authenticator: Proc.new do | username, password |
-  #       # Check username/password and return 'true' if valid, else 'false'.
-  #     end, # ...other configuration entries might follow...
-  #
-  # The 'username' and 'password' parameters come from Rails:
-  #
-  #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic.html
-  #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic/ControllerMethods.html#method-i-authenticate_with_http_basic
+    # If you have filters you want to run for any Scimitar action/route, you
+    # can define them here. For example, you might use a before-action to set
+    # up some multi-tenancy related state, or skip Rails CSRF token
+    # verification. For example:
+    #
+    #     application_controller_mixin: Module.new do
+    #       def self.included(base)
+    #         base.class_eval do
+    #
+    #           # Anything here is written just as you'd write it at the top of
+    #           # one of your controller classes, but it gets included in all
+    #           # Scimitar classes too.
+    #
+    #           skip_before_action    :verify_authenticity_token
+    #           prepend_before_action :setup_some_kind_of_multi_tenancy_data
+    #         end
+    #       end
+    #     end, # ...other configuration entries might follow...
 
-  # If you want to support HTTP bearer token (OAuth-style) authentication:
-  #
-  #     token_authenticator: Proc.new do | token, options |
-  #       # Check token and return 'true' if valid, else 'false'.
-  #     end, # ...other configuration entries might follow...
-  #
-  # The 'token' and 'options' parameters come from Rails:
-  #
-  #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token.html
-  #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token/ControllerMethods.html#method-i-authenticate_with_http_token
-  #
-  # Note that both basic and token authentication can be declared, with the
-  # parameters in the inbound HTTP request determining which is invoked.
+    # If you want to support username/password authentication:
+    #
+    #     basic_authenticator: Proc.new do | username, password |
+    #       # Check username/password and return 'true' if valid, else 'false'.
+    #     end, # ...other configuration entries might follow...
+    #
+    # The 'username' and 'password' parameters come from Rails:
+    #
+    #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic.html
+    #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic/ControllerMethods.html#method-i-authenticate_with_http_basic
+
+    # If you want to support HTTP bearer token (OAuth-style) authentication:
+    #
+    #     token_authenticator: Proc.new do | token, options |
+    #       # Check token and return 'true' if valid, else 'false'.
+    #     end, # ...other configuration entries might follow...
+    #
+    # The 'token' and 'options' parameters come from Rails:
+    #
+    #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token.html
+    #   https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token/ControllerMethods.html#method-i-authenticate_with_http_token
+    #
+    # Note that both basic and token authentication can be declared, with the
+    # parameters in the inbound HTTP request determining which is invoked.
+
+  })
 
-})
+end

data/lib/scimitar/support/hash_with_indifferent_case_insensitive_access.rb

@@ -0,0 +1,86 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Hash
+
+  # Converts this Hash to an instance of
+  # Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess, which is
+  # a subclass of ActiveSupport::HashWithIndifferentAccess with the addition of
+  # case-insensitive lookup.
+  #
+  # Note that this is more thorough than the ActiveSupport counterpart. It
+  # converts recursively, so that all Hashes to arbitrary depth, including any
+  # hashes inside Arrays, are converted. This is an expensive operation.
+  #
+  def with_indifferent_case_insensitive_access
+    self.class.deep_indifferent_case_insensitive_access(self)
+  end
+
+  # Supports #with_indifferent_case_insensitive_access. Converts the given item
+  # to indifferent, case-insensitive access as a Hash; or converts Array items
+  # if given an Array; or returns the given object.
+  #
+  # Hashes and Arrays at all depths are duplicated as a result.
+  #
+  def self.deep_indifferent_case_insensitive_access(object)
+    if object.is_a?(Hash)
+      new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new(object)
+      new_hash.each do | key, value |
+        new_hash[key] = deep_indifferent_case_insensitive_access(value)
+      end
+      new_hash
+
+    elsif object.is_a?(Array)
+      object.map do | array_entry |
+        deep_indifferent_case_insensitive_access(array_entry)
+      end
+
+    else
+      object
+
+    end
+  end
+end
+
+module Scimitar
+  module Support
+
+    # A subclass of ActiveSupport::HashWithIndifferentAccess where not only
+    # can Hash keys be queried as Symbols or Strings, but they are looked up
+    # in a case-insensitive fashion too.
+    #
+    # During enumeration, Hash keys will always be returned in whatever case
+    # they were originally set.
+    #
+    class HashWithIndifferentCaseInsensitiveAccess < ActiveSupport::HashWithIndifferentAccess
+      def with_indifferent_case_insensitive_access
+        self
+      end
+
+      private
+
+        if Symbol.method_defined?(:name)
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.name.downcase : key.downcase
+          end
+        else
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.to_s.downcase : key.downcase
+          end
+        end
+
+        def update_with_single_argument(other_hash, block)
+          if other_hash.is_a? HashWithIndifferentCaseInsensitiveAccess
+            regular_update(other_hash, &block)
+          else
+            other_hash.to_hash.each_pair do |key, value|
+              if block && key?(key)
+                value = block.call(convert_key(key), self[key], value)
+              end
+              regular_writer(convert_key(key), convert_value(value))
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/scimitar/version.rb

@@ -3,11 +3,11 @@ module Scimitar
   # Gem version. If this changes, be sure to re-run "bundle install" or
   # "bundle update".
   #
-  VERSION = '1.0.3'
+  VERSION = '2.0.0'
 
   # Date for VERSION. If this changes, be sure to re-run "bundle install"
   # or "bundle update".
   #
-  DATE = '2021-03-24'
+  DATE = '2022-03-04'
 
 end

data/lib/scimitar.rb

@@ -1,4 +1,5 @@
 require 'scimitar/version'
+require 'scimitar/support/hash_with_indifferent_case_insensitive_access'
 require 'scimitar/engine'
 
 module Scimitar

data/spec/apps/dummy/config/application.rb

@@ -12,6 +12,7 @@ require 'scimitar'
 
 module Dummy
   class Application < Rails::Application
+    config.load_defaults 7.0
   end
 end
 

data/spec/apps/dummy/config/environments/test.rb

@@ -1,15 +1,38 @@
+require 'active_support/core_ext/integer/time'
+
 Rails.application.configure do
   config.cache_classes = true
   config.eager_load = false
-  config.serve_static_files = true
-  config.static_cache_control = 'public, max-age=3600'
-  config.consider_all_requests_local = true
 
-  config.action_dispatch.show_exceptions = false
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.enabled = true
+  config.public_file_server.headers = {
+    'Cache-Control' => "public, max-age=#{1.hour.to_i}"
+  }
 
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment.
   config.action_controller.allow_forgery_protection = false
 
-  config.active_support.test_order = :random
+  # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
 end