prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/mark/strike.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "strike"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Strike < Base
-      PM_TYPE = 'strike'
+      PM_TYPE = "strike"
     end
   end
 end

data/lib/prosereflect/mark/subscript.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "subscript"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Subscript < Base
-      PM_TYPE = 'subscript'
+      PM_TYPE = "subscript"
     end
   end
 end

data/lib/prosereflect/mark/superscript.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "superscript"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Superscript < Base
-      PM_TYPE = 'superscript'
+      PM_TYPE = "superscript"
     end
   end
 end

data/lib/prosereflect/mark/underline.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "underline"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Underline < Base
-      PM_TYPE = 'underline'
+      PM_TYPE = "underline"
     end
   end
 end

data/lib/prosereflect/mark.rb

@@ -2,10 +2,14 @@
 
 module Prosereflect
   module Mark
+    autoload :Base, "#{__dir__}/mark/base"
+    autoload :Bold, "#{__dir__}/mark/bold"
+    autoload :Italic, "#{__dir__}/mark/italic"
+    autoload :Code, "#{__dir__}/mark/code"
+    autoload :Link, "#{__dir__}/mark/link"
+    autoload :Strike, "#{__dir__}/mark/strike"
+    autoload :Subscript, "#{__dir__}/mark/subscript"
+    autoload :Superscript, "#{__dir__}/mark/superscript"
+    autoload :Underline, "#{__dir__}/mark/underline"
   end
 end
-
-require_relative 'mark/bold'
-require_relative 'mark/italic'
-require_relative 'mark/code'
-require_relative 'mark/link'

data/lib/prosereflect/node.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require 'lutaml/model'
-require_relative 'attribute'
-require_relative 'mark'
-
 module Prosereflect
   class Node < Lutaml::Model::Serializable
-    PM_TYPE = 'node'
+    PM_TYPE = "node"
 
     attribute :type, :string
     attribute :attrs, :hash
@@ -14,10 +10,10 @@ module Prosereflect
     attribute :content, Node, polymorphic: true, collection: true
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'attrs', to: :attrs
-      map 'marks', to: :marks
-      map 'content', to: :content
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
+      map "marks", to: :marks
+      map "content", to: :content
     end
 
     def initialize(data = nil, attrs = nil)
@@ -25,18 +21,18 @@ module Prosereflect
         super(type: data, attrs: attrs, content: [])
       elsif data.is_a?(Hash)
         # Handle marks in a special way to preserve expected behavior in tests
-        if data[:marks] || data['marks']
-          marks_data = data[:marks] || data['marks']
+        if data[:marks] || data["marks"]
+          marks_data = data[:marks] || data["marks"]
           data = data.dup
-          data.delete('marks')
+          data.delete("marks")
           data.delete(:marks)
           super(data)
           self.marks = marks_data
         else
           # Handle attrs properly
-          if data[:attrs] || data['attrs']
+          if data[:attrs] || data["attrs"]
             data = data.dup
-            data[:attrs] = process_attrs_data(data[:attrs] || data['attrs'])
+            data[:attrs] = process_attrs_data(data[:attrs] || data["attrs"])
           end
           super(data)
         end
@@ -56,33 +52,35 @@ module Prosereflect
     def self.create(type = nil, attrs = nil)
       new(type || self::PM_TYPE, attrs)
     rescue NameError
-      new(type || 'node', attrs)
+      new(type || "node", attrs)
     end
 
     # Convert to hash for serialization
     def to_h
-      result = { 'type' => type }
+      result = { "type" => type }
 
       if attrs && !attrs.empty?
         if attrs.is_a?(Hash)
-          result['attrs'] = process_node_attributes(attrs, type)
-        elsif attrs.is_a?(Array) && attrs.all? { |attr| attr.respond_to?(:to_h) }
+          result["attrs"] = process_node_attributes(attrs, type)
+        elsif attrs.is_a?(Array) && attrs.all? do |attr|
+          attr.respond_to?(:to_h)
+        end
           # Convert array of attribute objects to a hash
           attrs_array = attrs.map do |attr|
             attr.is_a?(Prosereflect::Attribute::Base) ? attr.to_h : attr
           end
-          result['attrs'] = attrs_array unless attrs_array.empty?
+          result["attrs"] = attrs_array unless attrs_array.empty?
         end
       end
 
       if marks && !marks.empty?
-        result['marks'] = marks.map do |mark|
+        result["marks"] = marks.map do |mark|
           if mark.is_a?(Hash)
             mark
           elsif mark.respond_to?(:to_h)
             mark.to_h
           elsif mark.respond_to?(:type)
-            { 'type' => mark.type.to_s }
+            { "type" => mark.type.to_s }
           else
             raise ArgumentError, "Invalid mark type: #{mark.class}"
           end
@@ -90,8 +88,10 @@ module Prosereflect
       end
 
       if content && !content.empty?
-        result['content'] = if content.is_a?(Array)
-                              content.map { |item| item.respond_to?(:to_h) ? item.to_h : item }
+        result["content"] = if content.is_a?(Array)
+                              content.map do |item|
+                                item.respond_to?(:to_h) ? item.to_h : item
+                              end
                             else
                               [content]
                             end
@@ -112,7 +112,7 @@ module Prosereflect
         elsif mark.respond_to?(:to_h)
           mark.to_h
         elsif mark.respond_to?(:type)
-          { 'type' => mark.type.to_s }
+          { "type" => mark.type.to_s }
         else
           raise ArgumentError, "Invalid mark type: #{mark.class}"
         end
@@ -131,8 +131,8 @@ module Prosereflect
       elsif value.is_a?(Array)
         @marks = value.map do |v|
           if v.is_a?(Hash)
-            type = v['type'] || v[:type]
-            attrs = v['attrs'] || v[:attrs]
+            type = v["type"] || v[:type]
+            attrs = v["attrs"] || v[:attrs]
             begin
               mark_class = Prosereflect::Mark.const_get(type.to_s.capitalize)
               mark_class.new(attrs: attrs)
@@ -197,27 +197,165 @@ module Prosereflect
     def find_children(node_type)
       return [] unless content
 
-      content.select { |child| child.is_a?(node_type) }
+      content.grep(node_type)
     end
 
     def text_content
-      return '' unless content
+      return "" unless content
 
       content.map(&:text_content).join
     end
 
+    # Size of this node in the document tree.
+    # For non-text nodes: 1 (opening token) + sum of children's node_size.
+    # For text nodes: overridden to text.length + 1.
+    def node_size
+      size = 1
+      content&.each { |child| size += child.node_size }
+      size
+    end
+
+    # Whether this node represents a text node.
+    # Overridden to true in Text class.
+    def text?
+      false
+    end
+
+    # Return a copy of this node with content restricted to the given range.
+    # Positions are relative to the start of this node's content.
+    def cut(from = 0, to = nil)
+      to ||= node_size
+      return self if from.zero? && to == node_size
+
+      if text?
+        # Text nodes override this
+        self
+      else
+        copy(cut_content(from, to))
+      end
+    end
+
+    # Iterate over all nodes between two positions in this node.
+    # Accepts a block or a callable as the third positional argument.
+    def nodes_between(from, to, callback = nil, node_start = 0, &block)
+      cb = callback || block
+      return unless cb && to > from && content
+
+      pos = 0
+      content.each_with_index do |child, i|
+        break if pos >= to
+
+        child_end = pos + child.node_size
+        next unless child_end > from
+
+        child_start = node_start + pos + 1
+        if cb.call(child, child_start, i) != false && child.content && child.content.any?
+          child.nodes_between(
+            [0, from - pos - 1].max,
+            [child.content ? child.content.size : 0, to - pos - 1].min,
+            cb,
+            child_start,
+          )
+        end
+
+        pos = child_end
+      end
+    end
+
+    # Iterate over all descendant nodes.
+    def descendants(&block)
+      nodes_between(0, node_size - 1, &block)
+    end
+
+    # Check structural equality with another node.
+    def eq?(other)
+      return false unless other.is_a?(Node)
+
+      type == other.type && to_h == other.to_h
+    end
+
+    # Create a copy of this node with different content.
+    def copy(new_content = nil)
+      new_node = self.class.new(type: type, attrs: attrs, marks: raw_marks)
+      case new_content
+      when nil
+        # no content
+      when Array
+        new_node.content = new_content
+      when Fragment
+        new_node.content = new_content.to_a
+      else
+        new_node.content = [new_content]
+      end
+      new_node
+    end
+
     # Ensures YAML serialization outputs plain data instead of a Ruby object
     def to_yaml(*args)
       to_h.to_yaml(*args)
     end
 
+    # Resolve a document position to a ResolvedPos
+    def resolve(pos)
+      path = []
+      build_path_for_pos(pos, path)
+      depth = [(path.length / 3) - 1, 0].max
+      ResolvedPos.new(pos, path, depth)
+    end
+
+    # Get the node at a given depth in the path
+    def node(depth)
+      @path[depth * 2]
+    end
+
     private
 
-    def process_node_attributes(attrs, node_type)
-      if attrs['attrs'].is_a?(Hash)
-        attrs['attrs']
-      elsif node_type == 'bullet_list' && attrs['bullet_style'].nil?
-        nil
+    def cut_content(from, to)
+      return [] unless content
+
+      result = []
+      pos = 0
+      content.each do |child|
+        child_end = pos + child.node_size
+        if pos >= from && child_end <= to
+          result << child
+        elsif pos < to && child_end > from
+          result << child.cut([0, from - pos - 1].max, child.node_size - [0, child_end - to].max)
+        end
+        pos = child_end
+        break if pos >= to
+      end
+      result
+    end
+
+    def build_path_for_pos(pos, path, index = 0, start_offset = 0)
+      path << self << index << start_offset
+      return if pos.zero?
+
+      traverse_children_for_resolve(pos, path)
+    end
+
+    def traverse_children_for_resolve(pos, path)
+      return unless content
+
+      content_offset = 1
+      child_index = 0
+
+      content.each do |child|
+        child_end = content_offset + child.node_size
+        if pos < child_end
+          child.send(:build_path_for_pos, pos - content_offset, path, child_index, content_offset)
+          return
+        end
+
+        content_offset = child_end
+        child_index += 1
+      end
+    end
+
+    def process_node_attributes(attrs, _node_type)
+      if attrs["attrs"].is_a?(Hash)
+        attrs["attrs"]
       else
         attrs
       end

data/lib/prosereflect/ordered_list.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'list_item'
-
 module Prosereflect
   # OrderedList class represents a numbered list in ProseMirror.
   class OrderedList < Node
-    PM_TYPE = 'ordered_list'
+    PM_TYPE = "ordered_list"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :start, :integer
     attribute :attrs, :hash
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'attrs', to: :attrs
-      map 'content', to: :content
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
+      map "content", to: :content
     end
 
     def initialize(attributes = {})
@@ -29,12 +28,14 @@ module Prosereflect
 
     def start=(value)
       @start = value
+      return if value.nil?
+
       self.attrs ||= {}
-      attrs['start'] = value
+      attrs["start"] = value
     end
 
     def start
-      @start || attrs&.[]('start') || 1
+      @start || attrs&.[]("start") || 1
     end
 
     def add_item(text)
@@ -67,19 +68,21 @@ module Prosereflect
     # Update the order (1 for numerical, 'a' for alphabetical, etc.)
     def order=(order_value)
       self.attrs ||= {}
-      attrs['order'] = order_value
+      attrs["order"] = order_value
     end
 
     # Get the order value
     def order
-      attrs&.[]('order') || 1
+      attrs&.[]("order") || 1
     end
 
     # Get text content with proper formatting
     def text_content
-      return '' unless content
+      return "" unless content
 
-      content.map { |item| item.respond_to?(:text_content) ? item.text_content : '' }.join("\n")
+      content.map do |item|
+        item.respond_to?(:text_content) ? item.text_content : ""
+      end.join("\n")
     end
   end
 end