class ActionText::Content

body.to_plain_text # => “Funny times!”
body.to_s # => “<h1>Funny times!</h1>”
body = message.content.body # => #<ActionText::Content “<div class="trix-conte…”>
message = Message.create!(content: “<h1>Funny times!</h1>”)
end
has_rich_text :content
class Message < ActiveRecord::Base
`ActionText::Content`.
The ActionText::RichText record serializes the ‘body` attribute as
the database.
attachments, convert the fragment to plain text, or serialize the fragment to
parsing, rendering and serialization. It can be used to extract links and
The `ActionText::Content` class wraps an HTML fragment to add support for
# Action Text Content

def ==(other) 

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

def append_attachables(attachables) 

def append_attachables(attachables)
  attachments = ActionText::Attachment.from_attachables(attachables)
  self.class.new([self.to_s.presence, *attachments].compact.join("\n"))
end

def as_json(*) 

def as_json(*)
  to_html
end

def attachables

content.attachables # => [attachable]
content = ActionText::Content.new(html)
html = %Q()
attachable = ActiveStorage::Blob.first

Extracts +ActionText::Attachable+s from the HTML fragment: 
def attachables
  @attachables ||= attachment_nodes.map do |node|
    ActionText::Attachable.from_node(node)
  end
end

def attachment_for_node(node, with_full_attributes: true) 

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_galleries 

def attachment_galleries
  @attachment_galleries ||= attachment_gallery_nodes.map do |node|
    attachment_gallery_for_node(node)
  end
end

def attachment_gallery_for_node(node) 

def attachment_gallery_for_node(node)
  ActionText::AttachmentGallery.from_node(node)
end

def attachment_gallery_nodes 

def attachment_gallery_nodes
  @attachment_gallery_nodes ||= ActionText::AttachmentGallery.find_attachment_gallery_nodes(fragment)
end

def attachment_nodes 

def attachment_nodes
  @attachment_nodes ||= fragment.find_all(ActionText::Attachment.tag_name)
end

def attachments

content.attachments # => [#content = ActionText::Content.new(html)
html = %Q()
attachable = ActiveStorage::Blob.first

Extracts +ActionText::Attachment+s from the HTML fragment: 
def attachments
  @attachments ||= attachment_nodes.map do |node|
    attachment_for_node(node)
  end
end

def fragment_by_canonicalizing_content(content) 

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

def gallery_attachments 

def gallery_attachments
  @gallery_attachments ||= attachment_galleries.flat_map(&:attachments)
end

def initialize(content = nil, options = {}) 

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

def inspect 

def inspect
  "#<#{self.class.name} #{to_html.truncate(25).inspect}>"
end

def links

content.links # => ["http://example.com/"]
content = ActionText::Content.new(html)
html = 'Example'

Extracts links from the HTML fragment: 
def links
  @links ||= fragment.find_all("a[href]").map { |a| a["href"] }.uniq
end

def render_attachment_galleries(&block) 

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

def render_attachments(**options, &block) 

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 to_html 

def to_html
  fragment.to_html
end

def to_partial_path 

def to_partial_path
  "action_text/contents/content"
end

def to_plain_text

content.to_plain_text # => ""
content = ActionText::Content.new("<script>alert()</script>")

browsers.
NOTE: that the returned string is not HTML safe and should not be rendered in

content.to_plain_text # => "safeunsafe"
content = ActionText::Content.new("
safe
")

content.to_plain_text # => "Funny times!"
content = ActionText::Content.new("

Funny times!

")

removed but HTML entities encoded.
Returns a plain-text version of the markup contained by the content, with tags 
def to_plain_text
  render_attachments(with_full_attributes: false, &:to_plain_text).fragment.to_plain_text
end

def to_rendered_html_with_layout 

def to_rendered_html_with_layout
  render layout: "action_text/contents/content", partial: to_partial_path, formats: :html, locals: { content: self }
end

def to_s

content.to_s # => "
safeunsafe
"
content = ActionText::Content.new("
safe
")

content.to_s # => "

Funny times!

"
content = ActionText::Content.new(content: "

Funny times!

")

Safely transforms Content into an HTML String. 
def to_s
  to_rendered_html_with_layout
end

def to_trix_html 

def to_trix_html
  render_attachments(&:to_trix_attachment).to_html
end