valkyrie 2.0.0 → 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
@@ -488,10 +488,9 @@ module Valkyrie::Persistence::Fedora
         # @return [Valkyrie::Persistence::Fedora::Persister::ModelConverter::Property]
         def result
           # cast it to datetime for storage, to preserve milliseconds and date
-          # @todo Remove strftime when https://github.com/ruby-rdf/rdf/issues/394 is closed.
           map_value(converted_value:
               RDF::Literal.new(
-                value.value.to_datetime.strftime("%Y-%m-%dT%H:%M:%S.%N%z"),
+                value.value.to_datetime,
                 datatype: PermissiveSchema.valkyrie_time
               ))
         end

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
 
@@ -86,11 +84,18 @@ module Valkyrie::Persistence::Fedora
       end
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#count_all_of_model)
+    def count_all_of_model(model:)
+      find_all_of_model(model: model).count
+    end
+
     # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
-    def find_references_by(resource:, property:)
-      (resource[property] || []).select { |x| x.is_a?(Valkyrie::ID) }.lazy.map do |id|
+    def find_references_by(resource:, property:, model: nil)
+      objects = (resource[property] || []).select { |x| x.is_a?(Valkyrie::ID) }.lazy.map do |id|
         find_by(id: id)
       end
+      return objects unless model
+      objects.select { |obj| obj.is_a?(model) }
     end
 
     # Retrieves the RDF graph for the LDP container for a resource
@@ -111,15 +116,16 @@ module Valkyrie::Persistence::Fedora
     # Find all resources referencing a given resource (e. g. parents)
     # *This is done by iterating through the ID of each resource referencing the resource in the query, and requesting each resource over the HTTP*
     # *Also, an initial request is made to find the URIs of the resources referencing the resource in the query*
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    def find_inverse_references_by(resource: nil, id: nil, property:, model: nil)
       raise ArgumentError, "Provide resource or id" unless resource || id
       ensure_persisted(resource) if resource
       resource ||= find_by(id: id)
-      if ordered_property?(resource: resource, property: property)
-        find_inverse_references_by_ordered(resource: resource, property: property)
-      else
-        find_inverse_references_by_unordered(resource: resource, property: property)
-      end
+      ids = find_inverse_reference_ids_by_unordered(resource: resource, property: property).uniq
+      objects_from_unordered = ids.lazy.map { |ref_id| find_by(id: ref_id) }
+      objects_from_ordered = find_inverse_references_by_ordered(resource: resource, property: property, ignore_ids: ids)
+      objects = [objects_from_unordered, objects_from_ordered].lazy.flat_map(&:lazy)
+      return objects unless model
+      objects.select { |obj| obj.is_a?(model) }
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#custom_queries)
@@ -129,49 +135,44 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      def find_inverse_references_by_unordered(resource:, property:)
-        content = content_with_inbound(id: resource.id)
-        property_uri = adapter.schema.predicate_for(property: property, resource: nil)
-        ids = 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) }
-        ids.uniq!
-        ids.lazy.map { |id| find_by(id: id) }
-      end
-
-      def find_inverse_references_by_ordered(resource:, property:)
-        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.lazy.map { |id| find_by(id: id) }.select { |o| o[property].include?(resource.id) }
-      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
 
-      # 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
+    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
 
-      # 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 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 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
+    # 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
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Memory
+  # Query Service for the memory metadata adapter.
+  # @see Valkyrie::Persistence::Memory
+  # @note Documentation for Query Services in general is maintained here.
   class QueryService
-    # Query Service for the memory metadata adapter.
-    # @see Valkyrie::Persistence::Memory
-    # @note Documentation for Query Services in general is maintained here.
     attr_reader :adapter, :query_handlers
     delegate :cache, to: :adapter
 
@@ -27,7 +27,9 @@ module Valkyrie::Persistence::Memory
       cache[id] || raise(::Valkyrie::Persistence::ObjectNotFoundError)
     end
 
-    # Get a single resource by `alternate_identifier`.
+    # Get a single resource by `alternate_identifier`. Alternate identifiers are identifiers (like NOIDs,
+    # DOIs, ARKs, etc.) that are not the system-generated ID, but might be used to identify a resource in an
+    # application (e.g., to make shorter URLs).
     # @param alternate_identifier [Valkyrie::ID] The alternate identifier to query for.
     # @raise [Valkyrie::Persistence::ObjectNotFoundError] Raised when the alternate identifier
     #   isn't in the persistence backend.
@@ -49,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
 
@@ -73,9 +73,17 @@ module Valkyrie::Persistence::Memory
       end
     end
 
+    # Count all objects of a given model.
+    # @param model [Class] Class to query for.
+    # @return integer. Count objects in the persistence backend
+    #   with the given class.
+    def count_all_of_model(model:)
+      cache.values.count { |obj| obj.is_a?(model) }
+    end
+
     # Get all members of a given resource.
     # @param resource [Valkyrie::Resource] Model whose members are being searched for.
-    # @param model [Class] Class to query for. (optional)
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @return [Array<Valkyrie::Resource>] child objects of type `model` referenced by
     #   `resource`'s `member_ids` method. Returned in order.
     def find_members(resource:, model: nil)
@@ -90,36 +98,41 @@ module Valkyrie::Persistence::Memory
     # @param resource [Valkyrie::Resource] Model whose property is being searched.
     # @param property [Symbol] Property which, on the `resource`, contains {Valkyrie::ID}s which are
     #   to be de-referenced.
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @return [Array<Valkyrie::Resource>] All objects which are referenced by the
     #   `property` property on `resource`. Not necessarily in order.
-    def find_references_by(resource:, property:)
+    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)
-      refs
+      return refs unless model
+      refs.select { |obj| obj.is_a?(model) }
     end
 
     # Get all resources which link to a resource with a given property.
     # @param resource [Valkyrie::Resource] The resource which is being referenced by
-    #   other resources.
+    #   other resources. Requires either resource or id parameter to be specified.
+    # @param id [Valkyrie::ID] ID of the resource which is being reference by other
+    #   resources. Requires either resource or id parameter to be specified.
     # @param property [Symbol] The property which, on other resources, is
     #   referencing the given `resource`
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @raise [ArgumentError] Raised when the ID is not in the persistence backend.
     # @return [Array<Valkyrie::Resource>] All resources in the persistence backend
     #   which have the ID of the given `resource` in their `property` property. Not
     #   in order.
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    def find_inverse_references_by(resource: nil, id: nil, property:, model: nil)
       raise ArgumentError, "Provide resource or id" unless resource || id
       ensure_persisted(resource) if resource
       id ||= resource.id
-      find_all.select do |obj|
+      result = find_all.select do |obj|
         Array.wrap(obj[property]).include?(id)
       end
+      return result unless model
+      result.select { |obj| obj.is_a?(model) }
     end
 
     # Find all parents of a given resource.
@@ -142,22 +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
 
-      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
 
-      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