prosemirror 0.1.0 → 0.2.0

data/lib/prosemirror/mark_type.rb

@@ -27,6 +27,17 @@ module Prosemirror
         inherited_setting(:@excludes, nil)
       end
 
+      # Whether this mark can't coexist with marks of the other type.
+      def excludes?(other)
+        case excludes
+        when nil then other.type_name == type_name
+        when "_" then true
+        else
+          names = excludes.split.map(&:to_sym)
+          names.include?(other.type_name) || names.intersect?(other.group)
+        end
+      end
+
       def group(*names)
         return @group = names.flat_map { |n| n.to_s.split }.map(&:to_sym) unless names.empty?
 

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    module Basic
+      # ProseMirror's inline code, which can be combined with other marks.
+      class Code < MarkType
+        code
+
+        parse_html tag: "code"
+
+        def view_template(&) = code(&)
+      end
+    end
+  end
+end

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

@@ -5,6 +5,10 @@ module Prosemirror
     module Basic
       class Em < MarkType
         aliases :italic
+        parse_html tag: "i"
+        parse_html tag: "em"
+        parse_html style: "font-style=italic"
+        parse_html style: "font-style=normal", clear_mark: true
 
         def view_template(&) = em(&)
       end

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

@@ -7,6 +7,7 @@ module Prosemirror
       class Link < MarkType
         prop :href, _String(length: 1..)
         prop :title, _String?
+        parse_html(tag: "a[href]") { |element, schema| schema.allowed_url?(element["href"]) && {} }
 
         def view_template(&)
           href = safe_url(@href)

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

@@ -5,6 +5,10 @@ module Prosemirror
     module Basic
       class Strong < MarkType
         aliases :bold
+        parse_html tag: "strong"
+        parse_html(tag: "b") { |element| element.style["font-weight"] != "normal" && {} }
+        parse_html style: "font-weight=400", clear_mark: true
+        parse_html(style: "font-weight") { |value| value.match?(Bold::BOLD) && {} }
 
         def view_template(&) = strong(&)
       end

data/lib/prosemirror/marks/bold.rb

@@ -3,8 +3,16 @@
 module Prosemirror
   module Marks
     class Bold < MarkType
+      # The `font-weight` values that mean bold.
+      BOLD = /\A(bold(er)?|[5-9]\d{2,})\z/
+
       aliases :strong
 
+      parse_html tag: "strong"
+      parse_html(tag: "b") { |element| element.style["font-weight"] != "normal" && {} }
+      parse_html style: "font-weight=400", clear_mark: true
+      parse_html(style: "font-weight") { |value| value.match?(BOLD) && {} }
+
       def view_template(&) = strong(&)
     end
   end

data/lib/prosemirror/marks/code.rb

@@ -2,8 +2,13 @@
 
 module Prosemirror
   module Marks
+    # Tiptap's inline code, which can't be combined with other marks.
     class Code < MarkType
       code
+      excludes "_"
+
+      parse_html tag: "code"
+      parse_html tag: "tt"
 
       def view_template(&) = code(&)
     end

data/lib/prosemirror/marks/highlight.rb

@@ -6,7 +6,9 @@ module Prosemirror
     class Highlight < MarkType
       COLOR = %r{\A(\#\h{3,8}|[a-z]+|(rgb|hsl)a?\([\d\s.,%/]+\))\z}i
 
-      prop :color, _String?(COLOR)
+      prop :color, _String?(COLOR), parse_html: ->(element) { element["data-color"] || element.style["background-color"] }
+
+      parse_html tag: "mark"
 
       def view_template(&)
         mark(data_color: @color, style: @color && "background-color: #{@color}; color: inherit", &)

data/lib/prosemirror/marks/italic.rb

@@ -4,6 +4,10 @@ module Prosemirror
   module Marks
     class Italic < MarkType
       aliases :em
+      parse_html tag: "em"
+      parse_html(tag: "i") { |element| element.style["font-style"] != "normal" && {} }
+      parse_html style: "font-style=normal", clear_mark: true
+      parse_html style: "font-style=italic"
 
       def view_template(&) = em(&)
     end

data/lib/prosemirror/marks/link.rb

@@ -9,6 +9,7 @@ module Prosemirror
       prop :rel, _String?
       prop :css_class, _String?, json: "class"
       prop :title, _String?
+      parse_html(tag: "a[href]") { |element, schema| schema.allowed_url?(element["href"]) && {} }
 
       def view_template(&)
         href = safe_url(@href)

data/lib/prosemirror/marks/strike.rb

@@ -3,6 +3,11 @@
 module Prosemirror
   module Marks
     class Strike < MarkType
+      parse_html tag: "s"
+      parse_html tag: "del"
+      parse_html tag: "strike"
+      parse_html(style: "text-decoration", consuming: false) { |value| value.include?("line-through") ? {} : false }
+
       def view_template(&) = s(&)
     end
   end

data/lib/prosemirror/marks/subscript.rb

@@ -4,6 +4,8 @@ module Prosemirror
   module Marks
     class Subscript < MarkType
       excludes "superscript"
+      parse_html tag: "sub"
+      parse_html(style: "vertical-align") { |value| (value == "sub") ? {} : false }
 
       def view_template(&) = sub(&)
     end

data/lib/prosemirror/marks/superscript.rb

@@ -4,6 +4,8 @@ module Prosemirror
   module Marks
     class Superscript < MarkType
       excludes "subscript"
+      parse_html tag: "sup"
+      parse_html(style: "vertical-align") { |value| (value == "super") ? {} : false }
 
       def view_template(&) = sup(&)
     end

data/lib/prosemirror/marks/underline.rb

@@ -3,6 +3,9 @@
 module Prosemirror
   module Marks
     class Underline < MarkType
+      parse_html tag: "u"
+      parse_html(style: "text-decoration", consuming: false) { |value| value.include?("underline") ? {} : false }
+
       def view_template(&) = u(&)
     end
   end

data/lib/prosemirror/node.rb

@@ -18,6 +18,18 @@ module Prosemirror
     prop :marks, _Array(Mark), default: [].freeze, &Coerce::FROZEN
     prop :text, _String?, &Coerce::FROZEN
 
+    # The nodes with adjacent text nodes that have the same marks joined, as in ProseMirror.
+    def self.join_text(nodes)
+      nodes.each_with_object([]) do |node, joined|
+        previous = joined.last
+        if previous&.text? && node.text? && previous.marks == node.marks
+          joined[-1] = previous.with(text: previous.text + node.text)
+        else
+          joined << node
+        end
+      end
+    end
+
     # A copy with some properties changed.
     def with(**changes)
       self.class.new(**to_h, **changes)

data/lib/prosemirror/node_type.rb

@@ -86,6 +86,28 @@ module Prosemirror
         value = leaf_text
         value.respond_to?(:call) ? value.call(node).to_s : value.to_s
       end
+
+      # This inline node stands for a newline, as ProseMirror's `linebreakReplacement`: when importing
+      # HTML whose whitespace is preserved, newlines become nodes of this type.
+      def linebreak_replacement(value = true)
+        @linebreak_replacement = value
+      end
+
+      def linebreak_replacement?
+        inherited_setting(:@linebreak_replacement, false)
+      end
+
+      # Whether marks of this type can be applied inside this node, according to its `marks` option.
+      def allows_mark?(mark_type, schema)
+        case marks
+        when nil then schema.content_match(self).inline_content?
+        when "_" then true
+        when "" then false
+        else
+          names = marks.split.map(&:to_sym)
+          names.include?(mark_type.type_name) || names.intersect?(mark_type.group)
+        end
+      end
     end
 
     # The node being rendered.

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

@@ -9,6 +9,7 @@ module Prosemirror
         content "text*"
         marks ""
         code
+        parse_html tag: "pre", preserve_whitespace: :full
 
         def view_template(&)
           pre { code(&) }

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

@@ -11,6 +11,7 @@ module Prosemirror
         prop :src, _String(length: 1..)
         prop :alt, _String?
         prop :title, _String?
+        parse_html tag: "img[src]"
 
         def view_template
           src = safe_url(@src)

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

@@ -8,7 +8,10 @@ module Prosemirror
         group :block, :list
         content "list_item+"
 
-        prop :order, Integer, default: 1, aliases: ["start"], &Coerce::INTEGER
+        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), &)

data/lib/prosemirror/nodes/blockquote.rb

@@ -5,6 +5,7 @@ module Prosemirror
     class Blockquote < NodeType
       group :block
       content "block+"
+      parse_html tag: "blockquote"
 
       def view_template(&) = blockquote(&)
     end

data/lib/prosemirror/nodes/bullet_list.rb

@@ -5,6 +5,7 @@ module Prosemirror
     class BulletList < NodeType
       group :block, :list
       content "list_item+"
+      parse_html tag: "ul"
 
       def view_template(&) = ul(&)
     end

data/lib/prosemirror/nodes/code_block.rb

@@ -9,7 +9,12 @@ module Prosemirror
       marks ""
       code
 
-      prop :language, _String?(/\A[\w#+.-]+\z/), aliases: ["params"]
+      # 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}", &) }

data/lib/prosemirror/nodes/hard_break.rb

@@ -6,6 +6,8 @@ module Prosemirror
       group :inline
       inline
       leaf_text "\n"
+      linebreak_replacement
+      parse_html tag: "br"
 
       def view_template = br
     end

data/lib/prosemirror/nodes/heading.rb

@@ -7,6 +7,7 @@ module Prosemirror
       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

data/lib/prosemirror/nodes/horizontal_rule.rb

@@ -4,6 +4,7 @@ module Prosemirror
   module Nodes
     class HorizontalRule < NodeType
       group :block
+      parse_html tag: "hr"
 
       def view_template = hr
     end

data/lib/prosemirror/nodes/image.rb

@@ -11,6 +11,7 @@ module Prosemirror
       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)

data/lib/prosemirror/nodes/list_item.rb

@@ -4,6 +4,7 @@ module Prosemirror
   module Nodes
     class ListItem < NodeType
       content "paragraph block*"
+      parse_html tag: "li"
 
       def view_template(&) = li(&)
     end

data/lib/prosemirror/nodes/ordered_list.rb

@@ -4,11 +4,29 @@ 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"], &Coerce::INTEGER
-      prop :type, _Union?("1", "a", "A", "i", "I")
+      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, &)

data/lib/prosemirror/nodes/paragraph.rb

@@ -5,6 +5,7 @@ module Prosemirror
     class Paragraph < NodeType
       group :block
       content "inline*"
+      parse_html tag: "p"
 
       def view_template(&) = p(&)
     end

data/lib/prosemirror/nodes/table.rb

@@ -5,6 +5,7 @@ module Prosemirror
     class Table < NodeType
       group :block
       content "table_row+"
+      parse_html tag: "table"
 
       def view_template(&)
         table { tbody(&) }

data/lib/prosemirror/nodes/table_cell.rb

@@ -3,11 +3,20 @@
 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..))
+      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, &)
@@ -16,7 +25,8 @@ module Prosemirror
       private
 
       def cell_attributes
-        {colspan: (@colspan unless @colspan == 1), rowspan: (@rowspan unless @rowspan == 1)}
+        {colspan: (@colspan unless @colspan == 1), rowspan: (@rowspan unless @rowspan == 1),
+         style: @align && "text-align: #{@align}"}
       end
     end
   end

data/lib/prosemirror/nodes/table_header.rb

@@ -5,6 +5,8 @@ module Prosemirror
     class TableHeader < TableCell
       type_name :table_header
 
+      parse_html tag: "th"
+
       def view_template(&)
         th(**cell_attributes, &)
       end

data/lib/prosemirror/nodes/table_row.rb

@@ -4,6 +4,7 @@ module Prosemirror
   module Nodes
     class TableRow < NodeType
       content "(table_cell | table_header)*"
+      parse_html tag: "tr"
 
       def view_template(&) = tr(&)
     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/schema.rb

@@ -32,8 +32,9 @@ module Prosemirror
           Nodes::OrderedList, Nodes::ListItem, Nodes::CodeBlock, Nodes::HardBreak, Nodes::HorizontalRule,
           Nodes::Image, Nodes::Table, Nodes::TableRow, Nodes::TableHeader, Nodes::TableCell
         ],
+        # In Tiptap's order, which sorts and nests marks.
         marks: [
-          Marks::Link, Marks::Bold, Marks::Italic, Marks::Underline, Marks::Strike, Marks::Code,
+          Marks::Link, Marks::Bold, Marks::Code, Marks::Italic, Marks::Strike, Marks::Underline,
           Marks::Subscript, Marks::Superscript, Marks::Highlight
         ],
         **
@@ -48,7 +49,7 @@ module Prosemirror
           Nodes::Basic::CodeBlock, Nodes::Text, Nodes::Basic::Image, Nodes::HardBreak, Nodes::Basic::OrderedList,
           Nodes::BulletList, Nodes::ListItem
         ],
-        marks: [Marks::Basic::Link, Marks::Basic::Em, Marks::Basic::Strong, Marks::Code],
+        marks: [Marks::Basic::Link, Marks::Basic::Em, Marks::Basic::Strong, Marks::Basic::Code],
         **
       )
     end
@@ -57,9 +58,32 @@ module Prosemirror
       @node_lookup = lookup(@nodes)
       @mark_lookup = lookup(@marks)
       @textblocks = @nodes.to_h { |type| [type, textblock_type?(type)] }
+      @content_matches = @nodes.to_h { |type| [type, ContentMatch.compile(type.content, self)] }
       raise ArgumentError, "the schema has no #{@top_node} node type" unless node_type(@top_node)
     end
 
+    # The start state of a node type's content expression.
+    def content_match(type)
+      @content_matches.fetch(type)
+    end
+
+    # The node types with this name or in this group, in schema order.
+    def node_types_named(name)
+      @nodes.select { |type| type.type_name == name || type.group.include?(name) }
+    end
+
+    # A node of this type, created empty and filled with the content it requires, or nil when its
+    # type, or one it requires, has required attributes.
+    def create_and_fill(type)
+      return nil if type.required_attrs?
+
+      fill = content_match(type).fill_before([], self, to_end: true)
+      content = fill&.map { |child| create_and_fill(child) }
+      return nil if content.nil? || content.include?(nil)
+
+      Node.new(type: type.type_name, attrs: type.default_attrs, content: content)
+    end
+
     # A copy of the schema with other options.
     def with_options(**)
       self.class.new(**to_h, **)
@@ -88,11 +112,51 @@ module Prosemirror
       Document.new(JSONParser.new(self).parse(json), schema: self)
     end
 
+    # Build a document from HTML, with the parse rules of the schema's types. Needs the `herb` gem.
+    def parse_html(html)
+      Document.new(HTMLParser.new(self).parse(html), schema: self)
+    end
+
     # The type name as written in JSON.
     def json_type_name(name)
       (@case == :camel) ? Naming.camel(name) : name.to_s
     end
 
+    # The set of marks with this mark added, in schema order, as ProseMirror's `Mark#addToSet`: a mark
+    # replaces the marks it excludes, and isn't added when a mark of the set excludes it.
+    def add_mark(mark, set)
+      type = mark_type(mark.type)
+      result = []
+      placed = false
+      set.each do |other|
+        return set if other == mark
+
+        other_type = mark_type(other.type)
+        next if type.excludes?(other_type)
+        return set if other_type.excludes?(type)
+
+        if !placed && mark_rank(other.type) > mark_rank(mark.type)
+          result << mark
+          placed = true
+        end
+        result << other
+      end
+      result << mark unless placed
+      result
+    end
+
+    # Whether a URL's scheme is allowed, or the URL is relative. Browsers ignore leading control characters
+    # and spaces, and tabs and newlines anywhere in a URL.
+    def allowed_url?(url)
+      return false unless url.is_a?(String)
+
+      normalized = url.delete("\t\n\r").sub(/\A[\x00-\x20]+/, "")
+      scheme = normalized[%r{\A([^/?#]*):}, 1]
+      return true if scheme.nil?
+
+      scheme.match?(/\A[a-z][a-z\d+.-]*\z/i) && @url_schemes.include?(scheme.downcase)
+    end
+
     # The order of marks in a node. Marks of unknown types come last.
     def mark_rank(name)
       @marks.index(mark_type(name)) || @marks.size
@@ -158,19 +222,6 @@ module Prosemirror
       end
     end
 
-    def node_types_named(name)
-      @nodes.select { |type| type.type_name == name || type.group.include?(name) }
-    end
-
-    # Browsers ignore leading control characters and spaces, and tabs and newlines anywhere in a URL.
-    def allowed_url?(url)
-      normalized = url.delete("\t\n\r").sub(/\A[\x00-\x20]+/, "")
-      scheme = normalized[%r{\A([^/?#]*):}, 1]
-      return true if scheme.nil?
-
-      scheme.match?(/\A[a-z][a-z\d+.-]*\z/i) && @url_schemes.include?(scheme.downcase)
-    end
-
     # Declared attributes with their JSON names, then the unknown ones, as they were.
     def serialize_node_attrs(node)
       type = node_type(node.type)