omg-actiontext 8.0.0.alpha3

data/lib/action_text/plain_text_conversion.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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)
+        texts = []
+        node.children.each_with_index do |child, index|
+          texts << plain_text_for_node(child, index)
+        end
+        texts.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 ].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_block
+      end
+
+      def plain_text_for_list(node, index)
+        "#{break_if_nested_list(node, plain_text_for_block(node))}"
+      end
+
+      %i[ ul ol ].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_list
+      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))
+        indentation = indentation_for_li_node(node)
+
+        "#{indentation}#{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
+
+      def indentation_for_li_node(node)
+        depth = list_node_depth_for_node(node)
+        if depth > 1
+          "  " * (depth - 1)
+        end
+      end
+
+      def list_node_depth_for_node(node)
+        node.ancestors.map(&:name).grep(/^[uo]l$/).count
+      end
+
+      def break_if_nested_list(node, text)
+        if list_node_depth_for_node(node) > 0
+          "\n#{text}"
+        else
+          text
+        end
+      end
+  end
+end

data/lib/action_text/rendering.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+module ActionText
+  module Rendering # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      thread_cattr_accessor :renderer, instance_accessor: false
+      delegate :render, to: :class
+    end
+
+    class_methods do
+      def action_controller_renderer
+        @action_controller_renderer ||= Class.new(ActionController::Base).renderer
+      end
+
+      def with_renderer(renderer)
+        previous_renderer = self.renderer
+        self.renderer = renderer
+        yield
+      ensure
+        self.renderer = previous_renderer
+      end
+
+      def render(*args, &block)
+        (renderer || action_controller_renderer).render_to_string(*args, &block)
+      end
+    end
+  end
+end

data/lib/action_text/serialization.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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
+        when ActionText::RichText
+          content.body.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/system_test_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module SystemTestHelper
+    # Locates a Trix editor and fills it in with the given HTML.
+    #
+    # The editor can be found by:
+    # *   its `id`
+    # *   its `placeholder`
+    # *   the text from its `label` element
+    # *   its `aria-label`
+    # *   the `name` of its input
+    #
+    #
+    # Examples:
+    #
+    #     # <trix-editor id="message_content" ...></trix-editor>
+    #     fill_in_rich_textarea "message_content", with: "Hello <em>world!</em>"
+    #
+    #     # <trix-editor placeholder="Your message here" ...></trix-editor>
+    #     fill_in_rich_textarea "Your message here", with: "Hello <em>world!</em>"
+    #
+    #     # <label for="message_content">Message content</label>
+    #     # <trix-editor id="message_content" ...></trix-editor>
+    #     fill_in_rich_textarea "Message content", with: "Hello <em>world!</em>"
+    #
+    #     # <trix-editor aria-label="Message content" ...></trix-editor>
+    #     fill_in_rich_textarea "Message content", with: "Hello <em>world!</em>"
+    #
+    #     # <input id="trix_input_1" name="message[content]" type="hidden">
+    #     # <trix-editor input="trix_input_1"></trix-editor>
+    #     fill_in_rich_textarea "message[content]", with: "Hello <em>world!</em>"
+    def fill_in_rich_textarea(locator = nil, with:)
+      find(:rich_textarea, locator).execute_script("this.editor.loadHTML(arguments[0])", with.to_s)
+    end
+    alias_method :fill_in_rich_text_area, :fill_in_rich_textarea
+  end
+end
+
+%i[rich_textarea rich_text_area].each do |rich_textarea|
+  Capybara.add_selector rich_textarea do
+    label "rich-text area"
+    xpath do |locator|
+      if locator.nil?
+        XPath.descendant(:"trix-editor")
+      else
+        input_located_by_name = XPath.anywhere(:input).where(XPath.attr(:name) == locator).attr(:id)
+        input_located_by_label = XPath.anywhere(:label).where(XPath.string.n.is(locator)).attr(:for)
+
+        XPath.descendant(:"trix-editor").where \
+          XPath.attr(:id).equals(locator) |
+          XPath.attr(:placeholder).equals(locator) |
+          XPath.attr(:"aria-label").equals(locator) |
+          XPath.attr(:input).equals(input_located_by_name) |
+          XPath.attr(:id).equals(input_located_by_label)
+      end
+    end
+  end
+end

data/lib/action_text/trix_attachment.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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, exception: false) || value },
+      "width"       => ->(value) { Integer(value.to_s, exception: false) },
+      "height"      => ->(value) { Integer(value.to_s, exception: false) },
+      :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.to_h do |key, value|
+            typecast = ATTRIBUTE_TYPES[key] || ATTRIBUTE_TYPES[:default]
+            [key, typecast.call(value)]
+          end
+        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,12 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require_relative "gem_version"
+
+module ActionText
+  # Returns the currently loaded version of Action Text as a `Gem::Version`.
+  def self.version
+    gem_version
+  end
+end

data/lib/action_text.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/rails"
+
+require "action_text/version"
+require "action_text/deprecator"
+
+require "nokogiri"
+
+# :markup: markdown
+# :include: ../README.md
+module ActionText
+  extend ActiveSupport::Autoload
+
+  autoload :Attachable
+  autoload :AttachmentGallery
+  autoload :Attachment
+  autoload :Attribute
+  autoload :Content
+  autoload :Encryption
+  autoload :Fragment
+  autoload :FixtureSet
+  autoload :HtmlConversion
+  autoload :PlainTextConversion
+  autoload :Rendering
+  autoload :Serialization
+  autoload :TrixAttachment
+
+  module Attachables
+    extend ActiveSupport::Autoload
+
+    autoload :ContentAttachment
+    autoload :MissingAttachable
+    autoload :RemoteImage
+  end
+
+  module Attachments
+    extend ActiveSupport::Autoload
+
+    autoload :Caching
+    autoload :Minification
+    autoload :TrixConversion
+  end
+
+  class << self
+    def html_document_class
+      return @html_document_class if defined?(@html_document_class)
+      @html_document_class =
+        defined?(Nokogiri::HTML5) ? Nokogiri::HTML5::Document : Nokogiri::HTML4::Document
+    end
+
+    def html_document_fragment_class
+      return @html_document_fragment_class if defined?(@html_document_fragment_class)
+      @html_document_fragment_class =
+        defined?(Nokogiri::HTML5) ? Nokogiri::HTML5::DocumentFragment : Nokogiri::HTML4::DocumentFragment
+    end
+  end
+end

data/lib/generators/action_text/install/install_generator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "pathname"
+require "json"
+
+module ActionText
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def install_javascript_dependencies
+        say "Installing JavaScript dependencies", :green
+        if using_bun?
+          run "bun add @rails/actiontext trix"
+        elsif using_node?
+          run "yarn add @rails/actiontext trix"
+        end
+      end
+
+      def append_javascript_dependencies
+        destination = Pathname(destination_root)
+
+        if (application_javascript_path = destination.join("app/javascript/application.js")).exist?
+          insert_into_file application_javascript_path.to_s, %(\nimport "trix"\nimport "@rails/actiontext"\n)
+        else
+          say <<~INSTRUCTIONS, :green
+            You must import the @rails/actiontext and trix JavaScript modules in your application entrypoint.
+          INSTRUCTIONS
+        end
+
+        if (importmap_path = destination.join("config/importmap.rb")).exist?
+          append_to_file importmap_path.to_s, %(pin "trix"\npin "@rails/actiontext", to: "actiontext.esm.js"\n)
+        end
+      end
+
+      def create_actiontext_files
+        template "actiontext.css", "app/assets/stylesheets/actiontext.css"
+
+        gem_root = "#{__dir__}/../../../.."
+
+        copy_file "#{gem_root}/app/views/active_storage/blobs/_blob.html.erb",
+          "app/views/active_storage/blobs/_blob.html.erb"
+
+        copy_file "#{gem_root}/app/views/layouts/action_text/contents/_content.html.erb",
+          "app/views/layouts/action_text/contents/_content.html.erb"
+      end
+
+      def enable_image_processing_gem
+        if (gemfile_path = Pathname(destination_root).join("Gemfile")).exist?
+          say "Ensure image_processing gem has been enabled so image uploads will work (remember to bundle!)"
+          image_processing_regex = /gem ["']image_processing["']/
+          if File.readlines(gemfile_path).grep(image_processing_regex).any?
+            uncomment_lines gemfile_path, image_processing_regex
+          else
+            run "bundle add --skip-install image_processing"
+          end
+        end
+      end
+
+      def create_migrations
+        rails_command "railties:install:migrations FROM=active_storage,action_text", inline: true
+      end
+
+      def using_js_runtime?
+        @using_js_runtime ||= Pathname(destination_root).join("package.json").exist?
+      end
+
+      def using_bun?
+        # Cannot assume yarn.lock has been generated yet so we look for a file known to
+        # be generated by the jsbundling-rails gem
+        @using_bun ||= using_js_runtime? && Pathname(destination_root).join("bun.config.js").exist?
+      end
+
+      def using_node?
+        # Bun is the only runtime that _isn't_ node.
+        @using_node ||= using_js_runtime? && !Pathname(destination_root).join("bun.config.js").exist?
+      end
+
+      hook_for :test_framework
+    end
+  end
+end