activemail 1.2.2 → 2.0.0

data/lib/activemail/quality/rule.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ActiveMail
+  module Quality
+    # :html rules receive (Nokogiri document, html), :message rules the mail; a check
+    # returns nil/false to pass, else one message or an Array of them.
+    class Rule
+      extend T::Sig
+
+      LEVELS = T.let(%i[html message].freeze, T::Array[Symbol])
+
+      sig { returns(Symbol) }
+      attr_reader :name
+
+      sig { returns(Symbol) }
+      attr_reader :level
+
+      sig { params(name: Symbol, level: Symbol, check: Proc).void }
+      def initialize(name, level, check)
+        raise ArgumentError, "rule level must be one of #{LEVELS.inspect}, got #{level.inspect}" unless LEVELS.include?(level)
+
+        @name = name
+        @level = level
+        @check = check
+      end
+
+      sig { params(name: Symbol, check: Proc).returns(Rule) }
+      def self.html(name, &check)
+        new(name, :html, check)
+      end
+
+      sig { params(name: Symbol, check: Proc).returns(Rule) }
+      def self.message(name, &check)
+        new(name, :message, check)
+      end
+
+      sig { params(args: T::Array[T.untyped]).returns(T::Array[String]) }
+      def messages(args)
+        result = T.unsafe(@check).call(*args)
+        result ? Array(result).map(&:to_s) : []
+      end
+    end
+  end
+end

data/lib/activemail/rails/engine.rb

@@ -2,28 +2,28 @@
 # frozen_string_literal: true
 
 require 'rails/engine'
-require 'activemail/rails/compiled_stylesheet'
+require 'activemail/asset_pipeline'
+require 'activemail/rails/rendering'
 
 module ActiveMail
   module Rails
     class Engine < ::Rails::Engine
-      config.annotations.register_extensions('activemail') { |annotation| /<!--\s*(#{annotation}):?\s*(.*) -->/ } if config.respond_to?(:annotations)
-
-      # Sprockets only compiles whitelisted assets; the framework entry must be
-      # reachable as `stylesheet_link_tag "activemail/activemail"` from a host.
+      # Sprockets only compiles whitelisted assets (a no-op under Propshaft).
       initializer 'activemail.assets' do |app|
-        # Propshaft exposes config.assets but no #precompile (Sprockets-only).
-        assets = app.config.respond_to?(:assets) ? app.config.assets : nil
-        assets.precompile += %w[activemail/activemail.css] if assets.respond_to?(:precompile)
+        ActiveMail::AssetPipeline.for(app).register_precompile(%w[activemail/activemail.css])
+      end
+
+      initializer 'activemail.annotations' do |app|
+        ActiveSupport.on_load(:action_view) do
+          extensions = ActionView::Template.template_handler_extensions.grep(/\Ainky-/)
+          app.config.annotations.register_extensions(*extensions) { |annotation| /<!--\s*(#{annotation}):?\s*(.*) -->/ }
+        end
       end
 
       initializer 'activemail.action_mailer' do
         ActiveSupport.on_load(:action_mailer) do
-          require 'activemail/inliner/interceptor'
-          # The interceptor honors config.register_inline_interceptor (and inliner =
-          # :null) at delivery time — a boot-time check would precede host config.
-          register_interceptor ActiveMail::Inliner::Interceptor
-          # activemail_inline_styles must be available to mailer layouts/views.
+          prepend ActiveMail::Rails::Rendering::MailerExtension
+
           helper ActiveMail::StylesHelper
         end
       end

data/lib/activemail/rails/rendering.rb

@@ -0,0 +1,51 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'active_support/isolated_execution_state'
+
+module ActiveMail
+  module Rails
+    # Handlers only mark the scope; the pipeline runs once at its exit, so a
+    # layout wrapping a view never re-transpiles it.
+    module Rendering
+      STATE_KEY = :activemail_render_scope
+
+      class Scope
+        attr_accessor :inky_html
+      end
+
+      class << self
+        def scoped
+          return yield if current
+
+          scope = Scope.new
+          ActiveSupport::IsolatedExecutionState[STATE_KEY] = scope
+          body = yield
+          scope.inky_html ? ActiveMail::Pipeline.call(body.to_s).html_safe : body
+        ensure
+          ActiveSupport::IsolatedExecutionState[STATE_KEY] = nil if scope
+        end
+
+        def process(output, format)
+          scope = current
+          return ActiveMail.configuration.core.transpile(output) unless scope
+
+          scope.inky_html = true if format.nil? || format == :html
+          output
+        end
+
+        private
+
+        def current
+          ActiveSupport::IsolatedExecutionState[STATE_KEY]
+        end
+      end
+
+      module MailerExtension
+        def render_to_body(options = {})
+          ActiveMail::Rails::Rendering.scoped { super }
+        end
+      end
+    end
+  end
+end

data/lib/activemail/rails/template_handler.rb

@@ -3,6 +3,8 @@
 
 require 'sorbet-runtime'
 
+require_relative 'rendering'
+
 module ActiveMail
   module Rails
     class TemplateHandler
@@ -37,7 +39,7 @@ module ActiveMail
           else
             engine_handler.call(template)
           end
-        "ActiveMail::Core.new.transpile(begin; #{compiled_source};end)"
+        "ActiveMail::Rails::Rendering.process(begin; #{compiled_source};end, #{template.format.inspect})"
       end
 
       module Composer

data/lib/activemail/tokens/button_style.rb

@@ -14,12 +14,11 @@ module ActiveMail
       const :radius, String
       const :border, T.nilable(String)
 
-      # color falls back to :button_text; border is opt-in (a "<variant>_border" token).
       sig { params(tokens: ActiveMail::Tokens, variant: T.any(String, Symbol)).returns(ButtonStyle) }
       def self.from(tokens, variant)
         new(
           background: tokens.color!(variant),
-          color: tokens.color("#{variant}_text") || tokens.color!(:button_text),
+          color: tokens.color!("#{variant}_text"),
           radius: tokens.radius!(:button),
           border: tokens.color("#{variant}_border")
         )

data/lib/activemail/tokens/defaults.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ActiveMail
+  class Tokens
+    TokenMap = T.type_alias { T::Hash[Symbol, String] }
+
+    DEFAULT_COLORS = T.let(
+      {
+        primary: '#2a9d8f',
+        secondary: '#264653',
+        text: '#1a1a1a',
+        background: '#ffffff',
+        muted: '#6b7280',
+        border: '#e5e7eb',
+        button_text: '#ffffff'
+      }.freeze,
+      TokenMap
+    )
+
+    SYSTEM_FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif'
+
+    DEFAULT_FONTS = T.let(
+      {
+        body: SYSTEM_FONT_STACK,
+        heading: SYSTEM_FONT_STACK
+      }.freeze,
+      TokenMap
+    )
+
+    DEFAULT_SPACINGS = T.let(
+      {
+        xs: '4px',
+        sm: '8px',
+        md: '16px',
+        lg: '24px',
+        xl: '40px'
+      }.freeze,
+      TokenMap
+    )
+
+    DEFAULT_RADII = T.let(
+      {
+        button: '4px',
+        box: '4px'
+      }.freeze,
+      TokenMap
+    )
+
+    # Optional colors resolve to another token (nil: unset) so components and the
+    # SCSS bridge read the same value whether or not the host configured them.
+    DERIVED_COLORS = T.let(
+      {
+        primary_text: :button_text,
+        primary_border: nil,
+        secondary_text: :button_text,
+        secondary_border: nil,
+        info_box_background: :background,
+        info_box_border: :border,
+        info_box_text: :text
+      }.freeze,
+      T::Hash[Symbol, T.nilable(Symbol)]
+    )
+
+    GROUPS = T.let(
+      {
+        color: DEFAULT_COLORS,
+        font: DEFAULT_FONTS,
+        spacing: DEFAULT_SPACINGS,
+        radius: DEFAULT_RADII
+      }.freeze,
+      T::Hash[Symbol, TokenMap]
+    )
+  end
+end

data/lib/activemail/tokens/scss_serializer.rb

@@ -5,15 +5,15 @@ require 'sorbet-runtime'
 
 module ActiveMail
   class Tokens
-    # !default lets a host pre-declare overrides upstream. Values are emitted
-    # verbatim (trusted, app-controlled input) — not escaped.
+    # !default lets a host configure overrides upstream. Values are emitted
+    # verbatim (trusted, app-controlled input) — not escaped; nil becomes Sass null.
     module ScssSerializer
       extend T::Sig
 
-      sig { params(stores: T::Hash[Symbol, TokenMap]).returns(String) }
+      sig { params(stores: T::Hash[Symbol, T::Hash[Symbol, T.nilable(String)]]).returns(String) }
       def self.call(stores)
         lines = stores.flat_map do |group, store|
-          store.map { |name, value| "$am-#{group}-#{name.to_s.tr('_', '-')}: #{value} !default;" }
+          store.map { |name, value| "$am-#{group}-#{name.to_s.tr('_', '-')}: #{value || 'null'} !default;" }
         end
         "#{lines.join("\n")}\n"
       end

data/lib/activemail/tokens.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
+require_relative 'tokens/defaults'
 require_relative 'tokens/button_style'
 require_relative 'tokens/scss_serializer'
 
@@ -9,61 +10,6 @@ module ActiveMail
   class Tokens
     extend T::Sig
 
-    TokenMap = T.type_alias { T::Hash[Symbol, String] }
-
-    DEFAULT_COLORS = T.let(
-      {
-        primary: '#2a9d8f',
-        secondary: '#264653',
-        text: '#1a1a1a',
-        background: '#ffffff',
-        muted: '#6b7280',
-        border: '#e5e7eb',
-        button_text: '#ffffff'
-      }.freeze,
-      TokenMap
-    )
-
-    SYSTEM_FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif'
-
-    DEFAULT_FONTS = T.let(
-      {
-        body: SYSTEM_FONT_STACK,
-        heading: SYSTEM_FONT_STACK
-      }.freeze,
-      TokenMap
-    )
-
-    DEFAULT_SPACINGS = T.let(
-      {
-        xs: '4px',
-        sm: '8px',
-        md: '16px',
-        lg: '24px',
-        xl: '40px'
-      }.freeze,
-      TokenMap
-    )
-
-    DEFAULT_RADII = T.let(
-      {
-        button: '4px',
-        box: '4px'
-      }.freeze,
-      TokenMap
-    )
-
-    # Open/Closed: adding a group here is the only change needed to wire it everywhere.
-    GROUPS = T.let(
-      {
-        color: DEFAULT_COLORS,
-        font: DEFAULT_FONTS,
-        spacing: DEFAULT_SPACINGS,
-        radius: DEFAULT_RADII
-      }.freeze,
-      T::Hash[Symbol, TokenMap]
-    )
-
     sig { void }
     def initialize
       @stores = T.let(GROUPS.transform_values(&:dup), T::Hash[Symbol, TokenMap])
@@ -123,6 +69,13 @@ module ActiveMail
       end
     end
 
+    # Every token with derived colors filled in; nil marks a derived token left unset.
+    sig { returns(T::Hash[Symbol, T::Hash[Symbol, T.nilable(String)]]) }
+    def resolved
+      colors = DERIVED_COLORS.keys.to_h { |name| [name, color(name)] }
+      @stores.merge(color: store_for(:color).merge(colors))
+    end
+
     sig { params(variant: T.any(String, Symbol)).returns(ButtonStyle) }
     def button_style(variant)
       ButtonStyle.from(self, variant)
@@ -130,7 +83,7 @@ module ActiveMail
 
     sig { returns(String) }
     def to_scss
-      ScssSerializer.call(@stores)
+      ScssSerializer.call(resolved)
     end
 
     private
@@ -142,14 +95,22 @@ module ActiveMail
 
     sig { params(group: Symbol, name: T.any(String, Symbol)).returns(String) }
     def fetch!(group, name)
-      store_for(group).fetch(name.to_sym) { raise KeyError, "unknown #{group} token #{name.inspect}" }
+      access(group, name, nil) || raise(KeyError, "unknown or unset #{group} token #{name.inspect}")
+    end
+
+    sig { params(group: Symbol, key: Symbol).returns(T.nilable(String)) }
+    def derived(group, key)
+      return unless group == :color
+
+      source = DERIVED_COLORS[key]
+      source && store_for(:color)[source]
     end
 
     sig { params(group: Symbol, name: T.any(String, Symbol), value: T.nilable(String)).returns(T.nilable(String)) }
     def access(group, name, value)
       store = store_for(group)
       key = name.to_sym
-      return store[key] if value.nil?
+      return store.fetch(key) { derived(group, key) } if value.nil?
       # Emitted verbatim into SCSS — reject blanks that would yield broken CSS.
       raise ArgumentError, "token #{key} value must not be blank" if value.strip.empty?
 

data/lib/activemail/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module ActiveMail
-  VERSION = '1.2.2'
+  VERSION = '2.0.0'
 end

data/lib/activemail.rb

@@ -2,15 +2,17 @@
 # frozen_string_literal: true
 
 require 'nokogiri'
+require 'securerandom'
 require 'sorbet-runtime'
 
 require_relative 'activemail/version'
+require_relative 'activemail/errors'
 require_relative 'activemail/components/base'
+require_relative 'activemail/components/button_renderer'
 require_relative 'activemail/components/button'
 require_relative 'activemail/components/row'
 require_relative 'activemail/components/columns'
 require_relative 'activemail/components/container'
-require_relative 'activemail/components/inky'
 require_relative 'activemail/components/block_grid'
 require_relative 'activemail/components/menu'
 require_relative 'activemail/components/menu_item'
@@ -22,19 +24,32 @@ require_relative 'activemail/components/wrapper'
 require_relative 'activemail/components/cta'
 require_relative 'activemail/components/info_box'
 require_relative 'activemail/configuration'
-require_relative 'activemail/inliner/interceptor'
+require_relative 'activemail/pipeline'
 require_relative 'activemail/parse_error_reporter'
 
 module ActiveMail
-  class ParseError < StandardError; end
-
   class Core
     extend T::Sig
 
     # Nokogiri cannot parse a bare <th> outside a <tr>; components that emit
     # <th> use this placeholder, swapped back at the end.
     INTERIM_TH_TAG = 'activemail-interim-th'
-    INTERIM_TH_TAG_REGEX = T.let(%r{(?<=<|</)#{Regexp.escape(INTERIM_TH_TAG)}}, Regexp)
+
+    # Comment placeholder handed to components as `inner`; the transformed children
+    # are moved there without being re-serialized.
+    SLOT_TEXT = 'activemail-slot'
+    SLOT = T.let("<!--#{SLOT_TEXT}-->".freeze, String)
+
+    # The component markup repeats the id of the node it replaces, which libxml2 still has registered.
+    LIBXML_ID_REDEFINED_CODE = 513
+
+    RAW_REGEX = T.let(%r{< *raw *>([\s\S]*?)</ *raw *>}i, Regexp)
+
+    # One pass over the serialized output; <style>/<script> bodies are matched first so they are left alone.
+    POSTPROCESS_REGEX = T.let(
+      %r{(?<verbatim><(?<tag>style|script)\b[\s\S]*?</\k<tag>\s*>)|(?<=<|</)#{Regexp.escape(INTERIM_TH_TAG)}(?![\w-])|\u00A0}i,
+      Regexp
+    )
 
     DEFAULT_COMPONENTS = T.let(
       {
@@ -44,7 +59,6 @@ module ActiveMail
         'row' => ActiveMail::Components::Row,
         'columns' => ActiveMail::Components::Columns,
         'container' => ActiveMail::Components::Container,
-        'inky' => ActiveMail::Components::Inky,
         'block-grid' => ActiveMail::Components::BlockGrid,
         'menu' => ActiveMail::Components::Menu,
         'item' => ActiveMail::Components::MenuItem,
@@ -60,85 +74,99 @@ module ActiveMail
     sig { returns(Integer) }
     attr_reader :column_count, :container_width
 
-    sig { returns(T::Hash[String, ActiveMail::Components::Base]) }
-    attr_reader :component_instances
+    sig { returns(ActiveMail::Configuration) }
+    attr_reader :config
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).void }
-    def initialize(options = {})
-      config = ::ActiveMail.configuration
-      @component_instances = T.let(build_components(config, options[:components]), T::Hash[String, ActiveMail::Components::Base])
-      @column_count = T.let(ActiveMail.assert_positive_dimension!(:column_count, options[:column_count] || config.column_count), Integer)
-      @container_width = T.let(ActiveMail.assert_positive_dimension!(:container_width, options[:container_width] || config.container_width), Integer)
+    sig do
+      params(
+        config: ActiveMail::Configuration,
+        components: T.untyped,
+        column_count: T.untyped,
+        container_width: T.untyped
+      ).void
+    end
+    def initialize(config: ::ActiveMail.configuration, components: nil, column_count: nil, container_width: nil)
+      @config = T.let(config, ActiveMail::Configuration)
+      @component_instances = T.let(build_components(config, components), T::Hash[String, ActiveMail::Components::Base])
+      @column_count = T.let(ActiveMail.positive_integer!(:column_count, column_count || config.column_count), Integer)
+      @container_width = T.let(ActiveMail.positive_integer!(:container_width, container_width || config.container_width), Integer)
+      @error_reporter = T.let(ParseErrorReporter.new(@component_instances.keys + [INTERIM_TH_TAG], config), ParseErrorReporter)
     end
 
     # Object, not String: ActionView::OutputBuffer is no longer a String since Rails 7.1.
+    # Holds no per-call state: the instance is shared across threads.
     sig { params(html_string: Object).returns(String) }
     def transpile(html_string)
-      raws, str = extract_raws(normalize_input(html_string))
+      marker = "activemail-raw-#{SecureRandom.hex(8)}-"
+      raws = {}
+      str = extract_raws(normalize_input(html_string), marker, raws)
       parse_cmd = ::ActiveMail.full_document?(str) ? :parse : :fragment
       html = Nokogiri::HTML.public_send(parse_cmd, str)
-      ParseErrorReporter.new(component_instances.keys).call(html.errors)
+      @error_reporter.call(html.errors)
       transform_doc(html)
-      string = html.to_html
-      string = string.gsub(INTERIM_TH_TAG_REGEX, 'th')
-      # Needle is a literal U+00A0 (Nokogiri decodes the nbsp entity to one); re-encode
-      # it to the entity for email clients that mishandle raw NBSP bytes.
-      string = string.gsub(' ', '&nbsp;')
-      re_inject_raws(string, raws)
+      re_inject_raws(postprocess(html.to_html), marker, raws)
     end
 
-    sig { params(elem: Nokogiri::XML::Node).returns(Nokogiri::XML::Node) }
-    def transform_doc(elem)
-      if elem.respond_to?(:children)
-        elem.children.each { |child| transform_doc(child) }
-        markup = component_factory(elem)
-        elem.replace(markup) if markup
-      end
-      elem
-    end
+    private
 
-    sig { params(node: Nokogiri::XML::Node).returns(T.nilable(String)) }
-    def component_factory(node)
+    sig { returns(T::Hash[String, ActiveMail::Components::Base]) }
+    attr_reader :component_instances
+
+    sig { params(node: Nokogiri::XML::Node).void }
+    def transform_doc(node)
+      node.children.each { |child| transform_doc(child) }
       component = component_instances[node.name]
-      return unless component
+      replace_with_component(node, component, component.transform(node, SLOT)) if component
+    end
+
+    # Only the component's own markup is parsed; the node's children are moved into
+    # its slot, never re-serialized.
+    sig { params(node: Nokogiri::XML::Node, component: ActiveMail::Components::Base, markup: String).void }
+    def replace_with_component(node, component, markup)
+      fragment = Nokogiri::HTML::DocumentFragment.new(node.document, markup, node)
+      @error_reporter.call(fragment.errors.reject { |error| error.code == LIBXML_ID_REDEFINED_CODE })
+      slots = fragment.xpath('.//comment()').select { |comment| comment.content == SLOT_TEXT }
+      ensure_slot_usage!(node, component, slots.size)
+      slots.first&.replace(node.children)
+      node.replace(fragment)
+    end
+
+    sig { params(node: Nokogiri::XML::Node, component: ActiveMail::Components::Base, count: Integer).void }
+    def ensure_slot_usage!(node, component, count)
+      return if count == 1 || (count.zero? && node.children.all? { |child| child.text? && child.content.strip.empty? })
 
-      # Nokogiri::NodeSet has no #join; map to String first.
-      inner = node.children.map(&:to_s).join # rubocop:disable Style/MapJoin
-      component.transform(node, inner)
+      raise ActiveMail::Error,
+            "<#{node.name}> (#{component.class}) must output `inner` exactly once, found #{count}: its children would be lost or duplicated"
     end
 
-    sig { params(string: String).returns([T::Array[String], String]) }
-    def extract_raws(string)
-      raws = []
-      i = 0
+    sig { params(string: String, marker: String, raws: T::Hash[String, String]).returns(String) }
+    def extract_raws(string, marker, raws)
       # Only the tags + content, across lines: surrounding whitespace is left in
       # place (true pass-through; eating adjacent newlines corrupts <pre>/inline text).
-      regex = %r{< *raw *>([\s\S]*?)</ *raw *>}i
-      str = string
-      while (raw = str.match(regex))
-        raws[i] = T.must(raw[1])
-        str = str.sub(regex, "###RAW#{i}###")
-        i += 1
+      string.gsub(RAW_REGEX) do
+        placeholder = "#{marker}#{raws.size}~"
+        raws[placeholder] = T.must(Regexp.last_match(1))
+        placeholder
       end
-      [raws, str]
     end
 
-    sig { params(string: String, raws: T::Array[String]).returns(String) }
-    def re_inject_raws(string, raws)
-      str = string
-      raws.each_with_index do |val, i|
-        # Block form: the 2-arg String#sub would expand \0/\1/\& in val.
-        str = str.sub("###RAW#{i}###") { val }
+    # U+00A0 is what Nokogiri decodes the nbsp entity to; re-encoded for email clients that mishandle raw NBSP bytes.
+    sig { params(string: String).returns(String) }
+    def postprocess(string)
+      string.gsub(POSTPROCESS_REGEX) do |match|
+        next match if Regexp.last_match(:verbatim)
+
+        match == "\u00A0" ? '&nbsp;' : 'th'
       end
+    end
+
+    sig { params(string: String, marker: String, raws: T::Hash[String, String]).returns(String) }
+    def re_inject_raws(string, marker, raws)
+      str = raws.empty? ? string : string.gsub(/#{Regexp.escape(marker)}\d+~/) { |token| raws.fetch(token) }
       str = str.html_safe if str.respond_to?(:html_safe)
       str
     end
 
-    private
-
-    # Internal transpilation details, not public surface (column_count/container_width stay public).
-    private :component_instances, :transform_doc, :component_factory, :extract_raws, :re_inject_raws
-
     sig { params(config: ActiveMail::Configuration, overrides: T.untyped).returns(T::Hash[String, ActiveMail::Components::Base]) }
     def build_components(config, overrides)
       # Lookup is by node name (String); a Symbol key would never match.
@@ -151,8 +179,8 @@ module ActiveMail
     def normalize_input(html_string)
       html_string = html_string.to_s
       html_string = html_string.dup.force_encoding(Encoding::UTF_8) if html_string.encoding == Encoding::BINARY
-      html_string = ::ActiveMail.scrub_invalid_bytes(html_string) unless html_string.valid_encoding?
-      html_string.gsub(/doctype/i, 'DOCTYPE')
+      html_string = ::ActiveMail.scrub_invalid_bytes(html_string, config.on_parse_error) unless html_string.valid_encoding?
+      html_string
     end
   end
 end

data/lib/generators/activemail/templates/component.rb.tt

@@ -4,10 +4,9 @@
 module Components
   # Register in config/initializers/activemail.rb:
   #   config.register_component "<%= tag_name %>", Components::<%= class_name %>
-  class <%= class_name %> < ActiveMail::Components::Base
+  class <%= class_name %> < ActiveMail::Components::TableComponent
     def transform(node, inner)
-      classes = combine_classes(node, "<%= tag_name %>")
-      %(<table class="#{classes}" #{TABLE_RESET}><tbody><tr><td>#{inner}</td></tr></tbody></table>)
+      %(<table#{root_attributes(node, classes: "<%= tag_name %>")} #{TABLE_RESET}><tbody><tr><td>#{inner}</td></tr></tbody></table>)
     end
   end
 end

data/lib/generators/activemail/templates/initializer.rb

@@ -14,9 +14,6 @@ ActiveMail.configure do |config|
   # ActiveMail::Inliner::Base subclass/instance.
   # config.inliner = :premailer
 
-  # Set false if another inliner (e.g. premailer-rails) already runs on mailers.
-  # config.register_inline_interceptor = true
-
   # How malformed markup is handled: :warn (default), :ignore, or :raise.
   # config.on_parse_error = :warn
 

data/lib/generators/activemail/templates/mailer_layout.html.inky-erb

@@ -16,8 +16,6 @@
     </noscript>
     <![endif]-->
     <%%= activemail_inline_styles %>
-    <%%# Fallback for when activemail_inline_styles cannot read the compiled asset. %>
-    <%%= stylesheet_link_tag "activemail/activemail", media: "all" %>
   </head>
 
   <body style="margin:0;padding:0;word-spacing:normal;">

data/lib/generators/activemail/templates/mailer_layout.html.inky-haml

@@ -9,8 +9,6 @@
     :plain
       <!--[if mso]><noscript><xml><o:OfficeDocumentSettings><o:PixelsPerInch>96</o:PixelsPerInch></o:OfficeDocumentSettings></xml></noscript><![endif]-->
     = activemail_inline_styles
-    -# Fallback for when activemail_inline_styles cannot read the compiled asset.
-    = stylesheet_link_tag "activemail/activemail", media: "all"
   %body{style: "margin:0;padding:0;word-spacing:normal;"}
     %div{role: "article", "aria-roledescription" => "email", lang: I18n.locale, style: "width:100%;"}
       %container