sunrise-file-upload 0.1.1

data/README.rdoc

@@ -0,0 +1,43 @@
+= Sunrise CMS: File uploader
+
+== Install
+
+  rails generate sunrise:file_upload:install
+
+== Callbacks
+
+  Sunrise::FileUpload::Manager.before_create do |env, asset|
+    asset.user = env['warden'].user if env['warden']
+  end
+  
+  Sunrise::FileUpload::Manager.after_create do |env, asset|
+    asset.user = env['warden'].user if env['warden']
+  end
+
+== Usage
+
+  class User < ActiveRecord::Base
+    has_one :picture, :as => :assetable, :dependent => :destroy
+    
+    fileuploads :picture
+  end
+
+Find asset by foreign key or guid:
+
+  @user.fileupload_asset(:picture)
+
+=== Views
+
+  <%= stylesheet_link_tag "fileupload/jquery.fileupload-ui.css" %>
+  <%= javascript_include_tag :fileupload %>
+  
+  <%= form.fileupload :picture %>
+  <%= form.hidden_field :fileupload_guid if form.object.new_record? %>
+  
+  <script id="fileupload_tmpl" type="text/x-jquery-tmpl">
+    <div class="fileupload-container">
+      <div class="fileupload-preview"><img alt="Фото" src="/images/userico.jpg"></div>
+      <div class="fileupload-button"><input type="image" value="Оберіть фаіл" src="/images/but_set.png"></div>
+      <ul class="fileupload-list" style="display:none;"></ul>
+    </div>
+  </script>

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.join(File.dirname(__FILE__), 'lib', 'sunrise', 'file_upload', 'version')
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the sunrise 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 sunrise-file-upload plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Sunrise FileUpload'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "sunrise-file-upload"
+    s.version = Sunrise::FileUpload::VERSION.dup
+    s.summary = "Rails FileUpload"
+    s.description = "Sunrise is a Aimbulance CMS"
+    s.email = "galeta.igor@gmail.com"
+    s.homepage = "https://github.com/galetahub/sunrise-file-upload"
+    s.authors = ["Igor Galeta", "Pavlo Galeta"]
+    s.files =  FileList["[A-Z]*", "{app,config,lib}/**/*"]
+    s.extra_rdoc_files = FileList["[A-Z]*"] - %w(Gemfile Rakefile)
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/lib/generators/sunrise/file_upload/USAGE

@@ -0,0 +1,7 @@
+Usage:
+  rails generate sunrise:file_upload:install
+
+Options:
+                 
+Example:
+  rails g sunrise:file_upload:install

data/lib/generators/sunrise/file_upload/install_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+
+module Sunrise
+  module Generators
+    module FileUpload
+      class InstallGenerator < Rails::Generators::Base
+        desc "This generator downloads and installs FileUploader"
+        source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+        
+        def copy_javascripts
+          copy_file "fileuploader-input.js", 'public/javascripts/fileupload/fileuploader-input.js'
+        end
+        
+        def download_stylesheet
+          say_status("fetching fileuploader.css", "", :green)
+          get "https://github.com/galetahub/file-uploader/raw/master/client/fileuploader.css", "public/javascripts/fileupload/fileuploader.css"
+        end
+        
+        def download_fileupload
+          say_status("fetching fileuploader.js", "", :green)
+          get "https://github.com/galetahub/file-uploader/raw/master/client/fileuploader.js", "public/javascripts/fileupload/fileuploader.js"
+        end
+      end
+    end
+  end
+end

data/lib/generators/sunrise/file_upload/templates/fileuploader-input.js

@@ -0,0 +1,217 @@
+// Collection of all instances on page
+qq.FileUploader.instances = new Object();
+
+/**
+ * Class that creates upload widget with drag-and-drop and file list
+ * @inherits qq.FileUploaderBasic
+ */
+qq.FileUploaderInput = function(o){
+    // call parent constructor
+    qq.FileUploaderBasic.apply(this, arguments);
+    
+    // additional options    
+    qq.extend(this._options, {
+        element: null,
+        // if set, will be used instead of qq-upload-list in template
+        listElement: null,
+        
+        template_id: '#fileupload_tmpl',
+
+        // template for one item in file list
+        fileTemplate: '<li>' +
+                '<span class="fileupload-file"></span>' +
+                '<span class="fileupload-spinner"></span>' +
+                '<span class="fileupload-size"></span>' +
+                '<a class="fileupload-cancel" href="#">Cancel</a>' +
+                '<span class="fileupload-failed-text">Failed</span>' +
+            '</li>',        
+        
+        classes: {
+            // used to get elements from templates
+            button: 'fileupload-button',
+            drop: 'fileupload-drop-area',
+            dropActive: 'fileupload-drop-area-active',
+            list: 'fileupload-list',
+            preview: 'fileupload-preview',
+                        
+            file: 'fileupload-file',
+            spinner: 'fileupload-spinner',
+            size: 'fileupload-size',
+            cancel: 'fileupload-cancel',
+
+            // added to list item when upload completes
+            // used in css to hide progress spinner
+            success: 'fileupload-success',
+            fail: 'fileupload-fail'
+        }
+    });
+    // overwrite options with user supplied    
+    qq.extend(this._options, o);       
+
+    this._element = document.getElementById(this._options.element);
+    this._element.innerHTML = $(this._options.template_id).tmpl(this._options).html();        
+    this._listElement = this._options.listElement || this._find(this._element, 'list');
+    
+    this._classes = this._options.classes;
+        
+    this._button = this._createUploadButton(this._find(this._element, 'button'));        
+    
+    this._bindCancelEvent();
+    //this._setupDragDrop();
+    
+    qq.FileUploader.instances[this._element.id] = this;
+};
+
+// inherit from Basic Uploader
+qq.extend(qq.FileUploaderInput.prototype, qq.FileUploaderBasic.prototype);
+
+qq.extend(qq.FileUploaderInput.prototype, {
+    /**
+     * Gets one of the elements listed in this._options.classes
+     **/
+    _find: function(parent, type){                                
+        var element = qq.getByClass(parent, this._options.classes[type])[0];        
+        if (!element){
+            throw new Error('element not found ' + type);
+        }
+        
+        return element;
+    },
+    _setupDragDrop: function(){
+        var self = this,
+            dropArea = this._find(this._element, 'drop');                        
+
+        var dz = new qq.UploadDropZone({
+            element: dropArea,
+            onEnter: function(e){
+                qq.addClass(dropArea, self._classes.dropActive);
+                e.stopPropagation();
+            },
+            onLeave: function(e){
+                e.stopPropagation();
+            },
+            onLeaveNotDescendants: function(e){
+                qq.removeClass(dropArea, self._classes.dropActive);  
+            },
+            onDrop: function(e){
+                dropArea.style.display = 'none';
+                qq.removeClass(dropArea, self._classes.dropActive);
+                self._uploadFileList(e.dataTransfer.files);    
+            }
+        });
+                
+        dropArea.style.display = 'none';
+
+        qq.attach(document, 'dragenter', function(e){     
+            if (!dz._isValidFileDrag(e)) return; 
+            
+            dropArea.style.display = 'block';            
+        });                 
+        qq.attach(document, 'dragleave', function(e){
+            if (!dz._isValidFileDrag(e)) return;            
+            
+            var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
+            // only fire when leaving document out
+            if ( ! relatedTarget || relatedTarget.nodeName == "HTML"){               
+                dropArea.style.display = 'none';                                            
+            }
+        });                
+    },
+    _onSubmit: function(id, fileName){
+        qq.FileUploaderBasic.prototype._onSubmit.apply(this, arguments);
+        this._addToList(id, fileName);  
+    },
+    _onProgress: function(id, fileName, loaded, total){
+        qq.FileUploaderBasic.prototype._onProgress.apply(this, arguments);
+
+        var item = this._getItemByFileId(id);
+        var size = this._find(item, 'size');
+        size.style.display = 'inline';
+        
+        var text; 
+        if (loaded != total){
+            text = Math.round(loaded / total * 100) + '% from ' + this._formatSize(total);
+        } else {                                   
+            text = this._formatSize(total);
+        }          
+        
+        qq.setText(size, text);         
+    },
+    _onComplete: function(id, fileName, result){
+        qq.FileUploaderBasic.prototype._onComplete.apply(this, arguments);
+
+        var item = this._getItemByFileId(id);
+        var asset = result.asset;
+        
+        // mark completed
+        qq.remove(this._find(item, 'cancel'));
+        qq.remove(this._find(item, 'spinner'));
+        
+        if (asset && asset.id){
+            qq.addClass(item, this._classes.success);
+            this._updatePreview(result);
+        } else {
+            qq.addClass(item, this._classes.fail);
+        }
+    },
+    _addToList: function(id, fileName){
+        if (this._listElement) {
+          var item = qq.toElement(this._options.fileTemplate);                
+          item.qqFileId = id;
+          
+          var fileElement = this._find(item, 'file');        
+          qq.setText(fileElement, this._formatFileName(fileName));
+          this._find(item, 'size').style.display = 'none';        
+
+          this._listElement.appendChild(item);
+        }
+    },
+    _getItemByFileId: function(id){
+        var item = this._listElement.firstChild;        
+        
+        // there can't be txt nodes in dynamically created list
+        // and we can  use nextSibling
+        while (item){            
+            if (item.qqFileId == id) return item;            
+            item = item.nextSibling;
+        }          
+    },
+    /**
+     * delegate click event for cancel link 
+     **/
+    _bindCancelEvent: function(){
+        var self = this,
+            list = this._listElement;            
+        
+        if (list) {
+          qq.attach(list, 'click', function(e){            
+              e = e || window.event;
+              var target = e.target || e.srcElement;
+              
+              if (qq.hasClass(target, self._classes.cancel)){                
+                  qq.preventDefault(e);
+                 
+                  var item = target.parentNode;
+                  self._handler.cancel(item.qqFileId);
+                  qq.remove(item);
+              }
+          });
+        }
+    },
+    
+    _updatePreview: function(result) {
+      var preview = this._find(this._element, 'preview'),
+          asset = result.asset || result;
+          img = null;
+      
+      if (preview && asset) {
+        img = document.createElement('img');
+        img.src = asset.thumb_url;
+        img.alt = asset.filename;
+        img.setAttribute('data-url', asset.url);
+        
+        preview.innerHTML = '';
+        preview.appendChild(img);
+      }
+    }
+});

data/lib/sunrise-file-upload.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'sunrise/file_upload'

data/lib/sunrise/file_upload.rb

@@ -0,0 +1,20 @@
+require 'active_support/secure_random'
+
+module Sunrise
+  module FileUpload
+    autoload :Http, 'sunrise/file_upload/http'
+    autoload :Manager, 'sunrise/file_upload/manager'
+    autoload :Request, 'sunrise/file_upload/request'
+    autoload :ActiveRecord, 'sunrise/file_upload/active_record'
+    autoload :Callbacks, 'sunrise/file_upload/callbacks'
+    
+    autoload :ViewHelper, 'sunrise/file_upload/view_helper'
+    autoload :FormBuilder, 'sunrise/file_upload/form_builder'
+    
+    def self.guid
+      ActiveSupport::SecureRandom.base64(15).tr('+/=', 'xyz').slice(0, 10)
+    end
+  end
+end
+
+require 'sunrise/file_upload/engine'

data/lib/sunrise/file_upload/active_record.rb

@@ -0,0 +1,95 @@
+module Sunrise
+  module FileUpload
+    module ActiveRecord
+      def self.included(base)
+        base.send :extend, SingletonMethods
+      end
+      
+      module SingletonMethods
+        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
+            
+            attr_accessible :fileupload_guid
+            after_save :fileuploads_update, :if => :fileupload_changed?
+            
+            args.each do |asset|
+              accepts_nested_attributes_for asset, :allow_destroy => true
+            end
+          end
+        end
+      end
+      
+      module ClassMethods
+        # Update reflection klass by guid
+        def fileupload_update(record_id, guid, method)
+          klass = fileupload_klass(method)
+          klass.update_all(["assetable_id = ?, guid = ?", record_id, nil], ["assetable_type = ? AND guid = ?", name, guid])
+        end
+        
+        # Find asset by guid
+        def fileupload_find(method, guid)
+          klass = fileupload_klass(method)
+          klass.where(:guid => guid).first
+        end
+        
+        protected
+          
+          def fileupload_klass(method)
+            reflections[method.to_sym].klass
+          end
+      end
+      
+      module InstanceMethods
+        # Generate unique key
+        def fileupload_guid
+          @fileupload_guid ||= Sunrise::FileUpload.guid
+        end
+        
+        def fileupload_guid=(value)
+          @fileupload_changed = true unless value.blank?
+          @fileupload_guid = value.blank? ? nil : value
+        end
+        
+        def fileupload_changed?
+          @fileupload_changed
+        end
+        
+        def fileupload_multiple?(method)
+          association = self.class.reflect_on_association(method)
+          association.collection? 
+        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)
+            asset ||= send("build_#{method}") if respond_to?("build_#{method}")
+          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)
+            end
+          end
+      end
+      
+    end
+  end
+end

data/lib/sunrise/file_upload/callbacks.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Sunrise
+  module FileUpload
+    module Callbacks
+      # Hook to _run_callbacks asserting for conditions.
+      def _run_callbacks(kind, *args) #:nodoc:
+        options = args.last # Last callback arg MUST be a Hash
+
+        send("_#{kind}").each do |callback, conditions|
+          invalid = conditions.find do |key, value|
+            value.is_a?(Array) ? !value.include?(options[key]) : (value != options[key])
+          end
+
+          callback.call(*args) unless invalid
+        end
+      end
+      
+      # A callback that runs before create asset
+      # Example:
+      #   Sunrise::FileUpload::Manager.before_create do |env, opts|
+      #   end
+      #
+      def before_create(options = {}, method = :push, &block)
+        raise BlockNotGiven unless block_given?
+        _before_create.send(method, [block, options])
+      end
+      
+      # Provides access to the callback array for before_create
+      # :api: private
+      def _before_create
+        @_before_create ||= []
+      end
+      
+      # A callback that runs after asset created
+      # Example:
+      #   Sunrise::FileUpload::Manager.after_create do |env, opts|
+      #   end
+      #
+      def after_create(options = {}, method = :push, &block)
+        raise BlockNotGiven unless block_given?
+        _after_create.send(method, [block, options])
+      end
+      
+      # Provides access to the callback array for after_create
+      # :api: private
+      def _after_create
+        @_after_create ||= []
+      end
+    end
+  end
+end

data/lib/sunrise/file_upload/engine.rb

@@ -0,0 +1,25 @@
+require 'rails'
+require 'sunrise-file-upload'
+
+module Sunrise
+  module FileUpload
+    class Engine < ::Rails::Engine
+      # Initialize Rack file upload
+      config.app_middleware.use Sunrise::FileUpload::Manager, :paths => "/sunrise/fileupload"
+    
+      config.before_initialize do
+        ActiveSupport.on_load :active_record do
+          ::ActiveRecord::Base.send :include, Sunrise::FileUpload::ActiveRecord
+        end
+        
+        ActiveSupport.on_load :action_view do
+          ActionView::Base.send :include, Sunrise::FileUpload::ViewHelper
+          ActionView::Helpers::FormBuilder.send :include, Sunrise::FileUpload::FormBuilder
+        
+          ActionView::Helpers::AssetTagHelper.register_javascript_expansion :fileupload => 
+            ["fileupload/fileuploader.js", "fileupload/fileuploader-input.js"]
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/file_upload/form_builder.rb

@@ -0,0 +1,21 @@
+module Sunrise
+  module FileUpload
+    module FormBuilder
+      def self.included(base)
+        base.send(:include, ClassMethods)
+      end
+      
+      module ClassMethods
+        # Example:
+		    # <%= form_for @post do |form| %>
+		    #   ...
+		    #   <%= form.fileupload :picture %>
+		    # <% end %>
+		    #
+		    def fileupload(method, options = {})
+		      @template.fileupload_tag(@object_name, method, objectify_options(options))
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/file_upload/http.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require 'digest/sha1'
+require 'mime/types'
+
+module Sunrise
+  module FileUpload
+    module Http
+      # Create file from hash
+      class UploadedFile
+        attr_accessor :original_filename, :content_type, :tempfile, :headers
+
+        def initialize(hash)
+          @original_filename = hash[:filename]
+          @content_type      = hash[:type]
+          @headers           = hash[:head]
+          @tempfile          = hash[:tempfile]
+          raise(ArgumentError, ':tempfile is required') unless @tempfile
+        end
+
+        def open
+          @tempfile.open
+        end
+
+        def path
+          @tempfile.path
+        end
+
+        def read(*args)
+          @tempfile.read(*args)
+        end
+
+        def rewind
+          @tempfile.rewind
+        end
+
+        def size
+          @tempfile.size
+        end
+      end
+      
+      # Usage (paperclip example)
+      # @asset.data = QqFile.new(params[:qqfile], request)
+      class QqFile < ::Tempfile
+
+        def initialize(filename, request, tmpdir = Dir::tmpdir)
+          @original_filename  = filename
+          @request = request
+          
+          super Digest::SHA1.hexdigest(filename), tmpdir
+          fetch
+        end
+       
+        def fetch
+          self.write @request.raw_post
+          self.rewind
+          self
+        end
+       
+        def original_filename
+          @original_filename
+        end
+       
+        def content_type
+          types = MIME::Types.type_for(@request.content_type)
+	        types.empty? ? @request.content_type : types.first.to_s
+        end
+      end
+      
+      # Convert nested Hash to HashWithIndifferentAccess and replace
+      # file upload hash with UploadedFile objects
+      def self.normalize_param(*args)
+        value = args.first
+        if Hash === value && value.has_key?(:tempfile)
+          UploadedFile.new(value)
+        elsif value.is_a?(String)
+          QqFile.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/file_upload/manager.rb

@@ -0,0 +1,76 @@
+module Sunrise
+  module FileUpload
+    class Manager
+      extend Sunrise::FileUpload::Callbacks
+      
+      def initialize(app, options = {})
+        @app = app
+        @paths = [options[:paths]].flatten
+      end
+      
+      def call(env)
+        raw_file_post?(env) ? create(env) : @app.call(env)
+      end
+      
+      # :api: private
+      def _run_callbacks(*args) #:nodoc:
+        self.class._run_callbacks(*args)
+      end
+
+      protected
+      
+        def create(env)
+          request = Request.new(env)
+          params = request.params.symbolize_keys
+          
+          klass = find_klass(params)
+          asset = find_asset(klass, params) || klass.new(params[:asset])
+      
+        	asset.assetable_type = params[:assetable_type]
+		      asset.assetable_id = params[:assetable_id].blank? ? 0 : params[:assetable_id].to_i
+		      asset.guid = params[:guid]
+        	asset.data = Http.normalize_param(params[:qqfile], request)
+          
+          _run_callbacks(:before_create, env, asset)
+          
+          if asset.save
+            body = asset.to_json
+            status = 200
+            
+            _run_callbacks(:after_create, env, asset)
+          else
+            body = asset.errors.to_json
+            status = 422
+          end
+          
+          [status, {'Content-Type' => 'text/html', 'Content-Length' => body.size.to_s}, body]
+        end
+      
+        def find_klass(params)
+          params[:klass].blank? ? Asset : params[:klass].classify.constantize
+        end
+        
+        def find_asset(klass, params)
+          query = klass.scoped
+          
+          unless params[:assetable_id].blank? || params[:assetable_type].blank?
+            query = query.where(:assetable_id => params[:assetable_id].to_i)
+            query = query.where(:assetable_type => params[:assetable_type])
+          else
+            query = query.where(:guid => params[:guid])
+          end
+                    
+          query.first
+        end
+        
+        def raw_file_post?(env)
+          env['REQUEST_METHOD'] == 'POST' && upload_path?(env['PATH_INFO'])
+        end
+        
+        def upload_path?(request_path)
+          return true if @paths.nil?
+          @paths.any? { |candidate| candidate == request_path  }
+        end
+    end
+  end
+end

data/lib/sunrise/file_upload/request.rb

@@ -0,0 +1,26 @@
+require 'rack/request'
+require 'stringio'
+
+module Sunrise
+  module FileUpload
+    class Request < ::Rack::Request
+    
+      def raw_post
+        unless @env.include? 'RAW_POST_DATA'
+          @env['RAW_POST_DATA'] = body.read(@env['CONTENT_LENGTH'].to_i)
+          body.rewind if body.respond_to?(:rewind)
+        end
+        @env['RAW_POST_DATA']
+      end
+      
+      def body
+        if raw_post = @env['RAW_POST_DATA']
+          raw_post.force_encoding(Encoding::BINARY) if raw_post.respond_to?(:force_encoding)
+          StringIO.new(raw_post)
+        else
+          @env['rack.input']
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/file_upload/version.rb

@@ -0,0 +1,5 @@
+module Sunrise
+  module FileUpload
+    VERSION = "0.1.1".freeze
+  end
+end

data/lib/sunrise/file_upload/view_helper.rb

@@ -0,0 +1,58 @@
+module Sunrise
+  module FileUpload
+    module ViewHelper
+      include ActionView::Helpers::JavaScriptHelper
+      
+      def fileupload_tag(object_name, method, options = {})
+        object = options.delete(:object) if options.key?(:object)
+        object ||= @template.instance_variable_get("@#{object_name}")  
+        
+        value = options.delete(:value) if options.key?(:value)
+        value ||= object.fileupload_asset(method)
+               
+        element_guid = object.fileupload_guid
+        element_id = dom_id(object, [method, element_guid].join('_'))
+        
+        script_options = (options.delete(:script) || {}).stringify_keys
+        
+        params = {
+          :klass => value.class.name, 
+          :assetable_id => object.new_record? ? nil : object.id, 
+          :assetable_type => object.class.name,
+          :guid => element_guid
+        }.merge(script_options.delete(:params) || {})
+        
+        script_options['action'] ||= '/sunrise/fileupload?' + Rack::Utils.build_query(params)
+        script_options['allowedExtensions'] ||=  ['jpg', 'jpeg', 'png', 'gif']
+        script_options['multiple'] ||= object.fileupload_multiple?(method)
+        
+        content_tag(:div, :class => 'fileupload') do
+          content_tag(:div, :id => element_id) do
+            content_tag(:noscript) do
+              fields_for object do |form|
+                form.fields_for method, value do |f|
+                  f.file_field :data
+                end
+              end
+            end
+          end + javascript_tag( fileupload_script(element_id, value, script_options) )
+        end
+      end
+      
+      protected
+      
+        def fileupload_script(element_id, value = nil, options = {})
+          options = { 'element' => element_id }.merge(options)
+          formatted_options = options.inspect.gsub('=>', ':')
+          js = [ "new qq.FileUploaderInput(#{formatted_options});" ]
+          
+          if value && !value.new_record?
+            js << "qq.FileUploader.instances['#{element_id}']._updatePreview(#{value.to_json});"
+          end
+          
+          "$(document).ready(function(){ #{js.join} });"
+        end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: sunrise-file-upload
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Igor Galeta
+- Pavlo Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-19 00:00:00 Z
+dependencies: []
+
+description: Sunrise is a Aimbulance CMS
+email: galeta.igor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/generators/sunrise/file_upload/USAGE
+- lib/generators/sunrise/file_upload/install_generator.rb
+- lib/generators/sunrise/file_upload/templates/fileuploader-input.js
+- lib/sunrise-file-upload.rb
+- lib/sunrise/file_upload.rb
+- lib/sunrise/file_upload/active_record.rb
+- lib/sunrise/file_upload/callbacks.rb
+- lib/sunrise/file_upload/engine.rb
+- lib/sunrise/file_upload/form_builder.rb
+- lib/sunrise/file_upload/http.rb
+- lib/sunrise/file_upload/manager.rb
+- lib/sunrise/file_upload/request.rb
+- lib/sunrise/file_upload/version.rb
+- lib/sunrise/file_upload/view_helper.rb
+homepage: https://github.com/galetahub/sunrise-file-upload
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: Rails FileUpload
+test_files: []
+