inkcite 1.0.0

data/lib/inkcite/parser.rb

@@ -0,0 +1,111 @@
+module Inkcite
+  class Parser
+
+    def self.each str, regex=BRACKET_REGEX, &block
+
+      # Make sure we're dealing with a string.
+      str = str.to_s
+
+      # If the string provided is frozen, we need to duplicate it because we
+      # don't want to modify the original.
+      str = str.dup if str.frozen?
+
+      # Counts the number of replacements and prevents an infinite loop.
+      failsafe = 0
+
+      # While there are matches within the string, repeatedly iterate.
+      while match = regex.match(str)
+
+        # Get the position, as an array, of the match within the string.
+        offset = match.offset(0)
+
+        # Provide the block with the area that was matched, sans wrapper brackets.
+        # Replace the brackets and original value with the block's results.
+        result = yield(match[1].to_s) || EMPTY_STRING
+        str[offset.first, offset.last - offset.first] = result
+
+        # Ensure we don't infinite loop.
+        failsafe += 1
+        raise "Infinite replacement detected: #{failsafe} #{str}" if failsafe >= MAX_RECURSION
+      end
+
+      str
+    end
+
+    def self.parameters str
+
+      # Add an extra space to the end to ensure that the last parameter
+      # gets parsed correctly.
+      str = str.to_s + SPACE
+
+      # Will hold the parameters successfully parsed.
+      params = { }
+
+      # True if we're within a quoted value.
+      quote = false
+
+      # Will hold each key and value we find.
+      key = nil
+
+      # This will hold the substring that is assembled - it will either be the
+      # key (when an equals in encountered) or the value (when a space or closing
+      # quote is discovered).
+      value = ''
+
+      length = str.length - 1
+      for i in 0..length
+
+        # Read the next character in the string.
+        chr = str[i]
+
+        if chr == QUOTE
+
+          # Each time a quote is discovered, toggle the flag indicating that we're
+          # inside of a value or (when false) we're assembling a key.
+          quote = !quote
+
+        elsif chr == EQUAL && !quote
+
+          # When an equal sign is encountered and we're not inside of a quote, then
+          # convert the assembled value into a symbolized key.
+          unless value.blank?
+            key = value.to_sym
+            value = ''
+          end
+
+        elsif chr == SPACE && !quote
+
+          # When a space is encountered, if we're not inside of a quote block then
+          # assign the assembled value to the previously discovered key.
+          if key
+            params[key] = value
+            value = ''
+            key = nil
+          end
+
+        else
+          value << chr
+
+        end
+
+      end
+
+      params
+    end
+
+    private
+
+    # When the handler returns nil
+    EMPTY_STRING = ''
+
+    # We fail if we recurse through a property more than this many times.
+    MAX_RECURSION = 1000
+
+    BRACKET_REGEX = /\{([^\{\}]+)\}/
+
+    SPACE = ' '
+    QUOTE = '"'
+    EQUAL = '='
+
+  end
+end

data/lib/inkcite/renderer.rb

@@ -0,0 +1,177 @@
+require_relative 'renderer/base'
+require_relative 'renderer/element'
+require_relative 'renderer/responsive'
+require_relative 'renderer/image_base'
+require_relative 'renderer/table_base'
+
+require_relative 'renderer/button'
+require_relative 'renderer/div'
+require_relative 'renderer/footnote'
+require_relative 'renderer/google_analytics'
+require_relative 'renderer/image'
+require_relative 'renderer/in_browser'
+require_relative 'renderer/like'
+require_relative 'renderer/link'
+require_relative 'renderer/litmus'
+require_relative 'renderer/lorem'
+require_relative 'renderer/mobile_image'
+require_relative 'renderer/mobile_style'
+require_relative 'renderer/mobile_toggle'
+require_relative 'renderer/outlook_background'
+require_relative 'renderer/partial'
+require_relative 'renderer/preheader'
+require_relative 'renderer/property'
+require_relative 'renderer/span'
+require_relative 'renderer/table'
+require_relative 'renderer/td'
+
+module Inkcite
+  module Renderer
+
+    def self.fix_illegal_characters value, context
+
+      # These special characters cause rendering problems in a variety
+      # of email clients.  Convert them to the correct unicode characters.
+      # https://www.campaignmonitor.com/blog/post/1810/why-are-all-my-apostrophes-mis
+
+      if context.text?
+        value.gsub!(/[–—]/, '-')
+        value.gsub!(/™/, '(tm)')
+        value.gsub!(/®/, '(r)')
+        value.gsub!(/[‘’`]/, "'")
+        value.gsub!(/[“”]/, '"')
+        value.gsub!(/…/, '...')
+
+      else
+        value.gsub!(/[–—]/, '–')
+        value.gsub!(/\-\-/, '–')
+        value.gsub!(/™/, '™')
+        value.gsub!(/®/, '®')
+        value.gsub!(/[‘’`]/, '’')
+        value.gsub!(/“/, '“')
+        value.gsub!(/”/, '”')
+        value.gsub!(/é/, 'é')
+        value.gsub!(/…/, '…')
+
+      end
+
+      value
+    end
+
+    def self.hex color
+
+      # Convert #rgb into #rrggbb
+      if !color.blank? && color.length < 7
+        red = color[1]
+        green = color[2]
+        blue = color[3]
+        color = "##{red}#{red}#{green}#{green}#{blue}#{blue}"
+      end
+
+      color
+    end
+
+    # Joins the key-value-pairs of the provided hash into a readable
+    # string destined for HTML or CSS style declarations.  For example,
+    # { :bgcolor => '"#fff"' } would become bgcolor="#fff" using the
+    # default equality and space delimiters.
+    def self.join_hash hash, equal=EQUAL, sep=SPACE
+
+      pairs = []
+
+      hash.keys.sort.each do |att|
+        val = hash[att]
+        pairs << "#{att}#{equal}#{val}" unless val.blank?
+      end
+
+      pairs.join(sep)
+    end
+
+    # Applies a "px" extension to unlabeled integer values.  If a labeled
+    # value is detected (e.g. 2em) or a non-integer value is provided
+    # (e.g. "normal") then the value is returned directly.
+    def self.px val
+
+      # Quick abort if a non-integer value has been provided.  This catches
+      # cases like 3em and normal.  When provided, the value is not converted
+      # to pixels and instead is returned directly.
+      return val if val && val.to_i.to_s != val.to_s
+
+      val = val.to_i
+      val = "#{val}px" unless val == 0
+      val
+    end
+
+    def self.quote val
+      "\"#{val}\""
+    end
+
+    def self.render str, context
+
+      Parser.each(str) do |tag|
+
+        # Split the string into the tag and it's attributes.
+        name, opts = tag.split(SPACE, 2)
+
+        # Convert the options string (e.g. color=#ff9900 border=none) into parameters.
+        opts = Parser.parameters(opts)
+
+        # Strip off the leading slash (/) if there is one.  Renderers are
+        open_tag = (name.starts_with?(SLASH) ? name[1..-1] : name).to_sym
+
+        # Choose a renderer either from the dynamic set or use the default one that
+        # simply renders from the property values.
+        renderer = renderers[open_tag] || default_renderer
+
+        renderer.render name, opts, context
+
+      end
+
+    end
+
+    def self.render_styles styles
+      join_hash(styles, COLON, SEMI_COLON)
+    end
+
+    private
+
+    COLON      = ':'
+    EQUAL      = '='
+    SEMI_COLON = ';'
+    SPACE      = ' '
+    SLASH      = '/'
+
+    def self.default_renderer
+      @default_renderer ||= Property.new
+    end
+
+    def self.renderers
+
+      # Dynamic renderers for custom behavior and tags.
+      @renderers ||= {
+          :a                  => Link.new,
+          :button             => Button.new,
+          :div                => Div.new,
+          :footnote           => Footnote.new,
+          :footnotes          => Footnotes.new,
+          :google             => GoogleAnalytics.new,
+          :img                => Image.new,
+          :'in-browser'       => InBrowser.new,
+          :include            => Partial.new,
+          :like               => Like.new,
+          :litmus             => Litmus.new,
+          :lorem              => Lorem.new,
+          :'mobile-img'       => MobileImage.new,
+          :'mobile-style'     => MobileStyle.new,
+          :'mobile-toggle-on' => MobileToggleOn.new,
+          :'outlook-bg'       => OutlookBackground.new,
+          :preheader          => Preheader.new,
+          :span               => Span.new,
+          :table              => Table.new,
+          :td                 => Td.new
+      }
+
+    end
+
+  end
+end

data/lib/inkcite/renderer/base.rb

@@ -0,0 +1,186 @@
+module Inkcite
+  module Renderer
+    class Base
+
+      # Constants for style and property names with dashes in them.
+      BACKGROUND_COLOR    = :'background-color'
+      BACKGROUND_IMAGE    = :'background-image'
+      BACKGROUND_REPEAT   = :'background-repeat'
+      BACKGROUND_POSITION = :'background-position'
+      BACKGROUND_SIZE     = :'background-size'
+      BORDER_BOTTOM       = :'border-bottom'
+      BORDER_COLLAPSE     = :'border-collapse'
+      BORDER_RADIUS       = :'border-radius'
+      BORDER_SPACING      = :'border-spacing'
+      BOX_SHADOW          = :'box-shadow'
+      FONT_FAMILY         = :'font-family'
+      FONT_SIZE           = :'font-size'
+      FONT_WEIGHT         = :'font-weight'
+      LETTER_SPACING      = :'letter-spacing'
+      LINE_HEIGHT         = :'line-height'
+      LINK_COLOR          = :'#link'
+      MARGIN_TOP          = :'margin-top'
+      PADDING_X           = :'padding-x'
+      PADDING_Y           = :'padding-y'
+      TEXT_ALIGN          = :'text-align'
+      TEXT_DECORATION     = :'text-decoration'
+      TEXT_SHADOW         = :'text-shadow'
+      TEXT_SHADOW_BLUR    = :'shadow-blur'
+      TEXT_SHADOW_OFFSET  = :'shadow-offset'
+      VERTICAL_ALIGN      = :'vertical-align'
+
+      # CSS Directions
+      DIRECTIONS = [ :top, :right, :bottom, :left ]
+
+      # Attribute and CSS dimensions
+      DIMENSIONS = [ :width, :height ]
+
+      # Common value declarations
+      POUND_SIGN = '#'
+      NONE       = 'none'
+
+      # Zero-width space character
+      ZERO_WIDTH_SPACE = '​'
+
+      def render tag, opt, ctx
+        raise "Not implemented: #{tag} #{opts}"
+      end
+
+      protected
+
+      # Convenience proxy
+      def detect *opts
+        Util.detect(*opts)
+      end
+
+      def detect_font att, font, opt, parent, ctx
+        val = detect(opt[att], ctx["#{font}-#{att}"], parent ? parent[att] : nil)
+
+        # Sometimes font values reference other defined values so we need
+        # to run them through the renderer to resolve them.
+        val = Inkcite::Renderer.render(val, ctx)
+
+        # Convience
+        val = nil if none?(val)
+
+        val
+      end
+
+      # Convenience pass-thru to Renderer's static helper method.
+      def hex color
+        Renderer.hex(color)
+      end
+
+      def none? val
+        val.blank? || val == NONE
+      end
+
+      # Sets the element's in-line bgcolor style if it has been defined
+      # in the provided options.
+      def mix_background element, opt
+
+        # Background color of the image, if populated.
+        bgcolor = detect(opt[:bgcolor], opt[BACKGROUND_COLOR])
+        element.style[BACKGROUND_COLOR] = hex(bgcolor) unless none?(bgcolor)
+
+      end
+
+      def mix_font element, opt, ctx, parent=nil
+
+        # Always ensure we have a parent to inherit from.
+        parent ||= {}
+
+        # Check for a font in either the element's specified options or inherit a setting from
+        # from the parent if provided.
+        font = detect(opt[:font], parent[:font])
+
+        # Fonts can be disabled on individual cells if the parent table
+        # has set one for the entire table.
+        font = nil if none?(font)
+
+        font_family = detect_font(FONT_FAMILY, font, opt, parent, ctx)
+        element.style[FONT_FAMILY] = font_family unless font_family.blank?
+
+        font_size = detect_font(FONT_SIZE, font, opt, parent, ctx)
+        element.style[FONT_SIZE] = px(font_size) unless font_size.blank?
+
+        color = detect_font(:color, font, opt, parent, ctx)
+        element.style[:color] = hex(color) unless color.blank?
+
+        line_height = detect_font(LINE_HEIGHT, font, opt, parent, ctx)
+        element.style[LINE_HEIGHT] = px(line_height) unless line_height.blank?
+
+        font_weight = detect_font(FONT_WEIGHT, font, opt, parent, ctx)
+        element.style[FONT_WEIGHT] = font_weight unless font_weight.blank?
+
+        letter_spacing = detect_font(LETTER_SPACING, font, opt, parent, ctx)
+        element.style[LETTER_SPACING] = px(letter_spacing) unless none?(letter_spacing)
+
+        # With font support comes text shadow support.
+        mix_text_shadow element, opt, ctx
+
+        font
+      end
+
+      def mix_text_shadow element, opt, ctx
+
+        shadow = detect(opt[:shadow], opt[TEXT_SHADOW])
+        return if shadow.blank?
+
+        # Allow shadows to be disabled because sometimes a child element (like an
+        # image within a cell or an entire cell within a table) wants to disable
+        # the shadowing forced by a parent.
+        if none?(shadow)
+          element.style[TEXT_SHADOW] = shadow
+
+        else
+
+          shadow_offset = detect(opt[TEXT_SHADOW_OFFSET], ctx[TEXT_SHADOW_OFFSET], 1)
+          shadow_blur = detect(opt[TEXT_SHADOW_BLUR], ctx[TEXT_SHADOW_BLUR], 0)
+
+          element.style[TEXT_SHADOW] = "0 #{px(shadow_offset)} #{px(shadow_blur)} #{hex(shadow)}"
+
+        end
+
+      end
+
+      def px val
+        Renderer.px(val)
+      end
+
+      def quote val
+        Renderer.quote(val)
+      end
+
+      def render_tag tag, attributes=nil, styles=nil
+
+        # Convert the style hash into CSS style attribute.
+        unless styles.blank?
+          attributes ||= {}
+          attributes[:style] = quote(Renderer.render_styles(styles))
+        end
+
+        # Check to see if this is a self-closing tag.
+        self_close = attributes && attributes.delete(:self_close) == true
+
+        html = "<#{tag}"
+
+        unless attributes.blank?
+
+          # Make sure multiple classes are handled properly.
+          classes = attributes[:class]
+          attributes[:class] = quote([*classes].join(' ')) unless classes.blank?
+
+          html << SPACE + Renderer.join_hash(attributes)
+
+        end
+
+        html << '/' if self_close
+        html << '>'
+
+        html
+      end
+
+    end
+  end
+end