postmortem 0.1.0 → 0.2.1

data/layout/layout.js

@@ -0,0 +1,248 @@
+(function () {
+  let previousInbox;
+  let currentView;
+  let indexUuid;
+  let inboxInitialized = false;
+
+  var htmlIframeDocument = document.querySelector("#html-iframe").contentDocument;
+  var indexIframe = document.querySelector("#index-iframe");
+  var textIframeDocument = document.querySelector("#text-iframe").contentDocument;
+  var sourceIframeDocument = document.querySelector("#source-iframe").contentDocument;
+  var sourceHighlightBundle = [
+     '<link rel="stylesheet"',
+     '     href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.3/styles/agate.min.css"',
+     '     integrity="sha512-mMMMPADD4HAIogAWZbv+WjZTC0itafUZNI0jQm48PMBTApXt11omF5jhS7U1kp3R2Pr6oGJ+JwQKiUkUwCQaUQ=="',
+     '     crossorigin="anonymous" />',
+     '<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.3/highlight.min.js"',
+     '        integrity="sha512-tHQeqtcNWlZtEh8As/4MmZ5qpy0wj04svWFK7MIzLmUVIzaHXS8eod9OmHxyBL1UET5Rchvw7Ih4ZDv5JojZww=="',
+     '        crossorigin="anonymous"></' + 'script>',
+     '<script>hljs.initHighlightingOnLoad();</' + 'script>',
+  ].join('\n');
+
+  const initialize = () => {
+    loadMail(initialData);
+
+    let reloadIframeTimeout = setTimeout(() => indexIframe.src += '', 3000);
+
+    window.addEventListener('message', function (ev) {
+      clearTimeout(reloadIframeTimeout);
+      reloadIframeTimeout = setTimeout(() => indexIframe.src += '', 3000);
+      if (indexUuid !== ev.data.uuid) renderInbox(ev.data.mails);
+      indexUuid = ev.data.uuid;
+    });
+
+    setInterval(function () { indexIframe.contentWindow.postMessage('HELO', '*'); }, 1000);
+
+    toolbar.html.onclick    = function (ev) { setView('html', ev); };
+    toolbar.text.onclick    = function (ev) { setView('text', ev); };
+    toolbar.source.onclick  = function (ev) { setView('source', ev); };
+    toolbar.headers.onclick = function () { setHeadersView(!headersView); };
+    columnSwitch.onclick    = function () { setColumnView(!twoColumnView); };
+
+    if (hasHtml) {
+      setView('html');
+    } else {
+      setView('text');
+    }
+
+    setColumnView(false);
+    setHeadersView(true);
+
+    $('[data-toggle="tooltip"]').tooltip();
+  }
+
+
+  var twoColumnView;
+  var headersView;
+  var headers = document.querySelector('.headers');
+  var inbox = document.querySelector('#inbox');
+  var columnSwitch = document.querySelector('.column-switch');
+  var headersViewSwitch = document.querySelector('.headers-view-switch');
+
+  var setHeadersView = function (enableHeadersView) {
+    headersView = enableHeadersView;
+    if (enableHeadersView) {
+      setOn(headersViewSwitch);
+      headers.classList.add('visible');
+    } else {
+      setOff(headersViewSwitch);
+      headers.classList.remove('visible');
+    }
+  };
+
+  var setColumnView = function (enableTwoColumnView) {
+    if (!inboxInitialized) return;
+
+    var container = document.querySelector('.container');
+    twoColumnView = enableTwoColumnView;
+    if (twoColumnView) {
+      setVisible(inbox, true);
+      setOn(columnSwitch);
+      container.classList.add('full-width');
+    } else {
+      setVisible(inbox, false);
+      setOff(columnSwitch);
+      container.classList.remove('full-width');
+    }
+  };
+
+  var contexts = ['source', 'text', 'html'];
+
+  var views = {
+    source: document.querySelector('.source-view'),
+    html: document.querySelector('.html-view'),
+    text: document.querySelector('.text-view'),
+  };
+
+  var toolbar = {
+    source: document.querySelector('.source-view-switch'),
+    html: document.querySelector('.html-view-switch'),
+    text: document.querySelector('.text-view-switch'),
+    headers: document.querySelector('.headers-view-switch'),
+  };
+
+  var setOn = function(element) {
+    element.classList.add('text-primary');
+    element.classList.remove('text-secondary');
+  };
+
+  var setOff = function(element) {
+    element.classList.add('text-secondary');
+    element.classList.remove('text-primary');
+  };
+
+  var setDisabled = function(element) {
+    element.classList.add('disabled');
+    element.classList.remove('text-secondary');
+  };
+
+  var setEnabled = function(element) {
+    element.classList.remove('disabled');
+    element.classList.add('text-secondary');
+  };
+
+  var setVisible = function(element, visible) {
+    if (visible) {
+      element.classList.add('visible');
+    } else {
+      element.classList.remove('visible');
+    }
+  };
+
+  var setView = function(context, ev) {
+    if (ev && $(ev.target).hasClass('disabled')) return;
+    var key;
+    for (i = 0; i < contexts.length; i++) {
+      key = contexts[i];
+      if (key === context) {
+        setOn(toolbar[key]);
+        setVisible(views[key], true);
+      } else {
+        setOff(toolbar[key]);
+        setVisible(views[key], false);
+      }
+    }
+    currentView = context;
+  };
+
+  const arrayIdentical = (a, b) => {
+    if (a && !b) return false;
+    if (a.length !== b.length) return false;
+    if (!a.every((item, index) => item === b[index])) return false;
+
+    return true;
+  };
+
+  const htmlEscape = (html) => {
+    return $("<div></div>").text(html).html();
+  };
+
+  const $headersTemplate = $("#headers-template");
+
+  const loadHeaders = (mail) => {
+    $template = $headersTemplate.clone();
+    $('#headers').html($template.html());
+    ['subject', 'from', 'replyTo', 'to', 'cc', 'bcc'].forEach(item => {
+      const $item = $(`#email-${item}`)
+      $item.text(mail[item]);
+      if (!mail[item]) $item.parent().addClass('hidden');
+    });
+  };
+
+  const loadToolbar = (mail) => {
+    if (!mail.textBody) {
+      setDisabled(toolbar.text);
+      setView('html');
+    } else {
+      setEnabled(toolbar.text);
+    }
+
+    if (!mail.htmlBody) {
+      setDisabled(toolbar.html);
+      setDisabled(toolbar.source);
+      setView('text');
+    } else {
+      setEnabled(toolbar.html);
+      setEnabled(toolbar.source);
+    }
+
+    setDisabled(columnSwitch);
+    setView(currentView);
+  };
+
+  const loadMail = (mail) => {
+    htmlIframeDocument.open();
+    htmlIframeDocument.write(mail.htmlBody);
+    htmlIframeDocument.close();
+
+    textIframeDocument.open();
+    textIframeDocument.write(`<pre>${htmlEscape(mail.textBody)}</pre>`);
+    textIframeDocument.close();
+
+    sourceIframeDocument.open();
+    sourceIframeDocument.write(`<pre><code style="padding: 1rem;" class="language-html">${htmlEscape(mail.htmlBody)}</code></pre>`);
+    sourceIframeDocument.write(sourceHighlightBundle);
+    sourceIframeDocument.close();
+
+    loadHeaders(mail);
+    loadToolbar(mail);
+    loadDownloadLink();
+  };
+
+  const loadDownloadLink = () => {
+    const blob = new Blob([document.documentElement.innerHTML], { type: 'application/octet-stream' });
+    const uri = window.URL.createObjectURL(blob);
+    $("#download-link").attr('href', uri);
+  };
+
+  const renderInbox = function (mails) {
+    const html = mails.map((mail, invertedIndex) => {
+      const index = (mails.length - 1) - invertedIndex;
+      const parsedTimestamp = new Date(mail.timestamp);
+      const timestampSpan = `<span class="timestamp">${parsedTimestamp.toLocaleString()}</span>`;
+      const classes = ['list-group-item', 'inbox-item'];
+      if (window.location.hash === '#' + index) classes.push('active');
+      return `<li data-email-index="${index}" class="${classes.join(' ')}"><a title="${mail.subject}" href="javascript:void(0)">${mail.subject}</a>${timestampSpan}</li>`
+    });
+    if (arrayIdentical(html, previousInbox)) return;
+    previousInbox = html;
+    $('#inbox').html('<ul class="list-group">' + html.join('\n') + '</ul>');
+    $('.inbox-item').click((ev) => {
+      const $target = $(ev.currentTarget);
+      const index = $target.data('email-index');
+      $('.inbox-item').removeClass('active');
+      $target.addClass('active');
+      window.location.hash = index;
+      setTimeout(() => loadMail(mails[index].content), 0);
+    });
+
+    if (!inboxInitialized) {
+      setEnabled(columnSwitch);
+      setColumnView(true);
+      setVisible(inbox, true);
+    }
+    inboxInitialized = true;
+  };
+
+  initialize();
+})();

data/lib/postmortem.rb

@@ -7,26 +7,24 @@ require 'fileutils'
 require 'mail'
 require 'erb'
 require 'json'
+require 'cgi'
 
 require 'postmortem/version'
 require 'postmortem/adapters'
 require 'postmortem/delivery'
 require 'postmortem/layout'
+require 'postmortem/configuration'
+require 'postmortem/index'
 
 # HTML email inspection tool.
 module Postmortem
   class Error < StandardError; end
 
   class << self
-    attr_reader :output_directory, :layout
-    attr_accessor :output_file
+    attr_reader :config
 
-    def output_directory=(val)
-      @output_directory = Pathname.new(val)
-    end
-
-    def layout=(val)
-      @layout = Pathname.new(val)
+    def root
+      Pathname.new(__dir__).parent
     end
 
     def record_delivery(mail)
@@ -35,15 +33,24 @@ module Postmortem
               .tap { |delivery| log_delivery(delivery) }
     end
 
-    def try_load(*args)
+    def try_load(*args, plugin:)
       args.each { |arg| require arg }
     rescue LoadError
       false
     else
-      yield
+      require "postmortem/plugins/#{plugin}"
       true
     end
 
+    def configure
+      @config = Configuration.new
+      yield @config if block_given?
+    end
+
+    def clear_inbox
+      config.preview_directory.rmtree
+    end
+
     private
 
     def log_delivery(delivery)
@@ -52,14 +59,20 @@ module Postmortem
     end
 
     def colorized(val)
-      return val unless output_file.tty?
+      return val unless output_file.tty? || !config.colorize
 
       "\e[34m[postmortem]\e[36m #{val}\e[0m"
     end
+
+    def output_file
+      return STDOUT if config.log_path.nil?
+
+      @output_file ||= File.open(config.log_path, mode: 'a')
+    end
   end
 end
 
-Postmortem.output_directory = File.join(Dir.tmpdir, 'postmortem')
-Postmortem.output_file = STDOUT
-Postmortem.layout = File.expand_path(File.join(__dir__, '..', 'layout', 'default.html.erb'))
-Postmortem.try_load('action_mailer', 'active_support') { require 'postmortem/action_mailer' }
+Postmortem.configure
+Postmortem.try_load('action_mailer', 'active_support', plugin: 'action_mailer')
+Postmortem.try_load('pony', plugin: 'pony')
+Postmortem.try_load('mail', plugin: 'mail')

data/lib/postmortem/adapters.rb

@@ -2,6 +2,8 @@
 
 require 'postmortem/adapters/base'
 require 'postmortem/adapters/action_mailer'
+require 'postmortem/adapters/mail'
+require 'postmortem/adapters/pony'
 
 module Postmortem
   # Adapters for various email senders (e.g. ActionMailer).

data/lib/postmortem/adapters/action_mailer.rb

@@ -6,16 +6,55 @@ module Postmortem
     class ActionMailer < Base
       private
 
-      def adapted(data)
+      def adapted
         {
-          from: data[:from],
-          to: data[:to],
-          cc: data[:cc],
-          bcc: data[:bcc],
-          subject: data[:subject],
-          html_body: Mail.new(data[:mail]).html_part.decoded.strip
+          from: mail.from,
+          reply_to: mail.reply_to,
+          to: mail.to,
+          cc: mail.cc,
+          bcc: normalized_bcc,
+          subject: mail.subject,
+          text_body: text_part,
+          html_body: html_part
         }
       end
+
+      def text_part
+        return nil unless text?
+        return mail.body.decoded unless mail.text_part
+
+        mail.text_part.decoded
+      end
+
+      def html_part
+        return nil unless html?
+        return mail.body.decoded unless mail.html_part
+
+        mail.html_part.decoded
+      end
+
+      def mail
+        @mail ||= ::Mail.new(@data[:mail])
+      end
+
+      def normalized_bcc
+        ::Mail.new(to: @data[:bcc]).to
+      end
+
+      def text?
+        return true unless mail.has_content_type?
+        return true if mail.content_type.include?('text/plain')
+        return true if mail.multipart? && mail.text_part
+
+        false
+      end
+
+      def html?
+        return true if mail.has_content_type? && mail.content_type.include?('text/html')
+        return true if mail.multipart? && mail.html_part
+
+        false
+      end
     end
   end
 end

data/lib/postmortem/adapters/base.rb

@@ -2,23 +2,49 @@
 
 module Postmortem
   module Adapters
+    FIELDS = %i[from reply_to to cc bcc subject text_body html_body].freeze
+
     # Base interface implementation for all Postmortem adapters.
     class Base
       def initialize(data)
-        @mail = adapted(data)
+        @data = data
+        @adapted = adapted
+      end
+
+      def html_body=(val)
+        @adapted[:html_body] = val
       end
 
-      %i[from to cc bcc subject html_body].each do |method_name|
+      def serializable
+        FIELDS.map { |field| [camelize(field.to_s), public_send(field)] }.to_h
+      end
+
+      FIELDS.each do |method_name|
         define_method method_name do
-          @mail[method_name]
+          @adapted[method_name]
         end
       end
 
+      def html_body
+        @adapted[:html_body].to_s
+      end
+
+      def text_body
+        @adapted[:text_body].to_s
+      end
+
       private
 
-      def adapted(_data)
-        raise NotImplementedError,
-              'Adapter must be a child class of Base which implements #adapted'
+      def adapted
+        raise NotImplementedError, 'Adapter child class must implement #adapted'
+      end
+
+      def camelize(string)
+        string
+          .split('_')
+          .each_with_index
+          .map { |substring, index| index.zero? ? substring : substring.capitalize }
+          .join
       end
     end
   end