inkcite 1.0.0

data/lib/inkcite/cli/test.rb

@@ -0,0 +1,61 @@
+require 'litmus'
+require 'inkcite/mailer'
+
+module Inkcite
+  module Cli
+    class Test
+
+      def self.invoke email, opt
+
+        # Push the browser preview up to the server to ensure that the
+        # latest images are available.
+        email.upload
+
+        config = email.config[:litmus]
+
+        # Initialize the Litmus base.
+        Litmus::Base.new(config[:subdomain], config[:username], config[:password], true)
+
+        # Send each version to Litmus separately
+        email.versions.each do |version|
+
+          view = email.view(:preview, :email, version)
+
+          # This will hold the Litmus Test Version which provides the GUID (e.g. email)
+          # to which we will send.
+          test_version = nil
+
+          # Check to see if this email already has a test ID.
+          test_id = view.meta(:litmus_test_id)
+          if test_id.blank? || opt[:new]
+
+            email_test = Litmus::EmailTest.create
+
+            # Store the litmus test ID in the email's meta data.
+            view.set_meta :litmus_test_id, email_test['id']
+
+            # Extract the email address we need to send the test to.
+            test_version = email_test["test_set_versions"].first
+
+          else
+
+            # Create a new version of the test using the same ID as before.
+            test_version = Litmus::TestVersion.create(test_id)
+
+          end
+
+          # Extract the email address to send the test to.
+          send_to = test_version["url_or_guid"]
+
+          puts "Sending '#{view.subject}' to #{send_to} ..."
+
+          Inkcite::Mailer.litmus(email, version, send_to)
+
+        end
+
+        true
+      end
+
+    end
+  end
+end

data/lib/inkcite/email.rb

@@ -0,0 +1,219 @@
+module Inkcite
+  class Email
+
+    CACHE_BUST          = :'cache-bust'
+    IMAGE_HOST          = :'image-host'
+    IMAGE_PLACEHOLDERS  = :'image-placeholders'
+    OPTIMIZE_IMAGES     = :'optimize-images'
+    TRACK_LINKS         = :'track-links'
+    VIEW_IN_BROWSER_URL = :'view-in-browser-url'
+
+    # Sub-directory where images are located.
+    IMAGES = 'images'
+
+    # Allowed environments.
+    ENVIRONMENTS = [ :development, :preview, :production ].freeze
+
+    # The path to the directory from which the email is being generated.
+    # e.g. /projects/emails/holiday-mailing
+    attr_reader :path
+
+    def initialize path
+      @path = path
+    end
+
+    def config
+      Util.read_yml(File.join(path, 'config.yml'), true)
+    end
+
+    def formats env
+
+      f = [ :email, :browser ]
+
+      # Need to make sure a source.txt exists before we can include
+      # it in the list of known formats.
+      f << :text if File.exists?(project_file('source.txt'))
+
+      f
+    end
+
+    def image_dir
+      File.join(path, IMAGES)
+    end
+
+    def image_path file
+      File.join(image_dir, file)
+    end
+
+    def meta key
+      meta_data[key.to_sym]
+    end
+
+    def optimize_images
+      Minifier.images(self)
+    end
+
+    def optimize_images?
+      config[Inkcite::Email::OPTIMIZE_IMAGES] == true
+    end
+
+    # Returns the directory that optimized, compressed images
+    # have been saved to.
+    def optimized_image_dir
+      File.join(path, optimize_images?? Minifier::IMAGE_CACHE : IMAGES)
+    end
+
+    def properties
+
+      opts = {
+        :n => NEW_LINE
+      }
+
+      # Load the project's properties, which may include references to additional
+      # properties in other directories.
+      read_properties opts, 'helpers.tsv'
+
+      # As a convenience pre-populate the month name of the email.
+      mm = opts[:mm].to_i
+      opts[:month] = Date::MONTHNAMES[mm] if mm > 0
+
+      opts
+    end
+
+    def project_file file
+      File.join(path, file)
+    end
+
+    def set_meta key, value
+      md = meta_data
+      md[key.to_sym] = value
+      File.open(File.join(path, meta_file_name), 'w+') { |f| f.write(md.to_yaml) }
+      value
+    end
+
+    def upload
+      require_relative 'uploader'
+      Uploader.upload(self)
+    end
+
+    def upload!
+      require_relative 'uploader'
+      Uploader.upload!(self)
+    end
+
+    def versions
+      [* self.config[:versions] || :default ].collect(&:to_sym)
+    end
+
+    def view environment, format, version=nil
+
+      environment = environment.to_sym
+      format = format.to_sym
+      version = (version || versions.first).to_sym
+
+      raise "Unknown environment \"#{environment}\" - must be one of #{ENVIRONMENTS.join(',')}" unless ENVIRONMENTS.include?(environment)
+      raise "Unknown format \"#{format}\" - must be one of #{FORMATS.join(',')}" unless FORMATS.include?(format)
+      raise "Unknown version: \"#{version}\" - must be one of #{versions.join(',')}" unless versions.include?(version)
+
+      opt = properties
+      opt.merge!(self.config)
+
+      # Instantiate a new view of this email with the desired view and
+      # format.
+      View.new(self, environment, format, version, opt)
+
+    end
+
+    # Returns an array of all possible Views (every combination of version
+    # and format )of this email for the designated environment.
+    def views environment, &block
+
+      vs = []
+
+      formats(environment).each do |format|
+        versions.each do |version|
+          ev = view(environment, format, version)
+          yield(ev) if block_given?
+          vs << ev
+        end
+      end
+
+      vs
+    end
+
+    private
+
+    # Allowed formats.
+    FORMATS = [ :browser, :email, :text ].freeze
+
+    # Name of the property controlling the meta data file name and
+    # the default file name.
+    META_FILE_NAME = :'meta-file'
+    META_FILE      = '.inkcite'
+
+    COMMENT         = '//'
+    NEW_LINE        = "\n"
+    TAB             = "\t"
+    CARRIAGE_RETURN = "\r"
+
+    # Used for
+    MULTILINE_START = "<<-START"
+    MULTILINE_END = "END->>"
+    TAB_TO_SPACE = '  '
+
+    def meta_data
+      Util.read_yml(File.join(path, meta_file_name), false)
+    end
+
+    def meta_file_name
+      config[META_FILE_NAME] || META_FILE
+    end
+
+    def read_properties into, file
+
+      fp = File.join(path, file)
+      abort("Can't find #{file} in #{path} - are you sure this is an Inkcite project?") unless File.exists?(fp)
+
+      # Consolidate line-breaks for simplicity
+      raw = File.read(fp)
+      raw.gsub!(/[\r\f\n]{1,}/, NEW_LINE)
+
+      # Initial position of the
+      multiline_starts_at = 0
+
+      # Determine if there are any multiline declarations - those that are wrapped with
+      # <<-START and END->> and reduce them to single line declarations.
+      while (multiline_starts_at = raw.index(MULTILINE_START, multiline_starts_at))
+
+        break unless (multiline_ends_at = raw.index(MULTILINE_END, multiline_starts_at))
+
+        declaration = raw[(multiline_starts_at+MULTILINE_START.length)..multiline_ends_at - 1]
+        declaration.strip!
+        declaration.gsub!(/\t/, TAB_TO_SPACE)
+        declaration.gsub!(/\n/, "\r")
+
+        raw[multiline_starts_at..multiline_ends_at+MULTILINE_END.length - 1] = declaration
+
+      end
+
+      raw.split(NEW_LINE).each do |line|
+        next if line.starts_with?(COMMENT)
+
+        line.gsub!(/\r/, NEW_LINE)
+        line.strip!
+
+        key, open, close = line.split(TAB)
+        next if key.blank?
+
+        into[key.to_sym] = open.to_s.freeze
+
+        # Prepend the key with a "/" and populate the closing tag.
+        into["/#{key}".to_sym] = close.to_s.freeze
+
+      end
+
+      true
+    end
+
+  end
+end

data/lib/inkcite/mailer.rb

@@ -0,0 +1,140 @@
+require 'mail'
+
+module Inkcite
+  class Mailer
+
+    def self.client email
+
+      # Determine which preview this is
+      count = increment(email, :preview)
+
+      # Get the declared set of recipients.
+      recipients = email.config[:recipients]
+
+      # Get the list of client address(es) - check both client and clients
+      # as a convenience.
+      to = recipients[:clients] || recipients[:client]
+
+      # 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
+
+      # Always cc internal recipients so everyone stays informed of feedback.
+      cc = recipients[:internal]
+
+      self.send(email, {
+          :to => to,
+          :cc => cc,
+          :bcc => true,
+          :tag => "Preview ##{count}"
+      })
+
+    end
+
+    def self.developer email
+
+      count = increment(email, :developer)
+
+      self.send(email, {
+          :tag => "Developer Test ##{count}"
+      })
+
+    end
+
+    def self.litmus email, version, litmus_email
+      self.send_version(email, version, { :to => litmus_email })
+    end
+
+    def self.internal email
+
+      recipients = email.config[:recipients]
+
+      # Determine which preview this is
+      count = increment(email, :internal)
+
+      self.send(email, {
+          :to => recipients[:internal],
+          :bcc => true,
+          :tag => "Internal Proof ##{count}"
+      })
+
+    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.increment email, sym
+      count = email.meta(sym).to_i + 1
+      email.set_meta sym, count
+    end
+
+    # Sends each version of the provided email with the indicated options.
+    def self.send email, opt
+
+      email.versions.each do |version|
+        self.send_version(email, version, opt)
+      end
+
+    end
+
+    def self.send_version email, version, opt
+
+      config = email.config[:smtp]
+
+      Mail.defaults do
+        delivery_method :smtp, {
+          :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]
+
+      # Subject line tag such as "Preview #3"
+      _tag = opt[:tag]
+
+      # True if the developer should be bcc'd.
+      _bcc = opt[:bcc] == true
+
+      # The version of the email we will be sending.
+      _view = email.view(:preview, :email, version)
+
+      _subject = _view.subject
+      _subject = "#{_subject} (#{_tag})" unless _tag.blank?
+
+      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!
+        end
+
+      end
+
+      mail.deliver!
+
+    end
+
+  end
+end
+

data/lib/inkcite/minifier.rb

@@ -0,0 +1,151 @@
+require 'yui/compressor'
+
+module Inkcite
+  class Minifier
+
+    # Directory of optimized images
+    IMAGE_CACHE = ".images"
+
+    def self.css code, ctx
+      minify?(ctx) ? css_compressor(ctx).compress(code) : code
+    end
+
+    def self.html lines, ctx
+
+      if minify?(ctx)
+
+        # Will hold the assembled, minified HTML as it is prepared.
+        html = ''
+
+        # Will hold the line being assembled until it reaches the maximum
+        # allowed line length.
+        packed_line = ''
+
+        lines.each do |line|
+          next if line.blank?
+
+          line.strip!
+
+          ## Compress all in-line styles.
+          #Parser.each line, INLINE_STYLE_REGEX do |style|
+          #  style.gsub!(/: +/, ':')
+          #  style.gsub!(/; +/, ';')
+          #  style.gsub!(/;+/, ';')
+          #  style.gsub!(/;+$/, '')
+          #  "style=\"#{style}\""
+          #end
+
+          # If the length of the packed line with the addition of this line of content would
+          # exceed the maximum allowed line length, then push the collected lines onto the
+          # html and start a new line.
+          if !packed_line.blank? && packed_line.length + line.length > MAXIMUM_LINE_LENGTH
+            html << packed_line
+            html << NEW_LINE
+            packed_line = ''
+          end
+
+          packed_line << line
+
+        end
+
+        # Make sure to get any last lines assembled on the packed line.
+        html << packed_line unless packed_line.blank?
+
+        html
+      else
+        lines.join(NEW_LINE)
+
+      end
+
+    end
+
+    def self.images email
+
+      image_optim_path = '/Applications/ImageOptim.app/Contents/MacOS/ImageOptim'
+      image_optim = File.exists?(image_optim_path)
+      abort "Can't find ImageOptim (#{image_optim_path}) - download it from https://imageoptim.com" unless image_optim
+
+      images_path = email.image_dir
+      cache_path = email.project_file(IMAGE_CACHE)
+
+      # If the image cache exists, we need to check to see if any images have been
+      # removed since the last build.
+      if File.exists?(cache_path)
+
+        # 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?
+
+          # 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)
+
+        end
+
+      end
+
+      # Check to see if there are new or updated images that need to be re-optimized.
+      updated_images = Dir.entries(images_path).select do |img|
+        unless img.start_with?('.')
+          cimg = File.join(cache_path, img)
+          !File.exists?(cimg) || (File.stat(File.join(images_path, img)).mtime > File.stat(cimg).mtime)
+        end
+      end
+
+      return if updated_images.blank?
+
+      # This is the temporary path into which new or updated images will
+      # be copied and then optimized.
+      temp_path = email.project_file(IMAGE_TEMP)
+
+      # Make sure there is no existing temporary directory to interfere
+      # with the image processing.
+      FileUtils.rm_rf(temp_path)
+      FileUtils.mkpath(temp_path)
+
+      # 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 { |img| FileUtils.cp(File.join(images_path, img), File.join(temp_path, img)) }
+
+      # Optimize all of the images.
+      system("#{image_optim_path} #{temp_path}") if image_optim
+
+      FileUtils.cp_r(File.join(temp_path, "."), cache_path)
+      FileUtils.rm_rf(temp_path)
+
+    end
+
+    def self.js code, ctx
+      minify?(ctx) ? js_compressor(ctx).compress(code) : code
+    end
+
+    private
+
+    # Temporary directory that new or updated images will be copied into
+    # to be optimized and then cached in .images
+    IMAGE_TEMP = ".images-temp"
+
+    NEW_LINE = "\n"
+    MAXIMUM_LINE_LENGTH = 800
+
+    # Used to match inline styles that will be compressed when minifying
+    # the entire email.
+    INLINE_STYLE_REGEX = /style=\"([^\"]+)\"/
+
+    def self.minify? ctx
+      ctx.is_enabled?(:minify)
+    end
+
+    def self.js_compressor ctx
+      ctx.js_compressor ||= YUI::JavaScriptCompressor.new(:munge => true)
+    end
+
+    def self.css_compressor ctx
+      ctx.css_compressor ||= YUI::CssCompressor.new(:line_break => (ctx.email?? MAXIMUM_LINE_LENGTH : nil))
+    end
+
+  end
+end