prosemirror 0.0.1 → 0.2.0

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    module Basic
+      # ProseMirror's image, an inline node. Without an allowed `src`, it renders nothing.
+      class Image < NodeType
+        group :inline
+        inline
+
+        prop :src, _String(length: 1..)
+        prop :alt, _String?
+        prop :title, _String?
+        parse_html tag: "img[src]"
+
+        def view_template
+          src = safe_url(@src)
+          img(src: src, alt: @alt, title: @title) if src
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    module Basic
+      # ProseMirror's ordered list. Tiptap's `start` attribute is read as `order`.
+      class OrderedList < NodeType
+        group :block, :list
+        content "list_item+"
+
+        prop :order, Integer, default: 1, aliases: ["start"],
+          parse_html: ->(element) { element.key?("start") ? element["start"].to_i : 1 }, &Coerce::INTEGER
+
+        parse_html tag: "ol"
+
+        def view_template(&)
+          ol(start: (@order unless @order == 1), &)
+        end
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/blockquote.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class Blockquote < NodeType
+      group :block
+      content "block+"
+      parse_html tag: "blockquote"
+
+      def view_template(&) = blockquote(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/bullet_list.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class BulletList < NodeType
+      group :block, :list
+      content "list_item+"
+      parse_html tag: "ul"
+
+      def view_template(&) = ul(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/code_block.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's code block. `prosemirror-markdown`'s `params` attribute is read as `language`.
+    class CodeBlock < NodeType
+      group :block
+      content "text*"
+      marks ""
+      code
+
+      # From the `language-*` class of the `<code>` inside `<pre>`.
+      prop :language, _String?(/\A[\w#+.-]+\z/), aliases: ["params"], parse_html: lambda { |element|
+        element.first_element_child&.classes&.find { |name| name.start_with?("language-") }&.delete_prefix("language-")
+      }
+
+      parse_html tag: "pre", preserve_whitespace: :full
+
+      def view_template(&)
+        pre { code(class: @language && "language-#{@language}", &) }
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/doc.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # The top node of a document. It renders its content only.
+    class Doc < NodeType
+      content "block+"
+    end
+  end
+end

data/lib/prosemirror/nodes/hard_break.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class HardBreak < NodeType
+      group :inline
+      inline
+      leaf_text "\n"
+      linebreak_replacement
+      parse_html tag: "br"
+
+      def view_template = br
+    end
+  end
+end

data/lib/prosemirror/nodes/heading.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class Heading < NodeType
+      group :block
+      content "inline*"
+
+      prop :level, _Integer(1..6), default: 1, &Coerce::INTEGER
+      (1..6).each { |level| parse_html tag: "h#{level}", attrs: {level:} }
+
+      def view_template(&) = tag(:"h#{@level}", &)
+    end
+  end
+end

data/lib/prosemirror/nodes/horizontal_rule.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class HorizontalRule < NodeType
+      group :block
+      parse_html tag: "hr"
+
+      def view_template = hr
+    end
+  end
+end

data/lib/prosemirror/nodes/image.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's image, a block node. Without an allowed `src`, it renders nothing.
+    class Image < NodeType
+      group :block
+
+      prop :src, _String(length: 1..)
+      prop :alt, _String?
+      prop :title, _String?
+      prop :width, _Integer?(1..), &Coerce::INTEGER
+      prop :height, _Integer?(1..), &Coerce::INTEGER
+      parse_html tag: %(img[src]:not([src^="data:"]))
+
+      def view_template
+        src = safe_url(@src)
+        img(src: src, alt: @alt, title: @title, width: @width, height: @height) if src
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/list_item.rb

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

data/lib/prosemirror/nodes/ordered_list.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's ordered list. ProseMirror's `order` attribute is read as `start`.
+    class OrderedList < NodeType
+      # CSS list styles, used by Google Docs and Word, and their `type`.
+      LIST_STYLE_TYPES = {
+        "upper-roman" => "I", "lower-roman" => "i", "upper-alpha" => "A", "upper-latin" => "A",
+        "lower-alpha" => "a", "lower-latin" => "a"
+      }.freeze
+
+      group :block, :list
+      content "list_item+"
+
+      prop :start, Integer, default: 1, aliases: ["order"],
+        parse_html: ->(element) { element.key?("start") ? element["start"].to_i : 1 }, &Coerce::INTEGER
+      prop :type, _Union?("1", "a", "A", "i", "I"), parse_html: ->(element) { OrderedList.type_from_html(element) }
+
+      parse_html tag: "ol"
+
+      # From the `type` attribute, or the list style of the list or of its first item.
+      def self.type_from_html(element)
+        element["type"] || list_style_type(element) || element.query("li")&.then { |item| list_style_type(item) }
+      end
+
+      def self.list_style_type(element)
+        LIST_STYLE_TYPES[element.style["list-style-type"].to_s.downcase]
+      end
+
+      def view_template(&)
+        ol(start: (@start unless @start == 1), type: @type, &)
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/paragraph.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class Paragraph < NodeType
+      group :block
+      content "inline*"
+      parse_html tag: "p"
+
+      def view_template(&) = p(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/table.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class Table < NodeType
+      group :block
+      content "table_row+"
+      parse_html tag: "table"
+
+      def view_template(&)
+        table { tbody(&) }
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/table_cell.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class TableCell < NodeType
+      ALIGNMENTS = %w[left right center].freeze
+
+      content "block+"
+
+      prop :colspan, _Integer(1..), default: 1, &Coerce::INTEGER
+      prop :rowspan, _Integer(1..), default: 1, &Coerce::INTEGER
+      prop :colwidth, _Array?(_Integer(1..)),
+        parse_html: ->(element) { element["colwidth"]&.split(",")&.map(&:to_i) }
+      # From the `text-align` style, or the old `align` attribute.
+      prop :align, _Union?(*ALIGNMENTS), parse_html: lambda { |element|
+        (element.style["text-align"] || element["align"]).to_s.strip.downcase.then { |value| value if ALIGNMENTS.include?(value) }
+      }
+
+      parse_html tag: "td"
+
+      def view_template(&)
+        td(**cell_attributes, &)
+      end
+
+      private
+
+      def cell_attributes
+        {colspan: (@colspan unless @colspan == 1), rowspan: (@rowspan unless @rowspan == 1),
+         style: @align && "text-align: #{@align}"}
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/table_header.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class TableHeader < TableCell
+      type_name :table_header
+
+      parse_html tag: "th"
+
+      def view_template(&)
+        th(**cell_attributes, &)
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/table_row.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class TableRow < NodeType
+      content "(table_cell | table_header)*"
+      parse_html tag: "tr"
+
+      def view_template(&) = tr(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/text.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Text. Text nodes are rendered by the renderer, not by this type.
+    class Text < NodeType
+      group :inline
+    end
+  end
+end

data/lib/prosemirror/parse_rule.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # How to recognize a node or a mark in HTML, as ProseMirror's ParseRule:
+  # https://prosemirror.net/docs/ref/#model.ParseRule
+  #
+  # - `tag`: a CSS selector the element must match (see HTML::Selector), or
+  # - `style`: a CSS property (`"font-style"`), or a property and value (`"font-style=italic"`), for marks;
+  # - `attrs`: attributes to give the node or mark;
+  # - `get_attrs`: a block called with the element (or the style's value), returning attributes, nil for
+  #   the defaults, or false when the rule doesn't match;
+  # - `priority` (default 50): rules with a higher priority are tried first;
+  # - `consuming` (default true): false lets the following rules match the element too;
+  # - `context`: the parents the rule needs, as `"list_item/"` or `"blockquote//"`;
+  # - `ignore`: skip the element and its content;
+  # - `skip`: skip the element, but parse its content;
+  # - `close_parent`: close the current node;
+  # - `content_element`: a selector for the descendant holding the content;
+  # - `get_content`: a block called with the element and the schema, returning the nodes to use as content;
+  # - `preserve_whitespace`: true to keep spaces, `:full` to also keep newlines;
+  # - `clear_mark`: for style rules, true to remove the type's marks, or a block called with each mark.
+  ParseRule = Data.define(
+    :type, :tag, :style, :attrs, :get_attrs, :priority, :consuming, :context, :ignore, :skip,
+    :close_parent, :content_element, :get_content, :preserve_whitespace, :clear_mark
+  ) do
+    def initialize(type:, tag: nil, style: nil, attrs: nil, get_attrs: nil, priority: 50, consuming: true,
+      context: nil, ignore: false, skip: false, close_parent: false, content_element: nil, get_content: nil,
+      preserve_whitespace: nil, clear_mark: nil)
+      raise ArgumentError, "a parse rule needs a tag or a style" if tag.nil? == style.nil?
+
+      HTML::Selector.parse(tag) if tag
+      super
+    end
+
+    def node?
+      type < NodeType
+    end
+
+    # The style's property, without the value.
+    def style_property
+      style&.split("=", 2)&.first
+    end
+
+    # Whether a style rule applies to this property and value.
+    def style_matches?(property, value)
+      name, expected = style.split("=", 2)
+      name == property && (expected.nil? || expected == value)
+    end
+  end
+end

data/lib/prosemirror/rendering.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Renders nodes and their marks. Included in the HTML renderer, and in node and mark types
+  # so that they can render any part of their content.
+  module Rendering
+    # Render a list of nodes with their marks. A mark shared by adjacent nodes is rendered once.
+    def render_content(nodes)
+      render_fragment(nodes, 0)
+    end
+
+    # The schema of the document being rendered.
+    def prosemirror_schema
+      @_prosemirror_schema
+    end
+
+    # The URL, when its scheme is allowed, after the schema's `resolve_url`. Otherwise nil.
+    def safe_url(url)
+      prosemirror_schema.safe_url(url)
+    end
+
+    private
+
+    def render_fragment(nodes, depth)
+      index = 0
+      while index < nodes.size
+        mark = nodes[index].marks[depth]
+        unless mark
+          render_node(nodes[index])
+          index += 1
+          next
+        end
+
+        last = last_index_with_mark(nodes, index, depth, mark)
+        render_marked(mark, nodes[index..last], depth)
+        index = last + 1
+      end
+    end
+
+    def last_index_with_mark(nodes, index, depth, mark)
+      return index unless prosemirror_schema.mark_type(mark.type)&.spanning?
+
+      index += 1 while index + 1 < nodes.size && nodes[index + 1].marks[depth] == mark
+      index
+    end
+
+    def render_marked(mark, nodes, depth)
+      mark_type = prosemirror_schema.mark_type(mark.type)
+      return render_fragment(nodes, depth + 1) unless mark_type
+
+      render(prepare(mark_type.new(**mark.attrs))) { render_fragment(nodes, depth + 1) }
+    end
+
+    def render_node(node)
+      return plain(node.text) if node.text?
+
+      node_type = prosemirror_schema.node_type(node.type)
+      return render_content(node.content) unless node_type
+
+      component = prepare(node_type.new(**node.attrs))
+      component.instance_variable_set(:@_prosemirror_node, node)
+      render(component) { render_content(node.content) }
+    end
+
+    def prepare(component)
+      component.instance_variable_set(:@_prosemirror_schema, prosemirror_schema)
+      component
+    end
+  end
+end