inkcite 1.0.0

data/lib/inkcite/renderer/span.rb

@@ -0,0 +1,21 @@
+module Inkcite
+  module Renderer
+    class Span < Responsive
+
+      def render tag, opt, ctx
+
+        return '</span>' if tag == '/span'
+
+        span = Element.new('span')
+
+        mix_font span, opt, ctx
+
+        mix_responsive span, opt, ctx
+
+        span.to_s
+      end
+
+    end
+  end
+end
+

data/lib/inkcite/renderer/table.rb

@@ -0,0 +1,67 @@
+module Inkcite
+  module Renderer
+    class Table < TableBase
+
+      def render tag, opt, ctx
+
+        tag_stack = ctx.tag_stack(:table)
+
+        if tag == CLOSE_TABLE
+
+          # Remove this table from the stack of previously open tags.
+          tag_stack.pop
+
+          return '</tr></table>'
+
+        end
+
+        # Push this table onto the stack which will make it's declaration
+        # available to its child TDs.
+        tag_stack << opt
+
+        table = Element.new(tag, { :border => 0, :cellspacing => 0 })
+
+        # Inherit base cell attributes - border, background color and image, etc.
+        mix_all table, opt, ctx
+
+        # Text shadowing
+        mix_text_shadow table, opt, ctx
+
+        # Conveniently accept padding (easier to type and consistent with CSS)or
+        # cellpadding which must always be declared.
+        table[:cellpadding] = (opt[:padding] || opt[:cellpadding]).to_i
+
+        # Conveniently accept both float and align to mean the same thing.
+        align = opt[:align] || opt[:float]
+        table[:align] = align unless align.blank?
+
+        border_radius = opt[BORDER_RADIUS].to_i
+        table.style[BORDER_RADIUS] = px(border_radius) if border_radius > 0
+
+        border_collapse = opt[BORDER_COLLAPSE]
+        table.style[BORDER_COLLAPSE] = border_collapse unless border_collapse.blank?
+
+        margin_top = opt[MARGIN_TOP].to_i
+        table.style[MARGIN_TOP] = px(margin_top) if margin_top > 0
+
+        mobile = opt[:mobile]
+
+        # When a Table is configured to have it's cells DROP then it
+        # actually needs to FILL on mobile and it's child Tds will
+        # be DROP'd.  Override the local mobile klass so the child Tds
+        # see the parent as DROP.
+        mobile = FILL if mobile == DROP || mobile == SWITCH
+
+        mix_responsive table, opt, ctx, mobile
+
+        table.to_s + '<tr>'
+      end
+
+      private
+
+      CLOSE_TABLE = '/table'
+
+    end
+  end
+end
+

data/lib/inkcite/renderer/table_base.rb

@@ -0,0 +1,149 @@
+module Inkcite
+  module Renderer
+    class TableBase < Responsive
+
+      protected
+
+      def mix_all element, opt, ctx
+
+        mix_background element, opt, ctx
+        mix_border element, opt, ctx
+        mix_dimensions element, opt, ctx
+
+      end
+
+      def mix_background element, opt, ctx
+
+        bgcolor = opt[:bgcolor]
+        bgcolor = nil if bgcolor == NONE
+
+        # Set the bgcolor attribute of the element as a fallback if
+        # css isn't supported.
+        element[:bgcolor] = hex(bgcolor) unless bgcolor.blank?
+
+        # Assisted background image handling for maximum compatibility.
+        bgimage    = opt[:background]
+        bgposition = opt[BACKGROUND_POSITION]
+        bgrepeat   = opt[BACKGROUND_REPEAT]
+
+        # No need to set any CSS if there is no background image present on this
+        # element.  Previously, it would also set the background-color attribute
+        # for unnecessary duplication.
+        background_css(element.style, bgcolor, bgimage, bgposition, bgrepeat, nil, false, ctx)  unless bgimage.blank?
+
+        m_bgcolor = detect(opt[MOBILE_BACKGROUND_COLOR], opt[MOBILE_BGCOLOR])
+        m_bgimage = detect(opt[MOBILE_BACKGROUND_IMAGE], opt[MOBILE_BACKGROUND])
+
+        mobile_background = background_css(
+            {},
+            m_bgcolor,
+            m_bgimage,
+            detect(opt[MOBILE_BACKGROUND_POSITION], bgposition),
+            detect(opt[MOBILE_BACKGROUND_REPEAT], bgrepeat),
+            detect(opt[MOBILE_BACKGROUND_SIZE]),
+            (m_bgcolor && bgcolor) || (m_bgimage && bgimage),
+            ctx
+        )
+
+        unless mobile_background.blank?
+
+          # Add the responsive rule that applies to this element.
+          rule = Rule.new(element.tag, unique_klass(ctx), mobile_background)
+
+          # Add the rule to the view and the element
+          ctx.media_query << rule
+          element.add_rule rule
+
+        end
+
+      end
+
+      def mix_border element, opt, ctx
+
+        border = opt[:border]
+        element.style[:border] = border unless border.blank?
+
+        # Iterate through each of the possible borders and apply them individually
+        # to the style if they are defined.
+        DIRECTIONS.each do |dir|
+          key = :"border-#{dir}"
+          border = opt[key]
+          element.style[key] = border unless border.blank? || border == NONE
+        end
+
+      end
+
+      def mix_dimensions element, opt, ctx
+
+        # Not taking .to_i because we want to accept both integer values
+        # or percentages - e.g. 50%
+        width = opt[:width]
+        element[:width] = width unless width.blank?
+
+        height = opt[:height].to_i
+        element[:height] = height if height > 0
+
+      end
+
+      private
+
+      def background_css into, bgcolor, img, position, repeat, size, important, ctx
+
+        unless bgcolor.blank? && img.blank?
+
+          bgcolor = hex(bgcolor) unless bgcolor.blank?
+
+          # If no image has been provided or if the image provided is equal
+          # to "none" then we'll set the values independently.  Otherwise
+          # we'll use a composite background declaration.
+          if none?(img)
+
+            unless bgcolor.blank?
+              bgcolor << ' !important' if important
+              into[BACKGROUND_COLOR] = bgcolor
+            end
+
+            # Check specifically for a value of "none" which allows the email
+            # designer to the background that is otherwise present on the
+            # desktop version of the email.
+            if img == NONE
+              img = 'none'
+              img << ' !important' if important
+              into[BACKGROUND_IMAGE] = img
+            end
+
+          else
+
+            # Default to no-repeat if a position has been supplied or replace
+            # 'none' as a convenience (cause none is easier to type than no-repeat).
+            repeat = 'no-repeat' if (repeat.blank? && !position.blank?) || repeat == NONE
+
+            sty = []
+            sty << bgcolor unless bgcolor.blank?
+
+            ctx.assert_image_exists(img)
+
+            sty << "url(#{ctx.image_url(img)})"
+            sty << position unless position.blank?
+            sty << repeat unless repeat.blank?
+            sty << '!important' if important
+
+            into[:background] = sty.join(' ')
+
+          end
+
+          # Background size needs to be set independently.  Perhaps it can be
+          # mixed into background: but I couldn't make it work.
+          unless size.blank?
+            into[BACKGROUND_SIZE] = size
+            into[BACKGROUND_SIZE] << ' !important' if important
+          end
+
+        end
+
+        into
+      end
+
+    end
+  end
+end

data/lib/inkcite/renderer/td.rb

@@ -0,0 +1,92 @@
+module Inkcite
+  module Renderer
+    class Td < TableBase
+
+      def render tag, opt, ctx
+
+        tag_stack = ctx.tag_stack(:td)
+
+        if tag == CLOSE_TD
+          tag_stack.pop
+          return '</td>'
+        end
+
+        # Push this tag onto the stack so that child elements (e.g. links)
+        # can have access to its attributes.
+        tag_stack << opt
+
+        # Grab the attributes of the parent table so that the TD can inherit
+        # specific values like padding, valign, responsiveness, etc.
+        parent = ctx.parent_opts(:table)
+
+        td = Element.new('td')
+
+        # Inherit base cell attributes - border, background color and image, etc.
+        mix_all td, opt, ctx
+
+        # Force the td to collapse to a single pixel to support images that
+        # are less than 15 pixels.
+        opt.merge!({
+            :font => NONE,
+            :color => NONE,
+            FONT_SIZE => 1,
+            LINE_HEIGHT => 1
+        }) unless opt[:flush].blank?
+
+        # It is a best-practice to declare the same padding on all cells in a
+        # table.  Check to see if padding was declared on the parent.
+        padding = parent[:padding].to_i
+        td.style[:padding] = px(padding) if padding > 0
+
+        # Custom handling for text align on TDs rather than Base's mix_text_align
+        # because if possible, using align= rather than a style keeps emails
+        # smaller.  But for left-aligned text, you gotta use a style because
+        # you know, Outlook.
+        align = opt[:align]
+        unless align.blank?
+          td[:align] = align
+
+          # Must use style to reinforce left-align text in certain email clients.
+          # All other alignments are accepted naturally.
+          td.style[TEXT_ALIGN] = align if align == LEFT
+
+        end
+
+        valign = detect(opt[:valign], parent[:valign])
+        td[:valign] = valign unless valign.blank?
+
+        rowspan = opt[:rowspan].to_i
+        td[:rowspan] = rowspan if rowspan > 0
+
+        mix_font td, opt, ctx, parent
+
+        mobile = opt[:mobile]
+        if mobile.blank?
+
+          # If the cell doesn't define it's own responsive behavior, check to
+          # see if it inherits from its parent table.  DROP and SWITCH declared
+          # at the table-level descend to their tds.
+          pm = parent[:mobile]
+          mobile = pm if pm == DROP || pm == SWITCH
+
+        end
+
+        mix_responsive td, opt, ctx, mobile
+
+        #outlook-bg	<!-&#45;&#91;if gte mso 9]>[n]<v:rect style="width:%width%px;height:%height%px;" strokecolor="none"><v:fill type="tile" src="%src%" /></v:fill></v:rect><v:shape id="theText[rnd]" style="position:absolute;width:%width%px;height:%height%px;margin:0;padding:0;%style%">[n]<!&#91;endif]&#45;->
+        #/outlook-bg	<!-&#45;&#91;if gte mso 9]></v:shape><!&#91;endif]&#45;->
+
+        td.to_s
+      end
+
+      private
+
+      CLOSE_TD = '/td'
+      LEFT = 'left'
+
+      # Property which controls the color of text
+      TEXT_COLOR = :'#text'
+
+    end
+  end
+end

data/lib/inkcite/uploader.rb

@@ -0,0 +1,173 @@
+require 'net/sftp'
+require 'stringio'
+
+module Inkcite
+  class Uploader
+
+    def self.upload email
+
+      times = []
+
+      [ 'source.html', 'source.txt', 'helpers.tsv' ].each do |file|
+        file = email.project_file(file)
+        times << File.mtime(file).to_i if File.exists?(file)
+      end
+
+      local_images = email.image_dir
+      if File.exists?(local_images)
+        Dir.foreach(local_images) do |file|
+          times << File.mtime(File.join(local_images, file)).to_i unless file.starts_with?('.')
+        end
+      end
+
+      # Get the most recently updated file.
+      last_update = times.max
+
+      # Determine when the last upload was completed.
+      last_upload = email.meta(:last_upload).to_i
+
+      self.do_upload(email, false) if last_update > last_upload
+
+    end
+
+    def self.upload! email
+      self.do_upload(email, true)
+    end
+
+    private
+
+    IMAGE_PATH = :'image-path'
+
+    def self.copy! sftp, local, remote, force=true
+
+      # Nothing to copy unless the local directory exists (e.g. some emails don't
+      # have an images directory.)
+      return unless File.exists?(local)
+
+      Dir.foreach(local) do |file|
+        next if file.starts_with?('.')
+
+        local_file = File.join(local, file)
+        unless File.directory?(local_file)
+
+          remote_file = File.join(remote, file)
+
+          unless force
+            next unless begin
+              File.stat(local_file).mtime > Time.at(sftp.stat!(remote_file).mtime)
+            rescue Net::SFTP::StatusException
+              true # File doesn't exist, so assume it's changed.
+            end
+          end
+
+          puts "Uploading #{local_file} -> #{remote_file} ..."
+          sftp.upload!(local_file, remote_file)
+
+        end
+
+      end
+    end
+
+    # Internal method responsive for doing the actual upload and
+    # forcing (if necessary) the update of the graphics.
+    def self.do_upload email, force
+
+      # The preview version defines the configuration for the server to which
+      # the files will be sftp'd.
+      config = email.config[:sftp]
+
+      # TODO: Verify SFTP configuration
+      host     = config[:host]
+      path     = config[:path]
+      username = config[:username]
+      password = config[:password]
+
+      # Pre-optimize images before we upload them to the CDN.
+      email.optimize_images
+
+      # This is the directory from which images will be uploaded.
+      # The email provides us with the correct directory based on
+      # whether or not image optimization is enabled.
+      local_images = email.optimized_image_dir
+
+      # This is the last location of image upload.  If we're working
+      # on multiple versions but the images all point to the same
+      # location, it isn't necessary to re-upload images each time.
+      last_remote_root = nil
+
+      puts "Uploading to #{host} ..."
+
+      # Get a local handle on the litmus configuration.
+      Net::SFTP.start(host, username, :password => password) do |sftp|
+
+        # Upload each version of the email.
+        email.versions.each do |version|
+
+          view = email.view(:preview, :browser, version)
+
+          # Need to pass the upload path through the renderer to ensure
+          # that embedded tags will be converted into data.
+          remote_root = Inkcite::Renderer.render(path, view)
+
+          # Recursively ensure that the full directory structure necessary for
+          # the content and images is present.
+          mkdir! sftp, remote_root
+
+          # Check to see if there is a HTML version of this preview.  Some emails
+          # do not have a hosted version and so it is not necessary to upload the
+          # HTML version of the email - but this is a bad practice.
+          file_name = view.file_name
+          unless file_name.blank?
+
+            remote_file_name = File.join(remote_root, file_name)
+            puts "Uploading #{remote_file_name}"
+
+            # We need to use StringIO to write the email to a buffer in order to upload
+            # the email's content in binary so that its encoding is honored.  SFTP defaults
+            # to ASCII-8bit in non-binary mode, so it was blowing up on UTF-8 special
+            # characters (e.g. "Mäkinen").
+            # http://stackoverflow.com/questions/9439289/netsftp-transfer-mode-binary-vs-text
+            io = StringIO.new(view.render!)
+            sftp.upload!(io, remote_file_name)
+
+          end
+
+          # Upload the images to the remote directory
+          copy! sftp, local_images, remote_root, force && last_remote_root != remote_root
+          last_remote_root = remote_root
+
+        end
+
+      end
+
+      # Timestamp to indicate we uploaded now
+      email.set_meta :last_upload, Time.now.to_i
+
+      true
+    end
+
+    def self.mkdir! sftp, path
+
+      _path = File::SEPARATOR
+
+      path.split(File::SEPARATOR).each do |dir|
+
+        # Add the child directory on to the path.
+        _path = File.join(_path, dir)
+
+        begin
+          sftp.stat!(_path).directory?
+        rescue Net::SFTP::StatusException
+          begin
+            puts "Creating directory: #{_path}"
+            sftp.mkdir!(_path)
+          rescue
+            raise "Error creating #{_path}: #{$!}"
+          end
+        end
+      end
+
+    end
+
+  end
+end