actiontext 7.2.2.1 → 8.1.2

data/app/javascript/actiontext/attachment_upload.js

@@ -1,32 +1,86 @@
-import { DirectUpload } from "@rails/activestorage"
+import { DirectUpload, dispatchEvent } from "@rails/activestorage"
 
 export class AttachmentUpload {
-  constructor(attachment, element) {
+  constructor(attachment, element, file = attachment.file) {
     this.attachment = attachment
     this.element = element
-    this.directUpload = new DirectUpload(attachment.file, this.directUploadUrl, this)
+    this.directUpload = new DirectUpload(file, this.directUploadUrl, this)
+    this.file = file
   }
 
   start() {
-    this.directUpload.create(this.directUploadDidComplete.bind(this))
+    return new Promise((resolve, reject) => {
+      this.directUpload.create((error, attributes) => this.directUploadDidComplete(error, attributes, resolve, reject))
+      this.dispatch("start")
+    })
   }
 
   directUploadWillStoreFileWithXHR(xhr) {
     xhr.upload.addEventListener("progress", event => {
-      const progress = event.loaded / event.total * 100
-      this.attachment.setUploadProgress(progress)
+      // Scale upload progress to 0-90% range
+      const progress = (event.loaded / event.total) * 90
+      if (progress) {
+        this.dispatch("progress", { progress: progress })
+      }
+    })
+
+    // Start simulating progress after upload completes
+    xhr.upload.addEventListener("loadend", () => {
+      this.simulateResponseProgress(xhr)
     })
   }
 
-  directUploadDidComplete(error, attributes) {
-    if (error) {
-      throw new Error(`Direct upload failed: ${error}`)
+  simulateResponseProgress(xhr) {
+    let progress = 90
+    const startTime = Date.now()
+
+    const updateProgress = () => {
+      // Simulate progress from 90% to 99% over estimated time
+      const elapsed = Date.now() - startTime
+      const estimatedResponseTime = this.estimateResponseTime()
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1)
+      progress = 90 + (responseProgress * 9) // 90% to 99%
+
+      this.dispatch("progress", { progress })
+
+      // Continue until response arrives or we hit 99%
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress)
+      }
     }
 
-    this.attachment.setAttributes({
-      sgid: attributes.attachable_sgid,
-      url: this.createBlobUrl(attributes.signed_id, attributes.filename)
+    // Stop simulation when response arrives
+    xhr.addEventListener("loadend", () => {
+      this.dispatch("progress", { progress: 100 })
     })
+
+    requestAnimationFrame(updateProgress)
+  }
+
+  estimateResponseTime() {
+    // Base estimate: 1 second for small files, scaling up for larger files
+    const fileSize = this.file.size
+    const MB = 1024 * 1024
+
+    if (fileSize < MB) {
+      return 1000 // 1 second for files under 1MB
+    } else if (fileSize < 10 * MB) {
+      return 2000 // 2 seconds for files 1-10MB
+    } else {
+      return 3000 + (fileSize / MB * 50) // 3+ seconds for larger files
+    }
+  }
+
+  directUploadDidComplete(error, attributes, resolve, reject) {
+    if (error) {
+      this.dispatchError(error, reject)
+    } else {
+      resolve({
+        sgid: attributes.attachable_sgid,
+        url: this.createBlobUrl(attributes.signed_id, attributes.filename)
+      })
+      this.dispatch("end")
+    }
   }
 
   createBlobUrl(signedId, filename) {
@@ -35,6 +89,18 @@ export class AttachmentUpload {
       .replace(":filename", encodeURIComponent(filename))
   }
 
+  dispatch(name, detail = {}) {
+    detail.attachment = this.attachment
+    return dispatchEvent(this.element, `direct-upload:${name}`, { detail })
+  }
+
+  dispatchError(error, reject) {
+    const event = this.dispatch("error", { error })
+    if (!event.defaultPrevented) {
+      reject(error)
+    }
+  }
+
   get directUploadUrl() {
     return this.element.dataset.directUploadUrl
   }

data/app/javascript/actiontext/index.js

@@ -4,7 +4,16 @@ addEventListener("trix-attachment-add", event => {
   const { attachment, target } = event
 
   if (attachment.file) {
-    const upload = new AttachmentUpload(attachment, target)
+    const upload = new AttachmentUpload(attachment, target, attachment.file)
+    const onProgress = event => attachment.setUploadProgress(event.detail.progress)
+
+    target.addEventListener("direct-upload:progress", onProgress)
+
     upload.start()
+      .then(attributes => attachment.setAttributes(attributes))
+      .catch(error => alert(error))
+      .finally(() => target.removeEventListener("direct-upload:progress", onProgress))
   }
 })
+
+export { AttachmentUpload }

data/app/models/action_text/rich_text.rb

@@ -48,10 +48,13 @@ module ActionText
     ##
     # :method: embeds
     #
-    # Returns the `ActiveStorage::Blob`s of the embedded files.
+    # Returns the ActiveStorage::Attachment records from the embedded files.
+    #
+    # Attached ActiveStorage::Blob records are extracted from the `body`
+    # in a {before_validation}[rdoc-ref:ActiveModel::Validations::Callbacks::ClassMethods#before_validation] callback.
     has_many_attached :embeds
 
-    before_save do
+    before_validation do
       self.embeds = body.attachables.grep(ActiveStorage::Blob).uniq if body.present?
     end
 

data/lib/action_text/attribute.rb

@@ -41,13 +41,16 @@ module ActionText
       #     `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)
+      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}
@@ -56,12 +59,29 @@ module ActionText
           def #{name}?
             rich_text_#{name}.present?
           end
-
-          def #{name}=(body)
-            self.#{name}.body = body
-          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,

data/lib/action_text/content.rb

@@ -56,7 +56,7 @@ module ActionText
       @links ||= fragment.find_all("a[href]").map { |a| a["href"] }.uniq
     end
 
-    # Extracts +ActionText::Attachment+s from the HTML fragment:
+    # Extracts ActionText::Attachment objects from the HTML fragment:
     #
     #     attachable = ActiveStorage::Blob.first
     #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
@@ -78,7 +78,7 @@ module ActionText
       @gallery_attachments ||= attachment_galleries.flat_map(&:attachments)
     end
 
-    # Extracts +ActionText::Attachable+s from the HTML fragment:
+    # Extracts ActionText::Attachable objects from the HTML fragment:
     #
     #     attachable = ActiveStorage::Blob.first
     #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
@@ -123,10 +123,11 @@ module ActionText
     #     content.to_plain_text # => "safeunsafe"
     #
     # NOTE: that the returned string is not HTML safe and should not be rendered in
-    # browsers.
+    # browsers without additional sanitization.
     #
     #     content = ActionText::Content.new("&lt;script&gt;alert()&lt;/script&gt;")
     #     content.to_plain_text # => "<script>alert()</script>"
+    #     ActionText::ContentHelper.sanitizer.sanitize(content.to_plain_text) # => ""
     def to_plain_text
       render_attachments(with_full_attributes: false, &:to_plain_text).fragment.to_plain_text
     end

data/lib/action_text/engine.rb

@@ -8,6 +8,7 @@ require "active_record/railtie"
 require "active_storage/engine"
 
 require "action_text"
+require "action_text/trix"
 
 module ActionText
   class Engine < Rails::Engine
@@ -34,7 +35,7 @@ module ActionText
 
     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 )
+        Rails.application.config.assets.precompile += %w( actiontext.js actiontext.esm.js )
       end
     end
 
@@ -87,7 +88,9 @@ module ActionText
 
     config.after_initialize do |app|
       if klass = app.config.action_text.sanitizer_vendor
-        ActionText::ContentHelper.sanitizer = klass.safe_list_sanitizer.new
+        ActiveSupport.on_load(:action_view) do
+          ActionText::ContentHelper.sanitizer = klass.safe_list_sanitizer.new
+        end
       end
     end
   end

data/lib/action_text/fixture_set.rb

@@ -62,7 +62,7 @@ module ActionText
       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>)
+      %(<#{Attachment.tag_name} sgid="#{signed_global_id}"></#{Attachment.tag_name}>)
     end
   end
 end

data/lib/action_text/gem_version.rb

@@ -9,10 +9,10 @@ module ActionText
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
+    MAJOR = 8
+    MINOR = 1
     TINY  = 2
-    PRE   = "1"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_text/plain_text_conversion.rb

@@ -7,64 +7,70 @@ module ActionText
     extend self
 
     def node_to_plain_text(node)
-      remove_trailing_newlines(plain_text_for_node(node))
+      BottomUpReducer.new(node).reduce do |n, child_values|
+        plain_text_for_node(n, child_values)
+      end.then(&method(:remove_trailing_newlines))
     end
 
     private
-      def plain_text_for_node(node, index = 0)
+      def plain_text_for_node(node, child_values)
         if respond_to?(plain_text_method_for_node(node), true)
-          send(plain_text_method_for_node(node), node, index)
+          send(plain_text_method_for_node(node), node, child_values)
         else
-          plain_text_for_node_children(node)
+          plain_text_for_child_values(child_values)
         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"
+      def plain_text_for_child_values(child_values)
+        child_values.join
+      end
+
+      def plain_text_for_unsupported_node(node, _child_values)
+        ""
+      end
+
+      %i[ script style].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_unsupported_node
+      end
+
+      def plain_text_for_block(node, child_values)
+        "#{remove_trailing_newlines(plain_text_for_child_values(child_values))}\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))}"
+      def plain_text_for_list(node, child_values)
+        "#{break_if_nested_list(node, plain_text_for_block(node, child_values))}"
       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)
+      def plain_text_for_br_node(node, _child_values)
         "\n"
       end
 
-      def plain_text_for_text_node(node, index)
+      def plain_text_for_text_node(node, _child_values)
         remove_trailing_newlines(node.text)
       end
 
-      def plain_text_for_div_node(node, index)
-        "#{remove_trailing_newlines(plain_text_for_node_children(node))}\n"
+      def plain_text_for_div_node(node, child_values)
+        "#{remove_trailing_newlines(plain_text_for_child_values(child_values))}\n"
       end
 
-      def plain_text_for_figcaption_node(node, index)
-        "[#{remove_trailing_newlines(plain_text_for_node_children(node))}]"
+      def plain_text_for_figcaption_node(node, child_values)
+        "[#{remove_trailing_newlines(plain_text_for_child_values(child_values))}]"
       end
 
-      def plain_text_for_blockquote_node(node, index)
-        text = plain_text_for_block(node)
+      def plain_text_for_blockquote_node(node, child_values)
+        text = plain_text_for_block(node, child_values)
         return "“”" if text.blank?
 
         text = text.dup
@@ -73,9 +79,9 @@ module ActionText
         text
       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))
+      def plain_text_for_li_node(node, child_values)
+        bullet = bullet_for_li_node(node)
+        text = remove_trailing_newlines(plain_text_for_child_values(child_values))
         indentation = indentation_for_li_node(node)
 
         "#{indentation}#{bullet} #{text}\n"
@@ -85,8 +91,9 @@ module ActionText
         text.chomp("")
       end
 
-      def bullet_for_li_node(node, index)
+      def bullet_for_li_node(node)
         if list_node_name_for_li_node(node) == "ol"
+          index = node.parent.elements.index(node)
           "#{index + 1}."
         else
           "•"
@@ -115,5 +122,33 @@ module ActionText
           text
         end
       end
+
+      class BottomUpReducer # :nodoc:
+        def initialize(node)
+          @node = node
+          @values = {}
+        end
+
+        def reduce(&block)
+          traverse_bottom_up(@node) do |n|
+            child_values = @values.values_at(*n.children)
+            @values[n] = block.call(n, child_values)
+          end
+          @values[@node]
+        end
+
+        private
+          def traverse_bottom_up(node, &block)
+            call_stack, processing_stack = [ node ], []
+
+            until call_stack.empty?
+              node = call_stack.pop
+              processing_stack.push(node)
+              call_stack.concat node.children
+            end
+
+            processing_stack.reverse_each(&block)
+          end
+      end
   end
 end

data/lib/action_text/rendering.rb

@@ -2,7 +2,6 @@
 
 # :markup: markdown
 
-require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
 module ActionText

data/lib/action_text/system_test_helper.rb

@@ -7,52 +7,68 @@ module ActionText
     # 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
     #
+    # Additional options are forwarded to Capybara as filters
     #
     # Examples:
     #
     #     # <trix-editor id="message_content" ...></trix-editor>
-    #     fill_in_rich_text_area "message_content", with: "Hello <em>world!</em>"
+    #     fill_in_rich_textarea "message_content", with: "Hello <em>world!</em>"
     #
     #     # <trix-editor placeholder="Your message here" ...></trix-editor>
-    #     fill_in_rich_text_area "Your message here", with: "Hello <em>world!</em>"
+    #     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_text_area "Message content", with: "Hello <em>world!</em>"
+    #     fill_in_rich_textarea "Message content", with: "Hello <em>world!</em>"
     #
     #     # <trix-editor aria-label="Message content" ...></trix-editor>
-    #     fill_in_rich_text_area "Message content", with: "Hello <em>world!</em>"
+    #     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_text_area "message[content]", with: "Hello <em>world!</em>"
-    def fill_in_rich_text_area(locator = nil, with:)
-      find(:rich_text_area, locator).execute_script("this.editor.loadHTML(arguments[0])", with.to_s)
+    #     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(<<~JS, with.to_s)
+        if ("value" in this) {
+          this.value = arguments[0]
+        } else {
+          this.editor.loadHTML(arguments[0])
+        }
+      JS
     end
+    alias_method :fill_in_rich_text_area, :fill_in_rich_textarea
   end
 end
 
-Capybara.add_selector :rich_text_area 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)
+%i[rich_textarea rich_text_area].each do |rich_textarea|
+  Capybara.add_selector rich_textarea do
+    label "rich-text area"
+    xpath do |locator|
+      xpath = XPath.descendant[[
+        XPath.attribute(:role) == "textbox",
+        (XPath.attribute(:contenteditable) == "") | (XPath.attribute(:contenteditable) == "true")
+      ].reduce(:&)]
+
+      if locator.nil?
+        xpath
+      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)
+        xpath.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/generators/action_text/install/install_generator.rb

@@ -36,20 +36,8 @@ module ActionText
       end
 
       def create_actiontext_files
-        destination = Pathname(destination_root)
-
         template "actiontext.css", "app/assets/stylesheets/actiontext.css"
 
-        unless destination.join("app/assets/application.css").exist?
-          if (stylesheets = Dir.glob "#{destination_root}/app/assets/stylesheets/application.*.{scss,css}").length > 0
-            insert_into_file stylesheets.first.to_s, %(@import 'actiontext.css';)
-          else
-            say <<~INSTRUCTIONS, :green
-              To use the Trix editor, you must require 'app/assets/stylesheets/actiontext.css' in your base stylesheet.
-            INSTRUCTIONS
-          end
-        end
-
         gem_root = "#{__dir__}/../../../.."
 
         copy_file "#{gem_root}/app/views/active_storage/blobs/_blob.html.erb",
@@ -59,18 +47,6 @@ module ActionText
           "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