saviour 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a8dde206061328305a93bbcbcf03ef6e15d9659
-  data.tar.gz: 828b58ec76d1974a88bf595ea2306cded359f752
+  metadata.gz: 5b1d3de91b6a03bd4e483d2012346575d1fb444d
+  data.tar.gz: eca43877819318d52cabb2bcc6a02f71f131ee03
 SHA512:
-  metadata.gz: 0a13bc0dced7f96b5306a6ef7dbb72f01a66d8b9f9f962b4de99697eea8212db71f706abb9f7d12ef1cb29ae5a879d329c408937ddffd9f225d1c35ae4bb4e76
-  data.tar.gz: dee3ef8dab84f49536c9c311d23e97cbe66ee6e1e5278fe48f02267720dfa7178a424b814746ba0dd1fdf67d4cd8e213c11f37d17e26144fa1bd281e40a801ea
+  metadata.gz: ab1eabe24fdc96f7785c9a72d6da2250c6ae9362aca1da91817c08846d70443b8919ca41c14cc34afc5652d4081dcac80a2450a3e30cbeee5ce9c2b82ac5fd29
+  data.tar.gz: 9db4871ec035aa11f7d9fcce3cd72ed7eb7e96e44567a5f21552e02df9a520a9057b455941ead2513cac13cdf14ce44d1d9c42012ec4af1e01007e855feef6ef

data/.travis.yml

@@ -2,15 +2,11 @@ language: ruby
 sudo: false
 cache: bundler
 rvm:
-  - 2.1.10
   - 2.2.8
   - 2.3.5
   - 2.4.2
 
 gemfile:
-  - gemfiles/4.0.gemfile
-  - gemfiles/4.1.gemfile
-  - gemfiles/4.2.gemfile
   - gemfiles/5.0.gemfile
   - gemfiles/5.1.gemfile
 
@@ -20,17 +16,3 @@ addons:
 
 after_success:
   - bundle exec codeclimate-test-reporter
-
-matrix:
-  exclude:
-    # rails 5+ requires 2.2+
-    - rvm: 2.1.10
-      gemfile: gemfiles/5.0.gemfile
-    - rvm: 2.1.10
-      gemfile: gemfiles/5.1.gemfile
-
-    # Arel support for ruby 2.4 starts in 4.2
-    - rvm: 2.4.2
-      gemfile: gemfiles/4.0.gemfile
-    - rvm: 2.4.2
-      gemfile: gemfiles/4.1.gemfile

data/README.md

@@ -223,10 +223,6 @@ You can also assign a Proc instead of a String to dynamically manage this (for m
 
 This storage will take care of removing empty folders after removing files.
 
-This storage includes a feature of overwrite protection, raising an exception if an attempt is made of writing something
-on a path that already exists. This behaviour in enabled by default, but you can turn it off by passing an additional
-argument when instantiating the storage: `overwrite_protection: false`.
-
 
 ### S3Storage
 
@@ -262,11 +258,6 @@ Saviour::Config.storage = Saviour::S3Storage.new(
 )
 ```
 
-This storage includes a feature of overwrite protection, raising an exception if an attempt is made of writing something
-on a path that already exists. This behaviour in enabled by default, but you can turn it off by passing an additional
-argument when instantiating the storage: `overwrite_protection: false`. This feature requires an additional HEAD request
-to verify existence for every write.
-
 NOTE: Be aware that S3 has a limit of 1024 bytes for the keys (paths) used. Be sure to truncate to that maximum length
 if you're using an s3 storage, for example with a processor like this:
 
@@ -368,6 +359,12 @@ end
 Use `store_dir` to indicate the default directory under which the file will be stored. You can also use it under a
 `version` to change the default directory for that specific version.
 
+Note that it's very important that the full path to any attached file to any model is unique. This is typically
+accomplished by using `model.id` and `attached_as` as part of either the `store_dir` or the `filename`, in any
+combination you may want. If this is not satisfied, you may experience unexpected overwrite of files or files
+having unexpected contents, for example if two different models write to the same storage path, and then one
+of them is deleted.  
+
 
 ### Accessing model and attached_as
 

data/lib/saviour.rb

@@ -12,8 +12,16 @@ require 'saviour/source_filename_extractor'
 require 'saviour/life_cycle'
 require 'saviour/persistence_layer'
 require 'saviour/validator'
+require 'saviour/db_helpers'
 
 require 'tempfile'
+require 'fileutils'
 
 module Saviour
+  NoActiveRecordDetected = Class.new(StandardError)
+  FileNotPresent = Class.new(StandardError)
+  ConfigurationError = Class.new(StandardError)
+  SourceError = Class.new(StandardError)
+  CannotCopy = Class.new(StandardError)
+  MissingSource = Class.new(StandardError)
 end

data/lib/saviour/base_uploader.rb

@@ -19,8 +19,8 @@ module Saviour
       @data.key?(name) || super
     end
 
-    def write(contents, filename)
-      raise RuntimeError, "Please use `store_dir` before trying to write" unless store_dir
+    def _process_as_contents(contents, filename)
+      raise ConfigurationError, "Please use `store_dir` in the uploader" unless store_dir
 
       catch(:halt_process) do
         if Config.processing_enabled
@@ -28,9 +28,22 @@ module Saviour
         end
 
         path = ::File.join(store_dir, filename)
-        Config.storage.write(contents, path)
 
-        path
+        [contents, path]
+      end
+    end
+
+    def _process_as_file(file, filename)
+      raise ConfigurationError, "Please use `store_dir` in the uploader" unless store_dir
+
+      catch(:halt_process) do
+        if Config.processing_enabled
+          file, filename = Uploader::ProcessorsRunner.new(self).run_as_file!(file, filename)
+        end
+
+        path = ::File.join(store_dir, filename)
+
+        [file, path]
       end
     end
 

data/lib/saviour/config.rb

@@ -4,7 +4,7 @@ module Saviour
   class Config
     class NotImplemented
       def method_missing(*)
-        raise(RuntimeError, "You need to provide a storage! Set Saviour::Config.storage = xxx")
+        raise(ConfigurationError, "You need to provide a storage! Set Saviour::Config.storage = xxx")
       end
     end
 

data/lib/saviour/db_helpers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Saviour
+  module DbHelpers
+    NotInTransaction = Class.new(StandardError)
+
+    class CommitDummy
+      def initialize(block)
+        @block = block
+      end
+
+      def rolledback!(*)
+        close_transaction
+      end
+
+      def close_transaction(*)
+      end
+
+      def before_committed!(*)
+      end
+
+      def committed!(*)
+        @block.call
+      end
+    end
+
+    class RollbackDummy
+      def initialize(block)
+        @block = block
+      end
+
+      def rolledback!(*)
+        @block.call
+        close_transaction
+      end
+
+      def close_transaction(*)
+      end
+
+      def before_committed!(*)
+      end
+
+      def committed!(*)
+      end
+    end
+
+
+    class << self
+
+      def run_after_commit(&block)
+        unless ActiveRecord::Base.connection.current_transaction.open?
+          raise NotInTransaction, 'Trying to use `run_after_commit` but no transaction is currently open.'
+        end
+
+        dummy = CommitDummy.new(block)
+        ActiveRecord::Base.connection.add_transaction_record(dummy)
+      end
+
+      def run_after_rollback(&block)
+        unless ActiveRecord::Base.connection.current_transaction.open?
+          raise NotInTransaction, 'Trying to use `run_after_commit` but no transaction is currently open.'
+        end
+
+        dummy = RollbackDummy.new(block)
+        ActiveRecord::Base.connection.add_transaction_record(dummy)
+      end
+    end
+  end
+end

data/lib/saviour/file.rb

@@ -3,6 +3,7 @@ require 'securerandom'
 module Saviour
   class File
     attr_reader :persisted_path
+    attr_reader :source
 
     def initialize(uploader_klass, model, attached_as)
       @uploader_klass, @model, @attached_as = uploader_klass, model, attached_as
@@ -11,6 +12,7 @@ module Saviour
 
     def set_path!(path)
       @persisted_path = path
+      @persisted_path_before_last_save = path
     end
 
     def exists?
@@ -18,11 +20,11 @@ module Saviour
     end
 
     def read
-      persisted? && exists? && Config.storage.read(@persisted_path)
+      persisted? && Config.storage.read(@persisted_path)
     end
 
     def delete
-      persisted? && exists? && Config.storage.delete(@persisted_path)
+      persisted? && Config.storage.delete(@persisted_path)
     end
 
     def public_url
@@ -36,20 +38,34 @@ module Saviour
       if persisted?
         another_file.persisted_path == persisted_path
       else
-        another_file.instance_variable_get("@source") == @source
+        another_file.source == @source
       end
     end
 
     def clone
+      return nil unless persisted?
+
       new_file = Saviour::File.new(@uploader_klass, @model, @attached_as)
-      new_file.set_path!(@persisted_path)
+      new_file.set_path! @persisted_path
+      new_file
+    end
+
+    def dup
+      new_file = Saviour::File.new(@uploader_klass, @model, @attached_as)
+
+      if persisted?
+        new_file.assign(Saviour::StringSource.new(read, filename))
+      else
+        new_file.assign(Saviour::StringSource.new(source_data, filename_to_be_assigned))
+      end
+
       new_file
     end
 
     alias_method :url, :public_url
 
     def assign(object)
-      raise(RuntimeError, "must respond to `read`") if object && !object.respond_to?(:read)
+      raise(SourceError, "given object to #assign or #<attach_as>= must respond to `read`") if object && !object.respond_to?(:read)
 
       followers = @model.class.attached_followers_per_leader[@attached_as]
       followers.each { |x| @model.send(x).assign(object) unless @model.send(x).changed? } if followers
@@ -79,20 +95,16 @@ module Saviour
     end
 
     def with_copy
-      raise "must be persisted" unless persisted?
-
-      Tempfile.open([::File.basename(filename, ".*"), ::File.extname(filename)]) do |file|
-        begin
-          file.binmode
-          file.write(read)
-          file.flush
-          file.rewind
-
-          yield(file)
-        ensure
-          file.close
-          file.delete
-        end
+      raise CannotCopy, "must be persisted" unless persisted?
+
+      temp_file = Tempfile.new([::File.basename(filename, ".*"), ::File.extname(filename)])
+
+      begin
+        Config.storage.read_to_file(@persisted_path, temp_file)
+
+        yield(temp_file)
+      ensure
+        temp_file.close!
       end
     end
 
@@ -100,15 +112,53 @@ module Saviour
       changed? ? (SourceFilenameExtractor.new(@source).detected_filename || SecureRandom.hex) : nil
     end
 
-    def write
-      raise(RuntimeError, "You must provide a source to read from first") unless @source
+    def __maybe_with_tmpfile(source_type, file)
+      return yield if source_type == :stream
+
+      tmpfile = Tempfile.new([::File.basename(file.path, ".*"), ::File.extname(file.path)])
+      FileUtils.cp(file.path, tmpfile.path)
+
+      begin
+        yield(tmpfile)
+      ensure
+        tmpfile.close!
+      end
+    end
+
+    def write(before_write: nil)
+      raise(MissingSource, "You must provide a source to read from before trying to write") unless @source
+
+      __maybe_with_tmpfile(source_type, @source) do |tmpfile|
+        contents, path = case source_type
+                           when :stream
+                             uploader._process_as_contents(source_data, filename_to_be_assigned)
+                           when :file
+                             uploader._process_as_file(tmpfile, filename_to_be_assigned)
+                         end
+        @source_was = @source
 
-      path = uploader.write(source_data, filename_to_be_assigned)
-      @source_was = @source
+        if path
+          before_write.call(path) if before_write
 
-      if path
-        @persisted_path = path
-        path
+          case source_type
+            when :stream
+              Config.storage.write(contents, path)
+            when :file
+              Config.storage.write_from_file(contents, path)
+          end
+
+          @persisted_path = path
+          @persisted_path_before_last_save = path
+          path
+        end
+      end
+    end
+
+    def source_type
+      if @source.respond_to?(:path)
+        :file
+      else
+        :stream
       end
     end
 

data/lib/saviour/integrator.rb

@@ -6,7 +6,7 @@ module Saviour
     end
 
     def setup!
-      raise "You cannot include Saviour twice in the same class" if @klass.respond_to?(:attached_files)
+      raise(ConfigurationError, "You cannot include Saviour::Model twice in the same class") if @klass.respond_to?(:attached_files)
 
       @klass.class_attribute :attached_files
       @klass.attached_files = []
@@ -26,7 +26,7 @@ module Saviour
         end
 
         if uploader_klass.nil? && block.nil?
-          raise ArgumentError, "you must provide either an UploaderClass or a block to define it."
+          raise ConfigurationError, "you must provide either an UploaderClass or a block to define it."
         end
 
         mod = Module.new do
@@ -58,7 +58,12 @@ module Saviour
 
       @klass.define_singleton_method("attach_validation") do |attach_as, method_name = nil, &block|
         klass.__saviour_validations ||= Hash.new { [] }
-        klass.__saviour_validations[attach_as] += [method_name || block]
+        klass.__saviour_validations[attach_as] += [{ method_or_block: method_name || block, type: :memory }]
+      end
+
+      @klass.define_singleton_method("attach_validation_with_file") do |attach_as, method_name = nil, &block|
+        klass.__saviour_validations ||= Hash.new { [] }
+        klass.__saviour_validations[attach_as] += [{ method_or_block: method_name || block, type: :file }]
       end
     end
   end

data/lib/saviour/life_cycle.rb

@@ -1,23 +1,42 @@
 module Saviour
   class LifeCycle
-    def initialize(model, persistence_klass = nil)
-      raise "Please provide an object compatible with Saviour." unless model.class.respond_to?(:attached_files)
+    def initialize(model, persistence_klass)
+      raise ConfigurationError, "Please provide an object compatible with Saviour." unless model.class.respond_to?(:attached_files)
 
       @persistence_klass = persistence_klass
       @model = model
     end
 
     def delete!
+      DbHelpers.run_after_commit do
+        attached_files.each do |column|
+          @model.send(column).delete
+        end
+      end
+    end
+
+    def create!
       attached_files.each do |column|
-        @model.send(column).delete if @model.send(column).exists?
+        next unless @model.send(column).changed?
+
+        persistence_layer = @persistence_klass.new(@model)
+        new_path = @model.send(column).write
+
+        if new_path
+          persistence_layer.write(column, new_path)
+
+          DbHelpers.run_after_rollback do
+            Config.storage.delete(new_path)
+          end
+        end
       end
     end
 
-    def save!
+    def update!
       attached_files.each do |column|
-        base_file_changed = @model.send(column).changed?
+        next unless @model.send(column).changed?
 
-        upload_file(column) if base_file_changed
+        update_file(column)
       end
     end
 
@@ -25,14 +44,43 @@ module Saviour
     private
 
 
-    def upload_file(column)
-      persistence_layer = @persistence_klass.new(@model) if @persistence_klass
-      current_path = persistence_layer.read(column) if persistence_layer
+    def update_file(column)
+      persistence_layer = @persistence_klass.new(@model)
+      current_path = persistence_layer.read(column)
+      dup_temp_path = SecureRandom.hex
+
+      dup_file = proc do
+        Config.storage.cp current_path, dup_temp_path
 
-      Config.storage.delete(current_path) if current_path
+        DbHelpers.run_after_commit do
+          Config.storage.delete dup_temp_path
+        end
 
-      new_path = @model.send(column).write
-      persistence_layer.write(column, new_path) if persistence_layer && new_path
+        DbHelpers.run_after_rollback do
+          Config.storage.mv dup_temp_path, current_path
+        end
+      end
+
+      new_path = @model.send(column).write(
+        before_write: ->(path) { dup_file.call if current_path == path }
+      )
+
+      if new_path
+        persistence_layer.write(column, new_path)
+
+        if current_path && current_path != new_path
+          DbHelpers.run_after_commit do
+            Config.storage.delete(current_path)
+          end
+        end
+
+        # Delete the newly uploaded file only if it's an update in a different path
+        if current_path.nil? || current_path != new_path
+          DbHelpers.run_after_rollback do
+            Config.storage.delete(new_path)
+          end
+        end
+      end
     end
 
     def attached_files