valkyrie 2.1.1 → 2.1.2

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

@@ -325,21 +325,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,9 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
-        # Class for handling cases where blacklisted values should not be mapped
-        class BlacklistedValue < ::Valkyrie::ValueMapper
-          FedoraValue.register(self)
-
-          # Determines whether or not the value has a blacklisted namespace for the RDF statement object
+        # Class for handling cases where deny listed values should not be mapped
+        class DenylistedValue < ::Valkyrie::ValueMapper
+          # 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,12 +107,20 @@ 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
         end
 
+        # @deprecated
+        # Class for handling cases where deny listed values should not be mapped
+        # @see DenylistedValue
+        class BlacklistedValue < DenylistedValue
+          FedoraValue.register(self)
+          warn "[DEPRECATION] Samvera is deprecating '#{self}' in 3.0.0. Use #{DenylistedValue} instead."
+        end
+
         # Class for handling cases where the RDF subject of a Property references a separate resource using a hash URI
         class DifferentSubject < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
@@ -318,7 +324,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 +400,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 +528,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 +547,23 @@ module Valkyrie::Persistence::Fedora
             key
           end
 
-          # Determines whether or not a key is blacklisted for mapping
+          # @deprecated
+          # 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)
+            warn "[DEPRECATION] Samvera is deprecating '#{self.class}#blacklist?' in 3.0.0. Use #{self.class}#deny? instead."
+            deny?(key)
+          end
+
+          # 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 deny?(key)
+            denylist.each do |denylist_item|
+              return true if key.start_with?(denylist_item)
             end
             false
           end
@@ -556,16 +572,20 @@ 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
+          # @deprecated
+          # Retrieve a list of denied URIs for predicates
           # @return [Array<String>]
           def blacklist
+            warn "[DEPRECATION] Samvera is deprecating '#{self.class}#blacklist' in 3.0.0. Use #{self.class}#denylist instead."
+            denylist
+          end
+
+          # Retrieve a list of denied URIs for predicates
+          # @return [Array<String>]
+          def denylist
             [
               "http://fedora.info/definitions",
               "http://www.iana.org/assignments/relation/last"

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
 
@@ -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

@@ -62,46 +62,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

data/lib/valkyrie/persistence/postgres/orm_converter.rb

@@ -21,65 +21,65 @@ module Valkyrie::Persistence::Postgres
 
     private
 
-      # Construct a new Valkyrie Resource using the attributes retrieved from the database
-      # @return [Valkyrie::Resource]
-      def resource
-        resource_klass.new(
-          attributes.merge(
-            new_record: false,
-            Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
-          )
+    # Construct a new Valkyrie Resource using the attributes retrieved from the database
+    # @return [Valkyrie::Resource]
+    def resource
+      resource_klass.new(
+        attributes.merge(
+          new_record: false,
+          Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
         )
-      end
+      )
+    end
 
-      # Construct the optimistic lock token using the adapter and lock version for the Resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def lock_token
-        return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
-        @lock_token ||=
-          Valkyrie::Persistence::OptimisticLockToken.new(
-            adapter_id: resource_factory.adapter_id,
-            token: orm_object.lock_version
-          )
-      end
+    # Construct the optimistic lock token using the adapter and lock version for the Resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def lock_token
+      return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
+      @lock_token ||=
+        Valkyrie::Persistence::OptimisticLockToken.new(
+          adapter_id: resource_factory.adapter_id,
+          token: orm_object.lock_version
+        )
+    end
 
-      # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
-      def lock_token_warning
-        return nil unless resource_klass.optimistic_locking_enabled?
-        warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
-             "optimistic locking enabled, but the necessary migrations have not been run. \n" \
-             "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
-             "to enable this feature for Postgres."
-        nil
-      end
+    # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
+    def lock_token_warning
+      return nil unless resource_klass.optimistic_locking_enabled?
+      warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
+           "optimistic locking enabled, but the necessary migrations have not been run. \n" \
+           "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
+           "to enable this feature for Postgres."
+      nil
+    end
 
-      # Retrieve the Class used to construct the Valkyrie Resource
-      # @return [Class]
-      def resource_klass
-        Valkyrie.config.resource_class_resolver.call(internal_resource)
-      end
+    # Retrieve the Class used to construct the Valkyrie Resource
+    # @return [Class]
+    def resource_klass
+      Valkyrie.config.resource_class_resolver.call(internal_resource)
+    end
 
-      # Access the String for the Valkyrie Resource type within the attributes
-      # @return [String]
-      def internal_resource
-        attributes[:internal_resource]
-      end
+    # Access the String for the Valkyrie Resource type within the attributes
+    # @return [String]
+    def internal_resource
+      attributes[:internal_resource]
+    end
 
-      # @return [Hash] Valkyrie-style hash of attributes.
-      def attributes
-        @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
-      end
+    # @return [Hash] Valkyrie-style hash of attributes.
+    def attributes
+      @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
+    end
 
-      # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
-      # @return [Hash]
-      def rdf_metadata
-        @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
-      end
+    # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
+    # @return [Hash]
+    def rdf_metadata
+      @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
+    end
 
-      # Responsible for converting `metadata` JSON-B field in
-      # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
-      # for {Valkyrie::Resource}
-      class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
-      end
+    # Responsible for converting `metadata` JSON-B field in
+    # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
+    # for {Valkyrie::Resource}
+    class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
+    end
   end
 end