glebtv-rails-uploader 0.4.1 → 0.5.0

data/app/views/rails_admin/main/_form_rails_uploader.haml

@@ -1,10 +1 @@
-= stylesheet_link_tag "uploader/application.css"
-= form.send 'uploader_field', field.method_name, field.html_attributes
-:javascript
-  (function(d, s, id) {
-    var js, fjs = d.getElementsByTagName(s)[0];
-    if (d.getElementById(id)) return;
-    js = d.createElement(s); js.id = id;
-    js.src = "/assets/uploader/rails_admin.js";
-    fjs.parentNode.appendChild(js);
-  }(document, 'script', 'uploader-jssdk'));
+= form.uploader_field(field.method_name, field.html_attributes.merge(sortable: true))

data/app/views/uploader/default/_container.html.erb

@@ -1,67 +1,52 @@
-<% if field.object_name =~ /.*\[.*\]\[(.*)\]/ %>
-    <% assoc = true %>
-    <% field.object.fileupload_guid = field.object.fileupload_guid + '_' + $1 %>
-<% else %>
-    <% assoc = false %>
-<% end %>
-
 <%= content_tag(:div, :id => field.id, :class => "uploader-dnd-area") do -%>
-    <% # if assoc || field.object.new_record? %>
-        <%= hidden_field(field.object_name, :fileupload_guid, :object => field.object) %>
-    <% # end %>
-
-    <div class="uploader-files" data-sort-path="<%= field.sort_path %>"></div>
-
-    <div class="uploader-dnd-hints">
-      <div class="uploader-button gray fileinput-button">
-        <div><%= I18n.t('uploader.button') %></div>
-        <%= fields_for field.object do |f| -%>
-            <%= f.fields_for field.method_name, field.klass.new do |m| -%>
-                <%= m.file_field(:data, field.input_html) %>
-            <% end -%>
-        <% end -%>
-      </div>
-
-      <div class="uploader-dnd-hint">
-        <%= I18n.t('uploader.or') %>
-        <span><%= I18n.t('uploader.drop') %></span>
-      </div>
-    </div>
-
-    <%= render :partial => "uploader/#{field.theme}/upload", :locals => {:field => field} %>
-    <%= render :partial => "uploader/#{field.theme}/download", :locals => {:field => field} %>
-
-    <script type="text/javascript">
-        $(function () {
-            var container = $("#<%= field.id %> div.uploader-files");
-
-            $('#<%= field.id %> input[type="file"]').attr('name', 'uploader_field').bind("init.uploader", function (e) {
-                if (!$.fn.fileupload) {
-                    return false;
-                }
-
-                $(this).fileupload({
-                    dataType: 'json',
-                    dropZone: $("#<%= field.id %>"),
-                    autoUpload: true,
-                    paramName: "asset[data]",
-                    formData: function (form) {
-                        return [];
-                    },
-                    filesContainer: container,
-                    namespace: 'uploader',
-                    uploadTemplateId: 'template-upload-<%= field.klass %>',
-                    downloadTemplateId: 'template-download-<%= field.klass %>'
-                });
-
-                <% if field.exists? -%>
-                <% fv = field.values.map { |v| v.respond_to?(:to_jq_upload) ? v.to_jq_upload : v } %>
-                $(this).data().blueimpFileupload
-                        ._renderDownload(<%=raw fv.to_json(:root => false) %>)
-                        .appendTo(container);
-                <% end -%>
-                container.trigger('init.sort');
-            }).trigger("init.uploader");
+  <%= hidden_field(field.object_name, :fileupload_guid, :object => field.object) if field.object.new_record? %>
+  
+  <div class="uploader-files"></div>
+  
+	<div class="uploader-dnd-hints">  
+	  <span class="uploader-button gray fileinput-button">
+      <span><%= I18n.t('uploader.button') %></span>
+      <%= fields_for field.object do |f| -%>
+	      <%= f.fields_for field.method_name, field.klass.new do |m| -%>
+          <%= m.file_field(:data, field.input_html) %>
+	      <% end -%>
+	    <% end -%>
+    </span>
+    
+	  <div class="uploader-dnd-hint">
+		  <%= I18n.t('uploader.or') %><span><%= I18n.t('uploader.drop') %></span>
+	  </div>
+	</div>
+	
+	<%= render :partial => "uploader/#{field.theme}/upload", :locals => {:field => field} %>
+  <%= render :partial => "uploader/#{field.theme}/download", :locals => {:field => field} %>
+  <%= render :partial => "uploader/#{field.theme}/sortable", :locals => {:field => field} if field.sortable? %>
+  
+	<script type="text/javascript">
+    $(function() {
+      var uploader, container;
+      container = $("#<%= field.id %> div.uploader-files");
+      
+      $('#<%= field.id %> input[type="file"]').each(function(){
+        $(this).fileupload({
+          dataType: 'json',
+          dropZone: $("#<%= field.id %>"),
+          autoUpload: true,
+          paramName: "asset[data]",
+          formData: function(form){ return []; },
+          filesContainer: container,
+          namespace: 'uploader',
+          uploadTemplateId: 'template-upload-<%= field.klass %>',
+          downloadTemplateId: 'template-download-<%= field.klass %>'
         });
-    </script>
+        
+        <% if field.exists? -%>
+          uploader = ($(this).data('blueimp-fileupload') || $(this).data('fileupload'));
+          uploader
+            ._renderDownload(<%=raw field.values.sort_by {|s| s.sort }.map(&:to_jq_upload).to_json %>)
+            .appendTo(container);
+        <% end -%>
+      });
+    });
+  </script>
 <% end -%>

data/app/views/uploader/default/_download.html.erb

@@ -1,17 +1,21 @@
 <!-- The template to display files available for download -->
 <script id="template-download-<%= field.klass %>" type="text/x-tmpl">
 {% for (var i=0, file; file=o.files[i]; i++) { %}
-  <div class="attach_item template-download" data-id="{%=file.id%}">
-		<div class="delete">
-      <a href="/" class="del_btn delete" data-type="DELETE" data-url="/uploader/attachments/{%=file.id%}?guid={%= file.guid %}&klass=<%= field.klass %>"></a>
-		</div>
-		<div class="thumbnail preview">
-		  <a href="{%=file.url%}"><img src="{%=file.thumb_url%}" title="{%=file.filename%}" rel="gallery"></a>
-		</div>
-		<div class="infoHolder">
-			<div class="fileName">{%=file.filename%}</div>
-			<div class="fileWeight">{%=o.formatFileSize(file.size)%}</div>
-		</div>
-	</div>
+  <div id="asset_{%=file.id%}" class="attach_item template-download">
+    <div class="buttons-panel">
+      <a href="#" class="del_btn delete" data-type="DELETE" data-url="/uploader/attachments/{%=file.public_token%}?klass=<%= field.klass %>"></a>
+    </div>
+    <div class="thumbnail preview">
+      <a href="{%=file.url%}" download="{%=file.filename%}">
+        <img src="{%=file.thumb_url%}" title="{%=file.filename%}" rel="gallery" />
+      </a>
+    </div>
+    <div class="infoHolder">
+      <div class="fileName">
+        <a href="{%=file.url%}" download="{%=file.filename%}">{%=file.filename%}</a>
+      </div>
+      <div class="fileWeight">{%=o.formatFileSize(file.size)%}</div>
+    </div>
+  </div>
 {% } %}
 </script>

data/app/views/uploader/default/_upload.html.erb

@@ -2,8 +2,8 @@
 <script id="template-upload-<%= field.klass %>" type="text/x-tmpl">
 {% for (var i=0, file; file=o.files[i]; i++) { %}
   <div class="attach_item loading template-upload">
-		<div class="cancel"><a href="#" class="del_btn"></a></div>
-		<div class="thumbnail preview"><img class="preloader" src="/assets/uploader/preloader.gif" alt=""></div>
+		<div class="buttons-panel"><a href="#" class="del_btn cancel"></a></div>
+		<div class="thumbnail preview"><img class="preloader" src="/assets/uploader/preloader.gif" alt="preloader" /></div>
 		<div class="infoHolder">
 			<div class="fileName">{%=file.name%}</div>
 			<div class="fileWeight">{%=o.formatFileSize(file.size)%}</div>

data/config/routes.rb

@@ -1,7 +1,3 @@
 Uploader::Engine.routes.draw do
-  resources :attachments, :only => [:create, :destroy] do
-    collection do
-      post :sort
-    end
-  end
+  resources :attachments, :only => [:create, :update, :destroy]
 end

data/lib/glebtv-rails-uploader.rb

@@ -1,3 +1,2 @@
 # encoding: utf-8
 require 'uploader'
-require 'file_size_validator'

data/lib/uploader.rb

@@ -12,7 +12,7 @@ module Uploader
   end
 
   def self.guid
-    SecureRandom.base64(15).tr('+/=', 'xyz').slice(0, 10)
+    SecureRandom.base64(16).tr('+/=', 'xyz').slice(0, 20)
   end
   
   def self.root_path
@@ -20,9 +20,9 @@ module Uploader
   end
   
   def self.assets
-    ['uploader/application.css', 'uploader/application.js', 'uploader/rails_admin.js'] +
-    Dir[root_path.join('app/assets/javascripts/uploader/**', '*.{js,css}')].inject([]) do |list, path|
-      list << Pathname.new(path).relative_path_from(root_path.join('app/assets/javascripts')).to_s
+    Dir[root_path.join('vendor/assets/**/uploader/**', '*.{js,css,png,gif}')].inject([]) do |list, path|
+      folder = path.split('/assets/')[1].split('/')[0]
+      list << Pathname.new(path).relative_path_from(root_path.join("vendor/assets/#{folder}")).to_s
       list
     end
   end
@@ -37,4 +37,4 @@ require 'uploader/engine'
 
 if Object.const_defined?("RailsAdmin")
   require "uploader/rails_admin/field"
-end
+end

data/lib/uploader/asset.rb

@@ -1,51 +1,94 @@
 module Uploader
   module Asset
-    # Save asset
-    # Usage:
-    #
-    #   class Asset < ActiveRecord::Base
-    #     include Uploader::Asset
-    #
-    #     def uploader_create(params, request = nil)
-    #       self.user = request.env['warden'].user
-    #       super
-    #     end
-    #   end
-    #
-    def uploader_create(params, request = nil)
-      self.guid = params[:guid]
-      self.assetable_type = params[:assetable_type]
-      if self.class.respond_to?(:collection) && !params[:assetable_id].blank?
-        if defined?( Moped::BSON )
-          self.assetable_id = Moped::BSON::ObjectId.from_string(params[:assetable_id])
-        else
-          self.assetable_id = BSON::ObjectId.from_string(params[:assetable_id])
+    def self.included(base)
+      base.send(:extend, Uploader::Asset::ClassMethods)
+      base.send(:include, Uploader::Asset::AssetProcessor)
+
+      base.instance_eval do
+        before_create :generate_public_token
+      end
+    end
+
+    module Mongoid
+      def self.included(base)
+        base.send(:extend, Uploader::Asset::ClassMethods)
+        base.send(:include, Uploader::Asset::AssetProcessor)
+
+        base.instance_eval do
+          field :guid, type: String
+          field :public_token, type: String
+
+          before_create :generate_public_token
+        end
+      end
+
+      def assetable_id_format(assetable_id)
+        BSON::ObjectId.from_string(assetable_id)
+      end
+
+      class << self
+        def include_root_in_json
+          false
+        end
+      end
+    end
+
+    module ClassMethods
+      def generate_token(column)
+        loop do
+          token = Uploader.guid
+          break token unless where({ column => token }).exists?
         end
-      else
-        self.assetable_id = params[:assetable_id]
       end
+    end
 
-      save
+    module AssetProcessor
+      # Save asset
+      # Usage:
+      #
+      #   class Asset < ActiveRecord::Base
+      #     include Uploader::Asset
+      #     
+      #     def uploader_create(params, request = nil)
+      #       self.user = request.env['warden'].user
+      #       super
+      #     end
+      #   end
+      #
+      def uploader_create(params, request = nil)
+        self.guid = params[:guid]
+        self.assetable_type = params[:assetable_type]
+        self.assetable_id = assetable_id_format(params[:assetable_id]) if params[:assetable_id]
+        save
+      end
+      
+      # Destroy asset
+      # Usage (cancan example):
+      #
+      #   class Asset < ActiveRecord::Base
+      #     include Uploader::Asset
+      #     
+      #     def uploader_destroy(params, request = nil)
+      #       ability = Ability.new(request.env['warden'].user)
+      #       if ability.can? :delete, self
+      #         super
+      #       else
+      #         errors.add(:id, :access_denied)
+      #       end
+      #     end
+      #   end
+      #
+      def uploader_destroy(params, request)
+        destroy
+      end
+
+      def generate_public_token
+        self.public_token = self.class.generate_token(:public_token)
+      end
     end
 
-    # Destroy asset
-    # Usage (cancan example):
-    #
-    #   class Asset < ActiveRecord::Base
-    #     include Uploader::Asset
-    #
-    #     def uploader_destroy(params, request = nil)
-    #       ability = Ability.new(request.env['warden'].user)
-    #       if ability.can? :delete, self
-    #         super
-    #       else
-    #         errors.add(:id, :access_denied)
-    #       end
-    #     end
-    #   end
-    #
-    def uploader_destroy(params, request)
-      destroy
+    def assetable_id_format(assetable_id)
+      assetable_id
     end
   end
 end

data/lib/uploader/engine.rb

@@ -4,22 +4,26 @@ require 'uploader'
 module Uploader
   class Engine < ::Rails::Engine
     isolate_namespace Uploader
-
+    
     initializer "uploader.assets_precompile" do |app|
       app.config.assets.precompile += Uploader.assets
     end
-
-    initializer "uploader.helpers" do
+    
+    initializer "uploader.helpers" do    
       ActiveSupport.on_load :action_view do
         ActionView::Base.send(:include, Uploader::Helpers::FormTagHelper)
         ActionView::Helpers::FormBuilder.send(:include, Uploader::Helpers::FormBuilder)
       end
     end
-
+   
     initializer "uploader.hooks" do
       require "uploader/hooks/active_record" if Object.const_defined?("ActiveRecord")
-      require "uploader/hooks/formtastic"    if Object.const_defined?("Formtastic")
-      require "uploader/hooks/simple_form"   if Object.const_defined?("SimpleForm")
+
+      if Object.const_defined?("SimpleForm")
+        require "uploader/hooks/simple_form"
+      elsif Object.const_defined?("Formtastic")
+        require "uploader/hooks/formtastic" 
+      end
     end
   end
 end

data/lib/uploader/fileuploads.rb

@@ -4,83 +4,104 @@ module Uploader
       base.send :extend, SingletonMethods
     end
 
+    module Mongoid
+      def self.included(base)
+        base.send :include, Uploader::Fileuploads
+      end
+
+      def self.include_root_in_json
+        false
+      end
+    end
+
     module SingletonMethods
-      # Join Mongoid object with uploaded file
+      # Join ActiveRecord object with uploaded file
+      # Usage:
+      # 
+      #   class Article < ActiveRecord::Base
+      #     has_one :picture, :as => :assetable, :dependent => :destroy
+      #
+      #     fileuploads :picture
+      #   end
+      #
+      #
       def fileuploads(*args)
         options = args.extract_options!
-
+        
         class_attribute :fileuploads_options, :instance_writer => false
         self.fileuploads_options = options
-
+        
         class_attribute :fileuploads_columns, :instance_writer => false
         self.fileuploads_columns = args.map(&:to_sym)
-
+        
         unless self.is_a?(ClassMethods)
           include InstanceMethods
           extend ClassMethods
-
+          
           after_save :fileuploads_update, :if => :fileupload_changed?
-
+          
           fileuploads_columns.each { |asset| accepts_nested_attributes_for asset, :allow_destroy => true }
         end
       end
     end
-
+    
     module ClassMethods
       # Update reflection klass by guid
       def fileupload_update(record_id, guid, method)
-        query = fileupload_klass(method).where(:guid => guid, :assetable_type => base_class.name.to_s)
-        if defined?( Moped::BSON )
-          record_id = Moped::BSON::ObjectId.from_string(record_id) unless record_id.class.name == "Moped::BSON::ObjectId"
-        else 
-          record_id = BSON::ObjectId.from_string(record_id) unless record_id.class.name == "BSON::ObjectId"
-        end
-        query.update_all(:assetable_id => record_id, :guid => nil)
+        fileupload_scope(method, guid).update_all(:assetable_id => record_id, :guid => nil)
       end
-
-      # Find asset by guid
+      
+      # Find asset(s) by guid
       def fileupload_find(method, guid)
-        klass = fileupload_klass(method)
-        klass.where(:guid => guid).first
+        query = fileupload_scope(method, guid)
+        fileupload_multiple?(method) ? query.all : query.first
       end
 
+      def fileupload_scope(method, guid)
+        fileupload_klass(method).where(:guid => guid, :assetable_type => base_class.name.to_s)
+      end
+      
       # Find class by reflection
       def fileupload_klass(method)
         reflect_on_association(method.to_sym).klass
       end
 
+      def fileupload_multiple?(method)
+        association = reflect_on_association(method.to_sym)
+
+        # many? for Mongoid, :collection? for AR
+        method_name = association.respond_to?(:many?) ? :many? : :collection?
+
+        !!(association && association.send(method_name))
+      end
+
       unless respond_to?(:base_class)
         def base_class
           self
         end
       end
     end
-
+    
     module InstanceMethods
       # Generate unique key
       def fileupload_guid
         @fileupload_guid ||= Uploader.guid
       end
-
+      
       def fileupload_guid=(value)
         @fileupload_changed = true unless value.blank?
         @fileupload_guid = value.blank? ? nil : value
       end
-
+      
       def fileupload_changed?
         @fileupload_changed === true
       end
-
+      
       def fileupload_multiple?(method)
-        association = self.class.reflect_on_association(method.to_sym)
-        if association.respond_to?(:collection?)
-          !!(association && association.collection?)
-        else
-          association.macro == :has_many
-        end
+        self.class.fileupload_multiple?(method)
       end
+      
       # Find or build new asset object
-
       def fileupload_asset(method)
         if fileuploads_columns.include?(method.to_sym)
           asset = new_record? ? self.class.fileupload_find(method, fileupload_guid) : send(method)
@@ -88,12 +109,13 @@ module Uploader
           asset
         end
       end
-
+      
       def fileuploads_columns
         self.class.fileuploads_columns
       end
-
+      
       protected
+      
         def fileuploads_update
           fileuploads_columns.each do |method|
             self.class.fileupload_update(id, fileupload_guid, method)