valkyrie 2.0.2 → 2.1.0

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

@@ -62,8 +62,9 @@ module Valkyrie::Persistence::Solr
     # 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
+    # @see Valkyrie::Logging for details concerning log suppression.
     def generate_id(resource)
-      Valkyrie.logger.warn "The Solr adapter is not meant to persist new resources, but is now generating an ID."
+      Valkyrie.logger.warn("The Solr adapter is not meant to persist new resources, but is now generating an ID.", logging_context: "Valkyrie::Persistence::Solr::Repository#generate_id")
       resource.id = SecureRandom.uuid
     end
 

data/lib/valkyrie/rdf_patches.rb

@@ -6,12 +6,12 @@
 module RDF
   class Literal
     def as_json(*_args)
-      JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
+      ::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]
+      ::JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
     end
   end
 end

data/lib/valkyrie/resource.rb

@@ -50,7 +50,6 @@ module Valkyrie
                                                                                                                                 attribute_names.include?(name.to_sym) &&
                                                                                                                                 !internal
 
-      type = type.meta(ordered: true) if name == :member_ids
       super(name, type)
     end
 
@@ -58,9 +57,14 @@ module Valkyrie
     # @return [Dry::Struct]
     # @raise [RepeatedAttributeError] when trying to define attribute with the
     #   same name as previously defined one
+    # @raise [ReservedAttributeError] when trying to define an attribute
+    #   reserved by Valkyrie
     # @see #attribute
     # @note extends {Dry::Struct} by adding `#attr=` style setters
     def self.attributes(new_schema)
+      new_schema[:member_ids] = new_schema[:member_ids].meta(ordered: true) if
+        new_schema.key?(:member_ids)
+
       super
 
       new_schema.each_key do |key|
@@ -109,6 +113,10 @@ module Valkyrie
       self.class.optimistic_locking_enabled?
     end
 
+    def clear_optimistic_lock_token!
+      send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", []) if optimistic_locking_enabled?
+    end
+
     def attributes
       Hash[self.class.attribute_names.map { |x| [x, nil] }].merge(super).freeze
     end
@@ -183,7 +191,7 @@ module Valkyrie
 
     # Returns if an attribute is set as ordered.
     def ordered_attribute?(key)
-      self.class.schema.key(key).type.meta.try(:[], :ordered)
+      self.class.schema.key(key.to_sym).type.meta.try(:[], :ordered)
     end
 
     class ReservedAttributeError < StandardError; end

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

@@ -84,14 +84,14 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
 
   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")])
+    book = resource_class.new(title: "Sub-nested", author: [Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://example.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")
+    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://example.com")
   end
 
   it "stores created_at/updated_at" do
@@ -360,7 +360,7 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
           resource = MyLockingResource.new(title: ["My Locked Resource"])
           initial_resource = persister.save(resource: resource)
           initial_token = initial_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first
-          initial_resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", [])
+          initial_resource.clear_optimistic_lock_token!
           updated_resource = persister.save(resource: initial_resource)
           expect(initial_token.serialize)
             .not_to eq(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first.serialize)

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

@@ -12,10 +12,15 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     end
     class Valkyrie::Specs::SecondResource < Valkyrie::Resource
     end
+    class Valkyrie::Specs::ThirdResource < Valkyrie::Resource
+      attribute :a_member_of, Valkyrie::Types::Array
+      attribute :an_ordered_member_of, Valkyrie::Types::Array.meta(ordered: true)
+    end
   end
   after do
     Valkyrie::Specs.send(:remove_const, :CustomResource)
     Valkyrie::Specs.send(:remove_const, :SecondResource)
+    Valkyrie::Specs.send(:remove_const, :ThirdResource)
   end
   let(:resource_class) { Valkyrie::Specs::CustomResource }
   let(:query_service) { adapter.query_service } unless defined? query_service
@@ -28,10 +33,11 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   it { is_expected.to respond_to(:find_by_alternate_identifier).with_keywords(:alternate_identifier) }
   it { is_expected.to respond_to(:find_many_by_ids).with_keywords(:ids) }
   it { is_expected.to respond_to(:find_members).with_keywords(:resource, :model) }
-  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_inverse_references_by).with_keywords(:id, :property) }
+  it { is_expected.to respond_to(:find_references_by).with_keywords(:resource, :property, :model) }
+  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:resource, :property, :model) }
+  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:id, :property, :model) }
   it { is_expected.to respond_to(:find_parents).with_keywords(:resource) }
+  it { is_expected.to respond_to(:count_all_of_model).with_keywords(:model) }
 
   describe ".find_all" do
     it "returns all created resources" do
@@ -273,14 +279,50 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         expect(query_service.find_references_by(resource: child, property: :an_ordered_member_of).map(&:id).to_a).to eq []
       end
     end
+
+    context "filtering by model" do
+      context "when the object has related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :a_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent3.id, parent2.id, parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:parent2) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+        let(:parent3) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          expect(subject.map(&:id).to_a).to match_array [parent3.id, parent.id]
+        end
+      end
+
+      context "when the object has ordered related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :an_ordered_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(an_ordered_member_of: [parent.id, parent3.id, parent2.id, parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:parent2) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+        let(:parent3) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          expect(subject.map(&:id).to_a).to match_array [parent.id, parent3.id, parent.id]
+        end
+      end
+
+      context "when there are no related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :a_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+
+        it "returns an empty array" do
+          expect(subject.to_a).to eq []
+        end
+      end
+    end
   end
 
   describe ".find_inverse_references_by" do
     context "when the resource is saved" do
       context "when the property is unordered" do
         it "returns everything which references the given resource by the given property" do
-          parent = persister.save(resource: resource_class.new)
-          parent2 = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
+          parent2 = persister.save(resource: Valkyrie::Specs::SecondResource.new)
           child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
           child2 = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id, parent.id]))
           persister.save(resource: resource_class.new)
@@ -290,7 +332,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         end
 
         it "returns an empty array if there are none" do
-          parent = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
 
           expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
         end
@@ -298,7 +340,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
 
       context "when the property is ordered" do
         it "returns everything which references the given resource by the given property" do
-          parent = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
           child = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id]))
           child2 = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id, parent.id]))
           persister.save(resource: resource_class.new)
@@ -307,12 +349,38 @@ RSpec.shared_examples 'a Valkyrie query provider' do
           expect(query_service.find_inverse_references_by(resource: parent, property: :an_ordered_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
         end
       end
+
+      context "when the property is ordered for one child but not the other" do
+        before do
+          class Valkyrie::Specs::Parent < Valkyrie::Resource; end
+          class Valkyrie::Specs::ChildWithUnorderedParents < Valkyrie::Resource
+            attribute :a_member_of, Valkyrie::Types::Array
+          end
+          class Valkyrie::Specs::ChildWithOrderedParents < Valkyrie::Resource
+            attribute :a_member_of, Valkyrie::Types::Array.meta(ordered: true)
+          end
+        end
+        after do
+          Valkyrie::Specs.send(:remove_const, :Parent)
+          Valkyrie::Specs.send(:remove_const, :ChildWithUnorderedParents)
+          Valkyrie::Specs.send(:remove_const, :ChildWithOrderedParents)
+        end
+        it "returns" do
+          parent = persister.save(resource: Valkyrie::Specs::Parent.new)
+          child = persister.save(resource: Valkyrie::Specs::ChildWithUnorderedParents.new(a_member_of: [parent.id]))
+          child2 = persister.save(resource: Valkyrie::Specs::ChildWithOrderedParents.new(a_member_of: [parent.id, parent.id]))
+          persister.save(resource: Valkyrie::Specs::ChildWithUnorderedParents.new)
+          persister.save(resource: Valkyrie::Specs::Parent.new)
+
+          expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
+        end
+      end
     end
 
     context "when id is passed instead of resource" do
       it "returns everything which references the given resource by the given property" do
-        parent = persister.save(resource: resource_class.new)
-        parent2 = persister.save(resource: resource_class.new)
+        parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
+        parent2 = persister.save(resource: Valkyrie::Specs::SecondResource.new)
         child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
         child2 = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id, parent.id]))
         persister.save(resource: resource_class.new)
@@ -335,6 +403,32 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         expect { query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a }.to raise_error ArgumentError
       end
     end
+
+    context "filtering by model" do
+      subject { query_service.find_inverse_references_by(resource: parent, property: :a_member_of, model: Valkyrie::Specs::CustomResource) }
+
+      context "when the object has related resources that match the filter" do
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          child1 = persister.save(resource: Valkyrie::Specs::CustomResource.new(a_member_of: [parent.id]))
+          persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id]))
+          child3 = persister.save(resource: Valkyrie::Specs::CustomResource.new(a_member_of: [parent.id]))
+
+          expect(subject.map(&:id).to_a).to match_array [child3.id, child1.id]
+        end
+      end
+
+      context "when there are no related resources that match the filter" do
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns an empty array" do
+          persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id]))
+
+          expect(subject.to_a).to eq []
+        end
+      end
+    end
   end
 
   describe ".find_parents" do
@@ -411,4 +505,13 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       expect(resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
     end
   end
+
+  describe ".count_all_of_model" do
+    it "counts all of that model" do
+      persister.save(resource: resource_class.new)
+      persister.save(resource: Valkyrie::Specs::SecondResource.new)
+      persister.save(resource: Valkyrie::Specs::SecondResource.new)
+      expect(query_service.count_all_of_model(model: Valkyrie::Specs::SecondResource)).to eq(2)
+    end
+  end
 end

data/lib/valkyrie/storage/fedora.rb

@@ -7,7 +7,7 @@ module Valkyrie::Storage
     SLASH = '/'
 
     # @param [Ldp::Client] connection
-    def initialize(connection:, base_path: "/", fedora_version: 5)
+    def initialize(connection:, base_path: "/", fedora_version: Valkyrie::Persistence::Fedora::DEFAULT_FEDORA_VERSION)
       @connection = connection
       @base_path = base_path
       @fedora_version = fedora_version

data/lib/valkyrie/storage_adapter.rb

@@ -5,6 +5,7 @@ module Valkyrie
   #  storage backends (such as fedora, disk, etc)
   class StorageAdapter
     class FileNotFound < StandardError; end
+    class AdapterNotFoundError < StandardError; end
     class_attribute :storage_adapters
     self.storage_adapters = {}
     class << self
@@ -54,10 +55,12 @@ module Valkyrie
       # @param id [Valkyrie::ID]
       # @return [Valkyrie::StorageAdapter]
       def adapter_for(id:)
-        # TODO: Determine the appropriate response when we have an unhandled :id
-        storage_adapters.values.find do |storage_adapter|
+        handler = storage_adapters.values.find do |storage_adapter|
           storage_adapter.handles?(id: id)
         end
+
+        raise AdapterNotFoundError, 'Unable to find a StorageAdapter' if handler.nil?
+        handler
       end
     end
 

data/lib/valkyrie/types.rb

@@ -99,6 +99,8 @@ module Valkyrie
     end
     Array.singleton_class.include(ArrayDefault)
     Set.singleton_class.include(ArrayDefault)
+    Relation = Valkyrie::Types::Set.of(Valkyrie::Types::ID)
+    OrderedRelation = Valkyrie::Types::Array.of(Valkyrie::Types::ID).meta(ordered: true)
 
     # Used for when an input may be an array, but the output needs to be a
     # single string.

data/lib/valkyrie/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Valkyrie
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/solr/config/solrconfig.xml

@@ -284,16 +284,6 @@
       -->
   </searchComponent>
 
-  <searchComponent name="suggest" class="solr.SuggestComponent">
-    <lst name="suggester">
-      <str name="name">mySuggester</str>
-      <str name="lookupImpl">FuzzyLookupFactory</str>
-      <str name="suggestAnalyzerFieldType">textSuggest</str>
-      <str name="buildOnCommit">true</str>
-      <str name="field">suggest</str>
-    </lst>
-  </searchComponent>
-
   <requestHandler name="/suggest" class="solr.SearchHandler" startup="lazy">
     <lst name="defaults">
       <str name="suggest">true</str>

data/valkyrie.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'json'
   spec.add_dependency 'rdf-vocab'
   spec.add_dependency 'disposable', '~> 0.4.5'
+  spec.add_dependency 'faraday', '< 1.0'
 
   spec.add_development_dependency "bundler", "> 1.16.0", "< 3"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Trey Pendragon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-17 00:00:00.000000000 Z
+date: 2020-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.5
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -449,8 +463,6 @@ files:
 - db/migrate/20180212092225_create_updated_at_index.rb
 - db/migrate/20180802220739_add_optimistic_locking_to_orm_resources.rb
 - db/schema.rb
-- db/seeds.rb
-- gemfiles/activerecord_5_1.gemfile
 - gemfiles/activerecord_5_2.gemfile
 - gemfiles/activerecord_6_0.gemfile
 - lib/config/database_connection.rb
@@ -463,6 +475,7 @@ files:
 - lib/valkyrie/engine.rb
 - lib/valkyrie/id.rb
 - lib/valkyrie/indexers/access_controls_indexer.rb
+- lib/valkyrie/logging.rb
 - lib/valkyrie/metadata_adapter.rb
 - lib/valkyrie/persistence.rb
 - lib/valkyrie/persistence/buffered_persister.rb

data/db/seeds.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-# This file should contain all the record creation needed to seed the database with its default values.
-# The data can then be loaded with the rails db:seed command (or created alongside the database with db:setup).
-#
-# Examples:
-#
-#   movies = Movie.create([{ name: 'Star Wars' }, { name: 'Lord of the Rings' }])
-#   Character.create(name: 'Luke', movie: movies.first)

data/gemfiles/activerecord_5_1.gemfile

@@ -1,10 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "activerecord", "~> 5.1.0"
-gem "ldp"
-gem "pg"
-gem "rsolr"
-
-gemspec path: "../"