actiontext 6.0.2

data/lib/action_text/engine.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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
+
+    initializer "action_text.attribute" do
+      ActiveSupport.on_load(:active_record) do
+        include ActionText::Attribute
+      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
+      end
+    end
+
+    initializer "action_text.helper" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper ActionText::Engine.helpers
+      end
+    end
+
+    initializer "action_text.renderer" do |app|
+      app.executor.to_run      { ActionText::Content.renderer = ApplicationController.renderer }
+      app.executor.to_complete { ActionText::Content.renderer = ApplicationController.renderer }
+
+      ActiveSupport.on_load(:action_text_content) do
+        self.renderer = ApplicationController.renderer
+      end
+
+      ActiveSupport.on_load(:action_controller_base) do
+        before_action { ActionText::Content.renderer = ApplicationController.renderer.new(request.env) }
+      end
+    end
+  end
+end

data/lib/action_text/fragment.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionText
+  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(ActionText::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_text/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionText
+  # Returns the currently-loaded version of Action Text as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 6
+    MINOR = 0
+    TINY  = 2
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_text/html_conversion.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+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
+        Nokogiri::HTML::Document.new.tap { |doc| doc.encoding = "UTF-8" }
+      end
+  end
+end

data/lib/action_text/plain_text_conversion.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActionText
+  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)
+        node.children.each_with_index.map do |child, index|
+          plain_text_for_node(child, index)
+        end.compact.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_text/serialization.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionText
+  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
+        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_text/trix_attachment.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActionText
+  class TrixAttachment
+    TAG_NAME = "figure"
+    SELECTOR = "[data-trix-attachment]"
+
+    COMPOSED_ATTRIBUTES = %w( caption presentation )
+    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) rescue value },
+      "width"       => ->(value) { Integer(value.to_s) rescue nil },
+      "height"      => ->(value) { Integer(value.to_s) rescue nil },
+      :default      => ->(value) { value.to_s }
+    }
+
+    class << self
+      def from_attributes(attributes)
+        attributes = process_attributes(attributes)
+
+        trix_attachment_attributes = attributes.except(*COMPOSED_ATTRIBUTES)
+        trix_attributes = attributes.slice(*COMPOSED_ATTRIBUTES)
+
+        node = ActionText::HtmlConversion.create_element(TAG_NAME)
+        node["data-trix-attachment"] = JSON.generate(trix_attachment_attributes)
+        node["data-trix-attributes"] = JSON.generate(trix_attributes) if trix_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
+      ActionText::HtmlConversion.node_to_html(node)
+    end
+
+    def to_s
+      to_html
+    end
+
+    private
+      def attachment_attributes
+        read_json_object_attribute("data-trix-attachment")
+      end
+
+      def composed_attributes
+        read_json_object_attribute("data-trix-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 => 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_text/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActionText
+  # Returns the currently-loaded version of Action Text as a <tt>Gem::Version</tt>.
+  def self.version
+    gem_version
+  end
+end

data/lib/tasks/actiontext.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+namespace :action_text do
+  # Prevent migration installation task from showing up twice.
+  Rake::Task["install:migrations"].clear_comments
+
+  desc "Copy over the migration, stylesheet, and JavaScript files"
+  task install: %w( environment run_installer copy_migrations )
+
+  task :run_installer do
+    installer_template = File.expand_path("../templates/installer.rb", __dir__)
+    system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{installer_template}"
+  end
+
+  task :copy_migrations do
+    Rake::Task["active_storage:install:migrations"].invoke
+    Rake::Task["railties:install:migrations"].reenable # Otherwise you can't run 2 migration copy tasks in one invocation
+    Rake::Task["action_text:install:migrations"].invoke
+  end
+end

data/lib/templates/actiontext.scss

@@ -0,0 +1,36 @@
+//
+// Provides a drop-in pointer for the default Trix stylesheet that will format the toolbar and
+// the trix-editor content (whether displayed or under editing). Feel free to incorporate this
+// inclusion directly in any other asset bundle and remove this file.
+//
+//= require trix/dist/trix
+
+// We need to override trix.css’s image gallery styles to accommodate the
+// <action-text-attachment> element we wrap around attachments. Otherwise,
+// images in galleries will be squished by the max-width: 33%; rule.
+.trix-content {
+  .attachment-gallery {
+    > action-text-attachment,
+    > .attachment {
+      flex: 1 0 33%;
+      padding: 0 0.5em;
+      max-width: 33%;
+    }
+
+    &.attachment-gallery--2,
+    &.attachment-gallery--4 {
+      > action-text-attachment,
+      > .attachment {
+        flex-basis: 50%;
+        max-width: 50%;
+      }
+    }
+  }
+
+  action-text-attachment {
+    .attachment {
+      padding: 0 !important;
+      max-width: 100% !important;
+    }
+  }
+}

data/lib/templates/fixtures.yml

@@ -0,0 +1,4 @@
+# one:
+#   record: name_of_fixture (ClassOfFixture)
+#   name: content
+#   body: <p>In a <i>million</i> stars!</p>

data/lib/templates/installer.rb

@@ -0,0 +1,45 @@
+require "pathname"
+require "json"
+
+APPLICATION_PACK_PATH = Pathname.new("app/javascript/packs/application.js")
+JS_PACKAGE_PATH = Pathname.new("#{__dir__}/../../package.json")
+
+JS_PACKAGE = JSON.load(JS_PACKAGE_PATH)
+JS_DEPENDENCIES = JS_PACKAGE["peerDependencies"].dup.merge \
+  JS_PACKAGE["name"] => "^#{JS_PACKAGE["version"]}"
+
+say "Copying actiontext.scss to app/assets/stylesheets"
+copy_file "#{__dir__}/actiontext.scss", "app/assets/stylesheets/actiontext.scss"
+
+say "Copying fixtures to test/fixtures/action_text/rich_texts.yml"
+copy_file "#{__dir__}/fixtures.yml", "test/fixtures/action_text/rich_texts.yml"
+
+say "Copying blob rendering partial to app/views/active_storage/blobs/_blob.html.erb"
+copy_file "#{__dir__}/../../app/views/active_storage/blobs/_blob.html.erb",
+  "app/views/active_storage/blobs/_blob.html.erb"
+
+say "Installing JavaScript dependencies"
+run "yarn add #{JS_DEPENDENCIES.map { |name, version| "#{name}@#{version}" }.join(" ")}"
+
+if APPLICATION_PACK_PATH.exist?
+  JS_DEPENDENCIES.keys.each do |name|
+    line = %[require("#{name}")]
+    unless APPLICATION_PACK_PATH.read.include? line
+      say "Adding #{name} to #{APPLICATION_PACK_PATH}"
+      append_to_file APPLICATION_PACK_PATH, "\n#{line}"
+    end
+  end
+else
+  warn <<~WARNING
+    WARNING: Action Text can't locate your JavaScript bundle to add its package dependencies.
+
+    Add these lines to any bundles:
+
+    require("trix")
+    require("@rails/actiontext")
+
+    Alternatively, install and setup the webpacker gem then rerun `bin/rails action_text:install`
+    to have these dependencies added automatically.
+
+  WARNING
+end