valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class Persister
+    class ResourceFactory
+      require 'valkyrie/persistence/fedora/persister/model_converter'
+      require 'valkyrie/persistence/fedora/persister/orm_converter'
+      attr_reader :adapter
+      def initialize(adapter:)
+        @adapter = adapter
+      end
+
+      def from_resource(resource:)
+        ModelConverter.new(resource: resource, adapter: adapter).convert
+      end
+
+      def to_resource(object:)
+        OrmConverter.new(object: object, adapter: adapter).convert
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class QueryService
+    attr_reader :adapter
+    delegate :connection, :resource_factory, to: :adapter
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def find_by(id:)
+      uri = adapter.id_to_uri(id)
+      begin
+        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
+    end
+
+    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) }
+      parent_ids.lazy.map do |id|
+        find_by(id: id)
+      end
+    end
+
+    def include_uris
+      [
+        ::RDF::Vocab::Fcrepo4.InboundReferences
+      ]
+    end
+
+    def find_members(resource:)
+      Array(resource.member_ids).lazy.map do |id|
+        find_by(id: id)
+      end.select(&:present?)
+    end
+
+    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) }
+      ids.lazy.map do |id|
+        find_by(id: id)
+      end
+    rescue ::Ldp::NotFound
+      []
+    end
+
+    def find_all_of_model(model:)
+      find_all.select do |m|
+        m.is_a?(model)
+      end
+    end
+
+    def find_references_by(resource:, property:)
+      (resource[property] || []).select { |x| x.is_a?(Valkyrie::ID) }.lazy.map do |id|
+        find_by(id: id)
+      end
+    end
+
+    def content_with_inbound(id:)
+      uri = adapter.id_to_uri(id)
+      connection.get(uri) do |req|
+        prefer_headers = Ldp::PreferHeaders.new(req.headers["Prefer"])
+        prefer_headers.include = prefer_headers.include | include_uris
+        req.headers["Prefer"] = prefer_headers.to_s
+      end
+    end
+
+    def find_inverse_references_by(resource:, property:)
+      content = content_with_inbound(id: resource.id)
+      property_uri = RDF::URI("http://example.com/predicate/#{property}")
+      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
+  end
+end

data/lib/valkyrie/persistence/memory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  module Memory
+    require 'valkyrie/persistence/memory/metadata_adapter'
+    require 'valkyrie/persistence/memory/persister'
+    require 'valkyrie/persistence/memory/query_service'
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Memory
+  class MetadataAdapter
+    attr_writer :cache
+
+    # @return [Valkyrie::Persistence::Memory::Persister] A memory persister for
+    #   this adapter.
+    def persister
+      Valkyrie::Persistence::Memory::Persister.new(self)
+    end
+
+    # @return [Valkyrie::Persistence::Memory::QueryService] A query service for
+    #   this adapter.
+    def query_service
+      Valkyrie::Persistence::Memory::QueryService.new(adapter: self)
+    end
+
+    def cache
+      @cache ||= {}
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Memory
+  class Persister
+    attr_reader :adapter
+    delegate :cache, to: :adapter
+    # @param adapter [Valkyrie::Persistence::Memory::MetadataAdapter] The memory adapter which
+    #   holds the cache for this persister.
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    # @param resource [Valkyrie::Resource] The resource to save.
+    # @return [Valkyrie::Resource] The resource with an `#id` value generated by the
+    #   persistence backend.
+    def save(resource:)
+      resource = generate_id(resource) if resource.id.blank?
+      resource.updated_at = Time.current
+      normalize_dates!(resource)
+      cache[resource.id] = resource
+    end
+
+    # @param resources [Array<Valkyrie::Resource>] List of resources to save.
+    # @return [Array<Valkyrie::Resource>] List of resources with an `#id` value
+    #   generated by the persistence backend.
+    def save_all(resources:)
+      resources.map do |resource|
+        save(resource: resource)
+      end
+    end
+
+    # @param resource [Valkyrie::Resource] The resource to delete from the persistence
+    #   backend.
+    def delete(resource:)
+      cache.delete(resource.id)
+    end
+
+    private
+
+      def generate_id(resource)
+        resource.new(id: SecureRandom.uuid, created_at: Time.current)
+      end
+
+      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_value(value)
+        return value.utc if value.is_a?(DateTime)
+        return value.to_datetime.utc if value.is_a?(Time)
+        value
+      end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Memory
+  class QueryService
+    attr_reader :adapter
+    delegate :cache, to: :adapter
+    # @param adapter [Valkyrie::Persistence::Memory::MetadataAdapter] The adapter which
+    #   has the cache to query.
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    # @param id [Valkyrie::ID] The ID to query for.
+    # @raise [Valkyrie::Persistence::ObjectNotFoundError] Raised when the ID
+    #   isn't in the persistence backend.
+    # @return [Valkyrie::Resource] The object being searched for.
+    def find_by(id:)
+      cache[id] || raise(::Valkyrie::Persistence::ObjectNotFoundError)
+    end
+
+    # @return [Array<Valkyrie::Resource>] All objects in the persistence backend.
+    def find_all
+      cache.values
+    end
+
+    # @param resource [Class] Class to query for.
+    # @return [Array<Valkyrie::Resource>] All objects in the persistence backend
+    #   with the given class.
+    def find_all_of_model(model:)
+      cache.values.select do |obj|
+        obj.is_a?(model)
+      end
+    end
+
+    # @param resource [Valkyrie::Resource] Model whose members are being searched for.
+    # @return [Array<Valkyrie::Resource>] All child objects referenced by `resource`'s
+    #   `member_ids` method. Returned in order.
+    def find_members(resource:)
+      member_ids(resource: resource).map do |id|
+        find_by(id: id)
+      end
+    end
+
+    # @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.
+    # @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:)
+      Array.wrap(resource[property]).map do |id|
+        find_by(id: id)
+      end
+    end
+
+    # @param resource [Valkyrie::Resource] The resource which is being referenced by
+    #   other resources.
+    # @param property [Symbol] The property which, on other resources, is
+    #   referencing the given `resource`
+    # @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:, property:)
+      find_all.select do |obj|
+        begin
+          Array.wrap(obj[property]).include?(resource.id)
+        rescue
+          false
+        end
+      end
+    end
+
+    # @param resource [Valkyrie::Resource] The resource whose parents are being searched
+    #   for.
+    # @return [Array<Valkyrie::Resource>] All resources which are parents of the given
+    #   `resource`. This means the resource's `id` appears in their `member_ids`
+    #   array.
+    def find_parents(resource:)
+      cache.values.select do |record|
+        member_ids(resource: record).include?(resource.id)
+      end
+    end
+
+    def member_ids(resource:)
+      resource.member_ids || []
+    end
+  end
+end

data/lib/valkyrie/persistence/postgres.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  module Postgres
+    require 'valkyrie/persistence/postgres/metadata_adapter'
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/persister'
+require 'valkyrie/persistence/postgres/query_service'
+module Valkyrie::Persistence::Postgres
+  class MetadataAdapter
+    # @return [Class] {Valkyrie::Persistence::Postgres::Persister}
+    def persister
+      Valkyrie::Persistence::Postgres::Persister.new(adapter: self)
+    end
+
+    # @return [Class] {Valkyrie::Persistence::Postgres::QueryService}
+    def query_service
+      Valkyrie::Persistence::Postgres::QueryService.new(adapter: self)
+    end
+
+    def resource_factory
+      Valkyrie::Persistence::Postgres::ResourceFactory
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/orm/resource'
+module Valkyrie::Persistence::Postgres
+  module ORM
+    def self.table_name_prefix
+      'orm_'
+    end
+  end
+end

data/lib/valkyrie/persistence/postgres/orm/resource.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres
+  module ORM
+    class Resource < ActiveRecord::Base
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres
+  class ORMConverter
+    attr_reader :orm_object
+    def initialize(orm_object)
+      @orm_object = orm_object
+    end
+
+    def convert!
+      @resource ||= attributes[:internal_resource].constantize.new(attributes)
+    end
+
+    # @return [Hash] Valkyrie-style hash of attributes.
+    def attributes
+      @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
+    end
+
+    def rdf_metadata
+      @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
+    end
+
+    class RDFMetadata
+      attr_reader :metadata
+      def initialize(metadata)
+        @metadata = metadata
+      end
+
+      def result
+        Hash[
+          metadata.map do |key, value|
+            [key, PostgresValue.for(value).result]
+          end
+        ]
+      end
+
+      class PostgresValue < ::Valkyrie::ValueMapper
+      end
+      # Converts {RDF::Literal} typed-literals from JSON-LD stored into an
+      #   {RDF::Literal}
+      class HashValue < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Hash) && value["@value"]
+        end
+
+        def result
+          RDF::Literal.new(value["@value"], language: value["@language"])
+        end
+      end
+
+      # Converts stored IDs into {Valkyrie::ID}s
+      class IDValue < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Hash) && value["id"] && !value["internal_resource"]
+        end
+
+        def result
+          Valkyrie::ID.new(value["id"])
+        end
+      end
+
+      # Converts stored URIs into {RDF::URI}s
+      class URIValue < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Hash) && value["@id"]
+        end
+
+        def result
+          ::RDF::URI.new(value["@id"])
+        end
+      end
+
+      # Converts nested records into {Valkyrie::Resource}s
+      class NestedRecord < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Hash) && value.keys.length > 1
+        end
+
+        def result
+          RDFMetadata.new(value).result.symbolize_keys
+        end
+      end
+
+      class DateValue < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          return false unless value.is_a?(String)
+          return false unless value[4] == "-"
+          year = value.to_s[0..3]
+          return false unless year.length == 4 && year.to_i.to_s == year
+          DateTime.iso8601(value)
+        rescue
+          false
+        end
+
+        def result
+          DateTime.iso8601(value).utc
+        end
+      end
+
+      class EnumeratorValue < ::Valkyrie::ValueMapper
+        PostgresValue.register(self)
+        def self.handles?(value)
+          value.respond_to?(:each)
+        end
+
+        def result
+          value.map do |value|
+            calling_mapper.for(value).result
+          end
+        end
+      end
+    end
+  end
+end