prosereflect 0.2.0 → 0.3.0

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/horizontal_rule.rb

@@ -59,6 +59,15 @@ module Prosereflect
     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"
     end

data/lib/prosereflect/image.rb

@@ -94,6 +94,15 @@ module Prosereflect
       }.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"

data/lib/prosereflect/input/html.rb

@@ -478,7 +478,103 @@ module Prosereflect
           user.id = html_node["data-id"]
           user
         end
+
+        # Parse HTML with full schema validation
+        def parse_with_schema(html, schema, _rules = {})
+          document = parse(html)
+          validate_against_schema(document, schema)
+          document
+        rescue ValidationError
+          # Fall back to basic parsing if validation fails
+          document
+        end
+
+        # Parse HTML with custom parse rules
+        def parse_with_rules(html, rules:)
+          options = {
+            keep_empty: rules[:keep_empty] || false,
+            find_wrapping: rules[:find_wrapping],
+            top_node: rules[:top_node],
+            top_start: rules[:top_start],
+          }.merge(rules)
+
+          document = parse(html)
+          apply_parse_rules(document, options)
+        end
+
+        # Parse a single node with context
+        def parse_node(html_node, options = {})
+          parent_node = options[:node]
+          saved_styles = options[:saved_styles] || []
+          top_node = options[:top_node] || false
+          clear_null = options.fetch(:clear_null, true)
+
+          node = convert_node(html_node)
+          return nil if clear_null && node.nil?
+
+          apply_node_options(node, parent_node, saved_styles, top_node)
+        end
+
+        # Check if whitespace should be preserved in node
+        def preserve_whitespace?(node)
+          return true if node.name == "pre"
+          return true if node.name == "textarea"
+
+          style = node["style"]
+          return false unless style
+
+          style.include?("white-space") && style.include?("pre")
+        end
+
+        # Determine space collapsing behavior
+        def collapsed_spaces(node)
+          return :preserve if preserve_whitespace?(node)
+          return :collapse if node.name == "br"
+
+          :collapse
+        end
+
+        # Normalize whitespace in text
+        def normalize_whitespace(text)
+          text.gsub(/\s+/, " ").strip
+        end
+
+        def validate_against_schema(document, schema)
+          # Basic schema validation
+          document.nodes.each do |node|
+            validate_node_against_schema(node, schema)
+          end
+        end
+
+        def validate_node_against_schema(node, schema)
+          node_type = schema.node_type(node.type)
+          return unless node_type
+
+          # Check required content
+          return unless node_type.required_content.any?
+
+          missing = node_type.required_content - (node.content.map(&:type) & node_type.required_content)
+          raise ValidationError, "Missing required content: #{missing.join(', ')}" unless missing.empty?
+        end
+
+        def apply_parse_rules(document, options)
+          return document unless options[:keep_empty]
+
+          document
+        end
+
+        def apply_node_options(node, parent_node, saved_styles, top_node)
+          return node unless node.respond_to?(:marks=)
+
+          if top_node && parent_node
+            # Apply parent context marks
+            node.marks = saved_styles.dup
+          end
+          node
+        end
       end
+
+      class ValidationError < StandardError; end
     end
   end
 end

data/lib/prosereflect/node.rb

@@ -206,18 +206,156 @@ module Prosereflect
       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)
+    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"]
-      elsif node_type == "bullet_list" && attrs["bullet_style"].nil?
-        nil
       else
         attrs
       end

data/lib/prosereflect/ordered_list.rb

@@ -28,6 +28,8 @@ module Prosereflect
 
     def start=(value)
       @start = value
+      return if value.nil?
+
       self.attrs ||= {}
       attrs["start"] = value
     end