prosemirror 0.0.1 → 0.2.0

data/lib/prosemirror/json_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Builds nodes from ProseMirror JSON, and normalizes them as ProseMirror does:
+  # marks sorted in schema order, adjacent text with the same marks joined, empty text removed.
+  # Invalid parts are fixed and reported to the schema (which raises in strict mode).
+  class JSONParser
+    MAX_DEPTH = 100
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def parse(json)
+      hash = json.is_a?(String) ? JSON.parse(json, max_nesting: (MAX_DEPTH * 2) + 2) : json
+      raise ArgumentError, "expected a Hash or a JSON String, got #{json.class}" unless hash.is_a?(Hash)
+
+      root = build_node(hash, "doc", 0) || Node.new(type: @schema.top_node)
+      return root if root.type == @schema.top_node
+
+      @schema.report("the top node is #{root.type}, not #{@schema.top_node}", path: "doc")
+      Node.new(type: @schema.top_node, content: [root])
+    rescue JSON::NestingError
+      raise InvalidDocument, "the document is nested more than #{MAX_DEPTH} levels deep"
+    end
+
+    private
+
+    def build_node(hash, path, depth)
+      return invalid("not a node: #{hash.inspect}", path) unless hash.is_a?(Hash)
+      return invalid("nested more than #{MAX_DEPTH} levels deep", path) if depth > MAX_DEPTH
+
+      name = fetch(hash, "type")
+      return invalid("missing node type", path) unless name.is_a?(String) || name.is_a?(Symbol)
+      return build_text(hash, path) if name.to_s == "text"
+
+      node_type = @schema.node_type(name)
+      return build_unknown(hash, name, path, depth) unless node_type
+
+      given = fetch(hash, "attrs")
+      attrs = node_type.build_attrs(given, report: reporter(path))
+      return invalid("removed #{name} node", path) unless attrs
+
+      Node.new(type: node_type.type_name, attrs: attrs, unknown_attrs: node_type.unknown_attrs(given),
+        content: build_content(hash, path, depth), marks: build_marks(fetch(hash, "marks"), path))
+    end
+
+    def build_text(hash, path)
+      text = fetch(hash, "text")
+      return invalid("text node without text", path) unless text.is_a?(String)
+      return nil if text.empty?
+
+      Node.new(type: :text, text: text, marks: build_marks(fetch(hash, "marks"), path))
+    end
+
+    def build_unknown(hash, name, path, depth)
+      invalid("unknown node type #{name}", path)
+      attrs = fetch(hash, "attrs")
+      Node.new(type: Naming.snake(name), attrs: attrs.is_a?(Hash) ? attrs.transform_keys(&:to_sym) : {},
+        content: build_content(hash, path, depth), marks: build_marks(fetch(hash, "marks"), path))
+    end
+
+    def build_content(hash, path, depth)
+      content = fetch(hash, "content")
+      return [] if content.nil?
+      return invalid("content is not a list", path) || [] unless content.is_a?(Array)
+
+      nodes = content.each_with_index.filter_map do |child, index|
+        build_node(child, "#{path}.content[#{index}]", depth + 1)
+      end
+      Node.join_text(nodes)
+    end
+
+    def build_marks(marks, path)
+      return [] if marks.nil?
+      return invalid("marks is not a list", path) || [] unless marks.is_a?(Array)
+
+      built = marks.each_with_index.filter_map { |mark, index| build_mark(mark, "#{path}.marks[#{index}]") }
+      built.uniq.sort_by.with_index { |mark, index| [@schema.mark_rank(mark.type), index] }
+    end
+
+    def build_mark(hash, path)
+      return invalid("not a mark: #{hash.inspect}", path) unless hash.is_a?(Hash)
+
+      name = fetch(hash, "type")
+      return invalid("missing mark type", path) unless name.is_a?(String) || name.is_a?(Symbol)
+
+      mark_type = @schema.mark_type(name)
+      unless mark_type
+        invalid("unknown mark type #{name}", path)
+        attrs = fetch(hash, "attrs")
+        return Mark.new(type: Naming.snake(name), attrs: attrs.is_a?(Hash) ? attrs.transform_keys(&:to_sym) : {})
+      end
+
+      given = fetch(hash, "attrs")
+      attrs = mark_type.build_attrs(given, report: reporter(path))
+      return invalid("removed #{name} mark", path) unless attrs
+
+      Mark.new(type: mark_type.type_name, attrs: attrs, unknown_attrs: mark_type.unknown_attrs(given))
+    end
+
+    def fetch(hash, key)
+      hash.key?(key) ? hash[key] : hash[key.to_sym]
+    end
+
+    def reporter(path)
+      ->(message) { @schema.report(message, path: path) }
+    end
+
+    def invalid(message, path)
+      @schema.report(message, path: path)
+    end
+  end
+end

data/lib/prosemirror/mark.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A mark applied to a node, such as `bold` or `link`. Marks are immutable values.
+  #
+  #   mark in { type: :link, attrs: { href: } }
+  #
+  # As for nodes, `unknown_attrs` holds the attributes the mark's type doesn't declare.
+  class Mark < Literal::Data
+    prop :type, Symbol, &Coerce::SYMBOL
+    prop :attrs, _Hash(Symbol, _Any?), default: {}.freeze, &Coerce::FROZEN
+    prop :unknown_attrs, _Hash(String, _Any?), default: {}.freeze, &Coerce::FROZEN
+
+    # A copy with some properties changed.
+    def with(**changes)
+      self.class.new(**to_h, **changes)
+    end
+  end
+end

data/lib/prosemirror/mark_type.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # The base class of mark types. A mark type is a Phlex component: `view_template` renders one element
+  # and yields to render the marked content. Attributes are Literal properties.
+  #
+  #   class Bold < Prosemirror::MarkType
+  #     def view_template(&) = strong(&)
+  #   end
+  #
+  # The options follow ProseMirror's MarkSpec: https://prosemirror.net/docs/ref/#model.MarkSpec
+  class MarkType < Phlex::HTML
+    extend Literal::Properties
+    extend TypeDefinition
+    include Rendering
+
+    class << self
+      def base_type?
+        self == MarkType
+      end
+
+      # The marks this mark can't coexist with: mark or group names, `"_"` for all.
+      # Defaults to marks of the same type.
+      def excludes(spec = nil)
+        return @excludes = spec if spec
+
+        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?
+
+        inherited_setting(:@group, [])
+      end
+
+      # Whether one element can wrap several adjacent nodes with this mark. Defaults to true.
+      def spanning(value = nil)
+        return @spanning = value unless value.nil?
+
+        inherited_setting(:@spanning, true)
+      end
+
+      def spanning?
+        spanning
+      end
+
+      def code(value = true)
+        @code = value
+      end
+
+      def code?
+        inherited_setting(:@code, false)
+      end
+    end
+
+    def view_template
+      yield if block_given?
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    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
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    module Basic
+      # ProseMirror's link. Without an allowed `href`, its text is rendered without a link.
+      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)
+          return yield unless href
+
+          a(href: href, title: @title, &)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    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
+    end
+  end
+end

data/lib/prosemirror/marks/bold.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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
+end

data/lib/prosemirror/marks/code.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/prosemirror/marks/highlight.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    # Tiptap's highlight. `color` must be a hex, named, rgb() or hsl() color, so it is safe in a style.
+    class Highlight < MarkType
+      COLOR = %r{\A(\#\h{3,8}|[a-z]+|(rgb|hsl)a?\([\d\s.,%/]+\))\z}i
+
+      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", &)
+      end
+    end
+  end
+end

data/lib/prosemirror/marks/italic.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/prosemirror/marks/link.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    # Tiptap's link. Without an allowed `href`, its text is rendered without a link.
+    class Link < MarkType
+      prop :href, _String(length: 1..)
+      prop :target, _String?
+      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)
+        return yield unless href
+
+        a(href: href, target: @target, rel: @rel, class: @css_class, title: @title, &)
+      end
+    end
+  end
+end

data/lib/prosemirror/marks/strike.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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
+end

data/lib/prosemirror/marks/subscript.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/prosemirror/marks/superscript.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/prosemirror/marks/underline.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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
+end

data/lib/prosemirror/naming.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Converts names between snake_case (`bullet_list`) and camelCase (`bulletList`).
+  module Naming
+    module_function
+
+    def snake(name)
+      name.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').tr("-", "_").downcase
+    end
+
+    def camel(name)
+      snake(name).gsub(/_([a-z\d])/) { Regexp.last_match(1).upcase }
+    end
+  end
+end

data/lib/prosemirror/node.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A node of a document. Nodes are immutable values, and support pattern matching:
+  #
+  #   node in { type: :heading, attrs: { level: 1 } }
+  #
+  # Text nodes have the type `:text` and their content in `text`.
+  #
+  # `attrs` holds the attributes the node's type declares. `unknown_attrs` holds the others, as written
+  # in JSON (for example from a Tiptap extension the schema doesn't know): they are never rendered,
+  # and `to_h` gives them back unchanged.
+  class Node < Literal::Data
+    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
+
+    # 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)
+    end
+
+    def text?
+      @type == :text
+    end
+
+    def first_child
+      @content.first
+    end
+
+    def last_child
+      @content.last
+    end
+
+    def child_count
+      @content.size
+    end
+
+    # All text in this node and its descendants, joined without separators.
+    def text_content
+      return @text if text?
+
+      descendants.select(&:text?).map(&:text).join
+    end
+
+    # Iterate over all descendants, depth first, without the node itself.
+    def descendants
+      return enum_for(:descendants) unless block_given?
+
+      stack = @content.reverse
+      until stack.empty?
+        node = stack.pop
+        yield node
+        stack.concat(node.content.reverse)
+      end
+    end
+
+    def same_markup?(other)
+      @type == other.type && @attrs == other.attrs && @unknown_attrs == other.unknown_attrs && @marks == other.marks
+    end
+  end
+end

data/lib/prosemirror/node_type.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # The base class of node types. A node type is a Phlex component: `view_template` renders a node,
+  # and yields to render its content. Attributes are Literal properties, available as instance variables.
+  #
+  #   class Heading < Prosemirror::NodeType
+  #     group :block
+  #     content "inline*"
+  #     prop :level, _Integer(1..6), default: 1
+  #
+  #     def view_template(&) = tag(:"h#{@level}", &)
+  #   end
+  #
+  # The options follow ProseMirror's NodeSpec: https://prosemirror.net/docs/ref/#model.NodeSpec
+  class NodeType < Phlex::HTML
+    extend Literal::Properties
+    extend TypeDefinition
+    include Rendering
+
+    class << self
+      def base_type?
+        self == NodeType
+      end
+
+      # The content expression, such as `"block+"`. Nodes without one are leaves.
+      def content(expression = nil)
+        return @content = ContentExpression.new(expression) if expression
+
+        inherited_setting(:@content, nil)
+      end
+
+      # The groups this type belongs to, such as `:block` or `:inline`.
+      def group(*names)
+        return @group = names.flat_map { |n| n.to_s.split }.map(&:to_sym) unless names.empty?
+
+        inherited_setting(:@group, [])
+      end
+
+      def inline(value = true)
+        @inline = value
+      end
+
+      def inline?
+        inherited_setting(:@inline, false) || group.include?(:inline)
+      end
+
+      def block?
+        !inline?
+      end
+
+      def leaf?
+        content.nil?
+      end
+
+      # The marks allowed inside this node: mark or group names, `"_"` for all, `""` for none.
+      def marks(spec = nil)
+        return @marks = spec if spec
+
+        inherited_setting(:@marks, nil)
+      end
+
+      # `:pre` to keep whitespace when parsing. Implied by `code`.
+      def whitespace(value = nil)
+        return @whitespace = value if value
+
+        inherited_setting(:@whitespace, code? ? :pre : :normal)
+      end
+
+      def code(value = true)
+        @code = value
+      end
+
+      def code?
+        inherited_setting(:@code, false)
+      end
+
+      # The text of a leaf node in `to_text`, as a String or a block called with the node.
+      def leaf_text(text = nil, &block)
+        return @leaf_text = text || block if text || block
+
+        inherited_setting(:@leaf_text, nil)
+      end
+
+      def text_for(node)
+        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.
+    def node
+      @_prosemirror_node
+    end
+
+    # Render the node's content when no `view_template` is defined.
+    def view_template
+      yield if block_given?
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    module Basic
+      # ProseMirror's code block, without attributes.
+      class CodeBlock < NodeType
+        group :block
+        content "text*"
+        marks ""
+        code
+        parse_html tag: "pre", preserve_whitespace: :full
+
+        def view_template(&)
+          pre { code(&) }
+        end
+      end
+    end
+  end
+end