voltron-upload 0.2.1

data/lib/voltron/upload/action_view/field.rb

@@ -0,0 +1,152 @@
+module Voltron
+  module Upload
+    module Field
+
+      include ActionView::Helpers::TagHelper
+
+      def file_field(method, options={})
+        if Voltron.config.upload.enabled && !options[:default]
+          template = instance_variable_get('@template')
+          field = UploadField.new(@object, method, template, options)
+
+          # +merge+ is because options is a hash with_indifferent_access, and will therefore have an 'object' attribute when converted to html
+          #super method, {}.merge(field.options)
+          content_tag 'v-upload', nil, field.options
+        else
+          options.delete(:default)
+          super method, options
+        end
+      end
+
+      class UploadField
+
+        include ::ActionDispatch::Routing::PolymorphicRoutes
+
+        include ::Rails.application.routes.url_helpers
+
+        include ::ActionView::Helpers::TextHelper
+
+        attr_reader :options, :template
+
+        def initialize(model, method, template, options)
+          @model = model
+          @method = method.to_sym
+          @template = template
+          @options = options.with_indifferent_access
+          prepare
+        end
+
+        def prepare
+          #add_preview_class if has_preview_template?
+
+          options.merge!({
+            ':multiple'   => multiple?,
+            ':files'      => files.to_json,
+            ':cached'     => caches.to_json,
+            ':removed'    => removals.to_json,
+            ':options'    => preview_options.to_json,
+            'accept'      => accept,
+            'preview'     => preview_name,
+            'param'       => input_name,
+            'url'         => polymorphic_path(@model.class, action: :upload)
+          })
+
+          #options[:data] ||= {}
+          #options[:data].merge!({
+          #  upload_files: files,
+          #  upload_cache: caches,
+          #  upload_remove: removals,
+          #  upload_options: preview_options
+          #})
+        end
+
+        def preview_options
+          previews = Voltron.config.upload.previews || {}
+          opts = previews.with_indifferent_access.try(:[], preview_name) || {}
+          opts.merge!({
+            preview_template: preview_markup,
+          })
+          opts.merge!(options.delete(:options) || {})
+          opts.map { |k,v| { k.to_s.camelize(:lower) => v } }.reduce(Hash.new, :merge).compact
+        end
+
+        def preview_markup
+          if has_preview_template?
+            # Fetch the html found in the partial provided
+            ActionController::Base.new.render_to_string(partial: "voltron/upload/preview/#{preview_name}").squish
+          elsif has_preview_markup?
+            # If not blank, value of +preview+ is likely (should be) raw html, in which case, just return that markup
+            preview.squish
+          end
+        end
+
+        # Strip tags, they cause problems in the lookup_context +exists?+ and +render_to_string+
+        def preview_name
+          strip_tags(preview)
+        end
+
+        def preview
+          @preview ||= options.delete(:preview).to_s
+        end
+
+        def accept
+          @accept ||= options.delete(:accept).to_s
+        end
+
+        def has_preview_template?
+          preview_name.present? && template.lookup_context.exists?(preview_name, 'voltron/upload/preview', true)
+        end
+
+        # Eventually, consider utilizing Nokogiri to detect whether content also is actually HTML markup
+        # Right now the overhead and frustration of that gem is not worth it
+        def has_preview_markup?
+          preview.present?
+        end
+
+        #def add_preview_class
+        #  options[:class] ||= ''
+        #  classes = options[:class].split(/\s+/)
+        #  classes << "dz-layout-#{preview_name}"
+        #  options[:class] = classes.join(' ')
+        #end
+
+        def input_name
+          ActionView::Helpers::Tags::Base.new(ActiveModel::Naming.param_key(@model), @method, nil).send(:tag_name) + (multiple? ? '[]' : '')
+        end
+
+        def multiple?
+          @model.respond_to?("#{@method}_urls")
+        end
+
+        def files
+          # If set to not preserve files, return an empty array so nothing is shown
+          return [] if options[:preserve] === false
+
+          # Return an array of files' json data
+          uploads = Array.wrap(@model.send(@method)).map(&:to_upload_json).reject(&:blank?)
+
+          # Remove all uploads from the array that have been flagged for removal
+          removals.each do |removal|
+            uploads.reject! { |upload| upload[:id] == removal }
+          end
+
+          uploads
+        end
+
+        def caches
+          if multiple?
+            cache = @model.send("cache_#{@method}") rescue []
+            Array.wrap(cache)
+          else
+            Array.wrap(@model.send("cache_#{@method}"))
+          end
+        end
+
+        def removals
+          Array.wrap(@model.send("remove_#{@method}")).compact.reject { |i| !i }
+        end
+
+      end
+    end
+  end
+end

data/lib/voltron/upload/active_record/base.rb

@@ -0,0 +1,87 @@
+module Voltron
+  module Upload
+    module Base
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def mount_uploader(*args)
+          super *args
+
+          column = args.first.to_sym
+
+          attr_accessor "cache_#{column}"
+
+          before_validation do
+            uploader = self.class.uploaders[column]
+
+            begin
+              cache_id = send("cache_#{column}")
+              send(column).retrieve_from_cache!(cache_id) if cache_id.present?
+            rescue ::CarrierWave::InvalidParameter => e
+              # Invalid cache id, we don't need to do anything but skip it
+            end
+          end
+        end
+
+        def mount_uploaders(*args)
+          super *args
+
+          column = args.first.to_sym
+
+          attr_accessor "cache_#{column}"
+
+          before_validation do
+            uploader = self.class.uploaders[column]
+            cache_ids = (send("cache_#{column}") rescue []) || []
+
+            # Store the existing files
+            files = send(column)
+
+            cache_ids.each do |cache_id|
+              begin
+                # Retrieve files from the cache and add them to the list of files
+                file = uploader.new(self, column)
+                file.retrieve_from_cache!(cache_id)
+                files << file
+              rescue ::CarrierWave::InvalidParameter => e
+                # Invalid cache id, we don't need to do anything but skip it
+              end
+            end
+
+            # Set the files
+            send("#{column}=", files)
+          end
+
+          # Only required for multiple uploads. Since Carrierwave does not have any way to remove individual files
+          # we must identify each file to be removed individually, remove it from the array of existing files,
+          # then reset the value of our mounted files
+          after_validation do
+            # Only attempt to remove files if there are no validation errors
+            if errors.empty?
+              # Merge any new uploads with the pre-existing uploads (so we can "add" new files, instead of overwriting)
+              uploads = Array.wrap(send(column))
+
+              # Get the ids of uploads we want to remove
+              removals = Array.wrap(send("remove_#{column}"))
+
+              removals.each do |removal|
+                uploads.reject! { |upload| upload.id == removal }
+              end
+
+              # Initially ensure carrierwave DOESN'T think we want to remove ALL files, we're just going to change the files (i.e. - remove some, not all)
+              send("remove_#{column}=", false)
+
+              # Ensure that nil is assigned as the value if we indeed have no more files
+              send("remove_#{column}!") if uploads.empty?
+
+              assign_attributes(column => uploads)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/voltron/upload/carrierwave/uploader/base.rb

@@ -0,0 +1,66 @@
+module Voltron
+  module Upload
+    module CarrierWave
+      module Uploader
+        module Base
+
+          def initialize(*args)
+            self.class.send(:before, :store, :save_timestamp)
+            self.class.send(:after, :store, :apply_timestamp)
+            super(*args)
+          end
+
+          def to_upload_json
+            if present?
+              {
+                id: id,
+                url: url,
+                name: file.original_filename,
+                size: file.size,
+                type: file.content_type
+              }
+            else
+              {}
+            end
+          end
+
+          def id
+            if stored?
+              [File.mtime(full_store_path).to_i, file.original_filename].join('/')
+            elsif cached? && File.exists?(Rails.root.join('public', cache_path))
+              [cached?, file.original_filename].join('/')
+            else
+              file.original_filename
+            end
+          end
+
+          def stored?
+            File.exists?(full_store_path)
+          end
+
+          def full_store_path
+            Rails.root.join('public', store_path(file.filename))
+          end
+
+          private
+
+            # Before we store the file for good, grab the offset number
+            # so it can be used to create a unique timestamp after storing
+            def save_timestamp(*args)
+              id_components = File.basename(File.expand_path('..', file.path)).split('-')
+              @offset = id_components[2].to_i + 1000
+            end
+
+            # Update the modified time of the file to a unique timestamp
+            # This timestamp will later be used to help identify the file,
+            # as it will be part of the generated id
+            def apply_timestamp(*args)
+              @offset ||= rand(1..1000)
+              FileUtils.touch file.path, mtime: Time.now + @offset.seconds
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/voltron/upload/engine.rb

@@ -0,0 +1,20 @@
+module Voltron
+  module Upload
+    class Engine < Rails::Engine
+
+      isolate_namespace Voltron
+
+      initializer 'voltron.upload.initialize' do
+        ::ActionDispatch::Routing::Mapper.send :include, ::Voltron::Upload::Routes
+        ::ActionController::Base.send :extend, ::Voltron::Upload
+
+        ActiveSupport.on_load :active_record do
+          require 'voltron/upload/action_view/field'
+          ::ActionView::Helpers::FormBuilder.send :prepend, ::Voltron::Upload::Field
+          ::CarrierWave::Uploader::Base.send :prepend, ::Voltron::Upload::CarrierWave::Uploader::Base
+          ::ActiveRecord::Base.send :include, ::Voltron::Upload::Base
+        end
+      end
+    end
+  end
+end

data/lib/voltron/upload/error.rb

@@ -0,0 +1,20 @@
+module Voltron
+  module Upload
+    class Error < StandardError
+
+      attr_accessor :messages
+
+      def initialize(*messages)
+        @messages = messages.flatten
+      end
+
+      def response
+        { success: false, error: @messages }
+      end
+
+      def status
+        :not_acceptable
+      end
+    end
+  end
+end

data/lib/voltron/upload/version.rb

@@ -0,0 +1,5 @@
+module Voltron
+  module Upload
+    VERSION = '0.2.1'.freeze
+  end
+end

data/lib/voltron/upload.rb

@@ -0,0 +1,51 @@
+require 'voltron'
+require 'carrierwave'
+require 'voltron/upload/version'
+require 'voltron/config/upload'
+require 'voltron/upload/error'
+require 'voltron/uploader'
+require 'voltron/upload/carrierwave/uploader/base'
+require 'voltron/upload/active_record/base'
+require 'voltron/upload/action_dispatch/routes'
+
+module Voltron
+  module Upload
+
+    LOG_COLOR = :light_cyan
+
+    def uploadable(resource = nil)
+      include ControllerMethods
+
+      resource ||= controller_name
+      @uploader ||= Voltron::Uploader.new(resource)
+
+      rescue_from ActionController::InvalidAuthenticityToken do |e|
+        raise unless action_name == 'upload'
+        render json: { success: false, error: 'Invalid authenticity token provided' }, status: :unauthorized
+      end
+    end
+
+    module ControllerMethods
+
+      def upload
+        begin
+          render json: uploader.process!(upload_params), status: :created
+        rescue Voltron::Upload::Error => e
+          render json: e.response, status: e.status
+        end
+      end
+
+      def uploader
+        self.class.instance_variable_get('@uploader')
+      end
+
+      def upload_params
+        request.parameters[uploader.resource_name].slice(*uploader.permitted_params)
+      end
+
+    end
+
+  end
+end
+
+require "voltron/upload/engine" if defined?(Rails)

data/lib/voltron/uploader.rb

@@ -0,0 +1,58 @@
+module Voltron
+  class Uploader
+
+    attr_accessor :resource
+
+    def initialize(resource)
+      @resource = resource.to_s.classify.safe_constantize
+    end
+
+    # Resource name as it would appear in the params hash
+    def resource_name
+      resource.name.singularize.underscore.to_sym
+    end
+
+    # List of permitted parameters needed for upload action
+    def permitted_params
+      columns.keys.map(&:to_sym)
+      #.map { |name, multiple| multiple ? { name => [] } : name }
+    end
+
+    def process!(params)
+      params = params.map { |column, value| { column => multiple?(column) && value.is_a?(Array) ? value.map(&:values).flatten : value } }.reduce(Hash.new, :merge)
+      model = resource.new(params)
+
+      # Test the validity, get the errors if any
+      model.valid?
+
+      # Remove all errors that were not related to an uploader, they're expected in this case
+      (model.errors.keys - resource.uploaders.keys).each { |k| model.errors.delete k }
+
+      if model.errors.any?
+        # If any errors, return the messages
+        raise ::Voltron::Upload::Error.new(model.errors.full_messages)
+      else
+        { uploads: files_from(model) }
+      end
+    end
+
+    def files_from(model)
+      model.slice(columns.keys).values.flatten.reject(&:blank?).map(&:to_upload_json)
+    end
+
+    # Get a hash of uploader columns and whether or not it accepts multiple uploads
+    # i.e. - { column => multiple_uploads? }
+    # i.e. - { avatar: false }
+    def columns
+      @instance ||= resource.new
+      uploaders = resource.uploaders.keys.map(&:to_s)
+      resource.uploaders.map { |k,v| { k.to_s => multiple?(k) } }.reduce(Hash.new, :merge)
+    end
+
+    def multiple?(column)
+      @instance ||= resource.new
+      @instance.respond_to?("#{column}_urls")
+    end
+
+  end
+end

data/voltron-upload.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'voltron/upload/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'voltron-upload'
+  spec.version       = Voltron::Upload::VERSION
+  spec.authors       = ['Eric Hainer']
+  spec.email         = ['eric@commercekitchen.com']
+
+  spec.summary       = %q{Adds logic to handle drag and drop file uploads with Dropzone.js}
+  spec.homepage      = 'https://github.com/ehainer/voltron-upload'
+  spec.license       = 'GNU GPL v3'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rails', '>= 4.2'
+  spec.add_dependency 'voltron', '>= 0.2.5'
+  spec.add_dependency 'carrierwave', '~> 1.0'
+  spec.add_dependency 'sass-rails', '>= 5.0'
+
+  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 11.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-rails', '~> 3.4'
+  spec.add_development_dependency 'factory_girl_rails', '~> 4.0'
+  spec.add_development_dependency 'jquery-rails', '~> 4'
+  spec.add_development_dependency 'sqlite3', '~> 1.2'
+end