discourse_image_optim 0.24.4

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/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 |_key, value_a, value_b|
+          if value_a.is_a?(Hash) && value_b.is_a?(Hash)
+            deep_merge(value_a, value_b)
+          else
+            value_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 |key, value|
+          new_hash[yield key] = if value.is_a?(Hash)
+            deep_transform_keys(value, &block)
+          else
+            value
+          end
+        end
+        new_hash
+      end
+    end
+  end
+end

data/lib/image_optim/image_meta.rb

@@ -0,0 +1,20 @@
+require 'image_size'
+
+class ImageOptim
+  # Getting format of image at path or as data
+  module ImageMeta
+    def self.format_for_path(path)
+      is = ImageSize.path(path)
+      is.format if is
+    rescue ImageSize::FormatError => e
+      warn "#{e} (detecting format of image at #{path})"
+    end
+
+    def self.format_for_data(data)
+      is = ImageSize.new(data)
+      is.format if is
+    rescue ImageSize::FormatError => e
+      warn "#{e} (detecting format of image data)"
+    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/optimized_path.rb

@@ -0,0 +1,25 @@
+require 'image_optim/path'
+
+class ImageOptim
+  # Holds optimized image with reference to original and its size
+  class OptimizedPath < DelegateClass(Path)
+    def initialize(path, original_or_size = nil)
+      path = Path.convert(path)
+      __setobj__(path)
+      if original_or_size.is_a?(Integer)
+        @original = path
+        @original_size = original_or_size
+      elsif original_or_size
+        @original = Path.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
+end

data/lib/image_optim/option_definition.rb

@@ -0,0 +1,38 @@
+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
+
+    # Describe default value, returns string as is otherwise surrounds
+    # inspected value with backticks
+    def default_description
+      default.is_a?(String) ? default : "`#{default.inspect}`"
+    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/path.rb

@@ -0,0 +1,70 @@
+require 'fspath'
+require 'image_optim/image_meta'
+
+class ImageOptim
+  # FSPath with additional helpful methods
+  class Path < FSPath
+    NULL = if defined?(IO::NULL)
+      IO::NULL
+    else
+      %w[/dev/null NUL: NUL nul NIL: NL:].find{ |dev| File.exist?(dev) }
+    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 dst, optionally preserving attributes
+    #
+    # See FileUtils.copy_file
+    def copy(dst, preserve = false)
+      FileUtils.copy_file(self, dst, preserve)
+    end
+
+    # Move file to dst: rename on same device, copy and unlink original
+    # otherwise
+    #
+    # See FileUtils.mv
+    def move(dst)
+      FileUtils.move(self, dst)
+    end
+
+    # Copy metadata: uid, gid, mode, optionally atime and mtime
+    #
+    # Adapted from FileUtils::Entry_#copy_metadata by Minero Aoki
+    def copy_metadata(dst, time = false)
+      stat = lstat
+      dst.utime(stat.atime, stat.mtime) if time
+      begin
+        dst.chown(stat.uid, stat.gid)
+      rescue Errno::EPERM
+        dst.chmod(stat.mode & 0o1777)
+      else
+        dst.chmod(stat.mode)
+      end
+    end
+
+    # Atomic replace dst with self
+    def replace(dst)
+      dst = self.class.new(dst)
+      dst.temp_path(dst.dirname) do |temp|
+        move(temp)
+        dst.copy_metadata(temp)
+        temp.rename(dst.to_s)
+      end
+    end
+
+    # Get format using ImageSize
+    def image_format
+      ImageMeta.format_for_path(self)
+    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/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

data/lib/image_optim/runner/glob_helpers.rb

@@ -0,0 +1,45 @@
+class ImageOptim
+  class Runner
+    # Helper methods for glob
+    module GlobHelpers
+      class << self
+        # Match inner curly braces in glob
+        # Negative lookbehind is not used as is not supported by ruby before 1.9
+        BRACE_REGEXP = /
+          \A
+          (
+            (?:.*[^\\]|)  # anything ending not with slash or nothing
+            (?:\\\\)*     # any number of self escaped slashes
+          )
+          \{              # open brace
+          (
+            (?:|.*?[^\\]) # nothing or non greedy anything ending not with slash
+            (?:\\\\)*     # any number of self escaped slashes
+          )
+          \}              # close brace
+          (
+            .*            # what is left
+          )
+          \z
+        /x
+
+        # Expand curly braces in glob as fnmatch in ruby before 2.0 doesn't
+        # support them
+        def expand_braces(original_glob)
+          expanded = []
+          unexpanded = [original_glob]
+          while (glob = unexpanded.shift)
+            if (m = BRACE_REGEXP.match(glob))
+              m[2].split(',', -1).each do |variant|
+                unexpanded << "#{m[1]}#{variant}#{m[3]}"
+              end
+            else
+              expanded << glob
+            end
+          end
+          expanded.uniq
+        end
+      end
+    end
+  end
+end