glebtv-rails-uploader 0.0.8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Fodojo http://fodojo.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,241 @@
+# this fork adds mongoid support
+
+This fork works when both simple form and formtastic are loaded
+
+Also nested associations seem to be working
+
+a little 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
+    end
+```
+
+### Your asset model
+``` ruby
+    # models/cover.rb
+    class Cover < Asset
+      # DO NOT add this!
+      # belongs_to :post
+
+      # 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
+      include Uploader::Fileuploads
+      has_one :cover, as: :assetable
+      fileuploads :cover
+    end
+```
+
+### has_many
+
+```ruby
+class Album
+  # optional built-in sorting for rails_admin
+  def sort_assets!(order)
+    pos = 0
+    order.each do |pic_id|
+        pic = self.pictures.find(pic_id)
+        pic.sort = (pos+=1)
+        pic.save!
+    end
+  end
+
+  has_many :pictures, as: :assetable, dependent: :destroy
+  fileuploads :pictures
+
+  accepts_nested_attributes_for :pictures
+
+  rails_admin do
+    edit do
+      ...
+      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
+
+# RailsAdmin Integration
+``` ruby
+    rails_admin do
+        edit do
+          ...
+          field :pictures, :rails_uploader
+        end
+    end
+```
+
+# HTML5 File uploader for rails
+
+This gem use https://github.com/blueimp/jQuery-File-Upload for upload files.
+
+Preview:
+
+![Uploader in use](http://img39.imageshack.us/img39/2206/railsuploader.png)
+
+## Install
+
+In Gemfile:
+
+    gem "glebtv-rails-uploader", require: 'rails-uploader'
+
+In routes:  
+
+``` ruby
+mount Uploader::Engine => '/uploader'
+```
+
+## Usage
+
+Architecture to store uploaded files (cancan integration):
+
+``` ruby
+class Asset < ActiveRecord::Base
+  include Uploader::Asset
+  
+  def uploader_create(params, request = nil)
+    ability = Ability.new(request.env['warden'].user)
+    
+    if ability.can? :create, self
+      self.user = request.env['warden'].user
+      super
+    else
+      errors.add(:id, :access_denied)
+    end
+  end
+  
+  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
+
+class Picture < Asset
+  mount_uploader :data, PictureUploader
+  
+  validates_integrity_of :data
+  validates_filesize_of :data, :maximum => 2.megabytes.to_i
+end
+```
+
+For example user has one picture:
+
+``` ruby
+class User < ActiveRecord::Base
+  has_one :picture, :as => :assetable, :dependent => :destroy
+  
+  fileuploads :picture
+
+  # If your don't use strong_parameters, uncomment next line
+  # attr_accessible :fileupload_guid
+end
+```
+
+Find asset by foreign key or guid:
+
+``` ruby
+@user.fileupload_asset(:picture)
+```
+
+### Include assets
+
+Javascripts:
+
+``` ruby
+//= require uploader/application
+```
+
+Stylesheets:
+
+``` ruby
+*= require uploader/application  
+```
+
+### Views
+
+``` ruby
+<%= uploader_field_tag :article, :photo %>
+```
+
+or FormBuilder:
+
+``` ruby
+<%= form.uploader_field :photo %>
+```
+
+### Formtastic
+
+``` ruby
+<%= f.input :picture, :as => :uploader %>
+```
+
+### SimpleForm
+
+``` ruby
+<%= f.input :picture, :as => :uploader %>
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Copyright (c) 2013 Fodojo, released under the MIT license

data/Rakefile

@@ -0,0 +1,26 @@
+# encoding: utf-8
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the rails-uploader plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the rails-uploader plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rails Uploader'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

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

@@ -0,0 +1,9 @@
+//= require uploader/locales/en
+//= require uploader/tmpl.min
+//= require uploader/load-image.min
+//= require uploader/jquery.ui.widget
+//= require uploader/jquery.iframe-transport
+//= require uploader/jquery.fileupload
+//= require uploader/jquery.fileupload-ui
+
+

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

@@ -0,0 +1,25 @@
+//= 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-ui
+
+$('.uploader-dnd-area input[type=file]').trigger("init.uploader");
+
+$('.uploader-files').each(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('|')}
+            })
+        }
+    })
+});

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

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require uploader/jquery.fileupload-ui
+ *= require uploader/default
+*/

data/app/controllers/uploader/attachments_controller.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+module Uploader
+  class AttachmentsController < ActionController::Metal
+    include AbstractController::Callbacks
+  
+    before_filter :find_klass
+    
+    def create
+      @asset = @klass.new(params[:asset])
+      @asset.uploader_create(params, request)
+      render_resourse(@asset, 201)
+    end
+    
+    def destroy
+      @asset = @klass.find(params[:id])
+      @asset.uploader_destroy(params, request)
+      render_resourse(@asset, 200)
+    end
+
+    def sort
+      @model = params[:assetable_type].safe_constantize
+      @object = @model.find(params[:assetable_id])
+
+      if @object.respond_to?(:sort_assets!)
+        @object.sort_assets!(params[:sort].split('|'))
+      end
+
+      self.status = 200
+      self.content_type = "application/json"
+      self.response_body = '{"ok": 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
+        raise ActionController::RoutingError.new("Class not found #{params[:klass]}") if @klass.nil?
+      end
+      
+      def render_resourse(record, status = 200)
+        if record.errors.empty?
+          if record.respond_to?(:to_jq_upload)
+            render_json(record.to_jq_upload.to_json(:root => false), status)
+          else
+            render_json([record].to_json(:root => false), status)
+          end
+
+        else
+          render_json([record.errors].to_json, 422)
+        end
+      end
+      
+      def render_json(body, status = 200)
+        self.status = status
+        self.content_type = "application/json"
+        self.response_body = body
+      end
+  end
+end

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

@@ -0,0 +1,10 @@
+= 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'));

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

@@ -0,0 +1,67 @@
+<% 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) {
+                    // not yet loaded
+                    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.first : v } %>
+                $(this).data("fileupload")
+                        ._renderDownload(<%=raw fv.to_json(:root => false) %>)
+                        .appendTo(container);
+                <% end -%>
+            }).trigger("init.uploader");
+        });
+    </script>
+<% end -%>