260 lines
8.9 KiB
Ruby
260 lines
8.9 KiB
Ruby
module FileColumn # :nodoc:
|
|
|
|
class BaseUploadedFile # :nodoc:
|
|
def transform_with_magick
|
|
if needs_transform?
|
|
begin
|
|
img = ::Magick::Image::read(absolute_path).first
|
|
rescue ::Magick::ImageMagickError
|
|
if options[:magick][:image_required]
|
|
@magick_errors ||= []
|
|
@magick_errors << "invalid image"
|
|
end
|
|
return
|
|
end
|
|
|
|
if options[:magick][:versions]
|
|
options[:magick][:versions].each_pair do |version, version_options|
|
|
next if version_options[:lazy]
|
|
dirname = version_options[:name]
|
|
FileUtils.mkdir File.join(@dir, dirname)
|
|
transform_image(img, version_options, absolute_path(dirname))
|
|
end
|
|
end
|
|
if options[:magick][:size] or options[:magick][:crop] or options[:magick][:transformation] or options[:magick][:attributes]
|
|
transform_image(img, options[:magick], absolute_path)
|
|
end
|
|
|
|
GC.start
|
|
end
|
|
end
|
|
|
|
def create_magick_version_if_needed(version)
|
|
# RMagick might not have been loaded so far.
|
|
# We do not want to require it on every call of this method
|
|
# as this might be fairly expensive, so we just try if ::Magick
|
|
# exists and require it if not.
|
|
begin
|
|
::Magick
|
|
rescue NameError
|
|
require 'RMagick'
|
|
end
|
|
|
|
if version.is_a?(Symbol)
|
|
version_options = options[:magick][:versions][version]
|
|
else
|
|
version_options = MagickExtension::process_options(version)
|
|
end
|
|
|
|
unless File.exists?(absolute_path(version_options[:name]))
|
|
begin
|
|
img = ::Magick::Image::read(absolute_path).first
|
|
rescue ::Magick::ImageMagickError
|
|
# we might be called directly from the view here
|
|
# so we just return nil if we cannot load the image
|
|
return nil
|
|
end
|
|
dirname = version_options[:name]
|
|
FileUtils.mkdir File.join(@dir, dirname)
|
|
transform_image(img, version_options, absolute_path(dirname))
|
|
end
|
|
|
|
version_options[:name]
|
|
end
|
|
|
|
attr_reader :magick_errors
|
|
|
|
def has_magick_errors?
|
|
@magick_errors and !@magick_errors.empty?
|
|
end
|
|
|
|
private
|
|
|
|
def needs_transform?
|
|
options[:magick] and just_uploaded? and
|
|
(options[:magick][:size] or options[:magick][:versions] or options[:magick][:transformation] or options[:magick][:attributes])
|
|
end
|
|
|
|
def transform_image(img, img_options, dest_path)
|
|
begin
|
|
if img_options[:transformation]
|
|
if img_options[:transformation].is_a?(Symbol)
|
|
img = @instance.send(img_options[:transformation], img)
|
|
else
|
|
img = img_options[:transformation].call(img)
|
|
end
|
|
end
|
|
if img_options[:crop]
|
|
dx, dy = img_options[:crop].split(':').map { |x| x.to_f }
|
|
w, h = (img.rows * dx / dy), (img.columns * dy / dx)
|
|
img = img.crop(::Magick::CenterGravity, [img.columns, w].min,
|
|
[img.rows, h].min, true)
|
|
end
|
|
|
|
if img_options[:size]
|
|
img = img.change_geometry(img_options[:size]) do |c, r, i|
|
|
i.resize(c, r)
|
|
end
|
|
end
|
|
ensure
|
|
img.write(dest_path) do
|
|
if img_options[:attributes]
|
|
img_options[:attributes].each_pair do |property, value|
|
|
self.send "#{property}=", value
|
|
end
|
|
end
|
|
end
|
|
File.chmod options[:permissions], dest_path
|
|
end
|
|
end
|
|
end
|
|
|
|
# If you are using file_column to upload images, you can
|
|
# directly process the images with RMagick,
|
|
# a ruby extension
|
|
# for accessing the popular imagemagick libraries. You can find
|
|
# more information about RMagick at http://rmagick.rubyforge.org.
|
|
#
|
|
# You can control what to do by adding a <tt>:magick</tt> option
|
|
# to your options hash. All operations are performed immediately
|
|
# after a new file is assigned to the file_column attribute (i.e.,
|
|
# when a new file has been uploaded).
|
|
#
|
|
# == Resizing images
|
|
#
|
|
# To resize the uploaded image according to an imagemagick geometry
|
|
# string, just use the <tt>:size</tt> option:
|
|
#
|
|
# file_column :image, :magick => {:size => "800x600>"}
|
|
#
|
|
# If the uploaded file cannot be loaded by RMagick, file_column will
|
|
# signal a validation error for the corresponding attribute. If you
|
|
# want to allow non-image files to be uploaded in a column that uses
|
|
# the <tt>:magick</tt> option, you can set the <tt>:image_required</tt>
|
|
# attribute to +false+:
|
|
#
|
|
# file_column :image, :magick => {:size => "800x600>",
|
|
# :image_required => false }
|
|
#
|
|
# == Multiple versions
|
|
#
|
|
# You can also create additional versions of your image, for example
|
|
# thumb-nails, like this:
|
|
# file_column :image, :magick => {:versions => {
|
|
# :thumb => {:size => "50x50"},
|
|
# :medium => {:size => "640x480>"}
|
|
# }
|
|
#
|
|
# These versions will be stored in separate sub-directories, named like the
|
|
# symbol you used to identify the version. So in the previous example, the
|
|
# image versions will be stored in "thumb", "screen" and "widescreen"
|
|
# directories, resp.
|
|
# A name different from the symbol can be set via the <tt>:name</tt> option.
|
|
#
|
|
# These versions can be accessed via FileColumnHelper's +url_for_image_column+
|
|
# method like this:
|
|
#
|
|
# <%= url_for_image_column "entry", "image", :thumb %>
|
|
#
|
|
# == Cropping images
|
|
#
|
|
# If you wish to crop your images with a size ratio before scaling
|
|
# them according to your version geometry, you can use the :crop directive.
|
|
# file_column :image, :magick => {:versions => {
|
|
# :square => {:crop => "1:1", :size => "50x50", :name => "thumb"},
|
|
# :screen => {:crop => "4:3", :size => "640x480>"},
|
|
# :widescreen => {:crop => "16:9", :size => "640x360!"},
|
|
# }
|
|
# }
|
|
#
|
|
# == Custom attributes
|
|
#
|
|
# To change some of the image properties like compression level before they
|
|
# are saved you can set the <tt>:attributes</tt> option.
|
|
# For a list of available attributes go to http://www.simplesystems.org/RMagick/doc/info.html
|
|
#
|
|
# file_column :image, :magick => { :attributes => { :quality => 30 } }
|
|
#
|
|
# == Custom transformations
|
|
#
|
|
# To perform custom transformations on uploaded images, you can pass a
|
|
# callback to file_column:
|
|
# file_column :image, :magick =>
|
|
# Proc.new { |image| image.quantize(256, Magick::GRAYColorspace) }
|
|
#
|
|
# The callback you give, receives one argument, which is an instance
|
|
# of Magick::Image, the RMagick image class. It should return a transformed
|
|
# image. Instead of passing a <tt>Proc</tt> object, you can also give a
|
|
# <tt>Symbol</tt>, the name of an instance method of your model.
|
|
#
|
|
# Custom transformations can be combined via the standard :size and :crop
|
|
# features, by using the :transformation option:
|
|
# file_column :image, :magick => {
|
|
# :transformation => Proc.new { |image| ... },
|
|
# :size => "640x480"
|
|
# }
|
|
#
|
|
# In this case, the standard resizing operations will be performed after the
|
|
# custom transformation.
|
|
#
|
|
# Of course, custom transformations can be used in versions, as well.
|
|
#
|
|
# <b>Note:</b> You'll need the
|
|
# RMagick extension being installed in order to use file_column's
|
|
# imagemagick integration.
|
|
module MagickExtension
|
|
|
|
def self.file_column(klass, attr, options) # :nodoc:
|
|
require 'RMagick'
|
|
options[:magick] = process_options(options[:magick],false) if options[:magick]
|
|
if options[:magick][:versions]
|
|
options[:magick][:versions].each_pair do |name, value|
|
|
options[:magick][:versions][name] = process_options(value, name.to_s)
|
|
end
|
|
end
|
|
state_method = "#{attr}_state".to_sym
|
|
after_assign_method = "#{attr}_magick_after_assign".to_sym
|
|
|
|
klass.send(:define_method, after_assign_method) do
|
|
self.send(state_method).transform_with_magick
|
|
end
|
|
|
|
options[:after_upload] ||= []
|
|
options[:after_upload] << after_assign_method
|
|
|
|
klass.validate do |record|
|
|
state = record.send(state_method)
|
|
if state.has_magick_errors?
|
|
state.magick_errors.each do |error|
|
|
record.errors.add attr, error
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
def self.process_options(options,create_name=true)
|
|
case options
|
|
when String then options = {:size => options}
|
|
when Proc, Symbol then options = {:transformation => options }
|
|
end
|
|
if options[:geometry]
|
|
options[:size] = options.delete(:geometry)
|
|
end
|
|
options[:image_required] = true unless options.key?(:image_required)
|
|
if options[:name].nil? and create_name
|
|
if create_name == true
|
|
hash = 0
|
|
for key in [:size, :crop]
|
|
hash = hash ^ options[key].hash if options[key]
|
|
end
|
|
options[:name] = hash.abs.to_s(36)
|
|
else
|
|
options[:name] = create_name
|
|
end
|
|
end
|
|
options
|
|
end
|
|
|
|
end
|
|
end
|