valkyrie 1.2.0.rc1 → 1.2.0.rc2

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

@@ -6,12 +6,18 @@ module Valkyrie::Persistence::Solr
     COMMIT_PARAMS = { softCommit: true, versions: true }.freeze
 
     attr_reader :resources, :connection, :resource_factory
+
+    # @param [Array<Valkyrie::Resource>] resources
+    # @param [RSolr::Client] connection
+    # @param [ResourceFactory] resource_factory
     def initialize(resources:, connection:, resource_factory:)
       @resources = resources
       @connection = connection
       @resource_factory = resource_factory
     end
 
+    # Persist the resources into Solr
+    # @return [Array<Valkyrie::Resource>]
     def persist
       documents = resources.map do |resource|
         generate_id(resource) if resource.id.blank?
@@ -33,29 +39,40 @@ module Valkyrie::Persistence::Solr
     rescue RSolr::Error::Http => exception
       # Error 409 conflict is returned when versions do not match
       if exception.response[:status] == 409
-        handle_409
+        handle_conflict
       end
       raise exception
     end
     # rubocop:enable Style/IfUnlessModifier
 
+    # Deletes a Solr Document using the ID
+    # @return [Array<Valkyrie::Resource>] resources which have been deleted from Solr
     def delete
       connection.delete_by_id resources.map { |resource| resource.id.to_s }, params: COMMIT_PARAMS
       resources
     end
 
+    # Given a Valkyrie Resource, generate the Hash for the Solr Document
+    # @param [Valkyrie::Resource] resource
+    # @return [Hash]
     def solr_document(resource)
       resource_factory.from_resource(resource: resource).to_h
     end
 
+    # Given a new Valkyrie Resource, generate a random UUID and assign it to the Resource
+    # @param [Valkyrie::Resource] resource
+    # @param [String] the UUID for the new resource
     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
 
-    def handle_409
-      raise Valkyrie::Persistence::StaleObjectError if resources.count > 1
-      raise Valkyrie::Persistence::StaleObjectError, resources.first.id.to_s
+    # If a 409 conflict response is encountered when attempting to commit updates to Solr, raise a StaleObjectError
+    # @see https://lucene.apache.org/solr/guide/updating-parts-of-documents.html#optimistic-concurrency
+    # @see https://tools.ietf.org/html/rfc7231#section-6.5.8
+    def handle_conflict
+      raise Valkyrie::Persistence::StaleObjectError, "One or more resources have been updated by another process." if resources.count > 1
+      raise Valkyrie::Persistence::StaleObjectError, "The object #{resources.first.id} has been updated by another process."
     end
   end
 end

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

@@ -8,6 +8,8 @@ module Valkyrie::Persistence::Solr
     attr_reader :resource_indexer, :adapter
     delegate :id, to: :adapter, prefix: true
 
+    # @param [Valkyrie::Persistence::Solr::MetadataAdapter::NullIndexer] resource_indexer
+    # @param [Valkyrie::Persistence::Solr::MetadataAdapter] adapter
     def initialize(resource_indexer:, adapter:)
       @resource_indexer = resource_indexer
       @adapter = adapter

data/lib/valkyrie/resource.rb

@@ -50,6 +50,7 @@ module Valkyrie
       define_method("#{name}=") do |value|
         instance_variable_set("@#{name}", self.class.schema[name].call(value))
       end
+      type = type.meta(ordered: true) if name == :member_ids
       super(name, type)
     end
 

data/lib/valkyrie/specs/shared_specs.rb

@@ -7,3 +7,4 @@ require 'valkyrie/specs/shared_specs/storage_adapter.rb'
 require 'valkyrie/specs/shared_specs/change_set_persister.rb'
 require 'valkyrie/specs/shared_specs/file.rb'
 require 'valkyrie/specs/shared_specs/change_set.rb'
+require 'valkyrie/specs/shared_specs/solr_indexer.rb'

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

@@ -9,6 +9,8 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
       attribute :member_ids
       attribute :nested_resource
       attribute :single_value, Valkyrie::Types::String.optional
+      attribute :ordered_authors, Valkyrie::Types::Array.of(Valkyrie::Types::Anything).meta(ordered: true)
+      attribute :ordered_nested, Valkyrie::Types::Array.of(CustomResource).meta(ordered: true)
     end
   end
   after do
@@ -185,6 +187,13 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     expect(reloaded.author.first.zone).to eq('UTC')
   end
 
+  it "can store Floats" do
+    decimal = 5.5
+    book = persister.save(resource: resource_class.new(title: [decimal]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly decimal
+  end
+
   # Pending decimals support in Valkyrie
   #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
   xit "can store Decimals" do
@@ -329,7 +338,7 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
           # update the resource in the datastore to make its token stale
           persister.save(resource: resource)
 
-          expect { persister.save(resource: resource) }.to raise_error(Valkyrie::Persistence::StaleObjectError, resource.id.to_s)
+          expect { persister.save(resource: resource) }.to raise_error(Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process.")
         end
       end
 
@@ -403,9 +412,90 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
           persister.save(resource: resource2)
 
           expect { persister.save_all(resources: [resource1, resource2, resource3]) }
-            .to raise_error(Valkyrie::Persistence::StaleObjectError, "Valkyrie::Persistence::StaleObjectError")
+            .to raise_error(Valkyrie::Persistence::StaleObjectError, "One or more resources have been updated by another process.")
         end
       end
     end
   end
+
+  context 'ordered properties' do
+    it "orders string values and returns them in the appropriate order" do
+      validate_order ["a", "b", "a"]
+    end
+
+    it "orders boolean values and returns them in the appropriate order" do
+      validate_order [true, false, true]
+    end
+
+    it "orders integer values and returns them in the appropriate order" do
+      validate_order [1, 2, 1]
+    end
+
+    it "orders date values and returns them in the appropriate order" do
+      now = Time.now.round(0).utc
+      validate_order [now, now - 3.hours, now - 1.hour]
+    end
+
+    it "orders URIs and returns them in the appropriate order" do
+      uri1 = RDF::URI("http://example.com/foo")
+      uri2 = RDF::URI("http://example.com/bar")
+      uri3 = RDF::URI("http://example.com/baz")
+      validate_order [uri1, uri2, uri3]
+    end
+
+    it "orders IDs and returns them in the appropriate order" do
+      page1 = persister.save(resource: resource_class.new(authors: ["Page 1"]))
+      page2 = persister.save(resource: resource_class.new(authors: ["Page 2"]))
+      page3 = persister.save(resource: resource_class.new(authors: ["Page 3"]))
+      validate_order [page1.id, page2.id, page3.id]
+    end
+
+    it "orders floating point values and returns them in the appropriate order" do
+      validate_order [1.123, 2.222, 1.123]
+    end
+
+    it "orders different types of objects together" do
+      validate_order [
+        RDF::URI("http://example.com/foo", language: :ita),
+        RDF::URI("http://example.com/foo", datatype: RDF::URI("http://datatype")),
+        1,
+        1.01,
+        "Test"
+      ]
+    end
+
+    it "orders nested objects with strings" do
+      nested1 = resource_class.new(id: Valkyrie::ID.new("resource1"))
+
+      resource.ordered_authors = [nested1, "test"]
+
+      output = persister.save(resource: resource)
+      expect(output.ordered_authors[0].id).to eq nested1.id
+      expect(output.ordered_authors[1]).to eq "test"
+    end
+
+    it "orders nested objects" do
+      nested1 = resource_class.new(id: Valkyrie::ID.new("resource1"), authors: ["Resource 1"])
+      nested2 = resource_class.new(id: Valkyrie::ID.new("resource2"), authors: ["Resource 2"])
+      nested3 = resource_class.new(id: Valkyrie::ID.new("resource3"), authors: ["Resource 3"])
+      values = [nested1, nested2, nested3]
+
+      resource.ordered_nested = values
+
+      output = persister.save(resource: resource)
+      expect(output.ordered_nested.map(&:id)).to eq values.map(&:id)
+
+      reloaded = query_service.find_by(id: output.id)
+      expect(reloaded.ordered_nested.map(&:id)).to eq values.map(&:id)
+    end
+
+    def validate_order(values)
+      resource.ordered_authors = values
+      output = persister.save(resource: resource)
+      expect(output.ordered_authors).to eq(values)
+
+      reloaded = query_service.find_by(id: output.id)
+      expect(reloaded.ordered_authors).to eq(values)
+    end
+  end
 end

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

@@ -8,6 +8,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       attribute :title
       attribute :member_ids, Valkyrie::Types::Array
       attribute :a_member_of
+      attribute :an_ordered_member_of, Valkyrie::Types::Array.meta(ordered: true)
     end
     class SecondResource < Valkyrie::Resource
     end
@@ -217,6 +218,17 @@ RSpec.shared_examples 'a Valkyrie query provider' 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
+
+    context "when the property is ordered" do
+      it "returns all references in order" do
+        parent = persister.save(resource: resource_class.new)
+        parent2 = persister.save(resource: resource_class.new)
+        child = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id, parent2.id, parent.id]))
+        persister.save(resource: resource_class.new)
+
+        expect(query_service.find_references_by(resource: child, property: :an_ordered_member_of).map(&:id).to_a).to eq [parent.id, parent2.id, parent.id]
+      end
+    end
   end
 
   describe ".find_inverse_references_by" do

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'a Valkyrie::Persistence::Solr::Indexer' do |*_flags|
+  let(:created_at) { Time.now.utc }
+  let(:attributes) do
+    {
+      created_at: created_at,
+      internal_resource: 'Resource',
+      title: ["Test", RDF::Literal.new("French", language: :fr)],
+      author: ["Author"],
+      creator: "Creator"
+    }
+  end
+  let(:resource) do
+    Resource.new(
+      id: "1",
+      internal_resource: 'Resource',
+      attributes: attributes
+    )
+  end
+  let(:indexer) { described_class.new(resource: resource) }
+
+  before do
+    class Resource < Valkyrie::Resource
+      attribute :title, Valkyrie::Types::Set
+      attribute :author, Valkyrie::Types::Set
+      attribute :birthday, Valkyrie::Types::DateTime.optional
+      attribute :creator, Valkyrie::Types::String
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Resource)
+  end
+
+  describe '#to_solr' do
+    subject { indexer.to_solr }
+
+    it { is_expected.to be_a Hash }
+  end
+end

data/lib/valkyrie/storage/fedora.rb

@@ -23,8 +23,6 @@ module Valkyrie::Storage
     # @raise Valkyrie::StorageAdapter::FileNotFound if nothing is found
     def find_by(id:)
       Valkyrie::StorageAdapter::StreamFile.new(id: id, io: response(id: id))
-    rescue ::Ldp::Gone
-      raise Valkyrie::StorageAdapter::FileNotFound
     end
 
     # @param file [IO]

data/lib/valkyrie/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Valkyrie
-  VERSION = "1.2.0.rc1"
+  VERSION = "1.2.0.rc2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie
 version: !ruby/object:Gem::Version
-  version: 1.2.0.rc1
+  version: 1.2.0.rc2
 platform: ruby
 authors:
 - Trey Pendragon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-09 00:00:00.000000000 Z
+date: 2018-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -509,6 +509,7 @@ files:
 - lib/valkyrie/persistence/solr/queries/find_inverse_references_query.rb
 - lib/valkyrie/persistence/solr/queries/find_many_by_ids_query.rb
 - lib/valkyrie/persistence/solr/queries/find_members_query.rb
+- lib/valkyrie/persistence/solr/queries/find_ordered_references_query.rb
 - lib/valkyrie/persistence/solr/queries/find_references_query.rb
 - lib/valkyrie/persistence/solr/query_service.rb
 - lib/valkyrie/persistence/solr/repository.rb
@@ -524,6 +525,7 @@ files:
 - lib/valkyrie/specs/shared_specs/persister.rb
 - lib/valkyrie/specs/shared_specs/queries.rb
 - lib/valkyrie/specs/shared_specs/resource.rb
+- lib/valkyrie/specs/shared_specs/solr_indexer.rb
 - lib/valkyrie/specs/shared_specs/storage_adapter.rb
 - lib/valkyrie/storage.rb
 - lib/valkyrie/storage/disk.rb