papermill 1.4.3 → 2.0.0.pre

data/lib/papermill/form_builder.rb

@@ -1,130 +1,122 @@
 class ActionView::Helpers::FormBuilder
   include ActionView::Helpers::FormTagHelper
   
-  def assets_upload(key = nil, options = {})
-    papermill_upload_tag key, { :thumbnail => false }.update(options)
+  def assets_upload(method, options = {})
+    papermill_upload_tag method, { :thumbnail => false }.update(options)
   end
-  def asset_upload(key = nil, options = {})
-    papermill_upload_tag key, { :gallery => false, :thumbnail => false }.update(options)
+  def asset_upload(method, options = {})
+    papermill_upload_tag method, { :gallery => false, :thumbnail => false }.update(options)
   end
-  def images_upload(key = nil, options = {})
-    papermill_upload_tag key, options
+  def images_upload(method, options = {})
+    papermill_upload_tag method, options
   end
-  def image_upload(key = nil, options = {})
-    papermill_upload_tag key, { :gallery => false }.update(options)
+  def image_upload(method, options = {})
+    papermill_upload_tag method, { :gallery => false }.update(options)
   end
 end
 
 module ActionView::Helpers::FormTagHelper
   
-  def assets_upload_tag(assetable, key = nil, options = {})
-    papermill_upload_tag key, { :thumbnail => false, :assetable => assetable }.update(options)
+  def assets_upload_tag(assetable, method, options = {})
+    papermill_upload_tag method, { :thumbnail => false, :assetable => assetable }.update(options)
   end
   
-  def asset_upload_tag(assetable, key = nil, options = {})
-    papermill_upload_tag key, { :gallery => false, :thumbnail => false, :assetable => assetable }.update(options)
+  def asset_upload_tag(assetable, method, options = {})
+    papermill_upload_tag method, { :gallery => false, :thumbnail => false, :assetable => assetable }.update(options)
   end
   
-  def images_upload_tag(assetable, key = nil, options = {})
-    papermill_upload_tag key, { :assetable => assetable }.update(options)
+  def images_upload_tag(assetable, method, options = {})
+    papermill_upload_tag method, { :assetable => assetable }.update(options)
   end
   
-  def image_upload_tag(assetable, key = nil, options = {})
-    papermill_upload_tag key, { :gallery => false, :assetable => assetable }.update(options)
+  def image_upload_tag(assetable, method, options = {})
+    papermill_upload_tag method, { :gallery => false, :assetable => assetable }.update(options)
   end
   
   private
   
-  def papermill_upload_tag(key, options)
+  def papermill_upload_tag(method, options)
+    assetable = options[:object] || options[:assetable] || @object || @template.instance_variable_get("@#{@object_name}")
     
-    if key.nil? && [String, Symbol].include?(options[:assetable].class)
-      key = options[:assetable].to_s
-      options[:assetable] = nil
-    end
-
-    assetable = @object || options[:object] || options[:assetable] || @template.instance_variable_get("@#{@object_name}")
-    
-    raise PapermillException.new("Your form instance object is not @#{@object_name}, and therefor cannot be found. \nPlease provide your object name in your form_for initialization. \nform_for :my_object_name, @my_object_name, :url => { :action => 'create'/'update'}") if @object_name && !assetable
+    raise PapermillException.new("Form object not found. Please provide it with :object => @assetable with the Papermill helper call") unless assetable
+    assetable_name = @object_name && "#{@object_name}#{(i = @options[:index]) ? "[#{i}]" : ""}"
     
-    assetable_id = assetable && (assetable.id || assetable.timestamp) || nil
-    assetable_type = assetable && assetable.class.base_class.name || nil
-    
-    options = PapermillAsset.papermill_options(assetable && assetable.class.name, key).deep_merge(options)
-    
-    dom_id = "papermill_#{assetable_type}_#{assetable_id}_#{key}"
+    sanitized_method = method.to_s.gsub(/[\?\/\-]$/, '')
+    sanitized_object_name = @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+    field_id = @object_name && "#{sanitized_object_name}#{(i = @options[:index]) ? "_#{i}" : ""}_#{sanitized_method}"
+    assetable.class.papermill(method)
+    association_options = assetable.class.papermill_options[method.to_sym]
+
+    raise PapermillException.new("Papermill association #{method} failed to be generated dynamically for #{assetable.class.name}") unless association_options
+    options = association_options.deep_merge(options)
+    field_name = "#{assetable_name}[papermill_#{method}_ids][]"
     
     if ot = options[:thumbnail]
       w = ot[:width]  || ot[:height] && ot[:aspect_ratio] && (ot[:height] * ot[:aspect_ratio]).to_i || nil
-      h = ot[:height] || ot[:width]  && ot[:aspect_ratio] && (ot[:width]  / ot[:aspect_ratio]).to_i || nil
-      
+      h = ot[:height] || ot[:width]  && ot[:aspect_ratio] && (ot[:width] / ot[:aspect_ratio]).to_i || nil
       computed_style = ot[:style] || (w || h) && "#{w}x#{h}>" || "original"
-      set_papermill_inline_css(dom_id, w, h, options)
+      set_papermill_inline_css(field_id, w, h, options)
     end
 
-    set_papermill_inline_js(dom_id, compute_papermill_create_url(assetable_id, assetable_type, key, computed_style, options), options)
+    set_papermill_inline_js(field_id, compute_papermill_url(:create, computed_style, field_name, field_id, options), options)
 
     html = {}
-    html[:upload_button] = %{<div id="#{dom_id}-button-wrapper" class="papermill-button-wrapper" style="height: #{options[:swfupload][:button_height]}px;"><span id="browse_for_#{dom_id}" class="swf_button"></span></div>}
-    html[:container] = @template.content_tag(:div, :id => dom_id, :class => "papermill-#{key.to_s} #{(options[:thumbnail] ? "papermill-thumb-container" : "papermill-asset-container")} #{(options[:gallery] ? "papermill-multiple-items" : "papermill-unique-item")}") do
-      conditions = {:assetable_type => assetable_type, :assetable_id => assetable_id}
-      conditions.merge!({:assetable_key => key.to_s}) if key
-      @template.render :partial => "papermill/asset", :collection => PapermillAsset.all(:conditions => conditions), :locals => { :thumbnail_style => computed_style, :targetted_size => options[:targetted_size] }
-    end
+    html[:upload_button] = %{\
+      <div id="#{field_id}-button-wrapper" class="papermill-button-wrapper" style="height: #{options[:swfupload][:button_height]}px;">
+        <span id="browse_for_#{field_id}" class="swf_button"></span>
+      </div>}
     
-    if options[:gallery]
-      html[:dashboard] = {}
-      html[:dashboard][:mass_edit] = %{<a onclick="Papermill.modify_all('#{dom_id}'); return false;" style="cursor:pointer">#{I18n.t("papermill.modify-all")}</a><select id="batch_#{dom_id}">#{options[:mass_editable_fields].map do |field|
-                %{<option value="#{field.to_s}">#{I18n.t("papermill.#{field.to_s}", :default => field.to_s)}</option>}
-              end.join("\n")}</select>}
-      html[:dashboard][:mass_delete] = %{<a onclick="Papermill.mass_delete('#{dom_id}', '#{@template.escape_javascript I18n.t("papermill.delete-all-confirmation")}'); return false;" style="cursor:pointer">#{I18n.t("papermill.delete-all")}</a>}
-      html[:dashboard][:mass_thumbnail_reset] = %{<a onclick="Papermill.mass_thumbnail_reset('#{dom_id}', '#{@template.escape_javascript I18n.t("papermill.mass-thumbnail-reset-confirmation")}'); return false;" style="cursor:pointer">#{I18n.t("papermill.mass-thumbnail-reset")}</a>}
-      html[:dashboard] = @template.content_tag(:ul, options[:dashboard].map{|action| @template.content_tag(:li, html[:dashboard][action], :class => action.to_s) }.join("\n"), :class => "dashboard")
+    # I don't use the full :through association that is not updated if assetable.new_record?.
+    collection = association_options[:through] ? assetable.send("#{method}_associations").map(&:papermill_asset) : assetable.send(method)
+    locals = { :thumbnail_style => computed_style, :targetted_size => options[:targetted_size], :field_name => field_name, :field_id => field_id }
+    html[:container] = @template.content_tag(:div, :id => field_id, :class => "papermill-#{method.to_s} #{(options[:thumbnail] ? "papermill-thumb-container" : "papermill-asset-container")} #{(options[:gallery] ? "papermill-multiple-items" : "papermill-unique-item")}") do
+      @template.render(:partial => "papermill/asset", 
+        :collection => collection,
+        :locals => locals)
     end
-      
-    if assetable && assetable.new_record? && !@timestamped
-      @timestamp_field = @template.hidden_field(@object_name && "#{@object_name}#{(i = @options[:index]) ? "[#{i}]" : ""}" || assetable_type.underscore, :timestamp, :value => assetable.timestamp)
-      @timestamped = true
+    
+    if options[:gallery] && options[:mass_edit]
+      html[:mass_edit] = %{\
+        <a onclick="Papermill.modify_all('#{field_id}'); return false;" style="cursor:pointer">#{I18n.t("papermill.modify-all")}</a>
+        <select id="batch_#{field_id}">#{options[:mass_editable_fields].map do |field|
+          %{<option value="#{field.to_s}">#{I18n.t("papermill.#{field.to_s}", :default => field.to_s)}</option>}
+        end.join("\n")}</select>}
     end
     
-	  %{<div class="papermill">#{@timestamp_field.to_s + options[:form_helper_elements].map{|element| html[element] || ""}.join("\n")}</div>}
+    if options[:through]
+      browser_url = compute_papermill_url(:browser, computed_style, field_name, field_id, options)
+      html[:browser] = %{<a onclick="popup('#{@template.escape_javascript(browser_url)}&list_id=#{field_id}&' + jQuery('##{field_id}').sortable('serialize')); return false;" style="cursor:pointer">Ajouter...</a>}
+    end
+
+    # hidden_field needed to empty a list.
+	  %{<div class="papermill">
+	    #{@template.hidden_field("#{assetable_name}[papermill_#{method}_ids]", nil)}
+	    #{options[:form_helper_elements].map{|element| html[element] || ""}.join("\n")}
+	  </div>}
   end
   
   
-  def compute_papermill_create_url(assetable_id, assetable_type, key, computed_style, options)
-    create_url_options = { 
-      :escape => false, :controller => "/papermill", :action => "create", 
+  def compute_papermill_url(action, computed_style, field_name, field_id, options)
+     @template.url_for({ 
+      :escape => false, :controller => "/papermill", :action => action, 
       :asset_class => (options[:class_name] || PapermillAsset).to_s,
-      :gallery => !!options[:gallery], :thumbnail_style => computed_style, :targetted_size => options[:targetted_size]
-    }
-    create_url_options.merge!({ :assetable_id => assetable_id, :assetable_type => assetable_type }) if assetable_id
-    create_url_options.merge!({ :assetable_key => key }) if key
-    @template.url_for(create_url_options)
+      :gallery => !!options[:gallery], :thumbnail_style => computed_style, :targetted_size => options[:targetted_size],
+      :field_name => field_name, :field_id => field_id
+    })
   end
   
-  def set_papermill_inline_js(dom_id, create_url, options)
+  def set_papermill_inline_js(field_id, create_url, options)
     return unless options[:inline_css]
     @template.content_for :papermill_inline_js do
-      %{
-        jQuery("##{dom_id}").sortable({
-          update:function(){
-            jQuery.ajax({
-              async: true, 
-              data: jQuery(this).sortable('serialize'), 
-              dataType: 'script', 
-              type: 'post', 
-              url: '#{@template.controller.send("sort_papermill_path")}'
-            })
-          }
-        })
-      } if options[:gallery]
+      %{ jQuery("##{field_id}").sortable() } if options[:gallery]
     end
     @template.content_for :papermill_inline_js do
       %{
         new SWFUpload({
-          post_params: {
+          post_params: { 
             "#{ ActionController::Base.session_options[:key] }": "#{ @template.cookies[ActionController::Base.session_options[:key]] }"
           },
-          upload_id: "#{ dom_id }",
+          upload_id: "#{ field_id }",
           upload_url: "#{ @template.escape_javascript create_url }",
           file_types: "#{ options[:images_only] ? '*.jpg;*.jpeg;*.png;*.gif' : '' }",
           file_queue_limit: "#{ !options[:gallery] ? '1' : '0' }",
@@ -136,26 +128,26 @@ module ActionView::Helpers::FormTagHelper
           upload_error_handler: Papermill.upload_error,
           upload_success_handler: Papermill.upload_success,
           upload_complete_handler: Papermill.upload_complete,
-          button_placeholder_id: "browse_for_#{dom_id}",
+          button_placeholder_id: "browse_for_#{field_id}",
           #{ options[:swfupload].map { |key, value| "#{key}: #{value}" if value }.compact.join(",\n") }
         });
       }
     end
   end
   
-  def set_papermill_inline_css(dom_id, width, height, options)
+  def set_papermill_inline_css(field_id, width, height, options)
     html = ["\n"]
     size = [width && "width:#{width}px", height && "height:#{height}px"].compact.join("; ")
     if og = options[:gallery]
       vp, hp, vm, hm, b = [og[:vpadding], og[:hpadding], og[:vmargin], og[:hmargin], og[:border_thickness]].map &:to_i
       gallery_width = (og[:width] || width) && "width:#{og[:width] || og[:columns]*(width.to_i+(hp+hm+b)*2)}px;" || ""
       gallery_height = (og[:height] || height) && "min-height:#{og[:height] || og[:lines]*(height.to_i+(vp+vm+b)*2)}px;" || ""
-      html << %{##{dom_id} { #{gallery_width} #{gallery_height} }}
-      html << %{##{dom_id} .asset { margin:#{vm}px #{hm}px; border-width:#{b}px; padding:#{vp}px #{hp}px; #{size}; }}
+      html << %{##{field_id} { #{gallery_width} #{gallery_height} }}
+      html << %{##{field_id} .asset { margin:#{vm}px #{hm}px; border-width:#{b}px; padding:#{vp}px #{hp}px; #{size}; }}
     else
-      html << %{##{dom_id}, ##{dom_id} .asset { #{size} }}
+      html << %{##{field_id}, ##{field_id} .asset { #{size} }}
     end
-    html << %{##{dom_id} .name { width:#{width || "100"}px; }}
+    html << %{##{field_id} .name { width:#{width || "100"}px; }}
     @template.content_for :papermill_inline_css do
       html.join("\n")
     end

data/lib/papermill/papermill.rb

@@ -1,15 +1,10 @@
 module Papermill
-  
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
+  MSWIN = (Config::CONFIG['host_os'] =~ /mswin|mingw/)
   
   def self.options
     @options ||= BASE_OPTIONS.deep_merge(defined?(OPTIONS) ? OPTIONS : {})
   end
   
-  MSWIN = (Config::CONFIG['host_os'] =~ /mswin|mingw/)
-  
   def self.compute_paperclip_path
     path = []
     path << (options[:use_id_partition] ? ":id_partition" : ":id")
@@ -19,52 +14,69 @@ module Papermill
     path.compact.join("/")
   end
 
-  module ClassMethods
-    attr_reader :papermill_associations
-    
-    def papermill(*args)
-      assoc_name = (!args.first.is_a?(Hash) && args.shift || Papermill::options[:base_association_name]).to_sym
-      local_options = args.first || {}
-
-      (@papermill_associations ||= {}).merge!( assoc_name => Papermill::options.deep_merge(local_options) )
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      def papermill(key, through = ((po = self.class.papermill_options) && (po[key.to_sym] || po[:default]) || Papermill::options)[:through])
+        PapermillAsset.papermill(self.class.base_class.name, self.id, key.to_s, through)
+      end
       
-      include Papermill::InstanceMethods
-      after_create :rebase_assets
-      has_many :papermill_assets, :as => "assetable", :dependent => :destroy
-
-      [assoc_name, Papermill::options[:base_association_name].to_sym].uniq.each do |assoc|
-        define_method assoc do |*options|
-          scope = PapermillAsset.scoped(:conditions => {:assetable_id => self.id, :assetable_type => self.class.base_class.name})
-          if assoc != Papermill::options[:base_association_name]
-            scope = scope.scoped(:conditions => { :assetable_key => assoc.to_s })
-          elsif options.first && !options.first.is_a?(Hash)
-            scope = scope.scoped(:conditions => { :assetable_key => options.shift.to_s.nie })
-          end
-          scope = scope.scoped(options.shift) if options.first
-          scope
+      def respond_to_with_papermill?(method, *args, &block)
+        respond_to_without_papermill?(method, *args, &block) || (method.to_s =~ /^papermill_.+_ids=$/) == 0
+      end
+      
+      def method_missing_with_papermill(method, *args, &block)
+        if method.to_s =~ /^papermill_.+_ids=$/
+          self.class.papermill(method.to_s[10..-6])
+          self.send(method, *args, &block)
+        else
+          method_missing_without_papermill(method, *args, &block)
         end
       end
-      ActionController::Dispatcher.middleware.delete(FlashSessionCookieMiddleware) rescue true
-      ActionController::Dispatcher.middleware.insert_before(ActionController::Base.session_store, FlashSessionCookieMiddleware, ActionController::Base.session_options[:key]) rescue true
     end
+    base.send :alias_method_chain, :method_missing, :papermill
+    base.send :alias_method_chain, :respond_to?, :papermill
+    ActionController::Dispatcher.middleware.insert_before(ActionController::Base.session_store, FlashSessionCookieMiddleware, ActionController::Base.session_options[:key]) unless ActionController::Dispatcher.middleware.include?(FlashSessionCookieMiddleware)
+  end
+  
+  module ClassMethods
+    attr_reader :papermill_options
     
     def inherited(subclass)
-      subclass.instance_variable_set("@papermill_associations", @papermill_associations)
+      subclass.instance_variable_set("@papermill_options", @papermill_options)
       super
     end
-  end
-
-  module InstanceMethods
-    attr_writer :timestamp
-    def timestamp
-      @timestamp ||= "-#{(Time.now.to_f * 1000).to_i.to_s[4..-1]}"
-    end
     
-    private
-    
-    def rebase_assets
-      PapermillAsset.all(:conditions => { :assetable_id => self.timestamp, :assetable_type => self.class.base_class.name }).each do |asset|
-        asset.created_at < 2.hours.ago ? asset.destroy : asset.update_attribute(:assetable_id, self.id)
+    def papermill(assoc_key, assoc_options = (@papermill_options && @papermill_options[:default] || {}))
+      return if @papermill_options && @papermill_options[assoc_key.to_sym] # already defined
+      raise PapermillException.new("Can't use '#{assoc_key}' association : #{self.name} instances already responds to it !") if self.new.respond_to?(assoc_key)
+      (@papermill_options ||= {}).merge!( { assoc_key.to_sym => Papermill::options.deep_merge(assoc_options) } )
+      return if assoc_key.to_sym == :default
+      unless papermill_options[assoc_key.to_sym][:through]
+        self.class_eval %{ 
+          has_many :#{assoc_key}, :as => "assetable", :dependent => :delete_all, :order => :position, :class_name => "PapermillAsset", :conditions => {:assetable_key => '#{assoc_key}'}, :before_add => Proc.new{|a, asset| asset.assetable_key = '#{assoc_key}'}
+          def papermill_#{assoc_key}_ids=(ids)
+            unless (assets_ids = ids.map(&:to_i).select{|i|i>0}) == self.#{assoc_key}.map(&:id)
+              assets = PapermillAsset.find(assets_ids)
+              self.#{assoc_key} = assets_ids.map{|asset_id| assets.select{|asset|asset.id==asset_id}.first}
+              PapermillAsset.update_all("position = CASE id " + assets_ids.map_with_index{|asset_id, index| " WHEN " + asset_id.to_s + " THEN " + (index+1).to_s }.join + " END",
+                  :id => assets_ids) unless assets_ids.empty?
+            end
+          end
+        }
+      else
+        self.class_eval %{ 
+          has_many(:#{assoc_key}_associations, :as => "assetable", :class_name => "PapermillAssociation", :include => :papermill_asset, :dependent => :delete_all, :order => :position, :conditions => {:assetable_key => '#{assoc_key}'}, :before_add => Proc.new{|a, assoc| assoc.assetable_key = '#{assoc_key}'})
+          has_many(:#{assoc_key}, :through => :#{assoc_key}_associations, :source => :papermill_asset)
+          def papermill_#{assoc_key}_ids=(ids)
+            unless (assets_ids = ids.map(&:to_i).select{|i|i>0}) == self.#{assoc_key}_associations.map(&:papermill_asset_id)
+              self.#{assoc_key}_associations.delete_all
+              self.#{assoc_key}_associations = assets_ids.map_with_index do |asset_id, index|
+                PapermillAssociation.new(:papermill_asset_id => asset_id, :position => (index+1))
+              end
+            end
+          end
+        }
       end
     end
   end

data/lib/papermill/papermill_asset.rb

@@ -1,8 +1,6 @@
 class PapermillAsset < ActiveRecord::Base
-  
   before_destroy :destroy_files
-  before_create :set_position
-  
+
   has_attached_file :file, 
     :processors => [:papermill_paperclip_processor],
     :url => "#{Papermill::options[:papermill_url_prefix]}/#{Papermill::compute_paperclip_path.gsub(':style', ':escape_style_in_url')}",
@@ -12,10 +10,26 @@ class PapermillAsset < ActiveRecord::Base
   
   validates_attachment_presence :file
   
-  belongs_to :assetable, :polymorphic => true, :touch => Papermill::options[:touch]
-  default_scope :order => 'position'
-  
-  named_scope :key, lambda { |assetable_key| { :conditions => ['assetable_key = ?', assetable_key.to_s] }}
+  belongs_to :assetable, :polymorphic => true
+  has_many :papermill_associations, :dependent => :delete_all
+  
+  named_scope :papermill, lambda { |assetable_type, assetable_id, assetable_key, through|
+    through ? 
+    { :joins => "INNER JOIN papermill_associations ON papermill_assets.id = papermill_associations.papermill_asset_id \
+                  AND papermill_associations.assetable_type = #{connection.quote assetable_type} \
+                  AND papermill_associations.assetable_id = #{assetable_id.to_i} \
+                  AND papermill_associations.assetable_key = #{connection.quote assetable_key}",
+      :order => "papermill_associations.position" } : 
+    { :conditions => { 
+        :assetable_type => assetable_type, 
+        :assetable_id => assetable_id, 
+        :assetable_key => assetable_key.to_s }, 
+      :order => "papermill_assets.position" }
+  }
+
+  def assetable_type=(sType)
+     super(sType.to_s.classify.constantize.base_class.to_s)
+  end
   
   Paperclip.interpolates :url_key do |attachment, style|
     attachment.instance.compute_url_key((style || "original").to_s)
@@ -103,10 +117,10 @@ class PapermillAsset < ActiveRecord::Base
     style.is_a?(Hash) ? (style[:name] || style.hash).to_s : (style || "original").to_s
   end
   
-  def self.papermill_options(assetable_class, assetable_key)
-    if assetable_class
-      assoc = assetable_class.constantize.papermill_associations
-      assoc[assetable_key.try(:to_sym)] || assoc[Papermill::options[:base_association_name]]
+  def self.papermill_options(assetable_type, assetable_key)
+    if assetable_type
+      assoc = assetable_type.constantize.papermill_options
+      assoc[assetable_key.try(:to_sym)] || assoc[:default] || Papermill::options
     else
       Papermill::options
     end
@@ -121,12 +135,14 @@ class PapermillAsset < ActiveRecord::Base
   end
   
   def create_thumb_file(style_name, style = nil)
+    return false unless self.image?
     destroy_thumbnails if style_name.to_s == "original"
     style = self.class.compute_style(style_name) unless style.is_a?(Hash)
     FileUtils.mkdir_p File.dirname(new_path = file.path(style_name))
     FileUtils.cp((tmp_path = Paperclip::PapermillPaperclipProcessor.make(file, style).path), new_path)
     FileUtils.chmod(0644, new_path) unless Papermill::MSWIN
     File.delete(tmp_path)
+    return true
   end
   
   def destroy_thumbnails
@@ -141,7 +157,9 @@ class PapermillAsset < ActiveRecord::Base
   end
   
   def self.destroy_orphans
-    self.all(:conditions => ["id < 0 AND created_at < ?", DateTime.now.yesterday]).each &:destroy
+    self.name != self.base_class.name ? 
+    PapermillAsset.delete_all(["created_at < ? AND assetable_id IS NULL AND type = ?", 1.hour.ago, self.name]) :
+    PapermillAsset.delete_all(["created_at < ? AND assetable_id IS NULL AND type IS NULL", 1.hour.ago])
   end
   
   def compute_url_key(style)
@@ -153,7 +171,7 @@ class PapermillAsset < ActiveRecord::Base
   end
   
   private
-    
+  
   def root_directory
     deepness_to_root = Papermill::options[:use_url_key] ? -3 : -2
     @root_directory ||= File.dirname(path).split('/')[0..deepness_to_root].join('/')
@@ -165,10 +183,6 @@ class PapermillAsset < ActiveRecord::Base
     self.file.instance_write(:file_name, "#{basename.to_url}#{extension}")
   end
   
-  def set_position
-    self.position ||= PapermillAsset.maximum(:position, :conditions => { :assetable_type => assetable_type, :assetable_id => assetable_id, :assetable_key => assetable_key } ).to_i + 1
-  end
-  
   def destroy_files
     FileUtils.rm_r(root_directory) rescue true
   end

data/lib/papermill/papermill_association.rb

@@ -0,0 +1,8 @@
+class PapermillAssociation < ActiveRecord::Base
+  belongs_to :papermill_asset
+  belongs_to :assetable, :polymorphic => true
+  
+  def assetable_type=(sType)
+     super(sType.to_s.classify.constantize.base_class.to_s)
+  end
+end

data/lib/papermill/papermill_options.rb

@@ -1,10 +1,11 @@
 module Papermill
   BASE_OPTIONS = {
     :class_name => "PapermillAsset",
+    :through => false,
     :inline_css => true,
     :images_only => false,
-    :form_helper_elements => [:upload_button, :container, :dashboard],
-    :dashboard => [:mass_edit, :mass_delete],
+    :form_helper_elements => [:upload_button, :container, :browser, :mass_edit],
+    :mass_edit => true,
     :mass_editable_fields => ["title", "copyright", "description"],
     :editable_fields => [
       {:title =>       {:type => "string"}}, 
@@ -48,8 +49,6 @@ module Papermill
     :copyright_im_command => %{\\( -font Arial-Bold -pointsize 9 -fill '#FFFFFFE0' -border 3 -bordercolor '#50550080' -background '#00000000' label:' %s ' \\) -gravity South-West -geometry +0+0 -composite},
     :watermark => "/images/rails.png",
     :watermark_im_command => %{- | composite \\( %s -resize 100% \\) - -dissolve 20% -gravity center -geometry +0+0 },
-    :base_association_name => :assets,
-    :touch => false,
     :alias_only => false,
     :aliases => {},
     :use_url_key => false,
@@ -57,9 +56,6 @@ module Papermill
     :url_key_generator => Proc.new { |style, asset| Digest::SHA512.hexdigest("#{style}#{asset.id}#{Papermill::options[:url_key_salt]}")[0..10] },
     :use_id_partition => true,
     :papermill_url_prefix => "/system/papermill",
-    :papermill_path_prefix => ":rails_root/public/system/papermill",
-    :authorize_create => "true", 
-    :authorize_update_and_destroy => "true", 
-    :authorize_multiple_modification => "true",
+    :papermill_path_prefix => ":rails_root/public/system/papermill"
   }
 end

data/lib/papermill.rb

@@ -1,4 +1,5 @@
 require "rbconfig"
+require "acts_as_list"
 begin
   require "mime/types"
   MIME_TYPE_LOADED = true
@@ -12,6 +13,7 @@ require 'papermill/flash_session_cookie_middleware.rb'
 
 Object.send :include, PapermillObjectExtensions
 Hash.send :include, PapermillHashExtensions
+Array.send :include, PapermillArrayExtensions
 String.send :include, StringToUrlNotFound unless String.instance_methods.include? "to_url"
 Formtastic::SemanticFormBuilder.send(:include, PapermillFormtasticExtensions) rescue NameError
 
@@ -23,6 +25,7 @@ end
 require 'paperclip' unless defined?(Paperclip)
 require 'papermill/papermill_paperclip_processor'
 require 'papermill/papermill'
+require 'papermill/papermill_association'
 require 'papermill/papermill_asset'
 require 'papermill/form_builder'
 require 'papermill/papermill_helper'

data/public/papermill/papermill.css

@@ -23,8 +23,6 @@
 
 .papermill .dashboard li a { display:inline; padding-left:20px }
 .papermill .dashboard li.mass_edit a { background:transparent url(/papermill/images/mass-edit.png) no-repeat top left; }
-.papermill .dashboard li.mass_delete a { background:transparent url(/papermill/images/mass-delete.png) no-repeat top left; }
-.papermill .dashboard li.mass_thumbnail_reset a { background:transparent url(/papermill/images/mass-thumbnail-reset.png) no-repeat top left; }
 
 .papermill-thumb-container { position:relative; border:5px solid #EEE; padding:4px; overflow:hidden; }	
 .papermill-thumb-container .asset { border:0px solid transparent; min-height:25px; min-width:25px; display:block; float:left; position:relative; }

data/public/papermill/papermill.js

@@ -6,14 +6,15 @@ If you have your own popup solution, override popup and close_popup in your appl
 popup = function(url) {
 	jQuery.facebox(function() {
 	  jQuery.get(url, function(data) {
-	    jQuery.facebox(data)
+	    jQuery.facebox(data);
 	  })
 	})
 	return false;
-}
+};
+
 close_popup = function(source) {
 	jQuery(document).trigger('close.facebox');
-}
+};
 
 jQuery(document).ajaxError(function(){
 	switch (arguments[1].status) {
@@ -37,10 +38,11 @@ If you have your own notification solution, override notify
 */
 
 notify = function(title, message, type) {
-	if(type == "notice") { jQuery.jGrowl(message, { header: title, life: 4000, theme: type }) }
-	if(type == "warning") {	jQuery.jGrowl(message, { header: title, life: 15000, theme: type }) }
-	if(type == "error") {	jQuery.jGrowl(message, { header: title, sticky: true, theme: type }) }
-}
+	if(type == "notice") { jQuery.jGrowl(message, { header: title, life: 4000, theme: type }) };
+	if(type == "warning") {	jQuery.jGrowl(message, { header: title, life: 15000, theme: type }) };
+	if(type == "error") {	jQuery.jGrowl(message, { header: title, sticky: true, theme: type }) };
+};
+
 var Papermill = {
 	files_queued: 0,
 	file_dialog_complete: function(num_selected, num_queued)
@@ -62,7 +64,7 @@ var Papermill = {
 			} while (file != null);
 			this.sorted_queue = file_queue.sort(function(a,b){
 				if(b.name < a.name) { return (1) } else { return (-1) }
-			})
+			});
 			var self = this;
 			jQuery(this.sorted_queue).each( function(index, file) {
 				div = jQuery('<div></div>').attr({ 'id': file.id, 'class': 'swfupload asset' });
@@ -76,7 +78,7 @@ var Papermill = {
 					}
 				}
 				jQuery("#" + self.settings.upload_id).append(div);
-			})
+			});
 			this.startUpload(this.sorted_queue[this.index++].id);
 		}
 	},
@@ -84,6 +86,12 @@ var Papermill = {
 	{
 		jQuery('#' + file.id + ' .status').html(SWFUPLOAD_LOADING);
 		this.addFileParam(file.id, "Fileid", file.id);
+		if(this.settings.file_queue_limit == 1) {
+			old_asset = jQuery("#" + this.settings.upload_id).children()[0];
+			if (old_asset && old_asset.id != file.id) {
+				this.addFileParam(file.id, "Oldfileid", old_asset.id);
+			}
+		}
 	},
 	upload_progress: function(file, bytes, total)
 	{
@@ -107,7 +115,7 @@ var Papermill = {
 	{
 		Papermill.files_queued -= 1;
 		if(this.sorted_queue[this.index]) { 
-			this.startUpload(this.sorted_queue[this.index++].id)
+			this.startUpload(this.sorted_queue[this.index++].id);
 		}
 	},
 	file_queue_error: function(file, errorCode, message)  {
@@ -127,23 +135,12 @@ var Papermill = {
 	},
 	modify_all: function(papermill_id) {
 		container = jQuery("#" + papermill_id)[0];
-		attribute_name = jQuery("#batch_" + papermill_id)[0].value
+		attribute_name = jQuery("#batch_" + papermill_id)[0].value;
 		attribute_wording = jQuery("#batch_" + papermill_id + " option:selected").text();
-		value = prompt(attribute_wording + ":")
+		value = prompt(attribute_wording + ":");
 		if(value != null) {
-			jQuery.ajax({async:true, data:jQuery(container).sortable('serialize'), dataType:'script', type:'post', url:'/papermill/mass_edit?attribute=' + attribute_name + "&value=" + value})
+			jQuery.ajax({async:true, data:jQuery(container).sortable('serialize') + "&list_id=" + container.id, dataType:'script', type:'post', url:'/papermill/mass_edit?attribute=' + attribute_name + "&value=" + value});
 		}
-	},
-	mass_delete: function(papermill_id, wording) {
-		if(confirm(wording)){ 
-	    jQuery.ajax({async:true, data:jQuery('#' + papermill_id).sortable('serialize'), dataType:'script', type:'post', url:'/papermill/mass_delete'})
-	  }
-	},
-	
-	mass_thumbnail_reset: function(papermill_id, wording) {
-		if(confirm(wording)){ 
-	    jQuery.ajax({async:true, data:jQuery('#' + papermill_id).sortable('serialize'), dataType:'script', type:'post', url:'/papermill/mass_thumbnail_reset'})
-	  }
 	}
-}
+};