prosemirror 0.4.0 → 0.5.0

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

@@ -16,6 +16,10 @@ module Prosemirror
         def view_template(&)
           ol(start: (@order unless @order == 1), &)
         end
+
+        def to_markdown(markdown, parent, index)
+          Nodes::OrderedList.numbered(markdown, node, @order, markdown.list_after_list?(parent, index) ? ")" : ".")
+        end
       end
     end
   end

data/lib/prosemirror/nodes/blockquote.rb

@@ -8,6 +8,10 @@ module Prosemirror
       parse_html tag: "blockquote"
 
       def view_template(&) = blockquote(&)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.wrap_block("> ", nil, node) { markdown.render_content(node) }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/bullet_list.rb

@@ -8,6 +8,12 @@ module Prosemirror
       parse_html tag: "ul"
 
       def view_template(&) = ul(&)
+
+      # `-` items, or `*` right after another bullet list, which would otherwise continue it.
+      def to_markdown(markdown, parent, index)
+        marker = markdown.list_after_list?(parent, index) ? "* " : "- "
+        markdown.render_list(node, "  ") { marker }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/code_block.rb

@@ -19,6 +19,21 @@ module Prosemirror
       def view_template(&)
         pre { code(class: @language && "language-#{@language}", &) }
       end
+
+      def to_markdown(markdown, _parent, _index)
+        self.class.fenced(markdown, node, @language)
+      end
+
+      # A fenced code block, with a fence longer than any run of backticks in the code.
+      def self.fenced(markdown, node, language)
+        code = node.text_content
+        fence = "`" * [3, (code.scan(/`{3,}/).map(&:length).max || 0) + 1].max
+        markdown.write("#{fence}#{language}\n")
+        markdown.text(code, escape: false)
+        markdown.ensure_new_line
+        markdown.write(fence)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/hard_break.rb

@@ -10,6 +10,11 @@ module Prosemirror
       parse_html tag: "br"
 
       def view_template = br
+
+      # A backslash before the newline, unless only line breaks follow.
+      def to_markdown(markdown, parent, index)
+        markdown.write("\\\n") if parent.content[(index + 1)..].any? { |sibling| sibling.type != node.type }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/heading.rb

@@ -10,6 +10,12 @@ module Prosemirror
       (1..6).each { |level| parse_html tag: "h#{level}", attrs: {level:} }
 
       def view_template(&) = tag(:"h#{@level}", &)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.write("#{"#" * @level} ")
+        markdown.render_inline(node, from_block_start: false)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/horizontal_rule.rb

@@ -7,6 +7,11 @@ module Prosemirror
       parse_html tag: "hr"
 
       def view_template = hr
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.write("---")
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/image.rb

@@ -17,6 +17,22 @@ module Prosemirror
         src = safe_url(@src)
         img(src: src, alt: @alt, title: @title, width: @width, height: @height) if src
       end
+
+      # `![alt](src "title")`, or HTML with `html: true` when it has dimensions. Images in a row share a line,
+      # as Markdown would give them back: in separate paragraphs, each would come back after an empty one.
+      def to_markdown(markdown, parent, index)
+        markdown.write(" ") if index.positive? && parent.content[index - 1].type == node.type
+        if markdown.html? && (@width || @height)
+          markdown.write(markdown.node_html(node))
+        else
+          markdown.write(self.class.markdown_image(markdown, @src, @alt, @title))
+        end
+        markdown.close_block(node) unless parent.content[index + 1]&.type == node.type
+      end
+
+      def self.markdown_image(markdown, src, alt, title)
+        "![#{markdown.esc(alt.to_s)}](#{markdown.url(src)}#{markdown.title(title)})"
+      end
     end
   end
 end

data/lib/prosemirror/nodes/list_item.rb

@@ -7,6 +7,10 @@ module Prosemirror
       parse_html tag: "li"
 
       def view_template(&) = li(&)
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.render_content(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/ordered_list.rb

@@ -31,6 +31,17 @@ module Prosemirror
       def view_template(&)
         ol(start: (@start unless @start == 1), type: @type, &)
       end
+
+      def to_markdown(markdown, parent, index)
+        self.class.numbered(markdown, node, @start, markdown.list_after_list?(parent, index) ? ")" : ".")
+      end
+
+      # Items numbered from `start`, with the numbers aligned. `)` instead of `.` keeps a list right after
+      # another ordered list apart from it.
+      def self.numbered(markdown, node, start, delimiter = ".")
+        width = (start + node.content.size - 1).to_s.length
+        markdown.render_list(node, " " * (width + 2)) { |index| "#{(start + index).to_s.rjust(width)}#{delimiter} " }
+      end
     end
   end
 end

data/lib/prosemirror/nodes/paragraph.rb

@@ -8,6 +8,14 @@ module Prosemirror
       parse_html tag: "p"
 
       def view_template(&) = p(&)
+
+      # Markdown has no empty paragraphs: they are left out.
+      def to_markdown(markdown, _parent, _index)
+        return if node.content.empty?
+
+        markdown.render_inline(node)
+        markdown.close_block(node)
+      end
     end
   end
 end

data/lib/prosemirror/nodes/table.rb

@@ -10,6 +10,42 @@ module Prosemirror
       def view_template(&)
         table { tbody(&) }
       end
+
+      # A GitHub Flavored Markdown table: the first row is the header, and gives the columns' alignments. A
+      # cell's paragraphs, images and line breaks are joined with `<br>`, and its other blocks, like lists, are
+      # written as HTML, which Markdown import reads back with the herb gem.
+      def to_markdown(markdown, _parent, _index)
+        rows = node.content.map { |row| row.content.map { |cell| cell_markdown(markdown, cell) } }
+        columns = rows.map(&:size).max.to_i
+        return markdown.close_block(node) if columns.zero?
+
+        aligns = node.content.first.content.map { |cell| cell.attrs[:align] }
+        delimiter = Array.new(columns) do |index|
+          {"left" => ":--", "center" => ":-:", "right" => "--:"}.fetch(aligns[index].to_s, "---")
+        end
+        lines = [rows.first, delimiter, *rows.drop(1)].map do |cells|
+          "| #{Array.new(columns) { |index| cells[index].to_s }.join(" | ")} |"
+        end
+        markdown.text(lines.join("\n"), escape: false)
+        markdown.close_block(node)
+      end
+
+      private
+
+      def cell_markdown(markdown, cell)
+        parts = cell.content.map do |block|
+          type = markdown.schema.node_type(block.type)
+          if type && (type <= Paragraph || type <= Image)
+            serializer = MarkdownSerializer.new(markdown.schema, html: markdown.html?)
+            serializer.render(block, cell, 0)
+            serializer.out.strip.gsub(/\\\n|\n+/, "<br>")
+          else
+            markdown.node_html(block).gsub("\n", "&#10;")
+          end
+        end
+        # A space after a line break is dropped, as in HTML.
+        parts.join("<br>").gsub(/(?:<br>[[:space:]]*)+/, "<br>").delete_prefix("<br>").delete_suffix("<br>").gsub("|", "\\|")
+      end
     end
   end
 end

data/lib/prosemirror/nodes/text.rb

@@ -5,6 +5,10 @@ module Prosemirror
     # Text. Text nodes are rendered by the renderer, not by this type.
     class Text < NodeType
       group :inline
+
+      def to_markdown(markdown, _parent, _index)
+        markdown.text(node.text, escape: !markdown.in_autolink)
+      end
     end
   end
 end

data/lib/prosemirror/schema.rb

@@ -57,6 +57,8 @@ module Prosemirror
     def after_initialize
       @node_lookup = lookup(@nodes)
       @mark_lookup = lookup(@marks)
+      @node_names = spellings(@node_lookup)
+      @mark_names = spellings(@mark_lookup)
       @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)
@@ -100,11 +102,11 @@ module Prosemirror
 
     # The node type for a name, alias, or camelCase name.
     def node_type(name)
-      @node_lookup[Naming.snake(name).to_sym]
+      @node_names[name] || @node_lookup[Naming.snake(name).to_sym]
     end
 
     def mark_type(name)
-      @mark_lookup[Naming.snake(name).to_sym]
+      @mark_names[name] || @mark_lookup[Naming.snake(name).to_sym]
     end
 
     # Build a document from JSON, given as a Hash or a String.
@@ -228,6 +230,16 @@ module Prosemirror
       end
     end
 
+    # The names of a lookup table, as Symbols and Strings, in snake_case and camelCase, so that most names
+    # are found without converting them.
+    def spellings(lookup)
+      table = {}
+      lookup.each { |name, type| table[name] = table[name.name] = type }
+      lookup.each { |name, type| table[Naming.camel(name).freeze] ||= type }
+      table.each_key.select { |name| name.is_a?(String) }.each { |name| table[name.to_sym] ||= table[name] }
+      table.freeze
+    end
+
     def merge_types(types, additions)
       additions.reduce(types) do |list, addition|
         index = list.index { |type| type.type_name == addition.type_name }

data/lib/prosemirror/type_definition.rb

@@ -3,6 +3,7 @@
 module Prosemirror
   # Class-level declarations shared by node types and mark types.
   module TypeDefinition
+    EMPTY_HASH = {}.freeze
     # The name of the type, as a snake_case Symbol. It defaults to the class name (`BulletList` → `:bullet_list`),
     # and subclasses of a concrete type keep its name.
     def type_name(name = nil)
@@ -24,7 +25,12 @@ module Prosemirror
     # - `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
+      json = (json || name).to_s
+      aliases = aliases.map(&:to_s)
+      # The keys accepted in JSON: each name as written, in snake_case and in camelCase.
+      keys = [json, *aliases].flat_map { |key| [key, Naming.snake(key), Naming.camel(key)] }.uniq.map(&:freeze).freeze
+      attribute_names[name] = {json:, aliases:, parse_html:, keys:}.freeze
+      @known_keys = nil
       super(name, type, kind, **, &)
     end
 
@@ -54,7 +60,10 @@ module Prosemirror
     # Invalid values are converted when the meaning is clear, or replaced by their default.
     # Returns nil when a required attribute is missing or invalid.
     def build_attrs(given, report:)
-      given = given.is_a?(Hash) ? given.transform_keys(&:to_s) : {}
+      given = if !given.is_a?(Hash) then EMPTY_HASH
+      elsif keys?(given) { |key| key.is_a?(String) } then given
+      else given.transform_keys(&:to_s)
+      end
 
       literal_properties.each_with_object({}) do |property, attrs|
         json_name = attribute_names.dig(property.name, :json)
@@ -86,14 +95,19 @@ module Prosemirror
 
     # 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)
+      return EMPTY_HASH unless given.is_a?(Hash)
+
+      known = known_keys
+      return EMPTY_HASH if keys?(given) { |key| known.include?(key.is_a?(Symbol) ? key.name : key) }
 
-      known = attribute_names.values.flat_map do |names|
-        [names[:json], *names[:aliases]].flat_map { |name| [name, Naming.snake(name), Naming.camel(name)] }
-      end
       given.transform_keys(&:to_s).except(*known)
     end
 
+    # The JSON keys of the declared attributes, in all their spellings.
+    def known_keys
+      @known_keys ||= attribute_names.each_value.flat_map { |names| names[:keys] }.to_set.freeze
+    end
+
     # Attributes as JSON, with their JSON names.
     def serialize_attrs(attrs)
       attrs.to_h { |name, value| [attribute_names.dig(name, :json) || name.to_s, value] }
@@ -122,17 +136,23 @@ module Prosemirror
       superclass.send(:inherited_setting, ivar, default)
     end
 
+    # Whether the block is true for all keys of the hash, without the Enumerator `each_key.all?` allocates.
+    def keys?(hash)
+      hash.each_key { |key| return false unless yield(key) }
+      true
+    end
+
     def attribute_key(given, names)
-      [names[:json], *names[:aliases]].each do |name|
-        [name, Naming.snake(name), Naming.camel(name)].each do |candidate|
-          return candidate if given.key?(candidate)
-        end
-      end
-      nil
+      names[:keys].find { |key| given.key?(key) }
     end
 
+    # The gem's coercions don't use `self`: they are called directly, without Literal's `instance_exec`.
     def coerce_attribute(property, value)
-      property.coercion ? property.coerce(value, context: self) : value
+      coercion = property.coercion
+      if coercion.nil? then value
+      elsif Coerce::PLAIN.include?(coercion) then coercion.call(value)
+      else property.coerce(value, context: self)
+      end
     rescue
       value
     end

data/lib/prosemirror/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosemirror
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Hans Lemuet
@@ -84,6 +84,7 @@ files:
 - lib/prosemirror/mark.rb
 - lib/prosemirror/mark_type.rb
 - lib/prosemirror/markdown/builder.rb
+- lib/prosemirror/markdown_serializer.rb
 - lib/prosemirror/marks/basic/code.rb
 - lib/prosemirror/marks/basic/em.rb
 - lib/prosemirror/marks/basic/link.rb