prosemirror 0.4.0 → 0.6.0

data/lib/prosemirror/marks/basic/strong.rb

@@ -10,6 +10,8 @@ module Prosemirror
         parse_html style: "font-weight=400", clear_mark: true
         parse_html(style: "font-weight") { |value| value.match?(Bold::BOLD) && {} }
 
+        markdown open: "**", close: "**", mixable: true, expel_enclosing_whitespace: true
+
         def view_template(&) = strong(&)
       end
     end

data/lib/prosemirror/marks/bold.rb

@@ -13,6 +13,8 @@ module Prosemirror
       parse_html style: "font-weight=400", clear_mark: true
       parse_html(style: "font-weight") { |value| value.match?(BOLD) && {} }
 
+      markdown open: "**", close: "**", mixable: true, expel_enclosing_whitespace: true
+
       def view_template(&) = strong(&)
     end
   end

data/lib/prosemirror/marks/code.rb

@@ -10,6 +10,8 @@ module Prosemirror
       parse_html tag: "code"
       parse_html tag: "tt"
 
+      markdown(**MarkdownSerializer::CODE)
+
       def view_template(&) = code(&)
     end
   end

data/lib/prosemirror/marks/italic.rb

@@ -9,6 +9,8 @@ module Prosemirror
       parse_html style: "font-style=normal", clear_mark: true
       parse_html style: "font-style=italic"
 
+      markdown open: "*", close: "*", mixable: true, expel_enclosing_whitespace: true
+
       def view_template(&) = em(&)
     end
   end

data/lib/prosemirror/marks/link.rb

@@ -11,6 +11,8 @@ module Prosemirror
       prop :title, _String?
       parse_html(tag: "a[href]") { |element, schema| schema.allowed_url?(element["href"]) && {} }
 
+      markdown(**MarkdownSerializer::LINK)
+
       def view_template(&)
         href = safe_url(@href)
         return yield unless href

data/lib/prosemirror/marks/strike.rb

@@ -8,6 +8,8 @@ module Prosemirror
       parse_html tag: "strike"
       parse_html(style: "text-decoration", consuming: false) { |value| value.include?("line-through") ? {} : false }
 
+      markdown open: "~~", close: "~~", mixable: true, expel_enclosing_whitespace: true
+
       def view_template(&) = s(&)
     end
   end

data/lib/prosemirror/node.rb

@@ -14,15 +14,30 @@ module Prosemirror
     # Whitespace, including non-breaking spaces.
     BLANK = /\A[[:space:]]*\z/
 
-    prop :type, Symbol, &Coerce::SYMBOL
-    prop :attrs, _Hash(Symbol, _Any?), default: {}.freeze, &Coerce::FROZEN
-    prop :unknown_attrs, _Hash(String, _Any?), default: {}.freeze, &Coerce::FROZEN
-    prop :content, _Array(Node), default: [].freeze, &Coerce::FROZEN
-    prop :marks, _Array(Mark), default: [].freeze, &Coerce::FROZEN
-    prop :text, _String?, &Coerce::FROZEN
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+
+    prop :type, Symbol
+    prop :attrs, _Hash(Symbol, _Any?), default: EMPTY_HASH
+    prop :unknown_attrs, _Hash(String, _Any?), default: EMPTY_HASH
+    prop :content, _Array(Node), default: EMPTY_ARRAY
+    prop :marks, _Array(Mark), default: EMPTY_ARRAY
+    prop :text, _String?
+
+    # The type as a Symbol, and frozen values. Done here rather than with Literal coercion blocks, which
+    # cost an `instance_exec` each, for each of the many nodes a document has.
+    def initialize(type:, attrs: EMPTY_HASH, unknown_attrs: EMPTY_HASH, content: EMPTY_ARRAY, marks: EMPTY_ARRAY, text: nil)
+      super(type: type.is_a?(String) ? type.to_sym : type, attrs: Coerce.frozen(attrs), unknown_attrs: Coerce.frozen(unknown_attrs),
+            content: Coerce.frozen(content), marks: Coerce.frozen(marks), text: Coerce.frozen(text))
+    end
 
     # The nodes with adjacent text nodes that have the same marks joined, as in ProseMirror.
     def self.join_text(nodes)
+      return nodes unless (1...nodes.size).any? do |index|
+        previous, node = nodes[index - 1], nodes[index]
+        previous.text? && node.text? && previous.marks == node.marks
+      end
+
       nodes.each_with_object([]) do |node, joined|
         previous = joined.last
         if previous&.text? && node.text? && previous.marks == node.marks

data/lib/prosemirror/node_type.rb

@@ -119,5 +119,18 @@ module Prosemirror
     def view_template
       yield if block_given?
     end
+
+    # Write the node as Markdown, with the MarkdownSerializer's methods. `parent` and `index` locate the node.
+    # By default, the content is written, as a block for block nodes.
+    def to_markdown(markdown, _parent, _index)
+      return if self.class.leaf?
+
+      if markdown.schema.textblock?(self.class)
+        markdown.render_inline(node)
+      else
+        markdown.render_content(node)
+      end
+      markdown.close_block(node) if self.class.block?
+    end
   end
 end

data/lib/prosemirror/nodes/basic/code_block.rb

@@ -14,6 +14,10 @@ module Prosemirror
         def view_template(&)
           pre { code(&) }
         end
+
+        def to_markdown(markdown, _parent, _index)
+          Nodes::CodeBlock.fenced(markdown, node, nil)
+        end
       end
     end
   end

data/lib/prosemirror/nodes/basic/image.rb

@@ -17,6 +17,10 @@ module Prosemirror
           src = safe_url(@src)
           img(src: src, alt: @alt, title: @title) if src
         end
+
+        def to_markdown(markdown, _parent, _index)
+          markdown.write(Nodes::Image.markdown_image(markdown, @src, @alt, @title))
+        end
       end
     end
   end

data/lib/prosemirror/nodes/basic/ordered_list.rb

@@ -16,6 +16,10 @@ module Prosemirror
         def view_template(&)
           ol(start: (@order unless @order == 1), &)
         end
+
+        def to_markdown(markdown, parent, index)
+          Nodes::OrderedList.numbered(markdown, node, @order, markdown.list_after_list?(parent, index) ? ")" : ".")
+        end
       end
     end
   end

data/lib/prosemirror/nodes/blockquote.rb

@@ -8,6 +8,10 @@ module Prosemirror
       parse_html tag: "blockquote"
 
       def view_template(&) = blockquote(&)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.wrap_block("> ", nil, node) { markdown.render_content(node) }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/bullet_list.rb

@@ -8,6 +8,21 @@ module Prosemirror
       parse_html tag: "ul"
 
       def view_template(&) = ul(&)
+
+      # `-` items, or `*` right after another bullet or task list, which would otherwise continue it.
+      def to_markdown(markdown, parent, index)
+        marker = self.class.marker(markdown, parent, index)
+        markdown.render_list(node, "  ") { marker }
+      end
+
+      # Bullet and task lists share markers.
+      def self.marker(markdown, parent, index)
+        after_list = markdown.list_after_list?(parent, index) do |sibling|
+          type = markdown.schema.node_type(sibling.type)
+          !type.nil? && (type <= BulletList || type <= TaskList)
+        end
+        after_list ? "* " : "- "
+      end
     end
   end
 end

data/lib/prosemirror/nodes/code_block.rb

@@ -19,6 +19,21 @@ module Prosemirror
       def view_template(&)
         pre { code(class: @language && "language-#{@language}", &) }
       end
+
+      def to_markdown(markdown, _parent, _index)
+        self.class.fenced(markdown, node, @language)
+      end
+
+      # A fenced code block, with a fence longer than any run of backticks in the code.
+      def self.fenced(markdown, node, language)
+        code = node.text_content
+        fence = "`" * [3, (code.scan(/`{3,}/).map(&:length).max || 0) + 1].max
+        markdown.write("#{fence}#{language}\n")
+        markdown.text(code, escape: false)
+        markdown.ensure_new_line
+        markdown.write(fence)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/details.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's details: a summary, and content shown when it's open. `open` is the attribute Tiptap keeps with
+    # `persist: true`.
+    class Details < NodeType
+      group :block
+      content "details_summary details_content"
+
+      prop :open, _Boolean, default: false, parse_html: ->(element) { element.key?("open") }
+      parse_html tag: "details"
+
+      def view_template(&) = details(open: @open, &)
+
+      # As HTML, which GitHub and Markdown import read, with the content in Markdown between blank lines.
+      def to_markdown(markdown, _parent, _index)
+        summary, content = node.content
+        markdown.text("<details#{" open" if @open}>\n#{markdown.node_html(summary)}", escape: false)
+        markdown.close_block(node)
+        markdown.render(content, node, 1)
+        markdown.text("</details>", escape: false)
+        markdown.close_block(node)
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/details_content.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class DetailsContent < NodeType
+      content "block+"
+      parse_html tag: %(div[data-type="detailsContent"])
+
+      def view_template(&) = div(data_type: "detailsContent", &)
+    end
+  end
+end

data/lib/prosemirror/nodes/details_summary.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class DetailsSummary < NodeType
+      content "text*"
+      parse_html tag: "summary"
+
+      def view_template(&) = summary(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/hard_break.rb

@@ -10,6 +10,11 @@ module Prosemirror
       parse_html tag: "br"
 
       def view_template = br
+
+      # A backslash before the newline, unless only line breaks follow.
+      def to_markdown(markdown, parent, index)
+        markdown.write("\\\n") if parent.content[(index + 1)..].any? { |sibling| sibling.type != node.type }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/heading.rb

@@ -10,6 +10,12 @@ module Prosemirror
       (1..6).each { |level| parse_html tag: "h#{level}", attrs: {level:} }
 
       def view_template(&) = tag(:"h#{@level}", &)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.write("#{"#" * @level} ")
+        markdown.render_inline(node, from_block_start: false)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/horizontal_rule.rb

@@ -7,6 +7,11 @@ module Prosemirror
       parse_html tag: "hr"
 
       def view_template = hr
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.write("---")
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/image.rb

@@ -17,6 +17,22 @@ module Prosemirror
         src = safe_url(@src)
         img(src: src, alt: @alt, title: @title, width: @width, height: @height) if src
       end
+
+      # `![alt](src "title")`, or HTML with `html: true` when it has dimensions. Images in a row share a line,
+      # as Markdown would give them back: in separate paragraphs, each would come back after an empty one.
+      def to_markdown(markdown, parent, index)
+        markdown.write(" ") if index.positive? && parent.content[index - 1].type == node.type
+        if markdown.html? && (@width || @height)
+          markdown.write(markdown.node_html(node))
+        else
+          markdown.write(self.class.markdown_image(markdown, @src, @alt, @title))
+        end
+        markdown.close_block(node) unless parent.content[index + 1]&.type == node.type
+      end
+
+      def self.markdown_image(markdown, src, alt, title)
+        "![#{markdown.esc(alt.to_s)}](#{markdown.url(src)}#{markdown.title(title)})"
+      end
     end
   end
 end

data/lib/prosemirror/nodes/list_item.rb

@@ -7,6 +7,10 @@ module Prosemirror
       parse_html tag: "li"
 
       def view_template(&) = li(&)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.render_content(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/mention.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's mention: `@label`, or `@id` without a label. `mentionSuggestionChar` is the character typed
+    # to insert it, `@` by default, which tells mentions of different kinds apart.
+    class Mention < NodeType
+      group :inline
+      inline
+
+      prop :id, _Union?(String, Integer), parse_html: ->(element) { element["data-id"] }
+      prop :label, _String?, parse_html: ->(element) { element["data-label"] }
+      prop :mention_suggestion_char, _String(length: 1..), default: "@", json: "mentionSuggestionChar",
+        parse_html: ->(element) { element["data-mention-suggestion-char"] }
+      leaf_text { |node| display_text(node.attrs) }
+      parse_html tag: %(span[data-type="mention"])
+
+      def view_template
+        span(data: {type: "mention", id: @id, label: @label, mention_suggestion_char: @mention_suggestion_char}) do
+          self.class.display_text(node.attrs)
+        end
+      end
+
+      # Its text, or with `html: true`, its HTML, which Markdown import reads back.
+      def to_markdown(markdown, _parent, _index)
+        if markdown.html?
+          markdown.write(markdown.node_html(node))
+        else
+          markdown.text(self.class.display_text(node.attrs))
+        end
+      end
+
+      def self.display_text(attrs) = "#{attrs[:mention_suggestion_char] || "@"}#{attrs[:label] || attrs[:id]}"
+    end
+  end
+end

data/lib/prosemirror/nodes/ordered_list.rb

@@ -31,6 +31,17 @@ module Prosemirror
       def view_template(&)
         ol(start: (@start unless @start == 1), type: @type, &)
       end
+
+      def to_markdown(markdown, parent, index)
+        self.class.numbered(markdown, node, @start, markdown.list_after_list?(parent, index) ? ")" : ".")
+      end
+
+      # Items numbered from `start`, with the numbers aligned. `)` instead of `.` keeps a list right after
+      # another ordered list apart from it.
+      def self.numbered(markdown, node, start, delimiter = ".")
+        width = (start + node.content.size - 1).to_s.length
+        markdown.render_list(node, " " * (width + 2)) { |index| "#{(start + index).to_s.rjust(width)}#{delimiter} " }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/paragraph.rb

@@ -8,6 +8,14 @@ module Prosemirror
       parse_html tag: "p"
 
       def view_template(&) = p(&)
+
+      # Markdown has no empty paragraphs: they are left out.
+      def to_markdown(markdown, _parent, _index)
+        return if node.content.empty?
+
+        markdown.render_inline(node)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/table.rb

@@ -10,6 +10,42 @@ module Prosemirror
       def view_template(&)
         table { tbody(&) }
       end
+
+      # A GitHub Flavored Markdown table: the first row is the header, and gives the columns' alignments. A
+      # cell's paragraphs, images and line breaks are joined with `<br>`, and its other blocks, like lists, are
+      # written as HTML, which Markdown import reads back with the herb gem.
+      def to_markdown(markdown, _parent, _index)
+        rows = node.content.map { |row| row.content.map { |cell| cell_markdown(markdown, cell) } }
+        columns = rows.map(&:size).max.to_i
+        return markdown.close_block(node) if columns.zero?
+
+        aligns = node.content.first.content.map { |cell| cell.attrs[:align] }
+        delimiter = Array.new(columns) do |index|
+          {"left" => ":--", "center" => ":-:", "right" => "--:"}.fetch(aligns[index].to_s, "---")
+        end
+        lines = [rows.first, delimiter, *rows.drop(1)].map do |cells|
+          "| #{Array.new(columns) { |index| cells[index].to_s }.join(" | ")} |"
+        end
+        markdown.text(lines.join("\n"), escape: false)
+        markdown.close_block(node)
+      end
+
+      private
+
+      def cell_markdown(markdown, cell)
+        parts = cell.content.map do |block|
+          type = markdown.schema.node_type(block.type)
+          if type && (type <= Paragraph || type <= Image)
+            serializer = MarkdownSerializer.new(markdown.schema, html: markdown.html?)
+            serializer.render(block, cell, 0)
+            serializer.out.strip.gsub(/\\\n|\n+/, "<br>")
+          else
+            markdown.node_html(block).gsub("\n", "&#10;")
+          end
+        end
+        # A space after a line break is dropped, as in HTML.
+        parts.join("<br>").gsub(/(?:<br>[[:space:]]*)+/, "<br>").delete_prefix("<br>").delete_suffix("<br>").gsub("|", "\\|")
+      end
     end
   end
 end

data/lib/prosemirror/nodes/task_item.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's task item, with its content in a `div` after the checkbox. Its content is Tiptap's with
+    # `nested: true`, which also accepts documents written without it.
+    class TaskItem < NodeType
+      content "paragraph block*"
+
+      # From Tiptap's `data-checked`, or the checkbox.
+      prop :checked, _Boolean, default: false, parse_html: lambda { |element|
+        if element.key?("data-checked")
+          ["", "true"].include?(element["data-checked"])
+        else
+          element.query(%(input[type="checkbox"]))&.key?("checked") || false
+        end
+      }
+
+      parse_html tag: %(li[data-type="taskItem"]), priority: 51, content_element: "div"
+      parse_html tag: "li.task-list-item", priority: 51, context: "task_list/"
+
+      def view_template(&)
+        li(data_checked: @checked.to_s, data_type: "taskItem") do
+          label do
+            input(type: "checkbox", checked: @checked)
+            span
+          end
+          div(&)
+        end
+      end
+
+      # `[x] ` before its content, without the space when its first paragraph is empty.
+      def to_markdown(markdown, _parent, _index)
+        markdown.write(@checked ? "[x]" : "[ ]")
+        markdown.write(" ") unless node.content.first&.content.to_a.empty?
+        markdown.render_content(node)
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/task_list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's task list. Also imported from GitHub's HTML, as commonmarker renders it, when every item has a
+    # checkbox.
+    class TaskList < NodeType
+      group :block, :list
+      content "task_item+"
+      parse_html tag: %(ul[data-type="taskList"]), priority: 51
+      parse_html(tag: "ul.contains-task-list", priority: 51) do |element|
+        element.element_children.all? { |item| item.matches?("li.task-list-item") } && {}
+      end
+
+      def view_template(&) = ul(data_type: "taskList", &)
+
+      # `- [x]` items. Its markers alternate with bullet lists', or Markdown would join them.
+      def to_markdown(markdown, parent, index)
+        marker = BulletList.marker(markdown, parent, index)
+        markdown.render_list(node, "  ") { marker }
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/text.rb

@@ -5,6 +5,10 @@ module Prosemirror
     # Text. Text nodes are rendered by the renderer, not by this type.
     class Text < NodeType
       group :inline
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.text(node.text, escape: !markdown.in_autolink)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/twitch.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Prosemirror
+  module Nodes
+    # Tiptap's Twitch embed. `src` is the URL of a video, clip or channel, rendered as an iframe of its embed
+    # URL. Without a Twitch URL, it renders nothing. Twitch only plays embeds on the domain named by `parent`:
+    # override `parent` in a subclass, as Tiptap's `parent` option, which defaults to `localhost`.
+    class Twitch < NodeType
+      # The URLs Tiptap accepts.
+      URL = %r{\A(?:https?://)?(?:www\.)?(?:twitch\.tv|clips\.twitch\.tv)/(?:videos/\d+|\w+/clip/[\w-]+|[\w-]+/?)?(?:\?.*)?\z}
+
+      group :block
+
+      prop :src, _String(length: 1..), parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:src) || element["src"] }
+      prop :width, _Integer?(1..), default: 640, &Coerce::INTEGER
+      prop :height, _Integer?(1..), default: 480, &Coerce::INTEGER
+      prop :autoplay, _Boolean, default: false, parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:autoplay) }
+      prop :muted, _Boolean, default: false, parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:muted) }
+      prop :time, _String?, parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:time) }
+
+      # Tiptap's markup, `<div data-twitch-video><iframe>`, or an iframe of a Twitch embed URL.
+      parse_html(tag: "iframe[src]") do |element|
+        (element.parent&.key?("data-twitch-video") || Twitch.from_embed_url(element["src"])) ? {} : false
+      end
+
+      def view_template
+        src = safe_url(self.class.embed_url(@src, parent:, autoplay: @autoplay, muted: @muted, time: @time))
+        return unless src
+
+        div(data_twitch_video: "") { iframe(src:, width: @width, height: @height, allowfullscreen: true) }
+      end
+
+      # The domain of the site the embed is on.
+      def parent = "localhost"
+
+      # The URL, as text that Markdown links. With `html: true`, the iframe.
+      def to_markdown(markdown, _parent, _index)
+        markdown.write(markdown.html? ? markdown.node_html(node) : "<#{markdown.url(@src)}>")
+        markdown.close_block(node)
+      end
+
+      # The video, clip or channel of a Twitch URL, as `[kind, id]`, or nil.
+      def self.identify(src)
+        return unless src.match?(URL)
+
+        path = src.split("?").first
+        if (clip = path[%r{clips\.twitch\.tv/([\w-]+)}, 1] || path[%r{twitch\.tv/[\w-]+/clip/([\w-]+)}, 1])
+          [:clip, clip]
+        elsif (video = path[%r{twitch\.tv/videos/(\d+)}, 1])
+          [:video, video]
+        elsif (channel = path[%r{twitch\.tv/([\w-]+)/?\z}, 1])
+          [:channel, channel]
+        end
+      end
+
+      # The embed URL, as Tiptap builds it, or nil.
+      def self.embed_url(src, parent:, autoplay: false, muted: false, time: nil)
+        kind, id = identify(src)
+        return unless kind
+
+        options = {"autoplay" => ("true" if autoplay), "muted" => ("true" if muted)}
+        query = if kind == :clip
+          {"clip" => id, "parent" => parent, **options}
+        else
+          {kind.to_s => id, "parent" => parent, "allowfullscreen" => "true", **options, "time" => (time if kind == :video)}
+        end
+        base = (kind == :clip) ? "https://clips.twitch.tv/embed" : "https://player.twitch.tv/"
+        "#{base}?#{URI.encode_www_form(query.compact)}"
+      end
+
+      # The URL and options of an embed URL, as Tiptap reads them, or nil.
+      def self.from_embed_url(url)
+        uri = URI.parse(url.to_s)
+        return unless uri.is_a?(URI::HTTP)
+
+        query = URI.decode_www_form(uri.query.to_s).to_h
+        src = case [uri.host.to_s.delete_prefix("www."), uri.path]
+        in ["player.twitch.tv", _]
+          if query["video"] then "https://www.twitch.tv/videos/#{query["video"]}"
+          elsif query["channel"] then "https://www.twitch.tv/#{query["channel"]}"
+          end
+        in ["clips.twitch.tv", "/embed"]
+          query["clip"]&.then { |clip| "https://clips.twitch.tv/#{clip}" }
+        else nil
+        end
+        {src:, autoplay: query["autoplay"] == "true", muted: query["muted"] == "true", time: query["time"]} if src&.match?(URL)
+      rescue URI::Error, ArgumentError
+        nil
+      end
+    end
+  end
+end