durran-carrierwave 0.3.2.3

data/lib/carrierwave/orm/activerecord.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'activerecord'
+
+module CarrierWave
+  module ActiveRecord
+
+    include CarrierWave::Mount
+    
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
+      super
+
+      alias_method :read_uploader, :read_attribute
+      alias_method :write_uploader, :write_attribute
+
+      validates_integrity_of column if uploader_options[column.to_sym][:validate_integrity]
+      validates_processing_of column if uploader_options[column.to_sym][:validate_processing]
+
+      after_save "store_#{column}!"
+      before_save "write_#{column}_identifier"
+      after_destroy "remove_#{column}!"
+    end
+
+    ##
+    # Makes the record invalid if the file couldn't be uploaded due to an integrity error
+    #
+    # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+    #
+    # === Note
+    #
+    # Set this key in your translations file for I18n:
+    #
+    #     carrierwave:
+    #       errors:
+    #         integrity: 'Here be an error message'
+    #
+    def validates_integrity_of(*attrs)
+      options = attrs.last.is_a?(Hash) ? attrs.last : {}
+      options[:message] ||= I18n.t('carrierwave.errors.integrity', :default => 'is not an allowed type of file.')
+      validates_each(*attrs) do |record, attr, value|
+        record.errors.add attr, options[:message] if record.send("#{attr}_integrity_error")
+      end
+    end
+
+    ##
+    # Makes the record invalid if the file couldn't be processed (assuming the process failed
+    # with a CarrierWave::ProcessingError)
+    #
+    # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+    #
+    # === Note
+    #
+    # Set this key in your translations file for I18n:
+    #
+    #     carrierwave:
+    #       errors:
+    #         processing: 'Here be an error message'
+    #
+    def validates_processing_of(*attrs)
+      options = attrs.last.is_a?(Hash) ? attrs.last : {}
+      options[:message] ||= I18n.t('carrierwave.errors.processing', :default => 'failed to be processed.')
+      validates_each(*attrs) do |record, attr, value|
+        record.errors.add attr, options[:message] if record.send("#{attr}_processing_error")
+      end
+    end
+
+  end # ActiveRecord
+end # CarrierWave
+
+ActiveRecord::Base.send(:extend, CarrierWave::ActiveRecord)

data/lib/carrierwave/orm/datamapper.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'dm-core'
+
+module CarrierWave
+  module DataMapper
+
+    include CarrierWave::Mount
+
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
+      super
+
+      alias_method :read_uploader, :attribute_get
+      alias_method :write_uploader, :attribute_set
+
+      after :save, "store_#{column}!".to_sym
+      before :save, "write_#{column}_identifier".to_sym
+      after :destroy, "remove_#{column}!".to_sym
+    end
+
+  end # DataMapper
+end # CarrierWave
+
+DataMapper::Model.send(:include, CarrierWave::DataMapper)

data/lib/carrierwave/orm/mongomapper.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'mongomapper'
+
+module CarrierWave
+  module MongoMapper
+    include CarrierWave::Mount
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
+      # We need to set the mount_on column (or key in MongoMapper's case)
+      # since MongoMapper will attempt to set the filename on 
+      # the uploader instead of the file on a Document's initialization.
+      options[:mount_on] ||= "#{column}_filename"
+      key options[:mount_on]
+      
+      super
+      alias_method :read_uploader, :[]
+      alias_method :write_uploader, :[]=
+      after_save "store_#{column}!".to_sym
+      before_save "write_#{column}_identifier".to_sym
+      after_destroy "remove_#{column}!".to_sym
+    end
+  end # MongoMapper
+end # CarrierWave
+
+MongoMapper::Document::ClassMethods.send(:include, CarrierWave::MongoMapper)

data/lib/carrierwave/orm/sequel.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'sequel'
+ 
+module CarrierWave
+  module Sequel
+    include CarrierWave::Mount
+ 
+    def mount_uploader(column, uploader)
+      super
+ 
+      alias_method :read_uploader, :[]
+      alias_method :write_uploader, :[]=
+ 
+      if CarrierWave::Sequel.new_sequel?
+        include CarrierWave::Sequel::Hooks
+        include CarrierWave::Sequel::Validations
+      else
+        after_save "store_#{column}!"
+        before_save "write_#{column}_identifier"
+        before_destroy "remove_#{column}!"
+      end
+    end
+ 
+    # Determine if we're using Sequel > 2.12
+    #
+    # ==== Returns
+    # Bool:: True if Sequel 2.12 or higher False otherwise
+    def self.new_sequel?
+      ::Sequel::Model.respond_to?(:plugin)
+    end
+  end # Sequel
+end # CarrierWave
+ 
+# Instance hook methods for the Sequel 3.x
+module CarrierWave::Sequel::Hooks
+  def after_save
+    return false if super == false
+    self.class.uploaders.each_key {|column| self.send("store_#{column}!") }
+  end
+
+  def before_save
+    return false if super == false
+    self.class.uploaders.each_key {|column| self.send("write_#{column}_identifier") }
+  end
+
+  def before_destroy
+    return false if super == false
+    self.class.uploaders.each_key {|column| self.send("remove_#{column}!") }
+  end
+end
+
+# Instance validation methods for the Sequel 3.x
+module CarrierWave::Sequel::Validations
+end
+
+Sequel::Model.send(:extend, CarrierWave::Sequel)

data/lib/carrierwave/processing/image_science.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require "image_science"
+
+module CarrierWave
+  module ImageScience
+
+    # 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.current_path) do |img|
+        width, height = extract_dimensions(img.width, img.height, geometry)
+        img.resize( width, height ) do |file|
+          file.save( self.current_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.current_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.current_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 # ImageScience
+end # CarrierWave

data/lib/carrierwave/processing/rmagick.rb

@@ -0,0 +1,286 @@
+# encoding: utf-8
+
+unless Module.const_defined?('Magick')
+  begin
+    require 'rmagick'
+  rescue LoadError
+    require 'RMagick'
+  end
+end
+
+module CarrierWave
+
+  ##
+  # This module simplifies manipulation with RMagick by providing a set
+  # of convenient helper methods. If you want to use them, you'll need to
+  # require this file:
+  #
+  #     require 'carrierwave/processing/rmagick'
+  #
+  # And then include it in your uploader:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::RMagick
+  #     end
+  #
+  # You can now use the provided helpers:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::RMagick
+  #
+  #       process :resize_to_fit => [200, 200]
+  #     end
+  #
+  # Or create your own helpers with the powerful manipulate! method. Check
+  # out the RMagick docs at http://www.imagemagick.org/RMagick/doc/ for more
+  # info
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::RMagick
+  #
+  #       process :do_stuff => 10.0
+  #
+  #       def do_stuff(blur_factor)
+  #         manipulate! do |img|
+  #           img = img.sepiatone
+  #           img = img.auto_orient
+  #           img = img.radial_blur(blur_factor)
+  #         end
+  #       end
+  #     end
+  #
+  # === Note
+  #
+  # You should be aware how RMagick handles memory. manipulate! takes care
+  # of freeing up memory for you, but for optimum memory usage you should
+  # use destructive operations as much as possible:
+  #
+  # DON'T DO THIS:
+  #     img = img.resize_to_fit
+  #
+  # DO THIS INSTEAD:
+  #     img.resize_to_fit!
+  #
+  # Read this for more information why:
+  #
+  # http://rubyforge.org/forum/forum.php?thread_id=1374&forum_id=1618
+  #
+  module RMagick
+
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def convert(format)
+        process :resize_to_limit => format
+      end
+
+      def resize_to_limit(width, height)
+        process :resize_to_limit => [width, height]
+      end
+
+      def resize_to_fit(width, height)
+        process :resize_to_fit => [width, height]
+      end
+
+      def resize_to_fill(width, height)
+        process :resize_to_fill => [width, height]
+      end
+
+      def resize_and_pad(width, height)
+        process :resize_to_fit => [width, height]
+      end
+
+      def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity)
+        process :resize_and_pad => [width, height, background, gravity]
+      end
+    end
+
+    ##
+    # Changes the image encoding format to the given format
+    #
+    # See even http://www.imagemagick.org/RMagick/doc/magick.html#formats
+    #
+    # === Parameters
+    #
+    # [format (#to_s)] an abreviation of the format
+    #
+    # === Yields
+    #
+    # [Magick::Image] additional manipulations to perform
+    #
+    # === Examples
+    #
+    #     image.convert(:png)
+    #
+    def convert(format)
+      manipulate! do |img|
+        img.format = format.to_s.upcase
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    ##
+    # Resize the image to fit within the specified dimensions while retaining
+    # the original aspect ratio. Will only resize the image if it is larger than the
+    # specified dimensions. The resulting image may be shorter or narrower than specified
+    # in the smaller dimension but will not be larger than the specified values.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    #
+    # === Yields
+    #
+    # [Magick::Image] additional manipulations to perform
+    #
+    def resize_to_limit(width, height)
+      manipulate! do |img|
+        geometry = Magick::Geometry.new(width, height, 0, 0, Magick::GreaterGeometry)
+        new_img = img.change_geometry(geometry) do |new_width, new_height|
+          img.resize(new_width, new_height)
+        end
+        destroy_image(img)
+        new_img = yield(new_img) if block_given?
+        new_img
+      end
+    end
+
+    ##
+    # From the RMagick documentation: "Resize the image to fit within the
+    # specified dimensions while retaining the original aspect ratio. The
+    # image may be shorter or narrower than specified in the smaller dimension
+    # but will not be larger than the specified values."
+    #
+    # See even http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fit
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    #
+    # === Yields
+    #
+    # [Magick::Image] additional manipulations to perform
+    #
+    def resize_to_fit(width, height)
+      manipulate! do |img|
+        img.resize_to_fit!(width, height)
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    alias_method :resize, :resize_to_fit
+
+    ##
+    # From the RMagick documentation: "Resize the image to fit within the
+    # specified dimensions while retaining the aspect ratio of the original
+    # image. If necessary, crop the image in the larger dimension."
+    #
+    # See even http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fill
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    #
+    # === Yields
+    #
+    # [Magick::Image] additional manipulations to perform
+    #
+    def resize_to_fill(width, height)
+      manipulate! do |img|
+        img.resize_to_fill!(width, height)
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    alias_method :crop_resized, :resize_to_fill
+
+    ##
+    # Resize the image to fit within the specified dimensions while retaining
+    # the original aspect ratio. If necessary, will pad the remaining area
+    # with the given color, which defaults to transparent (for gif and png,
+    # white for jpeg).
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    # [background (String, :transparent)] the color of the background as a hexcode, like "#ff45de"
+    # [gravity (Magick::GravityType)] how to position the image
+    #
+    # === Yields
+    #
+    # [Magick::Image] additional manipulations to perform
+    #
+    def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity)
+      manipulate! do |img|
+        img.resize_to_fit!(width, height)
+        new_img = ::Magick::Image.new(width, height)
+        if background == :transparent
+          filled = new_img.matte_floodfill(1, 1)
+        else
+          filled = new_img.color_floodfill(1, 1, ::Magick::Pixel.from_color(background))
+        end
+        destroy_image(new_img)
+        filled.composite!(img, gravity, ::Magick::OverCompositeOp)
+        destroy_image(img)
+        filled = yield(filled) if block_given?
+        filled
+      end
+    end
+
+    ##
+    # Manipulate the image with RMagick. This method will load up an image
+    # and then pass each of its frames to the supplied block. It will then
+    # save the image to disk.
+    #
+    # === Gotcha
+    #
+    # This method assumes that the object responds to +current_path+.
+    # Any class that this module is mixed into must have a +current_path+ method.
+    # CarrierWave::Uploader does, so you won't need to worry about this in
+    # most cases.
+    #
+    # === Yields
+    #
+    # [Magick::Image] manipulations to perform
+    #
+    # === Raises
+    #
+    # [CarrierWave::ProcessingError] if manipulation failed.
+    #
+    def manipulate!
+      image = ::Magick::Image.read(current_path)
+
+      if image.size > 1
+        list = ::Magick::ImageList.new
+        image.each do |frame|
+          list << yield( frame )
+        end
+        list.write(current_path)
+        destroy_image(list)
+      else
+        frame = image.first
+        yield( frame ).write(current_path)
+        destroy_image(frame)
+      end
+    rescue ::Magick::ImageMagickError => e
+      raise CarrierWave::ProcessingError.new("Failed to manipulate with rmagick, maybe it is not an image? Original Error: #{e}")
+    end
+
+  private
+  
+    def destroy_image(image)
+      image.destroy! if image.respond_to?(:destroy!)
+    end
+
+  end # RMagick
+end # CarrierWave