action_mosaico 0.1.0

data/lib/action_mosaico/content.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  class Content
+    include Serialization
+    include Rendering
+
+    attr_reader :fragment
+
+    delegate :blank?, :empty?, :html_safe, :present?, to: :to_html # Delegating to to_html to avoid including the layout
+
+    class << self
+      def fragment_by_canonicalizing_content(content)
+        fragment = ActionMosaico::Attachment.fragment_by_canonicalizing_attachments(content)
+        ActionMosaico::AttachmentGallery.fragment_by_canonicalizing_attachment_galleries(fragment)
+      end
+    end
+
+    def initialize(content = nil, options = {})
+      options.with_defaults! canonicalize: true
+
+      @fragment = if options[:canonicalize]
+                    self.class.fragment_by_canonicalizing_content(content)
+                  else
+                    ActionMosaico::Fragment.wrap(content)
+                  end
+    end
+
+    def links
+      @links ||= fragment.find_all('a[href]').map { |a| a['href'] }.uniq
+    end
+
+    def attachments
+      @attachments ||= attachment_nodes.map do |node|
+        attachment_for_node(node)
+      end
+    end
+
+    def attachment_galleries
+      @attachment_galleries ||= attachment_gallery_nodes.map do |node|
+        attachment_gallery_for_node(node)
+      end
+    end
+
+    def gallery_attachments
+      @gallery_attachments ||= attachment_galleries.flat_map(&:attachments)
+    end
+
+    def attachables
+      @attachables ||= attachment_nodes.map do |node|
+        ActionMosaico::Attachable.from_node(node)
+      end
+    end
+
+    def append_attachables(attachables)
+      attachments = ActionMosaico::Attachment.from_attachables(attachables)
+      self.class.new([to_s.presence, *attachments].compact.join("\n"))
+    end
+
+    def render_attachments(**options, &block)
+      content = fragment.replace(ActionMosaico::Attachment.tag_name) do |node|
+        block.call(attachment_for_node(node, **options))
+      end
+      self.class.new(content, canonicalize: false)
+    end
+
+    def render_attachment_galleries(&block)
+      content = ActionMosaico::AttachmentGallery.fragment_by_replacing_attachment_gallery_nodes(fragment) do |node|
+        block.call(attachment_gallery_for_node(node))
+      end
+      self.class.new(content, canonicalize: false)
+    end
+
+    def to_plain_text
+      render_attachments(with_full_attributes: false, &:to_plain_text).fragment.to_plain_text
+    end
+
+    def to_mosaico_html
+      render_attachments(&:to_mosaico_attachment).to_html
+    end
+
+    def to_html
+      fragment.to_html
+    end
+
+    def to_rendered_html_with_layout
+      render layout: 'action_mosaico/contents/content', partial: to_partial_path, formats: :html,
+             locals: { content: self }
+    end
+
+    def to_partial_path
+      'action_mosaico/contents/content'
+    end
+
+    def to_s
+      to_rendered_html_with_layout
+    end
+
+    def as_json(*)
+      to_html
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_s.truncate(25).inspect}>"
+    end
+
+    def ==(other)
+      to_s == other.to_s if other.is_a?(self.class)
+    end
+
+    private
+
+    def attachment_nodes
+      @attachment_nodes ||= fragment.find_all(ActionMosaico::Attachment.tag_name)
+    end
+
+    def attachment_gallery_nodes
+      @attachment_gallery_nodes ||= ActionMosaico::AttachmentGallery.find_attachment_gallery_nodes(fragment)
+    end
+
+    def attachment_for_node(node, with_full_attributes: true)
+      attachment = ActionMosaico::Attachment.from_node(node)
+      with_full_attributes ? attachment.with_full_attributes : attachment
+    end
+
+    def attachment_gallery_for_node(node)
+      ActionMosaico::AttachmentGallery.from_node(node)
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_mosaico_content, ActionMosaico::Content

data/lib/action_mosaico/encryption.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Encryption
+    def encrypt
+      transaction do
+        super
+        encrypt_rich_texts if has_encrypted_rich_texts?
+      end
+    end
+
+    def decrypt
+      transaction do
+        super
+        decrypt_rich_texts if has_encrypted_rich_texts?
+      end
+    end
+
+    private
+
+    def encrypt_rich_texts
+      encryptable_rich_texts.each(&:encrypt)
+    end
+
+    def decrypt_rich_texts
+      encryptable_rich_texts.each(&:decrypt)
+    end
+
+    def has_encrypted_rich_texts?
+      encryptable_rich_texts.present?
+    end
+
+    def encryptable_rich_texts
+      @encryptable_rich_texts ||= self.class.rich_text_association_names
+                                      .filter_map { |attribute_name| send(attribute_name) }
+                                      .find_all { |record| record.is_a?(ActionMosaico::EncryptedRichText) }
+    end
+  end
+end

data/lib/action_mosaico/engine.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'action_controller/railtie'
+require 'active_record/railtie'
+require 'active_storage/engine'
+
+require 'action_mosaico'
+
+module ActionMosaico
+  class Engine < Rails::Engine
+    isolate_namespace ActionMosaico
+    config.eager_load_namespaces << ActionMosaico
+
+    config.action_mosaico = ActiveSupport::OrderedOptions.new
+    config.action_mosaico.attachment_tag_name = 'action-text-attachment'
+    config.autoload_once_paths = %W[
+      #{root}/app/helpers
+      #{root}/app/models
+    ]
+
+    initializer 'action_mosaico.attribute' do
+      ActiveSupport.on_load(:active_record) do
+        include ActionMosaico::Attribute
+        prepend ActionMosaico::Encryption
+      end
+    end
+
+    initializer 'action_mosaico.asset' do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w[action_mosaico.js mosaico.js mosaico.css]
+      end
+    end
+
+    initializer 'action_mosaico.attachable' do
+      ActiveSupport.on_load(:active_storage_blob) do
+        include ActionMosaico::Attachable
+
+        def previewable_attachable?
+          representable?
+        end
+
+        def attachable_plain_text_representation(caption = nil)
+          "[#{caption || filename}]"
+        end
+
+        def to_mosaico_content_attachment_partial_path
+          nil
+        end
+      end
+    end
+
+    initializer 'action_mosaico.helper' do
+      %i[action_controller_base action_mailer].each do |abstract_controller|
+        ActiveSupport.on_load(abstract_controller) do
+          helper ActionMosaico::Engine.helpers
+        end
+      end
+    end
+
+    initializer 'action_mosaico.renderer' do
+      ActiveSupport.on_load(:action_mosaico_content) do
+        self.default_renderer = Class.new(ActionController::Base).renderer
+      end
+
+      %i[action_controller_base action_mailer].each do |abstract_controller|
+        ActiveSupport.on_load(abstract_controller) do
+          around_action do |controller, action|
+            ActionMosaico::Content.with_renderer(controller, &action)
+          end
+        end
+      end
+    end
+
+    initializer 'action_mosaico.system_test_helper' do
+      ActiveSupport.on_load(:action_dispatch_system_test_case) do
+        require 'action_mosaico/system_test_helper'
+        include ActionMosaico::SystemTestHelper
+      end
+    end
+
+    initializer 'action_mosaico.configure' do |app|
+      ActionMosaico::Attachment.tag_name = app.config.action_mosaico.attachment_tag_name
+    end
+  end
+end

data/lib/action_mosaico/fixture_set.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  # Fixtures are a way of organizing data that you want to test against; in
+  # short, sample data.
+  #
+  # To learn more about fixtures, read the
+  # {ActiveRecord::FixtureSet}[rdoc-ref:ActiveRecord::FixtureSet] documentation.
+  #
+  # === YAML
+  #
+  # Like other Active Record-backed models, ActionMosaico::RichText records inherit
+  # from ActiveRecord::Base instances and therefore can be populated by
+  # fixtures.
+  #
+  # Consider a hypothetical <tt>Article</tt> model class, its related fixture
+  # data, as well as fixture data for related ActionMosaico::RichText records:
+  #
+  #   # app/models/article.rb
+  #   class Article < ApplicationRecord
+  #     has_rich_text :content
+  #   end
+  #
+  #   # tests/fixtures/articles.yml
+  #   first:
+  #     title: An Article
+  #
+  #   # tests/fixtures/action_mosaico/rich_texts.yml
+  #   first_content:
+  #     record: first (Article)
+  #     name: content
+  #     body: <div>Hello, world.</div>
+  #
+  # When processed, Active Record will insert database records for each fixture
+  # entry and will ensure the Action Mosaico relationship is intact.
+  class FixtureSet
+    # Fixtures support Action Mosaico attachments as part of their <tt>body</tt>
+    # HTML.
+    #
+    # === Examples
+    #
+    # For example, consider a second <tt>Article</tt> record that mentions the
+    # first as part of its <tt>content</tt> HTML:
+    #
+    #   # tests/fixtures/articles.yml
+    #   second:
+    #     title: Another Article
+    #
+    #   # tests/fixtures/action_mosaico/rich_texts.yml
+    #   second_content:
+    #     record: second (Article)
+    #     name: content
+    #     body: <div>Hello, <%= ActionMosaico::FixtureSet.attachment("articles", :first) %></div>
+    def self.attachment(fixture_set_name, label, column_type: :integer)
+      signed_global_id = ActiveRecord::FixtureSet.signed_global_id fixture_set_name, label,
+                                                                   column_type: column_type, for: ActionMosaico::Attachable::LOCATOR_NAME
+
+      %(<action-text-attachment sgid="#{signed_global_id}"></action-text-attachment>)
+    end
+  end
+end

data/lib/action_mosaico/fragment.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  class Fragment
+    class << self
+      def wrap(fragment_or_html)
+        case fragment_or_html
+        when self
+          fragment_or_html
+        when Nokogiri::HTML::DocumentFragment
+          new(fragment_or_html)
+        else
+          from_html(fragment_or_html)
+        end
+      end
+
+      def from_html(html)
+        new(ActionMosaico::HtmlConversion.fragment_for_html(html.to_s.strip))
+      end
+    end
+
+    attr_reader :source
+
+    def initialize(source)
+      @source = source
+    end
+
+    def find_all(selector)
+      source.css(selector)
+    end
+
+    def update
+      yield source = self.source.clone
+      self.class.new(source)
+    end
+
+    def replace(selector)
+      update do |source|
+        source.css(selector).each do |node|
+          node.replace(yield(node).to_s)
+        end
+      end
+    end
+
+    def to_plain_text
+      @plain_text ||= PlainTextConversion.node_to_plain_text(source)
+    end
+
+    def to_html
+      @html ||= HtmlConversion.node_to_html(source)
+    end
+
+    def to_s
+      to_html
+    end
+  end
+end

data/lib/action_mosaico/html_conversion.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module HtmlConversion
+    extend self
+
+    def node_to_html(node)
+      node.to_html(save_with: Nokogiri::XML::Node::SaveOptions::AS_HTML)
+    end
+
+    def fragment_for_html(html)
+      document.fragment(html)
+    end
+
+    def create_element(tag_name, attributes = {})
+      document.create_element(tag_name, attributes)
+    end
+
+    private
+
+    def document
+      Nokogiri::HTML::Document.new.tap { |doc| doc.encoding = 'UTF-8' }
+    end
+  end
+end

data/lib/action_mosaico/mosaico_attachment.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  class TrixAttachment
+    TAG_NAME = 'figure'
+    SELECTOR = '[data-mosaico-attachment]'
+
+    COMPOSED_ATTRIBUTES = %w[caption presentation].freeze
+    ATTRIBUTES = %w[sgid contentType url href filename filesize width height previewable
+                    content] + COMPOSED_ATTRIBUTES
+    ATTRIBUTE_TYPES = {
+      'previewable' => ->(value) { value.to_s == 'true' },
+      'filesize' => ->(value) { Integer(value.to_s, exception: false) || value },
+      'width' => ->(value) { Integer(value.to_s, exception: false) },
+      'height' => ->(value) { Integer(value.to_s, exception: false) },
+      :default => ->(value) { value.to_s }
+    }.freeze
+
+    class << self
+      def from_attributes(attributes)
+        attributes = process_attributes(attributes)
+
+        mosaico_attachment_attributes = attributes.except(*COMPOSED_ATTRIBUTES)
+        mosaico_attributes = attributes.slice(*COMPOSED_ATTRIBUTES)
+
+        node = ActionMosaico::HtmlConversion.create_element(TAG_NAME)
+        node['data-mosaico-attachment'] = JSON.generate(mosaico_attachment_attributes)
+        node['data-mosaico-attributes'] = JSON.generate(mosaico_attributes) if mosaico_attributes.any?
+
+        new(node)
+      end
+
+      private
+
+      def process_attributes(attributes)
+        typecast_attribute_values(transform_attribute_keys(attributes))
+      end
+
+      def transform_attribute_keys(attributes)
+        attributes.transform_keys { |key| key.to_s.underscore.camelize(:lower) }
+      end
+
+      def typecast_attribute_values(attributes)
+        attributes.map do |key, value|
+          typecast = ATTRIBUTE_TYPES[key] || ATTRIBUTE_TYPES[:default]
+          [key, typecast.call(value)]
+        end.to_h
+      end
+    end
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def attributes
+      @attributes ||= attachment_attributes.merge(composed_attributes).slice(*ATTRIBUTES)
+    end
+
+    def to_html
+      ActionMosaico::HtmlConversion.node_to_html(node)
+    end
+
+    def to_s
+      to_html
+    end
+
+    private
+
+    def attachment_attributes
+      read_json_object_attribute('data-mosaico-attachment')
+    end
+
+    def composed_attributes
+      read_json_object_attribute('data-mosaico-attributes')
+    end
+
+    def read_json_object_attribute(name)
+      read_json_attribute(name) || {}
+    end
+
+    def read_json_attribute(name)
+      if value = node[name]
+        begin
+          JSON.parse(value)
+        rescue StandardError => e
+          Rails.logger.error "[#{self.class.name}] Couldn't parse JSON #{value} from NODE #{node.inspect}"
+          Rails.logger.error "[#{self.class.name}] Failed with #{e.class}: #{e.backtrace}"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/action_mosaico/plain_text_conversion.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module PlainTextConversion
+    extend self
+
+    def node_to_plain_text(node)
+      remove_trailing_newlines(plain_text_for_node(node))
+    end
+
+    private
+
+    def plain_text_for_node(node, index = 0)
+      if respond_to?(plain_text_method_for_node(node), true)
+        send(plain_text_method_for_node(node), node, index)
+      else
+        plain_text_for_node_children(node)
+      end
+    end
+
+    def plain_text_for_node_children(node)
+      texts = []
+      node.children.each_with_index do |child, index|
+        texts << plain_text_for_node(child, index)
+      end
+      texts.join
+    end
+
+    def plain_text_method_for_node(node)
+      :"plain_text_for_#{node.name}_node"
+    end
+
+    def plain_text_for_block(node, _index = 0)
+      "#{remove_trailing_newlines(plain_text_for_node_children(node))}\n\n"
+    end
+
+    %i[h1 p ul ol].each do |element|
+      alias_method :"plain_text_for_#{element}_node", :plain_text_for_block
+    end
+
+    def plain_text_for_br_node(_node, _index)
+      "\n"
+    end
+
+    def plain_text_for_text_node(node, _index)
+      remove_trailing_newlines(node.text)
+    end
+
+    def plain_text_for_div_node(node, _index)
+      "#{remove_trailing_newlines(plain_text_for_node_children(node))}\n"
+    end
+
+    def plain_text_for_figcaption_node(node, _index)
+      "[#{remove_trailing_newlines(plain_text_for_node_children(node))}]"
+    end
+
+    def plain_text_for_blockquote_node(node, _index)
+      text = plain_text_for_block(node)
+      text.sub(/\A(\s*)(.+?)(\s*)\Z/m, '\1“\2”\3')
+    end
+
+    def plain_text_for_li_node(node, index)
+      bullet = bullet_for_li_node(node, index)
+      text = remove_trailing_newlines(plain_text_for_node_children(node))
+      "#{bullet} #{text}\n"
+    end
+
+    def remove_trailing_newlines(text)
+      text.chomp('')
+    end
+
+    def bullet_for_li_node(node, index)
+      if list_node_name_for_li_node(node) == 'ol'
+        "#{index + 1}."
+      else
+        '•'
+      end
+    end
+
+    def list_node_name_for_li_node(node)
+      node.ancestors.lazy.map(&:name).grep(/^[uo]l$/).first
+    end
+  end
+end

data/lib/action_mosaico/rendering.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+
+module ActionMosaico
+  module Rendering # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :default_renderer, instance_accessor: false
+      thread_cattr_accessor :renderer, instance_accessor: false
+      delegate :render, to: :class
+    end
+
+    class_methods do
+      def with_renderer(renderer)
+        previous_renderer = self.renderer
+        self.renderer = renderer
+        yield
+      ensure
+        self.renderer = previous_renderer
+      end
+
+      def render(...)
+        (renderer || default_renderer).render_to_string(...)
+      end
+    end
+  end
+end

data/lib/action_mosaico/serialization.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Serialization
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def load(content)
+        new(content) if content
+      end
+
+      def dump(content)
+        case content
+        when nil
+          nil
+        when self
+          content.to_html
+        when ActionMosaico::RichText
+          content.body.to_html
+        else
+          new(content).to_html
+        end
+      end
+    end
+
+    # Marshal compatibility
+
+    class_methods do
+      alias_method :_load, :load
+    end
+
+    def _dump(*)
+      self.class.dump(self)
+    end
+  end
+end

data/lib/action_mosaico/system_test_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module SystemTestHelper
+    # Locates a Trix editor and fills it in with the given HTML.
+    #
+    # The editor can be found by:
+    # * its +id+
+    # * its +placeholder+
+    # * the text from its +label+ element
+    # * its +aria-label+
+    # * the +name+ of its input
+    #
+    # Examples:
+    #
+    #   # <mosaico-editor id="message_content" ...></mosaico-editor>
+    #   fill_in_rich_text_area "message_content", with: "Hello <em>world!</em>"
+    #
+    #   # <mosaico-editor placeholder="Your message here" ...></mosaico-editor>
+    #   fill_in_rich_text_area "Your message here", with: "Hello <em>world!</em>"
+    #
+    #   # <label for="message_content">Message content</label>
+    #   # <mosaico-editor id="message_content" ...></mosaico-editor>
+    #   fill_in_rich_text_area "Message content", with: "Hello <em>world!</em>"
+    #
+    #   # <mosaico-editor aria-label="Message content" ...></mosaico-editor>
+    #   fill_in_rich_text_area "Message content", with: "Hello <em>world!</em>"
+    #
+    #   # <input id="mosaico_input_1" name="message[content]" type="hidden">
+    #   # <mosaico-editor input="mosaico_input_1"></mosaico-editor>
+    #   fill_in_rich_text_area "message[content]", with: "Hello <em>world!</em>"
+    def fill_in_rich_text_area(locator = nil, with:)
+      find(:rich_text_area, locator).execute_script('this.editor.loadHTML(arguments[0])', with.to_s)
+    end
+  end
+end
+
+Capybara.add_selector :rich_text_area do
+  label 'rich-text area'
+  xpath do |locator|
+    if locator.nil?
+      XPath.descendant(:'mosaico-editor')
+    else
+      input_located_by_name = XPath.anywhere(:input).where(XPath.attr(:name) == locator).attr(:id)
+      input_located_by_label = XPath.anywhere(:label).where(XPath.string.n.is(locator)).attr(:for)
+
+      XPath.descendant(:'mosaico-editor').where \
+        XPath.attr(:id).equals(locator) |
+        XPath.attr(:placeholder).equals(locator) |
+        XPath.attr(:'aria-label').equals(locator) |
+        XPath.attr(:input).equals(input_located_by_name) |
+        XPath.attr(:id).equals(input_located_by_label)
+    end
+  end
+end