mojo_magick 0.5.7 → 0.6.5

data/lib/mojo_magick.rb

@@ -1,15 +1,12 @@
-cwd = File.dirname(__FILE__)
-require 'open3'
-initializers_dir = File.expand_path(File.join(cwd, 'initializers'))
-Dir.glob(File.join(initializers_dir, '*.rb')).each { |f| require f }
-require File.join(cwd, 'mojo_magick/util/parser')
-require File.join(cwd, 'mojo_magick/errors')
-require File.join(cwd, 'mojo_magick/command_status')
-require File.join(cwd, 'image_magick/resource_limits')
-require File.join(cwd, 'image_magick/fonts')
-require File.join(cwd, 'mojo_magick/opt_builder')
-require File.join(cwd, 'mojo_magick/font')
-require 'tempfile'
+require "tempfile"
+require "open3"
+require_relative "./mojo_magick/util/font_parser"
+require_relative "./mojo_magick/errors"
+require_relative "./mojo_magick/command_status"
+require_relative "./mojo_magick/commands"
+require_relative "./image_magick/fonts"
+require_relative "./mojo_magick/opt_builder"
+require_relative "./mojo_magick/font"
 
 # MojoMagick is a stateless set of module methods which present a convient interface
 # for accessing common tasks for ImageMagick command line library.
@@ -35,7 +32,8 @@ require 'tempfile'
 #
 # Equivalent to:
 #
-#   MojoMagick::raw_command('convert', 'source.jpg -crop 250x250+0+0 +repage -strip -set comment "my favorite file" dest.jpg')
+#   MojoMagick::Commands.raw_command('convert', 'source.jpg -crop 250x250+0+0\
+#         +repage -strip -set comment "my favorite file" dest.jpg')
 #
 # Example #mogrify usage:
 #
@@ -43,7 +41,7 @@ require 'tempfile'
 #
 # Equivalent to:
 #
-#   MojoMagick::raw_command('mogrify', '-shave 10x10 image.jpg')
+#   MojoMagick::Commands.raw_command('mogrify', '-shave 10x10 image.jpg')
 #
 # Example showing some additional options:
 #
@@ -60,39 +58,40 @@ require 'tempfile'
 # bang (!) can be appended to command names to use the '+' versions
 # instead of '-' versions.
 #
-module MojoMagick
-  # enable resource limiting functionality
-  extend ImageMagick::ResourceLimits
-  extend ImageMagick::Fonts
 
-  def self.windows?
-    !(RUBY_PLATFORM =~ /win32/).nil?
+module MojoMagickDeprecations
+  # rubocop:disable Naming/AccessorMethodName
+  def get_fonts
+    warn "DEPRECATION WARNING: #{__method__} is deprecated and will be removed with the next minor version release."\
+         "  Please use `available_fonts` instead"
+    MojoMagick.available_fonts
   end
 
-  def self.execute(command, args, _options = {})
-    # this suppress error messages to the console
-    # err_pipe = windows? ? "2>nul" : "2>/dev/null"
+  # rubocop:enable Naming/AccessorMethodName
+  ### Moved to `Commands`
+  def execute!(*args)
+    warn "DEPRECATION WARNING: #{__method__} is deprecated and will be removed with the next minor version release."\
+         "  Please use `MojoMagick::Commands.execute!` instead"
+    MojoMagick::Commands.send(:execute!, *args)
+  end
 
-    execute = "#{command} #{get_limits_as_params} #{args}"
-    out, outerr, status = Open3.capture3(execute)
-    CommandStatus.new execute, out, outerr, status
-  rescue Exception => e
-    raise MojoError, "#{e.class}: #{e.message}"
+  def execute(*args)
+    warn "DEPRECATION WARNING: #{__method__} is deprecated and will be removed with the next minor version release."\
+         "  Please use `MojoMagick::Commands.execute!` instead"
+    MojoMagick::Commands.send(:execute, *args)
   end
 
-  def self.execute!(command, args, options = {})
-    # this suppress error messages to the console
-    # err_pipe = windows? ? "2>nul" : "2>/dev/null"
-    status = execute(command, args, options)
-    unless status.success?
-      err_msg = options[:err_msg] || "MojoMagick command failed: #{command}."
-      raise(MojoFailed, "#{err_msg} (Exit status: #{status.exit_code})\n  Command: #{status.command}\n  Error: #{status.error}")
-    end
-    status.return_value
+  def raw_command(*args)
+    warn "DEPRECATION WARNING: #{__method__} is deprecated and will be removed with the next minor version release."\
+         "  Please use `MojoMagick::Commands.execute!` instead"
+    MojoMagick::Commands.raw_command(*args)
   end
+end
 
-  def self.raw_command(*args)
-    execute!(*args)
+module MojoMagick
+  extend MojoMagickDeprecations
+  def self.windows?
+    !RUBY_PLATFORM.include(win32)
   end
 
   def self.shrink(source_file, dest_file, options)
@@ -110,46 +109,56 @@ module MojoMagick
   # resizes an image and returns the filename written to
   # options:
   #   :width / :height => scale to these dimensions
-  #   :scale => pass scale options such as ">" to force shrink scaling only or "!" to force absolute width/height scaling (do not preserve aspect ratio)
+  #   :scale => pass scale options such as ">" to force shrink scaling only or
+  #             "!" to force absolute width/height scaling (do not preserve aspect ratio)
   #   :percent => scale image to this percentage (do not specify :width/:height in this case)
   def self.resize(source_file, dest_file, options)
-    scale_options = []
-    scale_options << '>' unless options[:shrink_only].nil?
-    scale_options << '<' unless options[:expand_only].nil?
-    scale_options << '!' unless options[:absolute_aspect].nil?
-    scale_options << '^' unless options[:fill].nil?
-    scale_options = scale_options.join
-
+    scale_options = extract_scale_options(options)
+    geometry = extract_geometry_options(options)
     extras = []
-    if !options[:width].nil? && !options[:height].nil?
-      geometry = "#{options[:width]}X#{options[:height]}"
-    elsif !options[:percent].nil?
-      geometry = "#{options[:percent]}%"
-    else
-      raise MojoMagickError, "Unknown options for method resize: #{options.inspect}"
-    end
     if !options[:fill].nil? && !options[:crop].nil?
-      extras << '-gravity Center'
-      extras << "-extent #{geometry}"
+      extras << "-gravity"
+      extras << "Center"
+      extras << "-extent"
+      extras << geometry.to_s
     end
-    raw_command('convert', "\"#{source_file}\" -resize \"#{geometry}#{scale_options}\" #{extras.join(' ')} \"#{dest_file}\"")
+    Commands.raw_command("convert",
+                         source_file,
+                         "-resize", "#{geometry}#{scale_options}",
+                         *extras, dest_file)
     dest_file
   end
 
+  def self.convert(source = nil, dest = nil)
+    opts = OptBuilder.new
+    opts.file source if source
+    yield opts
+    opts.file dest if dest
+
+    Commands.raw_command("convert", *opts.to_a)
+  end
+
+  def self.mogrify(dest = nil)
+    opts = OptBuilder.new
+    yield opts
+    opts.file dest if dest
+    Commands.raw_command("mogrify", *opts.to_a)
+  end
+
   def self.available_fonts
     # returns width, height of image if available, nil if not
     Font.all
   end
 
   def self.get_format(source_file, format_string)
-    raw_command('identify', "-format \"#{format_string}\" \"#{source_file}\"")
+    Commands.raw_command("identify", "-format", format_string, source_file)
   end
 
   # returns an empty hash or a hash with :width and :height set (e.g. {:width => INT, :height => INT})
   # raises MojoFailed when results are indeterminate (width and height could not be determined)
   def self.get_image_size(source_file)
     # returns width, height of image if available, nil if not
-    retval = get_format(source_file, 'w:%w h:%h')
+    retval = get_format(source_file, "w:%w h:%h")
     return {} unless retval
 
     width = retval.match(/w:([0-9]+) /)
@@ -161,30 +170,38 @@ module MojoMagick
     { width: width, height: height }
   end
 
-  def self.convert(source = nil, dest = nil)
-    opts = OptBuilder.new
-    opts.file source if source
-    yield opts
-    opts.file dest if dest
-    raw_command('convert', opts.to_s)
-  end
-
-  def self.mogrify(dest = nil)
-    opts = OptBuilder.new
-    yield opts
-    opts.file dest if dest
-    raw_command('mogrify', opts.to_s)
-  end
-
   def self.tempfile(*opts)
     data = opts[0]
     rest = opts[1]
     ext = rest && rest[:format]
-    file = Tempfile.new(['mojo', ext ? '.' + ext.to_s : ''])
+    file = Tempfile.new(["mojo", ext ? ".#{ext}" : ""])
     file.binmode
     file.write(data)
     file.path
   ensure
     file.close
   end
-end # MojoMagick
+
+  class << self
+    private
+
+    def extract_geometry_options(options)
+      if !options[:width].nil? && !options[:height].nil?
+        "#{options[:width]}X#{options[:height]}"
+      elsif !options[:percent].nil?
+        "#{options[:percent]}%"
+      else
+        raise MojoMagickError, "Resize requires width and height or percentage: #{options.inspect}"
+      end
+    end
+
+    def extract_scale_options(options)
+      [].tap { |scale_options|
+        scale_options << ">" unless options[:shrink_only].nil?
+        scale_options << "<" unless options[:expand_only].nil?
+        scale_options << "!" unless options[:absolute_aspect].nil?
+        scale_options << "^" unless options[:fill].nil?
+      }.join
+    end
+  end
+end

data/lib/mojo_magick/command_status.rb

@@ -5,7 +5,7 @@ module MojoMagick
     end
 
     def exit_code
-      system_status.exitstatus || 'unknown'
+      system_status.exitstatus || "unknown"
     end
   end
 end

data/lib/mojo_magick/commands.rb

@@ -0,0 +1,32 @@
+require_relative "opt_builder"
+
+module MojoMagick
+  class Commands
+    def self.raw_command(*args)
+      execute!(*args)
+    end
+
+    class << self
+      private
+
+      def execute(command, *args)
+        execute = "#{command} #{args}"
+        out, outerr, status = Open3.capture3(command, *args.map(&:to_s))
+        CommandStatus.new execute, out, outerr, status
+      rescue StandardError => e
+        raise MojoError, "#{e.class}: #{e.message}"
+      end
+
+      def execute!(command, *args)
+        status = execute(command, *args)
+        unless status.success?
+          err_msg = "MojoMagick command failed: #{command}."
+          raise(MojoFailed, "#{err_msg} (Exit status: #{status.exit_code})\n" \
+                            "  Command: #{status.command}\n" \
+                            "  Error: #{status.error}")
+        end
+        status.return_value
+      end
+    end
+  end
+end

data/lib/mojo_magick/errors.rb

@@ -1,5 +1,7 @@
 module MojoMagick
   class MojoMagickException < StandardError; end
+
   class MojoError < MojoMagickException; end
+
   class MojoFailed < MojoMagickException; end
 end

data/lib/mojo_magick/font.rb

@@ -7,7 +7,6 @@ module MojoMagick
     end
 
     def initialize(property_hash = {})
-      property_hash.symbolize_keys!
       %i[name family style stretch weight glyphs].each do |f|
         setter = "#{f}="
         send(setter, property_hash[f])
@@ -15,7 +14,7 @@ module MojoMagick
     end
 
     def self.all
-      ImageMagick::Font.all.map { |font_info| Font.new(font_info) }
+      ImageMagick::Fonts.all
     end
   end
 end

data/lib/mojo_magick/opt_builder.rb

@@ -17,9 +17,7 @@ module MojoMagick
 
     # Add files to command line, formatted if necessary
     def file(*args)
-      args.each do |arg|
-        add_formatted arg
-      end
+      @opts << args
       self
     end
     alias files file
@@ -29,21 +27,17 @@ module MojoMagick
     end
 
     # annotate takes non-standard args
-    def annotate(*args)
-      @opts << '-annotate'
-      arguments = args.join.split
-      arguments.unshift '0' if arguments.length == 1
-      arguments.each do |arg|
-        add_formatted arg
-      end
+    def annotate(*args, geometry: 0)
+      @opts << "-annotate"
+      arguments = [args.join]
+      arguments.unshift geometry.to_s
+      @opts << arguments
     end
 
     # Create a temporary file for the given image and add to command line
     def format(*args)
-      @opts << '-format'
-      args.each do |arg|
-        add_formatted arg
-      end
+      @opts << "-format"
+      @opts << args
     end
 
     def blob(*args)
@@ -64,33 +58,28 @@ module MojoMagick
     end
 
     # Generic commands. Arguments will be formatted if necessary
+    # rubocop:disable Style/MissingRespondToMissing
     def method_missing(command, *args)
-      @opts << if command.to_s[-1, 1] == '!'
+      @opts << if command.to_s[-1, 1] == "!"
                  "+#{command.to_s.chop}"
                else
                  "-#{command}"
                end
-      args.each do |arg|
-        add_formatted arg
-      end
+      @opts << args
       self
     end
 
-    def to_s
-      @opts.join ' '
+    # rubocop:enable Style/MissingRespondToMissing
+    def to_a
+      @opts.flatten
     end
 
     protected
 
-    def add_formatted(arg)
-      # Quote anything that would cause problems on *nix or windows
-      @opts << quoted_arg(arg)
-    end
-
     def quoted_arg(arg)
-      return arg unless arg =~ /[#'<>^|&();` ]/
+      return arg unless /[#'<>^|&();` ]/.match?(arg)
 
-      ['"', arg.gsub('"', '\"').gsub("'", "\'"), '"'].join
+      ['"', arg.gsub('"', '\"').tr("'", "\'"), '"'].join
     end
   end
 end

data/lib/mojo_magick/util/font_parser.rb

@@ -0,0 +1,43 @@
+# rubocop:disable Lint/AssignmentInCondition
+module MojoMagick
+  module Util
+    class FontParser
+      attr_reader :raw_fonts
+
+      def initialize(raw_fonts)
+        @raw_fonts = raw_fonts
+      end
+
+      def parse
+        fonts = {}
+        enumerator = raw_fonts.split("\n").each
+        name = nil
+        while begin; line = enumerator.next; rescue StopIteration; line = nil; end
+          line.chomp!
+          line = enumerator.next if line_is_empty(line)
+          m = /^\s*Font:\s+(.*)$/.match(line)
+          if m
+            name = m[1].strip
+            fonts[name] = { name: name }
+          else
+            k, v = extract_key_value(line)
+            fonts[name][k] = v if k && name
+          end
+        end
+        fonts.values.map { |f| MojoMagick::Font.new f }
+      end
+
+      private
+
+      def extract_key_value(line)
+        key_val = line.split(":").map(&:strip)
+        [key_val[0].downcase.to_sym, key_val[1]]
+      end
+
+      def line_is_empty(line)
+        line.nil? || line.empty? || (/^\s+$/ =~ line)
+      end
+    end
+  end
+end
+# rubocop:enable Lint/AssignmentInCondition

data/lib/mojo_magick/util/parser.rb

@@ -1,65 +1,20 @@
+require_relative "./font_parser"
 module MojoMagick
   module Util
     class Parser
-      # handle parsing outputs from ImageMagick commands
+      attr_reader :raw_fonts
 
-      def parse_fonts(raw_fonts)
-        fonts = {}
-        enumerator = raw_fonts.split(/\n/).each
-        name = nil
-        while begin; line = enumerator.next; rescue StopIteration; line = nil; end
-          line.chomp!
-          line = enumerator.next if line.nil? || line.empty? || (/^\s+$/ =~ line)
-          if m = /^\s*Font:\s+(.*)$/.match(line)
-            name = m[1].strip
-            fonts[name] = {name: name}
-          else
-            key_val = line.split(/:/).map(&:strip)
-            k = key_val[0].downcase.to_sym
-            v = key_val[1]
-            fonts[name][k] = v if k && name
-          end
-        end
-        fonts.values.map { |f| MojoMagick::Font.new f}
+      def initialize
+        warn "DEPRECATION WARNING: This class has been deprecated and will be removed with"\
+             " the next minor version release."\
+             "  Please use `MojoMagick::Util::FontParser` instead"
       end
 
-      def parse_limits(raw_limits)
-        row_limits = raw_limits.split("\n")
-        header = row_limits[0].chomp
-        data = row_limits[2].chomp
-        resources = header.strip.split
-        limits = data.strip.split
-
-        actual_values = {}
-        readable_values = {}
-
-        resources.each_index do |i|
-          resource = resources[i].downcase.to_sym
-          scale = limits[i].match(/[a-z]+$/) || []
-          value = limits[i].match(/^[0-9]+/)
-          unscaled_value = value ? value[0].to_i : -1
-          scaled_value = case scale[0]
-                         when 'eb'
-                           unscaled_value * (2**60)
-                         when 'pb'
-                           unscaled_value * (2**50)
-                         when 'tb'
-                           unscaled_value * (2**40)
-                         when 'gb'
-                           unscaled_value * (2**30)
-                         when 'mb'
-                           unscaled_value * (2**20)
-                         when 'kb'
-                           unscaled_value * (2**10)
-                         when 'b'
-                           unscaled_value
-                         else
-                           unscaled_value
-                         end
-          actual_values[resource] = scaled_value
-          readable_values[resource] = limits[i]
-        end
-        [actual_values, readable_values]
+      def parse_fonts(fonts)
+        warn "DEPRECATION WARNING: #{__method__} has been deprecated and will be removed with"\
+             " the next minor version release."\
+             "  Please use `MojoMagick::Util::FontParser#parse` instead"
+        FontParser.new(fonts).parse
       end
     end
   end