prose_mirror_ruby 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ca1e1715fe8d1e412d15a8ffddb367b6bd3e648029e62372051f343adcf0172
-  data.tar.gz: d5e675c75e8acb88e347d1f38ee30f157d63310d886883ea838ed96e52c9b4c1
+  metadata.gz: 997123de42d6971c9247120b96c785e771688b0e6d0555d0ba0f6f0a2810b45e
+  data.tar.gz: e03ebfd450a7265dbeae8f3bc257464116a526a6921f40cd842a857ae9507459
 SHA512:
-  metadata.gz: b02364d8907439c6ab5cab1a1c829bd8f5c437300dc72a93c81786e54a32bf0ede115a63280441fe58a2c3effeb973eb91e997e3359bae2e572e4fc1192886d0
-  data.tar.gz: 80ccdbcef5ab0e714185707114402727fbb603d431be68c28a2ab58bb4c5bad61640d5b7b4373fefa89a7a4660f07be805f838d03ff9a5670c4201878f70c978
+  metadata.gz: eefad1d1c11004d5d7b1ae3586185b52b589d9a84d3c8c8d7368e48587035dc6dc981687edca8fa96e27beab326d0f5fb86ff9b3ae6c1295f38bd55a2cd45308
+  data.tar.gz: 160e9d5b278280935b2b5550ff8062df6c4241a6d549a13d6c4ce17b4871ccb40f1455a43cd4980db9e92fe594203ae54d2a58ae7f2cf803c14081a2d9e714db

data/README.md

@@ -134,6 +134,18 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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).
 
+For developers looking to contribute or extend this gem, the test suite includes examples of various complex ProseMirror document structures including:
+
+- Blockquotes with embedded lists
+- Linked images
+- Nested lists (ordered and unordered)
+- Mixed formatting (bold and italic combined)
+- Code blocks with language specification
+- Horizontal rules
+- Tables (pending implementation)
+
+These tests serve as documentation for how different structures are (or should be) handled.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/firehydrant/prose_mirror.
@@ -141,6 +153,19 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/firehy
 ## Known Issues
 
 - Markdown serialization for lists and code blocks may not produce perfect output in all cases. Contributions to improve this are welcome.
+- Complex document structures like nested lists, linked images, and tables have varying levels of support:
+  - Basic formatting (bold, italic, links) works well
+  - Blockquotes with lists now have improved formatting
+  - Nested lists have significantly improved indentation and spacing
+  - Complex alternating list types (switching between ordered and bullet lists) now render with better formatting
+  - Tables are not currently supported
+- Custom mark types (beyond the standard strong, em, link, code) may not be properly rendered
+
+## Recent Improvements
+
+- **Better Nested List Handling**: The library now supports improved indentation for nested lists (e.g., ordered lists inside bullet lists or vice versa), making the generated Markdown more readable.
+- **CamelCase Support**: The library now automatically converts camelCase node types (like "orderedList") to snake_case ("ordered_list"), making it compatible with a wider range of ProseMirror documents and schemas.
+- **Enhanced List Rendering**: Completely refactored list rendering with better indentation, spacing, and handling of complex nested structures.
 
 ## License
 

data/lib/prose_mirror/converter.rb

@@ -15,7 +15,8 @@ module ProseMirror
     # @param node_data [Hash] The node data from JSON
     # @return [Node] The parsed node
     def self.parse_node(node_data)
-      type = node_data["type"]
+      # Convert camelCase node types to snake_case (e.g., "orderedList" -> "ordered_list")
+      type = node_data["type"].underscore
       attrs = parse_attrs(node_data["attrs"] || {})
       marks = parse_marks(node_data["marks"] || [])
 
@@ -35,7 +36,8 @@ module ProseMirror
     def self.parse_attrs(attrs_data)
       result = {}
       attrs_data.each do |key, value|
-        result[key.to_sym] = value
+        # Convert camelCase attr keys to snake_case as well
+        result[key.underscore.to_sym] = value
       end
       result
     end
@@ -45,7 +47,9 @@ module ProseMirror
     # @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"] || {}))
+        # Convert camelCase mark types to snake_case
+        mark_type = mark_data["type"].underscore
+        Mark.new(mark_type, parse_attrs(mark_data["attrs"] || {}))
       end
     end
   end

data/lib/prose_mirror/serializers/markdown_serializer.rb

@@ -10,7 +10,15 @@ module ProseMirror
       # Default serializers for various node types
       DEFAULT_NODE_SERIALIZERS = {
         blockquote: ->(state, node, parent = nil, index = nil) {
+          # Track that we're in a blockquote to handle lists within blockquotes properly
+          old_in_blockquote = state.instance_variable_get(:@in_blockquote) || false
+          state.instance_variable_set(:@in_blockquote, true)
+
+          # Use the standard blockquote prefix for all content
           state.wrap_block("> ", nil, node) { state.render_content(node) }
+
+          # Restore the blockquote state
+          state.instance_variable_set(:@in_blockquote, old_in_blockquote)
         },
 
         code_block: ->(state, node, parent = nil, index = nil) {
@@ -38,27 +46,86 @@ module ProseMirror
         },
 
         bullet_list: ->(state, node, parent = nil, index = nil) {
-          state.render_list(node, "  ", ->(_) { (node.attrs[:bullet] || "*") + " " })
+          # Special handling for lists inside blockquotes
+          if state.instance_variable_get(:@in_blockquote)
+            # For lists in blockquotes, add the blockquote prefix to each line
+            # Each list item should start with "> * "
+            state.render_list(node, "", ->(_) { "* " }, true)
+          else
+            # Standard list rendering
+            state.render_list(node, "  ", ->(_) { "* " })
+          end
         },
 
         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 + ". "
-          })
+          # Special handling for ordered lists inside blockquotes
+          if state.instance_variable_get(:@in_blockquote)
+            # For lists in blockquotes, add the blockquote prefix to each line
+            # Each list item should start with "> 1. " etc.
+            state.render_list(node, "", ->(i) {
+              "#{start + i}. "
+            }, true)
+          else
+            # Standard ordered list rendering
+            state.render_list(node, "  ", ->(i) {
+              "#{start + i}. "
+            })
+          end
         },
 
         list_item: ->(state, node, parent = nil, index = nil) {
-          state.render_content(node)
+          # Track that we're processing a list item to handle nested lists
+          old_in_list_item = state.instance_variable_get(:@in_list_item) || false
+          state.instance_variable_set(:@in_list_item, true)
+
+          # Special handling for list items in blockquotes
+          if state.instance_variable_get(:@in_blockquote)
+            # Process the list item content with special handling
+            node.each_with_index do |child, i|
+              if child.type.name == "paragraph"
+                # Render paragraph content directly
+                state.render_inline(child)
+              else
+                # Render other content normally
+                state.render(child, node, i)
+              end
+            end
+          else
+            # Process the list item content normally
+            state.render_content(node)
+          end
+
+          # Restore the previous state
+          state.instance_variable_set(:@in_list_item, old_in_list_item)
         },
 
         paragraph: ->(state, node, parent = nil, index = nil) {
-          state.render_inline(node)
-          state.close_block(node)
+          # Special handling for paragraphs inside list items to avoid extra whitespace
+          if state.instance_variable_get(:@in_list_item)
+            # Create a clean paragraph renderer for list items
+            old_at_block_start = state.instance_variable_get(:@at_block_start)
+
+            # Render the paragraph content directly with minimal whitespace
+            state.render_inline(node)
+
+            # Restore state
+            state.instance_variable_set(:@at_block_start, old_at_block_start)
+          elsif state.instance_variable_get(:@in_blockquote) && parent&.type&.name == "bullet_list"
+            # Special handling for paragraphs in bullet lists inside blockquotes
+            old_at_block_start = state.instance_variable_get(:@at_block_start)
+
+            # Render with blockquote prefix
+            state.render_inline(node)
+
+            # Restore state
+            state.instance_variable_set(:@at_block_start, old_at_block_start)
+          else
+            # Normal paragraph rendering for non-list items
+            state.render_inline(node)
+            state.close_block(node)
+          end
         },
 
         image: ->(state, node, parent = nil, index = nil) {
@@ -79,6 +146,62 @@ module ProseMirror
 
         text: ->(state, node, parent = nil, index = nil) {
           state.text(node.text, !state.in_autolink)
+        },
+
+        # Table serialization support
+        table: ->(state, node, parent = nil, index = nil) {
+          # Track that we're in a table
+          old_in_table = state.instance_variable_get(:@in_table) || false
+          state.instance_variable_set(:@in_table, true)
+
+          # Render table content
+          state.render_content(node)
+
+          # Restore table state
+          state.instance_variable_set(:@in_table, old_in_table)
+
+          # Only add newline if not at the end of the document
+          if parent && index < parent.child_count - 1
+            state.close_block(node)
+          end
+        },
+
+        table_row: ->(state, node, parent = nil, index = nil) {
+          # Write row separator after headers
+          if index == 1 && parent && parent.child(0).content.any? { |cell| cell.type.name == "table_header" }
+            state.write("|")
+            node.content.each do |_|
+              state.write(" --- |")
+            end
+            state.write("\n")
+          end
+
+          # Write row content
+          state.write("|")
+          state.render_content(node)
+
+          # Add newline unless this is the last row
+          if parent && index < parent.child_count - 1
+            state.write("\n")
+          end
+        },
+
+        table_header: ->(state, node, parent = nil, index = nil) {
+          state.write(" ")
+          # Render content with marks
+          node.content.each do |cell_content|
+            state.render_inline(cell_content)
+          end
+          state.write(" |")
+        },
+
+        table_cell: ->(state, node, parent = nil, index = nil) {
+          state.write(" ")
+          # Render content with marks
+          node.content.each do |cell_content|
+            state.render_inline(cell_content)
+          end
+          state.write(" |")
         }
       }
 
@@ -174,7 +297,7 @@ module ProseMirror
 
     # 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_accessor :delim, :out, :closed, :in_autolink, :at_block_start, :in_tight_list, :in_blockquote
       attr_reader :nodes, :marks, :options
 
       # Initialize a new state object
@@ -188,6 +311,7 @@ module ProseMirror
         @in_autolink = nil
         @at_block_start = false
         @in_tight_list = false
+        @in_blockquote = false
 
         @options[:tight_lists] = false if @options[:tight_lists].nil?
         @options[:hard_break_node_name] = "hard_break" if @options[:hard_break_node_name].nil?
@@ -428,23 +552,62 @@ module ProseMirror
       end
 
       # Render a list
-      def render_list(node, delim, first_delim)
+      def render_list(node, indent, marker_gen, in_blockquote = false)
+        # Clear any closed block
         if @closed && @closed.type == node.type
           @closed = nil
         else
           ensure_new_line
         end
 
-        starting = @delim
+        # Remember current indentation level
+        old_indent = @delim
+        is_nested = !old_indent.empty?
+
+        # Set up tight list handling
+        old_tight = @in_tight_list
+        @in_tight_list = node.attrs[:tight]
 
+        # Process each list item
         node.each_with_index do |child, i|
-          old_tight = @in_tight_list
-          @in_tight_list = node.attrs[:tight]
-          @delim = starting + first_delim.call(i)
+          # For blockquote lists, add the blockquote prefix
+          @delim = if in_blockquote
+            "> "
+          # For nested lists, add standard indentation
+          elsif is_nested
+            "    "
+          else
+            ""
+          end
+
+          # Write the marker with proper spacing
+          write(marker_gen.call(i))
+
+          # Store the current position after the marker
+          old_delim = @delim
+
+          # Add exactly one space after the marker for content
+          @delim = old_delim + " "
+
+          # Render the item's content
           render(child, node, i)
-          @in_tight_list = old_tight
+
+          # Restore delimiter for next item
+          @delim = old_delim
+
+          # Add a newline after each list item unless it's the last one
+          unless i == node.child_count - 1
+            ensure_new_line
+          end
         end
 
+        # Restore the tight list setting
+        @in_tight_list = old_tight
+
+        # Restore the original indentation
+        @delim = old_indent
+
+        # Handle spacing between list items and the next content
         size = (@closed && @closed.type.name == "paragraph" && !node.attrs[:tight]) ? 2 : 1
         flush_close(size)
       end

data/lib/prose_mirror/version.rb

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

data/lib/prose_mirror.rb

@@ -1,5 +1,6 @@
 require "json"
 require "ostruct"
+require "active_support/core_ext/string/inflections" # For underscore
 
 # Require all ProseMirror components
 require_relative "prose_mirror/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prose_mirror_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Robert Ross
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2025-03-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement