carrierwave-pressplane 0.5.8.3

data/lib/carrierwave/orm/activerecord.rb

@@ -0,0 +1,46 @@
+# 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=nil, 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}!"
+      before_update :"store_previous_model_for_#{column}"
+      after_save :"remove_previously_stored_#{column}"
+
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}=(new_file)
+          column = _mounter(:#{column}).serialization_column
+          send(:"\#{column}_will_change!")
+          super
+        end
+      RUBY
+
+    end
+
+  end # ActiveRecord
+end # CarrierWave
+
+ActiveRecord::Base.extend CarrierWave::ActiveRecord

data/lib/carrierwave/processing/mime_types.rb

@@ -0,0 +1,58 @@
+require 'mime/types'
+
+module CarrierWave
+
+  ##
+  # This module simplifies the use of the mime-types gem to intelligently
+  # guess and set the content-type of a file. If you want to use this, you'll
+  # need to require this file:
+  #
+  #     require 'carrierwave/processing/mime_types'
+  #
+  # And then include it in your uploader:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::MimeTypes
+  #     end
+  #
+  # You can now use the provided helper:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::MimeTypes
+  #
+  #       process :set_content_type
+  #     end
+  #
+  module MimeTypes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def set_content_type(override=false)
+        process :set_content_type => override
+      end
+    end
+
+    ##
+    # Changes the file content_type using the mime-types gem
+    #
+    # === Parameters
+    #
+    # [override (Boolean)] whether or not to override the file's content_type
+    #                      if it is already set and not a generic content-type,
+    #                      false by default
+    #
+    def set_content_type(override=false)
+      if override || file.content_type.blank? || file.content_type == 'application/octet-stream'
+        new_content_type = ::MIME::Types.type_for(file.original_filename).first.to_s
+        if file.respond_to?(:content_type=)
+          file.content_type = new_content_type
+        else
+          file.set_instance_variable(:@content_type, new_content_type)
+        end
+      end
+    rescue ::MIME::InvalidContentType => e
+      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.mime_types_processing_error", :e => e)
+    end
+
+  end # MimeTypes
+end # CarrierWave

data/lib/carrierwave/processing/mini_magick.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+require 'mini_magick'
+
+module CarrierWave
+
+  ##
+  # This module simplifies manipulation with MiniMagick by providing a set
+  # of convenient helper methods. If you want to use them, you'll need to
+  # require this file:
+  #
+  #     require 'carrierwave/processing/mini_magick'
+  #
+  # And then include it in your uploader:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::MiniMagick
+  #     end
+  #
+  # You can now use the provided helpers:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::MiniMagick
+  #
+  #       process :resize_to_fit => [200, 200]
+  #     end
+  #
+  # Or create your own helpers with the powerful manipulate! method. Check
+  # out the ImageMagick docs at http://www.imagemagick.org/script/command-line-options.php for more
+  # info
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::MiniMagick
+  #
+  #       process :radial_blur => 10
+  #
+  #       def radial_blur(amount)
+  #         manipulate! do |img|
+  #           img.radial_blur(amount)
+  #           img = yield(img) if block_given?
+  #           img
+  #         end
+  #       end
+  #
+  # === Note
+  #
+  # MiniMagick is a mini replacement for RMagick that uses the command line
+  # tool "mogrify" for image manipulation.
+  #
+  # You can find more information here:
+  #
+  # http://mini_magick.rubyforge.org/
+  # and
+  # http://github.com/probablycorey/mini_magick/
+  #
+  #
+  module MiniMagick
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def convert(format)
+        process :convert => 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, 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 http://www.imagemagick.org/script/command-line-options.php#format
+    #
+    # === Parameters
+    #
+    # [format (#to_s)] an abreviation of the format
+    #
+    # === Yields
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    # === Examples
+    #
+    #     image.convert(:png)
+    #
+    def convert(format)
+      manipulate! do |img|
+        img.format(format.to_s.downcase)
+        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
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    def resize_to_limit(width, height)
+      manipulate! do |img|
+        img.resize "#{width}x#{height}>"
+        img = yield(img) if block_given?
+        img
+      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.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    #
+    # === Yields
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    def resize_to_fit(width, height)
+      manipulate! do |img|
+        img.resize "#{width}x#{height}"
+        img = yield(img) if block_given?
+        img
+      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.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    #
+    # === Yields
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    def resize_to_fill(width, height, gravity = 'Center')
+      manipulate! do |img|
+        cols, rows = img[:dimensions]
+        img.combine_options do |cmd|
+          if width != cols || height != rows
+            scale = [width/cols.to_f, height/rows.to_f].max
+            cols = (scale * (cols + 0.5)).round
+            rows = (scale * (rows + 0.5)).round
+            cmd.resize "#{cols}x#{rows}"
+          end
+          cmd.gravity gravity
+          cmd.extent "#{width}x#{height}" if cols != width || rows != height
+        end
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    ##
+    # 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).
+    #
+    # See http://www.imagemagick.org/script/command-line-options.php#gravity
+    # for gravity options.
+    #
+    # === 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 (String)] how to position the image
+    #
+    # === Yields
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    def resize_and_pad(width, height, background=:transparent, gravity='Center')
+      manipulate! do |img|
+        img.combine_options do |cmd|
+          cmd.thumbnail "#{width}x#{height}>"
+          if background == :transparent
+            cmd.background "rgba(0, 0, 0, 0.0)"
+          else
+            cmd.background background
+          end
+          cmd.gravity gravity
+          cmd.extent "#{width}x#{height}"
+        end
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    ##
+    # Manipulate the image with MiniMagick. 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
+    #
+    # [MiniMagick::Image] manipulations to perform
+    #
+    # === Raises
+    #
+    # [CarrierWave::ProcessingError] if manipulation failed.
+    #
+    def manipulate!
+      cache_stored_file! if !cached?
+      image = ::MiniMagick::Image.open(current_path)
+      image = yield(image)
+      image.write(current_path)
+      ::MiniMagick::Image.open(current_path)
+    rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
+      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e)
+    end
+
+  end # MiniMagick
+end # CarrierWave

data/lib/carrierwave/processing/rmagick.rb

@@ -0,0 +1,279 @@
+# encoding: utf-8
+
+unless defined? Magick
+  begin
+    require 'rmagick'
+  rescue LoadError
+    require 'RMagick'
+  rescue LoadError
+    puts "WARNING: Failed to require rmagick, image processing may fail!"
+  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
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def convert(format)
+        process :convert => 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, gravity=::Magick::CenterGravity)
+        process :resize_to_fill => [width, height, gravity]
+      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!(:format => format)
+    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
+
+    ##
+    # 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, gravity=::Magick::CenterGravity)
+      manipulate! do |img|
+        img.crop_resized!(width, height, gravity)
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    ##
+    # 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!(options={})
+      cache_stored_file! if !cached?
+      image = ::Magick::Image.read(current_path)
+
+      frames = if image.size > 1
+        list = ::Magick::ImageList.new
+        image.each do |frame|
+          list << yield( frame )
+        end
+        list
+      else
+        frame = image.first
+        frame = yield( frame ) if block_given?
+        frame
+      end
+
+      if options[:format]
+        frames.write("#{options[:format]}:#{current_path}")
+      else
+        frames.write(current_path)
+      end
+      destroy_image(frames)
+    rescue ::Magick::ImageMagickError => e
+      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.rmagick_processing_error", :e => e)
+    end
+
+  private
+
+    def destroy_image(image)
+      image.destroy! if image.respond_to?(:destroy!)
+    end
+
+  end # RMagick
+end # CarrierWave