echo_uploads 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d46f6288ea37a24e3903287feb0158b686ba5fd
-  data.tar.gz: e545e0653e756f4d276b411dcf19334263fb6130
+  metadata.gz: 785ecfba2a86dcdf461ba6240cde71d5acc3cc34
+  data.tar.gz: 53b675e496cd46bdfddf3f27185e249fdcb647fa
 SHA512:
-  metadata.gz: c5ca94083493932ec6eb68c39e7958c3e28457a8cf07eeb58c15b0addd1793e619cba306a34aaad5c797e43d01efa6c931179c6e8f2f272a4e3ebb6c379369d9
-  data.tar.gz: ff9aabaea5385a75630421189f18152619af6e83d1b600d780b17503f46cda3619970544180765042240dd800f172743f838e3e835bc836bb36dd0c16ef85faa
+  metadata.gz: 7c3038650d90266e2c6cd4c68d2b4c805c806cab9a2c803e981020ab9d3163f2ff589541e093b4e98de7ab9ebd7ace2bffb66c47bff89d56a25e3d54ac05ecff
+  data.tar.gz: dac64b6e5495fb691a9ba9e12488edfdade91cbb1cd42ee12c468a0b3a5cc97f2b2376810bdbcfa7ac16fc12f97313817024c8c242e281db9578ba722a1ee898

data/lib/echo_uploads/callbacks.rb

@@ -0,0 +1,13 @@
+module EchoUploads
+  module Callbacks
+    extend ActiveSupport::Concern
+    
+    included do
+      unless included_modules.include? ::EchoUploads::Model
+        include ::EchoUploads::Model
+      end
+      
+      define_model_callbacks :failed_save, only: [:after]
+    end
+  end
+end

data/lib/echo_uploads/file.rb

@@ -21,10 +21,6 @@ module EchoUploads
       self.mime_type = type ? type.content_type : 'application/octet-stream'
     end
     
-    def compute_key!(file, options)
-      self.key = options[:key].call file
-    end
-    
     # Returns a proc that takes as its only argument an ActionDispatch::UploadedFile
     # and returns a key string.
     def self.default_key_proc
@@ -68,7 +64,7 @@ module EchoUploads
       end
       
       # Configure and save the metadata object.
-      compute_key! file, options
+      self.key = options[:key].call file # Normall, this is .default_key_proc.
       self.owner_attr = attr
       self.original_extension = ::File.extname(file.original_filename)
       self.original_basename = ::File.basename(file.original_filename, original_extension)
@@ -92,7 +88,7 @@ module EchoUploads
       
       # If we mapped the files, they were temporarily written to tmp/echo_uploads.
       # Delete them.
-      if file.is_a?(::EchoUploads::MappedFile)
+      if file.is_a?(::EchoUploads::MappedFile) and ::File.exists?(file.path)
         ::File.delete file.path
       end
     

data/lib/echo_uploads/model.rb

@@ -5,16 +5,14 @@ require 'securerandom'
 
 module EchoUploads    
   module Model
-    def self.included(base)
-      base.class_eval do
-        class_attribute :echo_uploads_config
-        
-        include ::EchoUploads::Validation
-        include ::EchoUploads::PermFileSaving
-        include ::EchoUploads::TempFileSaving
-        
-        extend ClassMethods
-      end
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :echo_uploads_config
+      
+      include ::EchoUploads::Validation
+      include ::EchoUploads::PrmFileWriting
+      include ::EchoUploads::TmpFileWriting
     end
     
     def echo_uploads_data
@@ -67,15 +65,19 @@ module EchoUploads
   
     module ClassMethods      
       # Options:
+      #
       # - +key+: A Proc that takes an ActionDispatch::UploadedFile and returns a key
       #   uniquely identifying the file. If this option is not specified, the key is
       #   computed as the SHA-512 hash of the file contents. A digest of the file's
       #   contents should always be at least a part of the key.
+      #
       # - +expires+: Length of time temporary files will be persisted. Defaults to
       #   +1.day+.
+      #
       # - +storage+: A class that persists uploaded files to disk, to the cloud, or to
       #   wherever else you want. Defaults to +Rails.configuration.echo_uploads.storage+,
       #   which in turn is +EchoUploads::FilesystemStore+ by default.
+      #
       # - +map+: A Proc that accepts an ActionDispatch::Htttp::UploadedFile and an
       #   instance of +EchoUploads::Mapper+. It should transform the file data (e.g.
       #   scaling an image). It should then write the transformed data to one of more
@@ -83,6 +85,7 @@ module EchoUploads
       #   +Mapper+. See readme.md for an example. The +:map+ option can also accept a
       #   symbol naming an an instance method that works the same way as the previously
       #   described Proc.
+      #
       # - +multiple+: You use the +:map+ option to write multiple versions of the file.
       #   E.g. multiple thumbnail sizes. If you do so, you must pass +multiple: true+.
       #   This will make the association with +EchoUploads::File+ a +has_many+ instead of
@@ -90,11 +93,23 @@ module EchoUploads
       #   E.g.: Your model is called +Widget+, and the upload file attribute is called
       #   +photo+. You pass +:map+ with a method that writes three files. If you call
       #   +Widget#photo_path+, it will return the path to the first of the three files.
+      #
+      # - +write_tmp_file+: Normally, on a failed attempt to save the record, Echo Uploads
+      #   writes a temp file. That way, the user can fix the validation errors without
+      #   re-uploading the file. This option determines when the temp file is written. The
+      #   default is +:after_rollback+, meaning the temp file is written on a failed
+      #   attempt to save the record. Set to +false+ to turn off temp file saving. You can
+      #   then save temp files manually by calling Set to +:after_validation+ and the temp
+      #   file will be written on validation failure. (Warning: Although ActiveRecord
+      #   implicitly validates before saving, it does so during a transaction. So setting
+      #   this option to +:after_validation+ will prevent temp files being written during
+      #   calls to +#save+ and similar methods.)
       def echo_upload(attr, options = {})
         options = {
           expires: 1.day,
           storage: Rails.configuration.echo_uploads.storage,
-          key: ::EchoUploads::File.default_key_proc
+          key: ::EchoUploads::File.default_key_proc,
+          write_tmp_file: :after_rollback
         }.merge(options)
         
         # Init the config object. We can't use [] syntax to set the hash key because
@@ -208,6 +223,10 @@ module EchoUploads
           echo_uploads_map_metadata(attr, options, &:size)
         end
         
+        define_method("maybe_write_tmp_#{attr}") do
+          echo_uploads_maybe_write_tmp_file(attr, options)
+        end
+        
         # Define the association with the metadata model.
         if options[:multiple]
           has_many("#{attr}_metadatas".to_sym,
@@ -234,9 +253,9 @@ module EchoUploads
         # Define the temp attribute for the metadata model.
         attr_accessor "#{attr}_tmp_metadata"
         
-        configure_temp_file_saving attr, options
+        echo_uploads_configure_tmp_file_writing attr, options
         
-        configure_perm_file_saving attr, options
+        echo_uploads_configure_prm_file_writing attr, options
       end
     end
   end

data/lib/echo_uploads/{perm_file_saving.rb → prm_file_writing.rb}

@@ -1,21 +1,19 @@
 module EchoUploads
-  module PermFileSaving
-    def self.included(base)
-      base.class_eval { extend ClassMethods }
-    end
+  module PrmFileWriting
+    extend ActiveSupport::Concern
     
     module ClassMethods
-      def configure_perm_file_saving(attr, options)
+      def echo_uploads_configure_prm_file_writing(attr, options)
         # Save the file and the metadata after this model saves.
         after_save do |model|
-          @echo_uploads_perm_files_saved ||= {}
-          if (file = send(attr)).present? and @echo_uploads_perm_files_saved[attr.to_sym] != file
+          @echo_uploads_prm_files_saved ||= {}
+          if (file = send(attr)).present? and @echo_uploads_prm_files_saved[attr.to_sym] != file
             # A file is being uploaded during this request cycle. Further, we have not
             # already done the permanent file saving during this request cycle. (It's
             # not uncommon for a model to be saved twice in one request. If we ran this
             # code twice, we'd have duplicate effort at best and exceptions at worst.)
             
-            @echo_uploads_perm_files_saved[attr.to_sym] = file
+            @echo_uploads_prm_files_saved[attr.to_sym] = file
             
             if options[:multiple]
               metas = send("#{attr}_metadatas")

data/lib/echo_uploads/tmp_file_writing.rb

@@ -0,0 +1,139 @@
+module EchoUploads
+  # This comment is current as of Rails 4.2.5.
+  # 
+  # This module writes temporary EchoUploads::Files on failed attempts to save the main
+  # ActiveRecord model. Because ActiveRecord wraps save attempts in transactions, we can't
+  # use after_save callbacks. If we tried, the EchoUploads::Files would be lost upon
+  # rollback. Instead, we have to wrap #save, #create, and #update methods so that the
+  # EchoUploads::Files are saved outside the transactions.
+  #
+  # Here is the ancestor chain for ActiveRecord::Base, including this module,
+  # highest-priority first:
+  # 
+  # EchoUploads::TmpFileWriting -> ActiveRecord::Transactions -> ActiveRecord::Persistence
+  # 
+  # Here is the control flow for each of the main persistence methods. (T) denotes that
+  # the method wraps all subsequent calls in a transaction.
+  #
+  # #save
+  #   EchoUploads::TmpFileWriting#save -> ActiveRecord::Transactions#save (T) ->
+  #   ActiveRecord::Persistence#save
+  # 
+  # #create
+  #   ActiveRecord::Persistence#create -> EchoUploads::TmpFileWriting#save ->
+  #   ActiveRecord::Transactions#save (T) -> ActiveRecord::Persistence#save
+  #
+  # #update
+  #   EchoUploads::TmpFileWriting#update -> ActiveRecord::Persistence#update (T) -> 
+  #   EchoUploads::TmpFileWriting#save -> ActiveRecord::Transactions#save (T) ->
+  #   ActiveRecord::Persistence#save
+  # 
+  # Per the above, #save and #create are easy enough: We just wrap #save. But #update is
+  # problematic because it starts its own transaction and then delegates to #save. Because
+  # of that outer transaction, we can't rely on the #save wrapper. Instead, we have to
+  # wrap #update. To prevent writing the temp file twice (once in #update and again in
+  # #save), #update sets @echo_uploads_persistence_wrapped. This tells the #save
+  # wrapper not to write the temp file.
+  
+  module TmpFileWriting
+    extend ActiveSupport::Concern
+    
+    included do
+      extend ClassMethods
+      class_attribute :echo_uploads_save_wrapper
+      self.echo_uploads_save_wrapper = []
+    end
+    
+    # On a failed attempt to save (typically due to validation errors), save the file
+    # and metadata. Metadata record will be given the temporary flag.
+    def echo_uploads_maybe_write_tmp_file(attr, options)
+      if (file = send(attr)).present? and errors[attr].empty?
+        # A file has been uploaded. Validation failed, but the file itself was valid.
+        # Thus, we must persist a temporary file.
+        # 
+        # It's possible at this point that the record already has a permanent file.
+        # That's fine. We'll now have a permanent and a temporary one. The temporary
+        # one will replace the permanent one if and when the user resubmits with
+        # valid data.
+        
+        # Construct an array of EchoUploads::File instances. The array might have only
+        # one element.
+        if options[:multiple]
+          mapped_files = send("mapped_#{attr}") ||
+            raise('echo_uploads called with :multiple, but :map option was missing')
+          metas = mapped_files.map do |mapped_file|
+            ::EchoUploads::File.new(
+              owner: nil, temporary: true, expires_at: options[:expires].from_now,
+              file: mapped_file
+            )
+          end
+        else
+          metas = [::EchoUploads::File.new(
+            owner: nil, temporary: true, expires_at: options[:expires].from_now,
+            file: send(attr)
+          )]
+        end
+        
+        # Persist each file. (There might only be one, though.)
+        metas.each do |meta|
+          meta.persist! attr, options
+        end
+        
+        # Set the attr_tmp_metadata attribute so the form can remember our records.
+        send("#{attr}_tmp_metadata=", metas)
+      end
+    end
+    
+    def echo_uploads_persistence_wrapper
+      success = yield
+      unless success
+        self.class.echo_uploads_save_wrapper.each do |attr, options|
+          echo_uploads_maybe_write_tmp_file(attr, options)
+        end
+        if self.class.included_modules.include? ::EchoUploads::Callbacks
+          run_callbacks :failed_save
+        end
+      end
+      success
+    end
+    
+      
+    def save(*)
+      if @echo_uploads_persistence_wrapped
+        super
+      else
+        echo_uploads_persistence_wrapper { super }
+      end
+    end
+    
+    
+    def update(*)
+      echo_uploads_persistence_wrapper do
+        begin
+          @echo_uploads_persistence_wrapped = true
+          super
+        ensure
+          @echo_uploads_persistence_wrapped = nil
+        end
+      end
+    end
+    
+    alias_method :update_attributes, :update
+    
+    module ClassMethods
+      def echo_uploads_configure_tmp_file_writing(attr, options)
+        if options[:write_tmp_file] == :after_rollback
+          # Because ActiveRecord rolls back the transaction on validation failure, we
+          # can't just use a convenient after_validation callback. Nor can we use an
+          # after_rollback hook, because that causes all kinds of bizarre side-effects,
+          # especially in the test environment.
+          self.echo_uploads_save_wrapper += [[attr, options]]
+        elsif options[:write_tmp_file] == :after_validation
+          after_validation do
+            echo_uploads_maybe_write_tmp_file(attr, options) { errors.empty? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/echo_uploads/version.rb

@@ -1,3 +1,3 @@
 module EchoUploads
-  VERSION = '0.0.16'
+  VERSION = '0.0.17'
 end

data/lib/echo_uploads.rb

@@ -3,8 +3,9 @@ module EchoUploads; end
 require 'echo_uploads/version'
 require 'echo_uploads/railtie'
 require 'echo_uploads/validation'
-require 'echo_uploads/perm_file_saving'
-require 'echo_uploads/temp_file_saving'
+require 'echo_uploads/prm_file_writing'
+require 'echo_uploads/tmp_file_writing'
+require 'echo_uploads/callbacks'
 require 'echo_uploads/model'
 require 'echo_uploads/file'
 require 'echo_uploads/mapper'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: echo_uploads
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Jarrett Colby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-18 00:00:00.000000000 Z
+date: 2015-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -48,15 +48,16 @@ extra_rdoc_files: []
 files:
 - lib/echo_uploads.rb
 - lib/echo_uploads/abstract_store.rb
+- lib/echo_uploads/callbacks.rb
 - lib/echo_uploads/file.rb
 - lib/echo_uploads/filesystem_store.rb
 - lib/echo_uploads/mapped_file.rb
 - lib/echo_uploads/mapper.rb
 - lib/echo_uploads/model.rb
-- lib/echo_uploads/perm_file_saving.rb
+- lib/echo_uploads/prm_file_writing.rb
 - lib/echo_uploads/railtie.rb
 - lib/echo_uploads/s3_store.rb
-- lib/echo_uploads/temp_file_saving.rb
+- lib/echo_uploads/tmp_file_writing.rb
 - lib/echo_uploads/validation.rb
 - lib/echo_uploads/version.rb
 homepage: https://github.com/jarrett/echo_uploads

data/lib/echo_uploads/temp_file_saving.rb

@@ -1,100 +0,0 @@
-module EchoUploads
-  module TempFileSaving
-    def self.included(base)
-      base.class_eval { extend ClassMethods }
-    end
-    
-    # On a failed attempt to save (typically due to validation errors), save the file
-    # and metadata. Metadata record will be given the temporary flag.
-    # 
-    # To deal with the various persistence methods (#save, #create,
-    # #update_attributes), and the fact that ActiveRecord rolls back the transaction
-    # on validation failure, we can't just use a convenient after_validation callback.
-    # Instead, we have to do some trickery with .alias_method_chain.
-    def maybe_save_temp_file(attr, options)
-      success = yield
-      
-      # Because of the tangled way ActiveRecord's persistence methods delegate to each
-      # other, maybe_save_temp_file sometimes gets called twice. That's unavoidable. To
-      # workaround that issue, we check whether we're calling #save from within #update.
-      @echo_uploads_saving ||= {}
-      @echo_uploads_updating ||= {}
-      unless @echo_uploads_saving[attr] and @echo_uploads_updating[attr]
-        if (file = send(attr)).present? and !success and errors[attr].empty?
-          # A file has been uploaded. Validation failed, but the file itself was valid.
-          # Thus, we must persist a temporary file.
-          # 
-          # It's possible at this point that the record already has a permanent file.
-          # That's fine. We'll now have a permanent and a temporary one. The temporary
-          # one will replace the permanent one if and when the user resubmits with
-          # valid data.
-          
-          # Construct an array of EchoUploads::File instances. The array might have only
-          # one element.
-          if options[:multiple]
-            mapped_files = send("mapped_#{attr}") ||
-              raise('echo_uploads called with :multiple, but :map option was missing')
-            metas = mapped_files.map do |mapped_file|
-              ::EchoUploads::File.new(
-                owner: nil, temporary: true, expires_at: options[:expires].from_now,
-                file: mapped_file
-              )
-            end
-          else
-            metas = [::EchoUploads::File.new(
-              owner: nil, temporary: true, expires_at: options[:expires].from_now,
-              file: send(attr)
-            )]
-          end
-          
-          # Persist each file. (There might only be one, though.)
-          metas.each do |meta|
-            meta.persist! attr, options
-          end
-          
-          # Set the attr_tmp_metadata attribute so the form can remember our records.
-          send("#{attr}_tmp_metadata=", metas)
-        end
-      end
-      
-      success
-    end
-    
-    module ClassMethods
-      # Wraps ActiveRecord's persistence methods. We can't use a callback for this. See
-      # the comment above for an explanation of why.
-      def configure_temp_file_saving(attr, options)
-        # Wrap the #save method. This also suffices for #create.
-        define_method("save_with_#{attr}_temp_file") do |*args|
-          @echo_uploads_saving ||= {}
-          @echo_uploads_saving[attr] = true
-          begin
-            success = maybe_save_temp_file(attr, options) do
-              send "save_without_#{attr}_temp_file", *args
-            end
-            success
-          ensure
-            @echo_uploads_saving.delete attr
-          end
-        end
-        alias_method_chain :save, "#{attr}_temp_file".to_sym
-        
-        # Wrap the #update and #update_attributes methods.
-        define_method("update_with_#{attr}_temp_file") do |*args|
-          @echo_uploads_updating ||= {}
-          @echo_uploads_updating[attr] = true
-          begin
-            success = maybe_save_temp_file(attr, options) do
-              send "update_without_#{attr}_temp_file", *args
-            end
-            success
-          ensure
-            @echo_uploads_updating.delete attr
-          end
-        end
-        alias_method_chain :update, "#{attr}_temp_file".to_sym
-        alias_method :update_attributes, "update_with_#{attr}_temp_file".to_sym
-      end
-    end
-  end
-end