echo_uploads 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b33b3e17496be452917ef4e82609a8fb39348ad4
-  data.tar.gz: 24efa6d8430db50e74d7079cf927ea2216a52917
+  metadata.gz: 9302fa84aaf621556620c40904c1c8ead227b53d
+  data.tar.gz: 8ffbf38511536c4fee0a341c19f8a30424d3f54f
 SHA512:
-  metadata.gz: d29afadb8644e6681922d70c5ebf9799cccff6cf1cd438e5596694a1304474e30189b4dd666b81a544e9890b58b9354e6a1bec1d4669a324fc8709e6c56d14f7
-  data.tar.gz: 10f158f2e2d911ab0f54490b7d8f216b720d8316692601c68dc1e5acfc017f5b89c2cbbd1a1716838cf962a4e9e096e38aa3e292526e35358c3561dc2b89eb29
+  metadata.gz: b53ba87f3dd560c8b163e2a8aba350f520eb982675a7c8629977816e473a80ea1b1d321dabc1716dade423ea20abaae833265f03b72f90be8966bc5a484ad2cc
+  data.tar.gz: 6110cf77bc31bc2906bb89c24fd493792ce84926ec44dc966f989cee08019a541f821ba6f937d12de731a12e2c580335a7d5af6e33728986603225e62b662b56

data/lib/echo_uploads/file.rb

@@ -9,11 +9,22 @@ module EchoUploads
     
     before_destroy :delete_file_conditionally
     
-    def compute_mime!
-      type = MIME::Types.type_for(original_filename).first
+    attr_accessor :file
+    
+    def compute_mime!(options)
+      if file and file.is_a?(::EchoUploads::MappedFile)
+        name = file.mapped_filename
+      else
+        name = original_filename
+      end
+      type = MIME::Types.type_for(name).first
       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
@@ -39,30 +50,47 @@ module EchoUploads
       original_basename + original_extension
     end
     
-    # Pass in an attribute name, an ActionDispatch::UploadedFile, and an options hash.
-    def persist!(attr, file, mapped_file, options)
-      # If .echo_uploads was called with the :map option, we need to use the mapped file.
-      file_to_write = mapped_file || file
+    def path
+      storage.path key
+    end
+    
+    # Pass in an attribute name, an ActionDispatch::Http::UploadedFile, and an options hash.
+    # Must set #file attribute first.
+    def persist!(attr, options)
+      unless(
+        file.is_a?(ActionDispatch::Http::UploadedFile) or
+        file.is_a?(Rack::Test::UploadedFile)
+      )
+        raise(
+          "Expected #file to be a ActionDispatch::Http::UploadedFile "+
+          "or Rack::Test::UploadedFile, but was #{file.inspect}"
+        )
+      end
       
       # Configure and save the metadata object.
-      self.key = options[:key].call file_to_write
+      compute_key! file, options
       self.owner_attr = attr
       self.original_extension = ::File.extname(file.original_filename)
       self.original_basename = ::File.basename(file.original_filename, original_extension)
-      compute_mime!
-      self.storage_type = options[:storage].name
+      compute_mime! options
+      if options[:storage].is_a? String
+        self.storage_type = options[:storage]
+      else
+        self.storage_type = options[:storage].name
+      end
       save!
     
       # Write the file to the filestore.
-      
-      if file_to_write.is_a?(ActionDispatch::Http::UploadedFile)
-        storage.write key, file_to_write.tempfile
+      if file.is_a?(ActionDispatch::Http::UploadedFile)
+        storage.write key, file.tempfile
       else
-        storage.write key, file_to_write
+        storage.write key, file
       end
-      if file_to_write == mapped_file
-        mapped_file.close
-        #::File.delete mapped_file.path
+      
+      # If we mapped the files, they were temporarily written to tmp/echo_uploads.
+      # Delete them.
+      if file.is_a?(::EchoUploads::MappedFile)
+        ::File.delete file.path
       end
     
       # Prune any expired temporary files. (Unless automatic pruning was turned off in

data/lib/echo_uploads/filesystem_store.rb

@@ -1,5 +1,26 @@
 module EchoUploads
   class FilesystemStore < ::EchoUploads::AbstractStore
+    def delete(key)
+      _path = path(key)
+      ::File.delete(_path) if ::File.exists?(_path)
+    end
+    
+    def exists?(key)
+      ::File.exists? path(key)
+    end
+    
+    def open(key)
+      ::File.open(path(key), 'rb', &block)
+    end
+    
+    def path(key)
+      ::File.join folder, key
+    end
+    
+    def read(key)
+      File.read path(key)
+    end
+    
     def write(key, file)
       _path = path key
       unless ::File.exists?(_path)
@@ -14,23 +35,6 @@ module EchoUploads
       end
     end
     
-    def read(key)
-      File.read path(key)
-    end
-    
-    def delete(key)
-      _path = path(key)
-      ::File.delete(_path) if ::File.exists?(_path)
-    end
-    
-    def open(key)
-      ::File.open(path(key), 'rb', &block)
-    end
-    
-    def path(key)
-      ::File.join folder, key
-    end
-    
     private
     
     # Can be customized in your per-environment config like this:

data/lib/echo_uploads/mapped_file.rb

@@ -0,0 +1,5 @@
+module EchoUploads
+  class MappedFile < ActionDispatch::Http::UploadedFile
+    attr_accessor :mapped_filename
+  end
+end

data/lib/echo_uploads/mapper.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module EchoUploads
+  class Mapper
+    def initialize(file)
+      unless(
+        file.is_a?(ActionDispatch::Http::UploadedFile) or
+        file.is_a?(Rack::Test::UploadedFile)
+      )
+        raise(
+          "Expected file to be a ActionDispatch::Http::UploadedFile "+
+          "or Rack::Test::UploadedFile, but was #{file.inspect}"
+        )
+      end
+      
+      @uploaded_file = file
+      @outputs = []
+    end
+    
+    attr_reader :outputs
+    
+    def write(ext)
+      folder = ::File.join Rails.root, 'tmp/echo_uploads'
+      FileUtils.mkdir_p folder
+      path = ::File.join(folder, SecureRandom.hex(15) + ext)
+      yield path
+      file = ::File.open path, 'rb'
+      mapped_file = ::EchoUploads::MappedFile.new(
+        tempfile: file, filename: @uploaded_file.original_filename
+      )
+      mapped_file.mapped_filename = ::File.basename path
+      outputs << mapped_file
+    end
+  end
+end

data/lib/echo_uploads/model.rb

@@ -19,9 +19,11 @@ module EchoUploads
     
     def echo_uploads_data
       Base64.encode64(JSON.dump(self.class.echo_uploads_config.inject({}) do |hash, (attr, cfg)|
-        meta = send("#{attr}_tmp_metadata")
-        if meta
-          hash[attr] = {'id' => meta.id, 'key' => meta.key}
+        metas = send("#{attr}_tmp_metadata")
+        if metas
+          hash[attr] = metas.map do |meta|
+            {'id' => meta.id, 'key' => meta.key}
+          end
         end
         hash
       end)).strip
@@ -30,17 +32,35 @@ module EchoUploads
     # Pass in a hash that's been encoded as JSON and then Base64.
     def echo_uploads_data=(data)
       parsed = JSON.parse Base64.decode64(data)
+      # parsed will look like:
+      # { 'attr1' => [ {'id' => 1, 'key' => 'abc...'} ] }
+      unless parsed.is_a? Hash
+        raise ArgumentError, "Invalid JSON structure in: #{parsed.inspect}"
+      end
       parsed.each do |attr, attr_data|
-        # Must verify that the metadata record is temporary. If not, an attacker could
-        # pass the ID of a permanent record and change its owner.
-        if meta = ::EchoUploads::File.where(id: attr_data['id'], key: attr_data['key'], temporary: true).first
-          send("#{attr}_tmp_metadata=", meta)
+        # If the :map option was passed, there may be multiple variants of the uploaded
+        # file. Even if not, attr_data is still a one-element array.
+        unless attr_data.is_a? Array
+          raise ArgumentError, "Invalid JSON structure in: #{parsed.inspect}"
+        end
+        attr_data.each do |variant_data|
+          unless variant_data.is_a? Hash
+            raise ArgumentError, "Invalid JSON structure in: #{parsed.inspect}"
+          end
+          if meta = ::EchoUploads::File.where(
+            id: variant_data['id'], key: variant_data['key'], temporary: true
+          ).first
+            if send("#{attr}_tmp_metadata").nil?
+              send "#{attr}_tmp_metadata=", []
+            end
+            send("#{attr}_tmp_metadata") << meta
+          end
         end
       end
     end
     
     # Helper method used internally Echo Uploads.
-    def map_metadata(attr)
+    def echo_uploads_map_metadata(attr, options)
       meta = send("#{attr}_metadata")
       meta ? yield(meta) : nil
     end
@@ -54,16 +74,26 @@ module EchoUploads
       # - +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 +EchoUploads::FilesystemStore+.
-      # - +map+: A Proc that accepts an ActionDispatch::Htttp::UploadedFile and a path to
-      #   a temporary file. It should transform the file data (e.g. scaling an image). It
-      #   should then write the transformed data to the temporary file path. Can also
-      #   accept a symbol naming an an instance method that works the same way as the
-      #   previously described Proc.
+      #   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
+      #   temporary files. To get the temporary file path(s), call +#write+ on the
+      #   +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
+      #   a +has_one+. The first file you write in the map function becomes the default.
+      #   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.
       def echo_upload(attr, options = {})
         options = {
           expires: 1.day,
-          storage: ::EchoUploads::FilesystemStore,
+          storage: Rails.configuration.echo_uploads.storage,
           key: ::EchoUploads::File.default_key_proc
         }.merge(options)
         
@@ -80,43 +110,45 @@ module EchoUploads
         # Define the writer method for the file attribute.
         define_method("#{attr}=") do |file|
           if options[:map]
-            mapped_file_path = ::File.join Rails.root, 'tmp', SecureRandom.hex(15)
+            mapper = ::EchoUploads::Mapper.new file
             if options[:map].is_a? Proc
-              options[:map].call file, mapped_file_path
+              options[:map].call file, mapper
             else
-              send(options[:map], file, mapped_file_path)
+              send(options[:map], file, mapper)
             end
-            mapped_file = ::File.open mapped_file_path, 'rb'
-            send "mapped_#{attr}=", mapped_file
+            # Write an array of ActionDispatch::Http::UploadedFile objects to the instance
+            # variable.
+            send "mapped_#{attr}=", mapper.outputs
           end
           instance_variable_set "@#{attr}", file
         end
         
-        # Define the accessor methods for the mapped version of the file.
+        # Define the accessor methods for the mapped version(s) of the file. Returns
+        # an array.
         attr_accessor "mapped_#{attr}"
         
+        # Define the original filename method.
+        define_method("#{attr}_original_filename") do
+          echo_uploads_map_metadata(attr, options, &:original_filename)
+        end
+        
         # Define the path method. This method will raise if the given storage
         # class doesn't support the #path method.
         define_method("#{attr}_path") do
-          map_metadata(attr) do |meta|
-            meta.storage.path meta.key
+          echo_uploads_map_metadata(attr, options) do |meta|
+            meta.path
           end
         end
         
         # Define the MIME type method.
         define_method("#{attr}_mime") do
-          map_metadata(attr, &:mime_type)
+          echo_uploads_map_metadata(attr, options, &:mime_type)
         end
         alias_method "#{attr}_mime_type", "#{attr}_mime"
         
-        # Define the original filename method.
-        define_method("#{attr}_original_filename") do
-          map_metadata(attr, &:original_filename)
-        end
-        
         # Define the key method
         define_method("#{attr}_key") do
-          map_metadata(attr, &:key)
+          echo_uploads_map_metadata(attr, options, &:key)
         end
         
         # Define the has_x? method. Returns true if a permanent or temporary file has been
@@ -147,10 +179,27 @@ module EchoUploads
         end
         
         # Define the association with the metadata model.
-        has_one("#{attr}_metadata".to_sym,
-          ->() { where(owner_attr: attr) },
-          as: :owner, dependent: :destroy, class_name: '::EchoUploads::File'
-        )
+        if options[:multiple]
+          has_many("#{attr}_metadatas".to_sym,
+            ->() { where(owner_attr: attr) },
+            as: :owner, dependent: :destroy, class_name: '::EchoUploads::File'
+          )
+          
+          alias_method attr.to_s.pluralize, "#{attr}_metadatas"
+          
+          define_method("#{attr}_metadata") do
+            send("#{attr}_metadatas").first
+          end
+          
+          define_method("#{attr}_metadata=") do |val|
+            send("#{attr}_metadatas") << val
+          end
+        else
+          has_one("#{attr}_metadata".to_sym,
+            ->() { where(owner_attr: attr) },
+            as: :owner, dependent: :destroy, class_name: '::EchoUploads::File'
+          )
+        end
         
         # Define the temp attribute for the metadata model.
         attr_accessor "#{attr}_tmp_metadata"

data/lib/echo_uploads/perm_file_saving.rb

@@ -10,34 +10,80 @@ module EchoUploads
         after_save do |model|
           if (file = send(attr)).present?
             # A file is being uploaded during this request cycle.
-            if meta = send("#{attr}_metadata")
-              # A previous permanent file exists. This is a new version being uploaded.
-              # Delete the old version from the disk if no other metadata record
-              # references it.
-              meta.delete_file_conditionally
+            
+            if options[:multiple]
+              metas = send("#{attr}_metadatas")
             else
-              # No previous permanent file exists. 
-              meta = ::EchoUploads::File.new(owner: model, temporary: false)
-              send("#{attr}_metadata=", meta)
+              metas = [send("#{attr}_metadata")].compact
             end
-            meta.persist! attr, file, send("mapped_#{attr}"), options
-          elsif meta = send("#{attr}_tmp_metadata") and meta.temporary
+            
+            # metas is now an array of ::EchoUploads::File instances. The array may
+            # be empty.
+            
+            if metas.any?
+              # Previous permanent file(s) exist. This is a new version being uploaded.
+              # Delete the old version(s).
+              metas.each(&:destroy)
+            end
+            
+            # No previous permanent files exists. The metas array is currently empty or
+            # else contains deleted records. We need to rebuild that array by constructing
+            # (but not yet saving) new EchoUploads::File objects.
+            
+            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: model, temporary: false, file: mapped_file
+                )
+              end
+              send("#{attr}_metadatas=", metas)
+            else
+              metas = [::EchoUploads::File.new(
+                owner: model, temporary: false, file: send(attr)
+              )]
+              send("#{attr}_metadata=", metas.first)
+            end
+            
+            # metas is still an array of the EchoUploads::File instances. If the array was
+            # initially empty (meaning no previous permanent file existed), then it has
+            # since been populated.
+            
+            metas.each do |meta|
+              meta.persist! attr, options
+            end
+          elsif metas = send("#{attr}_tmp_metadata")
             # A file has not been uploaded during this request cycle. However, the
             # submitted form "remembered" a temporary metadata record that was previously
-            # saved. We mark it as permanent and set its owner.
-            # 
-            # But first, we must delete any existing metadata record. (It's possible we
+            # saved.
+            
+            # Delete any existing metadata record. (It's possible we
             # were trying to replace an old version of the file, and there were validation
             # errors on the first attempt.)
-            if old = model.send("#{attr}_metadata")
+            
+            if options[:multiple]
+              model.send("#{attr}_metadatas").each(&:destroy)
+            elsif old = model.send("#{attr}_metadata")
               old.destroy
             end
             
-            meta.owner = model
-            send("#{attr}_metadata=", meta)
-            meta.temporary = false
-            meta.expires_at = nil
-            meta.save!
+            # We need not call persist! here, because the file is already persisted. (Nor
+            # could we call it, because persist! requires an
+            # ActionDispatch::HTTP::UploadedFile.) Mark the metadata record as permanent
+            # and set its owner.
+            metas.each do |meta|
+              meta.owner = model
+              meta.temporary = false
+              meta.expires_at = nil
+              meta.save!
+            end
+            
+            if options[:multiple]
+              send("#{attr}_metadatas=", metas)
+            else
+              send("#{attr}_metadata=", metas.first)
+            end
           end
         end
       end

data/lib/echo_uploads/railtie.rb

@@ -2,6 +2,9 @@ require 'ostruct'
 
 module EchoUploads
   class Railtie < Rails::Railtie
-    config.echo_uploads = OpenStruct.new
+    config.echo_uploads = OpenStruct.new(
+      storage: 'EchoUploads::FilesystemStore',
+      s3: OpenStruct.new(bucket: nil, folder: nil)
+    )
   end
 end

data/lib/echo_uploads/s3_store.rb

@@ -0,0 +1,51 @@
+# Uses the official Amazon Web Services SDK gem:
+#   gem install aws-sdk
+module EchoUploads
+  class S3Store < ::EchoUploads::AbstractStore    
+    def delete(key)
+      bucket.objects[key].delete
+    end
+    
+    def exists?(key)
+      bucket.objects[key].exists?
+    end
+    
+    def read(key)
+      data = ''
+      bucket.objects[key].read { |chunk| data << chunk }
+      data
+    end
+    
+    def url(key, options = {})
+      options = {method: :read}.merge(options)
+      bucket.objects[key].url_for options.delete(:method), options
+    end
+    
+    def write(key, file)
+      bucket.objects[key].write file
+    end
+    
+    private
+    
+    def bucket
+      if Rails.configuration.echo_uploads.aws
+        s3 = AWS::S3.new Rails.configuration.echo_uploads.aws
+      else
+        s3 = AWS::S3.new
+      end
+      bucket_name = Rails.configuration.echo_uploads.s3.bucket || raise(
+        'You must define config.echo_uploads.s3.bucket in your application config.'
+      )
+      if s3.buckets[bucket_name].nil?
+        s3.buckets.create bucket_name
+      end
+      s3.buckets[bucket_name]
+    end
+    
+    def folder
+      Rails.configuration.echo_uploads.s3.folder || raise(
+        'You must define config.echo_uploads.s3.folder in your application config.'
+      )
+    end
+  end
+end

data/lib/echo_uploads/temp_file_saving.rb

@@ -28,11 +28,32 @@ module EchoUploads
           # 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.
-          meta = ::EchoUploads::File.new(
-            owner: nil, temporary: true, expires_at: options[:expires].from_now
-          )
-          meta.persist! attr, file, send("mapped_#{attr}"), options
-          send("#{attr}_tmp_metadata=", meta)
+          
+          # 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
       

data/lib/echo_uploads.rb

@@ -6,5 +6,8 @@ require 'echo_uploads/perm_file_saving'
 require 'echo_uploads/temp_file_saving'
 require 'echo_uploads/model'
 require 'echo_uploads/file'
+require 'echo_uploads/mapper'
+require 'echo_uploads/mapped_file'
 require 'echo_uploads/abstract_store'
-require 'echo_uploads/filesystem_store'
+require 'echo_uploads/filesystem_store'
+require 'echo_uploads/s3_store'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: echo_uploads
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Jarrett Colby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -38,7 +38,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-description: ''
+description: Gracefully handles invalid form submissions, so users don't have to resubmit
+  the file. Supports transforming the file before saving, e.g. scaling an image. Compatible
+  with any storage mechanism, including the local filesystem and the cloud.
 email: jarrett@madebyhq.com
 executables: []
 extensions: []
@@ -48,9 +50,12 @@ files:
 - lib/echo_uploads/abstract_store.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/railtie.rb
+- lib/echo_uploads/s3_store.rb
 - lib/echo_uploads/temp_file_saving.rb
 - lib/echo_uploads/validation.rb
 homepage: https://github.com/jarrett/echo_uploads