image_processing 0.9.0 → 0.10.0

data/lib/image_processing/mini_magick/deprecated_api.rb

@@ -0,0 +1,119 @@
+require "tempfile"
+require "fileutils"
+
+module ImageProcessing
+  module MiniMagick
+    module DeprecatedApi
+      def self.included(base)
+        base.extend(self)
+      end
+
+      def self.deprecated_processing_method(name, &body)
+        define_method(name) do |*args, &block|
+          return ImageProcessing::MiniMagick.send(name, *args, &block) if self != ImageProcessing::MiniMagick
+          return super(*args, &block) unless args.first.respond_to?(:read)
+
+          warn "[IMAGE_PROCESSING DEPRECATION WARNING] This API is deprecated and will be removed in ImageProcessing 1.0. Please use the new chainable API."
+
+          file = args.shift
+
+          if file.respond_to?(:path)
+            instance_exec(file, *args, block, &body)
+          else
+            Utils.copy_to_tempfile(file) do |tempfile|
+              send(name, tempfile, *args, &block)
+            end
+          end
+        end
+
+        define_method("#{name}!") do |*args, &block|
+          return ImageProcessing::MiniMagick.send(name, *args, &block) if self != ImageProcessing::MiniMagick
+          return super(*args, &block) unless args.first.respond_to?(:read)
+
+          processed = send(name, *args, &block)
+          source    = args.first
+
+          if name == :convert
+            File.delete(source.path)
+          else
+            processed.close
+            FileUtils.mv processed.path, source.path
+            source.open if source.is_a?(Tempfile)
+          end
+
+          source
+        end
+      end
+
+      deprecated_processing_method :resize_to_limit do |file, *args, block|
+        source(file)
+          .custom(&block)
+          .resize_to_limit!(*args)
+      end
+
+      deprecated_processing_method :resize_to_fit do |file, *args, block|
+        source(file)
+          .custom(&block)
+          .resize_to_fit!(*args)
+      end
+
+      deprecated_processing_method :resize_to_fill do |file, *args, block|
+        source(file)
+          .custom(&block)
+          .resize_to_fill!(*args)
+      end
+
+      deprecated_processing_method :resize_and_pad do |file, *args, block|
+        source(file)
+          .custom(&block)
+          .resize_and_pad!(*args)
+      end
+
+      deprecated_processing_method :convert do |file, format, page = nil, block|
+        source(file, page: page)
+          .custom(&block)
+          .convert!(format)
+      end
+
+      deprecated_processing_method :auto_orient do |file, *args, block|
+        source(file)
+          .custom(&block)
+          .auto_orient!(*args)
+      end
+
+      deprecated_processing_method :resample do |file, width, height, block|
+        source(file)
+          .custom(&block)
+          .resample!("#{width}x#{height}")
+      end
+
+      deprecated_processing_method :crop do |file, width, height, x_offset, y_offset, block|
+        source(file)
+          .custom(&block)
+          .crop!("#{width}x#{height}+#{x_offset}+#{y_offset}")
+      end
+
+      deprecated_processing_method :corrupted? do |file, block|
+        valid_image?(file)
+      end
+
+      module Utils
+        module_function
+
+        def copy_to_tempfile(io)
+          extension = File.extname(io.path) if io.respond_to?(:path)
+          tempfile  = Tempfile.new(["image_processing", extension.to_s], binmode: true)
+
+          IO.copy_stream(io, tempfile)
+
+          io.rewind
+          tempfile.open # refresh content
+
+          yield tempfile
+        ensure
+          tempfile.close! if tempfile
+        end
+      end
+    end
+  end
+end

data/lib/image_processing/mini_magick.rb

@@ -1,236 +1,90 @@
-require "image_processing/version"
+gem "mini_magick", "~> 4.0"
 require "mini_magick"
-require "tempfile"
 
-if !MiniMagick.respond_to?(:version) || MiniMagick.version < Gem::Version.new("4.3.5")
-  raise "image_processing requires mini_magick version >= 4.3.5"
-end
+require "image_processing"
+require "image_processing/mini_magick/deprecated_api"
 
 module ImageProcessing
   module MiniMagick
-    def self.nondestructive_alias(name, original)
-      define_method(name) do |image, *args, &block|
-        send(original, _copy_to_tempfile(image), *args, &block)
+    def self.valid_image?(file)
+      ::MiniMagick::Tool::Convert.new do |convert|
+        convert.regard_warnings
+        convert << file.path
+        convert << "null:"
       end
-      module_function name
+      true
+    rescue ::MiniMagick::Error
+      false
     end
 
-    module_function
-
-    # Changes the image encoding format to the given format
-    #
-    # @see http://www.imagemagick.org/script/command-line-options.php#format
-    # @param [MiniMagick::Image] image    the image to convert
-    # @param [String] format              the format to convert to
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    def convert!(image, format, page = nil, &block)
-      with_minimagick(image) do |img|
-        img.format(format.downcase, page, &block)
-      end
-    end
-    nondestructive_alias :convert, :convert!
-
-    # Adjusts the image so that its orientation is suitable for viewing.
-    #
-    # @see http://www.imagemagick.org/script/command-line-options.php#auto-orient
-    # @param [MiniMagick::Image] image    the image to convert
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    def auto_orient!(image)
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.auto_orient
+    class Processor
+      IMAGE_CLASS = ::MiniMagick::Tool
+      TRANSPARENT = "rgba(255,255,255,0.0)"
+
+      def apply_operation(name, magick, *args)
+        if respond_to?(name)
+          public_send(name, magick, *args)
+        else
+          magick.send(name, *args)
         end
       end
-    end
-    nondestructive_alias :auto_orient, :auto_orient!
-
-    # 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 either dimension but will not be larger than
-    # the specified values.
-    #
-    # @param [MiniMagick::Image] image    the image to convert
-    # @param [#to_s] width                the maximum width
-    # @param [#to_s] height               the maximum height
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    def resize_to_limit!(image, width, height)
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.resize "#{width}x#{height}>"
-        end
+
+      def resize_to_limit(magick, width, height)
+        magick.resize "#{width}x#{height}>"
       end
-    end
-    nondestructive_alias :resize_to_limit, :resize_to_limit!
-
-    # 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.
-    #
-    # @param [MiniMagick::Image] image    the image to convert
-    # @param [#to_s] width                the width to fit into
-    # @param [#to_s] height               the height to fit into
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    def resize_to_fit!(image, width, height)
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.resize "#{width}x#{height}"
-        end
+
+      def resize_to_fit(magick, width, height)
+        magick.resize "#{width}x#{height}"
       end
-    end
-    nondestructive_alias :resize_to_fit, :resize_to_fit!
-
-    # Resize the image so that it is at least as large in both dimensions as
-    # specified, then crops any excess outside the specified dimensions.
-    #
-    # The resulting image will always be exactly as large as the specified
-    # dimensions.
-    #
-    # By default, the center part of the image is kept, and the remainder
-    # cropped off, but this can be changed via the `gravity` option.
-    #
-    # @param [MiniMagick::Image] image    the image to convert
-    # @param [#to_s] width                the width to fill out
-    # @param [#to_s] height               the height to fill out
-    # @param [String] gravity             which part of the image to focus on
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    # @see http://www.imagemagick.org/script/command-line-options.php#gravity
-    def resize_to_fill!(image, width, height, gravity: "Center")
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.resize "#{width}x#{height}^"
-          cmd.gravity gravity
-          cmd.background "rgba(255,255,255,0.0)" # transparent
-          cmd.extent "#{width}x#{height}"
-        end
+
+      def resize_to_fill(magick, width, height, gravity: "Center")
+        magick.resize "#{width}x#{height}^"
+        magick.gravity gravity
+        magick.background TRANSPARENT
+        magick.extent "#{width}x#{height}"
       end
-    end
-    nondestructive_alias :resize_to_fill, :resize_to_fill!
-
-    # Resize the image to fit within the specified dimensions while retaining
-    # the original aspect ratio in the same way as {#fill}. Unlike {#fill} it
-    # will, if necessary, pad the remaining area with the given color, which
-    # defaults to transparent where supported by the image format and white
-    # otherwise.
-    #
-    # The resulting image will always be exactly as large as the specified
-    # dimensions.
-    #
-    # By default, the image will be placed in the center but this can be
-    # changed via the `gravity` option.
-    #
-    # @param [MiniMagick::image] image    the image to convert
-    # @param [#to_s] width                the width to fill out
-    # @param [#to_s] height               the height to fill out
-    # @param [string] background          the color to use as a background
-    # @param [string] gravity             which part of the image to focus on
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    # @see http://www.imagemagick.org/script/color.php
-    # @see http://www.imagemagick.org/script/command-line-options.php#gravity
-    def resize_and_pad!(image, width, height, background: "transparent", gravity: "Center")
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.resize "#{width}x#{height}"
-          if background == "transparent"
-            cmd.background "rgba(255, 255, 255, 0.0)"
-          else
-            cmd.background background
-          end
-          cmd.gravity gravity
-          cmd.extent "#{width}x#{height}"
-        end
+
+      def resize_and_pad(magick, width, height, background: TRANSPARENT, gravity: "Center")
+        background = TRANSPARENT if background == "transparent"
+
+        magick.resize "#{width}x#{height}"
+        magick.background background
+        magick.gravity gravity
+        magick.extent "#{width}x#{height}"
       end
-    end
-    nondestructive_alias :resize_and_pad, :resize_and_pad!
-
-    # Resample the image to fit within the specified resolution while retaining
-    # the original image size.
-    #
-    # The resulting image will always be the same pixel size as the source with
-    # an adjusted resolution dimensions.
-    #
-    # @param [MiniMagick::Image] image    the image to convert
-    # @param [#to_s] width                the dpi width
-    # @param [#to_s] height               the dpi height
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    # @see http://www.imagemagick.org/script/command-line-options.php#resample
-    def resample!(image, width, height)
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.resample "#{width}x#{height}"
-        end
+
+      def append(magick, *args)
+        magick.merge! args
       end
-    end
-    nondestructive_alias :resample, :resample!
-
-    # Crops the image to be the defined area.
-    #
-    # @param [#to_s] width                the width of the cropped image
-    # @param [#to_s] height               the height of the cropped image
-    # @param [#to_s] x_offset             the x coordinate where to start cropping
-    # @param [#to_s] y_offset             the y coordinate where to start cropping
-    # @param [string] gravity             which part of the image to focus on
-    # @yield [MiniMagick::Tool::Mogrify, MiniMagick::Tool::Convert]
-    # @return [File, Tempfile]
-    # @see http://www.imagemagick.org/script/command-line-options.php#crop
-    def crop!(image, width, height, x_offset = 0, y_offset = 0, gravity: "NorthWest")
-      with_minimagick(image) do |img|
-        img.combine_options do |cmd|
-          yield cmd if block_given?
-          cmd.gravity gravity
-          cmd.crop "#{width}x#{height}+#{x_offset}+#{y_offset}"
+
+      def load_image(path_or_magick, page: nil, geometry: nil, fail: true, auto_orient: true)
+        if path_or_magick.is_a?(::MiniMagick::Tool)
+          magick = path_or_magick
+        else
+          source_path = path_or_magick
+          magick = ::MiniMagick::Tool::Convert.new
+
+          input_path  = source_path
+          input_path += "[#{page}]" if page
+          input_path += "[#{geometry}]" if geometry
+
+          magick << input_path
         end
+
+        magick.regard_warnings if fail
+        magick.auto_orient if auto_orient
+
+        magick
       end
-    end
-    nondestructive_alias :crop, :crop!
-
-    # Returns whether the image is corrupt.
-    #
-    # @param [File] image
-    # @return [Boolean]
-    def corrupted?(image)
-      ::MiniMagick::Tool::Identify.new do |identify|
-        identify.verbose
-        identify.regard_warnings
-        identify << image.path
+
+      def save_image(magick, destination_path, **options)
+        magick << destination_path
+        magick.call
       end
-      false
-    rescue ::MiniMagick::Error
-      true
     end
 
-    # Convert an image into a MiniMagick::Image for the duration of the block,
-    # and at the end return a File object.
-    def with_minimagick(image)
-      image = ::MiniMagick::Image.new(image.path, image)
-      yield image
-      tempfile = image.instance_variable_get("@tempfile")
-      tempfile.open if tempfile.is_a?(Tempfile)
-      tempfile
-    end
+    extend Chainable
 
-    # Creates a copy of the file and stores it into a Tempfile. Works for any
-    # IO object that responds to `#read(length = nil, outbuf = nil)`.
-    def _copy_to_tempfile(file)
-      extension = File.extname(file.path) if file.respond_to?(:path)
-      tempfile = Tempfile.new(["image_processing-mini_magick", extension.to_s], binmode: true)
-      IO.copy_stream(file, tempfile.path)
-      file.rewind
-      tempfile
-    end
+    include DeprecatedApi
   end
 end

data/lib/image_processing/pipeline.rb

@@ -0,0 +1,59 @@
+require "tempfile"
+
+module ImageProcessing
+  class Pipeline
+    include Chainable
+
+    def initialize(options)
+      @default_options = options
+    end
+
+    def call!(save: true, destination: nil)
+      fail Error, "source file is not provided" unless default_options[:source]
+
+      image_class = default_options[:processor]::IMAGE_CLASS
+
+      if default_options[:source].is_a?(image_class)
+        source = default_options[:source]
+      elsif default_options[:source].is_a?(String)
+        source = default_options[:source]
+      elsif default_options[:source].respond_to?(:path)
+        source = default_options[:source].path
+      elsif default_options[:source].respond_to?(:to_path)
+        source = default_options[:source].to_path
+      else
+        fail Error, "source file needs to respond to #path, or be a String, a Pathname, or a #{image_class} object"
+      end
+
+      processor = default_options[:processor].new
+      image     = processor.load_image(source, default_options[:loader])
+
+      default_options[:operations].each do |name, args|
+        if name == :custom
+          image = args.first.call(image) || image
+        else
+          image = processor.apply_operation(name, image, *args)
+        end
+      end
+
+      return image unless save
+
+      return processor.save_image(image, destination, default_options[:saver]) if destination
+
+      source_path = source if source.is_a?(String)
+      format      = default_options[:format] || File.extname(source_path.to_s)[1..-1] || "jpg"
+
+      result = Tempfile.new(["image_processing", ".#{format}"], binmode: true)
+
+      begin
+        processor.save_image(image, result.path, default_options[:saver])
+      rescue
+        result.close!
+        raise
+      end
+
+      result.open
+      result
+    end
+  end
+end

data/lib/image_processing/version.rb

@@ -1,3 +1,3 @@
 module ImageProcessing
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/image_processing/vips.rb

@@ -1,12 +1,98 @@
-require "image_processing/vips/chainable"
-require "image_processing/vips/pipeline"
-require "image_processing/vips/processor"
+gem "ruby-vips", "~> 2.0"
+require "vips"
 
-require "image_processing/version"
+require "image_processing"
+
+fail "image_processing/vips requires libvips 8.6+" unless Vips.at_least_libvips?(8, 6)
 
 module ImageProcessing
   module Vips
-    Error = Class.new(StandardError)
+    def self.valid_image?(file)
+      ::Vips::Image.new_from_file(file.path, access: :sequential, fail: true).avg
+      true
+    rescue ::Vips::Error
+      false
+    end
+
+    class Processor
+      IMAGE_CLASS = ::Vips::Image
+      # libvips has this arbitrary number as a sanity-check upper bound on image
+      # size.
+      MAX_COORD = 10_000_000
+
+      def apply_operation(name, image, *args)
+        if respond_to?(name)
+          public_send(name, image, *args)
+        else
+          result = image.send(name, *args)
+          result.is_a?(::Vips::Image) ? result : image
+        end
+      end
+
+      def resize_to_limit(image, width, height, **options)
+        width, height = default_dimensions(width, height)
+        image.thumbnail_image(width, height: height, size: :down, **options)
+      end
+
+      def resize_to_fit(image, width, height, **options)
+        width, height = default_dimensions(width, height)
+        image.thumbnail_image(width, height: height, **options)
+      end
+
+      def resize_to_fill(image, width, height, **options)
+        image.thumbnail_image(width, height: height, crop: :centre, **options)
+      end
+
+      def resize_and_pad(image, width, height, gravity: "centre", extend: nil, background: nil, alpha: nil, **options)
+        embed_options = { extend: extend, background: background }
+        embed_options.reject! { |name, value| value.nil? }
+
+        image = image.thumbnail_image(width, height: height, **options)
+        image = image.bandjoin(255) if alpha && image.bands == 3
+        image.gravity(gravity, width, height, **embed_options)
+      end
+
+      def load_image(path_or_image, autorot: true, **options)
+        if path_or_image.is_a?(::Vips::Image)
+          image = path_or_image
+        else
+          source_path = path_or_image
+          loader  = ::Vips.vips_foreign_find_load(source_path)
+          options = select_valid_options(loader, options) if loader
+
+          image = ::Vips::Image.new_from_file(source_path, fail: true, **options)
+        end
+
+        image = image.autorot if autorot
+        image
+      end
+
+      def save_image(image, destination_path, **options)
+        saver   = ::Vips.vips_foreign_find_save(destination_path)
+        options = select_valid_options(saver, options) if saver
+
+        image.write_to_file(destination_path, **options)
+      end
+
+      private
+
+      def default_dimensions(width, height)
+        raise Error, "either width or height must be specified" unless width || height
+
+        [width || MAX_COORD, height || MAX_COORD]
+      end
+
+      def select_valid_options(operation_name, options)
+        operation = ::Vips::Operation.new(operation_name)
+
+        operation_options = operation.get_construct_args
+          .select { |name, flags| (flags & ::Vips::ARGUMENT_INPUT)    != 0 }
+          .select { |name, flags| (flags & ::Vips::ARGUMENT_REQUIRED) == 0 }
+          .map(&:first).map(&:to_sym)
+
+        options.select { |name, value| operation_options.include?(name) }
+      end
+    end
 
     extend Chainable
   end

data/lib/image_processing.rb

@@ -1,4 +1,10 @@
+require "image_processing/chainable"
+require "image_processing/pipeline"
+require "image_processing/version"
+
 module ImageProcessing
+  Error = Class.new(StandardError)
+
   autoload :MiniMagick, 'image_processing/mini_magick'
   autoload :Vips, 'image_processing/vips'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_processing
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-16 00:00:00.000000000 Z
+date: 2018-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -106,13 +106,12 @@ files:
 - README.md
 - image_processing.gemspec
 - lib/image_processing.rb
+- lib/image_processing/chainable.rb
 - lib/image_processing/mini_magick.rb
+- lib/image_processing/mini_magick/deprecated_api.rb
+- lib/image_processing/pipeline.rb
 - lib/image_processing/version.rb
 - lib/image_processing/vips.rb
-- lib/image_processing/vips/chainable.rb
-- lib/image_processing/vips/color.rb
-- lib/image_processing/vips/pipeline.rb
-- lib/image_processing/vips/processor.rb
 homepage: https://github.com/janko-m/image_processing
 licenses:
 - MIT