tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/app/helpers/action_text/tag_helper.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+require "action_view/helpers/tags/placeholderable"
+
+module ActionText
+  module TagHelper
+    cattr_accessor(:id, instance_accessor: false) { 0 }
+
+    # Returns a `trix-editor` tag that instantiates the Trix JavaScript editor as
+    # well as a hidden field that Trix will write to on changes, so the content will
+    # be sent on form submissions.
+    #
+    # #### Options
+    # *   `:class` - Defaults to "trix-content" so that default styles will be
+    #     applied. Setting this to a different value will prevent default styles
+    #     from being applied.
+    # *   `[:data][:direct_upload_url]` - Defaults to `rails_direct_uploads_url`.
+    # *   `[:data][:blob_url_template]` - Defaults to
+    #     `rails_service_blob_url(":signed_id", ":filename")`.
+    #
+    #
+    # #### Example
+    #
+    #     rich_textarea_tag "content", message.content
+    #     # <input type="hidden" name="content" id="trix_input_post_1">
+    #     # <trix-editor id="content" input="trix_input_post_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea_tag "content", nil do
+    #       "<h1>Default content</h1>"
+    #     end
+    #     # <input type="hidden" name="content" id="trix_input_post_1" value="&lt;h1&gt;Default content&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="trix_input_post_1" class="trix-content" ...></trix-editor>
+    def rich_textarea_tag(name, value = nil, options = {}, &block)
+      value = capture(&block) if value.nil? && block_given?
+      options = options.symbolize_keys
+      form = options.delete(:form)
+
+      options[:input] ||= "trix_input_#{ActionText::TagHelper.id += 1}"
+      options[:class] ||= "trix-content"
+
+      options[:data] ||= {}
+      options[:data][:direct_upload_url] ||= main_app.rails_direct_uploads_url
+      options[:data][:blob_url_template] ||= main_app.rails_service_blob_url(":signed_id", ":filename")
+
+      editor_tag = content_tag("trix-editor", "", options)
+      input_tag = hidden_field_tag(name, value.try(:to_trix_html) || value, id: options[:input], form: form)
+
+      input_tag + editor_tag
+    end
+    alias_method :rich_text_area_tag, :rich_textarea_tag
+  end
+end
+
+module ActionView::Helpers
+  class Tags::ActionText < Tags::Base
+    include Tags::Placeholderable
+
+    delegate :dom_id, to: ActionView::RecordIdentifier
+
+    def render(&block)
+      options = @options.stringify_keys
+      add_default_name_and_field(options)
+      options["input"] ||= dom_id(object, [options["id"], :trix_input].compact.join("_")) if object
+      html_tag = @template_object.rich_textarea_tag(options.delete("name"), options.fetch("value") { value }, options.except("value"), &block)
+      error_wrapping(html_tag)
+    end
+  end
+
+  module FormHelper
+    # Returns a `trix-editor` tag that instantiates the Trix JavaScript editor as
+    # well as a hidden field that Trix will write to on changes, so the content will
+    # be sent on form submissions.
+    #
+    # #### Options
+    # *   `:class` - Defaults to "trix-content" which ensures default styling is
+    #     applied.
+    # *   `:value` - Adds a default value to the HTML input tag.
+    # *   `[:data][:direct_upload_url]` - Defaults to `rails_direct_uploads_url`.
+    # *   `[:data][:blob_url_template]` - Defaults to
+    #     `rails_service_blob_url(":signed_id", ":filename")`.
+    #
+    #
+    # #### Example
+    #     rich_textarea :message, :content
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea :message, :content, value: "<h1>Default message</h1>"
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1" value="&lt;h1&gt;Default message&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea :message, :content do
+    #       "<h1>Default message</h1>"
+    #     end
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1" value="&lt;h1&gt;Default message&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    def rich_textarea(object_name, method, options = {}, &block)
+      Tags::ActionText.new(object_name, method, self, options).render(&block)
+    end
+    alias_method :rich_text_area, :rich_textarea
+  end
+
+  class FormBuilder
+    # Wraps ActionView::Helpers::FormHelper#rich_textarea for form builders:
+    #
+    #     <%= form_with model: @message do |f| %>
+    #       <%= f.rich_textarea :content %>
+    #     <% end %>
+    #
+    # Please refer to the documentation of the base helper for details.
+    def rich_textarea(method, options = {}, &block)
+      @template.rich_textarea(@object_name, method, objectify_options(options), &block)
+    end
+    alias_method :rich_text_area, :rich_textarea
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/app/javascript/actiontext/attachment_upload.js

@@ -0,0 +1,111 @@
+import { DirectUpload, dispatchEvent } from "@rails/activestorage"
+
+export class AttachmentUpload {
+  constructor(attachment, element, file = attachment.file) {
+    this.attachment = attachment
+    this.element = element
+    this.directUpload = new DirectUpload(file, this.directUploadUrl, this)
+    this.file = file
+  }
+
+  start() {
+    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 => {
+      // 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)
+    })
+  }
+
+  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)
+      }
+    }
+
+    // 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) {
+    return this.blobUrlTemplate
+      .replace(":signed_id", signedId)
+      .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
+  }
+
+  get blobUrlTemplate() {
+    return this.element.dataset.blobUrlTemplate
+  }
+}

data/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/app/javascript/actiontext/index.js

@@ -0,0 +1,19 @@
+import { AttachmentUpload } from "./attachment_upload"
+
+addEventListener("trix-attachment-add", event => {
+  const { attachment, target } = event
+
+  if (attachment.file) {
+    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/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/app/models/action_text/rich_text.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text RichText
+  #
+  # The RichText record holds the content produced by the Trix editor in a
+  # serialized `body` attribute. It also holds all the references to the embedded
+  # files, which are stored using Active Storage. This record is then associated
+  # with the Active Record model the application desires to have rich text content
+  # using the `has_rich_text` class method.
+  #
+  #     class Message < ActiveRecord::Base
+  #       has_rich_text :content
+  #     end
+  #
+  #     message = Message.create!(content: "<h1>Funny times!</h1>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<h1>Funny times!</h1>"
+  #     message.content.to_plain_text # => "Funny times!"
+  #
+  #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<div>safeunsafe</div>"
+  #     message.content.to_plain_text # => "safeunsafe"
+  class RichText < Record
+    ##
+    # :method: to_s
+    #
+    # Safely transforms RichText into an HTML String.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_s # => "<h1>Funny times!</h1>"
+    #
+    #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     message.content.to_s # => "<div>safeunsafe</div>"
+
+    serialize :body, coder: ActionText::Content
+    delegate :to_s, :nil?, to: :body
+
+    ##
+    # :method: record
+    #
+    # Returns the associated record.
+    belongs_to :record, polymorphic: true, touch: true
+
+    ##
+    # :method: embeds
+    #
+    # 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_validation do
+      self.embeds = body.attachables.grep(ActiveStorage::Blob).uniq if body.present?
+    end
+
+    # Returns a plain-text version of the markup contained by the `body` attribute,
+    # with tags removed but HTML entities encoded.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_plain_text # => "Funny times!"
+    #
+    # NOTE: that the returned string is not HTML safe and should not be rendered in
+    # browsers.
+    #
+    #     message = Message.create!(content: "&lt;script&gt;alert()&lt;/script&gt;")
+    #     message.content.to_plain_text # => "<script>alert()</script>"
+    def to_plain_text
+      body&.to_plain_text.to_s
+    end
+
+    # Returns the `body` attribute in a format that makes it editable in the Trix
+    # editor. Previews of attachments are rendered inline.
+    #
+    #     content = "<h1>Funny Times!</h1><figure data-trix-attachment='{\"sgid\":\"..."\}'></figure>"
+    #     message = Message.create!(content: content)
+    #     message.content.to_trix_html # =>
+    #     # <div class="trix-content">
+    #     #   <h1>Funny times!</h1>
+    #     #   <figure data-trix-attachment='{\"sgid\":\"..."\}'>
+    #     #      <img src="http://example.org/rails/active_storage/.../funny.jpg">
+    #     #   </figure>
+    #     # </div>
+    def to_trix_html
+      body&.to_trix_html
+    end
+
+    delegate :blank?, :empty?, :present?, to: :to_plain_text
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_rich_text, ActionText::RichText

data/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/lib/action_text/content.rb

@@ -0,0 +1,198 @@
+# 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 objects 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 objects 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 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
+
+    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/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/lib/action_text/engine.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_controller/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+
+require "action_text"
+require "action_text/trix"
+
+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 )
+      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
+        ActiveSupport.on_load(:action_view) do
+          ActionText::ContentHelper.sanitizer = klass.safe_list_sanitizer.new
+        end
+      end
+    end
+  end
+end