valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  ##
+  # Lazily iterates over a doubly linked list, fixing up nodes if necessary.
+  class OrderedReader
+    include Enumerable
+    attr_reader :root
+    def initialize(root)
+      @root = root
+    end
+
+    def each
+      proxy = first_head
+      while proxy
+        yield proxy unless proxy.nil?
+        next_proxy = proxy.next
+        next_proxy.try(:prev=, proxy) if next_proxy && next_proxy.prev != proxy
+        proxy = next_proxy
+      end
+    end
+
+    private
+
+      def first_head
+        root.head
+      end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class Persister
+    require 'valkyrie/persistence/fedora/persister/resource_factory'
+    attr_reader :adapter
+    delegate :connection, :base_path, :resource_factory, to: :adapter
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def save(resource:)
+      initialize_repository
+      resource.created_at ||= Time.current
+      resource.updated_at ||= Time.current
+      orm = resource_factory.from_resource(resource: resource)
+      if !orm.new? || resource.id
+        orm.update do |req|
+          req.headers["Prefer"] = "handling=lenient; received=\"minimal\""
+        end
+      else
+        orm.create
+      end
+      resource_factory.to_resource(object: orm)
+    end
+
+    def save_all(resources:)
+      resources.map do |resource|
+        save(resource: resource)
+      end
+    end
+
+    def delete(resource:)
+      orm = resource_factory.from_resource(resource: resource)
+      orm.delete
+      resource
+    end
+
+    def initialize_repository
+      @initialized ||=
+        begin
+          resource = ::Ldp::Container::Basic.new(connection, base_path, nil, base_path)
+          resource.save if resource.new?
+          true
+        end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class Persister
+    class ModelConverter
+      attr_reader :resource, :adapter, :subject_uri
+      delegate :connection, :connection_prefix, :base_path, to: :adapter
+      def initialize(resource:, adapter:, subject_uri: RDF::URI(""))
+        @resource = resource
+        @adapter = adapter
+        @subject_uri = subject_uri
+      end
+
+      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
+          graph_resource.graph << output.to_graph
+        end
+        graph_resource
+      end
+
+      def graph_resource
+        @graph_resource ||= ::Ldp::Container::Basic.new(connection, subject, nil, base_path)
+      end
+
+      def subject
+        adapter.id_to_uri(resource.id) if resource.try(:id)
+      end
+
+      def property_converter
+        FedoraValue
+      end
+
+      class Property
+        attr_reader :key, :value, :subject, :adapter
+
+        def self.to_uri(key)
+          RDF::URI.new("http://example.com/predicate/#{key}")
+        end
+
+        def initialize(subject, key, value, adapter)
+          @subject = subject
+          @key = key
+          @value = value
+          @adapter = adapter
+        end
+
+        def to_graph(graph = RDF::Graph.new)
+          Array(value).each do |val|
+            graph << RDF::Statement.new(subject, self.class.to_uri(key), val)
+          end
+          graph
+        end
+      end
+
+      class CompositeProperty
+        attr_reader :properties
+        def initialize(properties)
+          @properties = properties
+        end
+
+        def to_graph(graph = RDF::Graph.new)
+          properties.each do |property|
+            property.to_graph(graph)
+          end
+          graph
+        end
+      end
+
+      class GraphProperty
+        attr_reader :key, :graph, :subject, :adapter
+        def initialize(subject, key, graph, adapter)
+          @subject = subject
+          @key = key
+          @graph = graph
+          @adapter = adapter
+        end
+
+        def to_graph(passed_graph = RDF::Graph.new)
+          passed_graph << graph
+        end
+      end
+
+      class FedoraValue < ::Valkyrie::ValueMapper
+      end
+
+      class OrderedMembers < ::Valkyrie::ValueMapper
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.key == :member_ids && Array(value.value).present?
+        end
+
+        def result
+          initialize_list
+          apply_first_and_last
+          GraphProperty.new(value.subject, value.key, graph, value.adapter)
+        end
+
+        def graph
+          @graph ||= ordered_list.to_graph
+        end
+
+        def apply_first_and_last
+          return if ordered_list.to_a.empty?
+          graph << RDF::Statement.new(value.subject, ::RDF::Vocab::IANA.first, ordered_list.head.next.rdf_subject)
+          graph << RDF::Statement.new(value.subject, ::RDF::Vocab::IANA.last, ordered_list.tail.prev.rdf_subject)
+        end
+
+        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)
+          end
+        end
+
+        def ordered_list
+          @ordered_list ||= OrderedList.new(RDF::Graph.new, nil, nil, value.adapter)
+        end
+      end
+
+      class NestedProperty < ::Valkyrie::ValueMapper
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Hash) && value.value[:internal_resource]
+        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)
+        end
+
+        def nested_graph
+          @nested_graph ||= ModelConverter.new(resource: Valkyrie::Types::Anything[value.value], adapter: value.adapter, subject_uri: subject_uri).convert.graph
+        end
+
+        def subject_uri
+          @subject_uri ||= ::RDF::URI(RDF::Node.new.to_s.gsub("_:", "#"))
+        end
+      end
+
+      class NestedInternalValkyrieID < ::Valkyrie::ValueMapper
+        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
+        end
+      end
+
+      class InternalValkyrieID < ::Valkyrie::ValueMapper
+        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
+        end
+      end
+
+      class TimeValue < ::Valkyrie::ValueMapper
+        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
+        end
+      end
+
+      class IdentifiableValue < ::Valkyrie::ValueMapper
+        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
+        end
+      end
+
+      class EnumerableValue < ::Valkyrie::ValueMapper
+        FedoraValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Array)
+        end
+
+        def result
+          new_values = value.value.map do |val|
+            calling_mapper.for(Property.new(value.subject, value.key, val, value.adapter)).result
+          end
+          CompositeProperty.new(new_values)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class Persister
+    class OrmConverter
+      attr_reader :object, :adapter
+      delegate :graph, to: :object
+      def initialize(object:, adapter:)
+        @object = object
+        @adapter = adapter
+      end
+
+      def convert
+        Valkyrie::Types::Anything[attributes]
+      end
+
+      def attributes
+        GraphToAttributes.new(graph: graph, adapter: adapter).convert.merge(id:
+                                                                            id)
+      end
+
+      def id
+        id_property.present? ? Valkyrie::ID.new(id_property) : adapter.uri_to_id(object.subject_uri)
+      end
+
+      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
+      end
+
+      class GraphToAttributes
+        attr_reader :graph, :adapter
+        def initialize(graph:, adapter:)
+          @graph = graph
+          @adapter = adapter
+        end
+
+        def convert
+          graph.each do |statement|
+            FedoraValue.for(Property.new(statement: statement, scope: graph, adapter: adapter)).result.apply_to(attributes)
+          end
+          attributes
+        end
+
+        def attributes
+          @attributes ||= {}
+        end
+
+        class FedoraValue < ::Valkyrie::ValueMapper
+          def result
+            Applicator.new(value)
+          end
+        end
+
+        class BlacklistedValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.to_s.start_with?("http://www.w3.org/ns/ldp", "http://fedora.info")
+          end
+
+          def result
+            NullApplicator
+          end
+        end
+
+        class DifferentSubject < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.subject.to_s.include?("#")
+          end
+
+          def result
+            NullApplicator
+          end
+        end
+
+        class CompositeApplicator
+          attr_reader :applicators
+          def initialize(applicators)
+            @applicators = applicators
+          end
+
+          def apply_to(hsh)
+            applicators.each do |applicator|
+              applicator.apply_to(hsh)
+            end
+            hsh
+          end
+        end
+
+        class MemberID < ::Valkyrie::ValueMapper
+          delegate :scope, :adapter, to: :value
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.predicate == ::RDF::Vocab::IANA.first
+          end
+
+          def result
+            value.statement.predicate = ::RDF::URI("http://example.com/predicate/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
+            end
+            CompositeApplicator.new(values)
+          end
+
+          def head
+            scope.query([value.statement.subject, RDF::Vocab::IANA.first]).to_a.first.object
+          end
+
+          def tail
+            scope.query([value.statement.subject, RDF::Vocab::IANA.last]).to_a.first.object
+          end
+        end
+
+        class NestedValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::URI) && value.statement.object.to_s.include?("#") &&
+              (value.statement.object.to_s.start_with?("#") ||
+               value.statement.object.to_s.start_with?(value.adapter.connection_prefix))
+          end
+
+          def result
+            value.scope.each do |statement|
+              next unless statement.subject.to_s.include?("#")
+              subject = new_subject(statement)
+              graph << RDF::Statement.new(subject, statement.predicate, statement.object)
+            end
+            value.statement.object = resource
+            Applicator.new(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter))
+          end
+
+          def container
+            GraphContainer.new(graph, value.statement.object)
+          end
+
+          def resource
+            OrmConverter.new(object: container, adapter: value.adapter).convert
+          end
+
+          def new_subject(statement)
+            if statement.subject == value.statement.object
+              RDF::URI("")
+            else
+              statement.subject
+            end
+          end
+
+          def graph
+            @graph ||= RDF::Graph.new
+          end
+
+          class GraphContainer
+            attr_reader :graph, :subject_uri
+            def initialize(graph, subject_uri)
+              @graph = graph
+              @subject_uri = subject_uri
+            end
+          end
+        end
+
+        class IntegerValue < ::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")
+          end
+
+          def result
+            value.statement.object = value.statement.object.to_i
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
+        class DateTimeValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::Literal::DateTime)
+          end
+
+          def result
+            value.statement.object = ::DateTime.iso8601(value.statement.object.to_s).utc
+            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)
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.language.blank? && value.statement.object.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
+          end
+
+          def result
+            value.statement.object = value.statement.object.to_s
+            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")
+          end
+
+          def result
+            value.statement.object = Valkyrie::ID.new(value.statement.object.to_s)
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
+        class InternalURI < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::URI) && value.statement.object.to_s.start_with?(value.adapter.connection_prefix)
+          end
+
+          def result
+            value.statement.object = value.adapter.uri_to_id(value.statement.object)
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
+        class InternalModelValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.predicate.to_s == "http://example.com/predicate/internal_resource"
+          end
+
+          def result
+            SingleApplicator.new(value)
+          end
+        end
+
+        class CreatedAtValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.predicate.to_s == "http://example.com/predicate/created_at"
+          end
+
+          def result
+            NonStringSingleApplicator.new(value)
+          end
+        end
+
+        class UpdatedAtValue < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.predicate.to_s == "http://example.com/predicate/updated_at"
+          end
+
+          def result
+            NonStringSingleApplicator.new(value)
+          end
+        end
+
+        class NullApplicator
+          def self.apply_to(_hsh); end
+        end
+
+        class Applicator
+          attr_reader :property
+          delegate :statement, to: :property
+          def initialize(property)
+            @property = property
+          end
+
+          def apply_to(hsh)
+            return if blacklist?(key)
+            hsh[key.to_sym] ||= []
+            hsh[key.to_sym] += cast_array(values)
+          end
+
+          def key
+            key = statement.predicate.to_s
+            namespaces.each do |namespace|
+              key = key.gsub(/^#{namespace}/, '')
+            end
+            key
+          end
+
+          def blacklist?(key)
+            blacklist.each do |blacklist_item|
+              return true if key.start_with?(blacklist_item)
+            end
+            false
+          end
+
+          def cast_array(values)
+            if values.is_a?(Time)
+              [values]
+            else
+              Array(values)
+            end
+          end
+
+          def blacklist
+            [
+              "http://fedora.info/definitions",
+              "http://www.iana.org/assignments/relation/last"
+            ]
+          end
+
+          def namespaces
+            [
+              "http://www.fedora.info/definitions/v4/",
+              "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+              "http://example.com/predicate/"
+            ]
+          end
+
+          def values
+            statement.object
+          end
+        end
+
+        class SingleApplicator < Applicator
+          def apply_to(hsh)
+            hsh[key.to_sym] = values.to_s
+          end
+        end
+
+        class NonStringSingleApplicator < Applicator
+          def apply_to(hsh)
+            hsh[key.to_sym] = values
+          end
+        end
+
+        class Property
+          attr_reader :statement, :scope, :adapter
+          def initialize(statement:, scope:, adapter:)
+            @statement = statement
+            @scope = scope
+            @adapter = adapter
+          end
+        end
+      end
+    end
+  end
+end