glebtv-rails-uploader 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88efe49c0d42aff2f12db2360479b4251fedc7a6
-  data.tar.gz: 6878df72b63fca3d0196d14fb5d4c3cc9c478b51
+  metadata.gz: c9ea7aed1c3dc17e2923dd15546cb0a417b1309d
+  data.tar.gz: 38353c20fc5a4c43a19cbad8f2f8c2b50f8d8bf7
 SHA512:
-  metadata.gz: fc980ceee75826bfd9d73ac15a4ed178575bc7fb99b9e6ada11f6024cfefe70bb6bd7bc53e0d6efcb1fdc0ae682f69447e668dd78f0e1c80d04cb98cc7ed46c6
-  data.tar.gz: beb74c354fa43d79cd95dd9ac9a2744c7c54bba1823e154d9d2d74a214cf8a76f0c8303155ab5faf95540fa046783f10f1783cc63d74983c83880f1206147c6c
+  metadata.gz: 8c0b5db051449405489eaaa1d65822d1c924a559f431c20cce280b4bd23914a7a4304ddaf27f6dbd980dcb1737d6973b6097ee82a212b88959f0bc413194f8e0
+  data.tar.gz: 55883971815eda043a179e150a78b806321dd6262b71274343c773fc9402413b0c21fd5625798db44c8d9bb58746f52f42010848eaf8310cbecf03579bb8d94e

data/README.md

@@ -1,11 +1,4 @@
-## this fork adds mongoid and rails_admin support. 
-## ActiveRecord support is dropped!
-
-This fork works when both simple form and formtastic are loaded
-
-Also nested associations are working
-
-## HTML5 File uploader for rails
+# HTML5 File uploader for rails
 
 This gem use https://github.com/blueimp/jQuery-File-Upload for upload files.
 
@@ -13,12 +6,12 @@ Preview:
 
 ![Uploader in use](http://img39.imageshack.us/img39/2206/railsuploader.png)
 
-
 ## Install
 
 In Gemfile:
-``` ruby
-gem "glebtv-rails-uploader"
+
+```
+gem "rails-uploader"
 ```
 
 In routes:
@@ -27,127 +20,13 @@ In routes:
 mount Uploader::Engine => '/uploader'
 ```
 
-## HowTo for mongoid / carrierwave:
-
-### Asset Parent Model (common)
-``` ruby
-    # models/asset.rb
-    class Asset
-      include Mongoid::Document
-      include Uploader::Asset
-
-      field :guid, type: String
-      belongs_to :assetable, polymorphic: true
-
-      # this workaround is sometimes needed so IDs are ObjectIDs not strings  
-      before_save do
-        return true if self.assetable_id.nil? || !self.assetable_id.is_a?(String)
-        if defined?(Moped::BSON)
-          self.assetable_id = Moped::BSON::ObjectId.from_string(self.assetable_id) if Moped::BSON::ObjectId.legal?(self.assetable_id)
-        else
-          self.assetable_id = BSON::ObjectId.from_string(self.assetable_id) if BSON::ObjectId.legal?(self.assetable_id)
-        end
-        true
-      end
-    end
-  ```
-
-### Your asset model
-``` ruby
-    # models/cover.rb
-    class Cover < Asset
-      # DO NOT add this!
-      # belongs_to :post
-
-      # optional built-in sorting for rails_admin
-      field :sort, type: Integer
-
-      # field name must be 'data'
-      mount_uploader :data, CoverUploader
-
-      validates :data,
-          :presence => true,
-          :file_size => {
-              :maximum => 5.megabytes.to_i
-          }
-
-      def to_jq_upload
-        {
-            'id'  => id.to_s,
-            "filename" => File.basename(data.path),
-            "url" => data.url,
-            'thumb_url' => data.thumb.url,
-        }
-      end
-    end
-```
-
-### Model to which you want to add assets
-```ruby
-    # models/post.rb
-    class Post
-      include Mongoid::Document
-
-      field :fileupload_guid, type: String
-
-      include Uploader::Fileuploads
-      has_one :cover, as: :assetable
-      fileuploads :cover
-    end
-```
-
-### has_many
-
-```ruby
-class Album
-  has_many :pictures, as: :assetable, dependent: :destroy
-  fileuploads :pictures
-
-  accepts_nested_attributes_for :pictures
-
-  rails_admin do
-    edit do
-      ...
-      field :fileupload_guid, :hidden # this is needed or else rails_admin sanitizes it away
-      field :pictures, :rails_uploader
-    end
-  end
-end
-
-```
-
-### CarrierWave uploader - all like usual
-```ruby
-    # uploades/cover_uploader.rb
-    class CoverUploader < CarrierWave::Uploader::Base
-      include CarrierWave::MiniMagick
-
-      storage :file
-
-      def store_dir
-        "uploads/covers/#{model.id}"
-      end
-
-      version :thumb do
-        process resize_to_limit: [50, 50]
-      end
-    end
-```
-
-# Active Admin and RailsAdmin are both working
+Migration for ActiveRecord:
 
-# RailsAdmin Integration
-``` ruby
-    rails_admin do
-        edit do
-          ...
-          field :fileupload_guid, :hidden # this is needed or else rails_admin sanitizes it away
-          field :pictures, :rails_uploader
-        end
-    end
+```bash
+$> rake uploader:install:migrations
 ```
 
-## Usage (Original description)
+## Usage
 
 Architecture to store uploaded files (cancan integration):
 
@@ -182,6 +61,17 @@ class Picture < Asset
 
   validates_integrity_of :data
   validates_filesize_of :data, :maximum => 2.megabytes.to_i
+
+  # structure of returned json array of files. (used in Hash.to_json operation)
+  def serializable_hash(options=nil)
+    {
+        "id" => id.to_s,
+        "filename" => File.basename(data.path),
+        "url" => data.url,
+        "thumb_url" => data.url(:thumb),
+        "public_token" => public_token
+    }
+  end
 end
 ```
 
@@ -206,66 +96,78 @@ Find asset by foreign key or guid:
 
 ### Mongoid
 
+No parent asset model is required, one only has to `include Uploader::Asset::Mongoid` into the
+model that should act like an asset:
+
 ``` ruby
-class Asset
+class Picture
   include Mongoid::Document
   include Uploader::Asset::Mongoid
 
-  belongs_to :assetable, polymorphic: true
+  belongs_to :user
 end
 
-class Picture < Asset
-  mount_uploader :data, ImageUploader
+class User
+  include Mongoid::Document
+  include Uploader::Fileuploads
+
+  has_one :picture, :as => :assetable
 
-  default_scope asc( :sort_order )
+  fileuploads :picture
 end
+```
+
+### Notice
 
+User method fileuploads only once pre model. So if you have many attached files, use this:
+
+``` ruby
 class User
-  include Mongoid::Document
-  include Uploader::Fileuploads::Mongoid
+  include Uploader::Fileuploads
 
-  has_many :pictures, :as => :assetable
+  has_one :picture, :as => :assetable
+  has_one :avatar, :as => :assetable
 
-  fileuploads :pictures
+  fileuploads :picture, :avatar
 end
 ```
 
+
 ### Include assets
 
 Javascripts:
 
-``` ruby
-//= require jquery.ui.widget
+```
 //= require uploader/application
 ```
 
 Stylesheets:
 
-``` ruby
+```
 *= require uploader/application
 ```
 
 ### Views
 
-``` ruby
+```erb
 <%= uploader_field_tag :article, :photo %>
 ```
 
 or FormBuilder:
 
-``` ruby
+```erb
 <%= form.uploader_field :photo, :sortable => true %>
 ```
 
 ### Formtastic
 
-``` ruby
+```erb
 <%= f.input :pictures, :as => :uploader %>
 ```
 
 ### SimpleForm
 
-``` ruby
+```erb
 <%= f.input :pictures, :as => :uploader, :input_html => {:sortable => true} %>
 ```
 
@@ -273,7 +175,7 @@ or FormBuilder:
 
 This is only working in Formtastic and FormBuilder:
 
-``` ruby
+``` erb
 # formtastic
 <%= f.input :picture, :as => :uploader, :confirm_delete => true %>
 # the i18n lookup key would be en.formtastic.delete_confirmations.picture

data/Rakefile

@@ -1,6 +1,4 @@
 # encoding: utf-8
-require 'bundler/gem_tasks'
-
 require 'rake'
 require 'rake/testtask'
 require 'rdoc/task'
@@ -24,3 +22,5 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+require "bundler/gem_tasks"

data/app/assets/javascripts/uploader/application.js

@@ -1,9 +1,8 @@
-//= require uploader/tmpl
-//= require uploader/canvas-to-blob
-//= require uploader/load-image
+//= require uploader/jquery.ui.widget
+//= require uploader/locales/en
+//= require uploader/tmpl.min
+//= require uploader/load-image.min
+//= require uploader/jquery.iframe-transport
 //= require uploader/jquery.fileupload
-//= require uploader/jquery.fileupload-process
-//= require uploader/jquery.fileupload-resize
-//= require uploader/jquery.fileupload-validate
 //= require uploader/jquery.fileupload-ui
 

data/app/assets/javascripts/uploader/rails_admin.js

@@ -1,27 +1,8 @@
-//= require uploader/tmpl
-//= require uploader/canvas-to-blob
-//= require uploader/load-image
+//= require uploader/jquery.ui.widget
+//= require uploader/jquery.ui.sortable
+//= require uploader/locales/en
+//= require uploader/tmpl.min
+//= require uploader/load-image.min
+//= require uploader/jquery.iframe-transport
 //= require uploader/jquery.fileupload
-//= require uploader/jquery.fileupload-process
-//= require uploader/jquery.fileupload-resize
-//= require uploader/jquery.fileupload-validate
 //= require uploader/jquery.fileupload-ui
-
-$(document).off('init.sort').on('init.sort', '.uploader-files', function() {
-    var $t = $(this);
-    $t.sortable({
-        update: function(event, ui) {
-            var sort = [];
-            $t.children().each(function() {
-                sort.push($(this).data('id'));
-            });
-            $.ajax({
-                type: 'POST',
-                url: $t.data('sortPath'),
-                data: {sort: sort.join('|')}
-            })
-        }
-    })
-});
-
-$('.uploader-dnd-area input[type=file]').trigger("init.uploader");

data/app/assets/stylesheets/uploader/application.css.sass

@@ -0,0 +1,2 @@
+@import uploader/jquery.fileupload-ui
+@import uploader/default

data/app/controllers/uploader/attachments_controller.rb

@@ -1,79 +1,57 @@
-# encoding: utf-8
 module Uploader
   class AttachmentsController < ActionController::Metal
     include AbstractController::Callbacks
-
+  
     before_filter :find_klass
-
+    before_filter :find_asset, :only => [:destroy]
+    
     def create
       @asset = @klass.new(params[:asset])
       @asset.uploader_create(params, request)
       render_resourse(@asset, 201)
     end
+    
+    def update
+      @assets = Array.wrap(params[:assets] || [])
 
-    def destroy
-      begin
-        @asset = @klass.find(params[:id])
-      rescue
-        @asset = @klass.where(guid: params[:guid])
-      end
-      @asset.uploader_destroy(params, request)
-      render_resourse(@asset, 200)
-    end
-
-    def sort
-      @model = params[:assetable_type].safe_constantize
-
-      sort = params[:sort].split('|')
-      if params[:assetable_id].blank?
-        @finder = @klass.where(guid: params[:guid])
-      else
-        @finder = @klass.where(assetable_id: params[:assetable_id])
+      @assets.each_with_index do |id, index|
+        @klass.where(:id => id).update_all(:sort => index)
       end
 
-      @finder.each do |asset|
-        if asset.respond_to?(:sort=)
-          asset.sort = sort.index(asset.id.to_s)
-          asset.save!
-        end
-      end
-
-      self.status = 200
-      self.content_type = "application/json"
-      self.response_body = '{"ok": true}'
+      render_json({files: []})
     end
 
+    def destroy
+      @asset.uploader_destroy(params, request)
+      render_json({success: true})
+    end
+    
     protected
-
-
-      def airbrake_request_data
-        {
-            :controller       => params[:controller],
-            :action           => params[:action],
-        }
-      end
-
+    
       def find_klass
-        @klass = params[:klass].blank? ? nil : params[:klass].safe_constantize
+        @klass = Uploader.constantize(params[:klass])
         raise ActionController::RoutingError.new("Class not found #{params[:klass]}") if @klass.nil?
       end
 
+      def find_asset
+        @asset = @klass.where(:public_token => params[:id]).first
+        raise ActionController::RoutingError.new("Asset not found by guid #{params[:id]}") if @asset.nil? 
+      end
+      
       def render_resourse(record, status = 200)
         if record.errors.empty?
-          if record.respond_to?(:to_jq_upload)
-            render_json({'files' => Array.wrap(record.to_jq_upload)}.to_json, status)
-          else
-            render_json({'files' => Array.wrap(record)}.to_json, status)
-          end
+          render_json({:files => [record.to_jq_upload]}, status)
         else
-          render_json([record.errors].to_json, 422)
+          render_json(record.errors, 422)
         end
       end
+      
+      def render_json(hash_or_object, status = 200)
+        ctype = env["HTTP_USER_AGENT"] && env["HTTP_USER_AGENT"].include?("Android") ? "text/plain" : "application/json"
 
-      def render_json(body, status = 200)
         self.status = status
-        self.content_type = "application/json"
-        self.response_body = body
+        self.content_type = ctype
+        self.response_body = hash_or_object.to_json(:root => false)
       end
   end
 end