valkyrie 0.0.0 → 0.1.0

data/lib/valkyrie/local_file_service.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Valkyrie
+  class LocalFileService
+    # @param [String] file_name path to the file
+    # @param [Hash] _options
+    # @yield [File] opens the file and yields it to the block
+    def self.call(file_name, _options)
+      yield File.open(file_name)
+    end
+  end
+end

data/lib/valkyrie/metadata_adapter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Valkyrie
+  class MetadataAdapter
+    class_attribute :adapters
+    self.adapters = {}
+    class << self
+      # Register an adapter by a short name.
+      # @param adapter [#persister,#query_service] Adapter to register.
+      # @param short_name [Symbol] Name to register it under.
+      def register(adapter, short_name)
+        adapters[short_name.to_sym] = adapter
+      end
+
+      # Find an adapter by its short name.
+      # @param short_name [Symbol]
+      # @return [#persister,#query_service]
+      def find(short_name)
+        adapters[short_name.to_sym]
+      end
+    end
+  end
+end

data/lib/valkyrie/persist_derivatives.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Valkyrie
+  class PersistDerivatives < Hydra::Derivatives::PersistOutputFileService
+    # Persists a derivative to the local file system.
+    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.
+    # This service is an alternative to the default Hydra::Derivatives::PersistOutputFileService.
+    # This service will always update existing and does not do versioning of persisted files.
+    #
+    # @param [#read] stream the derivative filestream
+    # @param [Hash] directives
+    # @option directives [String] :url a url to the file destination
+    def self.call(stream, directives)
+      output_file(directives) do |output|
+        IO.copy_stream(stream, output)
+      end
+    end
+
+    # Open the output file to write and yield the block to the
+    # file. It makes the directories in the path if necessary.
+    def self.output_file(directives, &blk)
+      raise ArgumentError, "No :url was provided in the transcoding directives" unless directives.key?(:url)
+      uri = URI(directives.fetch(:url))
+      raise ArgumentError, "Must provide a file uri" unless uri.scheme == 'file'
+      output_file_dir = File.dirname(uri.path)
+      FileUtils.mkdir_p(output_file_dir) unless File.directory?(output_file_dir)
+      File.open(uri.path, 'wb', &blk)
+    end
+  end
+end

data/lib/valkyrie/persistence.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Valkyrie
+  module Persistence
+    require 'valkyrie/persistence/memory'
+    require 'valkyrie/persistence/postgres'
+    require 'valkyrie/persistence/solr'
+    require 'valkyrie/persistence/fedora'
+    require 'valkyrie/persistence/composite_persister'
+    require 'valkyrie/persistence/delete_tracking_buffer'
+    require 'valkyrie/persistence/buffered_persister'
+    class ObjectNotFoundError < StandardError
+    end
+  end
+end

data/lib/valkyrie/persistence/buffered_persister.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  class BufferedPersister
+    attr_reader :persister, :buffer_class
+    delegate :adapter, to: :persister
+    def initialize(persister, buffer_class: Valkyrie::Persistence::DeleteTrackingBuffer)
+      @persister = persister
+      @buffer_class = buffer_class
+    end
+
+    def save(resource:)
+      persister.save(resource: resource)
+    end
+
+    def save_all(resources:)
+      persister.save_all(resources: resources)
+    end
+
+    def delete(resource:)
+      persister.delete(resource: resource)
+    end
+
+    def with_buffer
+      memory_buffer = buffer_class.new
+      yield [Valkyrie::Persistence::CompositePersister.new(self, memory_buffer.persister), memory_buffer]
+    end
+  end
+end

data/lib/valkyrie/persistence/composite_persister.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  ##
+  # Wrap up multiple persisters under a common interface, to transparently
+  # persist to multiple places at once.
+  class CompositePersister
+    attr_reader :persisters
+    def initialize(*persisters)
+      @persisters = persisters
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save)
+    def save(resource:)
+      persisters.inject(resource) { |m, persister| persister.save(resource: m) }
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save_all)
+    def save_all(resources:)
+      resources.map do |resource|
+        save(resource: resource)
+      end
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#delete)
+    def delete(resource:)
+      persisters.inject(resource) { |m, persister| persister.delete(resource: m) }
+    end
+  end
+end

data/lib/valkyrie/persistence/delete_tracking_buffer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  class DeleteTrackingBuffer < Valkyrie::Persistence::Memory::MetadataAdapter
+    def persister
+      @persister ||= DeleteTrackingBuffer::Persister.new(self)
+    end
+
+    class Persister < Valkyrie::Persistence::Memory::Persister
+      attr_reader :deletes
+      def initialize(*args)
+        @deletes = []
+        super
+      end
+
+      def delete(resource:)
+        @deletes << resource
+        super
+      end
+    end
+  end
+end

data/lib/valkyrie/persistence/fedora.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  module Fedora
+    require 'valkyrie/persistence/fedora/metadata_adapter'
+    require 'valkyrie/persistence/fedora/persister'
+    require 'valkyrie/persistence/fedora/query_service'
+    require 'valkyrie/persistence/fedora/ordered_list'
+    require 'valkyrie/persistence/fedora/ordered_reader'
+    require 'valkyrie/persistence/fedora/list_node'
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class ListNode
+    attr_reader :rdf_subject, :graph
+    attr_accessor :prev, :next, :target
+    attr_writer :next_uri, :prev_uri
+    attr_accessor :proxy_in, :proxy_for
+    attr_reader :adapter
+    def initialize(node_cache, rdf_subject, adapter, graph = RDF::Repository.new)
+      @rdf_subject = rdf_subject
+      @graph = graph
+      @node_cache = node_cache
+      @adapter = adapter
+      Builder.new(rdf_subject, graph).populate(self)
+    end
+
+    # Returns the next proxy or a tail sentinel.
+    # @return [ActiveFedora::Orders::ListNode]
+    def next
+      @next ||=
+        if next_uri
+          node_cache.fetch(next_uri) do
+            node = self.class.new(node_cache, next_uri, adapter, graph)
+            node.prev = self
+            node
+          end
+        end
+    end
+
+    # Returns the previous proxy or a head sentinel.
+    # @return [ActiveFedora::Orders::ListNode]
+    def prev
+      @prev ||= node_cache.fetch(prev_uri) if prev_uri
+    end
+
+    # Graph representation of node.
+    # @return [ActiveFedora::Orders::ListNode::Resource]
+    def to_graph
+      return RDF::Graph.new if target_id.blank?
+      g = Resource.new(rdf_subject)
+      g.proxy_for = target_uri
+      g.proxy_in = proxy_in.try(:uri)
+      g.next = self.next.try(:rdf_subject)
+      g.prev = prev.try(:rdf_subject)
+      g
+    end
+
+    def target_uri
+      adapter.id_to_uri(target_id.to_s)
+    end
+
+    def target_id
+      adapter.uri_to_id(proxy_for)
+    end
+
+    private
+
+      attr_reader :next_uri, :prev_uri, :graph, :node_cache
+
+      class Builder
+        attr_reader :uri, :graph
+        def initialize(uri, graph)
+          @uri = uri
+          @graph = graph
+        end
+
+        def populate(instance)
+          instance.proxy_for = resource.proxy_for.first
+          instance.proxy_in = resource.proxy_in.first
+          instance.next_uri = resource.next.first
+          instance.prev_uri = resource.prev.first
+        end
+
+        private
+
+          def resource
+            @resource ||= Resource.new(uri, data: graph)
+          end
+      end
+
+      class Resource < ActiveTriples::Resource
+        property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor, cast: false
+        property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn, cast: false
+        property :next, predicate: ::RDF::Vocab::IANA.next, cast: false
+        property :prev, predicate: ::RDF::Vocab::IANA.prev, cast: false
+      end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  class MetadataAdapter
+    attr_reader :connection, :base_path
+    def initialize(connection:, base_path: "/")
+      @connection = connection
+      @base_path = base_path
+    end
+
+    def query_service
+      Valkyrie::Persistence::Fedora::QueryService.new(adapter: self)
+    end
+
+    def persister
+      Valkyrie::Persistence::Fedora::Persister.new(adapter: self)
+    end
+
+    def resource_factory
+      Valkyrie::Persistence::Fedora::Persister::ResourceFactory.new(adapter: self)
+    end
+
+    def uri_to_id(uri)
+      Valkyrie::ID.new(uri.to_s.gsub(/^.*\//, ''))
+    end
+
+    def id_to_uri(id)
+      RDF::URI("#{connection_prefix}/#{pair_path(id)}/#{id}")
+    end
+
+    def pair_path(id)
+      id.to_s.split("-").first.split("").each_slice(2).map(&:join).join("/")
+    end
+
+    def connection_prefix
+      "#{connection.options}/#{base_path}"
+    end
+
+    def wipe!
+      connection.delete(base_path)
+      connection.delete("#{base_path}/fcr:tombstone")
+    rescue => error
+      Valkyrie.logger.debug("Failed to wipe Fedora for some reason.") unless error.is_a?(::Ldp::NotFound)
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Fedora
+  ##
+  # Ruby object representation of an ORE doubly linked list.
+  class OrderedList
+    include Enumerable
+    attr_reader :graph, :head_subject, :tail_subject, :adapter
+    attr_writer :head, :tail
+    delegate :each, to: :ordered_reader
+    delegate :length, to: :to_a
+    # @param [::RDF::Enumerable] graph Enumerable where ORE statements are
+    #   stored.
+    # @param [::RDF::URI] head_subject URI of head node in list.
+    # @param [::RDF::URI] tail_subject URI of tail node in list.
+    def initialize(graph, head_subject, tail_subject, adapter)
+      @graph = graph
+      @head_subject = head_subject
+      @tail_subject = tail_subject
+      @node_cache ||= NodeCache.new
+      @adapter = adapter
+      @changed = false
+      tail
+    end
+
+    # @return [HeadSentinel] Sentinel for the top of the list. If not empty,
+    #  head.next is the first element.
+    def head
+      @head ||= HeadSentinel.new(self, next_node: build_node(head_subject))
+    end
+
+    # @return [TailSentinel] Sentinel for the bottom of the list. If not
+    #   empty, tail.prev is the first element.
+    def tail
+      @tail ||=
+        begin
+          if tail_subject
+            TailSentinel.new(self, prev_node: build_node(tail_subject))
+          else
+            head.next
+          end
+        end
+    end
+
+    # @param [Integer] loc Location to insert target at
+    # @param [String] proxy_for proxyFor to add
+    def insert_proxy_for_at(loc, proxy_for, proxy_in: nil)
+      node = build_node(new_node_subject)
+      node.proxy_for = proxy_for
+      node.proxy_in = proxy_in
+      if loc.zero?
+        append_to(node, head)
+      else
+        append_to(node, ordered_reader.take(loc).last)
+      end
+    end
+
+    # @return [::RDF::Graph] Graph representation of this list.
+    def to_graph
+      ::RDF::Graph.new.tap do |g|
+        array = to_a
+        array.map(&:to_graph).each do |resource_graph|
+          g << resource_graph
+        end
+      end
+    end
+
+    private
+
+      attr_reader :node_cache
+
+      def append_to(source, append_node)
+        source.prev = append_node
+        append_node.next.prev = source
+        source.next = append_node.next
+        append_node.next = source
+        @changed = true
+      end
+
+      def ordered_reader
+        OrderedReader.new(self)
+      end
+
+      def build_node(subject = nil)
+        return nil unless subject
+        node_cache.fetch(subject) do
+          ListNode.new(node_cache, subject, adapter, graph)
+        end
+      end
+
+      def new_node_subject
+        node = ::RDF::URI("##{::RDF::Node.new.id}")
+        node = ::RDF::URI("##{::RDF::Node.new.id}") while node_cache.key?(node)
+        node
+      end
+
+      class NodeCache
+        def initialize
+          @cache ||= {}
+        end
+
+        def fetch(uri)
+          @cache[uri] ||= yield if block_given?
+        end
+
+        def key?(key)
+          @cache.key?(key)
+        end
+      end
+
+      class Sentinel
+        attr_reader :parent
+        attr_writer :next, :prev
+        def initialize(parent, next_node: nil, prev_node: nil)
+          @parent = parent
+          @next = next_node
+          @prev = prev_node
+        end
+
+        attr_reader :next
+
+        attr_reader :prev
+
+        def nil?
+          true
+        end
+
+        def rdf_subject
+          nil
+        end
+      end
+
+      class HeadSentinel < Sentinel
+        def initialize(*args)
+          super
+          @next ||= TailSentinel.new(parent, prev_node: self)
+        end
+      end
+
+      class TailSentinel < Sentinel
+        def initialize(*args)
+          super
+          prev.next = self if prev && prev.next != self
+        end
+      end
+  end
+end