prosemirror 0.0.1 → 0.1.0

data/lib/prosemirror/node_type.rb

@@ -0,0 +1,101 @@
+# 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
+    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,19 @@
+# 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
+
+        def view_template(&)
+          pre { code(&) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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?
+
+        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,19 @@
+# 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"], &Coerce::INTEGER
+
+        def view_template(&)
+          ol(start: (@order unless @order == 1), &)
+        end
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/blockquote.rb

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

data/lib/prosemirror/nodes/bullet_list.rb

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

data/lib/prosemirror/nodes/code_block.rb

@@ -0,0 +1,19 @@
+# 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
+
+      prop :language, _String?(/\A[\w#+.-]+\z/), aliases: ["params"]
+
+      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,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class HardBreak < NodeType
+      group :inline
+      inline
+      leaf_text "\n"
+
+      def view_template = br
+    end
+  end
+end

data/lib/prosemirror/nodes/heading.rb

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

data/lib/prosemirror/nodes/horizontal_rule.rb

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

data/lib/prosemirror/nodes/image.rb

@@ -0,0 +1,21 @@
+# 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
+
+      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,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class ListItem < NodeType
+      content "paragraph block*"
+
+      def view_template(&) = li(&)
+    end
+  end
+end

data/lib/prosemirror/nodes/ordered_list.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    # Tiptap's ordered list. ProseMirror's `order` attribute is read as `start`.
+    class OrderedList < NodeType
+      group :block, :list
+      content "list_item+"
+
+      prop :start, Integer, default: 1, aliases: ["order"], &Coerce::INTEGER
+      prop :type, _Union?("1", "a", "A", "i", "I")
+
+      def view_template(&)
+        ol(start: (@start unless @start == 1), type: @type, &)
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/paragraph.rb

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

data/lib/prosemirror/nodes/table.rb

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

data/lib/prosemirror/nodes/table_cell.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class TableCell < NodeType
+      content "block+"
+
+      prop :colspan, _Integer(1..), default: 1, &Coerce::INTEGER
+      prop :rowspan, _Integer(1..), default: 1, &Coerce::INTEGER
+      prop :colwidth, _Array?(_Integer(1..))
+
+      def view_template(&)
+        td(**cell_attributes, &)
+      end
+
+      private
+
+      def cell_attributes
+        {colspan: (@colspan unless @colspan == 1), rowspan: (@rowspan unless @rowspan == 1)}
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/table_header.rb

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

data/lib/prosemirror/nodes/table_row.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Nodes
+    class TableRow < NodeType
+      content "(table_cell | table_header)*"
+
+      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/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

data/lib/prosemirror/schema.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A set of node and mark types, with rendering options.
+  #
+  #   schema = Prosemirror::Schema.tiptap(case: :camel).with(ImageBlock)
+  #   schema.parse(json).to_html
+  class Schema < Literal::Data
+    DEFAULT_URL_SCHEMES = %w[http https mailto tel].freeze
+
+    prop :nodes, _Array(_Class(NodeType)), &Coerce::FROZEN
+    prop :marks, _Array(_Class(MarkType)), &Coerce::FROZEN
+    prop :top_node, Symbol, default: :doc, &Coerce::SYMBOL
+    # `:snake` or `:camel`, for type names in JSON output.
+    prop :case, _Union(:snake, :camel), default: :snake, reader: false
+    # The URL schemes allowed in links and images. Relative URLs are always allowed.
+    prop :url_schemes, _Array(String), default: DEFAULT_URL_SCHEMES do |schemes|
+      schemes.map(&:downcase).freeze
+    end
+    # Called with each URL before it is checked, to rewrite it.
+    prop :resolve_url, _Callable?, reader: false
+    # Raise `InvalidDocument` instead of fixing invalid documents.
+    prop :strict, _Boolean, default: false, reader: false, predicate: :public
+    # Called with an `InvalidDocument` error for each problem fixed.
+    prop :on_invalid, _Callable?, reader: false
+
+    # Tiptap's StarterKit and common extensions.
+    def self.tiptap(**)
+      new(
+        nodes: [
+          Nodes::Doc, Nodes::Paragraph, Nodes::Text, Nodes::Heading, Nodes::Blockquote, Nodes::BulletList,
+          Nodes::OrderedList, Nodes::ListItem, Nodes::CodeBlock, Nodes::HardBreak, Nodes::HorizontalRule,
+          Nodes::Image, Nodes::Table, Nodes::TableRow, Nodes::TableHeader, Nodes::TableCell
+        ],
+        marks: [
+          Marks::Link, Marks::Bold, Marks::Italic, Marks::Underline, Marks::Strike, Marks::Code,
+          Marks::Subscript, Marks::Superscript, Marks::Highlight
+        ],
+        **
+      )
+    end
+
+    # ProseMirror's prosemirror-schema-basic and prosemirror-schema-list.
+    def self.prosemirror(**)
+      new(
+        nodes: [
+          Nodes::Doc, Nodes::Paragraph, Nodes::Blockquote, Nodes::HorizontalRule, Nodes::Heading,
+          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],
+        **
+      )
+    end
+
+    def after_initialize
+      @node_lookup = lookup(@nodes)
+      @mark_lookup = lookup(@marks)
+      @textblocks = @nodes.to_h { |type| [type, textblock_type?(type)] }
+      raise ArgumentError, "the schema has no #{@top_node} node type" unless node_type(@top_node)
+    end
+
+    # A copy of the schema with other options.
+    def with_options(**)
+      self.class.new(**to_h, **)
+    end
+
+    # A copy of the schema with more types. A type replaces the type with the same name.
+    def with(*types)
+      nodes = types.select { |type| type.is_a?(Class) && type < NodeType }
+      marks = types.select { |type| type.is_a?(Class) && type < MarkType }
+      raise ArgumentError, "not a node or mark type" if nodes.size + marks.size != types.size
+
+      self.class.new(**to_h, nodes: merge_types(@nodes, nodes), marks: merge_types(@marks, marks))
+    end
+
+    # The node type for a name, alias, or camelCase name.
+    def node_type(name)
+      @node_lookup[Naming.snake(name).to_sym]
+    end
+
+    def mark_type(name)
+      @mark_lookup[Naming.snake(name).to_sym]
+    end
+
+    # Build a document from JSON, given as a Hash or a String.
+    def parse(json)
+      Document.new(JSONParser.new(self).parse(json), 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 order of marks in a node. Marks of unknown types come last.
+    def mark_rank(name)
+      @marks.index(mark_type(name)) || @marks.size
+    end
+
+    # Whether nodes of this type contain inline content, like a paragraph.
+    def textblock?(type)
+      @textblocks.fetch(type, false)
+    end
+
+    # The URL after `resolve_url`, when its scheme is allowed. Otherwise nil, and the problem is reported.
+    def safe_url(url)
+      return nil unless url.is_a?(String)
+
+      resolved = @resolve_url ? @resolve_url.call(url) : url
+      return report("URL could not be resolved: #{url.inspect}") unless resolved.is_a?(String)
+      return report("URL scheme not allowed: #{resolved.inspect}") unless allowed_url?(resolved)
+
+      resolved.gsub("&", "&amp;")
+    end
+
+    # Raise in strict mode, otherwise call `on_invalid`.
+    def report(message, path: nil)
+      error = InvalidDocument.new(message, path: path)
+      raise error if @strict
+
+      @on_invalid&.call(error)
+      nil
+    end
+
+    # The document as JSON, as a Hash.
+    def serialize(node)
+      hash = {"type" => json_type_name(node.type)}
+      hash["text"] = node.text if node.text?
+      attrs = serialize_node_attrs(node)
+      hash["attrs"] = attrs unless attrs.empty?
+      hash["content"] = node.content.map { |child| serialize(child) } unless node.content.empty?
+      hash["marks"] = node.marks.map { |mark| serialize_mark(mark) } unless node.marks.empty?
+      hash
+    end
+
+    private
+
+    def lookup(types)
+      types.each_with_object({}) do |type, table|
+        [type.type_name, *type.aliases].each { |name| table[name] ||= type }
+        table[type.type_name] = type
+      end
+    end
+
+    def merge_types(types, additions)
+      additions.reduce(types) do |list, addition|
+        index = list.index { |type| type.type_name == addition.type_name }
+        index ? list.dup.tap { |copy| copy[index] = addition } : list + [addition]
+      end
+    end
+
+    def textblock_type?(type)
+      return false if type.leaf?
+
+      type.content.names.any? do |name|
+        name == :text || name == :inline || node_types_named(name).any?(&:inline?)
+      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)
+      attrs = type ? type.serialize_attrs(node.attrs) : node.attrs.transform_keys(&:to_s)
+      attrs.merge(node.unknown_attrs)
+    end
+
+    def serialize_mark(mark)
+      hash = {"type" => json_type_name(mark.type)}
+      type = mark_type(mark.type)
+      attrs = type ? type.serialize_attrs(mark.attrs) : mark.attrs.transform_keys(&:to_s)
+      attrs = attrs.merge(mark.unknown_attrs)
+      hash["attrs"] = attrs unless attrs.empty?
+      hash
+    end
+  end
+end