uploadcolumn 0.3.0

data/lib/upload_column/magic_columns.rb

@@ -0,0 +1,50 @@
+module UploadColumn
+  module MagicColumns
+  
+    def self.included(base)
+      super
+      base.send :alias_method_chain, :set_upload_column, :magic_columns
+      base.send :alias_method_chain, :set_upload_column_temp, :magic_columns
+      base.send :alias_method_chain, :save_uploaded_files, :magic_columns
+    end
+  
+    def set_upload_column_with_magic_columns(name, file)
+      set_upload_column_without_magic_columns(name, file)
+      evaluate_magic_columns_for_upload_column(name)
+    end
+  
+    def set_upload_column_temp_with_magic_columns(name, path)
+      set_upload_column_temp_without_magic_columns(name, path)
+      evaluate_magic_columns_for_upload_column(name)
+    end
+    
+    def save_uploaded_files_with_magic_columns
+      save_uploaded_files_without_magic_columns
+      self.class.reflect_on_upload_columns.each do |name, column|
+        evaluate_magic_columns_for_upload_column(name)
+      end
+    end
+    
+    private
+    
+    def evaluate_magic_columns_for_upload_column(name)
+      
+      self.class.column_names.each do |column_name|
+        
+        statement, predicate = column_name.split('_', 2)
+        
+        if statement and predicate and name.to_s == statement and not self.read_attribute(column_name.to_sym)
+          uploaded_file = self.send(:get_upload_column, name.to_sym)
+          
+          self.write_attribute(column_name.to_sym, handle_predicate(uploaded_file, predicate))
+        end
+        
+      end
+    end
+    
+    def handle_predicate(uploaded_file, predicate)
+      return uploaded_file.send(predicate.to_sym) if uploaded_file.respond_to?(predicate.to_sym)
+    end
+  
+  end
+end

data/lib/upload_column/manipulators/image_science.rb

@@ -0,0 +1,86 @@
+module UploadColumn
+  module Manipulators
+    
+    module ImageScience
+      
+      attr_reader :width, :height
+
+      def load_manipulator_dependencies #:nodoc:
+        require 'image_science'
+      end
+
+      def process!(instruction)
+        if instruction.to_s =~ /^c(\d+x\d+)/
+          crop_resized!($1)
+        elsif instruction.to_s =~ /\d+x\d+/
+          resize!(instruction)
+        end
+      end
+      
+      # Resize the image so that it will not exceed the dimensions passed
+      # via geometry, geometry should be a string, formatted like '200x100' where
+      # the first number is the height and the second is the width
+      def resize!( geometry )
+        ::ImageScience.with_image(self.path) do |img|
+          width, height = extract_dimensions(img.width, img.height, geometry)
+          img.resize( width, height ) do |file|
+            file.save( self.path )
+          end
+        end
+      end
+
+      # Resize and crop the image so that it will have the exact dimensions passed
+      # via geometry, geometry should be a string, formatted like '200x100' where
+      # the first number is the height and the second is the width
+      def crop_resized!( geometry )
+        ::ImageScience.with_image(self.path) do |img|
+          new_width, new_height = geometry.split('x').map{|i| i.to_i }
+
+          width, height = extract_dimensions_for_crop(img.width, img.height, geometry)
+          x_offset, y_offset = extract_placement_for_crop(width, height, geometry)
+
+          img.resize( width, height ) do |i2|
+
+            i2.with_crop( x_offset, y_offset, new_width + x_offset, new_height + y_offset) do |file|
+              file.save( self.path )
+            end
+          end
+        end
+      end
+
+      private
+
+      def extract_dimensions(width, height, new_geometry, type = :resize)
+        new_width, new_height = convert_geometry(new_geometry)
+
+        aspect_ratio = width.to_f / height.to_f
+        new_aspect_ratio = new_width / new_height
+
+        if (new_aspect_ratio > aspect_ratio) ^ ( type == :crop )  # Image is too wide, the caret is the XOR operator
+          new_width, new_height = [ (new_height * aspect_ratio), new_height]
+        else #Image is too narrow
+          new_width, new_height = [ new_width, (new_width / aspect_ratio)]
+        end
+
+        [new_width, new_height].collect! { |v| v.round }
+      end
+
+      def extract_dimensions_for_crop(width, height, new_geometry)
+        extract_dimensions(width, height, new_geometry, :crop)
+      end
+
+      def extract_placement_for_crop(width, height, new_geometry)
+        new_width, new_height = convert_geometry(new_geometry)
+        x_offset = (width / 2.0) - (new_width / 2.0)
+        y_offset = (height / 2.0) - (new_height / 2.0)
+        [x_offset, y_offset].collect! { |v| v.round }
+      end
+
+      def convert_geometry(geometry)
+        geometry.split('x').map{|i| i.to_f }      
+      end
+
+    end
+    
+  end
+end

data/lib/upload_column/manipulators/rmagick.rb

@@ -0,0 +1,75 @@
+module UploadColumn
+  
+  UploadError = Class.new(StandardError) unless defined?(UploadError)
+  ManipulationError = Class.new(UploadError) unless defined?(ManipulationError)
+  
+  module Manipulators
+    
+    module RMagick
+      
+      def load_manipulator_dependencies #:nodoc:
+        require 'RMagick'
+      end
+      
+      def process!(instruction = nil, &block)
+        if instruction.is_a?(Proc)
+          manipulate!(&instruction)
+        elsif instruction.to_s =~ /^c(\d+x\d+)$/
+          crop_resized!($1)
+        elsif instruction.to_s =~ /^(\d+x\d+)$/
+          resize!($1)
+        end
+        manipulate!(&block) if block
+      end
+      
+      # Convert the image to format
+      def convert!(format)
+        manipulate! do |img|
+          img.format = format.to_s.upcase
+          img
+        end
+      end
+      
+      # Resize the image so that it will not exceed the dimensions passed
+      # via geometry, geometry should be a string, formatted like '200x100' where
+      # the first number is the height and the second is the width
+      def resize!( geometry )
+        manipulate! do |img|
+          img.change_geometry( geometry ) do |c, r, i|
+            i.resize(c,r)
+          end
+        end
+      end
+
+      # Resize and crop the image so that it will have the exact dimensions passed
+      # via geometry, geometry should be a string, formatted like '200x100' where
+      # the first number is the height and the second is the width
+      def crop_resized!( geometry )
+        manipulate! do |img|
+          h, w = geometry.split('x')
+          img.crop_resized(h.to_i,w.to_i)
+        end
+      end
+      
+      def manipulate!
+        image = ::Magick::Image.read(self.path)
+        
+        if image.size > 1
+          list = ::Magick::ImageList.new
+          image.each do |frame|
+            list << yield( frame )
+          end
+          list.write(self.path)
+        else
+          yield( image.first ).write(self.path)
+        end
+      rescue ::Magick::ImageMagickError => e
+        # this is a more meaningful error message, which we could catch later
+        raise ManipulationError.new("Failed to manipulate with rmagick, maybe it is not an image? Original Error: #{e}")
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/upload_column/rails/action_controller_extension.rb

@@ -0,0 +1,61 @@
+module UploadColumn::ActionControllerExtension
+
+  def self.included(base)
+    base.send :alias_method_chain, :url_for, :uploaded_file_check
+    base.helper_method :url_for_path
+  end
+  
+  protected
+  
+  def url_for_with_uploaded_file_check(options = {}, *parameters_for_method_reference)
+    if(options.respond_to?(:public_path))
+      options.public_path
+    else
+      url_for_without_uploaded_file_check(options || {}, *parameters_for_method_reference)
+    end
+  end
+  
+  def url_for_path(path)
+    request.protocol + request.host_with_port + path
+  end
+  
+  # You can use +render_image+ in your controllers to render an image
+  #     def picture
+  #       @user = User.find(params[:id])
+  #       render_image @user.picture
+  #     end
+  # This of course, is not very useful at all (you could simply have linked to the image itself),
+  # However it is even possible to pass a block to render_image that allows manipulation using
+  # RMagick, here the fun begins:
+  #     def solarize_picture
+  #       @user = User.find(params[:id])
+  #       render_image @user.picture do |img|
+  #         img = img.segment
+  #         img.solarize
+  #       end
+  #     end
+  # Note that like in UploadColumn::BaseUploadedFile.process you will need to 'carry' the image
+  # since most Rmagick methods do not modify the image itself but rather return the result of the
+  # transformation.
+  #
+  # Instead of passing an upload_column object to +render_image+ you can even pass a path String,
+  # if you do you will have to pass a :mime-type option as well though.
+  def render_image( file, options = {} )
+      format = if options.is_a?(Hash) then options[:force_format] else nil end
+      mime_type = if options.is_a?(String) then options else options[:mime_type] end
+      mime_type ||= file.mime_type
+      path = if file.is_a?( String ) then file else file.path end
+      headers["Content-Type"] = mime_type unless format
+      
+      if block_given? or format
+        img = ::Magick::Image::read(path).first
+        img = yield( img ) if block_given?
+        img.format = format.to_s.upcase if format
+        render :text => img.to_blob, :layout => false
+      else
+        send_file( path )
+      end
+  end
+end
+
+ActionController::Base.send(:include, UploadColumn::ActionControllerExtension)

data/lib/upload_column/rails/asset_tag_extension.rb

@@ -0,0 +1,17 @@
+module UploadColumn::AssetTagExtension
+  
+  def self.included(base)
+    base.send :alias_method_chain, :image_tag, :uploaded_file_check
+  end
+  
+  def image_tag_with_uploaded_file_check(source, options = {})
+    if(source.respond_to?(:public_path))
+      image_tag_without_uploaded_file_check(source.public_path, options)
+    else
+      image_tag_without_uploaded_file_check(source, options)
+    end
+  end
+  
+end
+
+ActionView::Helpers::AssetTagHelper.send(:include, UploadColumn::AssetTagExtension)

data/lib/upload_column/rails/upload_column_helper.rb

@@ -0,0 +1,45 @@
+module UploadColumn::UploadColumnHelper
+
+  # Returns an input tag of the "file" type tailored for accessing an upload_column field
+  # (identified by method) on an object assigned to the template (identified by object).
+  # Additional options on the input tag can be passed as a hash with options.
+  #
+  # Example (call, result)
+  #     upload_column_field( :user, :picture )
+  #       <input id="user_picture_temp" name="user[picture_temp]" type="hidden" />
+  #       <input id="user_picture" name="user[picture]" size="30" type="file" />
+  #
+  # Note: if you use file_field instead of upload_column_field, the file will not be
+  # stored across form redisplays.
+  def upload_column_field(object, method, options={})
+    file_field(object, method, options) + hidden_field(object, method.to_s + '_temp')
+  end
+
+  # A helper method for creating a form tag to use with uploadng files,
+  # it works exactly like Rails' form_tag, except that :multipart is always true
+  def upload_form_tag(url_for_options = {}, options = {}, *parameters_for_url, &proc)
+    options[:multipart] = true
+    form_tag( url_for_options, options, *parameters_for_url, &proc )
+  end
+
+  # A helper method for creating a form tag to use with uploadng files,
+  # it works exactly like Rails' form_for, except that :multipart is always true
+  def upload_form_for(*args, &block)
+    options = args.extract_options!
+    options[:html] ||= {}
+    options[:html][:multipart] = true
+    args.push(options)
+  
+    form_for(*args, &block)
+  end
+
+end
+
+class ActionView::Helpers::FormBuilder #:nodoc:
+  self.field_helpers += ['upload_column_field']  
+  def upload_column_field(method, options = {})
+    @template.send(:upload_column_field, @object_name, method, options.merge(:object => @object))
+  end
+end
+
+ActionView::Base.send(:include, UploadColumn::UploadColumnHelper)

data/lib/upload_column/sanitized_file.rb

@@ -0,0 +1,176 @@
+begin; require 'mime/types'; rescue Exception; end
+
+require 'fileutils'
+
+module UploadColumn
+  # Sanitize is a base class that takes care of all the dirtywork when dealing with file uploads.
+  # it is subclassed as UploadedFile in UploadColumn, which does most of the upload magic, but if
+  # you want to roll you own uploading system, SanitizedFile might be for you since it takes care
+  # of a lot of the unfun stuff.
+  # 
+  # Usage is pretty simple, just do SanitizedFile.new(some_uploaded_file) and you're good to go
+  # you can now use #copy_to and #move_to to place the file wherever you want, whether it is a StringIO
+  # or a TempFile.
+  #
+  # SanitizedFile also deals with content type detection, which it does either through the 'file' *nix exec
+  # or (if you are stuck on Windows) through the MIME::Types library (not to be confused with Rails' Mime class!).
+  class SanitizedFile
+    
+    attr_reader :basename, :extension
+    
+    def initialize(file, options = {})
+      @options = options
+      if file && file.instance_of?(String) && !file.empty? 
+        @path = file
+        self.filename = File.basename(file)
+      else
+        @file = file
+        self.filename = self.original_filename unless self.empty?
+      end
+    end
+    
+    # Returns the filename before sanitation took place
+    def original_filename
+      @original_filename ||= if @file and @file.respond_to?(:original_filename)
+        @file.original_filename
+      elsif self.path
+        File.basename(self.path)
+      end
+    end
+    
+    # Returns the files properly sanitized filename.
+    def filename
+      @filename ||= (self.extension && !self.extension.empty?) ? "#{self.basename}.#{self.extension}" : self.basename
+    end
+    
+    # Returns the file's size
+    def size
+      return @file.size if @file.respond_to?(:size)
+      File.size(self.path) rescue nil
+    end
+    
+    # Returns the full path to the file
+    def path
+      @path ||= File.expand_path(@file.path) rescue nil
+    end
+    
+    # Checks if the file is empty.
+    def empty?
+      (@file.nil? && @path.nil?) || self.size.nil? || self.size.zero?
+    end
+    
+    # Checks if the file exists
+    def exists?
+      File.exists?(self.path) if self.path
+    end
+    
+    # Moves the file to 'path'
+    def move_to(path)
+      if copy_file(path)
+        # FIXME: This gets pretty broken in UploadedFile. E.g. moving avatar-thumb.jpg will change the filename
+        # to avatar-thumb-thumb.jpg
+        @basename, @extension = split_extension(File.basename(path))
+        @file = nil
+        @filename = nil
+        @path = path
+      end
+    end
+    
+    # Copies the file to 'path' and returns a new SanitizedFile that points to the copy.
+    def copy_to(path)
+      copy = self.clone
+      copy.move_to(path)
+      return copy
+    end
+    
+    # Returns the content_type of the file as determined through the MIME::Types library or through a *nix exec.
+    def content_type
+      unless content_type = get_content_type_from_exec || get_content_type_from_mime_types
+        content_type ||= @file.content_type.chomp if @file.respond_to?(:content_type) and @file.content_type
+      end
+      return content_type
+    end
+    
+    private
+    
+    def copy_file(path)
+      unless self.empty?
+        # create the directory if it doesn't exist
+        FileUtils.mkdir_p(File.dirname(path)) unless File.exists?(File.dirname(path))
+        # stringios don't have a path and can't be copied
+        if not self.path and @file.respond_to?(:read)
+          @file.rewind # Make sure we are at the beginning of the buffer
+          File.open(path, "wb") { |f| f.write(@file.read) }
+        else
+          begin
+            FileUtils.cp(self.path, path)
+          rescue ArgumentError
+          end
+        end
+        File.chmod(@options[:permissions], path) if @options[:permissions]
+        return true
+      end
+    end
+    
+    def filename=(filename)
+      basename, extension = split_extension(filename)
+      @basename = sanitize(basename)
+      @extension = correct_file_extension(extension)
+    end
+    
+    # tries to identify the mime-type of file and correct self's extension
+    # based on the found mime-type
+    def correct_file_extension(ext)
+      if @options[:fix_file_extensions] && defined?(MIME::Types)
+        if mimes = MIME::Types[self.content_type]
+          return mimes.first.extensions.first unless mimes.first.extensions.empty?
+        end
+      end
+      return ext.downcase
+    end
+    
+    # Try to use *nix exec to fetch content type
+    def get_content_type_from_exec
+      if @options[:get_content_type_from_file_exec] and not self.path.empty?
+        return system_call(%(file -bi "#{self.path}")).chomp.scan(/^[a-z0-9\-_]+\/[a-z0-9\-_]+/).first
+      end
+    rescue
+      nil
+    end
+    
+    def system_call(command)
+      `#{command}`
+    end
+    
+    def get_content_type_from_mime_types
+      if @extension and defined?(MIME::Types)
+        mimes = MIME::Types.of(@extension)
+        return mimes.first.content_type rescue nil
+      end
+    end
+    
+    def sanitize(name)
+      # Sanitize the filename, to prevent hacking
+      name = File.basename(name.gsub("\\", "/")) # work-around for IE
+      name.gsub!(/[^a-zA-Z0-9\.\-\+_]/,"_")
+      name = "_#{name}" if name =~ /^\.+$/
+      name = "unnamed" if name.size == 0
+      return name.downcase
+    end
+    
+    def split_extension(fn)
+      # regular expressions to try for identifying extensions
+      ext_regexps = [ 
+        /^(.+)\.([^\.]{1,3}\.[^\.]{1,4})$/, # matches "something.tar.gz"
+        /^(.+)\.([^\.]+)$/ # matches "something.jpg"
+      ]
+      ext_regexps.each do |regexp|
+        if fn =~ regexp
+          return $1, $2
+        end
+      end
+      return fn, "" # In case we weren't able to split the extension
+    end
+    
+  end
+end