prosereflect 0.2.0 → 0.3.0

data/lib/prosereflect/output/html.rb

@@ -35,6 +35,31 @@ module Prosereflect
           html
         end
 
+        # Render document with options
+        def render(document, options = {})
+          options = {
+            document: true,
+            text: ->(text, _marks) { text },
+            mark: ->(_mark, content) { content },
+            node: ->(_node, content) { content },
+          }.merge(options)
+
+          serializer = DOMSerializer.new(document.schema, options)
+          serializer.serialize(document)
+        end
+
+        # Render single node with marks
+        def render_node(node, options = {})
+          serializer = DOMSerializer.new(nil, options)
+          serializer.render_node(node)
+        end
+
+        # Render text with marks applied
+        def render_text(text, marks, options = {})
+          serializer = DOMSerializer.new(nil, options)
+          serializer.render_text(text, marks)
+        end
+
         private
 
         # Process a node and its children
@@ -372,5 +397,207 @@ module Prosereflect
         end
       end
     end
+
+    # DOMSerializer provides configurable document serialization to HTML
+    class DOMSerializer
+      attr_reader :schema, :options, :marks
+
+      def initialize(schema, options = {})
+        @schema = schema
+        @options = options
+        @marks = build_mark_serializers
+      end
+
+      def serialize(document)
+        render_node(document)
+      end
+
+      def serialize_node(node)
+        render_node(node)
+      end
+
+      def render_node(node)
+        return render_text(node.text, node.marks) if node.text?
+
+        builder = Nokogiri::HTML::Builder.new
+        render_node_to_builder(node, builder)
+        builder.doc.root.children.to_html
+      end
+
+      def render_node_to_builder(node, builder)
+        content = render_node_content(node)
+        wrap_node(node, content, builder)
+      end
+
+      def render_text(text, node_marks = nil)
+        marks_to_apply = node_marks || []
+        marks_to_apply.each do |mark|
+          text = apply_mark(mark, text)
+        end
+        text
+      end
+
+      def apply_mark(mark, content)
+        mark_handler = @marks[mark.type]
+        return content unless mark_handler
+
+        case mark.type
+        when "bold"
+          "<strong>#{content}</strong>"
+        when "italic"
+          "<em>#{content}</em>"
+        when "code"
+          "<code>#{content}</code>"
+        when "link"
+          href = extract_mark_attr(mark, "href")
+          "<a href=\"#{href}\">#{content}</a>"
+        when "strike"
+          "<del>#{content}</del>"
+        when "underline"
+          "<u>#{content}</u>"
+        when "subscript"
+          "<sub>#{content}</sub>"
+        when "superscript"
+          "<sup>#{content}</sup>"
+        else
+          content
+        end
+      end
+
+      private
+
+      def build_mark_serializers
+        return {} unless @schema
+
+        @schema.marks.transform_values do |_mark_type|
+          ->(mark, content) { apply_mark(mark, content) }
+        end
+      end
+
+      def extract_mark_attr(mark, attr_name)
+        return nil unless mark.respond_to?(:attrs)
+
+        attrs = mark.attrs
+        return nil unless attrs.is_a?(Hash)
+
+        attrs[attr_name]
+      end
+
+      def render_node_content(node)
+        return render_text(node.text, node.marks) if node.text?
+
+        children = node.content.map { |child| render_node(child) }.join
+        apply_node_marks(node, children)
+      end
+
+      def apply_node_marks(node, content)
+        return content unless node.marks && !node.marks.empty?
+
+        node.marks.reverse_each do |mark|
+          content = apply_mark(mark, content)
+        end
+        content
+      end
+
+      def wrap_node(node, content, builder)
+        tag_name = node_tag_name(node)
+        return builder << content unless tag_name
+
+        builder.tag(tag_name, wrap_attrs(node)) do
+          builder << content
+        end
+      end
+
+      def node_tag_name(node)
+        case node.type
+        when "paragraph" then "p"
+        when "heading" then "h#{node.attrs[:level] || 1}"
+        when "table" then "table"
+        when "table_row" then "tr"
+        when "table_cell" then "td"
+        when "table_header" then "th"
+        when "bullet_list" then "ul"
+        when "ordered_list" then "ol"
+        when "list_item" then "li"
+        when "blockquote" then "blockquote"
+        when "hard_break" then "br"
+        when "horizontal_rule" then "hr"
+        when "code_block_wrapper" then "pre"
+        when "code_block" then "code"
+        when "image" then "img"
+        when "doc", "text", "user"
+          nil
+        end
+      end
+
+      def wrap_attrs(node)
+        return nil unless node.respond_to?(:attrs) && node.attrs.is_a?(Hash)
+
+        attrs = {}
+        case node.type
+        when "image"
+          attrs[:src] = node.attrs["src"]
+          attrs[:alt] = node.attrs["alt"] if node.attrs["alt"]
+          attrs[:title] = node.attrs["title"] if node.attrs["title"]
+        when "ordered_list"
+          attrs[:start] = node.attrs["start"] if node.attrs["start"]
+        end
+        attrs.empty? ? nil : attrs
+      end
+
+      # Check if a node should preserve whitespace
+      # Nodes like <pre>, <textarea>, or nodes with style="white-space: pre" preserve whitespace
+      def preserve_whitespace?(node)
+        return false unless node.respond_to?(:type)
+
+        case node.type
+        when "code_block", "code_block_wrapper", "pre"
+          return true
+        end
+
+        # Check for white-space style in attrs
+        if node.respond_to?(:attrs) && node.attrs.is_a?(Hash)
+          style = node.attrs["style"]
+          if style.is_a?(String) && style.include?("white-space: pre")
+            return true
+          end
+        end
+
+        false
+      end
+
+      # Determine how whitespace should be collapsed for a node
+      # Returns a symbol: :preserve, :collapse, :normalize
+      def whitespace_mode(node)
+        if preserve_whitespace?(node)
+          :preserve
+        else
+          :collapse
+        end
+      end
+
+      # Collapse multiple spaces into one
+      def collapse_whitespace(text)
+        text.gsub(/[ \t]+/, " ")
+      end
+
+      # Normalize whitespace (replace tabs/newlines with spaces, collapse multiple spaces)
+      def normalize_whitespace(text)
+        text.gsub(/[\t \n\r]+/, " ")
+      end
+
+      # Process text content with appropriate whitespace handling
+      def process_text_whitespace(text, node)
+        mode = whitespace_mode(node)
+        case mode
+        when :preserve
+          text
+        when :normalize
+          normalize_whitespace(text)
+        else
+          collapse_whitespace(text)
+        end
+      end
+    end
   end
 end

data/lib/prosereflect/parser.rb

@@ -48,6 +48,10 @@ module Prosereflect
                      HorizontalRule
                    when "image"
                      Image
+                   when "code_block"
+                     CodeBlock
+                   when "code_block_wrapper"
+                     CodeBlockWrapper
                    when "user"
                      User
                    else
@@ -95,6 +99,11 @@ module Prosereflect
           node.abbr = attrs["abbr"] if attrs["abbr"]
           node.colspan = attrs["colspan"] if attrs["colspan"]
         end
+      when "code_block"
+        if attrs
+          node.language = attrs["language"] if attrs["language"]
+          node.line_numbers = attrs["line_numbers"] if attrs["line_numbers"]
+        end
       end
 
       node.marks = marks_data if marks_data && !marks_data.empty?

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