valkyrie 0.1.0 → 1.0.0.rc1

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Fedora
   class Persister
+    # Responsible for converting {Valkyrie::Resource} to {LDP::Container::Basic}
     class ModelConverter
       attr_reader :resource, :adapter, :subject_uri
       delegate :connection, :connection_prefix, :base_path, to: :adapter
@@ -12,13 +13,21 @@ module Valkyrie::Persistence::Fedora
 
       def convert
         graph_resource.graph.delete([nil, nil, nil])
-        resource.attributes.each do |key, values|
-          output = property_converter.for(Property.new(subject_uri, key, values, adapter)).result
+        properties.each do |property|
+          values = resource_attributes[property]
+
+          output = property_converter.for(Property.new(subject_uri, property, values, adapter, resource)).result
           graph_resource.graph << output.to_graph
         end
         graph_resource
       end
 
+      def properties
+        resource_attributes.keys - [:new_record]
+      end
+
+      delegate :attributes, to: :resource, prefix: true
+
       def graph_resource
         @graph_resource ||= ::Ldp::Container::Basic.new(connection, subject, nil, base_path)
       end
@@ -32,25 +41,27 @@ module Valkyrie::Persistence::Fedora
       end
 
       class Property
-        attr_reader :key, :value, :subject, :adapter
+        attr_reader :key, :value, :subject, :adapter, :resource
+        delegate :schema, to: :adapter
 
-        def self.to_uri(key)
-          RDF::URI.new("http://example.com/predicate/#{key}")
-        end
-
-        def initialize(subject, key, value, adapter)
+        def initialize(subject, key, value, adapter, resource)
           @subject = subject
           @key = key
           @value = value
           @adapter = adapter
+          @resource = resource
         end
 
         def to_graph(graph = RDF::Graph.new)
           Array(value).each do |val|
-            graph << RDF::Statement.new(subject, self.class.to_uri(key), val)
+            graph << RDF::Statement.new(subject, predicate, val)
           end
           graph
         end
+
+        def predicate
+          schema.predicate_for(resource: resource, property: key)
+        end
       end
 
       class CompositeProperty
@@ -68,12 +79,13 @@ module Valkyrie::Persistence::Fedora
       end
 
       class GraphProperty
-        attr_reader :key, :graph, :subject, :adapter
-        def initialize(subject, key, graph, adapter)
+        attr_reader :key, :graph, :subject, :adapter, :resource
+        def initialize(subject, key, graph, adapter, resource)
           @subject = subject
           @key = key
           @graph = graph
           @adapter = adapter
+          @resource = resource
         end
 
         def to_graph(passed_graph = RDF::Graph.new)
@@ -93,7 +105,7 @@ module Valkyrie::Persistence::Fedora
         def result
           initialize_list
           apply_first_and_last
-          GraphProperty.new(value.subject, value.key, graph, value.adapter)
+          GraphProperty.new(value.subject, value.key, graph, value.adapter, value.resource)
         end
 
         def graph
@@ -108,7 +120,7 @@ module Valkyrie::Persistence::Fedora
 
         def initialize_list
           Array(value.value).each_with_index do |val, index|
-            ordered_list.insert_proxy_for_at(index, calling_mapper.for(Property.new(value.subject, :member_id, val, value.adapter)).result.value)
+            ordered_list.insert_proxy_for_at(index, calling_mapper.for(Property.new(value.subject, :member_id, val, value.adapter, value.resource)).result.value)
           end
         end
 
@@ -124,8 +136,8 @@ module Valkyrie::Persistence::Fedora
         end
 
         def result
-          nested_graph << RDF::Statement.new(value.subject, Property.to_uri(value.key), subject_uri)
-          GraphProperty.new(value.subject, value.key, nested_graph, value.adapter)
+          nested_graph << RDF::Statement.new(value.subject, value.predicate, subject_uri)
+          GraphProperty.new(value.subject, value.key, nested_graph, value.adapter, value.resource)
         end
 
         def nested_graph
@@ -137,51 +149,124 @@ module Valkyrie::Persistence::Fedora
         end
       end
 
-      class NestedInternalValkyrieID < ::Valkyrie::ValueMapper
+      class MappedFedoraValue < ::Valkyrie::ValueMapper
+        private
+
+          def map_value(converted_value:)
+            calling_mapper.for(
+              Property.new(
+                value.subject,
+                value.key,
+                converted_value,
+                value.adapter,
+                value.resource
+              )
+            ).result
+          end
+      end
+
+      class NestedInternalValkyrieID < MappedFedoraValue
         FedoraValue.register(self)
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Valkyrie::ID) && value.subject.to_s.include?("#")
         end
 
         def result
-          calling_mapper.for(Property.new(value.subject, value.key, RDF::Literal.new(value.value, datatype: RDF::URI("http://example.com/predicate/valkyrie_id")), value.adapter)).result
+          map_value(converted_value: RDF::Literal.new(
+            value.value,
+            datatype: PermissiveSchema.valkyrie_id
+          ))
         end
       end
 
-      class InternalValkyrieID < ::Valkyrie::ValueMapper
+      class InternalValkyrieID < MappedFedoraValue
         FedoraValue.register(self)
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Valkyrie::ID) && !value.value.to_s.include?("://")
         end
 
         def result
-          calling_mapper.for(Property.new(value.subject, value.key, value.adapter.id_to_uri(value.value), value.adapter)).result
+          map_value(converted_value: value.adapter.id_to_uri(value.value))
+        end
+      end
+
+      class BooleanValue < MappedFedoraValue
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && ([true, false].include? value.value)
+        end
+
+        def result
+          map_value(converted_value: RDF::Literal.new(
+            value.value,
+            datatype: PermissiveSchema.valkyrie_bool
+          ))
+        end
+      end
+
+      class IntegerValue < MappedFedoraValue
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Integer)
+        end
+
+        def result
+          map_value(converted_value: RDF::Literal.new(
+            value.value,
+            datatype: PermissiveSchema.valkyrie_int
+          ))
+        end
+      end
+
+      class DateTimeValue < MappedFedoraValue
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(DateTime)
+        end
+
+        def result
+          map_value(converted_value: RDF::Literal.new(
+            value.value,
+            datatype: PermissiveSchema.valkyrie_datetime
+          ))
         end
       end
 
-      class TimeValue < ::Valkyrie::ValueMapper
+      # technically valkyrie does not support time, but when other persister support time
+      #  this code will make fedora compliant
+      #
+      #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+      class TimeValue < MappedFedoraValue
         FedoraValue.register(self)
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Time)
         end
 
         def result
-          calling_mapper.for(Property.new(value.subject, value.key, value.value.to_datetime, value.adapter)).result
+          # cast it to datetime for storage, to preserve miliseconds and date
+          map_value(converted_value:
+              RDF::Literal.new(
+                value.value.to_datetime,
+                datatype: PermissiveSchema.valkyrie_time
+              ))
         end
       end
 
-      class IdentifiableValue < ::Valkyrie::ValueMapper
+      class IdentifiableValue < MappedFedoraValue
         FedoraValue.register(self)
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Valkyrie::ID)
         end
 
         def result
-          calling_mapper.for(Property.new(value.subject, value.key, RDF::Literal.new(value.value, datatype: RDF::URI("http://example.com/predicate/valkyrie_id")), value.adapter)).result
+          map_value(converted_value: RDF::Literal.new(
+            value.value,
+            datatype: PermissiveSchema.valkyrie_id
+          ))
         end
       end
 
-      class EnumerableValue < ::Valkyrie::ValueMapper
+      class EnumerableValue < MappedFedoraValue
         FedoraValue.register(self)
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Array)
@@ -189,7 +274,7 @@ module Valkyrie::Persistence::Fedora
 
         def result
           new_values = value.value.map do |val|
-            calling_mapper.for(Property.new(value.subject, value.key, val, value.adapter)).result
+            map_value(converted_value: val)
           end
           CompositeProperty.new(new_values)
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Fedora
   class Persister
+    # Responsible for converting {LDP::Container::Basic} to {RDF::Resource}
     class OrmConverter
       attr_reader :object, :adapter
       delegate :graph, to: :object
@@ -14,8 +15,9 @@ module Valkyrie::Persistence::Fedora
       end
 
       def attributes
-        GraphToAttributes.new(graph: graph, adapter: adapter).convert.merge(id:
-                                                                            id)
+        GraphToAttributes.new(graph: graph, adapter: adapter)
+                         .convert
+                         .merge(id: id, new_record: false)
       end
 
       def id
@@ -24,7 +26,7 @@ module Valkyrie::Persistence::Fedora
 
       def id_property
         return unless object.subject_uri.to_s.include?("#")
-        object.graph.query([RDF::URI(""), RDF::URI("http://example.com/predicate/id"), nil]).to_a.first.try(:object).to_s
+        object.graph.query([RDF::URI(""), PermissiveSchema.id, nil]).to_a.first.try(:object).to_s
       end
 
       class GraphToAttributes
@@ -95,7 +97,7 @@ module Valkyrie::Persistence::Fedora
           end
 
           def result
-            value.statement.predicate = ::RDF::URI("http://example.com/predicate/member_ids")
+            value.statement.predicate = PermissiveSchema.member_ids
             values = OrderedList.new(scope, head, tail, adapter).to_a.map(&:proxy_for)
             values = values.map do |val|
               calling_mapper.for(Property.new(statement: RDF::Statement.new(value.statement.subject, value.statement.predicate, val), scope: value.scope, adapter: value.adapter)).result
@@ -159,14 +161,14 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
-        class IntegerValue < ::Valkyrie::ValueMapper
+        class BooleanValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
-            value.statement.object.is_a?(RDF::Literal) && value.statement.object.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#integer")
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.language.blank? && value.statement.object.datatype == PermissiveSchema.valkyrie_bool
           end
 
           def result
-            value.statement.object = value.statement.object.to_i
+            value.statement.object = value.statement.object.value.casecmp("true").zero?
             calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
           end
         end
@@ -174,7 +176,7 @@ module Valkyrie::Persistence::Fedora
         class DateTimeValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
-            value.statement.object.is_a?(RDF::Literal::DateTime)
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.language.blank? && value.statement.object.datatype == PermissiveSchema.valkyrie_datetime
           end
 
           def result
@@ -183,6 +185,18 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
+        class IntegerValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.language.blank? && value.statement.object.datatype == PermissiveSchema.valkyrie_int
+          end
+
+          def result
+            value.statement.object = value.statement.object.value.to_i
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
         class LiteralValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
@@ -195,10 +209,26 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
+        # technically valkyrie does not support time, but when other persister support time
+        #  this code will make fedora compliant
+        #
+        #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+        class TimeValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.language.blank? && value.statement.object.datatype == PermissiveSchema.valkyrie_time
+          end
+
+          def result
+            value.statement.object = Time.parse(value.statement.object.to_s).utc
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
         class ValkyrieIDValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
-            value.statement.object.is_a?(RDF::Literal) && value.statement.object.datatype == RDF::URI("http://example.com/predicate/valkyrie_id")
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.datatype == PermissiveSchema.valkyrie_id
           end
 
           def result
@@ -221,8 +251,9 @@ module Valkyrie::Persistence::Fedora
 
         class InternalModelValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
+
           def self.handles?(value)
-            value.statement.predicate.to_s == "http://example.com/predicate/internal_resource"
+            value.statement.predicate == value.adapter.schema.predicate_for(property: :internal_resource, resource: nil)
           end
 
           def result
@@ -233,7 +264,7 @@ module Valkyrie::Persistence::Fedora
         class CreatedAtValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
-            value.statement.predicate.to_s == "http://example.com/predicate/created_at"
+            value.statement.predicate == value.adapter.schema.predicate_for(property: :created_at, resource: nil)
           end
 
           def result
@@ -244,7 +275,7 @@ module Valkyrie::Persistence::Fedora
         class UpdatedAtValue < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
-            value.statement.predicate.to_s == "http://example.com/predicate/updated_at"
+            value.statement.predicate == value.adapter.schema.predicate_for(property: :updated_at, resource: nil)
           end
 
           def result
@@ -258,7 +289,8 @@ module Valkyrie::Persistence::Fedora
 
         class Applicator
           attr_reader :property
-          delegate :statement, to: :property
+          delegate :statement, :adapter, to: :property
+          delegate :schema, to: :adapter
           def initialize(property)
             @property = property
           end
@@ -270,9 +302,10 @@ module Valkyrie::Persistence::Fedora
           end
 
           def key
-            key = statement.predicate.to_s
+            predicate = statement.predicate.to_s
+            key = schema.property_for(resource: nil, predicate: predicate)
             namespaces.each do |namespace|
-              key = key.gsub(/^#{namespace}/, '')
+              key = key.to_s.gsub(/^#{namespace}/, '')
             end
             key
           end
@@ -302,8 +335,7 @@ module Valkyrie::Persistence::Fedora
           def namespaces
             [
               "http://www.fedora.info/definitions/v4/",
-              "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-              "http://example.com/predicate/"
+              "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             ]
           end
 

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Fedora
   class Persister
+    # Provides access to generic methods for converting to/from
+    # {Valkyrie::Resource} and {LDP::Container::Basic}.
     class ResourceFactory
       require 'valkyrie/persistence/fedora/persister/model_converter'
       require 'valkyrie/persistence/fedora/persister/orm_converter'

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Fedora
+  # Query Service for Fedora MetadataAdapter
   class QueryService
     attr_reader :adapter
     delegate :connection, :resource_factory, to: :adapter
@@ -7,7 +8,10 @@ module Valkyrie::Persistence::Fedora
       @adapter = adapter
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#find_by)
     def find_by(id:)
+      id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+      validate_id(id)
       uri = adapter.id_to_uri(id)
       begin
         resource = Ldp::Resource.for(connection, uri, connection.get(uri))
@@ -17,6 +21,18 @@ module Valkyrie::Persistence::Fedora
       end
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#find_many_by_ids)
+    def find_many_by_ids(ids:)
+      ids.map do |id|
+        begin
+          find_by(id: id)
+        rescue ::Valkyrie::Persistence::ObjectNotFoundError
+          nil
+        end
+      end.reject(&:nil?)
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
     def find_parents(resource:)
       content = content_with_inbound(id: resource.id)
       parent_ids = content.graph.query([nil, RDF::Vocab::ORE.proxyFor, nil]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
@@ -31,12 +47,19 @@ module Valkyrie::Persistence::Fedora
       ]
     end
 
-    def find_members(resource:)
-      Array(resource.member_ids).lazy.map do |id|
+    # (see Valkyrie::Persistence::Memory::QueryService#find_members)
+    def find_members(resource:, model: nil)
+      return [] unless resource.respond_to? :member_ids
+      result = Array(resource.member_ids).lazy.map do |id|
         find_by(id: id)
       end.select(&:present?)
+      return result unless model
+      result.select { |obj| obj.is_a?(model) }
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all)
+    #
+    # @note This requires iterating over every resource in Fedora.
     def find_all
       resource = Ldp::Resource.for(connection, adapter.base_path, connection.get(adapter.base_path))
       ids = resource.graph.query([nil, RDF::Vocab::LDP.contains, nil]).map(&:object).map { |x| adapter.uri_to_id(x) }
@@ -47,12 +70,16 @@ module Valkyrie::Persistence::Fedora
       []
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all_of_model)
+    #
+    # @note This requires iterating over every resource in Fedora.
     def find_all_of_model(model:)
       find_all.select do |m|
         m.is_a?(model)
       end
     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|
         find_by(id: id)
@@ -68,13 +95,29 @@ module Valkyrie::Persistence::Fedora
       end
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#find_inverse_references_by)
     def find_inverse_references_by(resource:, property:)
+      ensure_persisted(resource)
       content = content_with_inbound(id: resource.id)
-      property_uri = RDF::URI("http://example.com/predicate/#{property}")
+      property_uri =  adapter.schema.predicate_for(property: property, resource: nil)
       ids = content.graph.query([nil, property_uri, nil]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
       ids.lazy.map do |id|
         find_by(id: id)
       end
     end
+
+    def custom_queries
+      @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
+    end
+
+    private
+
+      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
   end
 end