prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/parser.rb

@@ -1,27 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'text'
-require_relative 'paragraph'
-require_relative 'table'
-require_relative 'table_row'
-require_relative 'table_cell'
-require_relative 'table_header'
-require_relative 'hard_break'
-require_relative 'document'
-require_relative 'heading'
-require_relative 'mark/bold'
-require_relative 'mark/italic'
-require_relative 'mark/code'
-require_relative 'mark/link'
-require_relative 'ordered_list'
-require_relative 'bullet_list'
-require_relative 'list_item'
-require_relative 'blockquote'
-require_relative 'horizontal_rule'
-require_relative 'image'
-require_relative 'user'
-
 module Prosereflect
   class Parser
     def self.parse(data)
@@ -33,57 +11,61 @@ module Prosereflect
     def self.parse_node(data)
       return nil unless data.is_a?(Hash)
 
-      type = data['type']
-      text = data['text']
-      attrs = data['attrs']
-      marks_data = data['marks']
+      type = data["type"]
+      text = data["text"]
+      attrs = data["attrs"]
+      marks_data = data["marks"]
 
       # Find the right class based on type
       node_class = case type
-                   when 'doc'
+                   when "doc"
                      Document
-                   when 'paragraph'
+                   when "paragraph"
                      Paragraph
-                   when 'text'
+                   when "text"
                      Text
-                   when 'table'
+                   when "table"
                      Table
-                   when 'table_row'
+                   when "table_row"
                      TableRow
-                   when 'table_cell'
+                   when "table_cell"
                      TableCell
-                   when 'table_header'
+                   when "table_header"
                      TableHeader
-                   when 'hard_break'
+                   when "hard_break"
                      HardBreak
-                   when 'heading'
+                   when "heading"
                      Heading
-                   when 'ordered_list'
+                   when "ordered_list"
                      OrderedList
-                   when 'bullet_list'
+                   when "bullet_list"
                      BulletList
-                   when 'list_item'
+                   when "list_item"
                      ListItem
-                   when 'blockquote'
+                   when "blockquote"
                      Blockquote
-                   when 'horizontal_rule'
+                   when "horizontal_rule"
                      HorizontalRule
-                   when 'image'
+                   when "image"
                      Image
-                   when 'user'
+                   when "code_block"
+                     CodeBlock
+                   when "code_block_wrapper"
+                     CodeBlockWrapper
+                   when "user"
                      User
                    else
                      Node
                    end
 
-      if type == 'text'
+      if type == "text"
         node = Text.new(text: text)
       else
         node = node_class.create(attrs)
 
         # Process content recursively
-        if data['content'].is_a?(Array)
-          data['content'].each do |content_data|
+        if data["content"].is_a?(Array)
+          data["content"].each do |content_data|
             child_node = parse_node(content_data)
             node.add_child(child_node) if child_node
           end
@@ -92,30 +74,35 @@ module Prosereflect
 
       # Handle special attributes for specific node types
       case type
-      when 'ordered_list'
-        node.start = attrs['start'].to_i if attrs && attrs['start']
-      when 'bullet_list'
-        node.bullet_style = attrs['bullet_style'] if attrs && attrs['bullet_style']
-      when 'blockquote'
-        node.citation = attrs['cite'] if attrs && attrs['cite']
-      when 'horizontal_rule'
+      when "ordered_list"
+        node.start = attrs["start"].to_i if attrs && attrs["start"]
+      when "bullet_list"
+        node.bullet_style = attrs["bullet_style"] if attrs && attrs["bullet_style"]
+      when "blockquote"
+        node.citation = attrs["cite"] if attrs && attrs["cite"]
+      when "horizontal_rule"
+        if attrs
+          node.style = attrs["border_style"] if attrs["border_style"]
+          node.width = attrs["width"] if attrs["width"]
+          node.thickness = attrs["thickness"].to_i if attrs["thickness"]
+        end
+      when "image"
         if attrs
-          node.style = attrs['border_style'] if attrs['border_style']
-          node.width = attrs['width'] if attrs['width']
-          node.thickness = attrs['thickness'].to_i if attrs['thickness']
+          node.src = attrs["src"] if attrs["src"]
+          node.alt = attrs["alt"] if attrs["alt"]
+          node.title = attrs["title"] if attrs["title"]
+          node.dimensions = [attrs["width"]&.to_i, attrs["height"]&.to_i]
         end
-      when 'image'
+      when "table_header"
         if attrs
-          node.src = attrs['src'] if attrs['src']
-          node.alt = attrs['alt'] if attrs['alt']
-          node.title = attrs['title'] if attrs['title']
-          node.dimensions = [attrs['width']&.to_i, attrs['height']&.to_i]
+          node.scope = attrs["scope"] if attrs["scope"]
+          node.abbr = attrs["abbr"] if attrs["abbr"]
+          node.colspan = attrs["colspan"] if attrs["colspan"]
         end
-      when 'table_header'
+      when "code_block"
         if attrs
-          node.scope = attrs['scope'] if attrs['scope']
-          node.abbr = attrs['abbr'] if attrs['abbr']
-          node.colspan = attrs['colspan'] if attrs['colspan']
+          node.language = attrs["language"] if attrs["language"]
+          node.line_numbers = attrs["line_numbers"] if attrs["line_numbers"]
         end
       end
 
@@ -125,8 +112,11 @@ module Prosereflect
     end
 
     def self.parse_document(data)
-      raise ArgumentError, 'Input cannot be nil' if data.nil?
-      raise ArgumentError, "Input must be a hash, got #{data.class}" unless data.is_a?(Hash)
+      raise ArgumentError, "Input cannot be nil" if data.nil?
+      unless data.is_a?(Hash)
+        raise ArgumentError,
+              "Input must be a hash, got #{data.class}"
+      end
 
       document = parse_node(data)
 

data/lib/prosereflect/resolved_pos.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  # ResolvedPos represents a document position that has been resolved
+  # to a specific location in the document tree.
+  #
+  # The path array contains: [parent_node, index, start, parent_node, index, start, ...]
+  # depth 0 = before any nodes, depth N = inside node at path[N*2]
+  class ResolvedPos
+    attr_reader :pos, :path, :depth
+
+    def initialize(pos, path, depth)
+      @pos = pos
+      @path = path
+      @depth = depth
+      @parent_offset = nil
+    end
+
+    # The parent node at current depth
+    def parent
+      @path[@depth * 3]
+    end
+
+    # Index within parent
+    def index(depth = @depth)
+      @path[(depth * 3) + 1]
+    end
+
+    # Start position of current parent node
+    def start(depth = @depth)
+      @path[(depth * 3) + 2]
+    end
+
+    # End position of current parent node
+    def end_(depth = @depth)
+      start(depth) + parent.content.size
+    end
+
+    # The node at a given depth
+    def node(depth = @depth)
+      @path[depth * 3]
+    end
+
+    # Position within the parent node
+    def parent_offset
+      @parent_offset ||= @pos - start
+    end
+
+    # Marks at this position
+    def marks
+      if depth.zero?
+        # At root - no marks
+        []
+      else
+        parent_mark = parent.respond_to?(:marks) ? parent.marks : []
+        parent_mark || []
+      end
+    end
+
+    # Marks between two positions
+    def marks_between(from, to, marks)
+      result = marks.dup
+      nodes_between(from, to) do |node|
+        if node.respond_to?(:marks) && node.marks
+          result = result | node.marks
+        end
+      end
+      result
+    end
+
+    # Find shared depth with another position
+    def shared_depth(other_pos)
+      my_depth = depth
+      other_depth = other_pos.depth
+
+      while my_depth > other_depth
+        my_depth -= 1
+      end
+
+      while other_depth > my_depth
+        other_depth -= 1
+      end
+
+      while my_depth.positive?
+        break unless index(my_depth) == other_pos.index(my_depth)
+
+        my_depth -= 1
+
+      end
+
+      my_depth
+    end
+
+    # Get block range to another position
+    def block_range(other_pos = nil)
+      other_pos ||= self
+      NodeRange.new(self, other_pos)
+    end
+
+    # Check if at block boundary
+    def block?
+      parent.respond_to?(:is_block?) && parent.is_block?
+    end
+
+    # Check if at inline boundary
+    def inline?
+      !block?
+    end
+
+    # Check if in text block
+    def text_block?
+      parent.respond_to?(:is_textblock?) && parent.is_textblock?
+    end
+
+    # Check if at start of parent
+    def start_of_parent?
+      parent_offset.zero?
+    end
+
+    # Check if at end of parent
+    def end_of_parent?
+      parent_offset >= parent.content.size - 1
+    end
+
+    # Get position before current node
+    def before?
+      if depth.zero?
+        @pos.zero?
+      else
+        index.zero?
+      end
+    end
+
+    # Get position after current node
+    def after?
+      if depth.zero?
+        @pos >= 0
+      else
+        index >= parent.content.size
+      end
+    end
+
+    def eq?(other)
+      return false unless other.is_a?(ResolvedPos)
+
+      @pos == other.pos && @depth == other.depth
+    end
+
+    alias == eq?
+
+    def hash
+      [@pos, @depth].hash
+    end
+
+    def to_s
+      "<ResolvedPos #{@pos}:#{depth}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def nodes_between(from, to, &block)
+      return unless to > from
+
+      depth.times do |d|
+        node = node(d)
+        node.nodes_between(from, to, &block) if node.respond_to?(:nodes_between)
+      end
+    end
+  end
+
+  # NodeRange represents a range between two resolved positions
+  class NodeRange
+    attr_reader :start, :end_
+
+    alias end end_
+
+    def initialize(start_resolved, end_resolved)
+      @start = start_resolved
+      @end_ = end_resolved
+    end
+
+    # Content fragment between start and end
+    def content
+      # Would extract the fragment
+      Fragment.new([])
+    end
+
+    # Nodes within this range
+    def nodes
+      result = []
+      start.node.nodes_between(start.pos, end_.pos) { |n| result << n }
+      result
+    end
+
+    def to_s
+      "<NodeRange #{start.pos}:#{end_.pos}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # Extension to Node for position resolution
+  class Node
+    # Resolve a 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
+
+    private
+
+    def find_block_depth(common_depth)
+      block_depth = common_depth
+      while block_depth.positive?
+        current_node = node(block_depth)
+        break if current_node.respond_to?(:is_block?) && current_node.is_block?
+
+        block_depth -= 1
+      end
+      block_depth
+    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
+  end
+end

data/lib/prosereflect/schema/attribute.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    class Attribute
+      attr_reader :name, :default
+
+      def initialize(name:, default: nil, validate: nil)
+        @name = name
+        @default = default
+        @validate = validate
+      end
+
+      def has_default?
+        !@default.nil?
+      end
+
+      def required?
+        !has_default?
+      end
+
+      def validate_value(value)
+        return true if @validate.nil?
+        return @validate.call(value) if @validate.respond_to?(:call)
+
+        # Handle string-based type validation like "string", "number", "string|null"
+        validate_type(value, @validate.to_s)
+      end
+
+      private
+
+      def validate_type(value, type_str)
+        types = type_str.split("|")
+        actual_type = get_type_name(value)
+
+        unless types.include?(actual_type)
+          raise ::Prosereflect::SchemaErrors::ValidationError,
+                "Expected value of type #{types} for attribute #{@name}, got #{actual_type}"
+        end
+        true
+      end
+
+      def get_type_name(value)
+        case value
+        when nil then "null"
+        when String then "string"
+        when Integer, Float then "number"
+        when TrueClass, FalseClass then "boolean"
+        when Hash then "object"
+        when Array then "object"
+        else
+          value.class.name.downcase
+        end
+      end
+    end
+  end
+end