valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
+  before do
+    raise 'persister must be set with `let(:persister)`' unless defined? persister
+    class CustomResource < Valkyrie::Resource
+      include Valkyrie::Resource::AccessControls
+      attribute :id, Valkyrie::Types::ID.optional
+      attribute :title
+      attribute :author
+      attribute :member_ids
+      attribute :nested_resource
+    end
+  end
+  after do
+    Object.send(:remove_const, :CustomResource)
+  end
+
+  subject { persister }
+  let(:resource_class) { CustomResource }
+  let(:resource) { resource_class.new }
+
+  it { is_expected.to respond_to(:save).with_keywords(:resource) }
+  it { is_expected.to respond_to(:save_all).with_keywords(:resources) }
+  it { is_expected.to respond_to(:delete).with_keywords(:resource) }
+
+  it "can save a resource" do
+    expect(persister.save(resource: resource).id).not_to be_blank
+  end
+
+  it "can save multiple resources at once" do
+    resource2 = resource_class.new
+    results = persister.save_all(resources: [resource, resource2])
+
+    expect(results.map(&:id).uniq.length).to eq 2
+  end
+
+  it "can save nested resources" do
+    book2 = resource_class.new(title: "Nested")
+    book3 = persister.save(resource: resource_class.new(nested_resource: book2))
+
+    reloaded = query_service.find_by(id: book3.id)
+    expect(reloaded.nested_resource.first.title).to eq ["Nested"]
+  end
+
+  it "can mix properties with nested resources" do
+    pending "No support for mixed nesting." if flags.include?(:no_mixed_nesting)
+    book2 = resource_class.new(title: "Nested", id: SecureRandom.uuid)
+    book3 = persister.save(resource: resource_class.new(nested_resource: [book2, "Alabama"]))
+
+    reloaded = query_service.find_by(id: book3.id)
+    expect(reloaded.nested_resource.map { |x| x.try(:title) }).to include ["Nested"]
+    expect(reloaded.nested_resource).to include "Alabama"
+  end
+
+  it "can support deep nesting of resources" do
+    pending "No support for deep nesting." if flags.include?(:no_deep_nesting)
+    book = resource_class.new(title: "Sub-nested", author: [Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://test.com")])
+    book2 = resource_class.new(title: "Nested", nested_resource: book)
+    book3 = persister.save(resource: resource_class.new(nested_resource: book2))
+
+    reloaded = query_service.find_by(id: book3.id)
+    expect(reloaded.nested_resource.first.title).to eq ["Nested"]
+    expect(reloaded.nested_resource.first.nested_resource.first.title).to eq ["Sub-nested"]
+    expect(reloaded.nested_resource.first.nested_resource.first.author).to contain_exactly Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://test.com")
+  end
+
+  it "stores created_at/updated_at" do
+    book = persister.save(resource: resource_class.new)
+    book.title = "test"
+    book = persister.save(resource: book)
+    expect(book.created_at).not_to be_blank
+    expect(book.updated_at).not_to be_blank
+    expect(book.created_at).not_to be_kind_of Array
+    expect(book.updated_at).not_to be_kind_of Array
+  end
+
+  it "can handle language-typed RDF properties" do
+    book = persister.save(resource: resource_class.new(title: ["Test1", RDF::Literal.new("Test", language: :fr)]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly "Test1", RDF::Literal.new("Test", language: :fr)
+  end
+
+  it "can store Valkyrie::Ids" do
+    shared_title = persister.save(resource: resource_class.new(id: "test"))
+    book = persister.save(resource: resource_class.new(title: [shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly(shared_title.id, Valkyrie::ID.new("adapter://1"), "test")
+    expect([shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]).to contain_exactly(*reloaded.title)
+  end
+
+  it "can store ::RDF::URIs" do
+    book = persister.save(resource: resource_class.new(title: [::RDF::URI("http://example.com")]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly RDF::URI("http://example.com")
+  end
+
+  it "can store integers" do
+    book = persister.save(resource: resource_class.new(title: [1]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly 1
+  end
+
+  it "can store datetimes" do
+    time1 = DateTime.current
+    time2 = Time.current.in_time_zone
+    book = persister.save(resource: resource_class.new(title: [time1], author: [time2]))
+
+    reloaded = query_service.find_by(id: book.id)
+
+    expect(reloaded.title.first.to_i).to eq(time1.to_i)
+    expect(reloaded.title.first.zone).to eq('UTC')
+    expect(reloaded.author.first.to_i).to eq(time2.to_i)
+    expect(reloaded.author.first.zone).to eq('UTC')
+  end
+
+  context "parent tests" do
+    let(:book) { persister.save(resource: resource_class.new) }
+    let(:book2) { persister.save(resource: resource_class.new) }
+
+    it "can order members" do
+      book3 = persister.save(resource: resource_class.new)
+      parent = persister.save(resource: resource_class.new(member_ids: [book2.id, book.id]))
+      parent.member_ids = parent.member_ids + [book3.id]
+      parent = persister.save(resource: parent)
+      reloaded = query_service.find_by(id: parent.id)
+      expect(reloaded.member_ids).to eq [book2.id, book.id, book3.id]
+    end
+
+    it "can remove members" do
+      parent = persister.save(resource: resource_class.new(member_ids: [book2.id, book.id]))
+      parent.member_ids = parent.member_ids - [book2.id]
+      parent = persister.save(resource: parent)
+      expect(parent.member_ids).to eq [book.id]
+    end
+  end
+
+  it "doesn't override a resource that already has an ID" do
+    book = persister.save(resource: resource_class.new)
+    id = book.id
+    output = persister.save(resource: book)
+    expect(output.id).to eq id
+  end
+
+  it "can find that resource again" do
+    id = persister.save(resource: resource).id
+    expect(query_service.find_by(id: id)).to be_kind_of resource_class
+  end
+
+  it "can delete objects" do
+    persisted = persister.save(resource: resource)
+    persister.delete(resource: persisted)
+    expect { query_service.find_by(id: persisted.id) }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie query provider' do
+  before do
+    raise 'adapter must be set with `let(:adapter)`' unless
+      defined? adapter
+    class CustomResource < Valkyrie::Resource
+      attribute :id, Valkyrie::Types::ID.optional
+      attribute :title
+      attribute :member_ids
+      attribute :a_member_of
+    end
+    class SecondResource < Valkyrie::Resource
+      attribute :id, Valkyrie::Types::ID.optional
+    end
+  end
+  after do
+    Object.send(:remove_const, :CustomResource)
+    Object.send(:remove_const, :SecondResource)
+  end
+  let(:resource_class) { CustomResource }
+  let(:query_service) { adapter.query_service }
+  let(:persister) { adapter.persister }
+  subject { adapter.query_service }
+
+  it { is_expected.to respond_to(:find_all).with(0).arguments }
+  it { is_expected.to respond_to(:find_all_of_model).with_keywords(:model) }
+  it { is_expected.to respond_to(:find_by).with_keywords(:id) }
+  it { is_expected.to respond_to(:find_members).with_keywords(:resource) }
+  it { is_expected.to respond_to(:find_references_by).with_keywords(:resource, :property) }
+  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:resource, :property) }
+  it { is_expected.to respond_to(:find_parents).with_keywords(:resource) }
+
+  describe ".find_all" do
+    it "returns all created resources" do
+      resource1 = persister.save(resource: resource_class.new)
+      resource2 = persister.save(resource: resource_class.new)
+
+      expect(query_service.find_all.map(&:id)).to contain_exactly resource1.id, resource2.id
+    end
+  end
+
+  describe ".find_all_of_model" do
+    it "returns all of that model" do
+      persister.save(resource: resource_class.new)
+      resource2 = persister.save(resource: SecondResource.new)
+
+      expect(query_service.find_all_of_model(model: SecondResource).map(&:id)).to contain_exactly resource2.id
+    end
+    it "returns an empty array if there are none" do
+      expect(query_service.find_all_of_model(model: SecondResource).to_a).to eq []
+    end
+  end
+
+  describe ".find_by" do
+    it "returns a resource by id" do
+      resource = persister.save(resource: resource_class.new)
+
+      expect(query_service.find_by(id: resource.id).id).to eq resource.id
+    end
+    it "returns a Valkyrie::Persistence::ObjectNotFoundError for a non-found ID" do
+      expect { query_service.find_by(id: "123123123") }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
+    end
+  end
+
+  describe ".find_members" do
+    it "returns all a resource's members in order" do
+      child1 = persister.save(resource: resource_class.new)
+      child2 = persister.save(resource: resource_class.new)
+      parent = persister.save(resource: resource_class.new(member_ids: [child2.id, child1.id]))
+
+      expect(query_service.find_members(resource: parent).map(&:id).to_a).to eq [child2.id, child1.id]
+      expect(query_service.find_by(id: parent.id).member_ids).to eq [child2.id, child1.id]
+    end
+    it "doesn't error when there's no resource ID" do
+      parent = resource_class.new
+      expect(query_service.find_members(resource: parent).to_a).to eq []
+    end
+    it "returns an empty array if there are none" do
+      expect(query_service.find_all.to_a).to eq []
+    end
+  end
+
+  describe ".find_references_by" do
+    it "returns all references given in a property" do
+      parent = persister.save(resource: resource_class.new)
+      child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
+      persister.save(resource: resource_class.new)
+
+      expect(query_service.find_references_by(resource: child, property: :a_member_of).map(&:id).to_a).to eq [parent.id]
+    end
+    it "returns an empty array if there are none" do
+      child = persister.save(resource: resource_class.new)
+      expect(query_service.find_references_by(resource: child, property: :a_member_of).to_a).to eq []
+    end
+  end
+
+  describe ".find_inverse_references_by" do
+    it "returns everything which references the given resource by the given property" do
+      parent = persister.save(resource: resource_class.new)
+      child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
+      persister.save(resource: resource_class.new)
+      persister.save(resource: SecondResource.new)
+
+      expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to eq [child.id]
+    end
+    it "returns an empty array if there are none" do
+      parent = persister.save(resource: resource_class.new)
+
+      expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
+    end
+  end
+
+  describe ".find_parents" do
+    it "returns all parent resources" do
+      child1 = persister.save(resource: resource_class.new)
+      child2 = persister.save(resource: resource_class.new)
+      parent = persister.save(resource: resource_class.new(member_ids: [child1.id, child2.id]))
+      parent2 = persister.save(resource: resource_class.new(member_ids: [child1.id]))
+
+      expect(query_service.find_parents(resource: child1).map(&:id).to_a).to contain_exactly parent.id, parent2.id
+    end
+    it "returns an empty array if there are none" do
+      child1 = persister.save(resource: resource_class.new)
+
+      expect(query_service.find_parents(resource: child1).to_a).to eq []
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::Resource' do
+  before do
+    raise 'resource_klass must be set with `let(:resource_klass)`' unless
+      defined? resource_klass
+  end
+  describe "#id" do
+    it "can be set via instantiation and casts to a Valkyrie::ID" do
+      resource = resource_klass.new(id: "test")
+      expect(resource.id).to eq Valkyrie::ID.new("test")
+    end
+
+    it "is nil when not set" do
+      resource = resource_klass.new
+      expect(resource.id).to be_nil
+    end
+
+    it { is_expected.to respond_to(:persisted?).with(0).arguments }
+    it { is_expected.to respond_to(:to_param).with(0).arguments }
+    it { is_expected.to respond_to(:to_model).with(0).arguments }
+    it { is_expected.to respond_to(:model_name).with(0).arguments }
+    it { is_expected.to respond_to(:column_for_attribute).with(1).arguments }
+
+    describe "#has_attribute?" do
+      it "returns true when it has a given attribute" do
+        resource = resource_klass.new
+        expect(resource.has_attribute?(:id)).to eq true
+      end
+    end
+
+    describe "#fields" do
+      it "returns a set of fields" do
+        expect(resource_klass).to respond_to(:fields).with(0).arguments
+        expect(resource_klass.fields).to include(:id)
+      end
+    end
+
+    describe "#attributes" do
+      it "returns a list of all set attributes" do
+        resource = resource_klass.new(id: "test")
+        expect(resource.attributes[:id].to_s).to eq "test"
+      end
+    end
+  end
+
+  describe "#internal_resource" do
+    it "is set to the resource's class on instantiation" do
+      resource = resource_klass.new
+      expect(resource.internal_resource).to eq resource_klass.to_s
+    end
+  end
+
+  describe "#human_readable_type" do
+    before do
+      class MyCustomResource < Valkyrie::Resource
+        attribute :id, Valkyrie::Types::ID.optional
+        attribute :title, Valkyrie::Types::Set
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :MyCustomResource)
+    end
+
+    subject(:my_custom_resource) { MyCustomResource.new }
+
+    it "returns a human readable rendering of the resource class" do
+      expect(my_custom_resource.human_readable_type).to eq "My Custom Resource"
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
+  before do
+    raise 'storage_adapter must be set with `let(:storage_adapter)`' unless
+      defined? storage_adapter
+    raise 'file must be set with `let(:file)`' unless
+      defined? file
+    class CustomResource < Valkyrie::Resource
+      attribute :id, Valkyrie::Types::ID.optional
+    end
+  end
+  after do
+    Object.send(:remove_const, :CustomResource)
+  end
+  subject { storage_adapter }
+  it { is_expected.to respond_to(:handles?).with_keywords(:id) }
+  it { is_expected.to respond_to(:find_by).with_keywords(:id) }
+  it { is_expected.to respond_to(:upload).with_keywords(:file, :resource) }
+
+  it "can upload, validate, and re-fetch a file" do
+    resource = CustomResource.new(id: "test")
+    sha1 = Digest::SHA1.file(file).to_s
+    size = file.size
+    expect(uploaded_file = storage_adapter.upload(file: file, resource: resource)).to be_kind_of Valkyrie::StorageAdapter::File
+
+    expect(uploaded_file).to respond_to(:checksum).with_keywords(:digests)
+    expect(uploaded_file).to respond_to(:valid?).with_keywords(:size, :digests)
+    expect(uploaded_file.checksum(digests: [Digest::SHA1.new])).to eq([sha1])
+    expect(uploaded_file.valid?(digests: { sha1: sha1 })).to be true
+    expect(uploaded_file.valid?(size: size, digests: { sha1: sha1 })).to be true
+    expect(uploaded_file.valid?(size: (size + 1), digests: { sha1: sha1 })).to be false
+    expect(uploaded_file.valid?(size: size, digests: { sha1: 'bogus' })).to be false
+
+    expect(storage_adapter.handles?(id: uploaded_file.id)).to eq true
+    file = storage_adapter.find_by(id: uploaded_file.id)
+    expect(file.id).to eq uploaded_file.id
+    expect(file).to respond_to(:stream).with(0).arguments
+    expect(file).to respond_to(:read).with(0).arguments
+    expect(file).to respond_to(:rewind).with(0).arguments
+    expect(file.stream).to respond_to(:read)
+    new_file = Tempfile.new
+    expect { IO.copy_stream(file, new_file) }.not_to raise_error
+  end
+end

data/lib/valkyrie/storage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Valkyrie
+  module Storage
+    require 'valkyrie/storage/disk'
+    require 'valkyrie/storage/fedora'
+    require 'valkyrie/storage/memory'
+  end
+end

data/lib/valkyrie/storage/disk.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Valkyrie::Storage
+  class Disk
+    attr_reader :base_path, :path_generator, :file_mover
+    def initialize(base_path:, path_generator: BucketedStorage, file_mover: FileUtils.method(:mv))
+      @base_path = Pathname.new(base_path.to_s)
+      @path_generator = path_generator.new(base_path: base_path)
+      @file_mover = file_mover
+    end
+
+    # @param file [IO]
+    # @param resource [Valkyrie::Resource]
+    # @return [Valkyrie::StorageAdapter::File]
+    def upload(file:, resource: nil)
+      new_path = path_generator.generate(resource: resource, file: file)
+      FileUtils.mkdir_p(new_path.parent)
+      file_mover.call(file.path, new_path)
+      find_by(id: Valkyrie::ID.new("disk://#{new_path}"))
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Boolean] true if this adapter can handle this type of identifer
+    def handles?(id:)
+      id.to_s.start_with?("disk://")
+    end
+
+    def file_path(id)
+      id.to_s.gsub(/^disk:\/\//, '')
+    end
+
+    # Return the file associated with the given identifier
+    # @param id [Valkyrie::ID]
+    # @return [Valkyrie::StorageAdapter::File]
+    def find_by(id:)
+      return unless handles?(id: id)
+      Valkyrie::StorageAdapter::File.new(id: Valkyrie::ID.new(id.to_s), io: ::File.open(file_path(id), 'rb'))
+    end
+
+    class BucketedStorage
+      attr_reader :base_path
+      def initialize(base_path:)
+        @base_path = base_path
+      end
+
+      def generate(resource:, file:)
+        Pathname.new(base_path).join(*bucketed_path(resource.id)).join(file.original_filename)
+      end
+
+      def bucketed_path(id)
+        cleaned_id = id.to_s.delete("-")
+        cleaned_id[0..5].chars.each_slice(2).map(&:join) + [cleaned_id]
+      end
+    end
+  end
+end