locomotive_carrierwave 0.5.0.1.beta1

data/lib/carrierwave/mount.rb

@@ -0,0 +1,376 @@
+# encoding: utf-8
+
+module CarrierWave
+
+  ##
+  # If a Class is extended with this module, it gains the mount_uploader
+  # method, which is used for mapping attributes to uploaders and allowing
+  # easy assignment.
+  #
+  # You can use mount_uploader with pretty much any class, however it is
+  # intended to be used with some kind of persistent storage, like an ORM.
+  # If you want to persist the uploaded files in a particular Class, it
+  # needs to implement a `read_uploader` and a `write_uploader` method.
+  #
+  module Mount
+
+    ##
+    # === Returns
+    #
+    # [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns
+    #
+    def uploaders
+      @uploaders ||= {}
+      @uploaders = superclass.uploaders.merge(@uploaders)
+    rescue NoMethodError
+      @uploaders
+    end
+
+    def uploader_options
+      @uploader_options ||= {}
+      @uploader_options = superclass.uploader_options.merge(@uploader_options)
+    rescue NoMethodError
+      @uploader_options
+    end
+
+    ##
+    # Return a particular option for a particular uploader
+    #
+    # === Parameters
+    #
+    # [column (Symbol)] The column the uploader is mounted at
+    # [option (Symbol)] The option, e.g. validate_integrity
+    #
+    # === Returns
+    #
+    # [Object] The option value
+    #
+    def uploader_option(column, option)
+      if uploader_options[column].has_key?(option)
+        uploader_options[column][option]
+      else
+        uploaders[column].send(option)
+      end
+    end
+
+    ##
+    # Mounts the given uploader on the given column. This means that assigning
+    # and reading from the column will upload and retrieve files. Supposing
+    # that a User class has an uploader mounted on image, you can assign and
+    # retrieve files like this:
+    #
+    #     @user.image # => <Uploader>
+    #     @user.image = some_file_object
+    #
+    #     @user.store_image!
+    #
+    #     @user.image.url # => '/some_url.png'
+    #
+    # It is also possible (but not recommended) to ommit the uploader, which
+    # will create an anonymous uploader class. Passing a block to this method
+    # makes it possible to customize it. This can be convenient for brevity,
+    # but if there is any significatnt logic in the uploader, you should do
+    # the right thing and have it in its own file.
+    #
+    # === Added instance methods
+    #
+    # Supposing a class has used +mount_uploader+ to mount an uploader on a column
+    # named +image+, in that case the following methods will be added to the class:
+    #
+    # [image]                   Returns an instance of the uploader only if anything has been uploaded
+    # [image=]                  Caches the given file
+    #
+    # [image_url]               Returns the url to the uploaded file
+    #
+    # [image_cache]             Returns a string that identifies the cache location of the file
+    # [image_cache=]            Retrieves the file from the cache based on the given cache name
+    #
+    # [remote_image_url]        Returns previously cached remote url
+    # [remote_image_url=]       Retrieve the file from the remote url
+    #
+    # [remove_image]            An attribute reader that can be used with a checkbox to mark a file for removal
+    # [remove_image=]           An attribute writer that can be used with a checkbox to mark a file for removal
+    # [remove_image?]           Whether the file should be removed when store_image! is called.
+    #
+    # [store_image!]            Stores a file that has been assigned with +image=+
+    # [remove_image!]           Removes the uploaded file from the filesystem.
+    #
+    # [image_integrity_error]   Returns an error object if the last file to be assigned caused an integrity error
+    # [image_processing_error]  Returns an error object if the last file to be assigned caused a processing error
+    #
+    # [write_image_identifier]  Uses the write_uploader method to set the identifier.
+    #
+    # === Parameters
+    #
+    # [column (Symbol)]                   the attribute to mount this uploader on
+    # [uploader (CarrierWave::Uploader)]  the uploader class to mount
+    # [options (Hash{Symbol => Object})]  a set of options
+    # [&block (Proc)]                     customize anonymous uploaders
+    #
+    # === Options
+    #
+    # [:mount_on => Symbol] if the name of the column to be serialized to differs you can override it using this option
+    # [:ignore_integrity_errors => Boolean] if set to true, integrity errors will result in caching failing silently
+    # [:ignore_processing_errors => Boolean] if set to true, processing errors will result in caching failing silently
+    #
+    # === Examples
+    #
+    # Mounting uploaders on different columns.
+    #
+    #     class Song
+    #       mount_uploader :lyrics, LyricsUploader
+    #       mount_uploader :alternative_lyrics, LyricsUploader
+    #       mount_uploader :file, SongUploader
+    #     end
+    #
+    # This will add an anonymous uploader with only the default settings:
+    #
+    #     class Data
+    #       mount_uploader :csv
+    #     end
+    #
+    # this will add an anonymous uploader overriding the store_dir:
+    #
+    #     class Product
+    #       mount_uploader :blueprint do
+    #         def store_dir
+    #           'blueprints'
+    #         end
+    #       end
+    #     end
+    #
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      unless uploader
+        uploader = Class.new(CarrierWave::Uploader::Base)
+        uploader.class_eval(&block)
+      end
+
+      uploaders[column.to_sym] = uploader
+      uploader_options[column.to_sym] = options
+
+      include CarrierWave::Mount::Extension
+
+      # Make sure to write over accessors directly defined on the class.
+      # Simply super to the included module below.
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}; super; end
+        def #{column}=(new_file); super; end
+      RUBY
+
+      # Mixing this in as a Module instead of class_evaling directly, so we
+      # can maintain the ability to super to any of these methods from within
+      # the class.
+      mod = Module.new
+      include mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+
+        def #{column}
+          _mounter(:#{column}).uploader
+        end
+
+        def #{column}=(new_file)
+          _mounter(:#{column}).cache(new_file)
+        end
+
+        def #{column}?
+          !_mounter(:#{column}).blank?
+        end
+
+        def #{column}_url(*args)
+          _mounter(:#{column}).url(*args)
+        end
+
+        def #{column}_cache
+          _mounter(:#{column}).cache_name
+        end
+
+        def #{column}_cache=(cache_name)
+          _mounter(:#{column}).cache_name = cache_name
+        end
+
+        def remote_#{column}_url
+          _mounter(:#{column}).remote_url
+        end
+
+        def remote_#{column}_url=(url)
+          _mounter(:#{column}).remote_url = url
+        end
+
+        def remove_#{column}
+          _mounter(:#{column}).remove
+        end
+
+        def remove_#{column}!
+          _mounter(:#{column}).remove!
+        end
+
+        def remove_#{column}=(value)
+          _mounter(:#{column}).remove = value
+        end
+
+        def remove_#{column}?
+          _mounter(:#{column}).remove?
+        end
+
+        def store_#{column}!
+          _mounter(:#{column}).store!
+        end
+
+        def #{column}_integrity_error
+          _mounter(:#{column}).integrity_error
+        end
+
+        def #{column}_processing_error
+          _mounter(:#{column}).processing_error
+        end
+
+        def write_#{column}_identifier
+          _mounter(:#{column}).write_identifier
+        end
+
+        def check_stale_#{column}!
+          _mounter(:#{column}).check_stale_record!
+        end
+
+        def rename_#{column}!
+          _mounter(:#{column}).rename!
+        end
+
+      RUBY
+
+    end
+
+    module Extension
+
+      ##
+      # overwrite this to read from a serialized attribute
+      #
+      def read_uploader(column); end
+
+      ##
+      # overwrite this to write to a serialized attribute
+      #
+      def write_uploader(column, identifier); end
+
+    private
+
+      def _mounter(column)
+        # We cannot memoize in frozen objects :(
+        return Mounter.new(self, column) if frozen?
+        @_mounters ||= {}
+        @_mounters[column] ||= Mounter.new(self, column)
+      end
+
+    end # Extension
+
+    # this is an internal class, used by CarrierWave::Mount so that
+    # we don't pollute the model with a lot of methods.
+    class Mounter #:nodoc:
+
+      attr_reader :column, :record, :remote_url, :integrity_error, :processing_error
+      attr_accessor :remove
+
+      def initialize(record, column, options={})
+        @record = record
+        @column = column
+        @options = record.class.uploader_options[column]
+      end
+
+      def write_identifier
+        if remove?
+          record.write_uploader(serialization_column, '')
+        elsif not uploader.identifier.blank?
+          record.write_uploader(serialization_column, uploader.identifier)
+        end
+      end
+
+      def identifier
+        record.read_uploader(serialization_column)
+      end
+
+      def uploader
+        @uploader ||= record.class.uploaders[column].new(record, column)
+
+        if @uploader.blank? and not identifier.blank?
+          @uploader.retrieve_from_store!(identifier)
+        end
+        return @uploader
+      end
+
+      def cache(new_file)
+        uploader.cache!(new_file)
+        @integrity_error = nil
+        @processing_error = nil
+      rescue CarrierWave::IntegrityError => e
+        @integrity_error = e
+        raise e unless option(:ignore_integrity_errors)
+      rescue CarrierWave::ProcessingError => e
+        @processing_error = e
+        raise e unless option(:ignore_processing_errors)
+      end
+
+      def cache_name
+        uploader.cache_name
+      end
+
+      def cache_name=(cache_name)
+        uploader.retrieve_from_cache!(cache_name) unless uploader.cached?
+      rescue CarrierWave::InvalidParameter
+      end
+
+      def remote_url=(url)
+        unless uploader.cached?
+          @remote_url = url
+          uploader.download!(url)
+        end
+      end
+
+      def store!
+        unless uploader.blank?
+          if remove?
+            uploader.remove!
+          else
+            uploader.store!
+          end
+        end
+      end
+
+      def url(*args)
+        uploader.url(*args)
+      end
+
+      def blank?
+        uploader.blank?
+      end
+
+      def remove?
+        !remove.blank? and remove !~ /\A0|false$\z/
+      end
+
+      def remove!
+        uploader.remove!
+      end
+
+      def rename!
+        uploader.rename!
+      end
+
+      def check_stale_record!
+        uploader.send(:check_stale_model!)
+        true
+      end
+
+    private
+
+      def option(name)
+        record.class.uploader_option(column, name)
+      end
+
+      def serialization_column
+        option(:mount_on) || column
+      end
+
+    end # Mounter
+
+  end # Mount
+end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'active_record'
+require 'carrierwave/validations/active_model'
+
+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
+      public :read_uploader
+      public :write_uploader
+
+      include CarrierWave::Validations::ActiveModel
+
+      validates_integrity_of column if uploader_option(column.to_sym, :validate_integrity)
+      validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+
+      after_save "store_#{column}!"
+      before_save "write_#{column}_identifier"
+      after_destroy "remove_#{column}!"
+
+    end
+
+  end # ActiveRecord
+end # CarrierWave
+
+ActiveRecord::Base.extend CarrierWave::ActiveRecord

data/lib/carrierwave/orm/datamapper.rb

@@ -0,0 +1,37 @@
+# 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
+      pre_hook = ::DataMapper.const_defined?(:Validate) ? :valid? : :save
+      before pre_hook, "write_#{column}_identifier".to_sym
+      after :destroy, "remove_#{column}!".to_sym
+
+      # FIXME: Hack to work around Datamapper not triggering callbacks
+      # for objects that are not dirty. By explicitly calling
+      # attribute_set we are marking the record as dirty.
+      class_eval <<-RUBY
+        def remove_image=(value)
+          _mounter(:#{column}).remove = value
+          attribute_set(:#{column}, '') if _mounter(:#{column}).remove?
+        end
+      RUBY
+    end
+
+  end # DataMapper
+end # CarrierWave
+
+DataMapper::Model.send(:include, CarrierWave::DataMapper)

data/lib/carrierwave/orm/mongoid.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'mongoid'
+require 'carrierwave/validations/active_model'
+
+module CarrierWave
+  module Mongoid
+    include CarrierWave::Mount
+
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
+      options[:mount_on] ||= "#{column}_filename"
+      field options[:mount_on]
+
+      super
+
+      alias_method :read_uploader, :read_attribute
+      alias_method :write_uploader, :write_attribute
+
+      include CarrierWave::Validations::ActiveModel
+
+      validates_integrity_of  column if uploader_option(column.to_sym, :validate_integrity)
+      validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+
+      before_save "check_stale_#{column}!".to_sym
+      after_save "rename_#{column}!".to_sym
+      after_save "store_#{column}!".to_sym
+      before_save "write_#{column}_identifier".to_sym
+      after_destroy "remove_#{column}!".to_sym
+    end
+  end # Mongoid
+end # CarrierWave
+
+Mongoid::Document::ClassMethods.send(:include, CarrierWave::Mongoid)

data/lib/carrierwave/orm/sequel.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'sequel'
+ 
+module CarrierWave
+  module Sequel
+    include CarrierWave::Mount
+ 
+    def mount_uploader(column, uploader)
+      raise "You need to use Sequel 3.0 or higher. Please upgrade." unless ::Sequel::Model.respond_to?(:plugin)
+      super
+ 
+      alias_method :read_uploader, :[]
+      alias_method :write_uploader, :[]=
+ 
+      include CarrierWave::Sequel::Hooks
+      include CarrierWave::Sequel::Validations
+    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,116 @@
+# encoding: utf-8
+
+require "image_science"
+
+module CarrierWave
+  module ImageScience
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      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
+    end
+
+    ##
+    # 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
+    #
+    def resize_to_fit(new_width, new_height)
+      ::ImageScience.with_image(self.current_path) do |img|
+        width, height = extract_dimensions(img.width, img.height, new_width, new_height)
+        img.resize( width, height ) do |file|
+          file.save( self.current_path )
+        end
+      end
+    end
+
+    ##
+    # 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
+    #
+    def resize_to_fill(new_width, new_height)
+      ::ImageScience.with_image(self.current_path) do |img|
+        width, height = extract_dimensions_for_crop(img.width, img.height, new_width, new_height)
+        x_offset, y_offset = extract_placement_for_crop(width, height, new_width, new_height)
+
+        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
+    
+    ##
+    # 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
+    #
+    def resize_to_limit(new_width, new_height)
+      ::ImageScience.with_image(self.current_path) do |img|
+        if img.width > new_width or img.height > new_height
+          resize_to_fit(new_width, new_height)
+        end
+      end
+    end
+
+  private
+
+    def extract_dimensions(width, height, new_width, new_height, type = :resize)
+      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_width, new_height)
+      extract_dimensions(width, height, new_width, new_height, :crop)
+    end
+
+    def extract_placement_for_crop(width, height, new_width, new_height)
+      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
+
+  end # ImageScience
+end # CarrierWave