valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  ##
+  # Converts a solr hash to a {Valkyrie::Resource}
+  class ORMConverter
+    attr_reader :solr_document
+    def initialize(solr_document)
+      @solr_document = solr_document
+    end
+
+    def convert!
+      resource
+    end
+
+    def resource
+      resource_klass.new(attributes.symbolize_keys)
+    end
+
+    def resource_klass
+      internal_resource.constantize
+    end
+
+    def internal_resource
+      solr_document["internal_resource_ssim"].first
+    end
+
+    def attributes
+      attribute_hash.merge("id" => id, internal_resource: internal_resource, created_at: created_at, updated_at: updated_at)
+    end
+
+    def created_at
+      DateTime.parse(solr_document["created_at_dtsi"].to_s).utc
+    end
+
+    def updated_at
+      DateTime.parse(solr_document["timestamp"] || solr_document["created_at_dtsi"].to_s).utc
+    end
+
+    def id
+      solr_document["id"].gsub(/^id-/, '')
+    end
+
+    def attribute_hash
+      build_literals(strip_tsim(solr_document.select do |k, _v|
+        k.end_with?("tsim")
+      end))
+    end
+
+    def strip_tsim(hsh)
+      Hash[
+        hsh.map do |k, v|
+          [k.gsub("_tsim", ""), v]
+        end
+      ]
+    end
+
+    class Property
+      attr_reader :key, :value, :document
+      def initialize(key, value, document)
+        @key = key
+        @value = value
+        @document = document
+      end
+    end
+
+    def build_literals(hsh)
+      hsh.each_with_object({}) do |(key, value), output|
+        next if key.end_with?("_lang")
+        output[key] = SolrValue.for(Property.new(key, value, hsh)).result
+      end
+    end
+
+    class SolrValue < ::Valkyrie::ValueMapper
+    end
+
+    # Converts a stored language typed literal from two fields into one
+    #   {RDF::Literal}
+    class LanguagePropertyValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.is_a?(Property) && value.document["#{value.key}_lang"]
+      end
+
+      def result
+        value.value.zip(languages).map do |literal, language|
+          if language == "eng"
+            literal
+          else
+            RDF::Literal.new(literal, language: language)
+          end
+        end
+      end
+
+      def languages
+        value.document["#{value.key}_lang"]
+      end
+    end
+    class PropertyValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.is_a?(Property)
+      end
+
+      def result
+        calling_mapper.for(value.value).result
+      end
+    end
+    class EnumerableValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.respond_to?(:each)
+      end
+
+      def result
+        value.map do |element|
+          calling_mapper.for(element).result
+        end
+      end
+    end
+
+    # Converts a stored ID value in solr into a {Valkyrie::ID}
+    class IDValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.to_s.start_with?("id-")
+      end
+
+      def result
+        Valkyrie::ID.new(value.gsub(/^id-/, ''))
+      end
+    end
+
+    # Converts a stored URI value in solr into a {RDF::URI}
+    class URIValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.to_s.start_with?("uri-")
+      end
+
+      def result
+        ::RDF::URI.new(value.gsub(/^uri-/, ''))
+      end
+    end
+
+    # Converts a nested resource in solr into a {Valkyrie::Resource}
+    class NestedResourceValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.to_s.start_with?("serialized-")
+      end
+
+      def result
+        NestedResourceConverter.for(JSON.parse(json, symbolize_names: true)).result
+      end
+
+      def json
+        value.gsub(/^serialized-/, '')
+      end
+    end
+
+    class NestedResourceConverter < ::Valkyrie::ValueMapper
+    end
+
+    class NestedEnumerable < ::Valkyrie::ValueMapper
+      NestedResourceConverter.register(self)
+      def self.handles?(value)
+        value.is_a?(Array)
+      end
+
+      def result
+        value.map do |v|
+          calling_mapper.for(v).result
+        end
+      end
+    end
+
+    class NestedResourceID < ::Valkyrie::ValueMapper
+      NestedResourceConverter.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
+
+    class NestedResourceURI < ::Valkyrie::ValueMapper
+      NestedResourceConverter.register(self)
+      def self.handles?(value)
+        value.is_a?(Hash) && value[:@id]
+      end
+
+      def result
+        RDF::URI(value[:@id])
+      end
+    end
+
+    class NestedResourceLiteral < ::Valkyrie::ValueMapper
+      NestedResourceConverter.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
+
+    class NestedResourceHash < ::Valkyrie::ValueMapper
+      NestedResourceConverter.register(self)
+      def self.handles?(value)
+        value.is_a?(Hash)
+      end
+
+      def result
+        Hash[
+          value.map do |k, v|
+            [k, calling_mapper.for(v).result]
+          end
+        ]
+      end
+    end
+
+    # Converts an integer in solr into an {Integer}
+    class IntegerValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.to_s.start_with?("integer-")
+      end
+
+      def result
+        value.gsub(/^integer-/, '').to_i
+      end
+    end
+
+    # Converts a datetime in Solr into a {DateTime}
+    class DateTimeValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        return false unless value.to_s.start_with?("datetime-")
+        DateTime.iso8601(value.gsub(/^datetime-/, '')).utc
+      rescue
+        false
+      end
+
+      def result
+        DateTime.parse(value.gsub(/^datetime-/, '')).utc
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  require 'valkyrie/persistence/solr/repository'
+  class Persister
+    attr_reader :adapter
+    delegate :connection, :resource_factory, to: :adapter
+    # @param adapter [Valkyrie::Persistence::Solr::MetadataAdapter] The adapter with the
+    #   configured solr connection.
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save)
+    def save(resource:)
+      repository([resource]).persist.first
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save_all)
+    def save_all(resources:)
+      repository(resources).persist
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#delete)
+    def delete(resource:)
+      repository([resource]).delete.first
+    end
+
+    def repository(resources)
+      Valkyrie::Persistence::Solr::Repository.new(resources: resources, connection: connection, resource_factory: resource_factory)
+    end
+  end
+end

data/lib/valkyrie/persistence/solr/queries.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  module Queries
+    require 'valkyrie/persistence/solr/queries/default_paginator'
+    require 'valkyrie/persistence/solr/queries/find_all_query'
+    require 'valkyrie/persistence/solr/queries/find_by_id_query'
+    require 'valkyrie/persistence/solr/queries/find_inverse_references_query'
+    require 'valkyrie/persistence/solr/queries/find_members_query'
+    require 'valkyrie/persistence/solr/queries/find_references_query'
+  end
+end

data/lib/valkyrie/persistence/solr/queries/default_paginator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class DefaultPaginator
+    def next_page
+      1
+    end
+
+    def per_page
+      100
+    end
+
+    def has_next?
+      true
+    end
+  end
+end

data/lib/valkyrie/persistence/solr/queries/find_all_query.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class FindAllQuery
+    attr_reader :connection, :resource_factory, :model
+    def initialize(connection:, resource_factory:, model: nil)
+      @connection = connection
+      @resource_factory = resource_factory
+      @model = model
+    end
+
+    def run
+      enum_for(:each)
+    end
+
+    def each
+      docs = DefaultPaginator.new
+      while docs.has_next?
+        docs = connection.paginate(docs.next_page, docs.per_page, "select", params: { q: query })["response"]["docs"]
+        docs.each do |doc|
+          yield resource_factory.to_resource(object: doc)
+        end
+      end
+    end
+
+    def query
+      if !model
+        "*:*"
+      else
+        "internal_resource_ssim:#{model}"
+      end
+    end
+  end
+end

data/lib/valkyrie/persistence/solr/queries/find_by_id_query.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class FindByIdQuery
+    attr_reader :id, :connection, :resource_factory
+    def initialize(id, connection:, resource_factory:)
+      @id = id
+      @connection = connection
+      @resource_factory = resource_factory
+    end
+
+    def run
+      raise ::Valkyrie::Persistence::ObjectNotFoundError unless resource
+      resource_factory.to_resource(object: resource)
+    end
+
+    def id
+      "id-#{@id}"
+    end
+
+    def resource
+      connection.get("select", params: { q: "id:\"#{id}\"", fl: "*", rows: 1 })["response"]["docs"].first
+    end
+  end
+end

data/lib/valkyrie/persistence/solr/queries/find_inverse_references_query.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class FindInverseReferencesQuery
+    attr_reader :resource, :property, :connection, :resource_factory
+    def initialize(resource:, property:, connection:, resource_factory:)
+      @resource = resource
+      @property = property
+      @connection = connection
+      @resource_factory = resource_factory
+    end
+
+    def run
+      enum_for(:each)
+    end
+
+    def each
+      docs = DefaultPaginator.new
+      while docs.has_next?
+        docs = connection.paginate(docs.next_page, docs.per_page, "select", params: { q: query })["response"]["docs"]
+        docs.each do |doc|
+          yield resource_factory.to_resource(object: doc)
+        end
+      end
+    end
+
+    def query
+      "#{property}_ssim:id-#{resource.id}"
+    end
+  end
+end

data/lib/valkyrie/persistence/solr/queries/find_members_query.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class FindMembersQuery
+    attr_reader :resource, :connection, :resource_factory
+    def initialize(resource:, connection:, resource_factory:)
+      @resource = resource
+      @connection = connection
+      @resource_factory = resource_factory
+    end
+
+    def run
+      enum_for(:each)
+    end
+
+    def each
+      unordered_members.sort_by { |x| member_ids.index(x.id) }.each do |member|
+        yield member
+      end
+    end
+
+    def unordered_members
+      docs.map do |doc|
+        resource_factory.to_resource(object: doc)
+      end
+    end
+
+    def docs
+      connection.get("select", params: { q: query, rows: 1_000_000_000 })["response"]["docs"]
+    end
+
+    def member_ids
+      Array.wrap(resource.member_ids)
+    end
+
+    def query
+      "{!join from=member_ids_ssim to=id}id:#{id}"
+    end
+
+    def id
+      "id-#{resource.id}"
+    end
+  end
+end