valkyrie 1.7.1 → 2.0.0.RC1

data/lib/valkyrie/persistence/solr.rb

@@ -2,13 +2,6 @@
 module Valkyrie::Persistence
   # Implements the DataMapper Pattern to store metadata into Solr
   module Solr
-    # Deprecation to allow us to make rsolr an optional dependency
-    path = Bundler.definition.gemfiles.first
-    matches = File.readlines(path).select { |l| l =~ /gem ['"]rsolr\b/ }
-    if matches.empty?
-      warn "[DEPRECATION] rsolr will not be included as a dependency in Valkyrie's gemspec as of the next major release. Please add the gem directly to your Gemfile if you use a solr adapter."
-    end
-    require 'valkyrie/persistence/postgres/metadata_adapter'
     require 'valkyrie/persistence/solr/metadata_adapter'
     require 'valkyrie/persistence/solr/composite_indexer'
   end

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

@@ -64,11 +64,6 @@ module Valkyrie::Persistence::Solr
       Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer, adapter: self)
     end
 
-    def standardize_query_result?
-      Valkyrie.warn_about_standard_queries! if Valkyrie.config.standardize_query_result != true
-      Valkyrie.config.standardize_query_result == true
-    end
-
     # Class modeling the indexer for cases where indexing is *not* performed
     class NullIndexer
       # @note this is a no-op

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

@@ -41,25 +41,16 @@ module Valkyrie::Persistence::Solr
       if resource_attributes[:created_at]
         DateTime.parse(resource_attributes[:created_at].to_s).utc.iso8601
       else
-        Time.current.utc.iso8601(6)
+        Time.current.utc.iso8601
       end
     end
 
-    # @return [String] ISO-8601 timestamp in UTC of the updated_at for solr
-    # @note Solr stores its own updated_at timestamp, but for performance
-    # reasons we're generating our own. Without doing so, every time we add a
-    # new document we'd have to do a GET to find out the timestamp.
-    def updated_at
-      Time.current.utc.iso8601(6)
-    end
-
     # @return [Hash] Solr document to index.
     def to_h
       {
         "id": id,
         "join_id_ssi": "id-#{id}",
-        "created_at_dtsi": created_at,
-        "updated_at_dtsi": updated_at
+        "created_at_dtsi": created_at
       }.merge(add_single_values(attribute_hash)).merge(lock_hash)
     end
 

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

@@ -26,7 +26,7 @@ module Valkyrie::Persistence::Solr
     # Access the Class for the Valkyrie Resource
     # @return [Class]
     def resource_klass
-      Valkyrie.config.resource_class_resolver.call(internal_resource)
+      internal_resource.constantize
     end
 
     # Access the String specifying the Valkyrie Resource type in the Solr Document
@@ -54,7 +54,7 @@ module Valkyrie::Persistence::Solr
     # Construct a Time object from the datestamp for the date of the last resource update indexed in Solr
     # @return [Time]
     def updated_at
-      DateTime.parse((solr_document["updated_at_dtsi"] || solr_document["timestamp"] || solr_document["created_at_dtsi"]).to_s).utc
+      DateTime.parse(solr_document["timestamp"] || solr_document.fetch("created_at_dtsi").to_s).utc
     end
 
     # Construct the OptimisticLockToken object using the "_version_" field value in the Solr Document

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

@@ -3,14 +3,14 @@ module Valkyrie::Persistence::Solr::Queries
   # Responsible for efficiently returning all {Valkyrie::Resource}s which
   # reference a {Valkyrie::Resource} in a given property.
   class FindInverseReferencesQuery
-    attr_reader :id, :property, :connection, :resource_factory
+    attr_reader :resource, :property, :connection, :resource_factory
 
     # @param [Valkyrie::Resource] resource
     # @param [String] property
     # @param [RSolr::Client] connection
     # @param [ResourceFactory] resource_factory
-    def initialize(resource: nil, id: nil, property:, connection:, resource_factory:)
-      @id = id ? id : resource.id
+    def initialize(resource:, property:, connection:, resource_factory:)
+      @resource = resource
       @property = property
       @connection = connection
       @resource_factory = resource_factory
@@ -39,7 +39,7 @@ module Valkyrie::Persistence::Solr::Queries
     # @note the field used here is a _ssim dynamic field and the value is prefixed by "id-"
     # @return [Hash]
     def query
-      "#{property}_ssim:id-#{id}"
+      "#{property}_ssim:id-#{resource.id}"
     end
   end
 end

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

@@ -3,18 +3,17 @@ module Valkyrie::Persistence::Solr::Queries
   # Responsible for returning all members of a given resource as
   # {Valkyrie::Resource}s
   class FindMembersQuery
-    attr_reader :resource, :connection, :resource_factory, :model, :standardize_query_result
+    attr_reader :resource, :connection, :resource_factory, :model
 
     # @param [Valkyrie::Resource] resource
     # @param [RSolr::Client] connection
     # @param [ResourceFactory] resource_factory
     # @param [Class] model
-    def initialize(resource:, connection:, resource_factory:, model:, standardize_query_result:)
+    def initialize(resource:, connection:, resource_factory:, model:)
       @resource = resource
       @connection = connection
       @resource_factory = resource_factory
       @model = model
-      @standardize_query_result = standardize_query_result
     end
 
     # Iterate over each Solr Document and convert each Document into a Valkyrie Resource
@@ -29,14 +28,8 @@ module Valkyrie::Persistence::Solr::Queries
     # @yield [Valkyrie::Resource]
     def each
       return [] unless resource.id.present?
-      if standardize_query_result
-        member_ids.map { |id| unordered_members.find { |member| member.id == id } }.reject(&:nil?).each do |member|
-          yield member
-        end
-      else
-        unordered_members.sort_by { |x| member_ids.index(x.id) }.each do |member|
-          yield member
-        end
+      member_ids.map { |id| unordered_members.find { |member| member.id == id } }.reject(&:nil?).each do |member|
+        yield member
       end
     end
 

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

@@ -70,8 +70,7 @@ module Valkyrie::Persistence::Solr
         resource: resource,
         model: model,
         connection: connection,
-        resource_factory: resource_factory,
-        standardize_query_result: adapter.standardize_query_result?
+        resource_factory: resource_factory
       ).run
     end
 
@@ -92,11 +91,9 @@ module Valkyrie::Persistence::Solr
     # @param [Valkyrie::Resource] referenced resource
     # @param [Symbol, String] property
     # @return [Array<Valkyrie::Resource>] related resources
-    def find_inverse_references_by(resource: nil, id: nil, property:)
-      raise ArgumentError, "Provide resource or id" unless resource || id
-      ensure_persisted(resource) if resource
-      id ||= resource.id
-      Valkyrie::Persistence::Solr::Queries::FindInverseReferencesQuery.new(id: id, property: property, connection: connection, resource_factory: resource_factory).run
+    def find_inverse_references_by(resource:, property:)
+      ensure_persisted(resource)
+      Valkyrie::Persistence::Solr::Queries::FindInverseReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
     end
 
     # Construct the Valkyrie::Persistence::CustomQueryContainer object using this query service

data/lib/valkyrie/resource.rb

@@ -15,13 +15,26 @@ module Valkyrie
   # @see lib/valkyrie/specs/shared_specs/resource.rb
   class Resource < Dry::Struct
     include Draper::Decoratable
-    constructor_type :schema
+    # Allows a Valkyrie::Resource to be instantiated without providing every
+    # available key, and makes sure the defaults are set up if no value is
+    # given.
+    def self.allow_nonexistent_keys
+      nil_2_undef = ->(v) { v.nil? ? Dry::Types::Undefined : v }
+      transform_types do |type|
+        current_meta = type.meta.merge(omittable: true)
+        if type.default?
+          type.constructor(nil_2_undef).meta(current_meta)
+        else
+          type.meta(current_meta)
+        end
+      end
+    end
 
     # Overridden to provide default attributes.
     # @note The current theory is that we should use this sparingly.
     def self.inherited(subclass)
       super(subclass)
-      subclass.constructor_type :schema
+      subclass.allow_nonexistent_keys
       subclass.attribute :id, Valkyrie::Types::ID.optional, internal: true
       subclass.attribute :internal_resource, Valkyrie::Types::Any.default(subclass.to_s), internal: true
       subclass.attribute :created_at, Valkyrie::Types::DateTime.optional, internal: true
@@ -34,17 +47,6 @@ module Valkyrie
       schema.keys.without(:new_record)
     end
 
-    def self.new(attributes = default_attributes)
-      if attributes.is_a?(Hash) && attributes.keys.map(&:class).uniq.include?(String)
-        warn "[DEPRECATION] Instantiating a Valkyrie::Resource with strings as keys has " \
-             "been deprecated and will be removed in the next major release. " \
-             "Please use symbols instead." \
-             "Called from #{Gem.location_of_caller.join(':')}"
-        attributes = attributes.symbolize_keys
-      end
-      super
-    end
-
     # Define an attribute. Attributes are used to describe resources.
     # @param name [Symbol]
     # @param type [Dry::Types::Type]
@@ -97,55 +99,12 @@ module Valkyrie
       self.class.optimistic_locking_enabled?
     end
 
-    class DeprecatedHashWrite < Hash
-      def []=(_k, _v)
-        if @soft_frozen
-          warn "[DEPRECATION] Writing directly to attributes has been deprecated." \
-            " Please use #set_value(k, v) instead or #dup first." \
-            " In the next major version, this hash will be frozen. \n" \
-            "Called from #{Gem.location_of_caller.join(':')}"
-        end
-        super
-      end
-
-      def delete(*_args)
-        if @soft_frozen
-          warn "[DEPRECATION] Writing directly to attributes has been deprecated." \
-            " Please use #set_value(k, v) instead or #dup first." \
-            " In the next major version, this hash will be frozen. \n" \
-            "Called from #{Gem.location_of_caller.join(':')}"
-        end
-        super
-      end
-
-      def delete_if(*_args)
-        if @soft_frozen
-          warn "[DEPRECATION] Writing directly to attributes has been deprecated." \
-            " Please use #set_value(k, v) instead or #dup first." \
-            " In the next major version, this hash will be frozen. \n" \
-            "Called from #{Gem.location_of_caller.join(':')}"
-        end
-        super
-      end
-
-      def soft_freeze!
-        @soft_frozen = true
-        self
-      end
-
-      def soft_thaw!
-        @soft_frozen = false
-        self
-      end
-
-      def dup
-        super.soft_thaw!
-      end
+    def attributes
+      super.dup.freeze
     end
 
-    # @return [Hash] Hash of attributes
-    def attributes
-      DeprecatedHashWrite.new.merge(to_h).soft_freeze!
+    def dup
+      new({})
     end
 
     # @param name [Symbol] Attribute name
@@ -196,7 +155,7 @@ module Valkyrie
     # @param name [#to_sym] the name of the attribute to read
     def [](name)
       super(name.to_sym)
-    rescue NoMethodError
+    rescue Dry::Struct::MissingAttributeError
       nil
     end
 
@@ -205,7 +164,7 @@ module Valkyrie
     # @param key [#to_sym] the name of the attribute to set
     # @param value [] the value to set key to.
     def set_value(key, value)
-      instance_variable_set(:"@#{key}", self.class.schema[key.to_sym].call(value))
+      @attributes[key.to_sym] = self.class.schema[key.to_sym].call(value)
     end
   end
 end

data/lib/valkyrie/specs/shared_specs.rb

@@ -1,9 +1,4 @@
 # frozen_string_literal: true
-module Valkyrie
-  # Define a wrapper namespace for test resources.
-  module Specs
-  end
-end
 require 'valkyrie/specs/shared_specs/persister.rb'
 require 'valkyrie/specs/shared_specs/queries.rb'
 require 'valkyrie/specs/shared_specs/metadata_adapter'

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

@@ -2,25 +2,25 @@
 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 Valkyrie::Specs::CustomResource < Valkyrie::Resource
+    class CustomResource < Valkyrie::Resource
       include Valkyrie::Resource::AccessControls
       attribute :title
       attribute :member_ids
       attribute :nested_resource
     end
-    class Valkyrie::Specs::CustomChangeSet < Valkyrie::ChangeSet
+    class CustomChangeSet < Valkyrie::ChangeSet
       self.fields = [:title]
     end
   end
   after do
-    Valkyrie::Specs.send(:remove_const, :CustomResource)
-    Valkyrie::Specs.send(:remove_const, :CustomChangeSet)
+    Object.send(:remove_const, :CustomResource)
+    Object.send(:remove_const, :CustomChangeSet)
   end
 
   subject { change_set_persister }
-  let(:resource_class) { Valkyrie::Specs::CustomResource }
+  let(:resource_class) { CustomResource }
   let(:resource) { resource_class.new }
-  let(:change_set) { Valkyrie::Specs::CustomChangeSet.new(resource) }
+  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) }
@@ -32,7 +32,7 @@ RSpec.shared_examples 'a Valkyrie::ChangeSetPersister' do |*_flags|
     it "saves a resource and returns it" do
       output = subject.save(change_set: change_set)
 
-      expect(output).to be_kind_of Valkyrie::Specs::CustomResource
+      expect(output).to be_kind_of CustomResource
       expect(output).to be_persisted
     end
   end
@@ -40,7 +40,7 @@ RSpec.shared_examples 'a Valkyrie::ChangeSetPersister' do |*_flags|
   describe "#delete" do
     it "deletes a resource" do
       output = subject.save(change_set: change_set)
-      subject.delete(change_set: Valkyrie::Specs::CustomChangeSet.new(output))
+      subject.delete(change_set: CustomChangeSet.new(output))
 
       expect do
         subject.metadata_adapter.query_service.find_by(id: output.id)
@@ -50,7 +50,7 @@ RSpec.shared_examples 'a Valkyrie::ChangeSetPersister' do |*_flags|
 
   describe "#save_all" do
     it "saves multiple change_sets and returns them" do
-      change_set2 = Valkyrie::Specs::CustomChangeSet.new(resource_class.new)
+      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

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

@@ -2,7 +2,6 @@
 RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
   before do
     raise 'persister must be set with `let(:persister)`' unless defined? persister
-    raise 'query_service must be set with `let(:query_service)`' unless defined? query_service
     class CustomResource < Valkyrie::Resource
       include Valkyrie::Resource::AccessControls
       attribute :title
@@ -93,7 +92,6 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     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
-    expect(book.updated_at > book.created_at).to eq true
   end
 
   it "can handle Boolean RDF properties" do
@@ -237,7 +235,7 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
   end
 
   it "can store Valkyrie::IDs" do
-    shared_title = persister.save(resource: resource_class.new)
+    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")

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

@@ -3,27 +3,25 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   before do
     raise 'adapter must be set with `let(:adapter)`' unless
       defined? adapter
-    class Valkyrie::Specs::CustomResource < Valkyrie::Resource
-      attribute :alternate_ids, Valkyrie::Types::Set.of(Valkyrie::Types::ID)
+    class CustomResource < Valkyrie::Resource
+      attribute :alternate_ids, Valkyrie::Types::Array
       attribute :title
       attribute :member_ids, Valkyrie::Types::Array
       attribute :a_member_of, Valkyrie::Types::Array
       attribute :an_ordered_member_of, Valkyrie::Types::Array.meta(ordered: true)
     end
-    class Valkyrie::Specs::SecondResource < Valkyrie::Resource
+    class SecondResource < Valkyrie::Resource
     end
   end
   after do
-    Valkyrie::Specs.send(:remove_const, :CustomResource)
-    Valkyrie::Specs.send(:remove_const, :SecondResource)
+    Object.send(:remove_const, :CustomResource)
+    Object.send(:remove_const, :SecondResource)
   end
-  let(:resource_class) { Valkyrie::Specs::CustomResource }
+  let(:resource_class) { CustomResource }
   let(:query_service) { adapter.query_service } unless defined? query_service
   let(:persister) { adapter.persister }
   subject { adapter.query_service }
 
-  before { allow(Valkyrie.config).to receive(:standardize_query_result).and_return(true) }
-
   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) }
@@ -32,7 +30,6 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   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_parents).with_keywords(:resource) }
 
   describe ".find_all" do
@@ -47,12 +44,12 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   describe ".find_all_of_model" do
     it "returns all of that model" do
       persister.save(resource: resource_class.new)
-      resource2 = persister.save(resource: Valkyrie::Specs::SecondResource.new)
+      resource2 = persister.save(resource: SecondResource.new)
 
-      expect(query_service.find_all_of_model(model: Valkyrie::Specs::SecondResource).map(&:id)).to contain_exactly resource2.id
+      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: Valkyrie::Specs::SecondResource).to_a).to eq []
+      expect(query_service.find_all_of_model(model: SecondResource).to_a).to eq []
     end
   end
 
@@ -93,12 +90,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       expect(found).to be_persisted
     end
 
-    it 'raises a Valkyrie::Persistence::ObjectNotFoundError when persisted objects do not have alternate_ids' do
-      persister.save(resource: Valkyrie::Specs::SecondResource.new)
-      expect { query_service.find_by_alternate_identifier(alternate_identifier: Valkyrie::ID.new("123123123")) }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
-    end
-
-    it "raises a Valkyrie::Persistence::ObjectNotFoundError for a non-found alternate identifier" do
+    it "returns a Valkyrie::Persistence::ObjectNotFoundError for a non-found alternate identifier" do
       expect { query_service.find_by_alternate_identifier(alternate_identifier: Valkyrie::ID.new("123123123")) }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
     end
 
@@ -193,7 +185,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       end
 
       context "when the model doesn't have member_ids" do
-        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:parent) { persister.save(resource: SecondResource.new) }
 
         it "returns an empty array" do
           expect(subject.to_a).to eq []
@@ -202,12 +194,12 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     end
 
     context "filtering by model" do
-      subject { query_service.find_members(resource: parent, model: Valkyrie::Specs::SecondResource) }
+      subject { query_service.find_members(resource: parent, model: SecondResource) }
 
       context "when the object has members" do
-        let(:child1) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:child1) { persister.save(resource: SecondResource.new) }
         let(:child2) { persister.save(resource: resource_class.new) }
-        let(:child3) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:child3) { persister.save(resource: SecondResource.new) }
         let(:parent) { persister.save(resource: resource_class.new(member_ids: [child3.id, child2.id, child1.id])) }
 
         it "returns all a resource's members in order" do
@@ -286,7 +278,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
           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)
-          persister.save(resource: Valkyrie::Specs::SecondResource.new)
+          persister.save(resource: SecondResource.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
@@ -304,32 +296,12 @@ RSpec.shared_examples 'a Valkyrie query provider' do
           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)
-          persister.save(resource: Valkyrie::Specs::SecondResource.new)
+          persister.save(resource: SecondResource.new)
 
           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
     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)
-        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)
-        persister.save(resource: Valkyrie::Specs::SecondResource.new)
-
-        expect(query_service.find_inverse_references_by(id: parent.id, property: :a_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
-      end
-    end
-
-    context "when neither id nor resource is passed" do
-      it "raises an error" do
-        expect { query_service.find_inverse_references_by(property: :a_member_of) }.to raise_error ArgumentError
-      end
-    end
-
     context "when the resource is not saved" do
       it "raises an error" do
         parent = resource_class.new
@@ -364,7 +336,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     end
 
     context "when the model doesn't have member_ids" do
-      let(:child1) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+      let(:child1) { persister.save(resource: SecondResource.new) }
 
       it "returns an empty array if there are none" do
         expect(query_service.find_parents(resource: child1).to_a).to eq []