prose_mirror_ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ca1e1715fe8d1e412d15a8ffddb367b6bd3e648029e62372051f343adcf0172
-  data.tar.gz: d5e675c75e8acb88e347d1f38ee30f157d63310d886883ea838ed96e52c9b4c1
+  metadata.gz: 78bc17787531ffe01a656e70876935071859afc98eaf814799c165680f9c689a
+  data.tar.gz: 4d43f410e59748ef8e64335baaa8f328622c17057f7bb03ed41d8806bbe0e23e
 SHA512:
-  metadata.gz: b02364d8907439c6ab5cab1a1c829bd8f5c437300dc72a93c81786e54a32bf0ede115a63280441fe58a2c3effeb973eb91e997e3359bae2e572e4fc1192886d0
-  data.tar.gz: 80ccdbcef5ab0e714185707114402727fbb603d431be68c28a2ab58bb4c5bad61640d5b7b4373fefa89a7a4660f07be805f838d03ff9a5670c4201878f70c978
+  metadata.gz: d97653a9274c6e59271ac20b59dfd9cafe89d85fd7d80583c2b492bbcc2127ee0232cffba75e2b624f0066f888d361ab01c4b8460f294bfd3891bda7932495bf
+  data.tar.gz: ce4af37ef52f6e5a6504dfbd4c6b0a5d780cef3d773cccb8d86ee7aa03d871ae3b6e42894d981b219902c80b4839c08480cb7a7381a34bedc3aedf4d928e5893

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) {
@@ -174,7 +241,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 +255,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 +496,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.1"
 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.1
 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