actiontext 6.0.0.beta1

data/lib/action_text/attachables/missing_attachable.rb

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

data/lib/action_text/attachables/remote_image.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+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 =~ /^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,103 @@
+# frozen_string_literal: true
+
+module ActionText
+  class Attachment
+    include Attachments::TrixConversion, Attachments::Minification, Attachments::Caching
+
+    TAG_NAME = "action-text-attachment"
+    SELECTOR = TAG_NAME
+    ATTRIBUTES = %w( sgid content-type url href filename filesize width height previewable presentation caption )
+
+    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).map { |attachable| from_attachable(attachable) }.compact
+      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
+
+    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_text/attachment_gallery.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActionText
+  class AttachmentGallery
+    include ActiveModel::Model
+
+    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?
+              child.text =~ /\A(\n|\ )*\z/
+            else
+              child.matches? ATTACHMENT_SELECTOR
+            end
+          end
+        end
+      end
+
+      def from_node(node)
+        new(node)
+      end
+    end
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def attachments
+      @attachments ||= node.css(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
+
+    TAG_NAME = "div"
+    ATTACHMENT_SELECTOR = "#{ActionText::Attachment::SELECTOR}[presentation=gallery]"
+    SELECTOR = "#{TAG_NAME}:has(#{ATTACHMENT_SELECTOR} + #{ATTACHMENT_SELECTOR})"
+
+    private_constant :TAG_NAME, :ATTACHMENT_SELECTOR, :SELECTOR
+  end
+end

data/lib/action_text/attachments/caching.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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
+          Digest::SHA256.hexdigest(node.to_s)
+        end
+    end
+  end
+end

data/lib/action_text/attachments/minification.rb

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

data/lib/action_text/attachments/trix_conversion.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionText
+  module Attachments
+    module TrixConversion
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_converting_trix_attachments(content)
+          Fragment.wrap(content).replace(TrixAttachment::SELECTOR) do |node|
+            from_trix_attachment(TrixAttachment.new(node))
+          end
+        end
+
+        def from_trix_attachment(trix_attachment)
+          from_attributes(trix_attachment.attributes)
+        end
+      end
+
+      def to_trix_attachment(content = trix_attachment_content)
+        attributes = full_attributes.dup
+        attributes["content"] = content if content
+        TrixAttachment.from_attributes(attributes)
+      end
+
+      private
+        def trix_attachment_content
+          if partial_path = attachable.try(:to_trix_content_attachment_partial_path)
+            ActionText::Content.renderer.render(partial: partial_path, object: self, as: model_name.element)
+          end
+        end
+    end
+  end
+end

data/lib/action_text/attribute.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActionText
+  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.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.
+      def has_rich_text(name)
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            self.rich_text_#{name} ||= ActionText::RichText.new(name: "#{name}", record: self)
+          end
+
+          def #{name}=(body)
+            self.#{name}.body = body
+          end
+        CODE
+
+        has_one :"rich_text_#{name}", -> { where(name: name) }, class_name: "ActionText::RichText", as: :record, inverse_of: :record, 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 }) }
+
+        after_save do
+          public_send(name).save if public_send(name).changed?
+        end
+      end
+    end
+  end
+end

data/lib/action_text/content.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+module ActionText
+  class Content
+    include Serialization
+
+    thread_cattr_accessor :renderer
+
+    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 = ActionText::Attachment.fragment_by_canonicalizing_attachments(content)
+        fragment = ActionText::AttachmentGallery.fragment_by_canonicalizing_attachment_galleries(fragment)
+        fragment
+      end
+    end
+
+    def initialize(content = nil, options = {})
+      options.with_defaults! canonicalize: true
+
+      if options[:canonicalize]
+        @fragment = self.class.fragment_by_canonicalizing_content(content)
+      else
+        @fragment = ActionText::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|
+        ActionText::Attachable.from_node(node)
+      end
+    end
+
+    def append_attachables(attachables)
+      attachments = ActionText::Attachment.from_attachables(attachables)
+      self.class.new([self.to_s.presence, *attachments].compact.join("\n"))
+    end
+
+    def render_attachments(**options, &block)
+      content = fragment.replace(ActionText::Attachment::SELECTOR) do |node|
+        block.call(attachment_for_node(node, **options))
+      end
+      self.class.new(content, canonicalize: false)
+    end
+
+    def render_attachment_galleries(&block)
+      content = ActionText::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_trix_html
+      render_attachments(&:to_trix_attachment).to_html
+    end
+
+    def to_html
+      fragment.to_html
+    end
+
+    def to_rendered_html_with_layout
+      renderer.render(partial: "action_text/content/layout", locals: { content: self })
+    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)
+      if other.is_a?(self.class)
+        to_s == other.to_s
+      end
+    end
+
+    private
+      def attachment_nodes
+        @attachment_nodes ||= fragment.find_all(ActionText::Attachment::SELECTOR)
+      end
+
+      def attachment_gallery_nodes
+        @attachment_gallery_nodes ||= ActionText::AttachmentGallery.find_attachment_gallery_nodes(fragment)
+      end
+
+      def attachment_for_node(node, with_full_attributes: true)
+        attachment = ActionText::Attachment.from_node(node)
+        with_full_attributes ? attachment.with_full_attributes : attachment
+      end
+
+      def attachment_gallery_for_node(node)
+        ActionText::AttachmentGallery.from_node(node)
+      end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_content, ActionText::Content