discourse_image_optim 0.24.4

data/lib/image_optim/bin_resolver/comparable_condition.rb

@@ -0,0 +1,60 @@
+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|
+            ComparableCondition.new(method, *args)
+          end
+        end
+      end
+
+      def self.is
+        Builder.new
+      end
+
+      attr_reader :method, :args
+      def initialize(method, *args)
+        @method, @args = method.to_sym, args
+
+        case @method
+        when :between?
+          @args.length == 2 || argument_error!("`between?' expects 2 arguments")
+        when :<, :<=, :==, :>, :>=
+          @args.length == 1 || argument_error!("`#{method}' expects 1 argument")
+        else
+          argument_error! "Unknown method `#{method}'"
+        end
+      end
+
+      def ===(other)
+        other.send(@method, *@args)
+      end
+      alias_method :match, :===
+
+      def to_s
+        if @method == :between?
+          @args.join('..')
+        else
+          "#{@method} #{@args.first}"
+        end
+      end
+
+    private
+
+      def argument_error!(message)
+        fail ArgumentError, message
+      end
+    end
+  end
+end

data/lib/image_optim/bin_resolver/error.rb

@@ -0,0 +1,6 @@
+class ImageOptim
+  class BinResolver
+    # Base error during bin resolving
+    class Error < StandardError; end
+  end
+end

data/lib/image_optim/bin_resolver/simple_version.rb

@@ -0,0 +1,31 @@
+class ImageOptim
+  class BinResolver
+    # Allows comparision of simple versions, only numbers separated by dots are
+    # taken into account
+    class SimpleVersion
+      include Comparable
+
+      # Numbers extracted from version string
+      attr_reader :parts
+
+      # Initialize with a string or an object convertible to string
+      #
+      #    SimpleVersion.new('2.0.1') <=> SimpleVersion.new(2)
+      def initialize(str)
+        @str = String(str)
+        @parts = @str.split('.').map(&:to_i).reverse.drop_while(&:zero?).reverse
+      end
+
+      # Returns original version string
+      def to_s
+        @str
+      end
+
+      # Compare version parts of self with other
+      def <=>(other)
+        other = self.class.new(other) unless other.is_a?(self.class)
+        parts <=> other.parts
+      end
+    end
+  end
+end

data/lib/image_optim/cache.rb

@@ -0,0 +1,72 @@
+require 'digest/sha1'
+require 'fspath'
+require 'image_optim/cache_path'
+
+class ImageOptim
+  # Handles image cache
+  class Cache
+    def initialize(image_optim, workers_by_format)
+      return unless image_optim.cache_dir
+      @cache_dir = FSPath.new(image_optim.cache_dir)
+      @cache_worker_digests = image_optim.cache_worker_digests
+      @options_by_format = Hash[workers_by_format.map do |format, workers|
+        [format, workers.map(&:inspect).sort.join(', ')]
+      end]
+      @bins_by_format = Hash[workers_by_format.map do |format, workers|
+        [format, workers.map(&:used_bins).flatten!.map! do |sym|
+          bin = image_optim.resolve_bin!(sym)
+          "#{bin.name}[#{bin.digest}]"
+        end.sort!.uniq.join(', ')]
+      end]
+    end
+
+    def fetch(original)
+      return yield unless @cache_dir
+
+      digest = digest(original, original.image_format)
+      cached = @cache_dir / digest
+      return cached.size? && CachePath.convert(cached) if cached.file?
+
+      optimized = yield
+
+      cached.dirname.mkpath
+
+      if optimized
+        tmp = FSPath.temp_file_path(digest, @cache_dir)
+        FileUtils.mv(optimized, tmp)
+        tmp.chmod(0o666 & ~File.umask)
+        tmp.rename(cached)
+        cached_path = CachePath.convert(cached)
+
+        # mark cached image as already optimized
+        cached = @cache_dir / digest(cached, original.image_format)
+        cached.dirname.mkpath
+        FileUtils.touch(cached)
+
+        cached_path
+      else
+        # mark image as already optimized
+        FileUtils.touch(cached)
+        nil
+      end
+    end
+
+  private
+
+    def options_by_format(format)
+      @options_by_format[format]
+    end
+
+    def bins_by_format(format)
+      @bins_by_format[format]
+    end
+
+    def digest(path, format)
+      digest = Digest::SHA1.file(path)
+      digest.update options_by_format(format)
+      digest.update bins_by_format(format) if @cache_worker_digests
+      s = digest.hexdigest
+      "#{s[0..1]}/#{s[2..-1]}"
+    end
+  end
+end

data/lib/image_optim/cache_path.rb

@@ -0,0 +1,16 @@
+require 'image_optim/path'
+
+class ImageOptim
+  # ImageOptiom::Path with a non self destructing #replace method
+  class CachePath < Path
+    # Atomic replace dst with self
+    def replace(dst)
+      dst = self.class.new(dst)
+      dst.temp_path(dst.dirname) do |temp|
+        copy(temp)
+        dst.copy_metadata(temp)
+        temp.rename(dst.to_s)
+      end
+    end
+  end
+end

data/lib/image_optim/cmd.rb

@@ -0,0 +1,122 @@
+require 'English'
+require 'open3'
+
+class ImageOptim
+  # Helper for running commands
+  module Cmd
+    class TimeoutExceeded < StandardError; end
+
+    class << self
+      # Run using `system`
+      # Return success status
+      # Will raise SignalException if process was interrupted
+      def run(*args)
+        success = system(*args)
+
+        check_status!
+
+        success
+      end
+
+      def support_timeout?
+        if defined?(JRUBY_VERSION)
+          JRUBY_VERSION >= '9.0.0.0'
+        else
+          RUBY_VERSION >= '1.9'
+        end
+      end
+
+      # Run the specified command, and kill it off if it runs longer
+      # than `timeout` seconds.
+      #
+      # Return success status
+      # Will raise an error when command timeouts
+      def run_with_timeout(timeout, *args)
+        return run(*args) unless timeout > 0 && support_timeout?
+
+        success = false
+        init_options!(args)
+
+        begin
+          stdin, stdout, thread = Open3.popen2(*args)
+          stdin.close
+          stdout.close
+
+          pid = thread[:pid]
+
+          if thread.join(timeout).nil?
+            cleanup_process(pid)
+            thread.kill
+            fail TimeoutExceeded
+          else
+            success = thread.value.exitstatus.zero?
+          end
+        end
+
+        success
+      end
+
+      # Run using backtick
+      # Return captured output
+      # Will raise SignalException if process was interrupted
+      def capture(cmd)
+        output = `#{cmd}`
+
+        check_status!
+
+        output
+      end
+
+    private
+
+      def check_status!
+        status = $CHILD_STATUS
+
+        return unless status.signaled?
+
+        # jruby incorrectly returns true for `signaled?` if process exits with
+        # non zero status. For following code
+        #
+        #     `sh -c 'exit 66'`
+        #     p [$?.signaled?, $?.exitstatus, $?.termsig]
+        #
+        # jruby outputs `[true, 66, 66]` instead of expected `[false, 66, nil]`
+        return if defined?(JRUBY_VERSION) && status.exitstatus == status.termsig
+
+        fail SignalException, status.termsig
+      end
+
+      def init_options!(args)
+        pgroup_opt = Gem.win_platform? ? :new_pgroup : :pgroup
+
+        if args.last.is_a?(Hash)
+          args.last[pgroup_opt] = true
+        else
+          args.push(pgroup_opt => true)
+        end
+      end
+
+      def cleanup_process(pid)
+        Thread.new do
+          Process.kill('-TERM', pid)
+          Process.detach(pid)
+          now = Time.now
+
+          while Time.now - now < 10
+            begin
+              Process.kill(0, pid)
+              sleep 0.001
+              next
+            rescue Errno::ESRCH
+              break
+            end
+          end
+
+          if Process.getpgid(pid)
+            Process.kill('-KILL', pid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/image_optim/config.rb

@@ -0,0 +1,219 @@
+require 'image_optim/option_helpers'
+require 'image_optim/configuration_error'
+require 'image_optim/hash_helpers'
+require 'image_optim/worker'
+require 'image_optim/cmd'
+require 'set'
+require 'yaml'
+
+class ImageOptim
+  # Read, merge and parse configuration
+  class Config
+    include OptionHelpers
+
+    # Global config path at `$XDG_CONFIG_HOME/image_optim.yml` (by default
+    # `~/.config/image_optim.yml`)
+    GLOBAL_PATH = begin
+      File.join(ENV['XDG_CONFIG_HOME'] || '~/.config', 'image_optim.yml')
+    end
+
+    # Local config path at `./.image_optim.yml`
+    LOCAL_PATH = './.image_optim.yml'.freeze
+
+    class << self
+      # Read options at path: expand path (warn on failure), return {} if file
+      # does not exist or is empty, read yaml, check if it is a Hash, deep
+      # symbolise keys
+      def read_options(path)
+        begin
+          full_path = File.expand_path(path)
+        rescue ArgumentError => e
+          warn "Can't expand path #{path}: #{e}"
+          return {}
+        end
+        return {} unless File.size?(full_path)
+        config = YAML.load_file(full_path)
+        unless config.is_a?(Hash)
+          fail "expected hash, got #{config.inspect}"
+        end
+        HashHelpers.deep_symbolise_keys(config)
+      rescue => e
+        warn "exception when reading #{full_path}: #{e}"
+        {}
+      end
+    end
+
+    # Merge config from files with passed options
+    # Config files are checked at `GLOBAL_PATH` and `LOCAL_PATH` unless
+    # overriden using `:config_paths`
+    def initialize(options)
+      config_paths = options.delete(:config_paths) || [GLOBAL_PATH, LOCAL_PATH]
+      config_paths = Array(config_paths)
+
+      to_merge = config_paths.map{ |path| self.class.read_options(path) }
+      to_merge << HashHelpers.deep_symbolise_keys(options)
+
+      @options = to_merge.reduce do |memo, hash|
+        HashHelpers.deep_merge(memo, hash)
+      end
+      @used = Set.new
+    end
+
+    # Gets value for key converted to symbol and mark option as used
+    def get!(key)
+      key = key.to_sym
+      @used << key
+      @options[key]
+    end
+
+    # Check if key is present
+    def key?(key)
+      key = key.to_sym
+      @options.key?(key)
+    end
+
+    # Fail unless all options were marked as used (directly or indirectly
+    # accessed using `get!`)
+    def assert_no_unused_options!
+      unknown_options = @options.reject{ |key, _value| @used.include?(key) }
+      return if unknown_options.empty?
+      fail ConfigurationError, "unknown options #{unknown_options.inspect}"
+    end
+
+    # Nice level:
+    # * `10` by default and for `nil` or `true`
+    # * `0` for `false`
+    # * otherwise convert to integer
+    def nice
+      nice = get!(:nice)
+
+      case nice
+      when true, nil
+        10
+      when false
+        0
+      else
+        nice.to_i
+      end
+    end
+
+    # Number of parallel threads:
+    # * `processor_count` by default and for `nil` or `true`
+    # * `1` for `false`
+    # * otherwise convert to integer
+    def threads
+      threads = get!(:threads)
+
+      case threads
+      when true, nil
+        processor_count
+      when false
+        1
+      else
+        threads.to_i
+      end
+    end
+
+    # Verbose mode, converted to boolean
+    def verbose
+      !!get!(:verbose)
+    end
+
+    # Using image_optim_pack:
+    # * `false` to disable
+    # * `nil` to use if available
+    # * everything else to require
+    def pack
+      pack = get!(:pack)
+      return false if pack == false
+
+      require 'image_optim/pack'
+      true
+    rescue LoadError => e
+      raise "Cannot load image_optim_pack: #{e}" if pack
+      false
+    end
+
+    # Skip missing workers, converted to boolean
+    def skip_missing_workers
+      if key?(:skip_missing_workers)
+        !!get!(:skip_missing_workers)
+      else
+        pack
+      end
+    end
+
+    # Allow lossy workers and optimizations, converted to boolean
+    def allow_lossy
+      !!get!(:allow_lossy)
+    end
+
+    def cache_dir
+      dir = get!(:cache_dir)
+      dir unless dir.nil? || dir.empty?
+    end
+
+    def cache_worker_digests
+      !!get!(:cache_worker_digests)
+    end
+
+    def timeout
+      timeout = get!(:timeout)
+      timeout ? timeout.to_i : 0
+    end
+
+    # Options for worker class by its `bin_sym`:
+    # * `Hash` passed as is
+    # * `{}` for `true` or `nil`
+    # * `false` for `false`
+    # * otherwise fail with `ConfigurationError`
+    def for_worker(klass)
+      worker_options = get!(klass.bin_sym)
+
+      case worker_options
+      when Hash
+        worker_options
+      when true, nil
+        {}
+      when false
+        {:disable => true}
+      else
+        fail ConfigurationError, "Got #{worker_options.inspect} for "\
+            "#{klass.name} options"
+      end
+    end
+
+    # yaml dump without document beginning prefix `---`
+    def to_s
+      YAML.dump(HashHelpers.deep_stringify_keys(@options)).sub(/\A---\n/, '')
+    end
+
+  private
+
+    # http://stackoverflow.com/a/6420817
+    def processor_count
+      @processor_count ||= case host_os = RbConfig::CONFIG['host_os']
+      when /darwin9/
+        Cmd.capture 'hwprefs cpu_count'
+      when /darwin/
+        if (Cmd.capture 'which hwprefs') != ''
+          Cmd.capture 'hwprefs thread_count'
+        else
+          Cmd.capture 'sysctl -n hw.ncpu'
+        end
+      when /linux/
+        Cmd.capture 'grep -c processor /proc/cpuinfo'
+      when /freebsd/
+        Cmd.capture 'sysctl -n hw.ncpu'
+      when /mswin|mingw/
+        require 'win32ole'
+        query = 'select NumberOfLogicalProcessors from Win32_Processor'
+        result = WIN32OLE.connect('winmgmts://').ExecQuery(query)
+        result.to_enum.first.NumberOfLogicalProcessors
+      else
+        warn "Unknown architecture (#{host_os}) assuming one processor."
+        1
+      end.to_i
+    end
+  end
+end