valkyrie 2.1.0 → 3.0.0.pre.beta.1

data/lib/valkyrie/persistence/fedora/persister/model_converter.rb

@@ -313,7 +313,6 @@ module Valkyrie::Persistence::Fedora
         end
 
         # Generate a new RDF hash URI for the "child" graph for the ModelConverter::Property
-        # @see https://github.com/fcrepo4/fcrepo4/blob/master/fcrepo-kernel-modeshape/src/main/java/org/fcrepo/kernel/modeshape/rdf/JcrRdfTools.java#L455
         # @return [RDF::Graph]
         def subject_uri
           @subject_uri ||= ::RDF::URI(RDF::Node.new.to_s.gsub("_:", "#"))
@@ -325,21 +324,21 @@ module Valkyrie::Persistence::Fedora
       class MappedFedoraValue < ::Valkyrie::ValueMapper
         private
 
-          # Map a default Ruby data type
-          # (This maps the existing Property to a FedoraValue first)
-          # @param [Object] converted_value
-          # @return [Valkyrie::Persistence::Fedora::Persister::ModelConverter::Property]
-          def map_value(converted_value:)
-            calling_mapper.for(
-              Property.new(
-                value.subject,
-                value.key,
-                converted_value,
-                value.adapter,
-                value.resource
-              )
-            ).result
-          end
+        # Map a default Ruby data type
+        # (This maps the existing Property to a FedoraValue first)
+        # @param [Object] converted_value
+        # @return [Valkyrie::Persistence::Fedora::Persister::ModelConverter::Property]
+        def map_value(converted_value:)
+          calling_mapper.for(
+            Property.new(
+              value.subject,
+              value.key,
+              converted_value,
+              value.adapter,
+              value.resource
+            )
+          ).result
+        end
       end
 
       # Class mapping Property objects for Valkyrie IDs using typed RDF literals

data/lib/valkyrie/persistence/fedora/persister/orm_converter.rb

@@ -97,11 +97,10 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
-        # Class for handling cases where blacklisted values should not be mapped
-        class BlacklistedValue < ::Valkyrie::ValueMapper
+        # Class for handling cases where deny listed values should not be mapped
+        class DenylistedValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
-
-          # Determines whether or not the value has a blacklisted namespace for the RDF statement object
+          # Determines whether or not the value has a denied namespace for the RDF statement object
           # (i. e. avoid attempting to map any RDF statements making assertions about LDP containers or resource internal to Fedora)
           # @param [Property] value
           # @return [Boolean]
@@ -109,7 +108,7 @@ module Valkyrie::Persistence::Fedora
             value.statement.object.to_s.start_with?("http://www.w3.org/ns/ldp", "http://fedora.info")
           end
 
-          # Provide the NullApplicator Class for any Property in a blacklisted namespace
+          # Provide the NullApplicator Class for any Property in a deny listed namespace
           def result
             NullApplicator
           end
@@ -318,7 +317,7 @@ module Valkyrie::Persistence::Fedora
           # Casts the value of the RDF literal into an Applicator for DateTime values
           # @return [Applicator]
           def result
-            value.statement.object = ::DateTime.iso8601(value.statement.object.to_s).utc
+            value.statement.object = ::DateTime.iso8601(value.statement.object.to_s).new_offset(0)
             calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
           end
         end
@@ -394,7 +393,7 @@ module Valkyrie::Persistence::Fedora
           # Casts the value of the RDF literal into an Applicator for DateTime values
           # @return [Applicator]
           def result
-            value.statement.object = Time.parse(value.statement.object.to_s).utc
+            value.statement.object = DateTime.parse(value.statement.object.to_s).new_offset(0)
             calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
           end
         end
@@ -522,7 +521,7 @@ module Valkyrie::Persistence::Fedora
           # @param [Hash] hsh a new or existing Hash of attribute for Valkyrie resource attributes
           # @return [Hash]
           def apply_to(hsh)
-            return if blacklist?(key)
+            return if deny?(key)
             hsh[key.to_sym] = if hsh.key?(key.to_sym)
                                 Array.wrap(hsh[key.to_sym]) + cast_array(values)
                               else
@@ -541,13 +540,13 @@ module Valkyrie::Persistence::Fedora
             key
           end
 
-          # Determines whether or not a key is blacklisted for mapping
+          # Determines whether or not a key is on the deny list for mapping
           # (For example <http://fedora.info/definitions> assertions are not mapped to Valkyrie attributes)
           # @param [Symbol] key
           # @return [Boolean]
-          def blacklist?(key)
-            blacklist.each do |blacklist_item|
-              return true if key.start_with?(blacklist_item)
+          def deny?(key)
+            denylist.each do |denylist_item|
+              return true if key.start_with?(denylist_item)
             end
             false
           end
@@ -556,16 +555,12 @@ module Valkyrie::Persistence::Fedora
           # @param [Object] values
           # @return [Array<Object>]
           def cast_array(values)
-            if values.is_a?(Time)
-              [values]
-            else
-              Array(values)
-            end
+            Array(values)
           end
 
-          # Retrieve a list of blacklisted URIs for predicates
+          # Retrieve a list of denied URIs for predicates
           # @return [Array<String>]
-          def blacklist
+          def denylist
             [
               "http://fedora.info/definitions",
               "http://www.iana.org/assignments/relation/last"

data/lib/valkyrie/persistence/fedora/persister.rb

@@ -13,7 +13,7 @@ module Valkyrie::Persistence::Fedora
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save)
-    def save(resource:)
+    def save(resource:, external_resource: false)
       initialize_repository
       internal_resource = resource.dup
       internal_resource.created_at ||= Time.current
@@ -35,6 +35,8 @@ module Valkyrie::Persistence::Fedora
       alternate_resources ? save_reference_to_resource(persisted_resource, alternate_resources) : persisted_resource
     rescue Ldp::PreconditionFailed
       raise Valkyrie::Persistence::StaleObjectError, "The object #{internal_resource.id} has been updated by another process."
+    rescue Ldp::Gone
+      raise Valkyrie::Persistence::ObjectNotFoundError, "The object #{resource.id} is previously persisted but not found at save time."
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save_all)
@@ -86,97 +88,95 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      # Ensure that all alternate IDs for a given resource are persisted
-      # @param [Valkyrie::Resource] resource
-      # @return [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>]
-      def find_or_create_alternate_ids(resource)
-        return nil unless resource.try(:alternate_ids)
-
-        resource.alternate_ids.map do |alternate_identifier|
-          begin
-            adapter.query_service.find_by(id: alternate_identifier)
-          rescue ::Valkyrie::Persistence::ObjectNotFoundError
-            alternate_resource = ::Valkyrie::Persistence::Fedora::AlternateIdentifier.new(id: alternate_identifier)
-            adapter.persister.save(resource: alternate_resource)
-          end
-        end
+    # Ensure that all alternate IDs for a given resource are persisted
+    # @param [Valkyrie::Resource] resource
+    # @return [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>]
+    def find_or_create_alternate_ids(resource)
+      return nil unless resource.try(:alternate_ids)
+
+      resource.alternate_ids.map do |alternate_identifier|
+        adapter.query_service.find_by(id: alternate_identifier)
+      rescue ::Valkyrie::Persistence::ObjectNotFoundError
+        alternate_resource = ::Valkyrie::Persistence::Fedora::AlternateIdentifier.new(id: alternate_identifier)
+        adapter.persister.save(resource: alternate_resource)
       end
+    end
 
-      # Ensure that any Resources referenced by alternate IDs are deleted when a Resource has these IDs deleted
-      # @param [Valkyrie::Resource] updated_resource
-      def cleanup_alternate_resources(updated_resource)
-        persisted_resource = adapter.query_service.find_by(id: updated_resource.id)
-        removed_identifiers = persisted_resource.alternate_ids - updated_resource.alternate_ids
+    # Ensure that any Resources referenced by alternate IDs are deleted when a Resource has these IDs deleted
+    # @param [Valkyrie::Resource] updated_resource
+    def cleanup_alternate_resources(updated_resource)
+      persisted_resource = adapter.query_service.find_by(id: updated_resource.id)
+      removed_identifiers = persisted_resource.alternate_ids - updated_resource.alternate_ids
 
-        removed_identifiers.each do |removed_id|
-          adapter.persister.delete(resource: adapter.query_service.find_by(id: removed_id))
-        end
+      removed_identifiers.each do |removed_id|
+        adapter.persister.delete(resource: adapter.query_service.find_by(id: removed_id))
       end
+    end
 
-      # Ensure that any Resources referenced by alternate IDs are persisted when a Resource has these IDs added
-      # @param [Valkyrie::Resource] resource
-      # @param [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>] alternate_resources
-      # @return [Valkyrie::Resource]
-      def save_reference_to_resource(resource, alternate_resources)
-        alternate_resources.each do |alternate_resource|
-          alternate_resource.references = resource.id
-          adapter.persister.save(resource: alternate_resource)
-        end
-
-        resource
+    # Ensure that any Resources referenced by alternate IDs are persisted when a Resource has these IDs added
+    # @param [Valkyrie::Resource] resource
+    # @param [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>] alternate_resources
+    # @return [Valkyrie::Resource]
+    def save_reference_to_resource(resource, alternate_resources)
+      alternate_resources.each do |alternate_resource|
+        alternate_resource.references = resource.id
+        adapter.persister.save(resource: alternate_resource)
       end
 
-      # Generate the lock token for a Resource, and set it for attribute
-      # @param [Valkyrie::Resource] resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
-      # @note Fedora's last modified response is not granular enough to produce an effective lock token
-      #   therefore, we use the same implementation as the memory adapter. This could fail to lock a
-      #   resource if Fedora updated this resource between the time it was saved and Valkyrie created
-      #   the token.
-      def generate_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
-        resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
-      end
+      resource
+    end
 
-      # Determine whether or not a lock token is still valid for a persisted Resource
-      #   If the persisted Resource has been updated since it was last read into memory,
-      #   then the resouce in memory has been invalidated and Valkyrie::Persistence::StaleObjectError
-      #   is raised.
-      # @param [Valkyrie::Resource] resource
-      # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
-      # @raise [Valkyrie::Persistence::StaleObjectError]
-      def validate_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        return if resource.id.blank?
-
-        current_lock_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == adapter.id }
-        return if current_lock_token.blank?
-
-        retrieved_lock_tokens = adapter.query_service.find_by(id: resource.id)[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
-        retrieved_lock_token = retrieved_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
-        return if retrieved_lock_token.blank?
-
-        raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." unless current_lock_token == retrieved_lock_token
-      end
+    # Generate the lock token for a Resource, and set it for attribute
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
+    # @note Fedora's last modified response is not granular enough to produce an effective lock token
+    #   therefore, we use the same implementation as the memory adapter. This could fail to lock a
+    #   resource if Fedora updated this resource between the time it was saved and Valkyrie created
+    #   the token.
+    def generate_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
+      resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
+    end
 
-      # Retrieve the lock token that holds Fedora's system-managed last-modified date
-      # @param [Valkyrie::Resource] resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def native_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id.to_s == "native-#{adapter.id}" }
-      end
+    # Determine whether or not a lock token is still valid for a persisted Resource
+    #   If the persisted Resource has been updated since it was last read into memory,
+    #   then the resouce in memory has been invalidated and Valkyrie::Persistence::StaleObjectError
+    #   is raised.
+    # @param [Valkyrie::Resource] resource
+    # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
+    # @raise [Valkyrie::Persistence::StaleObjectError]
+    def validate_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      return if resource.id.blank?
+
+      current_lock_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == adapter.id }
+      return if current_lock_token.blank?
+
+      retrieved_lock_tokens = adapter.query_service.find_by(id: resource.id)[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+      retrieved_lock_token = retrieved_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
+      return if retrieved_lock_token.blank?
+
+      raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." unless current_lock_token == retrieved_lock_token
+    end
 
-      # Set Fedora request headers:
-      # * `Prefer: handling=lenient; received="minimal"` allows us to avoid sending all server-managed triples
-      # * `If-Unmodified-Since` triggers Fedora's server-side optimistic locking
-      # @param request [Faraday::Request]
-      # @param lock_token [Valkyrie::Persistence::OptimisticLockToken]
-      def update_request_headers(request, lock_token)
-        request.headers["Prefer"] = "handling=lenient; received=\"minimal\""
-        request.headers["If-Unmodified-Since"] = lock_token.token if lock_token
-      end
+    # Retrieve the lock token that holds Fedora's system-managed last-modified date
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def native_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id.to_s == "native-#{adapter.id}" }
+    end
+
+    # Set Fedora request headers:
+    # * `Prefer: handling=lenient; received="minimal"` allows us to avoid sending all server-managed triples
+    # * `If-Unmodified-Since` triggers Fedora's server-side optimistic locking
+    # @param request [Faraday::Request]
+    # @param lock_token [Valkyrie::Persistence::OptimisticLockToken]
+    def update_request_headers(request, lock_token)
+      request.headers["Prefer"] = "handling=lenient; received=\"minimal\""
+      request.headers["If-Unmodified-Since"] = lock_token.token if lock_token
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/query_service.rb

@@ -31,11 +31,9 @@ module Valkyrie::Persistence::Fedora
     def find_many_by_ids(ids:)
       ids = ids.uniq
       ids.map do |id|
-        begin
-          find_by(id: id)
-        rescue ::Valkyrie::Persistence::ObjectNotFoundError
-          nil
-        end
+        find_by(id: id)
+      rescue ::Valkyrie::Persistence::ObjectNotFoundError
+        nil
       end.reject(&:nil?)
     end
 
@@ -54,7 +52,7 @@ module Valkyrie::Persistence::Fedora
     # @return [Array<RDF::URI>]
     def include_uris
       [
-        adapter.fedora_version == 5 ? "http://fedora.info/definitions/fcrepo#PreferInboundReferences" : ::RDF::Vocab::Fcrepo4.InboundReferences
+        [5, 6].include?(adapter.fedora_version) ? "http://fedora.info/definitions/fcrepo#PreferInboundReferences" : ::RDF::Vocab::Fcrepo4.InboundReferences
       ]
     end
 
@@ -137,44 +135,44 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      def find_inverse_reference_ids_by_unordered(resource:, property:)
-        content = content_with_inbound(id: resource.id)
-        property_uri = adapter.schema.predicate_for(property: property, resource: nil)
-        content.graph.query([nil, property_uri, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
-      end
+    def find_inverse_reference_ids_by_unordered(resource:, property:)
+      content = content_with_inbound(id: resource.id)
+      property_uri = adapter.schema.predicate_for(property: property, resource: nil)
+      content.graph.query([nil, property_uri, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
+    end
 
-      def find_inverse_references_by_ordered(resource:, property:, ignore_ids: [])
-        content = content_with_inbound(id: resource.id)
-        ids = content.graph.query([nil, ::RDF::Vocab::ORE.proxyFor, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
-        ids.uniq!
-        ids.delete_if { |id| ignore_ids.include? id }
-        ids.lazy.map { |id| find_by(id: id) }.select { |o| o[property].include?(resource.id) }
-      end
+    def find_inverse_references_by_ordered(resource:, property:, ignore_ids: [])
+      content = content_with_inbound(id: resource.id)
+      ids = content.graph.query([nil, ::RDF::Vocab::ORE.proxyFor, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
+      ids.uniq!
+      ids.delete_if { |id| ignore_ids.include? id }
+      ids.lazy.map { |id| find_by(id: id) }.select { |o| o[property].include?(resource.id) }
+    end
 
-      # Ensures that an object is (or can be cast into a) Valkyrie::ID
-      # @return [Valkyrie::ID]
-      # @raise [ArgumentError]
-      def validate_id(id)
-        id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
-        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
-      end
+    # Ensures that an object is (or can be cast into a) Valkyrie::ID
+    # @return [Valkyrie::ID]
+    # @raise [ArgumentError]
+    def validate_id(id)
+      id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+      raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    end
 
-      # Resolve a URI for an LDP resource in Fedora and construct a Valkyrie::Resource
-      # @param uri [RDF::URI]
-      # @return [Valkyrie::Resource]
-      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
-      def resource_from_uri(uri)
-        resource = Ldp::Resource.for(connection, uri, connection.get(uri))
-        resource_factory.to_resource(object: resource)
-      rescue ::Ldp::Gone, ::Ldp::NotFound
-        raise ::Valkyrie::Persistence::ObjectNotFoundError
-      end
+    # Resolve a URI for an LDP resource in Fedora and construct a Valkyrie::Resource
+    # @param uri [RDF::URI]
+    # @return [Valkyrie::Resource]
+    # @raise [Valkyrie::Persistence::ObjectNotFoundError]
+    def resource_from_uri(uri)
+      resource = Ldp::Resource.for(connection, uri, connection.get(uri))
+      resource_factory.to_resource(object: resource)
+    rescue ::Ldp::Gone, ::Ldp::NotFound
+      raise ::Valkyrie::Persistence::ObjectNotFoundError
+    end
 
-      # Ensures that a Valkyrie::Resource has been persisted
-      # @param resource [Valkyrie::Resource]
-      # @raise [ArgumentError]
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
-      end
+    # Ensures that a Valkyrie::Resource has been persisted
+    # @param resource [Valkyrie::Resource]
+    # @raise [ArgumentError]
+    def ensure_persisted(resource)
+      raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    end
   end
 end

data/lib/valkyrie/persistence/memory/persister.rb

@@ -5,7 +5,7 @@ module Valkyrie::Persistence::Memory
   # @note Documentation for persisters in general is maintained here.
   class Persister
     attr_reader :adapter
-    delegate :cache, to: :adapter
+    delegate :cache, :query_service, to: :adapter
 
     # @param adapter [Valkyrie::Persistence::Memory::MetadataAdapter] The memory adapter which
     #   holds the cache for this persister.
@@ -16,11 +16,18 @@ module Valkyrie::Persistence::Memory
 
     # Save a single resource.
     # @param resource [Valkyrie::Resource] The resource to save.
+    # @param external_resource [Boolean] Whether the resource to be saved comes
+    #   from a different metadata store. Allows a resource to be saved even if
+    #   it's not already in the store. For example, if you're indexing a
+    #   resource into Solr - it's saved in your primary metadata store, but not
+    #   in Solr, so it's okay if it doesn't exist in Solr but is marked as
+    #   persisted.
     # @return [Valkyrie::Resource] The resource with an `#id` value generated by the
     #   persistence backend.
     # @raise [Valkyrie::Persistence::StaleObjectError]
-    def save(resource:)
+    def save(resource:, external_resource: false)
       raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." unless valid_lock?(resource)
+      raise Valkyrie::Persistence::ObjectNotFoundError, "The object #{resource.id} is previously persisted but not found at save time." unless external_resource || valid_for_save?(resource)
 
       # duplicate the resource so we are not creating side effects on the caller's resource
       internal_resource = resource.dup
@@ -34,6 +41,15 @@ module Valkyrie::Persistence::Memory
       cache[internal_resource.id] = internal_resource
     end
 
+    # return true if resource is
+    # persisted and found
+    # or
+    # not persisted
+    def valid_for_save?(resource)
+      return true unless resource.persisted? # a new resource
+      query_service.find_by(id: resource.id).present? # a persisted resource must be found
+    end
+
     # Save a batch of resources.
     # @param resources [Array<Valkyrie::Resource>] List of resources to save.
     # @return [Array<Valkyrie::Resource>] List of resources with an `#id` value
@@ -62,46 +78,46 @@ module Valkyrie::Persistence::Memory
 
     private
 
-      def generate_id(resource)
-        resource.new(id: SecureRandom.uuid)
-      end
+    def generate_id(resource)
+      resource.new(id: SecureRandom.uuid)
+    end
 
-      # Convert all dates to DateTime in the UTC time zone for consistency.
-      def normalize_dates!(resource)
-        resource.attributes.each { |k, v| resource.send("#{k}=", normalize_date_values(v)) }
-      end
+    # Convert all dates to DateTime in the UTC time zone for consistency.
+    def normalize_dates!(resource)
+      resource.attributes.each { |k, v| resource.send("#{k}=", normalize_date_values(v)) }
+    end
 
-      def normalize_date_values(v)
-        return v.map { |val| normalize_date_value(val) } if v.is_a?(Array)
-        normalize_date_value(v)
-      end
+    def normalize_date_values(v)
+      return v.map { |val| normalize_date_value(val) } if v.is_a?(Array)
+      normalize_date_value(v)
+    end
 
-      def normalize_date_value(value)
-        return value.utc if value.is_a?(DateTime)
-        return value.to_datetime.utc if value.is_a?(Time)
-        value
-      end
+    def normalize_date_value(value)
+      return value.new_offset(0) if value.is_a?(DateTime)
+      return value.to_datetime.new_offset(0) if value.is_a?(Time)
+      value
+    end
 
-      # Create a new lock token based on the current timestamp.
-      def generate_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
-        resource.set_value(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK, token)
-      end
+    # Create a new lock token based on the current timestamp.
+    def generate_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
+      resource.set_value(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK, token)
+    end
 
-      # Check whether a resource is current.
-      def valid_lock?(resource)
-        return true unless resource.optimistic_locking_enabled?
+    # Check whether a resource is current.
+    def valid_lock?(resource)
+      return true unless resource.optimistic_locking_enabled?
 
-        cached_resource = cache[resource.id]
-        return true if cached_resource.blank?
+      cached_resource = cache[resource.id]
+      return true if cached_resource.blank?
 
-        resource_lock_tokens = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
-        resource_value = resource_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
-        return true if resource_value.blank?
+      resource_lock_tokens = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+      resource_value = resource_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
+      return true if resource_value.blank?
 
-        cached_value = cached_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first
-        cached_value == resource_value
-      end
+      cached_value = cached_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first
+      cached_value == resource_value
+    end
   end
 end

data/lib/valkyrie/persistence/memory/query_service.rb

@@ -51,11 +51,9 @@ module Valkyrie::Persistence::Memory
     def find_many_by_ids(ids:)
       ids = ids.uniq
       ids.map do |id|
-        begin
-          find_by(id: id)
-        rescue ::Valkyrie::Persistence::ObjectNotFoundError
-          nil
-        end
+        find_by(id: id)
+      rescue ::Valkyrie::Persistence::ObjectNotFoundError
+        nil
       end.reject(&:nil?)
     end
 
@@ -80,7 +78,7 @@ module Valkyrie::Persistence::Memory
     # @return integer. Count objects in the persistence backend
     #   with the given class.
     def count_all_of_model(model:)
-      cache.values.select { |obj| obj.is_a?(model) }.count
+      cache.values.count { |obj| obj.is_a?(model) }
     end
 
     # Get all members of a given resource.
@@ -105,11 +103,9 @@ module Valkyrie::Persistence::Memory
     #   `property` property on `resource`. Not necessarily in order.
     def find_references_by(resource:, property:, model: nil)
       refs = Array.wrap(resource[property]).map do |id|
-        begin
-          find_by(id: id)
-        rescue ::Valkyrie::Persistence::ObjectNotFoundError
-          nil
-        end
+        find_by(id: id)
+             rescue ::Valkyrie::Persistence::ObjectNotFoundError
+               nil
       end.reject(&:nil?)
       refs.uniq! unless ordered_property?(resource: resource, property: property)
       return refs unless model
@@ -159,27 +155,27 @@ module Valkyrie::Persistence::Memory
 
     private
 
-      # @return [Array<Valkyrie::ID>] a list of the identifiers of the member objects
-      def member_ids(resource:)
-        return [] unless resource.respond_to? :member_ids
-        resource.member_ids || []
-      end
+    # @return [Array<Valkyrie::ID>] a list of the identifiers of the member objects
+    def member_ids(resource:)
+      return [] unless resource.respond_to? :member_ids
+      resource.member_ids || []
+    end
 
-      # Determine whether or not a value is a Valkyrie ID
-      # @param [Object] id
-      # @return [Boolean]
-      def validate_id(id)
-        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
-      end
+    # Determine whether or not a value is a Valkyrie ID
+    # @param [Object] id
+    # @return [Boolean]
+    def validate_id(id)
+      raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    end
 
-      # Ensure that a given Valkyrie Resource has been persisted
-      # @param [Valkyrie::Resource] resource
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
-      end
+    # Ensure that a given Valkyrie Resource has been persisted
+    # @param [Valkyrie::Resource] resource
+    def ensure_persisted(resource)
+      raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
+    def ordered_property?(resource:, property:)
+      resource.ordered_attribute?(property)
+    end
   end
 end