prosemirror 0.0.1 → 0.1.0

data/lib/prosemirror/content_expression.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A parsed content expression, such as `"paragraph block*"` or `"(table_cell | table_header){1,5}"`.
+  # See https://prosemirror.net/docs/guide/#schema.content_expressions
+  class ContentExpression
+    TOKEN = /\s*(\w+|[()|+*?]|\{\s*\d+\s*(?:,\s*\d*\s*)?\})/
+
+    attr_reader :source, :tree
+
+    def initialize(source)
+      @source = source
+      @tokens = tokenize(source)
+      @tree = parse_choice
+      raise ArgumentError, "unexpected #{@tokens.first.inspect} in content expression #{source.inspect}" if @tokens.any?
+    end
+
+    # The node names and group names the expression refers to.
+    def names
+      collect_names(@tree)
+    end
+
+    private
+
+    def tokenize(source)
+      tokens = []
+      rest = source.strip
+      until rest.empty?
+        match = TOKEN.match(rest)
+        raise ArgumentError, "invalid content expression #{source.inspect}" unless match&.begin(0)&.zero?
+
+        tokens << match[1]
+        rest = match.post_match.strip
+      end
+      tokens
+    end
+
+    def parse_choice
+      branches = [parse_sequence]
+      while @tokens.first == "|"
+        @tokens.shift
+        branches << parse_sequence
+      end
+      (branches.size == 1) ? branches.first : [:choice, branches]
+    end
+
+    def parse_sequence
+      terms = []
+      terms << parse_repeat while @tokens.any? && !["|", ")"].include?(@tokens.first)
+      raise ArgumentError, "empty content expression in #{@source.inspect}" if terms.empty?
+
+      (terms.size == 1) ? terms.first : [:sequence, terms]
+    end
+
+    def parse_repeat
+      atom = parse_atom
+      case @tokens.first
+      when "*" then @tokens.shift && [:repeat, atom, 0, nil]
+      when "+" then @tokens.shift && [:repeat, atom, 1, nil]
+      when "?" then @tokens.shift && [:repeat, atom, 0, 1]
+      when /\A\{/ then [:repeat, atom, *parse_range(@tokens.shift)]
+      else atom
+      end
+    end
+
+    def parse_range(token)
+      min, comma, max = token.delete("{} ").partition(",")
+      return [min.to_i, min.to_i] if comma.empty?
+
+      [min.to_i, max.empty? ? nil : max.to_i]
+    end
+
+    def parse_atom
+      token = @tokens.shift
+      case token
+      when "("
+        expression = parse_choice
+        raise ArgumentError, "missing ) in content expression #{@source.inspect}" unless @tokens.shift == ")"
+
+        expression
+      when /\A\w+\z/ then [:name, token.to_sym]
+      else raise ArgumentError, "unexpected #{token.inspect} in content expression #{@source.inspect}"
+      end
+    end
+
+    def collect_names(tree)
+      case tree.first
+      when :name then [tree[1]]
+      when :repeat then collect_names(tree[1])
+      else tree[1].flat_map { |child| collect_names(child) }.uniq
+      end
+    end
+  end
+end

data/lib/prosemirror/document.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A document and its schema. Enumerating a document yields all its nodes, depth first.
+  #
+  #   doc = Prosemirror.parse(json)
+  #   doc.to_html
+  #   doc.select { |node| node in { type: :heading, attrs: { level: 1 } } }
+  class Document
+    include Enumerable
+
+    attr_reader :root, :schema
+
+    def initialize(root, schema: Prosemirror.schema)
+      @root = root
+      @schema = schema
+    end
+
+    def content
+      root.content
+    end
+
+    def each(&)
+      root.descendants(&)
+    end
+
+    # The document as HTML. The string is `html_safe` when ActiveSupport is loaded.
+    def to_html
+      html = to_phlex.call
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
+    # A Phlex component rendering the document, to render it inside another Phlex component:
+    #
+    #   render doc.to_phlex
+    def to_phlex
+      HTMLRenderer.new(self)
+    end
+
+    # Lets Rails render the document in ERB templates and ViewComponents: `<%= render doc %>`.
+    def render_in(_view_context, &)
+      to_html
+    end
+
+    # The document as plain text, with blocks separated by `block_separator`.
+    def to_text(block_separator: "\n\n")
+      TextSerializer.new(schema, block_separator: block_separator).call(root)
+    end
+
+    # The document as JSON, as a Hash.
+    def to_h
+      schema.serialize(root)
+    end
+
+    def as_json(*)
+      to_h
+    end
+
+    def to_json(*)
+      to_h.to_json(*)
+    end
+
+    def text_content
+      root.text_content
+    end
+
+    def ==(other)
+      other.is_a?(Document) && root == other.root
+    end
+    alias_method :eql?, :==
+
+    def hash
+      root.hash
+    end
+  end
+end

data/lib/prosemirror/html_renderer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Renders a document to HTML. Use `doc.to_phlex` to render it inside another Phlex component:
+  #
+  #   render doc.to_phlex
+  class HTMLRenderer < Phlex::HTML
+    include Rendering
+
+    def initialize(document)
+      super()
+      @document = document
+      @_prosemirror_schema = document.schema
+    end
+
+    def view_template
+      render_content([@document.root])
+    end
+  end
+end

data/lib/prosemirror/json_parser.rb

@@ -0,0 +1,125 @@
+# 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
+      join_text(nodes)
+    end
+
+    def 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
+
+    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,60 @@
+# 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
+
+      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/em.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    module Basic
+      class Em < MarkType
+        aliases :italic
+
+        def view_template(&) = em(&)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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?
+
+        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,13 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    module Basic
+      class Strong < MarkType
+        aliases :bold
+
+        def view_template(&) = strong(&)
+      end
+    end
+  end
+end

data/lib/prosemirror/marks/bold.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Bold < MarkType
+      aliases :strong
+
+      def view_template(&) = strong(&)
+    end
+  end
+end

data/lib/prosemirror/marks/code.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Code < MarkType
+      code
+
+      def view_template(&) = code(&)
+    end
+  end
+end

data/lib/prosemirror/marks/highlight.rb

@@ -0,0 +1,16 @@
+# 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)
+
+      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,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Italic < MarkType
+      aliases :em
+
+      def view_template(&) = em(&)
+    end
+  end
+end

data/lib/prosemirror/marks/link.rb

@@ -0,0 +1,21 @@
+# 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?
+
+      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,9 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Strike < MarkType
+      def view_template(&) = s(&)
+    end
+  end
+end

data/lib/prosemirror/marks/subscript.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Subscript < MarkType
+      excludes "superscript"
+
+      def view_template(&) = sub(&)
+    end
+  end
+end

data/lib/prosemirror/marks/superscript.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Superscript < MarkType
+      excludes "subscript"
+
+      def view_template(&) = sup(&)
+    end
+  end
+end

data/lib/prosemirror/marks/underline.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    class Underline < MarkType
+      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,65 @@
+# 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
+
+    # 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