inkcite 1.14.0 → 1.15.0

data/lib/inkcite/image/image_minifier.rb

@@ -0,0 +1,143 @@
+require_relative 'base'
+require_relative 'guetzli_minifier'
+require_relative 'image_optim_minifier'
+require_relative 'mozjpeg_minifier'
+
+module Inkcite
+  module Image
+    class ImageMinifier
+
+      # Directory of optimized images
+      IMAGE_CACHE = 'images-optim'
+
+      # Common extensions
+      GIF = 'gif'
+      JPG = 'jpg'
+      PNG = 'png'
+
+      def self.minify email, img_name, force=false
+
+        # Original, unoptimized source image
+        source_img = File.join(email.image_dir, img_name)
+
+        # Cached, optimized path for this image.
+        cache_path = email.project_file(IMAGE_CACHE)
+        cached_img = File.join(cache_path, File.basename(img_name))
+
+        # Grab the first file that exists for this project.
+        config_path = email.config_file
+
+        unless force
+
+          # 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)
+
+          # 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)
+          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
+
+        end
+
+        # Make sure the image cache directory exists
+        FileUtils.mkpath(cache_path)
+
+        # Copy the original image to the cache where it can be processed.
+        FileUtils.copy(source_img, cached_img)
+
+        # Get the file format (e.g. gif) of the file being optimized.
+        source_ext = Util::file_extension(source_img)
+
+        # This will hold the list of minifiers that will be applied to the
+        # image, based on its extension.
+        pipeline = []
+
+        # True if ImageOptim is allowed to make lossy optimizations to the
+        # images.  When false, even if the quality settings allow it, ImageOptim
+        # won't make lossy optimizations.
+        allow_lossy = true
+
+        if source_ext == JPG
+          pipeline << MozjpegMinifier.new
+          pipeline << GuetzliMinifier.new
+          allow_lossy = false
+        end
+
+        # Always optimize with ImageOptim although for JPGs additional
+        # lossy compression is force disabled.
+        pipeline << ImageOptimMinifier.new(allow_lossy)
+
+        original_size = File.size(source_img)
+
+        msg = "Compressing #{img_name} #{Util.pretty_file_size(original_size)}"
+
+        # Process the image
+        pipeline.each do |p|
+
+          # Minifiers don't work well when the source and destination images are the
+          # same files - so move the image to a temporary file so the minifier can
+          # optimize it back into place.
+          temp_img = "#{cached_img}.tmp"
+          FileUtils.move(cached_img, temp_img)
+
+          temp_size = File.size(temp_img)
+
+          # Let the processor compress the image
+          p.minify!(email, temp_img, cached_img)
+
+          compressed_size = File.size(cached_img)
+          if compressed_size < temp_size
+            msg << " >> #{p.name} #{Util.pretty_file_size(compressed_size)}"
+
+          else
+
+            # Occassionally the compressor does the wrong thing and
+            # makes the image bigger (particularly ImageOptim after
+            # Guetzli) so in that case, revert the image to its
+            # smaller pre-optimization form.
+            FileUtils.copy(temp_img, cached_img)
+
+          end
+
+          # Now remove the temp file.
+          FileUtils.remove(temp_img) if File.exists?(temp_img)
+
+        end
+
+        # Get the final compressed size of the image so we can print the
+        # resulting compression ratio.
+        compressed_size = File.size(cached_img)
+        msg << " (#{self.compressed_percent(original_size, compressed_size)}%)"
+
+        Util.log msg
+
+      end
+
+      # Minifies all of the images in the provided email's project directory.
+      def self.minify_all email, force=false
+
+        images_path = File.join(email.image_dir, '*.*')
+
+        # Iterate through all of the images in the project and optimize them
+        # if necessary.
+        Dir.glob(images_path).each do |img|
+          self.minify(email, File.basename(img), force)
+        end
+
+      end
+
+      def self.compressed_percent original_size, compressed_size
+        ((1.0 - (compressed_size / original_size.to_f)) * 100).round(1)
+      end
+
+    end
+  end
+end
+

data/lib/inkcite/image/image_optim_minifier.rb

@@ -0,0 +1,90 @@
+module Inkcite
+  module Image
+    class ImageOptimMinifier < ImageMinifier::Base
+
+      def initialize allow_lossy=true
+        super('ImageOptim')
+        @allow_lossy = allow_lossy
+      end
+
+      def minify! email, source_img, cache_img
+
+        config = email.config
+
+        img_type = Util::file_extension(cache_img)
+
+        # This will hold the settings that control how imageoptim
+        # compresses the image, based on extension.
+        optim_opt = {
+            :verbose => false,
+            :svgo => false
+        }
+
+        FileUtils.copy(source_img, cache_img)
+
+        case img_type
+          when ImageMinifier::GIF
+            mix_gif_options email, config, optim_opt
+          when ImageMinifier::JPG
+            mix_jpg_options email, config, optim_opt
+          when ImageMinifier::PNG
+            mix_png_options email, config, optim_opt
+          else
+            # Don't know how to compress this type of image so
+            # just leave it alone
+            return
+        end
+
+        ImageOptim.new(optim_opt).optimize_image!(cache_img)
+
+      end
+
+      private
+
+      # Name of the configuration field that controls ImageOptim's JPG quality
+      IMAGEOPTIM_JPG_QUALITY = :'imageopt-jpg-quality'
+
+      # Default JPG image quality
+      DEFAULT_JPG_QUALITY = 85
+
+      # Quality constraints
+      MIN_QUALITY = 0
+      MAX_QUALITY = 100
+
+      def mix_gif_options email, config, opts
+
+      end
+
+      def mix_jpg_options email, config, opts
+
+        max_quality = get_jpg_quality(config, IMAGEOPTIM_JPG_QUALITY, DEFAULT_JPG_QUALITY)
+
+        # Anything less than 100% quality means lossy is enabled.
+        lossy = @allow_lossy && max_quality < 100
+        opts[:allow_lossy] = lossy
+
+        # Additional configuration necessary only if lossy compression
+        # is enabled.  Otherwise, the defaults are acceptable.
+        if lossy
+          opts[:jpegoptim] = {
+              :allow_lossy => lossy,
+              :max_quality => max_quality
+          }
+
+          opts[:jpegrecompress] = {
+              :allow_lossy => lossy,
+              :quality => (max_quality / 100.0 * 3).round(0)
+          }
+        end
+
+
+      end
+
+      def mix_png_options email, config, opts
+
+      end
+
+
+    end
+  end
+end

data/lib/inkcite/image/mozjpeg_minifier.rb

@@ -0,0 +1,92 @@
+require 'mozjpeg'
+
+module Inkcite
+  module Image
+    class MozjpegMinifier < ImageMinifier::Base
+
+      def initialize
+        super('Mozjpeg')
+      end
+
+      def minify! email, source_img, cache_img
+
+        config = email.config
+
+        cmd = []
+
+        # mozjpeg usage documentation available
+        # https://github.com/mozilla/mozjpeg/blob/master/usage.txt
+        cmd << Mozjpeg.cjpeg_path
+
+        chrominance_quality = get_jpg_quality(config, MOZJPEG_CHROMINANCE_QUALITY, DEFAULT_QUALITY)
+
+        # The human eye is more sensitive to spatial changes in brightness than
+        # spatial changes in color, the chrominance components can be quantized more
+        # than the luminance components without incurring any visible image quality loss.
+        luminance_quality = (config[MOZJPEG_LUMINANCE_QUALITY] || DEFAULT_QUALITY).to_i # Recommended default
+        luminance_quality = MAX_QUALITY if luminance_quality > MAX_QUALITY
+
+        cmd << "-quality #{luminance_quality},#{chrominance_quality}"
+
+        # Perform optimization of entropy encoding parameters.
+        # -optimize usually makes the JPEG file a little smaller,
+        # but cjpeg runs somewhat slower and needs much more
+        # memory.  Image quality and speed of decompression are
+        # unaffected by -optimize.
+        cmd << '-optimize'
+
+        # Produce progressive JPEGs
+        cmd << '-progressive'
+
+        subsampling = (config[MOZJPEG_SUBSAMPLING] || DEFAULT_SUBSAMPLING).to_i
+        cmd << "-sample #{subsampling}x#{subsampling}"
+
+        # Reduces posterization in lower-quality JPEGs
+        # https://calendar.perfplanet.com/2014/mozjpeg-3-0/
+        quant_table = (config[MOZJPEG_QUANT_TABLE] || MS_SSIM).to_i
+        cmd << "-quant-table #{quant_table}"
+
+        # Makes images sharper, at the cost of increased file size
+        # https://calendar.perfplanet.com/2014/mozjpeg-3-0/
+        cmd << '-notrellis'
+
+        cmd << %Q(-outfile "#{cache_img}")
+        cmd << %Q("#{source_img}")
+
+        Util::exec(cmd.join(' '))
+
+        true
+      end
+
+      private
+
+      # Name of the configuration attributes used to control
+      # JPEG compression.
+      MOZJPEG_LUMINANCE_QUALITY = :'mozjpeg-luminance-quality'
+      MOZJPEG_CHROMINANCE_QUALITY = :'mozjpeg-chrominance-quality'
+      MOZJPEG_QUANT_TABLE = :'mozjpeg-quant-table'
+      MOZJPEG_SUBSAMPLING = :'mozjpeg-subsampling'
+
+      # Default compression quality for images unless specified in the
+      # configuration file under 'mozjpeg-quality'
+      DEFAULT_QUALITY = 85
+
+      # Default subsampling
+      DEFAULT_SUBSAMPLING = 1
+
+      # Quality limits
+      MIN_QUALITY = 0
+      MAX_QUALITY = 100
+
+      # Quant table constants per the mozjpeg man page
+      JPEG_ANNEX_K = 0
+      FLAT = 1
+      MS_SSIM = 2
+      IMAGEMAGICK = 3
+      PSNR_HVS = 4
+      KLEIN_SILVERSTEIN_CARNEY = 5
+
+    end
+
+  end
+end

data/lib/inkcite/mailer.rb

@@ -4,166 +4,258 @@ require 'mailgun'
 module Inkcite
   class Mailer
 
-    def self.client email, opts
+    def self.send_test email, test_address, opts
 
-      # Determine which preview this is
-      count = increment(email, :preview)
+      # Determine the number of times we've emailed to this list
+      count = get_count(email, :test, opts)
 
-      # Get the declared set of recipients.
-      recipients = email.config[:recipients]
+      # Check to see if a specific version is requested or if unspecified
+      # all versions of the email should be sent.
+      versions = get_versions(email, opts)
 
-      # Get the list of client address(es) - check both client and clients
-      # as a convenience.
-      to = recipients[:clients] || recipients[:client]
+      # Will hold the instance of the Mailer::Base that will handle the
+      # actual sending of the email.
+      mailer_base = get_mailer_base(email)
 
-      # If this is the first preview, check to see if there is an
-      # additional set of recipients for this initial mailing.
-      if count == 1
-        also_to = recipients[FIRST_PREVIEW]
-        #to = [* to] + [* also_to] unless also_to.blank?
-        to = [* also_to] unless also_to.blank?
-      end
+      versions.each do |version|
 
-      # Always cc internal recipients so everyone stays informed of feedback.
-      cc = recipients[:internal]
+        # The version of the email we will be sending.
+        view = email.view(:preview, :email, version)
 
-      self.send(email, opts.merge({
-                  :to => to,
-                  :cc => cc,
-                  :bcc => true,
-                  :tag => "Preview ##{count}"
-              }))
+        subject = "#{view.subject} (Test ##{count})"
+        print "Sending '#{subject}' ... "
 
-    end
+        mailer_base.send!({ :to => test_address }, subject, view.render!)
 
-    def self.developer email, opts
+        puts 'Sent!'
 
-      count = increment(email, :developer)
+      end
 
-      self.send(email, opts.merge({
-                  :tag => "Developer Test ##{count}"
-              }))
+      # Increment the count now that we've successfully emailed this list
+      increment email, :test
 
     end
 
-    def self.internal email, opts
+    def self.send_to_list email, list, opts
+
+      # Determine the number of times we've emailed to this list
+      count = get_count(email, list, opts)
+
+      # Check to see if a specific version is requested or if unspecified
+      # all versions of the email should be sent.
+      versions = get_versions(email, opts)
+
+      # Will hold the instance of the Mailer::Base that will handle the
+      # actual sending of the email.
+      mailer_base = get_mailer_base(email)
+
+      # Get the email address from which the previews will be sent.
+      from = mailer_base.get_from_address
+
+      versions.each do |version|
+
+        # The version of the email we will be sending.
+        view = email.view(:preview, :email, version)
+
+        # Subject line tag such as "Preview #3"
+        tag = "#{opts[:tag]} ##{count}"
+
+        subject = view.subject
+        subject = "#{subject} (#{tag})" unless tag.blank?
+
+        # Get the list of recipients for this version
+        recipients = get_recipients(list, view, count, from)
 
-      recipients = email.config[:recipients]
+        # Get the total number of recipients for this version
+        total_recipients = recipients.inject(0) { |total, (k, v)| total + v.length }
 
-      # Determine which preview this is
-      count = increment(email, :internal)
+        print "Sending '#{subject}' to #{total_recipients} recipient#{'s' if total_recipients > 1} ... "
 
-      self.send(email, opts.merge({
-                  :to => recipients[:internal],
-                  :bcc => true,
-                  :tag => "Internal Proof ##{count}"
-              }))
+        mailer_base.send! recipients, subject, view.render!
+
+        puts 'Sent!'
+
+      end
+
+      # Increment the count now that we've successfully emailed this list
+      increment email, list
 
     end
 
-    # Sends each version of the provided email with the indicated options.
-    def self.send email, opts
+    private
 
-      # Check to see if additional one-time recipients have been added
-      # to the command line.
-      also_to = opts[:also]
-      opts[:cc] = [*opts[:cc]] + also_to unless also_to.blank?
+    # Name of the distribution list used on the first preview.  For one
+    # client, they wanted the first preview sent to additional people
+    # but subsequent previews went to a shorter list.
+    FIRST_PREVIEW = :'first-preview'
 
-      # Check to see if a specific version is requested or if unspecified
-      # all versions of the email should be sent.
-      versions = Array(opts[:version] || email.versions)
+    def self.comma_set_includes? _set, value
+      _set.blank? || _set.split(',').collect(&:to_sym).include?(value.to_sym)
+    end
 
-      # Will hold the instance of the Mailer::Base that will handle the
-      # actual sending of the email.
+    def self.get_count email, sym, opts
+      opts[:count] || email.meta(sym).to_i + 1
+    end
+
+    def self.get_mailer_base email
       mailer_base = nil
 
       # Check to see if
       if config = email.config[:mailgun]
-        mailer_base = MailgunMailer.new
+        mailer_base = MailgunMailer.new(config)
       elsif config = email.config[:smtp]
-        mailer_base = SmtpMailer.new
+        mailer_base = SmtpMailer.new(config)
       else
         abort <<-USAGE.strip_heredoc
 
-          Oops! Inkcite can't send this email because of a configuration problem.
-          Please update the mailgun or smtp sections of your config.yml file.
+                Oops! Inkcite can't send this email because of a configuration problem.
+                Please update the mailgun or smtp sections of your config.yml file.
 
-            smtp:
-              host: 'smtp.gmail.com'
-              port: 587
-              domain: 'yourdomain.com'
-              username: ''
-              password: ''
-              from: 'Your Name <email@domain.com>'
+                  smtp:
+                    host: 'smtp.gmail.com'
+                    port: 587
+                    domain: 'yourdomain.com'
+                    username: ''
+                    password: ''
+                    from: 'Your Name <email@domain.com>'
 
-          Or send via Mailgun:
+                Or send via Mailgun:
 
-            mailgun:
-              api-key: 'key-your-api-key'
-              domain: 'mg.sending-domain.com'
-              from: 'Your Name <email@domain.com>'
+                  mailgun:
+                    api-key: 'key-your-api-key'
+                    domain: 'mg.sending-domain.com'
+                    from: 'Your Name <email@domain.com>'
 
         USAGE
       end
 
-      versions.each do |version|
+      mailer_base
+    end
 
-        # The version of the email we will be sending.
-        view = email.view(:preview, :email, version)
+    def self.get_recipients list, view, count, from
 
-        # Subject line tag such as "Preview #3"
-        tag = opts[:tag]
+      recipients = { :to => [], :cc => [], :bcc => [] }
 
-        subject = view.subject
-        subject = "#{subject} (#{tag})" unless tag.blank?
+      # Developer list always only sends to the original from address.
+      if list == :developer
+        recipients[:to] << from
+
+      else
+
+        # Always bcc the developer of the email
+        recipients[:bcc] << from
+
+        # Check to see if there is a TSV file which allows for maximum
+        # configurability of the recipient list.
+        recipients_file = view.email.project_file('recipients.tsv')
+        if File.exist?(recipients_file)
+
+          # Iterate through the recipients file and determine which entries match the
+          # list, version and preview count...
+          Util.each_line(recipients_file, false) do |line|
+
+            # Skip comments
+            next if line.start_with?('#')
 
-        puts "Sending '#{subject}' ..."
+            name, email, _list, delivery, min_preview, max_preview, versions = line.split("\t")
+            next if name.blank? || email.blank?
 
-        mailer_base.send! config, view, subject, opts
+            # Skip this recipient unless the distribution list matches the one
+            # we're looking for.
+            next unless _list.to_sym == list
+
+            # Skip this recipient unless we've reached the minimum number of
+            # earlier previews for this recipient - e.g. they only receive the
+            # 2nd previews and beyond
+            min_preview = min_preview.to_i
+            next if min_preview > 0 && count < min_preview
+
+            # Skip this recipient if we've already delivered the maximum number
+            # of previews they should receive - e.g. they only receive the
+            # first preview, no additional previews.
+            max_preview = max_preview.to_i
+            next if max_preview > 0 && count > max_preview
+
+            # Skip this recipient unless
+            next unless comma_set_includes?(versions, view.version)
+
+            delivery = delivery.blank? ? :to : delivery.to_sym
+            recipient = "#{name} <#{email}>"
+            recipients[delivery] << recipient
+
+          end
+
+        else
+
+          # Grab the array of recipients from the config.yml
+          recipient_yml = view[:recipients]
+
+          case list
+            when :client
+              first_preview = count == 1 ? recipient_yml[FIRST_PREVIEW] : nil
+              clients = recipient_yml[:clients] || recipient_yml[:client]
+              recipients[:to] = first_preview || clients
+              recipients[:cc] = recipient_yml[:internal]
+            when :internal
+              recipients[:to] = recipient_yml[:internal]
+            when :developer
+              recipients[:to] = from
+          end
+
+        end
 
       end
 
+      return recipients
     end
 
-    private
-
-    # Name of the distribution list used on the first preview.  For one
-    # client, they wanted the first preview sent to additional people
-    # but subsequent previews went to a shorter list.
-    FIRST_PREVIEW = :'first-preview'
+    def self.get_versions email, opts
+      Array(opts[:version] || email.versions)
+    end
 
     def self.increment email, sym
-      count = email.meta(sym).to_i + 1
-      email.set_meta sym, count
+      email.set_meta sym, get_count(email, sym, {})
     end
 
     # Abstract base class for the workhorses of the Mailer class.
     # Instantiated based on the config.yml settings.
     class Base
-      def send! config, view, subject, opt
+
+      attr_accessor :config
+
+      def initialize config
+        @config = config
+      end
+
+      def get_from_address
+        @config[:from]
+      end
+
+      def send! recipients, subject, content
         raise NotImplementedError
       end
     end
 
     class MailgunMailer < Base
-      def send! config, view, subject, opt
+      def initialize config
+        super(config)
+      end
 
-        # The address of the developer
-        from = config[:from]
+      def send! recipients, subject, content
 
         # First, instantiate the Mailgun Client with your API key
         mg_client = Mailgun::Client.new config[:'api-key']
 
         # Define your message parameters
         message_params = {
-            :from => from,
-            :to => opt[:to] || from,
+            :from => get_from_address,
+            :to => recipients[:to],
             :subject => subject,
-            :html => view.render!
+            :html => content
         }
 
-        message_params[:cc] = opt[:cc] unless opt[:cc].blank?
-        message_params[:bcc] = from if opt[:bcc] == true
+        message_params[:cc] = recipients[:cc] unless recipients[:cc].blank?
+        message_params[:bcc] = recipients[:bcc] unless recipients[:bcc].blank?
 
         # Send your message through the client
         mg_client.send_message config[:domain], message_params
@@ -172,41 +264,38 @@ module Inkcite
     end
 
     class SmtpMailer < Base
-      def send! config, view, _subject, opt
+      def initialize config
+        super(config)
+      end
+
+      def send! recipients, subject, content
+
+        _config = config
 
         Mail.defaults do
           delivery_method :smtp, {
-                  :address => config[:host],
-                  :port => config[:port],
-                  :user_name => config[:username],
-                  :password => config[:password],
+                  :address => _config[:host],
+                  :port => _config[:port],
+                  :user_name => _config[:username],
+                  :password => _config[:password],
                   :authentication => :plain,
                   :enable_starttls_auto => true
               }
         end
 
-        # The address of the developer
-        _from = config[:from]
-
-        # True if the developer should be bcc'd.
-        _bcc = !!opt[:bcc]
-
         mail = Mail.new do
-
-          to opt[:to] || _from
-          cc opt[:cc]
-          from _from
-          subject _subject
-
-          bcc(_from) if _bcc
-
           html_part do
             content_type 'text/html; charset=UTF-8'
-            body view.render!
+            body content
           end
-
         end
 
+        mail[:to] = recipients[:to]
+        mail[:cc] = recipients[:cc]
+        mail[:bcc] = recipients[:bcc]
+        mail[:from] = get_from_address
+        mail[:subject] = subject
+
         mail.deliver!
 
       end