image_optim 0.13.3 → 0.14.0

data/lib/image_optim/bin_resolver/comparable_condition.rb

@@ -1,6 +1,16 @@
 class ImageOptim
   class BinResolver
+    # Allows to externalize conditions for an instance of Comparable to use in
+    # case statemens
+    #
+    #     is = ComparableCondition.is
+    #     case rand(100)
+    #     when is < 10 then # ...
+    #     when is.between?(13, 23) then # ...
+    #     when is >= 90 then # ...
+    #     end
     class ComparableCondition
+      # Helper class for creating conditions using ComparableCondition.is
       class Builder
         Comparable.instance_methods.each do |method|
           define_method method do |*args|
@@ -15,22 +25,22 @@ class ImageOptim
 
       attr_reader :method, :args
       def initialize(method, *args)
-        @method = method.to_sym
-        @args = args
+        @method, @args = method.to_sym, args
 
         case @method
         when :between?
-          raise ArgumentError, "`between?' expects 2 arguments" unless args.length == 2
+          @args.length == 2 || argument_error!("`between?' expects 2 arguments")
         when :<, :<=, :==, :>, :>=
-          raise ArgumentError, "`#{method}' expects 1 argument" unless args.length == 1
+          @args.length == 1 || argument_error!("`#{method}' expects 1 argument")
         else
-          raise ArgumentError, "Unknown method `#{method}'"
+          argument_error! "Unknown method `#{method}'"
         end
       end
 
-      def ===(to_compare)
-        to_compare.send(@method, *@args)
+      def ===(other)
+        other.send(@method, *@args)
       end
+      alias_method :match, :===
 
       def to_s
         if @method == :between?
@@ -39,6 +49,12 @@ class ImageOptim
           "#{@method} #{@args.first}"
         end
       end
+
+    private
+
+      def argument_error!(message)
+        fail ArgumentError, message
+      end
     end
   end
 end

data/lib/image_optim/bin_resolver/simple_version.rb

@@ -1,5 +1,7 @@
 class ImageOptim
   class BinResolver
+    # Allows comparision of simple versions, only numbers separated by dots are
+    # taken into account
     class SimpleVersion
       include Comparable
 

data/lib/image_optim/config.rb

@@ -6,17 +6,23 @@ require 'set'
 require 'yaml'
 
 class ImageOptim
+  # Read, merge and parse configuration
   class Config
     include OptionHelpers
 
-    GLOBAL_CONFIG_PATH = File.join(File.expand_path(ENV['XDG_CONFIG_HOME'] || '~/.config'), 'image_optim.yml')
-    LOCAL_CONFIG_PATH = '.image_optim.yml'
+    CONFIG_HOME = File.expand_path(ENV['XDG_CONFIG_HOME'] || '~/.config')
+    GLOBAL_CONFIG_PATH = File.join(CONFIG_HOME, 'image_optim.yml')
+    LOCAL_CONFIG_PATH = './.image_optim.yml'
 
     class << self
+      # Read config at GLOBAL_CONFIG_PATH if it exists, warn if anything is
+      # wrong
       def global
         File.file?(GLOBAL_CONFIG_PATH) ? read(GLOBAL_CONFIG_PATH) : {}
       end
 
+      # Read config at LOCAL_CONFIG_PATH if it exists, warn if anything is
+      # wrong
       def local
         File.file?(LOCAL_CONFIG_PATH) ? read(LOCAL_CONFIG_PATH) : {}
       end
@@ -26,7 +32,7 @@ class ImageOptim
       def read(path)
         config = YAML.load_file(path)
         unless config.is_a?(Hash)
-          raise "excpected hash, got #{config.inspect}"
+          fail "excpected hash, got #{config.inspect}"
         end
         HashHelpers.deep_symbolise_keys(config)
       rescue => e
@@ -40,7 +46,7 @@ class ImageOptim
         Config.global,
         Config.local,
         HashHelpers.deep_symbolise_keys(options),
-      ].inject do |memo, hash|
+      ].reduce do |memo, hash|
         HashHelpers.deep_merge(memo, hash)
       end
       @used = Set.new
@@ -53,10 +59,10 @@ class ImageOptim
     end
 
     def assert_no_unused_options!
-      unknown_options = @options.reject{ |key, value| @used.include?(key) }
-      unless unknown_options.empty?
-        raise ConfigurationError, "unknown options #{unknown_options.inspect} for #{self}"
-      end
+      unknown_options = @options.reject{ |key, _value| @used.include?(key) }
+      return if unknown_options.empty?
+      fail ConfigurationError, "unknown options #{unknown_options.inspect} "\
+          "for #{self}"
     end
 
     def nice
@@ -100,7 +106,8 @@ class ImageOptim
       when false
         false
       else
-        raise ConfigurationError, "Got #{worker_options.inspect} for #{klass.name} options"
+        fail ConfigurationError, "Got #{worker_options.inspect} for "\
+            "#{klass.name} options"
       end
     end
 
@@ -110,7 +117,7 @@ class ImageOptim
 
   private
 
-    # http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed
+    # http://stackoverflow.com/a/6420817
     def processor_count
       @processor_count ||= case host_os = RbConfig::CONFIG['host_os']
       when /darwin9/
@@ -123,9 +130,10 @@ class ImageOptim
         `sysctl -n hw.ncpu`
       when /mswin|mingw/
         require 'win32ole'
-        wmi = WIN32OLE.connect('winmgmts://')
-        cpu = wmi.ExecQuery('select NumberOfLogicalProcessors from Win32_Processor')
-        cpu.to_enum.first.NumberOfLogicalProcessors
+        WIN32OLE.
+          connect('winmgmts://').
+          ExecQuery('select NumberOfLogicalProcessors from Win32_Processor').
+          to_enum.first.NumberOfLogicalProcessors
       else
         warn "Unknown architecture (#{host_os}) assuming one processor."
         1

data/lib/image_optim/handler.rb

@@ -1,35 +1,41 @@
 require 'image_optim/image_path'
 
 class ImageOptim
+  # Handles processing of original to result using upto two temp files
   class Handler
+    # Holds latest successful result
     attr_reader :result
+
+    # original must respond to temp_path
     def initialize(original)
-      raise ArgumentError, 'original should respond to temp_path' unless original.respond_to?(:temp_path)
+      unless original.respond_to?(:temp_path)
+        fail ArgumentError, 'original should respond to temp_path'
+      end
 
       @original = original
       @result = nil
     end
 
+    # Yields two paths, one to latest successful result or original, second to
+    # temp path
     def process
       @src ||= @original
       @dst ||= @original.temp_path
 
-      if yield @src, @dst
-        @result = @dst
-        if @src == @original
-          @src, @dst = @dst, nil
-        else
-          @src, @dst = @dst, @src
-        end
+      return unless yield @src, @dst
+      @result = @dst
+      if @src == @original
+        @src, @dst = @dst, nil
+      else
+        @src, @dst = @dst, @src
       end
     end
 
     # Remove extra temp files
     def cleanup
-      if @dst
-        @dst.unlink
-        @dst = nil
-      end
+      return unless @dst
+      @dst.unlink
+      @dst = nil
     end
   end
 end

data/lib/image_optim/hash_helpers.rb

@@ -1,28 +1,22 @@
 class ImageOptim
+  # Helper methods to manipulate Hash, mainly used in config
   module HashHelpers
     class << self
-      def deep_transform_keys(hash, &block)
-        new_hash = {}
-        hash.each do |k, v|
-          new_hash[block.call(k)] = if v.is_a?(Hash)
-            deep_transform_keys(v, &block)
-          else
-            v
-          end
-        end
-        new_hash
-      end
-
+      # Returns a new hash with all keys of root and nested hashes converted to
+      # strings
       def deep_stringify_keys(hash)
         deep_transform_keys(hash, &:to_s)
       end
 
+      # Returns a new hash with all keys of root and nested hashes converted to
+      # symbols
       def deep_symbolise_keys(hash)
         deep_transform_keys(hash, &:to_sym)
       end
 
+      # Returns a new hash with recursive merge of all keys
       def deep_merge(a, b)
-        a.merge(b) do |k, v_a, v_b|
+        a.merge(b) do |_k, v_a, v_b|
           if v_a.is_a?(Hash) && v_b.is_a?(Hash)
             deep_merge(v_a, v_b)
           else
@@ -30,6 +24,22 @@ class ImageOptim
           end
         end
       end
+
+    private
+
+      # Returns a new hash with all keys of root and nested hashes converted by
+      # provided block
+      def deep_transform_keys(hash, &block)
+        new_hash = {}
+        hash.each do |k, v|
+          new_hash[block.call(k)] = if v.is_a?(Hash)
+            deep_transform_keys(v, &block)
+          else
+            v
+          end
+        end
+        new_hash
+      end
     end
   end
 end

data/lib/image_optim/image_meta.rb

@@ -1,6 +1,7 @@
 require 'image_size'
 
 class ImageOptim
+  # Getting format of image at path or as data
   class ImageMeta
     def self.for_path(path)
       is = ImageSize.path(path)

data/lib/image_optim/image_path.rb

@@ -2,23 +2,24 @@ require 'fspath'
 require 'image_optim/image_meta'
 
 class ImageOptim
+  # FSPath with additional helpful methods
   class ImagePath < FSPath
+    # Holds optimized image with reference to original and its size
     class Optimized < DelegateClass(self)
       def initialize(path, original_or_size = nil)
         path = ImagePath.convert(path)
         __setobj__(path)
-        if original_or_size
-          if original_or_size.is_a?(Integer)
-            @original = path
-            @original_size = original_or_size
-          else
-            @original = ImagePath.convert(original_or_size)
-            @original_size = @original.size
-          end
+        if original_or_size.is_a?(Integer)
+          @original = path
+          @original_size = original_or_size
+        elsif original_or_size
+          @original = ImagePath.convert(original_or_size)
+          @original_size = @original.size
         end
       end
 
-      # Original path, use original_size to get its size as original can be overwritten
+      # Original path, use original_size to get its size as original can be
+      # overwritten
       attr_reader :original
 
       # Stored size of original
@@ -49,12 +50,12 @@ class ImageOptim
 
     # Get format using ImageSize
     def format
-      if image_meta = ImageMeta.for_path(self)
-        image_meta.format
-      end
+      image_meta = ImageMeta.for_path(self)
+      image_meta && image_meta.format
     end
 
-    # Returns path if it is already an instance of this class otherwise new instance
+    # Returns path if it is already an instance of this class otherwise new
+    # instance
     def self.convert(path)
       path.is_a?(self) ? path : new(path)
     end

data/lib/image_optim/option_definition.rb

@@ -1,14 +1,16 @@
-class OptionDefinition
+class ImageOptim
+  # Hold information about an option
+  class OptionDefinition
+    attr_reader :name, :default, :type, :description, :proc
 
-  attr_reader :name, :default, :type, :description, :proc
+    def initialize(name, default, type, description, &proc)
+      if type.is_a?(String)
+        type, description = default.class, type
+      end
 
-  def initialize(name, default, type, description, &proc)
-    if type.is_a?(String)
-      type, description = default.class, type
+      @name = name.to_sym
+      @description = description.to_s
+      @default, @type, @proc = default, type, proc
     end
-
-    @name = name.to_sym
-    @description = description.to_s
-    @default, @type, @proc = default, type, proc
   end
 end

data/lib/image_optim/option_helpers.rb

@@ -1,6 +1,5 @@
-require 'image_optim/configuration_error'
-
 class ImageOptim
+  # Helper methods for options
   module OptionHelpers
     # Ensure number is in range
     def self.limit_with_range(number, range)

data/lib/image_optim/railtie.rb

@@ -1,28 +1,31 @@
 require 'image_optim'
 
 class ImageOptim
+  # Adds image_optim as preprocessor for gif, jpeg, png and svg images
   class Railtie < Rails::Railtie
     initializer 'image_optim.initializer' do |app|
-      if app.config.assets.compress != false && app.config.assets.image_optim != false && app.assets
 
-        options = if app.config.assets.image_optim == true
-          {}
-        else
-          app.config.assets.image_optim || {}
-        end
+      break if app.config.assets.compress == false
+      break if app.config.assets.image_optim == false
+      break unless app.assets
 
-        image_optim = ImageOptim.new(options)
-
-        processor = proc do |context, data|
-          image_optim.optimize_image_data(data) || data
-        end
+      options = if app.config.assets.image_optim == true
+        {}
+      else
+        app.config.assets.image_optim || {}
+      end
 
-        app.assets.register_preprocessor 'image/gif', :image_optim, &processor
-        app.assets.register_preprocessor 'image/jpeg', :image_optim, &processor
-        app.assets.register_preprocessor 'image/png', :image_optim, &processor
-        app.assets.register_preprocessor 'image/svg+xml', :image_optim, &processor
+      image_optim = ImageOptim.new(options)
 
+      processor = proc do |_context, data|
+        image_optim.optimize_image_data(data) || data
       end
+
+      app.assets.register_preprocessor 'image/gif', :image_optim, &processor
+      app.assets.register_preprocessor 'image/jpeg', :image_optim, &processor
+      app.assets.register_preprocessor 'image/png', :image_optim, &processor
+      app.assets.register_preprocessor 'image/svg+xml', :image_optim, &processor
+
     end
   end
 end

data/lib/image_optim/runner.rb

@@ -1,67 +1,69 @@
-# encoding: UTF-8
-
 require 'image_optim'
 require 'image_optim/hash_helpers'
 require 'image_optim/true_false_nil'
+require 'image_optim/space'
 require 'progress'
 require 'optparse'
 require 'find'
 require 'yaml'
 
 class ImageOptim
+  # Handling optimization using image_optim binary
   class Runner
-    module Space
-      SIZE_SYMBOLS = %w[B K M G T P E].freeze
-      PRECISION = 1
-      LENGTH = 4 + PRECISION + 1
+    # Collect and output results of optimization
+    class Results
+      def initialize
+        @lines = []
+        @original_size_sum = 0
+        @optimized_size_sum = 0
+      end
 
-      EMPTY_SPACE = ' ' * LENGTH
+      def add(original, optimized)
+        original_size = optimized ? optimized.original_size : original.size
+        optimized_size = optimized ? optimized.size : original.size
+        @lines << "#{size_percent(original_size, optimized_size)}  #{original}"
+        @original_size_sum += original_size
+        @optimized_size_sum += optimized_size
+      end
 
-      class << self
-        attr_writer :base10
-        def denominator
-          @denominator ||= @base10 ? 1000.0 : 1024.0
-        end
+      def print
+        puts @lines
+        puts "Total: #{size_percent(@original_size_sum, @optimized_size_sum)}"
+      end
 
-        def space(size)
-          case size
-          when 0, nil
-            EMPTY_SPACE
-          else
-            log_denominator = Math.log(size) / Math.log(denominator)
-            degree = [log_denominator.floor, SIZE_SYMBOLS.length - 1].min
-            number = size / (denominator ** degree)
-            "#{degree == 0 ? number.to_i : "%.#{PRECISION}f" % number}#{SIZE_SYMBOLS[degree]}".rjust(LENGTH)
-          end
+    private
+
+      def size_percent(size_a, size_b)
+        if size_a == size_b
+          "------ #{Space::EMPTY_SPACE}"
+        else
+          percent = 100 - 100.0 * size_b / size_a
+          space = Space.space(size_a - size_b)
+          format('%5.2f%% %s', percent, space)
         end
       end
     end
 
     def initialize(args, options)
-      raise 'specify paths to optimize' if args.empty?
+      fail 'specify paths to optimize' if args.empty?
       options = HashHelpers.deep_symbolise_keys(options)
       @recursive = options.delete(:recursive)
       @image_optim = ImageOptim.new(options)
-      @files = find_files(args)
+      @to_optimize = find_to_optimize(args)
     end
 
     def run!
-      unless @files.empty?
-        lines, original_sizes, optimized_sizes =
-        @image_optim.optimize_images!(@files.with_progress('optimizing')) do |original, optimized|
-          original_size = optimized ? optimized.original_size : original.size
-          optimized_size = optimized ? optimized.size : original.size
-          ["#{size_percent(original_size, optimized_size)}  #{original}", original_size, optimized_size]
-        end.transpose
-
-        puts lines, "Total: #{size_percent(original_sizes.inject(:+), optimized_sizes.inject(:+))}"
-      end
+      unless @to_optimize.empty?
+        results = Results.new
 
-      !warnings?
-    end
+        optimize_images! do |original, optimized|
+          results.add(original, optimized)
+        end
 
-    def warnings?
-      !!@warnings
+        results.print
+      end
+
+      !@warnings
     end
 
     def self.run!(args, options)
@@ -70,42 +72,46 @@ class ImageOptim
 
   private
 
-    def find_files(args)
-      files = []
-      args.each do |arg|
-        if File.file?(arg)
-          if @image_optim.optimizable?(arg)
-            files << arg
+    def optimize_images!(&block)
+      @image_optim.
+        optimize_images!(@to_optimize.with_progress('optimizing'), &block)
+    end
+
+    def find_to_optimize(paths)
+      to_optimize = []
+      paths.each do |path|
+        if File.file?(path)
+          if @image_optim.optimizable?(path)
+            to_optimize << path
           else
-            warning "#{arg} is not an image or there is no optimizer for it"
+            warning "#{path} is not an image or there is no optimizer for it"
           end
         elsif @recursive
-          if File.directory?(arg)
-            Find.find(arg) do |path|
-              files << path if File.file?(path) && @image_optim.optimizable?(path)
-            end
+          if File.directory?(path)
+            to_optimize += find_to_optimize_recursive(path)
           else
-            warning "#{arg} is not a file or a directory or does not exist"
+            warning "#{path} is not a file or a directory or does not exist"
           end
         else
-          warning "#{arg} is not a file or does not exist"
+          warning "#{path} is not a file or does not exist"
         end
       end
-      files
+      to_optimize
+    end
+
+    def find_to_optimize_recursive(dir)
+      to_optimize = []
+      Find.find(dir) do |path|
+        next unless File.file?(path)
+        next unless @image_optim.optimizable?(path)
+        to_optimize << path
+      end
+      to_optimize
     end
 
     def warning(message)
       @warnings = true
       warn message
     end
-
-    def size_percent(size_a, size_b)
-      if size_a == size_b
-        "------ #{Space::EMPTY_SPACE}"
-      else
-        '%5.2f%% %s' % [100 - 100.0 * size_b / size_a, Space.space(size_a - size_b)]
-      end
-    end
-
   end
 end