BBenezech-papermill 0.3.0 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/app/controllers/papermill_controller.rb

@@ -59,15 +59,18 @@ class PapermillController < ApplicationController
   end
   
   def create
-    params[:assetable_type] = params[:assetable_type].camelize
-    asset_class = params[:assetable_type].constantize.papermill_associations[params[:association].to_sym][:class]
+    params[:assetable_id] = params[:assetable_id].nie
+    asset_class = params[:asset_class].constantize
+    params[:assetable_type] = params[:assetable_type] && params[:assetable_type].to_s.camelize.nie
     params[:swfupload_file] = params.delete(:Filedata)
-    @old_asset = asset_class.find(:first, :conditions => {:assetable_key => params[:assetable_key].to_s, :assetable_type => params[:assetable_type], :assetable_id => params[:assetable_id]}) unless params[:gallery]
+    unless params[:gallery]
+      @old_asset = asset_class.find(:first, :conditions => {:assetable_key => params[:assetable_key], :assetable_type => params[:assetable_type], :assetable_id => params[:assetable_id]})
+    end
     @asset = asset_class.new(params.reject{|key, value| !(PapermillAsset.columns.map(&:name)+["swfupload_file"]).include?(key.to_s)})
     
     if @asset.save
       @old_asset.destroy if @old_asset
-      render :partial => "papermill/asset", :object => @asset, :locals => {:thumbnail => params[:thumbnail], :gallery => params[:gallery], :thumbnail_style => params[:thumbnail_style]}
+      render :partial => "papermill/asset", :object => @asset, :locals => {:gallery => params[:gallery], :thumbnail_style => params[:thumbnail_style]}
     else
       message = t("not-created", :scope => "papermill")
       render :text => message, :status => "500"

data/lib/papermill/form_builder.rb

@@ -1,28 +1,34 @@
 class ActionView::Helpers::FormBuilder
   
-  def assets_upload(key = nil, method = nil, options = {})
-    papermill_upload_field key, method, { :thumbnail => false }.update(options)
+  def assets_upload(key = nil, options = {})
+    papermill_upload_field key, { :thumbnail => false }.update(options)
   end
-  def asset_upload(key = nil, method = nil, options = {})
-    papermill_upload_field key, method, { :gallery => false, :thumbnail => false }.update(options)
+  def asset_upload(key = nil, options = {})
+    papermill_upload_field key, { :gallery => false, :thumbnail => false }.update(options)
   end
-  def images_upload(key = nil, method = nil, options = {})
-    papermill_upload_field key, method, options
+  def images_upload(key = nil, options = {})
+    papermill_upload_field key, options
   end
-  def image_upload(key = nil, method = nil, options = {})
-    papermill_upload_field key, method, { :gallery => false }.update(options)
+  def image_upload(key = nil, options = {})
+    papermill_upload_field key, { :gallery => false }.update(options)
   end
 
   private
-  def papermill_upload_field(key, method, options = {})
+  def papermill_upload_field(key, options = {})
+    if key.is_a? Hash
+      options = key
+      key = nil
+    end
     assetable = @template.instance_variable_get("@#{@object_name}")
-    method ||= options[:association] || :papermill_assets
-    key ||= options[:key] || nil
-    options = assetable.class.papermill_options.deep_merge(options)
-    assetable_id = assetable.id || assetable.timestamp
-    assetable_type = assetable.class.to_s.underscore
-    id = "papermill_#{assetable_type}_#{assetable_id}_#{key}_#{method}"
-    if options[:thumbnail] 
+    options = if assetable && (association = (assetable.class.papermill_associations[key] || assetable.class.papermill_associations[:papermill_assets]))
+      association[:options].deep_merge(options)
+    else
+      raise Exception.new("Papermill: can't find #{key.to_s} association for #{assetable.class.to_s}.\n\n##{assetable.class.to_s.underscore}.rb\n#set either a catchall papermill association: \npapermill {your_option_hash}\n#or this specific association: \npapermill :#{key.to_s}, {your_option_hash}")
+    end
+    assetable_id = assetable && (assetable.id || assetable.timestamp) || nil
+    assetable_type = assetable && assetable.class.to_s.underscore || nil
+    id = "papermill_#{assetable_type}_#{assetable_id}_#{key ? key.to_s : 'nil'}"
+    if options[:thumbnail]
       w = options[:thumbnail][:width]  || options[:thumbnail][:height] && options[:thumbnail][:aspect_ratio] && (options[:thumbnail][:height] * options[:thumbnail][:aspect_ratio]).to_i || nil
       h = options[:thumbnail][:height] || options[:thumbnail][:width]  && options[:thumbnail][:aspect_ratio] && (options[:thumbnail][:width]  / options[:thumbnail][:aspect_ratio]).to_i || nil
       options[:thumbnail][:style] ||= (w || h) && "#{w || options[:thumbnail][:max_width]}x#{h || options[:thumbnail][:max_height]}>" || "original"
@@ -51,17 +57,21 @@ class ActionView::Helpers::FormBuilder
         end
       end
     end
-    create_url = @template.url_for(:controller => "/papermill", :action => "create", :escape => false, :association => method.to_s, :assetable_key => key, :assetable_id => assetable_id, :assetable_type => assetable_type, :gallery => (options[:gallery] != false), :thumbnail_style => (options[:thumbnail] && options[:thumbnail][:style]))
     html = []
-    if assetable.new_record? && !@timestamped
+    
+    conditions = {:assetable_type => assetable.class.sti_name, :assetable_id => assetable_id}
+    conditions.merge!({:assetable_key => key.to_s}) if key
+    asset_class = options[:class_name] && options[:class_name].to_s.constantize || association && association[:class] || PapermillAsset
+    create_url = @template.url_for(:controller => "/papermill", :action => "create", :escape => false, :asset_class => asset_class.to_s, :assetable_key => key, :assetable_id => assetable_id, :assetable_type => assetable_type, :gallery => (options[:gallery] != false), :thumbnail_style => (options[:thumbnail] && options[:thumbnail][:style]))
+    if assetable && assetable.new_record? && !@timestamped
       html << self.hidden_field(:timestamp, :value => assetable.timestamp)
       @timestamped = true
     end
+    collection = asset_class.find(:all, :conditions => conditions, :order => "position")
+    
     html << %{<div style="height: #{options[:swfupload][:button_height]}px;"><span id="browse_for_#{id}" class="swf_button"></span></div>}
-    conditions = {:assetable_type => assetable.class.sti_name, :assetable_id => assetable_id}
-    conditions.merge!({:assetable_key => key.to_s}) if key
     html << @template.content_tag(:ul, :id => id, :class => "papermill #{(options[:thumbnail] ? "papermill-thumb-container" : "papermill-asset-container")} #{(options[:gallery] ? "papermill-multiple-items" : "papermill-unique-item")}") {
-      @template.render :partial => "papermill/asset", :collection => assetable.class.papermill_associations[method][:class].find(:all, :conditions => conditions, :order => "position"), :locals => { :thumbnail_style => (options[:thumbnail] && options[:thumbnail][:style]) }
+      @template.render :partial => "papermill/asset", :collection => collection, :locals => { :thumbnail_style => (options[:thumbnail] && options[:thumbnail][:style]) }
     }
     @template.content_for :inline_js do
       %{

data/lib/papermill/papermill_asset.rb

@@ -1,8 +1,5 @@
-require "acts_as_list"
-require "paperclip"
-
 class PapermillAsset < ActiveRecord::Base
-  acts_as_list :scope => 'assetable_key=\'#{assetable_key.simple_sql_sanitizer}\' AND assetable_id=#{assetable_id} AND assetable_type=\'#{assetable_type}\''
+  acts_as_list :scope => 'assetable_key=\'#{assetable_key.to_s.simple_sql_sanitizer}\' AND assetable_id=#{assetable_id} AND assetable_type=\'#{assetable_type}\''
   
   belongs_to :assetable, :polymorphic => true
   before_destroy :destroy_files
@@ -50,10 +47,6 @@ class PapermillAsset < ActiveRecord::Base
     content_type && content_type.first == "image" && content_type[1]
   end
   
-  def interpolated_path(with = {}, up_to = nil)
-    Papermill::papermill_interpolated_path({":id_partition" => self.id_partition}.merge(with), up_to)
-  end
-  
   # before_filter
   def destroy_files
     system "rm -rf #{Papermill::papermill_interpolated_path({":id_partition" => self.id_partition}, ':id_partition')}/" if image?

data/lib/papermill/papermill_helper.rb

@@ -1,5 +1,11 @@
 module PapermillHelper
   
+  # Sets all the javascript needed for papermill.
+  # If you already loaded jQuery and JQueryUI, call papermill_javascript_tag
+  # If you don't use jQuery or use some other library, call papermill_javascript_tag(:with_jquery => "no_conflict")
+  # If you want to rely on this helper to load jQuery/jQueryUI and use it, call papermill_javascript_tag(:with_jquery => true)
+  # If you loaded jQuery and need to load only jQueryUI, call papermill_javascript_tag(:with_jqueryui_only => true)
+  # If you changed the location of papermill.js, you'll need to set :root_folder (defaults to "javascripts")
   def papermill_javascript_tag(options = {})
     html = []
     root_folder = options[:path] || "javascripts"
@@ -7,7 +13,8 @@ module PapermillHelper
       html << %{<script src="http://www.google.com/jsapi"></script>}
       html << %{<script type="text/javascript">\n//<![CDATA[}
       html << %{google.load("jquery", "1");} if options[:with_jquery]
-      html << %{google.load("jqueryui", "1");} if options[:with_jquery] || options[:with_jqueryui]
+      html << %{google.load("jqueryui", "1");} if options[:with_jquery] || options[:with_jqueryui_only]
+      html << %{jQuery.noConflict();} if options[:with_jquery] == "no_conflict"
       html << %{</script>}
     end
     html << %{<script src="http://swfupload.googlecode.com/svn/swfupload/tags/swfupload_v2.2.0_core/swfupload.js"></script>}
@@ -23,6 +30,8 @@ module PapermillHelper
     html.join("\n")
   end
   
+  # Sets the css tags needed for papermill.
+  # If you changed the location of papermill.css, you'll need to set :root_folder (defaults to "stylesheets")
   def papermill_stylesheet_tag(options = {})
     html = []
     root_folder = options[:path] || "stylesheets"

data/lib/papermill/papermill_module.rb

@@ -84,53 +84,56 @@ module Papermill
   end
   
   module ClassMethods
-    attr_reader :papermill_options
     attr_reader :papermill_associations
     
-    # Dealing with STIed Asset table in papermill declaration is dead easy, since papermill follows ActiveRecord :has_many global syntax and the Convention over configuration concept :
-    # papermill <association_name>, :class_name => MySTIedPapermillAssetClassName
-    # class MyAsset < PapermillAsset
-    #   ...
-    # end
-    # class MyAssetableClass < ActiveRecord::Base
-    # 1 -> papermill :my_association, :class_name => MyAsset
-    # 2 -> papermill :class_name => MyAsset 
-    # 3 -> papermill :my_assets
-    # 4 -> papermill :my_other_assets
-    # 5 -> papermill
-    # end
-    # assetable = MyAssetableClass.new
-    # 1 -> assetable.my_association         attached MyAsset objects           (no magic here, association and class_name both specified)
-    # 2 -> assetable.my_assets              attached MyAsset objects           (association infered from :class_name as expected)
-    # 3 -> assetable.my_assets              attached MyAsset objects           (class_name guessed from association name)
-    # 4 -> assetable.my_other_assets        attached PapermillAssets objects   (couldn't find MyOtherAsset class or MyOtherAsset is not a PapermillAsset subclass, use default PapermillAsset superclass)
-    # 5 -> assetable.papermill_assets       attached PapermillAssets objects   (defaults)
+    # papermill comes in 2 flavors:
+    #
+    # 1. generic declaration =>
+    #   declare associations with =>  papermill {my_option_hash}
+    #   create assets with        =>  assets_upload(:my_key, {optional_option_hash})
+    #   access assets with        =>  assetable.papermill_assets(:key => :my_key)
+    #
+    # 2. association declaration =>
+    #   declare associations with =>  papermill :my_association, {my_option_hash}
+    #   create assets with        =>  assets_upload(my_association, {optional_option_hash})
+    #   access assets with        =>  assetable.my_association
+    #
+    # In both case, you can specify a PapermillAsset subclass to use with :class_name => MyPapermillAssetSubclass in the option hash
+    def papermill(assoc_name = :papermill_assets, options = {})
+      if assoc_name.is_a? Hash
+        options = assoc_name
+        assoc_name = :papermill_assets
+      end
       
-    def papermill(assoc = nil, options = {})
       @papermill_associations ||= {}
-      asset_class = ((klass = options.delete(:class_name)) && (klass = (klass.to_s.singularize.camelize.constantize rescue nil)) && klass.superclass == PapermillAsset && klass || assoc && (klass = (assoc.to_s.singularize.camelize.constantize rescue nil)) && klass.superclass == PapermillAsset && klass || PapermillAsset)
-      assoc ||= asset_class.to_s.pluralize.underscore.to_sym
+      begin
+        asset_class = (class_name = options.delete(:class_name)).to_s.constantize || PapermillAsset
+      rescue
+        raise Exception.new("Papermill: can't find class #{class_name.to_s}.\n#{class_name.to_s} should be a subclass of PapermillAsset")
+      end
+      assoc_name ||= asset_class.to_s.pluralize.underscore.to_sym
 
-      @papermill_associations.merge!({assoc => {:class => asset_class}})
-      @papermill_options = Papermill::PAPERMILL_DEFAULTS.deep_merge(options)
+      @papermill_associations.merge!({assoc_name => {:class => asset_class, :options => Papermill::PAPERMILL_DEFAULTS.deep_merge(options)}})
       before_destroy :destroy_assets
       after_create :rebase_assets
-      # reinventing the wheel because ActiveRecord chokes on :finder_sql with associations
-      # TODO Clean the mess
-      define_method assoc do |*options|
-        klass = self.class.papermill_associations[assoc.to_sym][:class]
+
+      define_method assoc_name do |*options|
+        klass = self.class.papermill_associations[assoc_name.to_sym][:class]
         options = options.first || {}
         conditions = {
           :assetable_type => self.class.sti_name,
-          :assetable_id => self.id,
+          :assetable_id => self.id
         }.merge(options.delete(:conditions) || {})
-        order = (options.delete(:order) || "position ASC")
-        conditions.merge!({:type => klass.to_s}) unless klass == PapermillAsset
-        conditions.merge!({:assetable_key => options[:key].to_s}) if options[:key]
+        conditions.merge!({:type => klass.to_s}) unless assoc_name == PapermillAsset
+        conditions.merge!({:assetable_key => assoc_name.to_s}) if assoc_name != :papermill_assets
+        conditions.merge!({:assetable_key => options.delete(:key)}) if options.has_key?(:key)
         conditions.merge!({:type => options[:class_name]}) if options[:class_name]
-        asset_class.find(:all, :conditions => conditions, :order => order)
+        hash = {
+          :conditions => conditions, 
+          :order => options.delete(:order) || "position ASC"
+        }.merge(options)
+        asset_class.find(:all, hash)
       end
-
       
       class_eval <<-EOV
         include Papermill::InstanceMethods
@@ -138,7 +141,6 @@ module Papermill
     end
     
     def inherited(subclass)
-      subclass.instance_variable_set("@papermill_options", @papermill_options)
       subclass.instance_variable_set("@papermill_associations", @papermill_associations)
       super
     end
@@ -162,7 +164,7 @@ module Papermill
       PapermillAsset.find(:all, :conditions => {:assetable_id => self.timestamp, :assetable_type => self.class.sti_name}).each do |asset|
         if asset.created_at < 2.hours.ago
           asset.destroy
-        else 
+        else
           asset.update_attribute(:assetable_id, self.id)
         end
       end

data/papermill.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{papermill}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Benoit B\303\251n\303\251zech"]
-  s.date = %q{2009-08-31}
+  s.date = %q{2009-09-01}
   s.description = %q{Paperclip wrapper}
   s.email = %q{benoit.benezech@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: BBenezech-papermill
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - "Benoit B\xC3\xA9n\xC3\xA9zech"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-31 00:00:00 -07:00
+date: 2009-09-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -63,7 +63,6 @@ files:
 - uninstall.rb
 has_rdoc: false
 homepage: http://github.com/BBenezech/papermill
-licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -84,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
 summary: Paperclip wrapper