middleman-imageoptim 0.1.4 → 0.2.0

data/lib/middleman-imageoptim/manifest_resource.rb

@@ -0,0 +1,41 @@
+module Middleman
+  module Imageoptim
+    class ManifestResource < ::Middleman::Sitemap::Resource
+      attr_accessor :output
+
+      def template?
+        false
+      end
+
+      def render(*_args, &_block)
+        manifest_content
+      end
+
+      def binary?
+        false
+      end
+
+      def raw_data
+        {}
+      end
+
+      def ignored?
+        false
+      end
+
+      def metadata
+        @local_metadata.dup
+      end
+
+      private
+
+      def manifest_content
+        if @source_file.nil?
+          YAML.dump({})
+        else
+          File.read(@source_file)
+        end
+      end
+    end
+  end
+end

data/lib/middleman-imageoptim/optimizer.rb

@@ -1,107 +1,104 @@
 module Middleman
   module Imageoptim
-    require "image_optim"
-    require "fileutils"
+    require 'image_optim'
+    require 'fileutils'
 
     # Optimizer class that accepts an options object and processes files and
     # passes them off to image_optim to be processed
     class Optimizer
-      def initialize(app, builder, options)
-        @app           = app
-        @builder       = builder
-        @options       = options
-        @total_savings = 0
-      end
+      attr_reader :app, :builder, :options, :byte_savings
 
-      def optimize!
-        images_to_optimize = filter_file_paths(file_paths())
-        optimizer.optimize_images(images_to_optimize) {|src_file, dst_file|
-          if dst_file
-            @total_savings += (src_file.size - dst_file.size)
-            say_file_size_stats(src_file, dst_file)
-            FileUtils.mv dst_file, src_file
-          elsif @options.verbose
-            say_status "[skipped] #{src_file}"
-          end
-        }
-        say_status "Total image savings: #{format_size(@total_savings)}"
+      def self.optimize!(app, builder, options)
+        new(app, builder, options).process_images
       end
 
-      def filter_file_paths(paths)
-        paths.select {|path|
-          is_image_extension(path.extname) && image_is_optimizable(path)
-        }
+      def initialize(app, builder, options)
+        @app = app
+        @builder = builder
+        @options = options
+        @byte_savings = 0
       end
 
-      def is_image_extension(extension)
-        @options.image_extensions.include?(extension)
+      def process_images
+        images = updated_images
+        modes = preoptimize_modes(images)
+        optimizer.optimize_images(images) do |source, destination|
+          process_image(source, destination, modes.fetch(source.to_s))
+        end
+        update_manifest
+        say_status 'Total savings: %{data}', data: Utils.format_size(byte_savings)
       end
 
-      def image_is_optimizable(path)
-        optimizer.optimizable?(path)
+      private
+
+      def update_manifest
+        return unless options.manifest
+        manifest.build_and_write(optimizable_images)
+        say_status '%{manifest_path} updated', manifest_path: manifest.path
       end
 
-      def size_change_word(size_src, size_dst)
-        size_difference = (size_src - size_dst)
-        if size_difference > 0
-          'smaller'
-        elsif size_difference < 0
-          'larger'
+      def process_image(source, destination = nil, mode = nil)
+        if destination
+          update_bytes_saved(source.size - destination.size)
+          say_status '%{source} (%{percent_change} / %{size_change} %{size_change_type})', Utils.file_size_stats(source, destination)
+          FileUtils.move(destination, source)
         else
-          'no change'
+          say_status '[skipped] %{source} not updated', source: source
         end
+      ensure
+        ensure_file_mode(mode, source) unless mode.nil?
       end
 
-      def percentage_change(size_src, size_dst)
-        '%.2f%%' % [100 - 100.0 * size_dst / size_src]
+      def updated_images
+        optimizable_images.select { |path| file_updated?(path) }
       end
 
-      private
-
-      def file_paths
-        ::Middleman::Util.all_files_under(@app.inst.build_dir)
+      def optimizable_images
+        build_files.select do |path|
+          options.image_extensions.include?(File.extname(path)) && optimizer.optimizable?(path)
+        end
       end
 
-      def say_file_size_stats(src_file, dst_file)
-        file_percent_change = percentage_change(src_file.size, dst_file.size)
-        file_size_change = format_size((src_file.size - dst_file.size))
-        file_size_change_type = size_change_word(src_file.size, dst_file.size)
-        say_status "#{src_file} (#{file_percent_change} / #{file_size_change} #{file_size_change_type})"
+      def file_updated?(file_path)
+        return true unless options.manifest
+        File.mtime(file_path) != manifest.resource(file_path)
       end
 
-      def say_status(status)
-        if @builder
-          @builder.say_status :image_optim, status
+      def preoptimize_modes(images)
+        images.inject({}) do |modes, image|
+          modes[image.to_s] = get_file_mode(image)
+          modes
         end
       end
 
+      def build_files
+        ::Middleman::Util.all_files_under(app.build_dir)
+      end
+
+      def say_status(status, interpolations = {})
+        builder.say_status(:imageoptim, status % interpolations) if builder
+      end
+
       def optimizer
-        @optimizer ||= ImageOptim.new(
-          :nice      => @options.nice,
-          :threads   => @options.threads,
-          :pngcrush  => @options.pngcrush_options,
-          :pngout    => @options.pngout_options,
-          :optipng   => @options.optipng_options,
-          :advpng    => @options.advpng_options,
-          :jpegoptim => @options.jpegoptim_options,
-          :jpegtran  => @options.jpegtran_options,
-          :gifsicle  => @options.gifsicle_options
-        )
-      end
-
-      def format_size(bytes)
-        units = %W(B KiB MiB GiB TiB)
-
-        if bytes.to_i < 1024
-          exponent = 0
-        else
-          max_exp  = units.size - 1
-          exponent = (Math.log(bytes) / Math.log(1024)).to_i
-          exponent = max_exp if exponent > max_exp
-          bytes  /= 1024 ** exponent
-        end
+        @optimizer ||= ImageOptim.new(options.imageoptim_options)
+      end
+
+      def manifest
+        @manifest ||= Manifest.new(app)
+      end
+
+      def update_bytes_saved(bytes)
+        @byte_savings += bytes
+      end
+
+      def get_file_mode(file)
+        sprintf('%o', File.stat(file).mode)[-4, 4].gsub(/^0*/, '')
+      end
 
-        "#{bytes}#{units[exponent]}"
+      def ensure_file_mode(mode, file)
+        return if mode == get_file_mode(file)
+        FileUtils.chmod(mode.to_i(8), file)
+        say_status 'fixed file mode on %{file} file to match source', file: file
       end
     end
   end

data/lib/middleman-imageoptim/options.rb

@@ -1,64 +1,54 @@
 module Middleman
   module Imageoptim
-
     # An options store that handles default options will accept user defined
     # overrides
     class Options
-      attr_accessor :user_options
-      attr_reader :verbose, :nice, :threads, :image_extensions,
-        :pngcrush_options, :pngout_options, :optipng_options, :advpng_options,
-        :jpegoptim_options, :jpegtran_options, :gifsicle_options
-
-      UserOptions = Struct.new(:verbose, :nice, :threads, :image_extensions,
-        :pngcrush_options, :pngout_options, :optipng_options, :advpng_options,
-        :jpegoptim_options, :jpegtran_options, :gifsicle_options)
-
-      def initialize(options_hash = {})
-        @user_options = UserOptions.new(*options_hash)
-      end
-
-      def verbose
-        !@user_options.verbose.nil? ? @user_options.verbose : false
-      end
-
-      def nice
-        !@user_options.nice.nil? ? @user_options.nice : true
-      end
-
-      def threads
-        !@user_options.threads.nil? ? @user_options.threads : true
-      end
-
-      def image_extensions
-        !@user_options.image_extensions.nil? ? @user_options.image_extensions : %w(.png .jpg .gif)
-      end
-
-      def pngcrush_options
-        !@user_options.pngcrush_options.nil? ? @user_options.pngcrush_options : {:chunks => ['alla'], :fix => false, :brute => false}
-      end
-
-      def pngout_options
-        !@user_options.pngout_options.nil? ? @user_options.pngout_options : {:copy_chunks => false, :strategy => 0}
-      end
-
-      def optipng_options
-        !@user_options.optipng_options.nil? ? @user_options.optipng_options : {:level => 6, :interlace => false}
-      end
-
-      def advpng_options
-        !@user_options.advpng_options.nil? ? @user_options.advpng_options : {:level => 4}
-      end
-
-      def jpegoptim_options
-        !@user_options.jpegoptim_options.nil? ? @user_options.jpegoptim_options : {:strip => ['all'], :max_quality => 100}
-      end
-
-      def jpegtran_options
-        !@user_options.jpegtran_options.nil? ? @user_options.jpegtran_options : {:copy_chunks => false, :progressive => true, :jpegrescan => true}
-      end
-
-      def gifsicle_options
-        !@user_options.gifsicle_options.nil? ? @user_options.gifsicle_options : {:interlace => false}
+      # Mapping of valid option names to default values
+      EXTENSION_OPTIONS = [
+        :image_extensions,
+        :manifest
+      ]
+      OPTIONS = {
+        advpng: { level: 4 },
+        allow_lossy: false,
+        gifsicle: { interlace: false },
+        image_extensions: %w(.png .jpg .jpeg .gif .svg),
+        jpegoptim: { strip: ['all'], max_quality: 100 },
+        jpegtran: { copy_chunks: false, progressive: true, jpegrescan: true },
+        nice: true,
+        manifest: true,
+        optipng: { level: 6, interlace: false },
+        pack: true,
+        pngcrush: { chunks: ['alla'], fix: false, brute: false },
+        pngout: { copy_chunks: false, strategy: 0 },
+        skip_missing_workers: true,
+        svgo: {},
+        threads: true,
+        verbose: false
+      }
+
+      attr_accessor *OPTIONS.keys.map(&:to_sym)
+
+      def initialize(user_options = {})
+        set_options(user_options)
+      end
+
+      def imageoptim_options
+        Hash[instance_variables.map do |name|
+          [symbolize_key(name), instance_variable_get(name)]
+        end].reject { |key| EXTENSION_OPTIONS.include?(key) }
+      end
+
+      private
+
+      def symbolize_key(key)
+        key.to_s[1..-1].to_sym
+      end
+
+      def set_options(user_options)
+        OPTIONS.keys.each do |name|
+          instance_variable_set(:"@#{name}", user_options.fetch(name, OPTIONS[name]))
+        end
       end
     end
   end

data/lib/middleman-imageoptim/resource_list.rb

@@ -0,0 +1,72 @@
+module Middleman
+  module Imageoptim
+    class ResourceList
+      attr_reader :app, :options
+
+      def self.manipulate(app, resources, options)
+        new(app, resources, options).manipulate_resources
+      end
+
+      def initialize(app, resources, options)
+        @app = app
+        @resources = resources
+        @options = options
+      end
+
+      def manipulate_resources
+        modified_resources << manifest_resource
+      end
+
+      private
+
+      def modified_resources
+        @resources.map do |resource|
+          if resource_up_to_date?(resource)
+            Middleman::Sitemap::Resource.new(
+              app.sitemap,
+              resource.destination_path,
+              File.join(app.build_dir, resource.destination_path)
+            )
+          else
+            resource
+          end
+        end
+      end
+
+      def manifest_resource
+        resource_args = [app.sitemap, Manifest::MANIFEST_FILENAME]
+        if File.exist?(File.join(app.build_dir, Manifest::MANIFEST_FILENAME))
+          resource_args << File.join(app.build_dir, Manifest::MANIFEST_FILENAME)
+        end
+        Middleman::Imageoptim::ManifestResource.new(*resource_args)
+      end
+
+      def resource_up_to_date?(resource)
+        image_resource?(resource) &&
+          sitemap_resource?(resource) &&
+          resource_exists?(resource) &&
+          resource_current?(resource)
+      end
+
+      def image_resource?(resource)
+        options.image_extensions.include?(File.extname(resource.destination_path))
+      end
+
+      def sitemap_resource?(resource)
+        resource.class.name == 'Middleman::Sitemap::Resource'
+      end
+
+      def resource_exists?(resource)
+        File.exist?(resource_build_path(resource))
+      end
+
+      def resource_current?(resource)
+        File.mtime(resource_build_path(resource)) > File.mtime(resource.source_file)
+      end
+
+      def resource_build_path(resource)
+        File.join(app.build_dir, resource.destination_path)
+      end
+    end
+  end
+end

data/lib/middleman-imageoptim/utils.rb

@@ -0,0 +1,42 @@
+module Middleman
+  module Imageoptim
+    module Utils
+      def self.size_change_word(size_a, size_b)
+        size_difference = (size_a - size_b)
+        if size_difference > 0
+          'smaller'
+        elsif size_difference < 0
+          'larger'
+        else
+          'no change'
+        end
+      end
+
+      def self.percentage_change(size_a, size_b)
+        '%.2f%%' % [100 - 100.0 * size_b / size_a]
+      end
+
+      def self.format_size(bytes)
+        units = %w(B KiB MiB GiB TiB)
+        if bytes.to_i < 1024
+          exponent = 0
+        else
+          max_exp  = units.size - 1
+          exponent = (Math.log(bytes) / Math.log(1024)).to_i
+          exponent = max_exp if exponent > max_exp
+          bytes  /= 1024**exponent
+        end
+        "#{bytes}#{units[exponent]}"
+      end
+
+      def self.file_size_stats(source, destination)
+        {
+          source: source,
+          percent_change: percentage_change(source.size, destination.size),
+          size_change: format_size((source.size - destination.size)),
+          size_change_type: size_change_word(source.size, destination.size)
+        }
+      end
+    end
+  end
+end

data/lib/middleman-imageoptim/version.rb

@@ -1,6 +1,6 @@
 module Middleman
   module Imageoptim
     PACKAGE = 'middleman-imageoptim'
-    VERSION = "0.1.4"
+    VERSION = '0.2.0'
   end
 end