message_train 0.7.6 → 1.0.0

data/app/helpers/message_train/conversations_helper.rb

@@ -47,26 +47,26 @@ module MessageTrain
 
     private
 
-    # rubocop:disable Metrics/ParameterLists
     def conversation_toggle(conv, icon, mark, method, title, options = {})
-      render(
-        partial: 'message_train/conversations/toggle',
-        locals: {
-          conversation: conv,
-          icon: icon,
-          mark_to_set: mark,
-          options: conversation_toggle_options(mark, method, title, options)
-        }
-      )
+      kind = options.delete(:kind) || mark
+      collective = options.delete(:collective)
+      show_text = options.delete(:show_text)
+      locals = {
+        conversation: conv, icon: icon, title: title, show_text: show_text,
+        mark_to_set: mark, kind: kind, collective: collective,
+        options: conversation_toggle_options(mark, method, title, options, small: !show_text)
+      }
+      render(partial: 'message_train/conversations/toggle', locals: locals)
     end
-    # rubocop:enable Metrics/ParameterLists
 
-    def conversation_toggle_options(mark, method, title, options = {})
-      options[:remote] = true
-      options[:method] = method
+    def conversation_toggle_options(mark, method, title, options = {}, small: true)
       options[:title] = title
-      options[:class] ||= ''
-      options[:class] += " #{mark}-toggle"
+      options[:class] = [
+        'message-train-button',
+        (small ? 'message-train-button--small' : nil),
+        "#{mark}-toggle"
+      ].compact.join(' ')
+      options[:method] = method
       options
     end
 

data/app/helpers/message_train/messages_helper.rb

@@ -1,6 +1,16 @@
 module MessageTrain
   # Messages helper
   module MessagesHelper
+    MARKDOWN_RENDERER = Redcarpet::Markdown.new(
+      Redcarpet::Render::HTML.new(safe_links_only: true),
+      autolink: true, tables: true, fenced_code_blocks: true,
+      no_intra_emphasis: true, strikethrough: true
+    ).freeze
+
+    def message_body(message)
+      sanitize(MARKDOWN_RENDERER.render(message.body.to_s))
+    end
+
     def message_class(box, message)
       css_classes = []
       css_classes << message_css_for_read_state(message)
@@ -9,24 +19,24 @@ module MessageTrain
       css_classes.join(' ')
     end
 
-    def message_trashed_toggle(message)
+    def message_trashed_toggle(message, collective = nil)
       render(
         partial: 'message_train/messages/trashed_toggle',
-        locals: { message: message }
+        locals: { message: message, collective: collective }
       )
     end
 
-    def message_read_toggle(message)
+    def message_read_toggle(message, collective = nil)
       render(
         partial: 'message_train/messages/read_toggle',
-        locals: { message: message }
+        locals: { message: message, collective: collective }
       )
     end
 
-    def message_deleted_toggle(message)
+    def message_deleted_toggle(message, collective = nil)
       render(
         partial: 'message_train/messages/deleted_toggle',
-        locals: { message: message }
+        locals: { message: message, collective: collective }
       )
     end
 
@@ -36,24 +46,27 @@ module MessageTrain
 
     private
 
-    def message_toggle(message, icon, mark_to_set, title, options = {})
+    def message_toggle(message, icon, mark_to_set, title, collective, options = {})
+      kind = options.delete(:kind) || mark_to_set
       render(
         partial: 'message_train/messages/toggle',
         locals: {
           message: message,
           icon: icon,
+          title: title,
           mark_to_set: mark_to_set,
+          kind: kind,
+          collective: collective,
           options: message_toggle_options(message, mark_to_set, title, options)
         }
       )
     end
 
     def message_toggle_options(message, mark_to_set, title, options = {})
-      options[:remote] = true
       options[:id] = "mark_#{mark_to_set}_#{message.id}"
-      options[:class] = 'mark-link'
-      options[:method] = :put
+      options[:class] = 'message-train-button message-train-button--small'
       options[:title] = title
+      options[:method] = :put
       options
     end
 

data/app/javascript/controllers/message_train/bulk_actions_controller.js

@@ -0,0 +1,36 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Replaces message_train.js's jQuery-driven checkbox/mark-all wiring for
+// the box listing's bulk actions (select rows, then mark them all at once).
+export default class extends Controller {
+  static targets = ["checkbox", "checkAll", "markToSet"]
+
+  toggleAll(event) {
+    this.checkboxTargets.forEach((box) => { box.checked = event.target.checked })
+  }
+
+  selectMatching(event) {
+    event.preventDefault()
+    event.stopPropagation()
+    const selector = event.currentTarget.dataset.selector
+    this.checkboxTargets.forEach((box) => {
+      box.checked = selector ? box.closest(".message_train_conversation")?.matches(selector) : false
+    })
+    if (this.hasCheckAllTarget) {
+      this.checkAllTarget.checked = selector === ".message_train_conversation"
+    }
+  }
+
+  markAll(event) {
+    event.preventDefault()
+    event.stopPropagation()
+    const mark = event.currentTarget.dataset.mark
+    const form = document.getElementById("box")
+    const methodField = form.querySelector('input[name="_method"]')
+    if (methodField) {
+      methodField.value = ["ignore", "unignore"].includes(mark) ? "delete" : "put"
+    }
+    this.markToSetTarget.value = mark
+    form.requestSubmit()
+  }
+}

data/app/javascript/controllers/message_train/lightbox_controller.js

@@ -0,0 +1,25 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Opens a <dialog> and points its image at the src/original carried on the
+// clicked link's data attributes, replacing the old Bootstrap modal.
+export default class extends Controller {
+  static targets = ["image"]
+
+  open(event) {
+    event.preventDefault()
+    const dialog = document.getElementById(event.currentTarget.dataset.lightboxDialogId)
+    if (!dialog) return
+
+    const image = dialog.querySelector("[data-lightbox-target~='image']") || dialog.querySelector("img")
+    if (image) {
+      image.src = event.currentTarget.dataset.lightboxSrc
+      image.alt = event.currentTarget.dataset.lightboxAlt || ""
+    }
+
+    dialog.showModal()
+  }
+
+  close(event) {
+    event.target.closest("dialog")?.close()
+  }
+}

data/app/javascript/controllers/message_train/nested_form_controller.js

@@ -0,0 +1,36 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Replaces cocoon's add/remove-nested-fields helpers. Expects a <template>
+// target holding one blank fields_for row (child_index: "NEW_RECORD"), and
+// wraps each row (new or persisted) in an element carrying the
+// "destroyField" target so removal can either drop the DOM node (new,
+// unsaved rows) or flag it for destruction on submit (persisted rows).
+export default class extends Controller {
+  static targets = ["template", "rows"]
+
+  add(event) {
+    event.preventDefault()
+    const content = this.templateTarget.innerHTML.replace(
+      /NEW_RECORD/g,
+      new Date().getTime()
+    )
+    this.rowsTarget.insertAdjacentHTML("beforeend", content)
+  }
+
+  remove(event) {
+    event.preventDefault()
+    const message = event.currentTarget.dataset.confirm
+    if (message && !window.confirm(message)) return
+
+    const row = event.currentTarget.closest("[data-message-train--nested-form-target='row']")
+    if (!row) return
+
+    const destroyField = row.querySelector("[data-message-train--nested-form-target='destroyField']")
+    if (destroyField) {
+      destroyField.value = "1"
+      row.hidden = true
+    } else {
+      row.remove()
+    }
+  }
+}

data/app/javascript/controllers/message_train/recipient_autocomplete_controller.js

@@ -0,0 +1,31 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Replaces the old Bloodhound/typeahead.js recipient picker with a plain
+// <input> + <datalist>, backed by the same participants JSON endpoint.
+export default class extends Controller {
+  static targets = ["input", "list"]
+  static values = { url: String }
+
+  connect() {
+    this.timeout = null
+  }
+
+  search() {
+    clearTimeout(this.timeout)
+    const query = this.inputTarget.value.trim()
+    if (query.length < 1) return
+
+    this.timeout = setTimeout(() => this.fetchSuggestions(query), 150)
+  }
+
+  async fetchSuggestions(query) {
+    const url = `${this.urlValue}?query=${encodeURIComponent(query)}`
+    const response = await fetch(url, { headers: { Accept: "application/json" } })
+    if (!response.ok) return
+
+    const data = await response.json()
+    this.listTarget.innerHTML = (data.participants || [])
+      .map((participant) => `<option value="${participant.slug}"></option>`)
+      .join("")
+  }
+}

data/app/mailers/message_train/previews/receipt_mailer_preview.rb

@@ -1,9 +1,11 @@
 module MessageTrain
-  # Receipt mailer preview
-  class ReceiptMailerPreview < ActionMailer::Preview
-    def notification_email
-      receipt = MessageTrain::Receipt.last
-      ReceiptMailer.notification_email(receipt)
+  module Previews
+    # Receipt mailer preview
+    class ReceiptMailerPreview < ActionMailer::Preview
+      def notification_email
+        receipt = MessageTrain::Receipt.last
+        MessageTrain::ReceiptMailer.notification_email(receipt)
+      end
     end
   end
 end

data/app/models/message_train/attachment.rb

@@ -1,51 +1,63 @@
 module MessageTrain
   # Attachment model
   class Attachment < ActiveRecord::Base
-    belongs_to :message, foreign_key: :message_train_message_id, touch: true
-    has_attached_file(
-      :attachment,
-      styles: lambda do |attachment|
-        if attachment.instance.image?
-          {
-            thumb: '235x',
-            large: '800x'
-          }
-        else
-          {}
-        end
-      end,
-      path: ':rails_root/public/system/:rails_env/:class/:attachment/'\
-        ':id_partition/:style_prefix:filename',
-      url: '/system/:rails_env/:class/:attachment/'\
-        ':id_partition/:style_prefix:filename',
-      convert_options: {
-        large: '-quality 75 -interlace Plane -strip',
-        thumb: '-quality 75 -strip'
-      }
-    )
-    validates_attachment_presence :attachment
-    validates_attachment_content_type(
-      :attachment,
-      content_type: [
-        'application/pdf',
-        'application/vnd.ms-excel',
-        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        'application/msword',
-        'application/'\
-          'vnd.openxmlformats-officedocument.wordprocessingml.document',
-        'application/rtf',
-        'text/plain',
-        %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}
-      ]
-    )
+    ALLOWED_CONTENT_TYPES = [
+      'application/pdf',
+      'application/vnd.ms-excel',
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'application/msword',
+      'application/'\
+        'vnd.openxmlformats-officedocument.wordprocessingml.document',
+      'application/rtf',
+      'text/plain',
+      %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}
+    ].freeze
+
+    belongs_to :message,
+               foreign_key: :message_train_message_id,
+               touch: true,
+               inverse_of: :attachments
+    has_one_attached :attachment
+
+    validate :attachment_must_be_present
+    validate :attachment_content_type_must_be_allowed
+
     def image?
-      # rubocop:disable Metrics/LineLength
-      !(attachment_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}).nil?
-      # rubocop:enable Metrics/LineLength
+      attached_content_type = attachment.content_type
+      !(attached_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}).nil?
     end
 
-    Paperclip.interpolates :style_prefix do |attachment, style|
-      attachment.instance.image? ? "#{style}/" : ''
+    def thumb
+      attachment.variant(
+        resize_to_limit: [235, 235],
+        quality: 75,
+        strip: true
+      )
+    end
+
+    def large
+      attachment.variant(
+        resize_to_limit: [800, 800],
+        quality: 75,
+        strip: true,
+        interlace: 'Plane'
+      )
+    end
+
+    private
+
+    def attachment_must_be_present
+      errors.add(:attachment, :blank) unless attachment.attached?
+    end
+
+    def attachment_content_type_must_be_allowed
+      return unless attachment.attached?
+
+      content_type = attachment.content_type
+      allowed = ALLOWED_CONTENT_TYPES.any? do |allowed_type|
+        allowed_type.is_a?(Regexp) ? allowed_type.match?(content_type) : allowed_type == content_type
+      end
+      errors.add(:attachment, :content_type_invalid) unless allowed
     end
   end
 end

data/app/models/message_train/box.rb

@@ -5,7 +5,7 @@ module MessageTrain
       'Hash' => :mark_hash,
       'Array' => :mark_array,
       'String' => :mark_id,
-      'Fixnum' => :mark_id,
+      'Integer' => :mark_id,
       'MessageTrain::Conversation' => :mark_communication
     }.freeze
 
@@ -31,7 +31,7 @@ module MessageTrain
     end
 
     def unread_count
-      conversations(read: false).count
+      @unread_count ||= conversations(read: false).count
     end
 
     def conversations(options = {})

data/app/models/message_train/conversation.rb

@@ -89,7 +89,7 @@ module MessageTrain
     def new_reply(args)
       args[:reply_recipients] = default_recipients_for(args.delete(:box).parent)
       args[:subject] = "Re: #{subject}"
-      args[:body] = "<blockquote>#{messages.last.body}</blockquote><p></p>"
+      args[:body] = quote_as_markdown(messages.last.body)
       messages.build(args)
     end
 
@@ -102,7 +102,13 @@ module MessageTrain
     end
 
     def participant_ignored?(participant)
-      ignores.empty? ? false : ignores.find_all_by_participant(participant).any?
+      # Filters the (often already-preloaded) in-memory ignores rather
+      # than issuing a fresh scoped query every call - this gets called
+      # several times per conversation row in a box listing.
+      ignores.any? do |ignore|
+        ignore.participant_type == participant.class.name &&
+          ignore.participant_id == participant.id
+      end
     end
 
     def mark(mark, participant)
@@ -125,6 +131,21 @@ module MessageTrain
       includes_matching_messages_with_prep?(flag, prep, *args)
     end
 
+    # PERF: this is the box listing's remaining N+1. `conversation_class`
+    # in ConversationsHelper calls the various includes_*_for? methods
+    # (read/trashed/untrashed/deleted/undeleted/drafts_by) several times
+    # per conversation row via this method, and each call is a fresh
+    # `receipts.send(...)` scoped query - none of it benefits from
+    # preloading `messages: :receipts`, because a *scope* call on an
+    # association always re-queries rather than filtering the already-
+    # loaded records. Fixing this for real means replicating the
+    # flag/preposition scope-combination DSL (see Receipt's own
+    # method_missing) as in-memory filtering over preloaded receipts,
+    # for every flag/preposition combination actually used in the box
+    # listing - judged too easy to get subtly wrong for the time
+    # available during the Phase 9 performance pass (see the modernization
+    # plan). `participant_ignored?` got the equivalent fix already; this
+    # one is next if this becomes a real bottleneck.
     def includes_matching_receipts?(match_method_sym, *args)
       receipts.send(match_method_sym, *args).any?
     end
@@ -153,5 +174,10 @@ module MessageTrain
     def includes_matching_messages_with_prep?(flag, preposition, *args)
       messages.send(flag).receipts.flagged(preposition, *args).any?
     end
+
+    def quote_as_markdown(body)
+      quoted = body.to_s.each_line.map { |line| "> #{line.chomp}" }.join("\n")
+      "#{quoted}\n\n"
+    end
   end
 end

data/app/models/message_train/ignore.rb

@@ -5,7 +5,7 @@ module MessageTrain
       'Hash' => :ignore_hash,
       'Array' => :ignore_array,
       'String' => :ignore_id,
-      'Fixnum' => :ignore_id,
+      'Integer' => :ignore_id,
       'MessageTrain::Conversation' => :ignore_conversation
     }.freeze
 
@@ -13,7 +13,7 @@ module MessageTrain
       'Hash' => :unignore_hash,
       'Array' => :unignore_array,
       'String' => :unignore_id,
-      'Fixnum' => :unignore_id,
+      'Integer' => :unignore_id,
       'MessageTrain::Conversation' => :unignore_conversation
     }.freeze
 

data/app/models/message_train/message.rb

@@ -2,7 +2,7 @@ module MessageTrain
   # Message model
   class Message < ActiveRecord::Base
     # Serializations
-    serialize :recipients_to_save, Hash
+    serialize :recipients_to_save, coder: JSON, type: Hash
 
     attr_accessor :box
 
@@ -14,7 +14,9 @@ module MessageTrain
       touch: true
     )
     belongs_to :sender, polymorphic: true
-    has_many :attachments, foreign_key: :message_train_message_id
+    has_many :attachments,
+             foreign_key: :message_train_message_id,
+             inverse_of: :message
     has_many :receipts, foreign_key: :message_train_message_id
     delegate :participant_ignored?, to: :conversation
     delegate :send_receipts, to: :receipts
@@ -23,7 +25,7 @@ module MessageTrain
     validates_presence_of :sender, :subject
 
     # Callbacks
-    before_create :create_conversation_if_blank
+    before_validation :create_conversation_if_blank
     after_create :generate_sender_receipt
     after_save :generate_receipts_or_set_draft
     after_save :set_conversation_subject_if_alone
@@ -60,7 +62,11 @@ module MessageTrain
     end
 
     def self.mark(mark_to_set, participant)
-      find_each { |message| message.mark(mark_to_set, participant) }
+      # Called both directly on the class and via a scoped relation (e.g.
+      # `conversation.messages.mark(...)`); Rails delegates the latter by
+      # calling this method on the bare class within a `scoping` block, so
+      # `all` (not `self`) is what resolves to the actually-scoped relation.
+      MessageTrain::Receipt.for_messages(all).for(participant).mark(mark_to_set)
     end
 
     def recipients

data/app/models/message_train/receipt.rb

@@ -2,7 +2,7 @@ module MessageTrain
   # Receipt model
   class Receipt < ActiveRecord::Base
     belongs_to :recipient, polymorphic: true
-    belongs_to :received_through, polymorphic: true
+    belongs_to :received_through, polymorphic: true, optional: true
     belongs_to :message, foreign_key: :message_train_message_id, touch: true
     delegate :conversation, to: :message
     validates_presence_of :recipient, :message
@@ -65,6 +65,11 @@ module MessageTrain
     end
 
     def mark(mark_to_set)
+      setting, column = self.class.setting_and_column_for(mark_to_set)
+      update_attribute(column, setting)
+    end
+
+    def self.setting_and_column_for(mark_to_set)
       if mark_to_set.to_s =~ /^un/
         setting = false
         suffix = mark_to_set.to_s.gsub(/^un/, '')
@@ -72,12 +77,30 @@ module MessageTrain
         setting = true
         suffix = mark_to_set.to_s
       end
-      column = "marked_#{suffix}".to_sym
-      update_attribute(column, setting)
+      [setting, "marked_#{suffix}".to_sym]
     end
 
+    # Bulk-updates every receipt in the current scope in a single query
+    # instead of loading and saving each one. update_attribute's touch:
+    # true cascade (Receipt -> Message -> Conversation) is skipped by
+    # update_all, so it's replicated explicitly below - the inbox listing
+    # orders by, and fragment-caches on, Conversation#updated_at.
     def self.mark(mark_to_set)
-      where(nil).each { |receipt| receipt.mark(mark_to_set) }
+      setting, column = setting_and_column_for(mark_to_set)
+      message_ids = distinct.pluck(:message_train_message_id)
+      update_all(column => setting)
+      touch_affected_parents(message_ids)
+    end
+
+    def self.touch_affected_parents(message_ids)
+      return if message_ids.empty?
+      now = Time.current
+      MessageTrain::Message.where(id: message_ids).update_all(updated_at: now)
+      conversation_ids = MessageTrain::Message.where(id: message_ids)
+                                              .distinct
+                                              .pluck(:message_train_conversation_id)
+      MessageTrain::Conversation.where(id: conversation_ids)
+                                .update_all(updated_at: now)
     end
 
     def self.method_missing(method_sym, *args, &block)

data/app/models/message_train/unsubscribe.rb

@@ -2,7 +2,7 @@ module MessageTrain
   # Unsubscribe model
   class Unsubscribe < ActiveRecord::Base
     belongs_to :recipient, polymorphic: true
-    belongs_to :from, polymorphic: true
+    belongs_to :from, polymorphic: true, optional: true
     validates_presence_of :recipient
   end
 end

data/app/views/application/404.html.haml

@@ -1,3 +1 @@
-- add_hero_unit do
-  %h1
-    404 - Page Not Found
+%h1 404 - Page Not Found

data/app/views/kaminari/_first_page.html.haml

@@ -1,2 +1,2 @@
 %li
-  = link_to_unless current_page.first?, raw(t 'views.pagination.first'), url, :remote => remote
+  = link_to_unless current_page.first?, raw(t 'views.pagination.first'), url

data/app/views/kaminari/_last_page.html.haml

@@ -1,2 +1,2 @@
 %li
-  = link_to_unless current_page.last?, raw(t 'views.pagination.last'), url, {:remote => remote}
+  = link_to_unless current_page.last?, raw(t 'views.pagination.last'), url

data/app/views/kaminari/_next_page.html.haml

@@ -1,2 +1,2 @@
 %li
-  = link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, :rel => 'next', :remote => remote
+  = link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, rel: 'next'

data/app/views/kaminari/_page.html.haml

@@ -1,6 +1,6 @@
 - if page.current?
-  %li.active
-    = content_tag :a, page, remote: remote, rel: (page.next? ? 'next' : (page.prev? ? 'prev' : nil))
+  %li.active{ 'aria-current': 'page' }
+    = content_tag :a, page, rel: (page.next? ? 'next' : (page.prev? ? 'prev' : nil))
 - else
   %li
-    = link_to page, url, remote: remote, rel: (page.next? ? 'next' : (page.prev? ? 'prev' : nil))
+    = link_to page, url, rel: (page.next? ? 'next' : (page.prev? ? 'prev' : nil))

data/app/views/kaminari/_paginator.html.haml

@@ -1,11 +1,12 @@
-= paginator.render do
-  %ul.pagination
-    = first_page_tag unless current_page.first?
-    = prev_page_tag unless current_page.first?
-    - each_page do |page|
-      - if page.left_outer? || page.right_outer? || page.inside_window?
-        = page_tag page
-      - elsif !page.was_truncated?
-        = gap_tag
-    = next_page_tag unless current_page.last?
-    = last_page_tag unless current_page.last?
+%nav{ 'aria-label': 'Pagination' }
+  = paginator.render do
+    %ul.pagination
+      = first_page_tag unless current_page.first?
+      = prev_page_tag unless current_page.first?
+      - each_page do |page|
+        - if page.left_outer? || page.right_outer? || page.inside_window?
+          = page_tag page
+        - elsif !page.was_truncated?
+          = gap_tag
+      = next_page_tag unless current_page.last?
+      = last_page_tag unless current_page.last?

data/app/views/kaminari/_prev_page.html.haml

@@ -1,2 +1,2 @@
 %li
-  = link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, :rel => 'prev', :remote => remote
+  = link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, rel: 'prev'