lipsiadmin 2.9

data/lib/controller/ext.rb

@@ -0,0 +1,168 @@
+module Lipsiadmin
+  module Controller
+    module Ext
+      # Return column config, and store config/data for ExtJS ColumnModel and Store
+      # 
+      #   Examples:
+      # 
+      #     # app/controllers/backend/debtors_controller.rb
+      #     def index
+      #       @column_store = column_store_for Debtor do |cm|
+      #         cm.add :id          
+      #         cm.add "full_name_or_company.upcase",   "Full Name",      :sortable => true, :dataIndex => :company
+      #         cm.add :email,                          "Email",          :sortable => true
+      #         cm.add :piva,                           "Piva",           :sortable => true
+      #         cm.add :created_at,                     "Creato il",      :sortable => true, :renderer => :date, :align => :right
+      #         cm.add :updated_at,                     "Aggiornato il",  :sortable => true, :renderer => :datetime, :align => :right
+      #       end
+      #     
+      #       respond_to do |format|
+      #         format.js 
+      #         format.json do
+      #           render :json => @column_store.store_data(params)
+      #           
+      #           # or you can manually do:
+      #             # debtors           = Debtor.search(params)
+      #             # debtors_count     = debtors.size
+      #             # debtors_paginated = debtors.paginate(params)
+      #             # render :json => { :results => @column_store.store_data_from(debtors_paginated), :count => debtors_count }
+      #         end
+      #       end
+      #     end
+      # 
+      #     # app/views/backend/index.rjs
+      #     page.grid do |grid|
+      #       grid.id "debtors-grid" # If you don't set this columns are not saved in cookies
+      #       grid.title "List al debtors"
+      #       grid.base_path "/backend/debtors"
+      #       grid.forgery_protection_token request_forgery_protection_token
+      #       grid.authenticity_token form_authenticity_token
+      #       grid.tbar  :default
+      #       grid.store do |store|
+      #         store.url "/backend/debtors.json"
+      #         store.fields @column_store.store_fields
+      #       end
+      #       grid.columns do |columns|
+      #         columns.fields @column_store.column_fields
+      #       end
+      #       grid.bbar  :store => grid.get_store, :pageSize => params[:limit] # Remember to add after defining store!
+      #     end
+      # 
+      def column_store_for(model, &block)
+        ColumnStore.new(model, &block)
+      end
+      
+      class ColumnStore#:nodoc:
+        attr_reader :data
+
+        def initialize(model, &block)#:nodoc
+          @model = model
+          @data = []
+          yield self
+        end
+
+        # Method for add columns to the Column Model
+        def add(method, header=nil, options={})
+          options[:method]      = method
+           # Setting hidden and removing query for 
+          # items that don't have headers
+          if header.blank?
+            options[:hidden]  = true
+            options[:query]   = false
+          end
+          
+          # Reforma DataIndex
+          if options[:dataIndex].is_a?(Array)
+            options[:dataIndex] = options[:dataIndex].collect do |f| 
+              f.is_a?(Symbol) ? "#{@model.table_name}.#{f}" : f 
+            end.join(",")
+          end
+          
+          # Reformat query
+          if options[:method].is_a?(Symbol)
+            options[:dataIndex] ||= "#{@model.table_name}.#{options[:method]}"
+          else
+            # if we have eg. prodcedure.category.name we need to build
+            # a sql finder action so we need to generate
+            # procedures.categories.name
+            columns = options[:method].split(".")
+            if columns.empty?
+              options[:dataIndex] ||= "#{@model.table_name}.#{options[:method]}"
+            else
+              options[:dataIndex] ||= columns[0..columns.length-2].collect(&:pluralize).join(".") + "." + columns.at(columns.size-1)
+            end
+          end
+          
+          # Reformat dataIndex
+          options[:mapping] ||= options[:dataIndex].to_s.downcase.gsub(/[^a-z0-9]+/, '_').
+                                                                  gsub(/-+$/, '_').
+                                                                  gsub(/^-+$/, '_')
+
+          # Reformat header
+          options[:header] = header || options[:dataIndex].to_s.humanize
+
+          @data << options
+        end
+
+        # Return an array config for build an Ext.grid.ColumnModel() config
+        def column_fields
+          @data.clone.inject([]) do |fields, data|
+            # Prevent to removing in the original Hash
+            field = data.clone
+            field.delete(:method)
+            field.delete(:mapping)
+            fields << field
+            fields
+          end
+        end
+        
+        # Return an array config for build an Ext.data.GroupingStore()
+        def store_fields
+          @data.inject([]) do |fields, data|
+            hash = { :name => data[:dataIndex], :mapping => data[:mapping] }
+            hash.merge!(:type => data[:renderer]) if data[:renderer] && 
+                                                     (data[:renderer] == :date || data[:renderer] == :datetime)
+            fields << hash
+            fields
+          end
+        end
+        
+        # Return data for a custom collection for the ExtJS Ext.data.GroupingStore() json
+        def store_data_from(collection)
+          collection.inject([]) do |store, c|
+            store << @data.inject({ :id => c.id }) do |options, data|
+              options[data[:mapping]] = (c.instance_eval(data[:method].to_s) rescue I18n.t("lipsiadmin.labels.not_found"))
+              options
+            end
+            store
+          end
+        end
+        
+        # Return a searched and paginated data collection for the ExtJS Ext.data.GroupingStore() json
+        # You can pass options like:
+        # 
+        #   Examples
+        #   
+        #     store_data(params, :conditions => "found = 1")
+        #     store_data(params, :include => :posts)
+        # 
+        def store_data(params, options={})
+          @model.send(:with_scope, :find => options) do
+            collection           = @model.search(params)
+            collection_count     = collection.size
+            collection_paginated = collection.paginate(params)
+            { :results => store_data_from(collection_paginated), :count => collection_count }
+          end
+        end
+
+        # Returns an object whose <tt>to_json</tt> evaluates to +code+. Use this to pass a literal JavaScript 
+        # expression as an argument to another JavaScriptGenerator method.
+        #
+        def literal(code)
+          ActiveSupport::JSON::Variable.new(code.to_s)
+        end
+        alias_method :l, :literal
+      end
+    end
+  end
+end

data/lib/controller/lipsiadmin_controller.rb

@@ -0,0 +1,18 @@
+module Lipsiadmin#:nodoc:
+  module Controller#:nodoc:
+    # Base Backend Controller that define:
+    # 
+    #   layout false
+    #   before_filter :backend_login_required
+    #   helper Lipsiadmin::View::Helpers::BackendHelper
+    # 
+    class Base < ActionController::Base
+      def self.inherited(subclass)#:nodoc:
+        super
+        subclass.layout false
+        subclass.before_filter :backend_login_required
+        subclass.helper Lipsiadmin::View::Helpers::BackendHelper
+      end
+    end
+  end
+end

data/lib/controller/pdf_builder.rb

@@ -0,0 +1,67 @@
+module Lipsiadmin
+  module Controller
+    # This module convert a string/controller to a pdf through Pd4ml java library (included in this plugin)
+    # 
+    # For generate a pdf you can simply do
+    #   
+    #     script/generate pdf invoice
+    # 
+    # then edit your template /app/views/pdf/invoice.html.haml
+    # 
+    # Then in any of your controllers add some like this:
+    # 
+    #   def generate_pdf_invoice
+    #     render_pdf :invoice, 'invoice_file.pdf'
+    #   end
+    # 
+    # Possible options are:
+    # 
+    # * landescape, default it's false
+    # * send_data,  default it's true
+    #   
+    module PdfBuilder
+      include Lipsiadmin::Utils::HtmlEntities
+      
+      # Path to the pd4ml jarfile        
+      JARPATH = "../../resources"
+
+      # Convert a stream to pdf, the template must be located in app/view/pdf/yourtemplate.pdf.erb
+      def render_pdf(template, filename=nil, options={})
+
+        options[:landescape] ||= true
+        options[:send_data]  ||= !filename.blank?
+        # encode the template
+        input = encode_entities(render(:template => "/pdf/#{template}.html.haml", :layout => "print"))
+        
+        # search for stylesheet links and make their paths absolute.
+        input.gsub!('<link href="/javascripts', '<link href="' + RAILS_ROOT + '/public/javascripts')
+        input.gsub!('<link href="/stylesheets', '<link href="' + RAILS_ROOT + '/public/stylesheets')   
+
+        # search for images src, append full-path.
+        input.gsub!('src="/', 'src="' + RAILS_ROOT + '/public/')
+        input.gsub!('url(','url('+RAILS_ROOT+'/public')
+
+        cmd = "java -Xmx512m -Djava.awt.headless=true -cp pd4ml.jar:.:#{File.dirname(__FILE__)}/#{JARPATH} Pd4Ruby '#{input}' 950 A4 #{options[:landescape]}"
+
+        output = %x[cd #{File.dirname(__FILE__)}/#{JARPATH} \n #{cmd}]
+
+        # raise error if process returned false (ie: a java error)
+        raise PdfError, "An unknonwn error occurred while generating pdf: cd #{File.dirname(__FILE__)}/#{JARPATH} #{cmd}" if $?.success? === false
+        
+        # return raw pdf binary-stream
+        if options[:send_data]
+          pdf_options  = { :filename => filename, :type => 'application/pdf' }
+          pdf_options[:disposition] = "inline" if Rails.env == "development"
+          send_data(output, pdf_options) 
+        else
+          erase_results
+          output
+        end
+      end
+
+      # Errors For PDF
+      class PdfError < StandardError#:nodoc:
+      end
+    end
+  end
+end

data/lib/controller/rescue.rb

@@ -0,0 +1,72 @@
+module Lipsiadmin
+  module Controller
+    # This module are raised when an exception fire up in controllers.
+    # 
+    # Now you can personalize exception and simplify the layout using templates in:
+    # 
+    #   app/views/exception
+    # 
+    # when an exception is raised it try to send an email, and for send an email 
+    # you need to configure in enviroment or in an initializer some like this:
+    #
+    #   Examples:
+    #     
+    #     Lipsiadmin::Mailer::ExceptionNotifier.sender_address       = %("Exception Notifier" <server1@lipsiasoft.com>)
+    #     Lipsiadmin::Mailer::ExceptionNotifier.recipients_addresses = %(info@lipsiasoft.com)
+    #     Lipsiadmin::Mailer::ExceptionNotifier.email_prefix         = "[Your Project]"
+    # 
+    module Rescue
+      
+      def self.included(base)#:nodoc:
+        base.class_eval do
+          alias_method_chain :rescue_action_in_public, :notifier
+        end
+      end
+
+      # Overwrite to implement public exception handling (for requests answering false to <tt>local_request?</tt>).  By
+      # default will call render_optional_error_file.  Override this method to provide more user friendly error messages.
+      def rescue_action_in_public_with_notifier(exception) #:doc:
+        response_code = response_code_for_rescue(exception)
+        status        = interpret_status(response_code)[0,3]
+        respond_to do |format|
+          # Personalize rescue rules for backend
+          if controller_path =~ /^backend\//
+            # Usually when we made a post we submit the form
+            # to a target iframe, so we need to respond to the parent.
+            if request.post?
+              responds_to_parent do
+                render :update do |page| 
+                  page.unmask
+                  page.ext_alert I18n.t("lipsiadmin.exceptions.#{status}.title"), I18n.t("lipsiadmin.exceptions.#{status}.description")
+                end
+              end
+            else
+              # We can't use status, because Backend.app.load don't permit load 500, 404 pages
+              format.html { render :template => "/exceptions/#{status}" }
+              format.js do 
+                render :update do |page| 
+                  page.unmask
+                  page.ext_alert I18n.t("lipsiadmin.exceptions.#{status}.title"), I18n.t("lipsiadmin.exceptions.#{status}.description")
+                end
+              end
+              format.all  { render :nothing => true, :status => status }
+            end
+          else
+            format.html { render :template => "/exceptions/#{status}", :status => status }
+            format.all  { render :nothing => true, :status => status }
+          end
+        end
+      rescue Exception => e
+        logger.error e.message
+        erase_results
+        rescue_action_in_public_without_notifier(exception)
+      ensure
+        if response_code != :not_found && Lipsiadmin::Mailer::ExceptionNotifier.send_mail
+          Lipsiadmin::Mailer::ExceptionNotifier.deliver_exception(exception, self, request)
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/controller/responds_to_parent.rb

@@ -0,0 +1,56 @@
+module Lipsiadmin
+  module Controller
+    # Executes the response body as JavaScript in the context of the parent window.
+    # 
+    # Use this method of you are posting a form to a hidden IFRAME or if you would like
+    # to use IFRAME base RPC.
+    module RespondsToParent
+      # Render an action to parent
+      def render_to_parent(*options_for_render)
+        responds_to_parent do
+          # I don't use page.update for prevent dobule rendering 
+          # and so we can save rendering time!
+          source = render_to_string(*options_for_render)
+          render :update do |page|
+            page.call "Backend.app.update", source
+          end
+        end
+      end
+      # Redirect parent to a new url
+      def redirect_parent_to(location)
+        responds_to_parent do
+          render :update do |page|
+            page.load location, true
+          end
+        end
+      end
+
+      private
+        def responds_to_parent(&block)
+          yield
+          # We're returning HTML instead of JS or XML now
+          response.headers['Content-Type'] = 'text/html; charset=UTF-8'
+          # Either pull out a redirect or the request body
+          script =  location = erase_redirect_results ? "document.location.href = #{location.to_s.inspect}" : response.body
+          # Escape quotes, linebreaks and slashes, maintaining previously escaped slashes
+          # Suggestions for improvement?
+          script = (script || '').
+            gsub('\\', '\\\\\\').
+            gsub(/\r\n|\r|\n/, '\\n').
+            gsub(/['"]/, '\\\\\&').
+            gsub('</script>','</scr"+"ipt>')
+          # Clear out the previous render to prevent double render
+          erase_results
+          # Eval in parent scope and replace document location of this frame 
+          # so back button doesn't replay action on targeted forms
+          # loc = document.location to be set after parent is updated for IE
+          # setTimeout - scope the execution in the windows parent for safari
+          # window.eval - legal eval for Opera
+          render :text => "<html><body><script type='text/javascript' charset='utf-8'>
+            window.parent.eval('#{script}');
+            document.location.replace('about:blank');
+          </script></body></html>"
+        end
+    end
+  end
+end

data/lib/data_base/attachment.rb

@@ -0,0 +1,351 @@
+require 'tempfile'
+require 'data_base/attachment/upfile'
+require 'data_base/attachment/iostream'
+require 'data_base/attachment/geometry'
+require 'data_base/attachment/processor'
+require 'data_base/attachment/thumbnail'
+require 'data_base/attachment/storage'
+require 'data_base/attachment/attach'
+
+if defined? RAILS_ROOT
+  Dir.glob(File.join(File.expand_path(RAILS_ROOT), "lib", "attachment_processors", "*.rb")).each do |processor|
+    require processor
+  end
+end
+
+module Lipsiadmin
+  module DataBase
+    module Attachment
+
+      class << self#:nodoc:
+        def included(base) #:nodoc:
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        
+        # Attach a single file/image to your model.
+        # 
+        #   Examples:
+        #     
+        #     has_one_attachment                    :image
+        #     attachment_styles_for                 :image, :normal, "128x128!"
+        #     validates_attachment_presence_for     :image
+        #     validates_attachment_size_for         :image, :greater_than => 10.megabytes
+        #     validates_attachment_content_type_for :image, "image/png"
+        # 
+        # Then in your form (with multipart) you can simply add:
+        # 
+        #   =file_field :mymodel, :image_attributes
+        # 
+        def has_one_attachment(name, options={})
+          options[:as]         ||= :attacher
+          options[:class_name] ||= "Attachment"
+          has_one name, options
+          before_save "before_save_for_#{name}"
+          attr_accessor "#{name}_attributes"
+
+          write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
+          attachment_definitions[name] = {:validations => {}}.merge(reflections[name].class_name.constantize.attachment_definitions)
+
+          validates_each(name) do |record, attr, value|
+            attributes = record.send("#{name}_attributes")
+            attributes ||= {}
+
+            attributes.merge!(:attachment_definitions => record.class.attachment_definitions[name])
+            file_column = reflections[name].class_name.constantize.new(attributes)
+            unless file_column.valid?
+              file_column.errors.each do |error, message|
+                record.errors.add(name, message) if message
+              end
+            end
+          end
+
+          define_method "before_save_for_#{name}" do
+            attributes = send("#{name}_attributes")
+            attributes ||= {}
+            
+            return if attributes[:file].blank?
+            
+            attributes.merge!(:attachment_definitions => self.class.attachment_definitions[name])
+            
+            if file_column = self.send(name)
+              file_column.update_attributes(attributes)
+            else
+              self.send(name).build(attributes)
+            end
+
+          end
+        end
+
+        # Attach a many files/images to your model.
+        # 
+        #   Examples:
+        #     
+        #     has_one_attachment                    :images
+        #     attachment_styles_for                 :images, :normal, "128x128!"
+        #     validates_attachment_presence_for     :images
+        #     validates_attachment_size_for         :images, :greater_than => 10.megabytes
+        #     validates_attachment_content_type_for :images, "image/png"
+        # 
+        # Then in your form (with multipart) you can simply add:
+        #   
+        #   =fields_for "yourmodel[attachments_attributes][]", @yourmodel.images.build do |image|
+        #     =image.file_field :file
+        # 
+        def has_many_attachments(name, options = {})
+          options[:as]         ||= :attacher
+          options[:class_name] ||= "Attachment"
+          
+          has_many name, options
+          before_save "before_save_for_#{name}"
+          attr_accessor "#{name}_attributes"
+
+          write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
+          attachment_definitions[name] = {:validations => {}}.merge(reflections[name].class_name.constantize.attachment_definitions)
+
+          validates_each(name) do |record, attr, value|
+            attributes = record.send("#{name}_attributes")
+            attributes ||= {}
+
+            file_column = nil
+            for attribute in attributes
+              attribute.merge!(:attachment_definitions => record.class.attachment_definitions[name])
+              file_column = reflections[name].class_name.constantize.new(attribute)
+              unless file_column.valid?
+                file_column.errors.each do |error, message|
+                  record.errors.add(name, message) if message
+                end
+              end
+            end
+          end
+
+          define_method "before_save_for_#{name}" do
+            attributes = send("#{name}_attributes")
+            attributes ||= {}
+
+            file_column = nil
+
+            for attribute in attributes
+              next if attribute["file"].blank?
+              attribute.merge!(:attachment_definitions => self.class.attachment_definitions[name])
+              self.send(name).build(attribute)
+            end
+
+          end
+        end
+        
+        # The full URL of where the attachment is publically accessible. This can just
+        # as easily point to a directory served directly through Apache as it can to an action
+        # that can control permissions. You can specify the full domain and path, but usually
+        # just an absolute path is sufficient. The leading slash *must* be included manually for 
+        # absolute paths. The default value is 
+        #   "/uploads/:id_:attachment_:style_:basename.:extension". See
+        #   Lipsiadmin::Attachment::Attach#interpolate for more information on variable interpolaton.
+        #   :url => "/:class/:attachment/:id/:style_:basename.:extension"
+        #   :url => "http://some.other.host/stuff/:class/:id_:extension"
+        def attachment_url_for(name, url)
+          attachment_definitions[name][:url] = url
+        end
+        
+        # The URL that will be returned if there is no attachment assigned. 
+        # This field is interpolated just as the url is. The default value is 
+        #   "/images/backend/no-image.png"
+        #   has_one_attached_file :avatar
+        #   attachment_default_url :avatar, "/images/backend/no-image.png"
+        #   User.new.avatar.url(:small) # => "/images/backend/no-image.png"        
+        def attachment_default_url_for(name, url)
+          attachment_definitions[name][:default_url]
+        end
+        
+        # The path were the attachment are stored. 
+        # The default value is
+        #   :rails_root/public/uploads/:id_:attachment_:style_:basename.:extension
+        # This value must be in consistency with <tt>url</tt>
+        def attachment_path_for(name, path)
+          attachment_definitions[name][:path] = path
+        end
+            
+        # A hash of thumbnail styles and their geometries. You can find more about 
+        # geometry strings at the ImageMagick website 
+        # (http://www.imagemagick.org/script/command-line-options.php#resize). Attachment
+        # also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally 
+        # inside the dimensions and then crop the rest off (weighted at the center). The 
+        # default value is to generate no thumbnails.
+        def attachment_styles_for(name, style_name, styles)
+          attachment_definitions[name][:styles] = { style_name => styles }
+        end
+        
+        # The thumbnail style that will be used by default URLs. 
+        # Defaults to +original+.
+        #   attachment_styles :avatar, :normal, "100x100#"
+        #   attachment_default_style :normal
+        #   user.avatar.url # => "/avatars/23/normal_me.png"
+        def attachment_default_style_for(name, default_style)
+          attachment_definitions[name][:default_style] = default_style
+        end
+
+        # Will raise an error if Attachment cannot post_process an uploaded file due
+        # to a command line error. This will override the global setting for this attachment. 
+        # Defaults to false.
+        def attachment_whiny_for(name, whiny_thumbnails)
+          attachment_definitions[name][:whiny_thumbnails] = whiny_thumbnails
+        end
+
+        # Chooses the storage backend where the files will be stored. The current
+        # choices are :filesystem and :s3. The default is :filesystem. Make sure you read the
+        # documentation for Lipsiadmin::Attachment::Storage::Filesystem and Lipsiadmin::Attachment::Storage::S3
+        # for backend-specific options.
+        def attachment_storage_for(name, storage)
+          attachment_definitions[name][:storage] = storage
+        end
+        
+        # When creating thumbnails, use this free-form options
+        # field to pass in various convert command options.  Typical options are "-strip" to
+        # remove all Exif data from the image (save space for thumbnails and avatars) or
+        # "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
+        # convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
+        # Note that this option takes a hash of options, each of which correspond to the style
+        # of thumbnail being generated. You can also specify :all as a key, which will apply
+        # to all of the thumbnails being generated. If you specify options for the :original,
+        # it would be best if you did not specify destructive options, as the intent of keeping
+        # the original around is to regenerate all the thumbnails when requirements change.
+        #   attachment_styles          :avatar, :large,    "300x300"
+        #   attachment_styles          :avatar, :negative, "100x100"
+        #   attachment_convert_options :avatar, :all,      "-strip"
+        #   attachment_convert_options :avatar, :negative, "-negate"
+        def attachment_convert_options_for(name, convert_name, convert_options)
+          attachment_definitions[name][:convert_options] = { convert_name => convert_options}
+        end
+        
+        # When processing, if the spawn plugin is installed, processing can be done in
+        # a background fork or thread if desired.
+        def attachment_background_for(name, background)
+          attachment_definitions[name][:background] = background
+        end
+        
+        # Attachment supports an extendible selection of post-processors. When you define
+        # a set of styles for an attachment, by default it is expected that those
+        # "styles" are actually "thumbnails". However, you can do more than just
+        # thumbnail images. By defining a subclass of Lipsiadmin::Attachment::Processor, you can
+        # perform any processing you want on the files that are attached. Any file in
+        # your Rails app's lib/attachment_processors directory is automatically loaded by
+        # Attachment, allowing you to easily define custom processors. You can specify a
+        # processor with the :processors option to has_attached_file:
+        # 
+        #   attachment_styles     :avatar, :text, { :quality => :better }
+        #   attachment_processors :avatar, :ocr
+        # 
+        # This would load the hypothetical class Lipsiadmin::Ocr, which would have the
+        # hash "{ :quality => :better }" passed to it along with the uploaded file. For
+        # more information about defining processors, see Lipsiadmin::Attachment::Processor.
+        # 
+        # The default processor is Lipsiadmin::Attachment::Thumbnail. For backwards compatability
+        # reasons, you can pass a single geometry string or an array containing a
+        # geometry and a format, which the file will be converted to, like so:
+        # 
+        #   attachment_styles     :avatar, :thumb, ["32x32#", :png]
+        # 
+        # This will convert the "thumb" style to a 32x32 square in png format, regardless
+        # of what was uploaded. If the format is not specified, it is kept the same (i.e.
+        # jpgs will remain jpgs).
+        # 
+        # Multiple processors can be specified, and they will be invoked in the order
+        # they are defined in the :processors array. Each successive processor will
+        # be given the result of the previous processor's execution. All processors will
+        # receive the same parameters, which are what you define in the :styles hash.
+        # For example, assuming we had this definition:
+        # 
+        #   attachment_styles     :avatar, :text, { :quality => :better }
+        #   attachment_processors :avatar, :rotator
+        #   attachment_processors :avatar, :ocr
+        # 
+        # then both the :rotator processor and the :ocr processor would receive the 
+        # options "{ :quality => :better }". This parameter may not mean anything to one
+        # or more or the processors, and they are free to ignore it.        
+        def attachment_processors_for(name, processor_name, processors)
+          attachment_definitions[name][:processors] = { processor_name => processor_processors }
+        end
+
+        # Places ActiveRecord-style validations on the size of the file assigned. The
+        # possible options are:
+        # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
+        # * +less_than+: equivalent to :in => 0..options[:less_than]
+        # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
+        # * +message+: error message to display, use :min and :max as replacements
+        def validates_attachment_size_for(name, options = {})
+          min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+          max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+          range   = (min..max)
+          helper  = ActionController::Base.helpers
+
+          if options[:message].blank?
+            message  = ""
+            message << I18n.t("activerecord.errors.messages.greater_than", :count => helper.number_to_human_size(min))    if min > 0
+            message << " " + I18n.t("activerecord.errors.messages.less_than", :count => helper.number_to_human_size(max)) if max.to_f.infinite? != 1
+          else
+            message = options[:message]
+          end
+
+          attachment_definitions[name][:validations][:size] = lambda do |attachment, instance|
+            if attachment.exist? && !range.include?(attachment.size.to_i)
+              message
+            end
+          end
+        end
+
+        # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
+        def validates_attachment_thumbnails_for(name, options = {})
+          attachment_definitions[name][:whiny_thumbnails] = true
+        end
+
+        # Places ActiveRecord-style validations on the presence of a file.
+        def validates_attachment_presence_for(name, options = {})
+          message = options[:message] || I18n.t("activerecord.errors.messages.blank")
+          attachment_definitions[name][:validations][:presence] = lambda do |attachment, instance|
+            message unless attachment.exist?
+          end
+        end
+
+        # Places ActiveRecord-style validations on the content type of the file
+        # assigned. The possible options are: 
+        # * +content_type+: Allowed content types.  Can be a single content type 
+        #   or an array.  Each type can be a String or a Regexp. It should be 
+        #   noted that Internet Explorer upload files with content_types that you 
+        #   may not expect. For example, JPEG images are given image/pjpeg and 
+        #   PNGs are image/x-png, so keep that in mind when determining how you 
+        #   match.  Allows all by default.
+        # * +message+: The message to display when the uploaded file has an invalid
+        #   content type.
+        def validates_attachment_content_type_for(name, *args)
+          options = {}
+          valid_types = []
+          args.each do |variable|
+            case variable
+              when String then valid_types << variable
+              when Hash   then options.merge!(variable)
+            end
+          end
+          attachment_definitions[name][:validations][:content_type] = lambda do |attachment, instance|
+            unless attachment.original_filename.blank?
+              content_type = attachment.instance_read(:content_type)
+              unless valid_types.any?{ |t| t === content_type }
+                options[:message] || I18n.t("activerecord.errors.messages.content_type")
+              end
+            end
+          end
+        end
+        
+        # Returns the attachment definitions defined by each call to
+        # has_attached_file.
+        def attachment_definitions
+          read_inheritable_attribute(:attachment_definitions)
+        end
+
+      end
+
+    end
+    
+  end
+end