omg-actiontext 8.0.0.alpha3

data/lib/action_text/attachments/minification.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachments
+    module Minification
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_minifying_attachments(content)
+          Fragment.wrap(content).replace(ActionText::Attachment.tag_name) 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,38 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+
+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.render(partial: partial_path, formats: :html, object: self, as: model_name.element)
+          end
+        end
+    end
+  end
+end

data/lib/action_text/attribute.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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? #=> 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
+      #
+      # *   `:encrypted` - Pass true to encrypt the rich text attribute. The
+      #     encryption will be non-deterministic. See
+      #     `ActiveRecord::Encryption::EncryptableRecord.encrypts`. Default: false.
+      #
+      # *   `:strict_loading` - Pass true to force strict loading. When omitted,
+      #     `strict_loading:` will be set to the value of the
+      #     `strict_loading_by_default` class attribute (false by default).
+      #
+      # *   `:store_if_blank` - Pass false to not create RichText records with empty values,
+      #     if a blank value is provided. Default: true.
+      #
+      #
+      # Note: Action Text relies on polymorphic associations, which in turn store
+      # class names in the database. When renaming classes that use `has_rich_text`,
+      # make sure to also update the class names in the
+      # `action_text_rich_texts.record_type` polymorphic type column of the
+      # corresponding rows.
+      def has_rich_text(name, encrypted: false, strict_loading: strict_loading_by_default, store_if_blank: true)
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            rich_text_#{name} || build_rich_text_#{name}
+          end
+
+          def #{name}?
+            rich_text_#{name}.present?
+          end
+        CODE
+
+        if store_if_blank
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}=(body)
+              self.#{name}.body = body
+            end
+          CODE
+        else
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}=(body)
+              if body.present?
+                self.#{name}.body = body
+              else
+                if #{name}?
+                  self.#{name}.body = body
+                  self.#{name}.mark_for_destruction
+                end
+              end
+            end
+          CODE
+        end
+
+        rich_text_class_name = encrypted ? "ActionText::EncryptedRichText" : "ActionText::RichText"
+        has_one :"rich_text_#{name}", -> { where(name: name) },
+          class_name: rich_text_class_name, as: :record, inverse_of: :record, autosave: true, dependent: :destroy,
+          strict_loading: strict_loading
+
+        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
+        includes(rich_text_association_names)
+      end
+
+      # Returns the names of all rich text associations.
+      def rich_text_association_names
+        reflect_on_all_associations(:has_one).collect(&:name).select { |n| n.start_with?("rich_text_") }
+      end
+    end
+  end
+end

data/lib/action_text/content.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text Content
+  #
+  # The `ActionText::Content` class wraps an HTML fragment to add support for
+  # parsing, rendering and serialization. It can be used to extract links and
+  # attachments, convert the fragment to plain text, or serialize the fragment to
+  # the database.
+  #
+  # The ActionText::RichText record serializes the `body` attribute as
+  # `ActionText::Content`.
+  #
+  #     class Message < ActiveRecord::Base
+  #       has_rich_text :content
+  #     end
+  #
+  #     message = Message.create!(content: "<h1>Funny times!</h1>")
+  #     body = message.content.body # => #<ActionText::Content "<div class=\"trix-conte...">
+  #     body.to_s # => "<h1>Funny times!</h1>"
+  #     body.to_plain_text # => "Funny times!"
+  class Content
+    include Rendering, Serialization, ContentHelper
+
+    attr_reader :fragment
+
+    delegate :deconstruct, to: :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
+
+    # Extracts links from the HTML fragment:
+    #
+    #     html = '<a href="http://example.com/">Example</a>'
+    #     content = ActionText::Content.new(html)
+    #     content.links # => ["http://example.com/"]
+    def links
+      @links ||= fragment.find_all("a[href]").map { |a| a["href"] }.uniq
+    end
+
+    # Extracts +ActionText::Attachment+s from the HTML fragment:
+    #
+    #     attachable = ActiveStorage::Blob.first
+    #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
+    #     content = ActionText::Content.new(html)
+    #     content.attachments # => [#<ActionText::Attachment attachable=#<ActiveStorage::Blob...
+    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
+
+    # Extracts +ActionText::Attachable+s from the HTML fragment:
+    #
+    #     attachable = ActiveStorage::Blob.first
+    #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
+    #     content = ActionText::Content.new(html)
+    #     content.attachables # => [attachable]
+    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.tag_name) do |node|
+        if node.key?("content")
+          sanitized_content = sanitize_content_attachment(node.remove_attribute("content").to_s)
+          node["content"] = sanitized_content if sanitized_content.present?
+        end
+        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
+
+    # Returns a plain-text version of the markup contained by the content, with tags
+    # removed but HTML entities encoded.
+    #
+    #     content = ActionText::Content.new("<h1>Funny times!</h1>")
+    #     content.to_plain_text # => "Funny times!"
+    #
+    #     content = ActionText::Content.new("<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     content.to_plain_text # => "safeunsafe"
+    #
+    # NOTE: that the returned string is not HTML safe and should not be rendered in
+    # browsers.
+    #
+    #     content = ActionText::Content.new("&lt;script&gt;alert()&lt;/script&gt;")
+    #     content.to_plain_text # => "<script>alert()</script>"
+    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
+      render layout: "action_text/contents/content", partial: to_partial_path, formats: :html, locals: { content: self }
+    end
+
+    def to_partial_path
+      "action_text/contents/content"
+    end
+
+    # Safely transforms Content into an HTML String.
+    #
+    #     content = ActionText::Content.new(content: "<h1>Funny times!</h1>")
+    #     content.to_s # => "<h1>Funny times!</h1>"
+    #
+    #     content = ActionText::Content.new("<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     content.to_s # => "<div>safeunsafe</div>"
+    def to_s
+      to_rendered_html_with_layout
+    end
+
+    def as_json(*)
+      to_html
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_html.truncate(25).inspect}>"
+    end
+
+    def ==(other)
+      if self.class == other.class
+        to_html == other.to_html
+      elsif other.is_a?(self.class)
+        to_s == other.to_s
+      end
+    end
+
+    private
+      def attachment_nodes
+        @attachment_nodes ||= fragment.find_all(ActionText::Attachment.tag_name)
+      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

data/lib/action_text/deprecator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_text/encryption.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  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?(ActionText::EncryptedRichText) }
+      end
+  end
+end

data/lib/action_text/engine.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_controller/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+
+require "action_text"
+
+module ActionText
+  class Engine < Rails::Engine
+    isolate_namespace ActionText
+    config.eager_load_namespaces << ActionText
+
+    config.action_text = ActiveSupport::OrderedOptions.new
+    config.action_text.attachment_tag_name = "action-text-attachment"
+    config.autoload_once_paths = %W(
+      #{root}/app/helpers
+      #{root}/app/models
+    )
+
+    initializer "action_text.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_text] = ActionText.deprecator
+    end
+
+    initializer "action_text.attribute" do
+      ActiveSupport.on_load(:active_record) do
+        include ActionText::Attribute
+        prepend ActionText::Encryption
+      end
+    end
+
+    initializer "action_text.asset" do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w( actiontext.js actiontext.esm.js trix.js trix.css )
+      end
+    end
+
+    initializer "action_text.attachable" do
+      ActiveSupport.on_load(:active_storage_blob) do
+        include ActionText::Attachable
+
+        def previewable_attachable?
+          representable?
+        end
+
+        def attachable_plain_text_representation(caption = nil)
+          "[#{caption || filename}]"
+        end
+
+        def to_trix_content_attachment_partial_path
+          nil
+        end
+      end
+    end
+
+    initializer "action_text.helper" do
+      %i[action_controller_base action_mailer].each do |base|
+        ActiveSupport.on_load(base) do
+          helper ActionText::Engine.helpers
+        end
+      end
+    end
+
+    initializer "action_text.renderer" do
+      %i[action_controller_base action_mailer].each do |base|
+        ActiveSupport.on_load(base) do
+          around_action do |controller, action|
+            ActionText::Content.with_renderer(controller, &action)
+          end
+        end
+      end
+    end
+
+    initializer "action_text.system_test_helper" do
+      ActiveSupport.on_load(:action_dispatch_system_test_case) do
+        require "action_text/system_test_helper"
+        include ActionText::SystemTestHelper
+      end
+    end
+
+    initializer "action_text.configure" do |app|
+      ActionText::Attachment.tag_name = app.config.action_text.attachment_tag_name
+    end
+
+    config.after_initialize do |app|
+      if klass = app.config.action_text.sanitizer_vendor
+        ActionText::ContentHelper.sanitizer = klass.safe_list_sanitizer.new
+      end
+    end
+  end
+end

data/lib/action_text/fixture_set.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text FixtureSet
+  #
+  # 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 documentation.
+  #
+  # ### YAML
+  #
+  # Like other Active Record-backed models, ActionText::RichText records inherit
+  # from ActiveRecord::Base instances and can therefore be populated by fixtures.
+  #
+  # Consider an `Article` class:
+  #
+  #     class Article < ApplicationRecord
+  #       has_rich_text :content
+  #     end
+  #
+  # To declare fixture data for the related `content`, first declare fixture data
+  # for `Article` instances in `test/fixtures/articles.yml`:
+  #
+  #     first:
+  #       title: An Article
+  #
+  # Then declare the ActionText::RichText fixture data in
+  # `test/fixtures/action_text/rich_texts.yml`, making sure to declare each
+  # entry's `record:` key as a polymorphic relationship:
+  #
+  #     first:
+  #       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 Text relationship is intact.
+  class FixtureSet
+    # Fixtures support Action Text attachments as part of their `body` HTML.
+    #
+    # ### Examples
+    #
+    # For example, consider a second `Article` fixture declared in
+    # `test/fixtures/articles.yml`:
+    #
+    #     second:
+    #       title: Another Article
+    #
+    # You can attach a mention of `articles(:first)` to `second`'s `content` by
+    # embedding a call to `ActionText::FixtureSet.attachment` in the `body:` value
+    # in `test/fixtures/action_text/rich_texts.yml`:
+    #
+    #     second:
+    #       record: second (Article)
+    #       name: content
+    #       body: <div>Hello, <%= ActionText::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: ActionText::Attachable::LOCATOR_NAME
+
+      %(<action-text-attachment sgid="#{signed_global_id}"></action-text-attachment>)
+    end
+  end
+end

data/lib/action_text/fragment.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class Fragment
+    class << self
+      def wrap(fragment_or_html)
+        case fragment_or_html
+        when self
+          fragment_or_html
+        when Nokogiri::XML::DocumentFragment # base class for all fragments
+          new(fragment_or_html)
+        else
+          from_html(fragment_or_html)
+        end
+      end
+
+      def from_html(html)
+        new(ActionText::HtmlConversion.fragment_for_html(html.to_s.strip))
+      end
+    end
+
+    attr_reader :source
+
+    delegate :deconstruct, to: "source.elements"
+
+    def initialize(source)
+      @source = source
+    end
+
+    def find_all(selector)
+      source.css(selector)
+    end
+
+    def update
+      yield source = self.source.dup
+      self.class.new(source)
+    end
+
+    def replace(selector)
+      update do |source|
+        source.css(selector).each do |node|
+          replacement_node = yield(node)
+          node.replace(replacement_node.to_s) if node != replacement_node
+        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_text/gem_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # Returns the currently loaded version of Action Text as a `Gem::Version`.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha3"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_text/html_conversion.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  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
+        ActionText.html_document_class.new.tap { |doc| doc.encoding = "UTF-8" }
+      end
+  end
+end