valkyrie 1.1.2 → 1.2.0.rc1

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

@@ -4,12 +4,11 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     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
-      attribute :single_value, Valkyrie::Types::String
+      attribute :single_value, Valkyrie::Types::String.optional
     end
   end
   after do
@@ -31,16 +30,12 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     expect(saved.id).not_to be_blank
   end
 
-  it "does not save non-array properties" do
-    resource.single_value = "A Single Value"
-    expect { persister.save(resource: resource) }.to raise_error ::Valkyrie::Persistence::UnsupportedDatatype
-  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
+    expect(persister.save_all(resources: [])).to eq []
   end
 
   it "can save nested resources" do
@@ -51,6 +46,20 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     expect(reloaded.nested_resource.first.title).to eq ["Nested"]
   end
 
+  it "can persist single values" do
+    resource.single_value = "A single value"
+
+    output = persister.save(resource: resource)
+
+    expect(output.single_value).to eq "A single value"
+  end
+
+  it "returns nil for an unset single value" do
+    output = persister.save(resource: resource_class.new)
+
+    expect(output.single_value).to be_nil
+  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)
@@ -281,4 +290,122 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     persister.wipe!
     expect(query_service.find_all.to_a.length).to eq 0
   end
+
+  context "optimistic locking" do
+    before do
+      class MyLockingResource < Valkyrie::Resource
+        enable_optimistic_locking
+        attribute :title
+      end
+    end
+
+    after do
+      ActiveSupport::Dependencies.remove_constant("MyLockingResource")
+    end
+
+    describe "#save" do
+      context "when creating a resource" do
+        it "returns the value of the system-generated optimistic locking attribute on the resource" do
+          resource = MyLockingResource.new(title: ["My Locked Resource"])
+          saved_resource = persister.save(resource: resource)
+          expect(saved_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
+        end
+      end
+
+      context "when updating a resource with a correct lock token" do
+        it "successfully saves the resource and returns the updated value of the optimistic locking attribute" do
+          resource = MyLockingResource.new(title: ["My Locked Resource"])
+          initial_resource = persister.save(resource: resource)
+          updated_resource = persister.save(resource: initial_resource)
+          expect(initial_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK])
+            .not_to eq updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+        end
+      end
+
+      context "when updating a resource with an incorrect lock token" do
+        it "raises a Valkyrie::Persistence::StaleObjectError" do
+          resource = MyLockingResource.new(title: ["My Locked Resource"])
+          resource = persister.save(resource: resource)
+          # 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)
+        end
+      end
+
+      context "when lock token is nil" do
+        it "successfully saves the resource and returns the updated value of the optimistic locking attribute" do
+          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}=", [])
+          updated_resource = persister.save(resource: initial_resource)
+          expect(initial_token.serialize)
+            .not_to eq(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first.serialize)
+          expect(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
+        end
+      end
+
+      context "when there is a token, but it's for a different adapter (migration use case)" do
+        it "successfully saves the resource and returns a token for the adapter that was saved to" do
+          resource = MyLockingResource.new(title: ["My Locked Resource"])
+          initial_resource = persister.save(resource: resource)
+          new_token = Valkyrie::Persistence::OptimisticLockToken.new(
+            adapter_id: Valkyrie::ID.new("fake_adapter"),
+            token: "token"
+          )
+          initial_resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", [new_token])
+          updated_resource = persister.save(resource: initial_resource)
+          expect(new_token.serialize)
+            .not_to eq(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first.serialize)
+          expect(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
+        end
+      end
+    end
+
+    describe "#save_all" do
+      context "when creating multiple resources" do
+        it "returns an array of resources with their system-generated optimistic locking attributes" do
+          resource1 = MyLockingResource.new(title: ["My Locked Resource 1"])
+          resource2 = MyLockingResource.new(title: ["My Locked Resource 2"])
+          resource3 = MyLockingResource.new(title: ["My Locked Resource 3"])
+          saved_resources = persister.save_all(resources: [resource1, resource2, resource3])
+          saved_resources.each do |saved_resource|
+            expect(saved_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
+          end
+        end
+      end
+
+      context "when updating multiple resources that all have a correct lock token" do
+        it "saves the resources and returns them with updated values of the optimistic locking attribute" do
+          resource1 = MyLockingResource.new(title: ["My Locked Resource 1"])
+          resource2 = MyLockingResource.new(title: ["My Locked Resource 2"])
+          resource3 = MyLockingResource.new(title: ["My Locked Resource 3"])
+          saved_resources = persister.save_all(resources: [resource1, resource2, resource3])
+          initial_lock_tokens = saved_resources.map do |r|
+            r[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+          end
+          updated_resources = persister.save_all(resources: saved_resources)
+          updated_lock_tokens = updated_resources.map do |r|
+            r[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+          end
+          expect(initial_lock_tokens & updated_lock_tokens).to be_empty
+        end
+      end
+
+      context "when one of the resources has an incorrect lock token" do
+        it "raises a Valkyrie::Persistence::StaleObjectError" do
+          resource1 = MyLockingResource.new(title: ["My Locked Resource 1"])
+          resource2 = MyLockingResource.new(title: ["My Locked Resource 2"])
+          resource3 = MyLockingResource.new(title: ["My Locked Resource 3"])
+          resource1, resource2, resource3 = persister.save_all(resources: [resource1, resource2, resource3])
+          # update a resource in the datastore to make its token stale
+          persister.save(resource: resource2)
+
+          expect { persister.save_all(resources: [resource1, resource2, resource3]) }
+            .to raise_error(Valkyrie::Persistence::StaleObjectError, "Valkyrie::Persistence::StaleObjectError")
+        end
+      end
+    end
+  end
 end

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

@@ -4,14 +4,12 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     raise 'adapter must be set with `let(:adapter)`' unless
       defined? adapter
     class CustomResource < Valkyrie::Resource
-      attribute :id, Valkyrie::Types::ID.optional
       attribute :alternate_ids, Valkyrie::Types::Array
       attribute :title
       attribute :member_ids, Valkyrie::Types::Array
       attribute :a_member_of
     end
     class SecondResource < Valkyrie::Resource
-      attribute :id, Valkyrie::Types::ID.optional
     end
   end
   after do
@@ -291,4 +289,24 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       expect(query_service.custom_queries.find_by_user_id).to eq 1
     end
   end
+
+  context "optimistic locking" do
+    before do
+      class CustomLockingQueryResource < Valkyrie::Resource
+        enable_optimistic_locking
+        attribute :title
+      end
+    end
+    after do
+      Object.send(:remove_const, :CustomLockingQueryResource)
+    end
+
+    it "retrieves the lock token and casts it to optimistic_lock_token attribute" do
+      resource = CustomLockingQueryResource.new(title: "My Title")
+      resource = persister.save(resource: resource)
+      resource = query_service.find_by(id: resource.id)
+      # we can't know the value in the general case
+      expect(resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
+    end
+  end
 end

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

@@ -53,7 +53,6 @@ RSpec.shared_examples 'a Valkyrie::Resource' do
   describe "#human_readable_type" do
     before do
       class MyCustomResource < Valkyrie::Resource
-        attribute :id, Valkyrie::Types::ID.optional
         attribute :title, Valkyrie::Types::Set
       end
     end

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

@@ -6,7 +6,6 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
     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

data/lib/valkyrie/storage/fedora.rb

@@ -2,10 +2,13 @@
 module Valkyrie::Storage
   # Implements the DataMapper Pattern to store binary data in fedora
   class Fedora
-    attr_reader :connection
+    attr_reader :connection, :base_path
     PROTOCOL = 'fedora://'
-    def initialize(connection:)
+
+    # @param [Ldp::Client] connection
+    def initialize(connection:, base_path: "/")
       @connection = connection
+      @base_path = base_path
     end
 
     # @param id [Valkyrie::ID]
@@ -29,14 +32,13 @@ module Valkyrie::Storage
     # @param resource [Valkyrie::Resource]
     # @return [Valkyrie::StorageAdapter::StreamFile]
     def upload(file:, original_filename:, resource:)
-      # TODO: this is a very naive aproach. Change to PCDM
-      identifier = resource.id.to_uri + '/original'
-      ActiveFedora::File.new(identifier) do |af|
-        af.content = file
-        af.original_name = original_filename
-        af.save!
-        af.metadata.set_value(:type, af.metadata.type + [::RDF::URI('http://pcdm.org/use#OriginalFile')])
-        af.metadata.save
+      identifier = id_to_uri(resource.id) + '/original'
+      connection.http.put do |request|
+        request.url identifier
+        request.headers['Content-Type'] = file.content_type
+        request.headers['Content-Disposition'] = "attachment; filename=\"#{original_filename}\""
+        request.headers['digest'] = "sha1=#{Digest::SHA1.file(file)}"
+        request.body = file.tempfile.read
       end
       find_by(id: Valkyrie::ID.new(identifier.to_s.sub(/^.+\/\//, PROTOCOL)))
     end
@@ -44,22 +46,22 @@ module Valkyrie::Storage
     # Delete the file in Fedora associated with the given identifier.
     # @param id [Valkyrie::ID]
     def delete(id:)
-      ActiveFedora::File.new(active_fedora_identifier(id: id)).ldp_source.delete
+      connection.http.delete(fedora_identifier(id: id))
     end
 
     class IOProxy
       # @param response [Ldp::Resource::BinarySource]
       attr_reader :size
-      def initialize(source, size)
+      def initialize(source)
         @source = source
-        @size = size
+        @size = source.size
       end
       delegate :each, :read, :rewind, to: :io
 
       # There is no streaming support in faraday (https://github.com/lostisland/faraday/pull/604)
       # @return [StringIO]
       def io
-        @io ||= StringIO.new(@source.get.response.body)
+        @io ||= StringIO.new(@source)
       end
     end
     private_constant :IOProxy
@@ -68,17 +70,24 @@ module Valkyrie::Storage
 
       # @return [IOProxy]
       def response(id:)
-        af_file = ActiveFedora::File.new(active_fedora_identifier(id: id))
-        raise Valkyrie::StorageAdapter::FileNotFound if af_file.ldp_source.new?
-        IOProxy.new(af_file.ldp_source, af_file.size)
+        response = connection.http.get(fedora_identifier(id: id))
+        raise Valkyrie::StorageAdapter::FileNotFound unless response.success?
+        IOProxy.new(response.body)
       end
 
       # Translate the Valkrie ID into a URL for the fedora file
       # @return [RDF::URI]
-      def active_fedora_identifier(id:)
-        scheme = URI(ActiveFedora.config.credentials[:url]).scheme
-        identifier = id.to_s.sub(PROTOCOL, "#{scheme}://")
+      def fedora_identifier(id:)
+        identifier = id.to_s.sub(PROTOCOL, "#{connection.http.scheme}://")
         RDF::URI(identifier)
       end
+
+      def id_to_uri(id)
+        RDF::URI("#{connection_prefix}/#{CGI.escape(id.to_s)}")
+      end
+
+      def connection_prefix
+        "#{connection.http.url_prefix}/#{base_path}"
+      end
   end
 end

data/lib/valkyrie/types.rb

@@ -3,9 +3,11 @@ module Valkyrie
   # Namespace for Dry::Types types.
   #  Includes Dry::Types built-in types and defines custom Valkyrie types
   #
+  # Types allow your models to automatically cast attributes to the appropriate type
+  # or even fail to instantiate should you give an inappropriate type.
+  #
   # @example Use types in property definitions on a resource
   #   class Book < Valkyrie::Resource
-  #     attribute :id, Valkyrie::Types::ID.optional
   #     attribute :title, Valkyrie::Types::Set.optional  # default type if none is specified
   #     attribute :member_ids, Valkyrie::Types::Array
   #   end
@@ -38,6 +40,14 @@ module Valkyrie
       end
     end
 
+    # Optimistic Lock Token
+    OptimisticLockToken =
+      Dry::Types::Definition
+      .new(::Valkyrie::Persistence::OptimisticLockToken)
+      .constructor do |input|
+        Valkyrie::Persistence::OptimisticLockToken.deserialize(input)
+      end
+
     # Used for casting {Valkyrie::Resources} if possible.
     Anything = Valkyrie::Types::Any.constructor do |value|
       if value.respond_to?(:fetch) && value.fetch(:internal_resource, nil)

data/lib/valkyrie/version.rb

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

data/lib/valkyrie.rb

@@ -13,10 +13,8 @@ require 'rdf'
 require 'valkyrie/rdf_patches'
 require 'json/ld'
 require 'logger'
-require 'active_triples'
 require 'rdf/vocab'
 require 'rails'
-require 'active_fedora'
 
 module Valkyrie
   require 'valkyrie/id'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0.rc1
 platform: ruby
 authors:
 - Trey Pendragon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -441,7 +441,6 @@ files:
 - bin/rspec
 - bin/setup
 - browserslist
-- config/fedora.yml
 - config/valkyrie.yml
 - db/config.yml
 - db/migrate/20160111215816_enable_uuid_extension.rb
@@ -451,6 +450,7 @@ files:
 - db/migrate/20171011224121_create_path_gin_index.rb
 - db/migrate/20171204224121_create_internal_resource_index.rb
 - db/migrate/20180212092225_create_updated_at_index.rb
+- db/migrate/20180802220739_add_optimistic_locking_to_orm_resources.rb
 - db/schema.rb
 - db/seeds.rb
 - lib/config/database_connection.rb
@@ -485,6 +485,7 @@ files:
 - lib/valkyrie/persistence/memory/metadata_adapter.rb
 - lib/valkyrie/persistence/memory/persister.rb
 - lib/valkyrie/persistence/memory/query_service.rb
+- lib/valkyrie/persistence/optimistic_lock_token.rb
 - lib/valkyrie/persistence/postgres.rb
 - lib/valkyrie/persistence/postgres/metadata_adapter.rb
 - lib/valkyrie/persistence/postgres/orm.rb
@@ -567,12 +568,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: An ORM using the Data Mapper pattern, specifically built to solve Digital

data/config/fedora.yml

@@ -1,10 +0,0 @@
-development:
-  user: fedoraAdmin
-  password: fedoraAdmin
-  url: http://localhost:<%= ENV['FCREPO_DEVELOPMENT_PORT'] || 8986 %>/rest
-  base_path: /dev
-test:
-  user: fedoraAdmin
-  password: fedoraAdmin
-  url: http://localhost:<%= ENV['FCREPO_TEST_PORT'] || 8988 %>/rest
-  base_path: /test