prosemirror 0.1.0 → 0.3.0

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,72 @@ 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
+
+    # Build a document from Markdown, with the parse rules of the schema's types. Needs the `commonmarker` gem.
+    def parse_markdown(markdown)
+      Document.new(HTMLParser.new(self).parse_element(Markdown::Builder.new.call(markdown)), schema: self)
+    end
+
+    # Build a document from plain text: blank lines separate paragraphs, and other line breaks become the
+    # schema's line break node, like `hard_break`, or spaces without one. Spaces are kept.
+    def parse_text(text)
+      paragraph = node_type(:paragraph) || @nodes.find { |type| textblock?(type) }
+      linebreak = @nodes.find(&:linebreak_replacement?)
+      separator = linebreak ? {"type" => linebreak.type_name.to_s} : {"type" => "text", "text" => " "}
+      blocks = UTF8.string(text).gsub(/\r\n?/, "\n").split(/\n[ \t]*\n/).map { |block| block.gsub(/\A\n+|\n+\z/, "") }
+      content = blocks.reject { |block| block.strip.empty? }.map do |block|
+        inline = block.split("\n").each_with_index.flat_map do |line, index|
+          [(separator if index.positive?), ({"type" => "text", "text" => line} unless line.empty?)].compact
+        end
+        {"type" => paragraph.type_name.to_s, "content" => inline}
+      end
+      parse({"type" => @top_node.to_s, "content" => content.empty? ? [{"type" => paragraph.type_name.to_s}] : content})
+    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 +243,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)

data/lib/prosemirror/type_definition.rb

@@ -18,14 +18,34 @@ module Prosemirror
       inherited_setting(:@aliases, [])
     end
 
-    # Declare an attribute. Same as Literal's `prop`, with two options:
+    # Declare an attribute. Same as Literal's `prop`, with these options:
     # - `json:` the attribute name in JSON, when it differs from the property name (`"textAlign"`);
-    # - `aliases:` other JSON names accepted on input (`["order"]`).
-    def prop(name, type, kind = :keyword, json: nil, aliases: [], **, &)
-      attribute_names[name] = {json: (json || name).to_s, aliases: aliases.map(&:to_s)}.freeze
+    # - `aliases:` other JSON names accepted on input (`["order"]`);
+    # - `parse_html:` a block reading the attribute from an HTML element, when importing HTML. By default,
+    #   the HTML attribute with the JSON name is read.
+    def prop(name, type, kind = :keyword, json: nil, aliases: [], parse_html: nil, **, &)
+      attribute_names[name] = {json: (json || name).to_s, aliases: aliases.map(&:to_s), parse_html:}.freeze
       super(name, type, kind, **, &)
     end
 
+    # Declare how to recognize this type in HTML. See ParseRule for the options. The block, if given, is the
+    # rule's `get_attrs`. A subclass that declares rules replaces the rules of its parent.
+    def parse_html(tag: nil, style: nil, **options, &get_attrs)
+      (@parse_rules ||= []) << ParseRule.new(type: self, tag:, style:, get_attrs:, **options)
+    end
+
+    def parse_rules
+      inherited_setting(:@parse_rules, [])
+    end
+
+    # The attributes read from an HTML element, by JSON name, without the missing ones.
+    def attrs_from_html(element)
+      attribute_names.each_value.with_object({}) do |names, attrs|
+        value = names[:parse_html] ? names[:parse_html].call(element) : element[names[:json]]
+        attrs[names[:json]] = value unless value.nil?
+      end
+    end
+
     def attribute_names
       @attribute_names ||= concrete_superclass ? concrete_superclass.attribute_names.dup : {}
     end
@@ -54,6 +74,16 @@ module Prosemirror
       end
     end
 
+    # Whether an attribute has no default, so that a node of this type can't be created empty.
+    def required_attrs?
+      literal_properties.any? { |property| !optional_attribute?(property) }
+    end
+
+    # The attributes of a node of this type created empty: the defaults.
+    def default_attrs
+      build_attrs({}, report: ->(_) {})
+    end
+
     # The JSON attributes this type doesn't declare, with String keys, so that `to_h` gives them back.
     def unknown_attrs(given)
       return {} unless given.is_a?(Hash)

data/lib/prosemirror/utf8.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Imported HTML, Markdown and text, as valid UTF-8.
+  module UTF8
+    module_function
+
+    # The value as a UTF-8 String: nil becomes empty, other encodings are read as UTF-8 (a binary string
+    # from a file or an HTTP body), and invalid bytes become U+FFFD, as browsers do.
+    def string(value)
+      string = value.to_s
+      string = string.dup.force_encoding(Encoding::UTF_8) unless string.encoding == Encoding::UTF_8
+      string.valid_encoding? ? string : string.scrub
+    end
+  end
+end

data/lib/prosemirror/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosemirror
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/prosemirror.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+# Phlex 2.4.1 checks attribute values against Date without loading it. Remove once a release includes the fix:
+# https://github.com/yippee-fun/phlex/issues/974
+require "date"
 require "json"
 require "literal"
 require "phlex"
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect("html_renderer" => "HTMLRenderer", "json_parser" => "JSONParser")
+loader.inflector.inflect(
+  "html" => "HTML", "html_parser" => "HTMLParser", "html_renderer" => "HTMLRenderer", "json_parser" => "JSONParser",
+  "utf8" => "UTF8"
+)
 loader.setup
 
 # Render ProseMirror and Tiptap documents.
@@ -35,5 +41,20 @@ module Prosemirror
     def parse(json, schema: self.schema)
       schema.parse(json)
     end
+
+    # Build a document from HTML, with the schema's parse rules. Needs the `herb` gem.
+    def from_html(html, schema: self.schema)
+      schema.parse_html(html)
+    end
+
+    # Build a document from Markdown, with the schema's parse rules. Needs the `commonmarker` gem.
+    def from_markdown(markdown, schema: self.schema)
+      schema.parse_markdown(markdown)
+    end
+
+    # Build a document from plain text: blank lines separate paragraphs, other line breaks become hard breaks.
+    def from_text(text, schema: self.schema)
+      schema.parse_text(text)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosemirror
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Hans Lemuet
@@ -64,14 +64,26 @@ files:
 - LICENSE.txt
 - README.md
 - ROADMAP.md
+- TYPES.md
 - lib/prosemirror.rb
 - lib/prosemirror/coerce.rb
 - lib/prosemirror/content_expression.rb
+- lib/prosemirror/content_match.rb
 - lib/prosemirror/document.rb
+- lib/prosemirror/html/builder.rb
+- lib/prosemirror/html/element.rb
+- lib/prosemirror/html/entities.rb
+- lib/prosemirror/html/entities.txt
+- lib/prosemirror/html/selector.rb
+- lib/prosemirror/html/splitter.rb
+- lib/prosemirror/html/text.rb
+- lib/prosemirror/html_parser.rb
 - lib/prosemirror/html_renderer.rb
 - lib/prosemirror/json_parser.rb
 - lib/prosemirror/mark.rb
 - lib/prosemirror/mark_type.rb
+- lib/prosemirror/markdown/builder.rb
+- lib/prosemirror/marks/basic/code.rb
 - lib/prosemirror/marks/basic/em.rb
 - lib/prosemirror/marks/basic/link.rb
 - lib/prosemirror/marks/basic/strong.rb
@@ -106,10 +118,12 @@ files:
 - lib/prosemirror/nodes/table_header.rb
 - lib/prosemirror/nodes/table_row.rb
 - lib/prosemirror/nodes/text.rb
+- lib/prosemirror/parse_rule.rb
 - lib/prosemirror/rendering.rb
 - lib/prosemirror/schema.rb
 - lib/prosemirror/text_serializer.rb
 - lib/prosemirror/type_definition.rb
+- lib/prosemirror/utf8.rb
 - lib/prosemirror/version.rb
 - sig/prosemirror.rbs
 homepage: https://github.com/etaminstudio/prosemirror