prose_mirror_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ca1e1715fe8d1e412d15a8ffddb367b6bd3e648029e62372051f343adcf0172
+  data.tar.gz: d5e675c75e8acb88e347d1f38ee30f157d63310d886883ea838ed96e52c9b4c1
+SHA512:
+  metadata.gz: b02364d8907439c6ab5cab1a1c829bd8f5c437300dc72a93c81786e54a32bf0ede115a63280441fe58a2c3effeb973eb91e997e3359bae2e572e4fc1192886d0
+  data.tar.gz: 80ccdbcef5ab0e714185707114402727fbb603d431be68c28a2ab58bb4c5bad61640d5b7b4373fefa89a7a4660f07be805f838d03ff9a5670c4201878f70c978

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2023-06-15
+
+### Added
+- Initial release
+- Core ProseMirror document model (Node, Mark)
+- JSON parser and converter
+- Markdown serialization
+- Helper methods for traversing and manipulating nodes

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Robert Ross, FireHydrant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,147 @@
+# ProseMirror Ruby
+
+A Ruby library for working with [ProseMirror](https://prosemirror.net/) documents, including conversion between ProseMirror JSON and other formats like Markdown.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'prose_mirror_ruby'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install prose_mirror_ruby
+```
+
+## Features
+
+- Parse ProseMirror JSON documents into Ruby objects
+- Convert ProseMirror documents to Markdown
+- Traverse and manipulate document nodes
+- Apply marks (like strong, em, code, etc.) to text nodes
+
+## Usage
+
+### Parsing ProseMirror JSON
+
+```ruby
+require 'prose_mirror'
+
+# Example ProseMirror JSON document
+json_document = <<~JSON
+  {
+    "type": "doc",
+    "content": [
+      {
+        "type": "heading",
+        "attrs": { "level": 2 },
+        "content": [
+          { "type": "text", "text": "Example Document" }
+        ]
+      },
+      {
+        "type": "paragraph",
+        "content": [
+          {
+            "type": "text",
+            "text": "This is bold text",
+            "marks": [
+              { "type": "strong" }
+            ]
+          },
+          { "type": "text", "text": " and " },
+          {
+            "type": "text",
+            "text": "this is italic",
+            "marks": [
+              { "type": "em" }
+            ]
+          },
+          { "type": "text", "text": "." }
+        ]
+      }
+    ]
+  }
+JSON
+
+# Parse JSON into a Node object tree
+document = ProseMirror.parse(json_document)
+```
+
+### Converting to Markdown
+
+```ruby
+# Convert a document to Markdown
+markdown = ProseMirror.to_markdown(document)
+puts markdown
+```
+
+### Working with Nodes
+
+```ruby
+# Traverse the document and print text nodes
+def traverse_and_print(node, level = 0)
+  indent = "  " * level
+
+  if node.is_text
+    puts "#{indent}Text: #{node.text}"
+  else
+    puts "#{indent}Node: #{node.type.name}"
+
+    node.each_with_index do |child, i|
+      traverse_and_print(child, level + 1)
+    end
+  end
+end
+
+traverse_and_print(document)
+```
+
+### Custom Markdown Serialization
+
+You can customize the Markdown serialization by providing your own node and mark serializers:
+
+```ruby
+# Add a custom serializer for a new node type
+custom_node_serializers = ProseMirror::Serializers::MarkdownSerializer::DEFAULT_NODE_SERIALIZERS.dup
+custom_node_serializers[:custom_node] = ->(state, node, parent = nil, index = nil) {
+  state.write("CUSTOM NODE: #{node.attrs[:custom_data]}")
+  state.close_block(node)
+}
+
+# Create a serializer with custom node handlers
+serializer = ProseMirror::Serializers::MarkdownSerializer.new(
+  custom_node_serializers,
+  ProseMirror::Serializers::MarkdownSerializer::DEFAULT_MARK_SERIALIZERS
+)
+
+# Use the custom serializer
+markdown = serializer.serialize(document)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/firehydrant/prose_mirror.
+
+## Known Issues
+
+- Markdown serialization for lists and code blocks may not produce perfect output in all cases. Contributions to improve this are welcome.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/prose_mirror/converter.rb

@@ -0,0 +1,52 @@
+module ProseMirror
+  # Converter for transforming between ProseMirror JSON and Node objects
+  class Converter
+    # Convert a JSON ProseMirror document into Ruby Node objects
+    # @param json_string [String] The JSON string representation of a ProseMirror document
+    # @return [Node] The root node of the document
+    def self.from_json(json_string)
+      data = JSON.parse(json_string)
+      parse_node(data)
+    end
+
+    private
+
+    # Recursively parse nodes from JSON data
+    # @param node_data [Hash] The node data from JSON
+    # @return [Node] The parsed node
+    def self.parse_node(node_data)
+      type = node_data["type"]
+      attrs = parse_attrs(node_data["attrs"] || {})
+      marks = parse_marks(node_data["marks"] || [])
+
+      if type == "text"
+        # Text nodes have text content directly
+        Node.new(type, attrs, [], marks, node_data["text"])
+      else
+        # Non-text nodes have child content
+        content = (node_data["content"] || []).map { |child| parse_node(child) }
+        Node.new(type, attrs, content, marks)
+      end
+    end
+
+    # Parse attributes from JSON to Ruby hash with symbol keys
+    # @param attrs_data [Hash] The attributes data from JSON
+    # @return [Hash] Hash with symbol keys
+    def self.parse_attrs(attrs_data)
+      result = {}
+      attrs_data.each do |key, value|
+        result[key.to_sym] = value
+      end
+      result
+    end
+
+    # Parse marks from JSON to Ruby Mark objects
+    # @param marks_data [Array] The marks data array from JSON
+    # @return [Array<Mark>] Array of Mark objects
+    def self.parse_marks(marks_data)
+      marks_data.map do |mark_data|
+        Mark.new(mark_data["type"], parse_attrs(mark_data["attrs"] || {}))
+      end
+    end
+  end
+end

data/lib/prose_mirror/mark.rb

@@ -0,0 +1,30 @@
+module ProseMirror
+  # Represents a mark in a ProseMirror document
+  # Marks can be applied to nodes to indicate formatting or other attributes
+  class Mark
+    attr_reader :type, :attrs
+
+    # Create a new Mark
+    # @param type [String] The mark type name (e.g., "strong", "em", "link")
+    # @param attrs [Hash] Mark attributes
+    def initialize(type, attrs = {})
+      @type = OpenStruct.new(name: type)
+      @attrs = attrs
+    end
+
+    # Check if this mark is equal to another mark
+    # Two marks are equal if they have the same type name
+    # @param other [Mark] The other mark to compare with
+    # @return [Boolean] true if the marks are equal, false otherwise
+    def eq(other)
+      @type.name == other.type.name
+    end
+
+    # Check if this mark is in the given set of marks
+    # @param mark_array [Array<Mark>] The array of marks to check against
+    # @return [Boolean] true if the mark is in the set, false otherwise
+    def is_in_set(mark_array)
+      mark_array.any? { |m| eq(m) }
+    end
+  end
+end

data/lib/prose_mirror/node.rb

@@ -0,0 +1,82 @@
+module ProseMirror
+  # Represents a node in a ProseMirror document
+  # This can be a block node (paragraph, heading), inline node, or a text node
+  class Node
+    attr_reader :type, :attrs, :content, :marks, :text
+
+    # Create a new Node
+    # @param type [String] The node type name
+    # @param attrs [Hash] Node attributes
+    # @param content [Array<Node>] Child nodes
+    # @param marks [Array<Mark>] Node marks
+    # @param text [String, nil] Text content for text nodes, nil otherwise
+    def initialize(type, attrs = {}, content = [], marks = [], text = nil)
+      @type = OpenStruct.new(
+        name: type,
+        is_block: true,
+        is_leaf: content.empty? && !text,
+        inline_content: !!text
+      )
+      @attrs = attrs
+      @content = content
+      @marks = marks
+      @text = text
+    end
+
+    # Check if this is a text node
+    # @return [Boolean] true if this is a text node, false otherwise
+    def is_text
+      !@text.nil?
+    end
+
+    # Check if this is a block node
+    # @return [Boolean] true if this is a block node, false otherwise
+    def is_block
+      @type.is_block
+    end
+
+    # Get the text content of this node
+    # For text nodes, returns the text directly
+    # For non-text nodes, returns the concatenated text content of all child nodes
+    # @return [String] The text content
+    def text_content
+      is_text ? @text : @content.map(&:text_content).join("")
+    end
+
+    # Get the number of child nodes
+    # @return [Integer] The number of child nodes
+    def child_count
+      @content.length
+    end
+
+    # Get a child node at the specified index
+    # @param index [Integer] The index of the child node to retrieve
+    # @return [Node, nil] The child node, or nil if not found
+    def child(index)
+      @content[index]
+    end
+
+    # Get the size of this node
+    # For text nodes, returns the text length
+    # For other nodes, returns 1
+    # @return [Integer] The node size
+    def node_size
+      @text ? @text.length : 1
+    end
+
+    # Iterate over each child node with its index
+    # @yield [node, index] Yields each child node and its index
+    # @yieldparam node [Node] The child node
+    # @yieldparam index [Integer] The index of the child node
+    def each_with_index(&block)
+      @content.each_with_index(&block)
+    end
+
+    # Create a new text node with the given text but same marks
+    # @param new_text [String] The new text content
+    # @return [Node] A new text node with the same marks but different text
+    def with_text(new_text)
+      Node.new(@type.name, @attrs, [], @marks, new_text)
+    end
+  end
+end

data/lib/prose_mirror/serializers/markdown_serializer.rb

@@ -0,0 +1,468 @@
+module ProseMirror
+  module Serializers
+    # A blank mark used as a fallback
+    BLANK_MARK = {open: "", close: "", mixable: true}.freeze
+
+    # A specification for serializing a ProseMirror document as Markdown/CommonMark text.
+    class MarkdownSerializer
+      attr_reader :nodes, :marks, :options
+
+      # Default serializers for various node types
+      DEFAULT_NODE_SERIALIZERS = {
+        blockquote: ->(state, node, parent = nil, index = nil) {
+          state.wrap_block("> ", nil, node) { state.render_content(node) }
+        },
+
+        code_block: ->(state, node, parent = nil, index = nil) {
+          # Make sure fence is longer than any dash sequence within content
+          backticks = node.text_content.scan(/`{3,}/m)
+          fence = backticks.empty? ? "```" : (backticks.sort.last + "`")
+
+          state.write(fence + (node.attrs[:params] || "") + "\n")
+          state.text(node.text_content, false)
+          # Add newline before closing marker
+          state.write("\n")
+          state.write(fence)
+          state.close_block(node)
+        },
+
+        heading: ->(state, node, parent = nil, index = nil) {
+          state.write(state.repeat("#", node.attrs[:level]) + " ")
+          state.render_inline(node, false)
+          state.close_block(node)
+        },
+
+        horizontal_rule: ->(state, node, parent = nil, index = nil) {
+          state.write(node.attrs[:markup] || "---")
+          state.close_block(node)
+        },
+
+        bullet_list: ->(state, node, parent = nil, index = nil) {
+          state.render_list(node, "  ", ->(_) { (node.attrs[:bullet] || "*") + " " })
+        },
+
+        ordered_list: ->(state, node, parent = nil, index = nil) {
+          start = node.attrs[:order] || 1
+          max_w = (start + node.child_count - 1).to_s.length
+          space = state.repeat(" ", max_w + 2)
+
+          state.render_list(node, space, ->(i) {
+            n_str = (start + i).to_s
+            state.repeat(" ", max_w - n_str.length) + n_str + ". "
+          })
+        },
+
+        list_item: ->(state, node, parent = nil, index = nil) {
+          state.render_content(node)
+        },
+
+        paragraph: ->(state, node, parent = nil, index = nil) {
+          state.render_inline(node)
+          state.close_block(node)
+        },
+
+        image: ->(state, node, parent = nil, index = nil) {
+          state.write("![" + state.esc(node.attrs[:alt] || "") + "](" +
+                    node.attrs[:src].gsub(/[\(\)]/, "\\\\\\&") +
+                    (node.attrs[:title] ? ' "' + node.attrs[:title].gsub('"', '\\"') + '"' : "") +
+                    ")")
+        },
+
+        hard_break: ->(state, node, parent, index) {
+          (index + 1...parent.child_count).each do |i|
+            if parent.child(i).type != node.type
+              state.write("\\\n")
+              return
+            end
+          end
+        },
+
+        text: ->(state, node, parent = nil, index = nil) {
+          state.text(node.text, !state.in_autolink)
+        }
+      }
+
+      # Default serializers for various mark types
+      DEFAULT_MARK_SERIALIZERS = {
+        em: {
+          open: "*",
+          close: "*",
+          mixable: true,
+          expel_enclosing_whitespace: true
+        },
+
+        strong: {
+          open: "**",
+          close: "**",
+          mixable: true,
+          expel_enclosing_whitespace: true
+        },
+
+        link: {
+          open: ->(state, mark, parent, index) {
+            state.in_autolink = ProseMirror::Serializers.is_plain_url(mark, parent, index)
+            state.in_autolink ? "<" : "["
+          },
+          close: ->(state, mark, parent, index) {
+            in_autolink = state.in_autolink
+            state.in_autolink = nil
+
+            if in_autolink
+              ">"
+            else
+              "](" + mark.attrs[:href].gsub(/[\(\)"]/, "\\\\\\&") +
+                (mark.attrs[:title] ? ' "' + mark.attrs[:title].gsub('"', '\\"') + '"' : "") + ")"
+            end
+          },
+          mixable: true
+        },
+
+        code: {
+          open: ->(_, mark, parent, index) { ProseMirror::Serializers.backticks_for(parent.child(index), -1) },
+          close: ->(_, mark, parent, index) { ProseMirror::Serializers.backticks_for(parent.child(index - 1), 1) },
+          escape: false
+        }
+      }
+
+      # Constructor with node serializers, mark serializers, and options
+      # @param nodes [Hash] Node serializer functions
+      # @param marks [Hash] Mark serializer specifications
+      # @param options [Hash] Configuration options
+      def initialize(nodes, marks, options = {})
+        @nodes = nodes
+        @marks = marks
+        @options = options
+      end
+
+      # Serialize the content of the given node to CommonMark
+      # @param content [Node] The node to serialize
+      # @param options [Hash] Serialization options
+      # @return [String] The markdown output
+      def serialize(content, options = {})
+        options = @options.merge(options)
+        state = MarkdownSerializerState.new(@nodes, @marks, options)
+        state.render_content(content)
+        state.out
+      end
+    end
+
+    # Helper method for determining backticks for code marks
+    def self.backticks_for(node, side)
+      ticks = /`+/
+      len = 0
+
+      if node.is_text
+        node.text.scan(ticks) { |m| len = [len, m.length].max }
+      end
+
+      result = (len > 0 && side > 0) ? " `" : "`"
+      len.times { result += "`" }
+      result += " " if len > 0 && side < 0
+
+      result
+    end
+
+    # Determines if a link is a plain URL
+    def self.is_plain_url(link, parent, index)
+      return false if link.attrs[:title] || !/^\w+:/.match?(link.attrs[:href])
+
+      content = parent.child(index)
+      return false if !content.is_text || content.text != link.attrs[:href] || content.marks[content.marks.length - 1] != link
+
+      index == parent.child_count - 1 || !link.is_in_set(parent.child(index + 1).marks)
+    end
+
+    # This class is used to track state and expose methods related to markdown serialization
+    class MarkdownSerializerState
+      attr_accessor :delim, :out, :closed, :in_autolink, :at_block_start, :in_tight_list
+      attr_reader :nodes, :marks, :options
+
+      # Initialize a new state object
+      def initialize(nodes, marks, options)
+        @nodes = nodes
+        @marks = marks
+        @options = options
+        @delim = ""
+        @out = ""
+        @closed = nil
+        @in_autolink = nil
+        @at_block_start = false
+        @in_tight_list = false
+
+        @options[:tight_lists] = false if @options[:tight_lists].nil?
+        @options[:hard_break_node_name] = "hard_break" if @options[:hard_break_node_name].nil?
+      end
+
+      # Flush any pending closing operations
+      def flush_close(size = 2)
+        if @closed
+          @out += "\n" unless at_blank?
+          if size > 1
+            delim_min = @delim
+            trim = /\s+$/.match(delim_min)
+            delim_min = delim_min[0...delim_min.length - trim[0].length] if trim
+
+            (1...size).each do
+              @out += delim_min + "\n"
+            end
+          end
+          @closed = nil
+        end
+      end
+
+      # Get mark info by name
+      def get_mark(name)
+        info = @marks[name.to_sym]
+        if !info
+          if @options[:strict] != false
+            raise "Mark type `#{name}` not supported by Markdown renderer"
+          end
+          info = BLANK_MARK
+        end
+        info
+      end
+
+      # Wrap a block with delimiters
+      def wrap_block(delim, first_delim, node)
+        old = @delim
+        write(first_delim.nil? ? delim : first_delim)
+        @delim += delim
+        yield
+        @delim = old
+        close_block(node)
+      end
+
+      # Check if the output ends with a blank line
+      def at_blank?
+        /(^|\n)$/.match?(@out)
+      end
+
+      # Ensure the current content ends with a newline
+      def ensure_new_line
+        @out += "\n" unless at_blank?
+      end
+
+      # Write content to the output
+      def write(content = nil)
+        flush_close
+        @out += @delim if @delim && at_blank?
+        @out += content if content
+      end
+
+      # Close the block for the given node
+      def close_block(node)
+        @closed = node
+      end
+
+      # Add text to the document
+      def text(text, escape = true)
+        lines = text.split("\n")
+        lines.each_with_index do |line, i|
+          write
+
+          # Escape exclamation marks in front of links
+          if !escape && line[0] == "[" && /(^|[^\\])!$/.match?(@out)
+            @out = @out[0...@out.length - 1] + "\\!"
+          end
+
+          @out += escape ? esc(line, @at_block_start) : line
+          @out += "\n" if i != lines.length - 1
+        end
+      end
+
+      # Render a node
+      def render(node, parent, index)
+        if @nodes[node.type.name.to_sym]
+          @nodes[node.type.name.to_sym].call(self, node, parent, index)
+        elsif @options[:strict] != false
+          raise "Token type `#{node.type.name}` not supported by Markdown renderer"
+        elsif !node.type.is_leaf
+          if node.type.inline_content
+            render_inline(node)
+          else
+            render_content(node)
+          end
+          close_block(node) if node.is_block
+        end
+      end
+
+      # Render the contents of a parent as block nodes
+      def render_content(parent)
+        parent.each_with_index do |node, i|
+          render(node, parent, i)
+        end
+      end
+
+      # Render inline content
+      def render_inline(parent, from_block_start = true)
+        @at_block_start = from_block_start
+        active = []
+        trailing = ""
+
+        progress = lambda do |node, offset, index|
+          marks = node ? node.marks : []
+
+          # Remove marks from hard_break that are the last node inside
+          # that mark to prevent parser edge cases
+          if node && node.type.name == @options[:hard_break_node_name]
+            marks = marks.select do |m|
+              next false if index + 1 == parent.child_count
+
+              next_node = parent.child(index + 1)
+              m.is_in_set(next_node.marks) && (!next_node.is_text || /\S/.match?(next_node.text))
+            end
+          end
+
+          leading = trailing
+          trailing = ""
+
+          # Handle whitespace expelling
+          if node && node.is_text && marks.any? { |mark|
+            info = get_mark(mark.type.name.to_sym)
+            info && info[:expel_enclosing_whitespace] && !mark.is_in_set(active)
+          }
+            match = /^(\s*)(.*)$/m.match(node.text)
+            if match[1] && !match[1].empty?
+              leading += match[1]
+              node = (match[2] && !match[2].empty?) ? node.with_text(match[2]) : nil
+              marks = active if node.nil?
+            end
+          end
+
+          if node && node.is_text && marks.any? { |mark|
+            info = get_mark(mark.type.name.to_sym)
+            info && info[:expel_enclosing_whitespace] &&
+                (index == parent.child_count - 1 || !mark.is_in_set(parent.child(index + 1).marks))
+          }
+            match = /^(.*?)(\s*)$/m.match(node.text)
+            if match[2] && !match[2].empty?
+              trailing = match[2]
+              node = (match[1] && !match[1].empty?) ? node.with_text(match[1]) : nil
+              marks = active if node.nil?
+            end
+          end
+
+          inner = (marks.length > 0) ? marks[marks.length - 1] : nil
+          no_esc = inner && get_mark(inner.type.name)[:escape] == false
+          len = marks.length - (no_esc ? 1 : 0)
+
+          # Try to reorder marks to avoid needless mark recalculation
+          i = 0
+          while i < len
+            mark = marks[i]
+            info = get_mark(mark.type.name)
+            break unless info[:mixable]
+
+            j = 0
+            while j < active.length
+              other = active[j]
+              info_other = get_mark(other.type.name)
+              break unless info_other[:mixable]
+
+              if mark.eq(other)
+                if i > j
+                  marks = marks[0...j] + [mark] + marks[j...i] + marks[(i + 1)...len]
+                elsif j > i
+                  marks = marks[0...i] + marks[(i + 1)...j] + [mark] + marks[j...len]
+                end
+                break
+              end
+              j += 1
+            end
+            i += 1
+          end
+
+          # Find the prefix of the mark set that didn't change
+          keep = 0
+          while keep < [active.length, len].min && active[keep].eq(marks[keep])
+            keep += 1
+          end
+
+          # Close marks that no longer apply
+          (active.length - 1).downto(keep) do |i|
+            info = get_mark(active[i].type.name)
+            text = info[:close]
+            text = text.call(self, active[i], parent, index) if text.is_a?(Proc)
+            write(text)
+          end
+
+          text = leading
+          active.slice!(keep, active.length)
+
+          # Output any previously expelled trailing whitespace
+          if text && leading.length > 0
+            @out += text
+          end
+
+          # Open marks that are new now
+          (keep...len).each do |i|
+            info = get_mark(marks[i].type.name)
+            text = info[:open]
+            text = text.call(self, marks[i], parent, index) if text.is_a?(Proc)
+            write(text)
+            active.push(marks[i])
+          end
+
+          # Render the node
+          if node
+            write
+            if no_esc
+              render(node, parent, index)
+            else
+              text = node.text
+              if node.is_text
+                write(esc(text, @at_block_start))
+              else
+                render(node, parent, index)
+              end
+            end
+          end
+
+          @at_block_start = false
+        end
+
+        (0...parent.child_count).each do |i|
+          progress.call(parent.child(i), 0, i)
+        end
+        progress.call(nil, 0, parent.child_count)
+      end
+
+      # Render a list
+      def render_list(node, delim, first_delim)
+        if @closed && @closed.type == node.type
+          @closed = nil
+        else
+          ensure_new_line
+        end
+
+        starting = @delim
+
+        node.each_with_index do |child, i|
+          old_tight = @in_tight_list
+          @in_tight_list = node.attrs[:tight]
+          @delim = starting + first_delim.call(i)
+          render(child, node, i)
+          @in_tight_list = old_tight
+        end
+
+        size = (@closed && @closed.type.name == "paragraph" && !node.attrs[:tight]) ? 2 : 1
+        flush_close(size)
+      end
+
+      # Escape Markdown characters
+      def esc(str, start_of_line = false)
+        str = str.gsub(/[`*\\~\[\]_]/) { |m| "\\" + m }
+        if start_of_line
+          str = str.gsub(/^[#\-*+>]/) { |m| "\\" + m }
+            .gsub(/^(\d+)\./) { |_, d| d + "\\." }
+        end
+        str.gsub("![", "\\![")
+      end
+
+      # Repeat a string n times
+      def repeat(str, n)
+        str * n
+      end
+    end
+  end
+end

data/lib/prose_mirror/version.rb

@@ -0,0 +1,3 @@
+module ProseMirror
+  VERSION = "0.1.0"
+end

data/lib/prose_mirror.rb

@@ -0,0 +1,34 @@
+require "json"
+require "ostruct"
+
+# Require all ProseMirror components
+require_relative "prose_mirror/version"
+require_relative "prose_mirror/node"
+require_relative "prose_mirror/mark"
+require_relative "prose_mirror/converter"
+require_relative "prose_mirror/serializers/markdown_serializer"
+
+# ProseMirror module serves as the namespace for all ProseMirror components
+module ProseMirror
+  # Helper functions can be added here if needed
+
+  # Convert a JSON ProseMirror document to a ProseMirror::Node tree
+  # @param json_string [String] The JSON string representation of a ProseMirror document
+  # @return [ProseMirror::Node] The root node of the document
+  def self.parse(json_string)
+    Converter.from_json(json_string)
+  end
+
+  # Convert a ProseMirror::Node to Markdown
+  # @param node [ProseMirror::Node] The root node of the document
+  # @param options [Hash] Optional serialization options
+  # @return [String] The markdown representation
+  def self.to_markdown(node, options = {})
+    serializer = Serializers::MarkdownSerializer.new(
+      Serializers::MarkdownSerializer::DEFAULT_NODE_SERIALIZERS,
+      Serializers::MarkdownSerializer::DEFAULT_MARK_SERIALIZERS,
+      options
+    )
+    serializer.serialize(node)
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: prose_mirror_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Ross
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A library for working with ProseMirror documents in Ruby, including conversion
+  between ProseMirror JSON and other formats such as Markdown.
+email:
+- robert@firehydrant.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/prose_mirror.rb
+- lib/prose_mirror/converter.rb
+- lib/prose_mirror/mark.rb
+- lib/prose_mirror/node.rb
+- lib/prose_mirror/serializers/markdown_serializer.rb
+- lib/prose_mirror/version.rb
+homepage: https://github.com/firehydrant/prose_mirror
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/firehydrant/prose_mirror
+  source_code_uri: https://github.com/firehydrant/prose_mirror
+  changelog_uri: https://github.com/firehydrant/prose_mirror/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Ruby implementation of ProseMirror document model
+test_files: []