prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/document.rb

@@ -1,27 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'table'
-require_relative 'paragraph'
-require_relative 'image'
-require_relative 'bullet_list'
-require_relative 'ordered_list'
-require_relative 'blockquote'
-require_relative 'horizontal_rule'
-require_relative 'code_block_wrapper'
-require_relative 'heading'
-require_relative 'user'
-
 module Prosereflect
   # Document class represents a ProseMirror document.
   class Document < Node
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
-    PM_TYPE = 'doc'
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
+    PM_TYPE = "doc"
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'content', to: :content
-      map 'attrs', to: :attrs
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
     end
 
     def self.create(attrs = nil)
@@ -33,12 +23,12 @@ module Prosereflect
       result = super
 
       # Handle array of attribute objects specially for serialization
-      if attrs.is_a?(Array) && attrs.all? { |attr| attr.is_a?(Prosereflect::Attribute::Base) }
+      if attrs.is_a?(Array) && attrs.all?(Prosereflect::Attribute::Base)
         attrs_hash = {}
         attrs.each do |attr|
           attrs_hash.merge!(attr.to_h)
         end
-        result['attrs'] = attrs_hash unless attrs_hash.empty?
+        result["attrs"] = attrs_hash unless attrs_hash.empty?
       end
 
       result
@@ -54,7 +44,7 @@ module Prosereflect
 
     # Add a heading to the document
     def add_heading(level)
-      heading = Heading.new(attrs: { 'level' => level })
+      heading = Heading.new(attrs: { "level" => level })
       add_child(heading)
       heading
     end
@@ -130,9 +120,11 @@ module Prosereflect
 
     # Get plain text content from all nodes
     def text_content
-      return '' unless content
+      return "" unless content
 
-      content.map { |node| node.respond_to?(:text_content) ? node.text_content : '' }.join("\n").strip
+      content.map do |node|
+        node.respond_to?(:text_content) ? node.text_content : ""
+      end.join("\n").strip
     end
   end
 end

data/lib/prosereflect/fragment.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  # Fragment represents a sequence of nodes.
+  # Used for document content, slice content, etc.
+  class Fragment
+    attr_reader :content
+
+    def initialize(content = [])
+      @content = if content.is_a?(Array)
+                   content
+                 elsif content.respond_to?(:to_a)
+                   content.to_a
+                 else
+                   [content]
+                 end
+    end
+
+    # Total size of all nodes in this fragment
+    def size
+      @content.sum { |n| n.respond_to?(:node_size) ? n.node_size : n.text_content.length + 1 }
+    end
+
+    # Check if fragment is empty
+    def empty?
+      @content.empty?
+    end
+
+    # Append another fragment to this one
+    def append(other)
+      if other.is_a?(Fragment)
+        Fragment.new(@content + other.content)
+      else
+        Fragment.new(@content + [other])
+      end
+    end
+
+    # Cut this fragment to a range
+    def cut(from = 0, to = nil)
+      to ||= size
+
+      return Fragment.new([]) if from >= to
+
+      cut_nodes(from, to)
+    end
+
+    def cut_nodes(from, to)
+      result = []
+      pos = 0
+
+      @content.each do |node|
+        node_end = pos + node.node_size
+
+        result << node if in_range_before_from?(pos, node_end, from)
+        result << node if overlaps_range?(pos, node_end, from, to)
+
+        pos = node_end
+        break if pos >= to
+      end
+
+      Fragment.new(result)
+    end
+
+    def in_range_before_from?(_pos, node_end, from)
+      node_end <= from
+    end
+
+    def overlaps_range?(pos, node_end, from, to)
+      (pos >= from && node_end <= to) || (pos < from && node_end > from)
+    end
+
+    # Replace child at index
+    def replace_child(index, replacement)
+      new_content = @content.dup
+      new_content[index] = replacement
+      Fragment.new(new_content)
+    end
+
+    # Iterate over all nodes between positions
+    def nodes_between(from, to, callback = nil, node_start = 0, &blk)
+      cb = callback || blk
+      return unless cb && to > from
+
+      pos = 0
+
+      @content.each do |node|
+        node_end = pos + node.node_size
+        next unless node_end > from
+
+        dispatch_node_callback(node, pos, node_end, from, to, cb, node_start)
+        pos = node_end
+        break if pos >= to
+      end
+    end
+
+    def dispatch_node_callback(node, pos, node_end, from, to, callback, node_start)
+      if node.text?
+        text_node_callback(node, pos, from, node_start, callback)
+      elsif node_fully_in_range?(pos, node_end, from, to)
+        full_node_callback(node, pos, node_end, from, to, callback, node_start)
+      elsif node_overlaps_from?(pos, node_end, from)
+        partial_node_callback(node, pos, node_end, from, to, callback, node_start)
+      end
+    end
+
+    def text_node_callback(node, pos, from, node_start, callback)
+      callback.call(node, node_start + (from - pos).clamp(0, node.node_size - 1))
+    end
+
+    def node_fully_in_range?(pos, node_end, from, to)
+      pos >= from && node_end <= to
+    end
+
+    def full_node_callback(node, _pos, _node_end, _from, _to, callback, node_start)
+      callback.call(node, node_start)
+      recurse_into_node(node, 0, node.content.size, callback, node_start)
+    end
+
+    def partial_node_callback(node, pos, _node_end, from, to, callback, node_start)
+      recurse_into_node(node, from - pos, [to - pos, node.content.size].min, callback, node_start)
+    end
+
+    def node_overlaps_from?(pos, node_end, from)
+      pos < from && node_end > from
+    end
+
+    def recurse_into_node(node, start_pos, end_pos, callback, node_start)
+      return unless node.respond_to?(:nodes_between)
+
+      node.nodes_between(start_pos, end_pos, callback, node_start)
+    end
+
+    # Iterate over all descendant nodes
+    def descendants(block, node_start = 0)
+      nodes_between(0, size, block, node_start)
+    end
+
+    # Extract text content between positions
+    def text_between(_from, _to, separator = "", _block_separator = "\n")
+      result = []
+      @content.each do |node|
+        if node.respond_to?(:text)
+          result << node.text
+        elsif node.respond_to?(:text_content)
+          result << node.text_content
+        end
+      end
+      result.join(separator)
+    end
+
+    # Find first position where two fragments differ
+    def find_diff_start(other)
+      min_length = [@content.length, other.content.length].min
+
+      pos = 0
+      min_length.times do |i|
+        return pos if @content[i] != other.content[i]
+
+        pos += @content[i].node_size
+      end
+
+      return nil if @content.length == other.content.length
+
+      pos
+    end
+
+    # Find last position where two fragments differ
+    def find_diff_end(other)
+      my_nodes = @content.reverse
+      other_nodes = other.content.reverse
+
+      i = 0
+      end_pos = size
+
+      while i < my_nodes.length && i < other_nodes.length
+        my_node = my_nodes[i]
+        other_node = other_nodes[i]
+
+        unless my_node == other_node
+          return end_pos
+        end
+
+        end_pos -= my_node.node_size
+        i += 1
+      end
+
+      nil
+    end
+
+    # Check equality
+    def eq?(other)
+      return false unless other.is_a?(Fragment)
+
+      @content.length == other.content.length &&
+        @content.zip(other.content).all? { |a, b| a.to_h == b.to_h }
+    end
+
+    alias == eq?
+
+    # Hash for use in sets/hashes
+    def hash
+      @content.map(&:to_h).hash
+    end
+
+    # Access by index
+    def [](index)
+      @content[index]
+    end
+
+    # Iterate
+    def each(&block)
+      @content.each(&block)
+    end
+
+    # Number of items
+    def length
+      @content.length
+    end
+
+    alias count length
+
+    # Convert to array
+    def to_a
+      @content.dup
+    end
+
+    # Create empty fragment
+    def self.empty
+      @empty ||= new([])
+    end
+
+    # Create from content
+    def self.from(content)
+      case content
+      when Fragment then content
+      when Array then new(content.flatten)
+      else new([content])
+      end
+    end
+
+    def to_s
+      "<Fragment #{@content.length} nodes>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/prosereflect/hard_break.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   class HardBreak < Node
-    PM_TYPE = 'hard_break'
+    PM_TYPE = "hard_break"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'marks', to: :marks
+      map "type", to: :type, render_default: true
+      map "marks", to: :marks
     end
 
     def self.create(marks = nil)

data/lib/prosereflect/heading.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'text'
-
 module Prosereflect
   class Heading < Node
-    PM_TYPE = 'heading'
+    PM_TYPE = "heading"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :level, :integer
     attribute :attrs, :hash
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'content', to: :content
-      map 'attrs', to: :attrs
-      map 'marks', to: :marks
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
+      map "marks", to: :marks
     end
 
     def initialize(params = {})
@@ -25,7 +24,7 @@ module Prosereflect
       # Extract level from attrs if provided
       return unless params[:attrs]
 
-      @level = params[:attrs]['level']
+      @level = params[:attrs]["level"]
     end
 
     def self.create(attrs = nil)
@@ -35,15 +34,15 @@ module Prosereflect
     def level=(value)
       @level = value
       self.attrs ||= {}
-      attrs['level'] = value
+      attrs["level"] = value
     end
 
     def level
-      @level || attrs&.[]('level')
+      @level || attrs&.[]("level")
     end
 
     def text_content
-      return '' unless content
+      return "" unless content
 
       content.map(&:text_content).join
     end
@@ -56,8 +55,8 @@ module Prosereflect
 
     def to_h
       result = super
-      result['attrs'] ||= {}
-      result['attrs']['level'] = level if level
+      result["attrs"] ||= {}
+      result["attrs"]["level"] = level if level
       result
     end
   end

data/lib/prosereflect/horizontal_rule.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # HorizontalRule class represents a horizontal rule in ProseMirror.
   class HorizontalRule < Node
-    PM_TYPE = 'horizontal_rule'
+    PM_TYPE = "horizontal_rule"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :style, :string
     attribute :width, :string
     attribute :thickness, :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 = {})
@@ -31,36 +31,45 @@ module Prosereflect
     def style=(value)
       @style = value
       self.attrs ||= {}
-      attrs['style'] = value
+      attrs["style"] = value
     end
 
     def style
-      @style || attrs&.[]('style')
+      @style || attrs&.[]("style")
     end
 
     def width=(value)
       @width = value
       self.attrs ||= {}
-      attrs['width'] = value
+      attrs["width"] = value
     end
 
     def width
-      @width || attrs&.[]('width')
+      @width || attrs&.[]("width")
     end
 
     def thickness=(value)
       @thickness = value
       self.attrs ||= {}
-      attrs['thickness'] = value
+      attrs["thickness"] = value
     end
 
     def thickness
-      @thickness || attrs&.[]('thickness')
+      @thickness || attrs&.[]("thickness")
     end
 
     # Override content-related methods since horizontal rules don't have content
+    def to_h
+      hash = super
+      if hash["attrs"]
+        %w[style width thickness].each { |k| hash["attrs"].delete(k) if hash["attrs"][k].nil? }
+        hash.delete("attrs") if hash["attrs"].empty?
+      end
+      hash
+    end
+
     def add_child(*)
-      raise NotImplementedError, 'Horizontal rule nodes cannot have children'
+      raise NotImplementedError, "Horizontal rule nodes cannot have children"
     end
 
     def content

data/lib/prosereflect/image.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # Image class represents a ProseMirror image node.
   # It handles image attributes like src, alt, title, dimensions, etc.
   class Image < Node
-    PM_TYPE = 'image'
+    PM_TYPE = "image"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :src, :string
     attribute :alt, :string
     attribute :title, :string
@@ -17,8 +17,8 @@ module Prosereflect
     attribute :attrs, :hash
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'attrs', to: :attrs
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
     end
 
     def initialize(attributes = {})
@@ -27,11 +27,11 @@ module Prosereflect
 
       # Extract attributes from the attrs hash if provided
       if attributes[:attrs]
-        @src = attributes[:attrs]['src']
-        @alt = attributes[:attrs]['alt']
-        @title = attributes[:attrs]['title']
-        @width = attributes[:attrs]['width']
-        @height = attributes[:attrs]['height']
+        @src = attributes[:attrs]["src"]
+        @alt = attributes[:attrs]["alt"]
+        @title = attributes[:attrs]["title"]
+        @width = attributes[:attrs]["width"]
+        @height = attributes[:attrs]["height"]
       end
 
       super
@@ -45,35 +45,35 @@ module Prosereflect
     def src=(src_url)
       @src = src_url
       self.attrs ||= {}
-      attrs['src'] = src_url
+      attrs["src"] = src_url
     end
 
     # Update the alt text
     def alt=(alt_text)
       @alt = alt_text
       self.attrs ||= {}
-      attrs['alt'] = alt_text
+      attrs["alt"] = alt_text
     end
 
     # Update the title (tooltip)
     def title=(title_text)
       @title = title_text
       self.attrs ||= {}
-      attrs['title'] = title_text
+      attrs["title"] = title_text
     end
 
     # Update the width
     def width=(value)
       @width = value
       self.attrs ||= {}
-      attrs['width'] = value
+      attrs["width"] = value
     end
 
     # Update the height
     def height=(value)
       @height = value
       self.attrs ||= {}
-      attrs['height'] = value
+      attrs["height"] = value
     end
 
     # Update dimensions (width and height)
@@ -90,13 +90,22 @@ module Prosereflect
         alt: alt,
         title: title,
         width: width,
-        height: height
+        height: height,
       }.compact
     end
 
+    def to_h
+      hash = super
+      if hash["attrs"]
+        %w[title width height].each { |k| hash["attrs"].delete(k) if hash["attrs"][k].nil? }
+        hash.delete("attrs") if hash["attrs"].empty?
+      end
+      hash
+    end
+
     # Override content-related methods since images don't have content
     def add_child(*)
-      raise NotImplementedError, 'Image nodes cannot have children'
+      raise NotImplementedError, "Image nodes cannot have children"
     end
 
     def content
@@ -104,23 +113,23 @@ module Prosereflect
     end
 
     def src
-      @src || attrs&.[]('src')
+      @src || attrs&.[]("src")
     end
 
     def alt
-      @alt || attrs&.[]('alt')
+      @alt || attrs&.[]("alt")
     end
 
     def title
-      @title || attrs&.[]('title')
+      @title || attrs&.[]("title")
     end
 
     def width
-      @width || attrs&.[]('width')
+      @width || attrs&.[]("width")
     end
 
     def height
-      @height || attrs&.[]('height')
+      @height || attrs&.[]("height")
     end
   end
 end