saviour 0.5.10 → 0.5.11

data/gemfiles/{5.0.gemfile → 5.2.gemfile}

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "codeclimate-test-reporter", :group => :test, :require => nil
-gem "activesupport", "~> 5.0.0"
-gem "activerecord", "~> 5.0.0"
+gem "activesupport", "~> 5.2.0"
+gem "activerecord", "~> 5.2.0"
 
 gemspec :path => "../"

data/lib/saviour.rb

@@ -1,6 +1,7 @@
 require 'saviour/version'
 require 'saviour/base_uploader'
 require 'saviour/file'
+require 'saviour/read_only_file'
 require 'saviour/local_storage'
 require 'saviour/s3_storage'
 require 'saviour/config'

data/lib/saviour/file.rb

@@ -5,13 +5,14 @@ module Saviour
     attr_reader :persisted_path
     attr_reader :source
 
-    def initialize(uploader_klass, model, attached_as)
+    def initialize(uploader_klass, model, attached_as, persisted_path = nil)
       @uploader_klass, @model, @attached_as = uploader_klass, model, attached_as
       @source_was = @source = nil
-    end
+      @persisted_path = persisted_path
 
-    def set_path!(path)
-      @persisted_path = path
+      if persisted_path
+        @model.instance_variable_set("@__uploader_#{@attached_as}_was", ReadOnlyFile.new(persisted_path))
+      end
     end
 
     def exists?
@@ -24,7 +25,6 @@ module Saviour
     end
 
     def delete
-      persisted? && Config.storage.delete(@persisted_path)
       @persisted_path = nil
       @source_was = nil
       @source = nil
@@ -48,10 +48,7 @@ module Saviour
 
     def clone
       return nil unless persisted?
-
-      new_file = Saviour::File.new(@uploader_klass, @model, @attached_as)
-      new_file.set_path! @persisted_path
-      new_file
+      Saviour::File.new(@uploader_klass, @model, @attached_as, @persisted_path)
     end
 
     def dup(new_model)
@@ -68,6 +65,7 @@ module Saviour
 
     def reload
       @model.instance_variable_set("@__uploader_#{@attached_as}", nil)
+      @model.instance_variable_set("@__uploader_#{@attached_as}_was", nil)
     end
 
     alias_method :url, :public_url
@@ -85,8 +83,8 @@ module Saviour
       @source_data = nil
       @source = object
 
-      if changed? && @model.respond_to?("#{@attached_as}_will_change!")
-        @model.send "#{@attached_as}_will_change!"
+      if changed? && @model.instance_variable_get("@__uploader_#{@attached_as}_was").nil?
+        @model.instance_variable_set("@__uploader_#{@attached_as}_was", clone)
       end
 
       @persisted_path = nil if object
@@ -162,6 +160,7 @@ module Saviour
           end
 
           @persisted_path = path
+          @model.instance_variable_set("@__uploader_#{@attached_as}_was", ReadOnlyFile.new(persisted_path))
           path
         end
       end
@@ -177,7 +176,7 @@ module Saviour
 
     def source_data
       @source_data ||= begin
-        @source.rewind
+        @source.rewind if @source.respond_to?(:rewind)
         @source.read
       end
     end

data/lib/saviour/integrator.rb

@@ -40,10 +40,8 @@ module Saviour
           define_method(attach_as) do
             instance_variable_get("@__uploader_#{attach_as}") || begin
               uploader_klass = Class.new(Saviour::BaseUploader, &block) if block
-              new_file = ::Saviour::File.new(uploader_klass, self, attach_as)
-
               layer = persistence_klass.new(self)
-              new_file.set_path!(layer.read(attach_as))
+              new_file = ::Saviour::File.new(uploader_klass, self, attach_as, layer.read(attach_as))
 
               instance_variable_set("@__uploader_#{attach_as}", new_file)
             end
@@ -57,10 +55,34 @@ module Saviour
             send(attach_as).present?
           end
 
+          define_method("#{attach_as}_was") do
+            instance_variable_get("@__uploader_#{attach_as}_was")
+          end
+
           define_method("#{attach_as}_changed?") do
             send(attach_as).changed?
           end
 
+          define_method(:changed_attributes) do
+            if send("#{attach_as}_changed?")
+              super().merge(attach_as => send("#{attach_as}_was"))
+            else
+              super()
+            end
+          end
+
+          define_method(:changes) do
+            if send("#{attach_as}_changed?")
+              super().merge(attach_as => send("#{attach_as}_change"))
+            else
+              super()
+            end
+          end
+
+          define_method("#{attach_as}_change") do
+            [send("#{attach_as}_was"), send(attach_as)]
+          end
+
           define_method("remove_#{attach_as}!") do |dependent: nil|
             if !dependent.nil? && ![:destroy, :ignore].include?(dependent)
               raise ArgumentError, ":dependent option must be either :destroy or :ignore"
@@ -69,9 +91,12 @@ module Saviour
             layer = persistence_klass.new(self)
 
             attachment_remover = proc do |attach_as|
+              layer.write(attach_as, nil)
+              deletion_path = send(attach_as).persisted_path
+              send(attach_as).delete
+
               work = proc do
-                send(attach_as).delete
-                layer.write(attach_as, nil)
+                Config.storage.delete(deletion_path) if deletion_path && send(attach_as).persisted_path.nil?
               end
 
               if ActiveRecord::Base.connection.current_transaction.open?

data/lib/saviour/life_cycle.rb

@@ -84,9 +84,25 @@ module Saviour
 
     def delete!
       DbHelpers.run_after_commit do
-        attached_files.each do |column|
-          @model.send(column).delete
+        pool = Concurrent::FixedThreadPool.new(Saviour::Config.concurrent_workers)
+
+        futures = attached_files.map do |column|
+          Concurrent::Future.execute(executor: pool) {
+            path = @model.send(column).persisted_path
+            Config.storage.delete(path) if path
+            @model.send(column).delete
+          }
         end
+
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          futures.each do |future|
+            future.value
+            raise(future.reason) if future.rejected?
+          end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination
       end
     end
 

data/lib/saviour/model.rb

@@ -26,6 +26,7 @@ module Saviour
       self.class.attached_files.each do |attach_as|
         duped[attach_as] = nil
         duped.instance_variable_set("@__uploader_#{attach_as}", send(attach_as).dup(duped))
+        duped.instance_variable_set("@__uploader_#{attach_as}_was", nil)
       end
 
       duped

data/lib/saviour/read_only_file.rb

@@ -0,0 +1,35 @@
+module Saviour
+  class ReadOnlyFile
+    attr_reader :persisted_path
+
+    def initialize(persisted_path)
+      @persisted_path = persisted_path
+    end
+
+    def exists?
+      persisted? && Config.storage.exists?(@persisted_path)
+    end
+
+    def read
+      return nil unless persisted?
+      Config.storage.read(@persisted_path)
+    end
+
+    def public_url
+      return nil unless persisted?
+      Config.storage.public_url(@persisted_path)
+    end
+    alias_method :url, :public_url
+
+    def ==(another_file)
+      return false unless another_file.is_a?(Saviour::File) || another_file.is_a?(ReadOnlyFile)
+      return false unless another_file.persisted?
+
+      another_file.persisted_path == persisted_path
+    end
+
+    def persisted?
+      true
+    end
+  end
+end

data/lib/saviour/version.rb

@@ -1,3 +1,3 @@
 module Saviour
-  VERSION = "0.5.10"
+  VERSION = "0.5.11"
 end

data/saviour.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.2.0"
 
-  spec.add_dependency "activerecord", ">= 5.0", "< 5.2"
-  spec.add_dependency "activesupport", ">= 5.0"
+  spec.add_dependency "activerecord", ">= 5.1"
+  spec.add_dependency "activesupport", ">= 5.1"
   spec.add_dependency "concurrent-ruby", ">= 1.0.5"
 
   spec.add_development_dependency "bundler"

data/spec/feature/{concurrent_processors_spec.rb → concurrency_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "concurrent processors" do
+describe "concurrency on operations" do
   before { allow(Saviour::Config).to receive(:storage).and_return(Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com")) }
 
   if ENV['TRAVIS']
@@ -131,4 +131,52 @@ describe "concurrent processors" do
       expect((start_times[0] - start_times[-1]).abs).to be > WAIT_TIME
     end
   end
+
+  context 'on destroy' do
+    before do
+      allow(Saviour::Config.storage).to receive(:delete) { sleep WAIT_TIME }
+    end
+
+    def measure
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - starting
+    end
+
+    it 'works concurrently with 4 workers' do
+      Saviour::Config.concurrent_workers = 4
+
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt"),
+                        file_thumb: Saviour::StringSource.new("contents", "file_2.txt"),
+                        file_thumb_2: Saviour::StringSource.new("contents", "file_3.txt"),
+                        file_thumb_3: Saviour::StringSource.new("contents", "file_4.txt")
+
+      time = measure { a.destroy! }
+      expect(time).to be_within(THRESHOLD).of(WAIT_TIME)
+    end
+
+    it 'works in serial with 1 worker' do
+      Saviour::Config.concurrent_workers = 1
+
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt"),
+                        file_thumb: Saviour::StringSource.new("contents", "file_2.txt"),
+                        file_thumb_2: Saviour::StringSource.new("contents", "file_3.txt"),
+                        file_thumb_3: Saviour::StringSource.new("contents", "file_4.txt")
+
+      time = measure { a.destroy! }
+      expect(time).to be_within(THRESHOLD).of(WAIT_TIME * 4)
+    end
+
+    it 'concurrency can be adjusted' do
+      Saviour::Config.concurrent_workers = 2
+
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt"),
+                        file_thumb: Saviour::StringSource.new("contents", "file_2.txt"),
+                        file_thumb_2: Saviour::StringSource.new("contents", "file_3.txt"),
+                        file_thumb_3: Saviour::StringSource.new("contents", "file_4.txt")
+
+      time = measure { a.destroy! }
+      expect(time).to be_within(THRESHOLD).of(WAIT_TIME * 2)
+    end
+  end
 end

data/spec/feature/crud_workflows_spec.rb

@@ -123,6 +123,14 @@ describe "CRUD" do
         end
       end
     end
+
+    it "can be created from another saviour attachment" do
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+      b = klass.create! file: a.file
+
+      expect(b.file.read).to eq "contents"
+      expect(b.file.filename).to eq "file.txt"
+    end
   end
 
   describe "deletion" do
@@ -163,6 +171,23 @@ describe "CRUD" do
       expect(Saviour::Config.storage.read(a[:file])).to eq "foo"
     end
 
+    it "does not generate an extra query when saving the file with only attached changes" do
+      a = klass.create!
+
+      expect_to_yield_queries(count: 1) do
+        a.update_attributes! file: Saviour::StringSource.new("foo", "file.txt")
+      end
+    end
+
+    it "does generate an extra query when saving the file with an extra change" do
+      a = klass.create!
+
+      expect_to_yield_queries(count: 2) do
+        a.update_attributes! name: "Text",
+                             file: Saviour::StringSource.new("foo", "file.txt")
+      end
+    end
+
     context do
       let(:klass) {
         a = Class.new(Test) { include Saviour::Model }
@@ -174,9 +199,8 @@ describe "CRUD" do
       it "saves to db only once with multiple file attachments" do
         a = klass.create!
 
-        # 2 update's, first empty and then 1 with the two attributes
         expected_query = %Q{UPDATE "tests" SET "file" = '/store/dir/file.txt', "file_thumb" = '/store/dir/file.txt'}
-        expect_to_yield_queries(count: 2, including: [expected_query]) do
+        expect_to_yield_queries(count: 1, including: [expected_query]) do
           a.update_attributes!(
             file: Saviour::StringSource.new("foo", "file.txt"),
             file_thumb: Saviour::StringSource.new("foo", "file.txt")

data/spec/feature/dirty_spec.rb

@@ -3,11 +3,14 @@ require 'spec_helper'
 describe "dirty model" do
   before { allow(Saviour::Config).to receive(:storage).and_return(Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com")) }
 
-  it "provides changes and previous file" do
+  before do
     uploader = Class.new(Saviour::BaseUploader) { store_dir { "/store/dir" } }
-    klass = Class.new(Test) { include Saviour::Model }
-    klass.attach_file :file, uploader
-    a = klass.create!
+    @klass = Class.new(Test) { include Saviour::Model }
+    @klass.attach_file :file, uploader
+  end
+
+  it "provides changes and previous file" do
+    a = @klass.create!
 
     with_test_file("example.xml") do |xml_file|
       with_test_file("camaloon.jpg") do |jpg_file|
@@ -28,17 +31,76 @@ describe "dirty model" do
         expect(a.file_was.persisted?).to be_truthy
 
         expect(a.changed_attributes).to include("file" => a.file_was)
+        expect(a.changed).to eq ["file"]
+
+        expect(a.changed?).to be_truthy
+
+        expect(a.changes).to eq({"file" => [a.file_was, a.file]})
       end
     end
   end
 
+  it "provides changes on two changed attributes" do
+    a = @klass.create!
+
+    a.name = "Foo bar"
+    a.file = Saviour::StringSource.new("contents", "file.txt")
+
+    expect(a.changed.sort).to eq ["file", "name"]
+    a.save!
+
+    a.name = "Johny"
+    a.file = Saviour::StringSource.new("contents", "file_2.txt")
+
+    expect(a.changed.sort).to eq ["file", "name"]
+    expect(a.changes).to eq({ "file" => [a.file_was, a.file], "name" => ["Foo bar", "Johny"]})
+  end
+
+  it "returns always the first ever known value as was" do
+    a = @klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+    url_was = a.file.url
+
+    a.file = Saviour::StringSource.new("contents", "file_45.txt")
+    expect(a.file_was.url).to eq url_was
+
+    a.file = Saviour::StringSource.new("contents", "file_95.txt")
+    expect(a.file_was.url).to eq url_was
+  end
+
   it "changes are nil when not persisted" do
-    uploader = Class.new(Saviour::BaseUploader) { store_dir { "/store/dir" } }
-    klass = Class.new(Test) { include Saviour::Model }
-    klass.attach_file :file, uploader
+    a = @klass.new file: Saviour::StringSource.new("contents", "file.txt")
 
-    a = klass.new file: Saviour::StringSource.new("contents", "file.txt")
     expect(a.file_changed?).to be_truthy
     expect(a.file_was).to be_nil
   end
+
+  it "changes are nil when persisted but no file was assigned" do
+    a = @klass.create!
+    a.file = Saviour::StringSource.new("contents", "file.txt")
+    expect(a.file_was).to be_nil
+  end
+
+  it "was data is kept after reload" do
+    a = @klass.create! file: Saviour::StringSource.new("contents", "file.txt"), name: "Cuca"
+    expect(a.name_was).to eq "Cuca"
+    expect(a.file_was).to eq a.file
+
+    a.reload
+    expect(a.file_was).to eq a.file
+  end
+
+  it "was data is refreshed on persisting a new assignation" do
+    a = @klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+    a.file = Saviour::StringSource.new("contents", "file_2.txt")
+    a.save!
+    expect(a.file_was.url).to match(/file_2\.txt/)
+  end
+
+  it "was file is cleared on dup" do
+    a = @klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+    expect(a.file_was).to eq a.file
+
+    b = a.dup
+    expect(b.file_was).to be_nil
+  end
 end