openstreetmap-image_optim 0.21.0.1

data/lib/image_optim/configuration_error.rb

@@ -0,0 +1,3 @@
+class ImageOptim
+  class ConfigurationError < StandardError; end
+end

data/lib/image_optim/handler.rb

@@ -0,0 +1,57 @@
+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)
+      unless original.respond_to?(:temp_path)
+        fail ArgumentError, 'original should respond to temp_path'
+      end
+
+      @original = original
+      @result = nil
+    end
+
+    # with no associated block, works as new. Otherwise creates instance and
+    # passes it to block, runs cleanup and returns result of handler
+    def self.for(original)
+      handler = new(original)
+      if block_given?
+        begin
+          yield handler
+          handler.result
+        ensure
+          handler.cleanup
+        end
+      else
+        handler
+      end
+    end
+
+    # Yields two paths, one to latest successful result or original, second to
+    # temp path
+    def process
+      @src ||= @original
+      @dst ||= @original.temp_path
+
+      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
+      return unless @dst
+      @dst.unlink
+      @dst = nil
+    end
+  end
+end

data/lib/image_optim/hash_helpers.rb

@@ -0,0 +1,45 @@
+class ImageOptim
+  # Helper methods to manipulate Hash, mainly used in config
+  module HashHelpers
+    class << self
+      # 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|
+          if v_a.is_a?(Hash) && v_b.is_a?(Hash)
+            deep_merge(v_a, v_b)
+          else
+            v_b
+          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

@@ -0,0 +1,25 @@
+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)
+      new(is.format)
+    rescue ImageSize::FormatError => e
+      warn "#{e} (detecting format of image at #{path})"
+    end
+
+    def self.for_data(data)
+      is = ImageSize.new(data)
+      new(is.format)
+    rescue ImageSize::FormatError => e
+      warn "#{e} (detecting format of image data)"
+    end
+
+    attr_reader :format
+    def initialize(format)
+      @format = format
+    end
+  end
+end

data/lib/image_optim/image_path.rb

@@ -0,0 +1,68 @@
+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.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
+      attr_reader :original
+
+      # Stored size of original
+      attr_reader :original_size
+    end
+
+    # Get temp path for this file with same extension
+    def temp_path(*args, &block)
+      ext = extname
+      self.class.temp_file_path([basename(ext).to_s, ext], *args, &block)
+    end
+
+    # Copy file to dest preserving attributes
+    def copy(dst)
+      FileUtils.copy_file(self, dst, true)
+    end
+
+    # Atomic replace src with self
+    def replace(src)
+      src = self.class.new(src)
+      src.temp_path(src.dirname) do |temp|
+        src.copy(temp)
+        temp.write(read)
+        temp.rename(src.to_s)
+        unlink
+      end
+    end
+
+    # Get format using ImageSize
+    def format
+      image_meta = ImageMeta.for_path(self)
+      image_meta && image_meta.format
+    end
+
+    # Read binary data
+    def binread
+      open('rb', &:read)
+    end
+
+    # 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
+  end
+end

data/lib/image_optim/non_negative_integer_range.rb

@@ -0,0 +1,11 @@
+class ImageOptim
+  # Denote range of non negative integers for worker option
+  class NonNegativeIntegerRange
+    # Add handling of range of non negative integers in OptionParser instance
+    def self.add_to_option_parser(option_parser)
+      option_parser.accept(self, /(\d+)(?:-|\.\.)(\d+)/) do |_, m, n|
+        m.to_i..n.to_i
+      end
+    end
+  end
+end

data/lib/image_optim/option_definition.rb

@@ -0,0 +1,32 @@
+class ImageOptim
+  # Hold information about an option
+  class OptionDefinition
+    attr_reader :name, :default, :type, :description, :proc
+
+    def initialize(name, default, type_or_description, description = nil, &proc)
+      if type_or_description.is_a?(Class)
+        type = type_or_description
+      else
+        type, description = default.class, type_or_description
+      end
+
+      @name = name.to_sym
+      @description = description.to_s
+      @default, @type, @proc = default, type, proc
+    end
+
+    # Get value for worker from options
+    def value(worker, options)
+      value = options.key?(name) ? options[name] : default
+      if proc
+        if proc.arity == 2
+          worker.instance_exec(value, self, &proc)
+        else
+          worker.instance_exec(value, &proc)
+        end
+      else
+        value
+      end
+    end
+  end
+end

data/lib/image_optim/option_helpers.rb

@@ -0,0 +1,17 @@
+class ImageOptim
+  # Helper methods for options
+  module OptionHelpers
+    # Ensure number is in range
+    def self.limit_with_range(number, range)
+      if range.include?(number)
+        number
+      elsif number < range.first
+        range.first
+      elsif range.exclude_end?
+        range.last - 1
+      else
+        range.last
+      end
+    end
+  end
+end

data/lib/image_optim/railtie.rb

@@ -0,0 +1,38 @@
+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|
+      register_preprocessor(app) if register_preprocessor?(app)
+    end
+
+    def register_preprocessor?(app)
+      return if app.config.assets.compress == false
+      return if app.config.assets.image_optim == false
+
+      app.assets
+    end
+
+    def options(app)
+      if app.config.assets.image_optim == true
+        {}
+      else
+        app.config.assets.image_optim || {}
+      end
+    end
+
+    def register_preprocessor(app)
+      image_optim = ImageOptim.new(options(app))
+
+      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

@@ -0,0 +1,139 @@
+require 'image_optim'
+require 'image_optim/hash_helpers'
+require 'image_optim/runner/glob_helpers'
+require 'image_optim/space'
+require 'progress'
+require 'find'
+require 'yaml'
+
+class ImageOptim
+  # Handling optimization using image_optim binary
+  class Runner
+    # Collect and output results of optimization
+    class Results
+      def initialize
+        @lines = []
+        @original_size_sum = 0
+        @optimized_size_sum = 0
+      end
+
+      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
+
+      def print
+        puts @lines
+        puts "Total: #{size_percent(@original_size_sum, @optimized_size_sum)}"
+      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(options)
+      options = HashHelpers.deep_symbolise_keys(options)
+      @recursive = options.delete(:recursive)
+      @progress = options.delete(:show_progress) != false
+      @exclude_dir_globs, @exclude_file_globs = %w[dir file].map do |type|
+        glob = options.delete(:"exclude_#{type}_glob") || '.*'
+        GlobHelpers.expand_braces(glob)
+      end
+      @image_optim = ImageOptim.new(options)
+    end
+
+    def run!(args)
+      to_optimize = find_to_optimize(args)
+      unless to_optimize.empty?
+        results = Results.new
+
+        optimize_images!(to_optimize).each do |original, optimized|
+          results.add(original, optimized)
+        end
+
+        results.print
+      end
+
+      !@warnings
+    end
+
+  private
+
+    def optimize_images!(to_optimize, &block)
+      to_optimize = to_optimize.with_progress('optimizing') if @progress
+      @image_optim.optimize_images!(to_optimize, &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 "#{path} is not an image or there is no optimizer for it"
+          end
+        elsif File.directory?(path)
+          if @recursive
+            to_optimize += find_to_optimize_recursive(path)
+          else
+            warning "#{path} is a directory, use --recursive option"
+          end
+        else
+          warning "#{path} is not a file or a directory or does not exist"
+        end
+      end
+      to_optimize
+    end
+
+    def find_to_optimize_recursive(dir)
+      to_optimize = []
+      Find.find(dir) do |path|
+        if File.file?(path)
+          next if exclude_file?(dir, path)
+          next unless @image_optim.optimizable?(path)
+          to_optimize << path
+        elsif File.directory?(path)
+          Find.prune if dir != path && exclude_dir?(dir, path)
+        end
+      end
+      to_optimize
+    end
+
+    def exclude_dir?(dir, path)
+      exclude?(dir, path, @exclude_dir_globs)
+    end
+
+    def exclude_file?(dir, path)
+      exclude?(dir, path, @exclude_file_globs)
+    end
+
+    # Check if any of globs matches either part of path relative from dir or
+    # just basename
+    def exclude?(dir, path, globs)
+      relative_path = Pathname(path).relative_path_from(Pathname(dir)).to_s
+      basename = File.basename(path)
+      globs.any? do |glob|
+        File.fnmatch(glob, relative_path, File::FNM_PATHNAME) ||
+          File.fnmatch(glob, basename, File::FNM_PATHNAME)
+      end
+    end
+
+    def warning(message)
+      @warnings = true
+      warn message
+    end
+  end
+end