inkcite 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db3a1196fe9bcc49e718925d27731a469807acdc
-  data.tar.gz: 4dfc1aa8998ec37e5ed03a81facaf7f75ac6bfc9
+  metadata.gz: a5968f3e718b373eb3740d89dd019165130776a2
+  data.tar.gz: e961a846c6e2d0664a66a1ae5abc9ed791db34dd
 SHA512:
-  metadata.gz: e1e085b9a0668c30f9c6bd968f962caa42205b45702c4c9cba5893bb71ea1fe0b63f6e85c90e767912c42640f36f3a94ed11b54078d189323fc1886a5d37ab7c
-  data.tar.gz: 92166f271e19bbcc7058136e2d77a441179a341ef8107d19c24a0f15f8ddc883c319d5410a50edfecfdac89180b1d518dd5270a1614fd09846f8f3145c3d08c6
+  metadata.gz: 068fe33972b2d0f91a9c8be212ac3781392860d518aaf5277104cb3af1e1491766e2f3a5da47bed778bea41273bbd1fba3335c8f0d026845e16d29da85e06311
+  data.tar.gz: 4f39b31b971373bb1beb2ab1c6689a53bdd73a0e75d3def5bc2eeaae61e83449e7a43581bce9375d2434c2c7e6178a4b912b098459a304080acb11be46664595

data/README.md

@@ -112,7 +112,7 @@ developer questions in a timely manner.
 
 ## License
 
-Copyright (c) 2014-2015 Jeffrey D. Hoffman. MIT Licensed, see [LICENSE] for
+Copyright (c) 2014-2017 Jeffrey D. Hoffman. MIT Licensed, see [LICENSE] for
 details.
 
 [Middleman]: http://middlemanapp.com

data/inkcite.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'htmlbeautifier'
   spec.add_dependency 'image_optim'
   spec.add_dependency 'image_optim_pack'
+  spec.add_dependency 'kraken-io'
   spec.add_dependency 'listen'
   spec.add_dependency 'litmus'
   spec.add_dependency 'mail'

data/lib/inkcite.rb

@@ -23,13 +23,13 @@ require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/string/starts_ends_with'
 
 require 'inkcite/version'
+require 'inkcite/facade'
 require 'inkcite/email'
 require 'inkcite/util'
 require 'inkcite/view'
 require 'inkcite/minifier'
 require 'inkcite/parser'
 require 'inkcite/renderer'
-require 'inkcite/animation'
 
 module Inkcite
 

data/lib/inkcite/cli/server.rb

@@ -53,7 +53,8 @@ module Inkcite
         # InkciteApp to server the email as the root index page.
         app = Rack::Builder.new do
           use Rack::LiveReload
-          use Rack::Static, :urls => %w( /images /images-optim ), :root => '.'
+          use Rack::Static, :urls => %w( /images/ ), :root => '.'
+          use OptimizedImage, :email => email, :urls => %w( /images-optim/ ), :root => '.'
           run InkciteApp.new(email, opts)
         end
 
@@ -88,6 +89,35 @@ module Inkcite
 
       private
 
+      # Extends Rack::Static to provide dynamic image
+      # minification on demand.  When an image is requested
+      # from the images-optim directory, compression is
+      # performed on the desired image if necessary and then
+      # the optimized image is returned.
+      class OptimizedImage < Rack::Static
+
+        def initialize app, opts
+          @email = opts[:email]
+          super
+        end
+
+        def call env
+
+          # e.g. images-optim/my-image.jpg
+          path = env['PATH_INFO']
+
+          # Minify the image if the source version in images/ is newer
+          # or if the configuration file controlling optimization has
+          # been updated since the last time the image was requested.
+          Minifier.image(@email, File.basename(path), false) if can_serve(path)
+
+          # Let the super method handle the actual serving of the image.
+          super
+
+        end
+
+      end
+
       class InkciteApp
 
         def initialize email, opts
@@ -123,11 +153,6 @@ module Inkcite
             puts ''
             puts "#{ts} Rendering your email [environment=#{environment}, format=#{format}, version=#{version || 'default'}]"
 
-            # Before the rendering takes place, trigger image optimization of any
-            # new or updated images.  The {image} tag takes care of injecting the
-            # right path (optimized or not) depending on which version is needed.
-            @email.optimize_images
-
             view = @email.view(environment, format, version)
 
             html = view.render!

data/lib/inkcite/facade.rb

@@ -0,0 +1,6 @@
+# Manages the facade classes that make it easier to
+# work with HTML elements, CSS styles and animations.
+require_relative 'facade/animation'
+require_relative 'facade/element'
+require_relative 'facade/keyframe'
+require_relative 'facade/style'

data/lib/inkcite/{animation.rb → facade/animation.rb}

@@ -1,71 +1,27 @@
 module Inkcite
   class Animation
 
-    class Keyframe
+    # A collection of animations assigned to a single element.
+    class Composite
 
-      attr_reader :percent, :style
-
-      def initialize percent, ctx, styles={}
-
-        # Animation percents are always rounded to the nearest whole number.
-        @percent = percent.round(0)
-
-        # Instantiate a new Style for this percentage.
-        @style = Inkcite::Renderer::Style.new("#{@percent}%", ctx, styles)
-
-      end
-
-      def [] key
-        @style[key]
-      end
-
-      def []= key, val
-        @style[key] = val
-      end
-
-      # For style chaining - e.g. keyframe.add(:key1, 'val').add(:key)
-      def add key, val
-        @style[key] = val
-        self
+      def initialize
+        @animations = []
       end
 
-      # Appends a value to an existing key
-      def append key, val
-
-        @style[key] ||= ''
-        @style[key] << ' ' unless @style[key].blank?
-        @style[key] << val
-
-      end
-
-      def add_with_prefixes key, val, ctx
-
-        ctx.prefixes.each do |prefix|
-          _key = "#{prefix}#{key}".to_sym
-          self[_key] = val
-        end
-
-        self
+      def << animation
+        @animations << animation
       end
 
-      def to_css prefix
-        @style.to_css(prefix)
+      def to_keyframe_css
+        @animations.collect(&:to_keyframe_css).join("\n")
       end
 
-      private
-
-      # Creates a copy of the array of styles with the appropriate
-      # properties (e.g. transform) prefixed.
-      def get_prefixed_styles prefix
-
-        _styles = {}
+      def to_s
 
-        @styles.each_pair do |key, val|
-          key = "#{prefix}#{key}".to_sym if Inkcite::Renderer::Style.needs_prefixing?(key)
-          _styles[key] = val
-        end
+        # Render each of the animations in the collection and join them
+        # in a single, comma-delimited string.
+        @animations.collect(&:to_s).join(', ')
 
-        _styles
       end
 
     end
@@ -76,7 +32,9 @@ module Inkcite
     # Timing functions
     LINEAR = 'linear'
     EASE = 'ease'
+    EASE_IN = 'ease-in'
     EASE_IN_OUT = 'ease-in-out'
+    EASE_OUT = 'ease-out'
 
     # Animation name, view context and array of keyframes
     attr_reader :name, :ctx
@@ -106,6 +64,11 @@ module Inkcite
       keyframe
     end
 
+    # Returns true if this animation is blank - e.g. it has no keyframes.
+    def blank?
+      @keyframes.blank?
+    end
+
     def to_keyframe_css
 
       css = ''

data/lib/inkcite/facade/keyframe.rb

@@ -0,0 +1,83 @@
+module Inkcite
+  class Animation
+    class Keyframe
+
+      attr_reader :percent, :style
+
+      # Ending percentage the animation stays at this keyframe.  For
+      # example, a keyframe that starts at 20% and has a duration
+      # of 19.9% would render as 25%, 39.9% { ... }
+      attr_accessor :duration
+
+      def initialize percent, ctx, styles={}
+
+        # Animation percents are always rounded to the nearest whole number.
+        @percent = percent.round(0)
+        @duration = 0
+
+        # Instantiate a new Style for this percentage.
+        @style = Inkcite::Renderer::Style.new(nil, ctx, styles)
+
+      end
+
+      def [] key
+        @style[key]
+      end
+
+      def []= key, val
+        @style[key] = val
+      end
+
+      # For style chaining - e.g. keyframe.add(:key1, 'val').add(:key)
+      def add key, val
+        @style[key] = val
+        self
+      end
+
+      # Appends a value to an existing key
+      def append key, val
+
+        @style[key] ||= ''
+        @style[key] << ' ' unless @style[key].blank?
+        @style[key] << val
+
+      end
+
+      def add_with_prefixes key, val, ctx
+
+        ctx.prefixes.each do |prefix|
+          _key = "#{prefix}#{key}".to_sym
+          self[_key] = val
+        end
+
+        self
+      end
+
+      def to_css prefix
+        css = "#{@percent}%"
+        css << ", #{@percent + @duration.to_f}%" if @duration > 0
+        css << ' { '
+        css << @style.to_inline_css(prefix)
+        css << ' }'
+        css
+      end
+
+      private
+
+      # Creates a copy of the array of styles with the appropriate
+      # properties (e.g. transform) prefixed.
+      def get_prefixed_styles prefix
+
+        _styles = {}
+
+        @styles.each_pair do |key, val|
+          key = "#{prefix}#{key}".to_sym if Inkcite::Renderer::Style.needs_prefixing?(key)
+          _styles[key] = val
+        end
+
+        _styles
+      end
+
+    end
+  end
+end

data/lib/inkcite/{renderer → facade}/style.rb

@@ -18,6 +18,10 @@ module Inkcite
         @styles[key] = val
       end
 
+      def blank?
+        @styles.blank?
+      end
+
       def to_css allowed_prefixes=nil
         "#{@name} { #{to_inline_css(allowed_prefixes)} }"
       end

data/lib/inkcite/minifier.rb

@@ -2,7 +2,7 @@ module Inkcite
   class Minifier
 
     # Directory of optimized images
-    IMAGE_CACHE = "images-optim"
+    IMAGE_CACHE = 'images-optim'
 
     # Maximum line length for CSS and HTML - lines exceeding this length cause
     # problems in certain email clients.
@@ -40,14 +40,31 @@ module Inkcite
         # a semicolon or close bracket.
         if ctx.email? && code.length > MAXIMUM_LINE_LENGTH
 
-          # Position at which a line break will be inserted at.
-          break_at = 0
+          # Last position at which a line break was be inserted at.
+          last_break_at = 0
 
           # Work through the code injecting line breaks until either no further
           # breakable characters are found or we've reached the end of the code.
-          while break_at < code.length
-            break_at = code.rindex(/[;}]/, break_at + MAXIMUM_LINE_LENGTH) + 1
-            code.insert(break_at, "\n") if break_at && break_at < code.length
+          while last_break_at < code.length
+            break_at = code.rindex(/[ ,;{}]/, last_break_at + MAXIMUM_LINE_LENGTH)
+
+            # No further characters match (unlikely) or an unbroken string since
+            # the last time a break was injected.  Either way, let's get out.
+            break if break_at.nil? || break_at <= last_break_at
+
+            # If we've found a space we can break at, do a direct replacement of the
+            # space with a new line.  Otherwise, inject a new line one spot after
+            # the matching character.
+            if code[break_at] == ' '
+              code[break_at] = NEW_LINE
+
+            else
+              break_at += 1
+              code.insert(break_at, NEW_LINE)
+              break_at += 1
+            end
+
+            last_break_at = break_at
           end
 
         end
@@ -107,75 +124,79 @@ module Inkcite
 
     end
 
-    def self.images email, force=false
+    def self.image email, img_name, force=false
 
-      images_path = email.image_dir
-      cache_path = email.project_file(IMAGE_CACHE)
+      # Original, unoptimized source image
+      source_img = File.join(email.image_dir, img_name)
 
-      # Check to see if there is an image optim configuration file.
-      config_path = email.project_file(IMAGE_OPTIM_CONFIG_YML)
-      config_last_modified = Util.last_modified(config_path)
+      # Cached, optimized path for this image.
+      cache_path = email.project_file(IMAGE_CACHE)
+      cached_img = File.join(cache_path, File.basename(img_name))
 
-      # If the image cache exists, we need to check to see if any images have been
-      # removed since the last build.
-      if File.exist?(cache_path)
+      # Full path to the local project's kraken config if it exists
+      kraken_config_path = email.project_file(KRAKEN_CONFIG_YML)
 
-        # Get a list of the files in the cache that do not also exist in the
-        # project's images/ directory.
-        removed_images = Dir.entries(cache_path) - Dir.entries(images_path)
-        unless removed_images.blank?
+      # This is the array of config files that will be searched to
+      # determine which algorithm to use to compress the images.
+      config_paths = [
+          kraken_config_path,
+          email.project_file(IMAGE_OPTIM_CONFIG_YML),
+          File.join(Inkcite.asset_path, 'init', IMAGE_OPTIM_CONFIG_YML)
+      ]
 
-          # Convert the images to fully-qualified paths and then remove
-          # those files from the cache
-          removed_images = removed_images.collect { |img| File.join(cache_path, img) }
-          FileUtils.rm(removed_images)
+      # Grab the first file that exists for this project.
+      config_path = config_paths.detect { |p| File.exist?(p) }
 
-        end
+      unless force
 
-      end
+        # Get the last-modified date of the image optimization config
+        # file - if that file is newer than the image, re-optimization
+        # is necessary because the settings have changed.
+        config_last_modified = Util.last_modified(config_path)
 
-      # Check to see if there are new or updated images that need to be re-optimized.
-      # Compare existing images against both the most recently cached version and
-      # the timestamp of the config file.
-      updated_images = Dir.glob(File.join(images_path, '*.*')).select do |img|
-        cached_img = File.join(cache_path, File.basename(img))
+        # Get the last-modified date of the actual image.  If the source
+        # image is newer than the cached version, we'll need to run it
+        # through optimization again, too.
         cache_last_modified = Util.last_modified(cached_img)
-        force || config_last_modified > cache_last_modified || Util.last_modified(img) > cache_last_modified
-      end
+        source_last_modified = Util.last_modified(source_img)
+
+        # Nothing to do unless the image in the cache is older than the
+        # source or the config file.
+        return unless config_last_modified > cache_last_modified || source_last_modified > cache_last_modified
 
-      # Return unless there is something to compress
-      return if updated_images.blank?
+      end
 
+      # Make sure the image cache directory exists
       FileUtils.mkpath(cache_path)
 
-      # Check to see if there is an image_optim.yml file in this directory that
-      # overrides the default settings.
-      image_optim_opts = if config_last_modified > 0
-        {
-            :config_paths => [IMAGE_OPTIM_CONFIG_YML]
-        }
+      # Read the image compression configuration settings
+      config = Util::read_yml(config_path, :fail_if_not_exists => false)
+
+      if config_path == kraken_config_path
+        minify_with_kraken_io email, config, source_img, cached_img
+
       else
-        {
-            :allow_lossy => true,
-            :gifsicle => { :level => 3 },
-            :jpegoptim => { :max_quality => 50 },
-            :jpegrecompress => { :quality => 1 },
-            :pngout => false,
-            :svgo => false
-        }
-      end
 
-      image_optim = ImageOptim.new(image_optim_opts)
+        # Default image optimization uses built-in ImageOptim
+        minify_with_image_optim email, config, source_img, cached_img
 
-      # Copy all of the images that need updating into the temporary directory.
-      # Specifically joining the images_path to the image to avoid Email's
-      # image_path which may change it's directory if optimization is enabled.
-      updated_images.each do |img|
-        cached_img = File.join(cache_path, File.basename(img))
-        FileUtils.cp(img, cached_img)
-        image_optim.optimize_image!(cached_img)
       end
 
+      original_size = File.size(source_img)
+      compressed_size = File.size(cached_img)
+      percent_compressed = ((1.0 - (compressed_size / original_size.to_f)) * 100).round(1)
+      puts "Compressed #{img_name} #{percent_compressed}%"
+
+    end
+
+    def self.images email, force=false
+
+      images_path = email.image_dir
+
+      # Iterate through all of the images in the project and optimize them
+      # if necessary.
+      Dir.glob(File.join(images_path, '*.*')).each { |img| self.image(email, File.basename(img), force) }
+
     end
 
     def self.js code, ctx
@@ -188,11 +209,74 @@ module Inkcite
 
     private
 
+    def self.minify_with_image_optim email, config, source_img, cached_img
+
+      # Copy the image into the destination directory and then use Image Optim
+      # to optimize it in place.
+      FileUtils.cp(source_img, cached_img)
+      ImageOptim.new(config).optimize_image!(cached_img)
+
+    end
+
+    def self.minify_with_kraken_io email, config, source_img, cached_img
+
+      require 'kraken-io'
+      require 'open-uri'
+
+      # Initialize the Kraken API using the API key and secret defined in the
+      # config.yml file.
+      kraken = Kraken::API.new(
+          :api_key => config[:api_key],
+          :api_secret => config[:api_secret]
+      )
+
+      # As you might expect, Outlook doesn't support webp so it needs to be
+      # disabled by default.  Otherwise, Kraken always compresses with webp.
+      kraken_opts = { :webp => false }
+
+      # Get the file format (e.g. gif) of the file being optimized.
+      source_fmt = File.extname(source_img).delete('.')
+
+      # True if the configuration file does not specifically exclude
+      # this format from being processed.
+      compress_this_fmt = config[source_fmt.to_sym] != false
+
+      # Typically, we're going to want lossy compression to minify the file
+      # but if the user has put lossy: false specifically in their config
+      # file, we'll disable that feature in Kraken too.  Defaults to true.
+      kraken_opts[:lossy] = compress_this_fmt
+
+      # Send the quality metric to Kraken only if specified.  Per their
+      # documentation, Kraken will attempt to guess the best quality to
+      # use but in my experience it errs on the side of higher quality
+      # whereas setting a quality factor around 50 produces a good
+      # balance of image detail and file size.
+      if compress_this_fmt
+        quality = config[:quality].to_i
+        kraken_opts[:quality] = quality if quality > 0 and quality <= 100
+      end
+
+      # Upload the image to Kraken which blocks by default until the image
+      # has been optimized.
+      data = kraken.upload(source_img, kraken_opts)
+      if data.success
+        File.write(cached_img, open(data.kraked_url).read, { :mode => 'wb' })
+      else
+        puts "Failed to optimize #{img_name}: #{data.message}"
+      end
+
+    end
+
     # Name of the Image Optim configuration yml file that can be
     # put in the project directory to explicitly control the image
     # optimization process.
     IMAGE_OPTIM_CONFIG_YML = 'image_optim.yml'
 
+    # Name of the Kraken configuration yml that, when present in
+    # the project directory and populated with an API key and secret
+    # causes Kraken.io paid image optimization service to be used.
+    KRAKEN_CONFIG_YML = 'kraken.yml'
+
     NEW_LINE = "\n"
 
     # Used to match inline styles that will be compressed when minifying