action_mosaico 0.1.0

data/app/views/active_storage/blobs/_blob.html.erb

@@ -0,0 +1,14 @@
+<figure class="attachment attachment--<%= blob.representable? ? "preview" : "file" %> attachment--<%= blob.filename.extension %>">
+  <% if blob.representable? %>
+    <%= image_tag blob.representation(resize_to_limit: local_assigns[:in_gallery] ? [ 800, 600 ] : [ 1024, 768 ]) %>
+  <% end %>
+
+  <figcaption class="attachment__caption">
+    <% if caption = blob.try(:caption) %>
+      <%= caption %>
+    <% else %>
+      <span class="attachment__name"><%= blob.filename %></span>
+      <span class="attachment__size"><%= number_to_human_size blob.byte_size %></span>
+    <% end %>
+  </figcaption>
+</figure>

data/app/views/layouts/action_text/contents/_content.html.erb

@@ -0,0 +1,3 @@
+<div class="mosaico-content">
+  <%= yield -%>
+</div>

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'action_mosaico'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrate/20180528164100_create_action_mosaico_tables.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class CreateActionMosaicoTables < ActiveRecord::Migration[7.0]
+  def change
+    # Use Active Record's configured type for primary and foreign keys
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+    create_table :action_mosaico_rich_texts, id: primary_key_type do |t|
+      t.string     :name, null: false
+      t.text       :body, size: :long
+      t.references :record, null: false, polymorphic: true, index: false, type: foreign_key_type
+
+      t.timestamps
+
+      t.index %i[record_type record_id name], name: 'index_action_mosaico_rich_texts_uniqueness', unique: true
+    end
+  end
+
+  private
+
+  def primary_and_foreign_key_types
+    config = Rails.configuration.generators
+    setting = config.options[config.orm][:primary_key_type]
+    primary_key_type = setting || :primary_key
+    foreign_key_type = setting || :bigint
+    [primary_key_type, foreign_key_type]
+  end
+end

data/lib/action_mosaico/attachable.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachable
+    extend ActiveSupport::Concern
+
+    LOCATOR_NAME = 'attachable'
+
+    class << self
+      def from_node(node)
+        if attachable = attachable_from_sgid(node['sgid'])
+          attachable
+        elsif attachable = ActionMosaico::Attachables::ContentAttachment.from_node(node)
+          attachable
+        elsif attachable = ActionMosaico::Attachables::RemoteImage.from_node(node)
+          attachable
+        else
+          ActionMosaico::Attachables::MissingAttachable
+        end
+      end
+
+      def from_attachable_sgid(sgid, options = {})
+        method = sgid.is_a?(Array) ? :locate_many_signed : :locate_signed
+        record = GlobalID::Locator.public_send(method, sgid, options.merge(for: LOCATOR_NAME))
+        record || raise(ActiveRecord::RecordNotFound)
+      end
+
+      private
+
+      def attachable_from_sgid(sgid)
+        from_attachable_sgid(sgid)
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end
+    end
+
+    class_methods do
+      def from_attachable_sgid(sgid)
+        ActionMosaico::Attachable.from_attachable_sgid(sgid, only: self)
+      end
+    end
+
+    def attachable_sgid
+      to_sgid(expires_in: nil, for: LOCATOR_NAME).to_s
+    end
+
+    def attachable_content_type
+      try(:content_type) || 'application/octet-stream'
+    end
+
+    def attachable_filename
+      filename.to_s if respond_to?(:filename)
+    end
+
+    def attachable_filesize
+      try(:byte_size) || try(:filesize)
+    end
+
+    def attachable_metadata
+      try(:metadata) || {}
+    end
+
+    def previewable_attachable?
+      false
+    end
+
+    def as_json(*)
+      super.merge(attachable_sgid: attachable_sgid)
+    end
+
+    def to_mosaico_content_attachment_partial_path
+      to_partial_path
+    end
+
+    def to_attachable_partial_path
+      to_partial_path
+    end
+
+    def to_rich_text_attributes(attributes = {})
+      attributes.dup.tap do |attrs|
+        attrs[:sgid] = attachable_sgid
+        attrs[:content_type] = attachable_content_type
+        attrs[:previewable] = true if previewable_attachable?
+        attrs[:filename] = attachable_filename
+        attrs[:filesize] = attachable_filesize
+        attrs[:width] = attachable_metadata[:width]
+        attrs[:height] = attachable_metadata[:height]
+      end.compact
+    end
+  end
+end

data/lib/action_mosaico/attachables/content_attachment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachables
+    class ContentAttachment
+      include ActiveModel::Model
+
+      def self.from_node(node)
+        if node['content-type'] && matches = node['content-type'].match(/vnd\.rubyonrails\.(.+)\.html/)
+          attachment = new(name: matches[1])
+          attachment if attachment.valid?
+        end
+      end
+
+      attr_accessor :name
+
+      validates_inclusion_of :name, in: %w[horizontal-rule]
+
+      def attachable_plain_text_representation(_caption)
+        case name
+        when 'horizontal-rule'
+          ' ┄ '
+        else
+          ' '
+        end
+      end
+
+      def to_partial_path
+        'action_mosaico/attachables/content_attachment'
+      end
+
+      def to_mosaico_content_attachment_partial_path
+        "action_mosaico/attachables/content_attachments/#{name.underscore}"
+      end
+    end
+  end
+end

data/lib/action_mosaico/attachables/missing_attachable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachables
+    module MissingAttachable
+      extend ActiveModel::Naming
+
+      def self.to_partial_path
+        'action_mosaico/attachables/missing_attachable'
+      end
+    end
+  end
+end

data/lib/action_mosaico/attachables/remote_image.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachables
+    class RemoteImage
+      extend ActiveModel::Naming
+
+      class << self
+        def from_node(node)
+          new(attributes_from_node(node)) if node['url'] && content_type_is_image?(node['content-type'])
+        end
+
+        private
+
+        def content_type_is_image?(content_type)
+          content_type.to_s.match?(%r{^image(/.+|$)})
+        end
+
+        def attributes_from_node(node)
+          { url: node['url'],
+            content_type: node['content-type'],
+            width: node['width'],
+            height: node['height'] }
+        end
+      end
+
+      attr_reader :url, :content_type, :width, :height
+
+      def initialize(attributes = {})
+        @url = attributes[:url]
+        @content_type = attributes[:content_type]
+        @width = attributes[:width]
+        @height = attributes[:height]
+      end
+
+      def attachable_plain_text_representation(caption)
+        "[#{caption || 'Image'}]"
+      end
+
+      def to_partial_path
+        'action_mosaico/attachables/remote_image'
+      end
+    end
+  end
+end

data/lib/action_mosaico/attachment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/try'
+
+module ActionMosaico
+  class Attachment
+    include Attachments::Caching
+    include Attachments::Minification
+    include Attachments::TrixConversion
+
+    mattr_accessor :tag_name, default: 'action-text-attachment'
+
+    ATTRIBUTES = %w[sgid content-type url href filename filesize width height previewable presentation caption].freeze
+
+    class << self
+      def fragment_by_canonicalizing_attachments(content)
+        fragment_by_minifying_attachments(fragment_by_converting_mosaico_attachments(content))
+      end
+
+      def from_node(node, attachable = nil)
+        new(node, attachable || ActionMosaico::Attachable.from_node(node))
+      end
+
+      def from_attachables(attachables)
+        Array(attachables).filter_map { |attachable| from_attachable(attachable) }
+      end
+
+      def from_attachable(attachable, attributes = {})
+        if node = node_from_attributes(attachable.to_rich_text_attributes(attributes))
+          new(node, attachable)
+        end
+      end
+
+      def from_attributes(attributes, attachable = nil)
+        if node = node_from_attributes(attributes)
+          from_node(node, attachable)
+        end
+      end
+
+      private
+
+      def node_from_attributes(attributes)
+        if attributes = process_attributes(attributes).presence
+          ActionMosaico::HtmlConversion.create_element(tag_name, attributes)
+        end
+      end
+
+      def process_attributes(attributes)
+        attributes.transform_keys { |key| key.to_s.underscore.dasherize }.slice(*ATTRIBUTES)
+      end
+    end
+
+    attr_reader :node, :attachable
+
+    delegate :to_param, to: :attachable
+    delegate_missing_to :attachable
+
+    def initialize(node, attachable)
+      @node = node
+      @attachable = attachable
+    end
+
+    def caption
+      node_attributes['caption'].presence
+    end
+
+    def full_attributes
+      node_attributes.merge(attachable_attributes).merge(sgid_attributes)
+    end
+
+    def with_full_attributes
+      self.class.from_attributes(full_attributes, attachable)
+    end
+
+    def to_plain_text
+      if respond_to?(:attachable_plain_text_representation)
+        attachable_plain_text_representation(caption)
+      else
+        caption.to_s
+      end
+    end
+
+    def to_html
+      HtmlConversion.node_to_html(node)
+    end
+
+    def to_s
+      to_html
+    end
+
+    def inspect
+      "#<#{self.class.name} attachable=#{attachable.inspect}>"
+    end
+
+    private
+
+    def node_attributes
+      @node_attributes ||= ATTRIBUTES.map { |name| [name.underscore, node[name]] }.to_h.compact
+    end
+
+    def attachable_attributes
+      @attachable_attributes ||= (attachable.try(:to_rich_text_attributes) || {}).stringify_keys
+    end
+
+    def sgid_attributes
+      @sgid_attributes ||= node_attributes.slice('sgid').presence || attachable_attributes.slice('sgid')
+    end
+  end
+end

data/lib/action_mosaico/attachment_gallery.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  class AttachmentGallery
+    include ActiveModel::Model
+
+    TAG_NAME = 'div'
+    private_constant :TAG_NAME
+
+    class << self
+      def fragment_by_canonicalizing_attachment_galleries(content)
+        fragment_by_replacing_attachment_gallery_nodes(content) do |node|
+          "<#{TAG_NAME}>#{node.inner_html}</#{TAG_NAME}>"
+        end
+      end
+
+      def fragment_by_replacing_attachment_gallery_nodes(content)
+        Fragment.wrap(content).update do |source|
+          find_attachment_gallery_nodes(source).each do |node|
+            node.replace(yield(node).to_s)
+          end
+        end
+      end
+
+      def find_attachment_gallery_nodes(content)
+        Fragment.wrap(content).find_all(selector).select do |node|
+          node.children.all? do |child|
+            if child.text?
+              /\A(\n|\ )*\z/.match?(child.text)
+            else
+              child.matches? attachment_selector
+            end
+          end
+        end
+      end
+
+      def from_node(node)
+        new(node)
+      end
+
+      def attachment_selector
+        "#{ActionMosaico::Attachment.tag_name}[presentation=gallery]"
+      end
+
+      def selector
+        "#{TAG_NAME}:has(#{attachment_selector} + #{attachment_selector})"
+      end
+    end
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def attachments
+      @attachments ||= node.css(ActionMosaico::AttachmentGallery.attachment_selector).map do |node|
+        ActionMosaico::Attachment.from_node(node).with_full_attributes
+      end
+    end
+
+    def size
+      attachments.size
+    end
+
+    def inspect
+      "#<#{self.class.name} size=#{size.inspect}>"
+    end
+  end
+end

data/lib/action_mosaico/attachments/caching.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachments
+    module Caching
+      def cache_key(*args)
+        [self.class.name, cache_digest, *attachable.cache_key(*args)].join('/')
+      end
+
+      private
+
+      def cache_digest
+        OpenSSL::Digest::SHA256.hexdigest(node.to_s)
+      end
+    end
+  end
+end

data/lib/action_mosaico/attachments/minification.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attachments
+    module Minification
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_minifying_attachments(content)
+          Fragment.wrap(content).replace(ActionMosaico::Attachment.tag_name) do |node|
+            node.tap { |n| n.inner_html = '' }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_mosaico/attachments/mosaico_conversion.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/try'
+
+module ActionMosaico
+  module Attachments
+    module TrixConversion
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_converting_mosaico_attachments(content)
+          Fragment.wrap(content).replace(TrixAttachment::SELECTOR) do |node|
+            from_mosaico_attachment(TrixAttachment.new(node))
+          end
+        end
+
+        def from_mosaico_attachment(mosaico_attachment)
+          from_attributes(mosaico_attachment.attributes)
+        end
+      end
+
+      def to_mosaico_attachment(content = mosaico_attachment_content)
+        attributes = full_attributes.dup
+        attributes['content'] = content if content
+        TrixAttachment.from_attributes(attributes)
+      end
+
+      private
+
+      def mosaico_attachment_content
+        if partial_path = attachable.try(:to_mosaico_content_attachment_partial_path)
+          ActionMosaico::Content.render(partial: partial_path, formats: :html, object: self, as: model_name.element)
+        end
+      end
+    end
+  end
+end

data/lib/action_mosaico/attribute.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActionMosaico
+  module Attribute
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Provides access to a dependent RichText model that holds the body and attachments for a single named rich text attribute.
+      # This dependent attribute is lazily instantiated and will be auto-saved when it's been changed. Example:
+      #
+      #   class Message < ActiveRecord::Base
+      #     has_rich_text :content
+      #   end
+      #
+      #   message = Message.create!(content: "<h1>Funny times!</h1>")
+      #   message.content? #=> true
+      #   message.content.to_s # => "<h1>Funny times!</h1>"
+      #   message.content.to_plain_text # => "Funny times!"
+      #
+      # The dependent RichText model will also automatically process attachments links as sent via the Trix-powered editor.
+      # These attachments are associated with the RichText model using Active Storage.
+      #
+      # If you wish to preload the dependent RichText model, you can use the named scope:
+      #
+      #   Message.all.with_rich_text_content # Avoids N+1 queries when you just want the body, not the attachments.
+      #   Message.all.with_rich_text_content_and_embeds # Avoids N+1 queries when you just want the body and attachments.
+      #   Message.all.with_all_rich_text # Loads all rich text associations.
+      #
+      #  === Options
+      #
+      #  * <tt>:encrypted</tt> - Pass true to encrypt the rich text attribute. The encryption will be non-deterministic. See
+      #  +ActiveRecord::Encryption::EncryptableRecord.encrypts+. Default: false.
+      def has_rich_text(name, encrypted: false)
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            rich_text_#{name} || build_rich_text_#{name}
+          end
+
+          def #{name}?
+            rich_text_#{name}.present?
+          end
+
+          def #{name}=(body)
+            self.#{name}.body = body
+          end
+        CODE
+
+        rich_text_class_name = encrypted ? 'ActionMosaico::EncryptedRichText' : 'ActionMosaico::RichText'
+        has_one :"rich_text_#{name}", -> { where(name: name) },
+                class_name: rich_text_class_name, as: :record, inverse_of: :record, autosave: true, dependent: :destroy
+
+        scope :"with_rich_text_#{name}", -> { includes("rich_text_#{name}") }
+        scope :"with_rich_text_#{name}_and_embeds", -> { includes("rich_text_#{name}": { embeds_attachments: :blob }) }
+      end
+
+      # Eager load all dependent RichText models in bulk.
+      def with_all_rich_text
+        eager_load(rich_text_association_names)
+      end
+
+      def rich_text_association_names
+        reflect_on_all_associations(:has_one).collect(&:name).select { |n| n.start_with?('rich_text_') }
+      end
+    end
+  end
+end