discourse_image_optim 0.24.4

data/lib/image_optim/worker/advpng.rb

@@ -0,0 +1,37 @@
+require 'image_optim/worker'
+require 'image_optim/option_helpers'
+
+class ImageOptim
+  class Worker
+    # http://advancemame.sourceforge.net/doc-advpng.html
+    class Advpng < Worker
+      LEVEL_OPTION =
+      option(:level, 4, 'Compression level: '\
+          '`0` - don\'t compress, '\
+          '`1` - fast, '\
+          '`2` - normal, '\
+          '`3` - extra, '\
+          '`4` - extreme') do |v|
+        OptionHelpers.limit_with_range(v.to_i, 0..4)
+      end
+
+      TIMEOUT_OPTION = timeout_option
+
+      def run_order
+        4
+      end
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[
+          --recompress
+          -#{level}
+          --quiet
+          --
+          #{dst}
+        ]
+        execute(:advpng, *args) && optimized?(src, dst)
+      end
+    end
+  end
+end

data/lib/image_optim/worker/class_methods.rb

@@ -0,0 +1,107 @@
+require 'image_optim/bin_resolver'
+require 'image_optim/option_definition'
+
+class ImageOptim
+  class Worker
+    # Class methods of ImageOptim::Worker
+    module ClassMethods
+      def self.extended(klass)
+        klass.instance_variable_set(:@klasses, [])
+      end
+
+      # List of available workers
+      def klasses
+        @klasses.to_enum
+      end
+
+      # Remember all classes inheriting from this one
+      def inherited(base)
+        @klasses << base
+      end
+
+      # Underscored class name symbol
+      def bin_sym
+        @underscored_name ||=
+          name.
+          split('::').last. # get last part
+          gsub(/([a-z])([A-Z])/, '\1_\2').downcase. # convert AbcDef to abc_def
+          to_sym
+      end
+
+      def option_definitions
+        @option_definitions ||= []
+      end
+
+      def timeout_option
+        option(
+          :timeout,
+          0,
+          'Number of seconds before worker is timed out. Must be greater than' \
+          '0 to enable timeout.'
+        ){ |v| v }
+      end
+
+      def option(name, default, type, description = nil, &proc)
+        attr_reader name
+        OptionDefinition.new(name, default, type, description, &proc).
+          tap{ |option_definition| option_definitions << option_definition }
+      end
+
+      # Create hash with format mapped to list of workers sorted by run order
+      def create_all_by_format(image_optim, &options_proc)
+        by_format = {}
+        create_all(image_optim, &options_proc).each do |worker|
+          worker.image_formats.each do |format|
+            by_format[format] ||= []
+            by_format[format] << worker
+          end
+        end
+        by_format
+      end
+
+      # Create list of workers sorted by run order
+      # Workers are initialized with options provided through options_proc
+      # Resolve all bins of all workers, if there are errors and
+      # skip_missing_workers of image_optim is true - show warnings, otherwise
+      # fail with one joint exception
+      def create_all(image_optim, &options_proc)
+        workers = init_all(image_optim, &options_proc)
+
+        resolved = []
+        errors = BinResolver.collect_errors(workers) do |worker|
+          worker.resolve_used_bins!
+          resolved << worker
+        end
+
+        unless errors.empty?
+          messages = errors.map(&:to_s).uniq
+          if image_optim.skip_missing_workers
+            messages.each{ |message| warn message }
+          else
+            joint_message = ['Bin resolving errors:', *messages].join("\n")
+            fail BinResolver::Error, joint_message
+          end
+        end
+
+        resolved.sort_by.with_index{ |worker, i| [worker.run_order, i] }
+      end
+
+    private
+
+      def init_all(image_optim, &options_proc)
+        klasses.map do |klass|
+          options = options_proc[klass]
+          next if options[:disable]
+
+          [:allow_lossy, :timeout].each do |option_key|
+            if !options.key?(option_key) && klass.method_defined?(option_key)
+              options[option_key] = image_optim.send(option_key)
+            end
+          end
+
+          klass.init(image_optim, options)
+        end.compact.flatten
+      end
+    end
+  end
+end

data/lib/image_optim/worker/gifsicle.rb

@@ -0,0 +1,65 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    # http://www.lcdf.org/gifsicle/
+    class Gifsicle < Worker
+      # If interlace specified initialize one instance
+      # Otherwise initialize two, one with interlace off and one with on
+      def self.init(image_optim, options = {})
+        return super if options.key?(:interlace)
+
+        [false, true].map do |interlace|
+          new(image_optim, options.merge(:interlace => interlace))
+        end
+      end
+
+      INTERLACE_OPTION =
+      option(:interlace, false, TrueFalseNil, 'Interlace: '\
+          '`true` - interlace on, '\
+          '`false` - interlace off, '\
+          '`nil` - as is in original image '\
+          '(defaults to running two instances, one with interlace off and '\
+          'one with on)') do |v|
+        TrueFalseNil.convert(v)
+      end
+
+      LEVEL_OPTION =
+      option(:level, 3, 'Compression level: '\
+          '`1` - light and fast, '\
+          '`2` - normal, '\
+          '`3` - heavy (slower)') do |v|
+        OptionHelpers.limit_with_range(v.to_i, 1..3)
+      end
+
+      CAREFUL_OPTION =
+      option(:careful, false, 'Avoid bugs with some software'){ |v| !!v }
+
+      TIMEOUT_OPTION = timeout_option
+
+      def optimize(src, dst)
+        args = %W[
+          --output=#{dst}
+          --no-comments
+          --no-names
+          --same-delay
+          --same-loopcount
+          --no-warnings
+          --
+          #{src}
+        ]
+
+        if resolve_bin!(:gifsicle).version >= '1.85'
+          args.unshift '--no-extensions', '--no-app-extensions'
+        end
+
+        unless interlace.nil?
+          args.unshift interlace ? '--interlace' : '--no-interlace'
+        end
+        args.unshift '--careful' if careful
+        args.unshift "--optimize=#{level}" if level
+        execute(:gifsicle, *args) && optimized?(src, dst)
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jhead.rb

@@ -0,0 +1,47 @@
+require 'image_optim/worker'
+require 'exifr'
+
+class ImageOptim
+  class Worker
+    # http://www.sentex.net/~mwandel/jhead/
+    #
+    # Jhead internally uses jpegtran which should be on path
+    class Jhead < Worker
+      TIMEOUT_OPTION = timeout_option
+
+      ORIENTED = 2..8 # not top-left
+
+      # Works on jpegs
+      def image_formats
+        [:jpeg]
+      end
+
+      # Run first, while exif is still present
+      def run_order
+        -10
+      end
+
+      def used_bins
+        [:jhead, :jpegtran]
+      end
+
+      def optimize(src, dst)
+        return false unless oriented?(src)
+        src.copy(dst)
+        args = %W[
+          -autorot
+          #{dst}
+        ]
+        resolve_bin!(:jpegtran)
+        execute(:jhead, *args) && dst.size?
+      end
+
+    private
+
+      def oriented?(image)
+        exif = EXIFR::JPEG.new(image.to_s)
+        ORIENTED.include?(exif.orientation.to_i)
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jpegoptim.rb

@@ -0,0 +1,63 @@
+require 'image_optim/worker'
+require 'image_optim/option_helpers'
+
+class ImageOptim
+  class Worker
+    # http://www.kokkonen.net/tjko/projects.html
+    class Jpegoptim < Worker
+      ALLOW_LOSSY_OPTION =
+      option(:allow_lossy, false, 'Allow limiting maximum quality'){ |v| !!v }
+
+      STRIP_OPTION =
+      option(:strip, :all, Array, 'List of extra markers to strip: '\
+          '`:comments`, '\
+          '`:exif`, '\
+          '`:iptc`, '\
+          '`:icc` or '\
+          '`:all`') do |v|
+        values = Array(v).map(&:to_s)
+        known_values = %w[all comments exif iptc icc]
+        unknown_values = values - known_values
+        unless unknown_values.empty?
+          warn "Unknown markers for jpegoptim: #{unknown_values.join(', ')}"
+        end
+        values & known_values
+      end
+
+      MAX_QUALITY_OPTION =
+      option(:max_quality, 100, 'Maximum image quality factor '\
+          '`0`..`100`, ignored in default/lossless mode') do |v, opt_def|
+        if allow_lossy
+          OptionHelpers.limit_with_range(v.to_i, 0..100)
+        else
+          if v != opt_def.default
+            warn "#{self.class.bin_sym} #{opt_def.name} #{v} ignored " \
+                'in lossless mode'
+          end
+          opt_def.default
+        end
+      end
+
+      TIMEOUT_OPTION = timeout_option
+
+      # Run earlier if max_quality is less than 100
+      def run_order
+        max_quality < 100 ? -1 : 0
+      end
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[
+          --quiet
+          --
+          #{dst}
+        ]
+        strip.each do |strip_marker|
+          args.unshift "--strip-#{strip_marker}"
+        end
+        args.unshift "--max=#{max_quality}" if max_quality < 100
+        execute(:jpegoptim, *args) && optimized?(src, dst)
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jpegrecompress.rb

@@ -0,0 +1,49 @@
+require 'image_optim/worker'
+require 'image_optim/option_helpers'
+
+class ImageOptim
+  class Worker
+    # https://github.com/danielgtaylor/jpeg-archive#jpeg-recompress
+    class Jpegrecompress < Worker
+      ALLOW_LOSSY_OPTION =
+      option(:allow_lossy, false, 'Allow worker, it is always lossy'){ |v| !!v }
+
+      # Initialize only if allow_lossy
+      def self.init(image_optim, options = {})
+        super if options[:allow_lossy]
+      end
+
+      QUALITY_NAMES = [:low, :medium, :high, :veryhigh].freeze
+
+      quality_names_desc = QUALITY_NAMES.each_with_index.map do |name, i|
+        "`#{i}` - #{name}"
+      end.join(', ')
+
+      QUALITY_OPTION =
+      option(:quality, 3, "JPEG quality preset: #{quality_names_desc}") do |v|
+        OptionHelpers.limit_with_range(v.to_i, 0...QUALITY_NAMES.length)
+      end
+
+      TIMEOUT_OPTION = timeout_option
+
+      def used_bins
+        [:'jpeg-recompress']
+      end
+
+      # Run early as lossy worker
+      def run_order
+        -5
+      end
+
+      def optimize(src, dst)
+        args = %W[
+          --quality #{QUALITY_NAMES[quality]}
+          --no-copy
+          #{src}
+          #{dst}
+        ]
+        execute(:'jpeg-recompress', *args) && optimized?(src, dst)
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jpegtran.rb

@@ -0,0 +1,48 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    # http://www.ijg.org/
+    #
+    # Uses jpegtran through jpegrescan if enabled, jpegrescan is vendored with
+    # this gem
+    class Jpegtran < Worker
+      COPY_CHUNKS_OPTION =
+      option(:copy_chunks, false, 'Copy all chunks'){ |v| !!v }
+
+      PROGRESSIVE_OPTION =
+      option(:progressive, true, 'Create progressive JPEG file'){ |v| !!v }
+
+      JPEGRESCAN_OPTION =
+      option(:jpegrescan, false, 'Use jpegtran through jpegrescan, '\
+          'ignore progressive option'){ |v| !!v }
+
+      TIMEOUT_OPTION = timeout_option
+
+      def used_bins
+        jpegrescan ? [:jpegtran, :jpegrescan] : [:jpegtran]
+      end
+
+      def optimize(src, dst)
+        if jpegrescan
+          args = %W[
+            #{src}
+            #{dst}
+          ]
+          args.unshift '-s' unless copy_chunks
+          resolve_bin!(:jpegtran)
+          execute(:jpegrescan, *args) && optimized?(src, dst)
+        else
+          args = %W[
+            -optimize
+            -outfile #{dst}
+            #{src}
+          ]
+          args.unshift '-copy', (copy_chunks ? 'all' : 'none')
+          args.unshift '-progressive' if progressive
+          execute(:jpegtran, *args) && optimized?(src, dst)
+        end
+      end
+    end
+  end
+end

data/lib/image_optim/worker/optipng.rb

@@ -0,0 +1,53 @@
+require 'image_optim/worker'
+require 'image_optim/option_helpers'
+require 'image_optim/true_false_nil'
+
+class ImageOptim
+  class Worker
+    # http://optipng.sourceforge.net/
+    class Optipng < Worker
+      LEVEL_OPTION =
+      option(:level, 6, 'Optimization level preset: '\
+          '`0` is least, '\
+          '`7` is best') do |v|
+        OptionHelpers.limit_with_range(v.to_i, 0..7)
+      end
+
+      INTERLACE_OPTION =
+      option(:interlace, false, TrueFalseNil, 'Interlace: '\
+          '`true` - interlace on, '\
+          '`false` - interlace off, '\
+          '`nil` - as is in original image') do |v|
+        TrueFalseNil.convert(v)
+      end
+
+      STRIP_OPTION =
+      option(:strip, true, 'Remove all auxiliary chunks'){ |v| !!v }
+
+      TIMEOUT_OPTION = timeout_option
+
+      def run_order
+        -4
+      end
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[
+          -o #{level}
+          -quiet
+          --
+          #{dst}
+        ]
+        args.unshift "-i#{interlace ? 1 : 0}" unless interlace.nil?
+        if resolve_bin!(:optipng).version >= '0.7'
+          args.unshift '-strip', 'all' if strip
+        end
+        execute(:optipng, *args) && optimized?(src, dst)
+      end
+
+      def optimized?(src, dst)
+        interlace ? dst.size? : super
+      end
+    end
+  end
+end