omg-actiontext 8.0.0.alpha3

data/app/models/action_text/record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class Record < ActiveRecord::Base # :nodoc:
+    self.abstract_class = true
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_record, ActionText::Record

data/app/models/action_text/rich_text.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text RichText
+  #
+  # The RichText record holds the content produced by the Trix editor in a
+  # serialized `body` attribute. It also holds all the references to the embedded
+  # files, which are stored using Active Storage. This record is then associated
+  # with the Active Record model the application desires to have rich text content
+  # using the `has_rich_text` class method.
+  #
+  #     class Message < ActiveRecord::Base
+  #       has_rich_text :content
+  #     end
+  #
+  #     message = Message.create!(content: "<h1>Funny times!</h1>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<h1>Funny times!</h1>"
+  #     message.content.to_plain_text # => "Funny times!"
+  #
+  #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<div>safeunsafe</div>"
+  #     message.content.to_plain_text # => "safeunsafe"
+  class RichText < Record
+    ##
+    # :method: to_s
+    #
+    # Safely transforms RichText into an HTML String.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_s # => "<h1>Funny times!</h1>"
+    #
+    #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     message.content.to_s # => "<div>safeunsafe</div>"
+
+    serialize :body, coder: ActionText::Content
+    delegate :to_s, :nil?, to: :body
+
+    ##
+    # :method: record
+    #
+    # Returns the associated record.
+    belongs_to :record, polymorphic: true, touch: true
+
+    ##
+    # :method: embeds
+    #
+    # Returns the `ActiveStorage::Blob`s of the embedded files.
+    has_many_attached :embeds
+
+    before_save do
+      self.embeds = body.attachables.grep(ActiveStorage::Blob).uniq if body.present?
+    end
+
+    # Returns a plain-text version of the markup contained by the `body` attribute,
+    # with tags removed but HTML entities encoded.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_plain_text # => "Funny times!"
+    #
+    # NOTE: that the returned string is not HTML safe and should not be rendered in
+    # browsers.
+    #
+    #     message = Message.create!(content: "&lt;script&gt;alert()&lt;/script&gt;")
+    #     message.content.to_plain_text # => "<script>alert()</script>"
+    def to_plain_text
+      body&.to_plain_text.to_s
+    end
+
+    # Returns the `body` attribute in a format that makes it editable in the Trix
+    # editor. Previews of attachments are rendered inline.
+    #
+    #     content = "<h1>Funny Times!</h1><figure data-trix-attachment='{\"sgid\":\"..."\}'></figure>"
+    #     message = Message.create!(content: content)
+    #     message.content.to_trix_html # =>
+    #     # <div class="trix-content">
+    #     #   <h1>Funny times!</h1>
+    #     #   <figure data-trix-attachment='{\"sgid\":\"..."\}'>
+    #     #      <img src="http://example.org/rails/active_storage/.../funny.jpg">
+    #     #   </figure>
+    #     # </div>
+    def to_trix_html
+      body&.to_trix_html
+    end
+
+    delegate :blank?, :empty?, :present?, to: :to_plain_text
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_rich_text, ActionText::RichText

data/app/views/action_text/attachables/_content_attachment.html.erb

@@ -0,0 +1,3 @@
+<figure class="attachment attachment--content">
+  <%= content_attachment.attachable %>
+</figure>

data/app/views/action_text/attachables/_missing_attachable.html.erb

@@ -0,0 +1 @@
+<%= "☒" -%>

data/app/views/action_text/attachables/_remote_image.html.erb

@@ -0,0 +1,8 @@
+<figure class="attachment attachment--preview">
+  <%= image_tag(remote_image.url, width: remote_image.width, height: remote_image.height) %>
+  <% if caption = remote_image.try(:caption) %>
+    <figcaption class="attachment__caption">
+      <%= caption %>
+    </figcaption>
+  <% end %>
+</figure>

data/app/views/action_text/attachment_galleries/_attachment_gallery.html.erb

@@ -0,0 +1,3 @@
+<div class="attachment-gallery attachment-gallery--<%= attachment_gallery.size %>">
+  <%= yield %>
+</div>

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

@@ -0,0 +1 @@
+<%= render_action_text_content(content) %>

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="trix-content">
+  <%= yield -%>
+</div>

data/db/migrate/20180528164100_create_action_text_tables.rb

@@ -0,0 +1,25 @@
+class CreateActionTextTables < ActiveRecord::Migration[6.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_text_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 [ :record_type, :record_id, :name ], name: "index_action_text_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_text/attachable.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text Attachable
+  #
+  # Include this module to make a record attachable to an ActionText::Content.
+  #
+  #     class Person < ApplicationRecord
+  #       include ActionText::Attachable
+  #     end
+  #
+  #     person = Person.create! name: "Javan"
+  #     html = %Q(<action-text-attachment sgid="#{person.attachable_sgid}"></action-text-attachment>)
+  #     content = ActionText::Content.new(html)
+  #     content.attachables # => [person]
+  module Attachable
+    extend ActiveSupport::Concern
+
+    LOCATOR_NAME = "attachable"
+
+    class << self
+      # Extracts the `ActionText::Attachable` from the attachment HTML node:
+      #
+      #     person = Person.create! name: "Javan"
+      #     html = %Q(<action-text-attachment sgid="#{person.attachable_sgid}"></action-text-attachment>)
+      #     fragment = ActionText::Fragment.wrap(html)
+      #     attachment_node = fragment.find_all(ActionText::Attachment.tag_name).first
+      #     ActionText::Attachable.from_node(attachment_node) # => person
+      def from_node(node)
+        if attachable = attachable_from_sgid(node["sgid"])
+          attachable
+        elsif attachable = ActionText::Attachables::ContentAttachment.from_node(node)
+          attachable
+        elsif attachable = ActionText::Attachables::RemoteImage.from_node(node)
+          attachable
+        else
+          ActionText::Attachables::MissingAttachable.new(node["sgid"])
+        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)
+        ActionText::Attachable.from_attachable_sgid(sgid, only: self)
+      end
+
+      # Returns the path to the partial that is used for rendering missing
+      # attachables. Defaults to "action_text/attachables/missing_attachable".
+      #
+      # Override to render a different partial:
+      #
+      #     class User < ApplicationRecord
+      #       def self.to_missing_attachable_partial_path
+      #         "users/missing_attachable"
+      #       end
+      #     end
+      def to_missing_attachable_partial_path
+        ActionText::Attachables::MissingAttachable::DEFAULT_PARTIAL_PATH
+      end
+    end
+
+    # Returns the Signed Global ID for the attachable. The purpose of the ID is set
+    # to 'attachable' so it can't be reused for other purposes.
+    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
+
+    # Returns the path to the partial that is used for rendering the attachable in
+    # Trix. Defaults to `to_partial_path`.
+    #
+    # Override to render a different partial:
+    #
+    #     class User < ApplicationRecord
+    #       def to_trix_content_attachment_partial_path
+    #         "users/trix_content_attachment"
+    #       end
+    #     end
+    def to_trix_content_attachment_partial_path
+      to_partial_path
+    end
+
+    # Returns the path to the partial that is used for rendering the attachable.
+    # Defaults to `to_partial_path`.
+    #
+    # Override to render a different partial:
+    #
+    #     class User < ApplicationRecord
+    #       def to_attachable_partial_path
+    #         "users/attachable"
+    #       end
+    #     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
+
+    private
+      def attribute_names_for_serialization
+        super + ["attachable_sgid"]
+      end
+
+      def read_attribute_for_serialization(key)
+        if key == "attachable_sgid"
+          persisted? ? super : nil
+        else
+          super
+        end
+      end
+  end
+end

data/lib/action_text/attachables/content_attachment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class ContentAttachment # :nodoc:
+      include ActiveModel::Model
+
+      def self.from_node(node)
+        attachment = new(content_type: node["content-type"], content: node["content"])
+        attachment if attachment.valid?
+      end
+
+      attr_accessor :content_type, :content
+
+      validates_format_of :content_type, with: /html/
+      validates_presence_of :content
+
+      def attachable_plain_text_representation(caption)
+        content_instance.fragment.source
+      end
+
+      def to_html
+        @to_html ||= content_instance.render(content_instance)
+      end
+
+      def to_s
+        to_html
+      end
+
+      def to_partial_path
+        "action_text/attachables/content_attachment"
+      end
+
+      private
+        def content_instance
+          @content_instance ||= ActionText::Content.new(content)
+        end
+    end
+  end
+end

data/lib/action_text/attachables/missing_attachable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class MissingAttachable
+      extend ActiveModel::Naming
+
+      DEFAULT_PARTIAL_PATH = "action_text/attachables/missing_attachable"
+
+      def initialize(sgid)
+        @sgid = SignedGlobalID.parse(sgid, for: ActionText::Attachable::LOCATOR_NAME)
+      end
+
+      def to_partial_path
+        if model
+          model.to_missing_attachable_partial_path
+        else
+          DEFAULT_PARTIAL_PATH
+        end
+      end
+
+      def model
+        @sgid&.model_name.to_s.safe_constantize
+      end
+    end
+  end
+end

data/lib/action_text/attachables/remote_image.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class RemoteImage
+      extend ActiveModel::Naming
+
+      class << self
+        def from_node(node)
+          if node["url"] && content_type_is_image?(node["content-type"])
+            new(attributes_from_node(node))
+          end
+        end
+
+        private
+          def content_type_is_image?(content_type)
+            content_type.to_s.match?(/^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_text/attachables/remote_image"
+      end
+    end
+  end
+end

data/lib/action_text/attachment.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+
+module ActionText
+  # # Action Text Attachment
+  #
+  # Attachments serialize attachables to HTML or plain text.
+  #
+  #     class Person < ApplicationRecord
+  #       include ActionText::Attachable
+  #     end
+  #
+  #     attachable = Person.create! name: "Javan"
+  #     attachment = ActionText::Attachment.from_attachable(attachable)
+  #     attachment.to_html # => "<action-text-attachment sgid=\"BAh7CEk..."
+  class Attachment
+    include Attachments::TrixConversion, Attachments::Minification, Attachments::Caching
+
+    mattr_accessor :tag_name, default: "action-text-attachment"
+
+    ATTRIBUTES = %w( sgid content-type url href filename filesize width height previewable presentation caption content )
+
+    class << self
+      def fragment_by_canonicalizing_attachments(content)
+        fragment_by_minifying_attachments(fragment_by_converting_trix_attachments(content))
+      end
+
+      def from_node(node, attachable = nil)
+        new(node, attachable || ActionText::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
+            ActionText::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
+
+    # Converts the attachment to plain text.
+    #
+    #     attachable = ActiveStorage::Blob.find_by filename: "racecar.jpg"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_plain_text # => "[racecar.jpg]"
+    #
+    # Use the `caption` when set:
+    #
+    #     attachment = ActionText::Attachment.from_attachable(attachable, caption: "Vroom vroom")
+    #     attachment.to_plain_text # => "[Vroom vroom]"
+    #
+    # The presentation can be overridden by implementing the
+    # `attachable_plain_text_representation` method:
+    #
+    #     class Person < ApplicationRecord
+    #       include ActionText::Attachable
+    #
+    #       def attachable_plain_text_representation
+    #         "[#{name}]"
+    #       end
+    #     end
+    #
+    #     attachable = Person.create! name: "Javan"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_plain_text # => "[Javan]"
+    def to_plain_text
+      if respond_to?(:attachable_plain_text_representation)
+        attachable_plain_text_representation(caption)
+      else
+        caption.to_s
+      end
+    end
+
+    # Converts the attachment to HTML.
+    #
+    #     attachable = Person.create! name: "Javan"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_html # => "<action-text-attachment sgid=\"BAh7CEk...
+    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.to_h { |name| [ name.underscore, node[name] ] }.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_text/attachment_gallery.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  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
+        "#{ActionText::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(ActionText::AttachmentGallery.attachment_selector).map do |node|
+        ActionText::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_text/attachments/caching.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  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