valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr::Queries
+  class FindReferencesQuery
+    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
+      "{!join from=#{property}_ssim to=id}id:#{id}"
+    end
+
+    def id
+      "id-#{resource.id}"
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  require 'valkyrie/persistence/solr/queries'
+  class QueryService
+    attr_reader :connection, :resource_factory
+    # @param connection [RSolr::Client]
+    # @param resource_factory [Valkyrie::Persistence::Solr::ResourceFactory]
+    def initialize(connection:, resource_factory:)
+      @connection = connection
+      @resource_factory = resource_factory
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_by)
+    def find_by(id:)
+      Valkyrie::Persistence::Solr::Queries::FindByIdQuery.new(id, connection: connection, resource_factory: resource_factory).run
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all)
+    def find_all
+      Valkyrie::Persistence::Solr::Queries::FindAllQuery.new(connection: connection, resource_factory: resource_factory).run
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all_of_model)
+    def find_all_of_model(model:)
+      Valkyrie::Persistence::Solr::Queries::FindAllQuery.new(connection: connection, resource_factory: resource_factory, model: model).run
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
+    def find_parents(resource:)
+      find_inverse_references_by(resource: resource, property: :member_ids)
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_members)
+    def find_members(resource:)
+      Valkyrie::Persistence::Solr::Queries::FindMembersQuery.new(resource: resource, connection: connection, resource_factory: resource_factory).run
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
+    def find_references_by(resource:, property:)
+      Valkyrie::Persistence::Solr::Queries::FindReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_inverse_references_by)
+    def find_inverse_references_by(resource:, property:)
+      Valkyrie::Persistence::Solr::Queries::FindInverseReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  class Repository
+    attr_reader :resources, :connection, :resource_factory
+    def initialize(resources:, connection:, resource_factory:)
+      @resources = resources
+      @connection = connection
+      @resource_factory = resource_factory
+    end
+
+    def persist
+      documents = resources.map do |resource|
+        generate_id(resource) if resource.id.blank?
+        solr_document(resource)
+      end
+      connection.add documents, params: { softCommit: true }
+      documents.map do |document|
+        resource_factory.to_resource(object: document.stringify_keys)
+      end
+    end
+
+    def delete
+      connection.delete_by_id resources.map { |resource| "id-#{resource.id}" }, params: { softCommit: true }
+      resources
+    end
+
+    def solr_document(resource)
+      resource_factory.from_resource(resource: resource).to_h
+    end
+
+    def generate_id(resource)
+      Valkyrie.logger.warn "The Solr adapter is not meant to persist new resources, but is now generating an ID."
+      resource.id = SecureRandom.uuid
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  class ResourceFactory
+    require 'valkyrie/persistence/solr/orm_converter'
+    require 'valkyrie/persistence/solr/model_converter'
+    attr_reader :resource_indexer
+    def initialize(resource_indexer:)
+      @resource_indexer = resource_indexer
+    end
+
+    # @param solr_document [Hash] The solr document in a hash to convert to a
+    #   resource.
+    # @return [Valkyrie::Resource]
+    def to_resource(object:)
+      ORMConverter.new(object).convert!
+    end
+
+    # @param resource [Valkyrie::Resource] The resource to convert to a solr hash.
+    # @return [Hash] The solr document represented as a hash.
+    def from_resource(resource:)
+      Valkyrie::Persistence::Solr::ModelConverter.new(resource, resource_factory: self).convert!
+    end
+  end
+end

data/lib/valkyrie/rdf_patches.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+##
+# These patches are necessary for the postgres adapter to build JSON-LD versions
+# of RDF objects when `to_json` is called on them - that way they're stored in
+# the database as a standard format.
+module RDF
+  class Literal
+    def as_json(*_args)
+      JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
+    end
+  end
+  class URI
+    def as_json(*_args)
+      JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
+    end
+  end
+end

data/lib/valkyrie/resource.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+module Valkyrie
+  ##
+  # The base resource class for all Valkyrie metadata objects.
+  # @example Define a resource
+  #   class Book < Valkyrie::Resource
+  #     attribute :id, Valkyrie::Types::ID.optional
+  #     attribute :member_ids, Valkyrie::Types::Array
+  #     attribute :author
+  #   end
+  class Resource < Dry::Struct
+    include Draper::Decoratable
+    constructor_type :schema
+
+    # Overridden to provide default attributes.
+    # @note The current theory is that we should use this sparingly.
+    def self.inherited(subclass)
+      ::Dry::Struct.inherited(subclass)
+      subclass.constructor_type :schema
+      subclass.attribute :internal_resource, Valkyrie::Types::Any.default(subclass.to_s)
+      subclass.attribute :created_at, Valkyrie::Types::DateTime.optional
+      subclass.attribute :updated_at, Valkyrie::Types::DateTime.optional
+    end
+
+    # @return [Array<Symbol>] Array of fields defined for this class.
+    def self.fields
+      schema.keys
+    end
+
+    # Define an attribute.
+    # @param name [Symbol]
+    # @param type [Dry::Types::Type]
+    # @note Overridden from {Dry::Struct} to make the default type
+    #   {Valkyrie::Types::Set}
+    def self.attribute(name, type = Valkyrie::Types::Set.optional)
+      define_method("#{name}=") do |value|
+        instance_variable_set("@#{name}", self.class.schema[name].call(value))
+      end
+      super
+    end
+
+    # @return [ActiveModel::Name]
+    # @note Added for ActiveModel compatibility.
+    def self.model_name
+      @model_name ||= ::ActiveModel::Name.new(self)
+    end
+
+    delegate :model_name, to: :class
+
+    def self.human_readable_type
+      @_human_readable_type ||= name.demodulize.titleize
+    end
+
+    def self.human_readable_type=(val)
+      @_human_readable_type = val
+    end
+
+    # @return [Hash] Hash of attributes
+    def attributes
+      to_h
+    end
+
+    # @param name [Symbol] Attribute name
+    # @return [Boolean]
+    def has_attribute?(name)
+      respond_to?(name)
+    end
+
+    # @param name [Symbol]
+    # @return [Symbol]
+    # @note Added for ActiveModel compatibility.
+    def column_for_attribute(name)
+      name
+    end
+
+    # @return [Boolean]
+    def persisted?
+      to_param.present?
+    end
+
+    def to_key
+      [id]
+    end
+
+    def to_param
+      id
+    end
+
+    # @note Added for ActiveModel compatibility
+    def to_model
+      self
+    end
+
+    # @return [String]
+    def to_s
+      "#{self.class}: #{id}"
+    end
+
+    ##
+    # Provide a human readable name for the resource
+    # @return [String]
+    def human_readable_type
+      self.class.human_readable_type
+    end
+  end
+end

data/lib/valkyrie/resource/access_controls.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Valkyrie
+  class Resource
+    module AccessControls
+      def self.included(klass)
+        klass.attribute :read_groups, Valkyrie::Types::Set
+        klass.attribute :read_users, Valkyrie::Types::Set
+        klass.attribute :edit_users, Valkyrie::Types::Set
+        klass.attribute :edit_groups, Valkyrie::Types::Set
+      end
+    end
+  end
+end

data/lib/valkyrie/specs/shared_specs.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'valkyrie/specs/shared_specs/persister.rb'
+require 'valkyrie/specs/shared_specs/queries.rb'
+require 'valkyrie/specs/shared_specs/metadata_adapter'
+require 'valkyrie/specs/shared_specs/resource.rb'
+require 'valkyrie/specs/shared_specs/storage_adapter.rb'
+require 'valkyrie/specs/shared_specs/derivative_service.rb'
+require 'valkyrie/specs/shared_specs/file_characterization_service.rb'
+require 'valkyrie/specs/shared_specs/change_set_persister.rb'
+require 'valkyrie/specs/shared_specs/file.rb'

data/lib/valkyrie/specs/shared_specs/change_set_persister.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::ChangeSetPersister' do |*_flags|
+  before do
+    raise 'adapter must be set with `let(:change_set_persister)`' unless defined? change_set_persister
+    class CustomResource < Valkyrie::Resource
+      include Valkyrie::Resource::AccessControls
+      attribute :id, Valkyrie::Types::ID.optional
+      attribute :title
+      attribute :member_ids
+      attribute :nested_resource
+    end
+    class CustomChangeSet < Valkyrie::ChangeSet
+      self.fields = [:title]
+    end
+  end
+  after do
+    Object.send(:remove_const, :CustomResource)
+    Object.send(:remove_const, :CustomChangeSet)
+  end
+
+  subject { change_set_persister }
+  let(:resource_class) { CustomResource }
+  let(:resource) { resource_class.new }
+  let(:change_set) { CustomChangeSet.new(resource) }
+
+  it { is_expected.to respond_to(:save).with_keywords(:change_set) }
+  it { is_expected.to respond_to(:save_all).with_keywords(:change_sets) }
+  it { is_expected.to respond_to(:delete).with_keywords(:change_set) }
+  it { is_expected.to respond_to(:metadata_adapter) }
+  it { is_expected.to respond_to(:storage_adapter) }
+
+  describe "#save" do
+    it "saves a resource and returns it" do
+      output = subject.save(change_set: change_set)
+
+      expect(output).to be_kind_of CustomResource
+      expect(output).to be_persisted
+    end
+  end
+
+  describe "#delete" do
+    it "deletes a resource" do
+      output = subject.save(change_set: change_set)
+      subject.delete(change_set: CustomChangeSet.new(output))
+
+      expect do
+        subject.metadata_adapter.query_service.find_by(id: output.id)
+      end.to raise_error Valkyrie::Persistence::ObjectNotFoundError
+    end
+  end
+
+  describe "#save_all" do
+    it "saves multiple change_sets and returns them" do
+      change_set2 = CustomChangeSet.new(resource_class.new)
+      output = subject.save_all(change_sets: [change_set, change_set2])
+
+      expect(output.map(&:id).compact.length).to eq 2
+    end
+  end
+end

data/lib/valkyrie/specs/shared_specs/derivative_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::DerivativeService' do
+  before do
+    raise 'valid_change_set must be set with `let(:valid_change_set)`' unless
+      defined? valid_change_set
+    raise 'derivative_service must be set with `let(:derivative_service)`' unless
+      defined? derivative_service
+  end
+
+  subject { derivative_service.new(valid_change_set) }
+
+  it { is_expected.to respond_to(:create_derivatives).with(0).arguments }
+
+  it { is_expected.to respond_to(:cleanup_derivatives).with(0).arguments }
+
+  it { is_expected.to respond_to(:change_set) }
+
+  it { is_expected.to respond_to(:mime_type) }
+
+  describe "#valid?" do
+    context "when given a resource it handles" do
+      it { is_expected.to be_valid }
+    end
+  end
+
+  it "takes a change_set as an argument" do
+    obj = derivative_service.new(valid_change_set)
+    expect(obj.change_set.resource).to eq valid_change_set.resource
+  end
+end

data/lib/valkyrie/specs/shared_specs/file.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::StorageAdapter::File' do
+  before do
+    raise 'adapter must be set with `let(:file)`' unless defined? file
+  end
+
+  subject { file }
+
+  it { is_expected.to respond_to(:read) }
+  it { is_expected.to respond_to(:rewind) }
+  it { is_expected.to respond_to(:id) }
+end

data/lib/valkyrie/specs/shared_specs/file_characterization_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'a Valkyrie::FileCharacterizationService' do
+  before do
+    raise 'valid_file_node must be set with `let(:valid_file_node)`' unless
+      defined? valid_file_node
+    raise 'persister must be set with `let(:persister)`' unless
+      defined? persister
+    raise 'file_characterization_service must be set with `let(:file_characterization_service)`' unless
+      defined? file_characterization_service
+  end
+
+  let(:file_node) { valid_file_node }
+  subject { file_characterization_service.new(file_node: file_node, persister: persister) }
+
+  it { is_expected.to respond_to(:characterize).with(0).arguments }
+  it 'returns a file node' do
+    expect(subject.characterize).to be_a(FileNode)
+  end
+
+  describe '#valid?' do
+    context 'when given a file_node it handles' do
+      let(:file_node) { valid_file_node }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  it 'takes a file_node and a persister as arguments' do
+    obj = file_characterization_service.new(file_node: file_node, persister: persister)
+    expect(obj.file_node).to eq valid_file_node
+    expect(obj.persister).to eq persister
+  end
+end

data/lib/valkyrie/specs/shared_specs/metadata_adapter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::MetadataAdapter' do |passed_adapter|
+  before do
+    raise 'adapter must be set with `let(:adapter)`' unless
+      defined? adapter
+  end
+  subject { passed_adapter || adapter }
+  it { is_expected.to respond_to(:persister).with(0).arguments }
+  it { is_expected.to respond_to(:query_service).with(0).arguments }
+end