prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/input/html.rb

@@ -1,33 +1,6 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
-require_relative '../document'
-require_relative '../paragraph'
-require_relative '../text'
-require_relative '../table'
-require_relative '../table_row'
-require_relative '../table_cell'
-require_relative '../table_header'
-require_relative '../hard_break'
-require_relative '../mark/bold'
-require_relative '../mark/italic'
-require_relative '../mark/code'
-require_relative '../mark/link'
-require_relative '../mark/strike'
-require_relative '../mark/subscript'
-require_relative '../mark/superscript'
-require_relative '../mark/underline'
-require_relative '../attribute/href'
-require_relative '../ordered_list'
-require_relative '../bullet_list'
-require_relative '../list_item'
-require_relative '../blockquote'
-require_relative '../horizontal_rule'
-require_relative '../image'
-require_relative '../code_block_wrapper'
-require_relative '../code_block'
-require_relative '../heading'
-require_relative '../user'
+require "nokogiri"
 
 module Prosereflect
   module Input
@@ -38,7 +11,7 @@ module Prosereflect
           html_doc = Nokogiri::HTML(html)
           document = Document.create # Use create instead of new to initialize content array
 
-          content_node = html_doc.at_css('body') || html_doc.root
+          content_node = html_doc.at_css("body") || html_doc.root
 
           # Process all child nodes
           process_node_children(content_node, document)
@@ -65,43 +38,43 @@ module Prosereflect
 
         # Convert an HTML node to a ProseMirror node
         def convert_node(html_node)
-          return nil if html_node.comment? || html_node.text? && html_node.text.strip.empty?
+          return nil if html_node.comment? || (html_node.text? && html_node.text.strip.empty?)
 
           case html_node.name
-          when 'text', '#text'
+          when "text", "#text"
             create_text_node(html_node)
-          when 'p'
+          when "p"
             create_paragraph_node(html_node)
           when /^h([1-6])$/
             create_heading_node(html_node, Regexp.last_match(1).to_i)
-          when 'br'
+          when "br"
             HardBreak.new
-          when 'table'
+          when "table"
             create_table_node(html_node)
-          when 'tr'
+          when "tr"
             create_table_row_node(html_node)
-          when 'th', 'td'
+          when "th", "td"
             create_table_cell_node(html_node)
-          when 'ol'
+          when "ol"
             create_ordered_list_node(html_node)
-          when 'ul'
+          when "ul"
             create_bullet_list_node(html_node)
-          when 'li'
+          when "li"
             create_list_item_node(html_node)
-          when 'blockquote'
+          when "blockquote"
             create_blockquote_node(html_node)
-          when 'hr'
+          when "hr"
             create_horizontal_rule_node(html_node)
-          when 'img'
+          when "img"
             create_image_node(html_node)
-          when 'user-mention'
+          when "user-mention"
             create_user_node(html_node)
-          when 'div', 'span'
+          when "div", "span"
             # For containers, we process their children
             handle_container_node(html_node)
-          when 'pre'
+          when "pre"
             create_code_block_wrapper(html_node)
-          when 'strong', 'b', 'em', 'i', 'code', 'a', 'strike', 's', 'del', 'sub', 'sup', 'u'
+          when "strong", "b", "em", "i", "code", "a", "strike", "s", "del", "sub", "sup", "u"
             # For inline elements with text styling, we handle differently
             handle_styled_text(html_node)
           else
@@ -126,13 +99,13 @@ module Prosereflect
         def create_table_node(html_node)
           table = Table.new
 
-          thead = html_node.at_css('thead')
-          thead&.css('tr')&.each do |tr|
+          thead = html_node.at_css("thead")
+          thead&.css("tr")&.each do |tr|
             process_table_row(tr, table, true)
           end
 
-          tbody = html_node.at_css('tbody') || html_node
-          tbody.css('tr').each do |tr|
+          tbody = html_node.at_css("tbody") || html_node
+          tbody.css("tr").each do |tr|
             process_table_row(tr, table, false)
           end
 
@@ -142,7 +115,7 @@ module Prosereflect
         # Process a table row
         def create_table_row_node(html_node)
           row = TableRow.new
-          html_node.css('th, td').each do |cell|
+          html_node.css("th, td").each do |cell|
             row.add_child(create_table_cell_node(cell))
           end
           row
@@ -157,13 +130,13 @@ module Prosereflect
         # Create a table cell node from HTML cell
         def create_table_cell_node(html_node)
           # Create either a TableHeader or TableCell based on the tag name
-          cell = if html_node.name == 'th'
+          cell = if html_node.name == "th"
                    header = TableHeader.create
 
                    # Handle header-specific attributes
-                   header.scope = html_node['scope'] if html_node['scope']
-                   header.abbr = html_node['abbr'] if html_node['abbr']
-                   header.colspan = html_node['colspan'] if html_node['colspan']
+                   header.scope = html_node["scope"] if html_node["scope"]
+                   header.abbr = html_node["abbr"] if html_node["abbr"]
+                   header.colspan = html_node["colspan"] if html_node["colspan"]
 
                    header
                  else
@@ -184,7 +157,7 @@ module Prosereflect
         # Handle a container-like node (div, span, etc.)
         def handle_container_node(html_node)
           # For top-level divs, process children directly
-          if html_node.name == 'div'
+          if html_node.name == "div"
             results = []
             html_node.children.each do |child|
               next if child.text? && child.text.strip.empty?
@@ -224,38 +197,38 @@ module Prosereflect
         def handle_styled_text(html_node)
           # Create mark based on the current node
           mark = case html_node.name
-                 when 'strong', 'b'
+                 when "strong", "b"
                    mark = Mark::Bold.new
-                   mark.type = 'bold'
+                   mark.type = "bold"
                    mark
-                 when 'em', 'i'
+                 when "em", "i"
                    mark = Mark::Italic.new
-                   mark.type = 'italic'
+                   mark.type = "italic"
                    mark
-                 when 'code'
+                 when "code"
                    mark = Mark::Code.new
-                   mark.type = 'code'
+                   mark.type = "code"
                    mark
-                 when 'a'
+                 when "a"
                    mark = Mark::Link.new
-                   mark.type = 'link'
-                   mark.attrs = { 'href' => html_node['href'] } if html_node['href']
+                   mark.type = "link"
+                   mark.attrs = { "href" => html_node["href"] } if html_node["href"]
                    mark
-                 when 'strike', 's', 'del'
+                 when "strike", "s", "del"
                    mark = Mark::Strike.new
-                   mark.type = 'strike'
+                   mark.type = "strike"
                    mark
-                 when 'sub'
+                 when "sub"
                    mark = Mark::Subscript.new
-                   mark.type = 'subscript'
+                   mark.type = "subscript"
                    mark
-                 when 'sup'
+                 when "sup"
                    mark = Mark::Superscript.new
-                   mark.type = 'superscript'
+                   mark.type = "superscript"
                    mark
-                 when 'u'
+                 when "u"
                    mark = Mark::Underline.new
-                   mark.type = 'underline'
+                   mark.type = "underline"
                    mark
                  end
 
@@ -292,7 +265,8 @@ module Prosereflect
         def contains_only_text_or_inline(node)
           node.children.all? do |child|
             child.text? ||
-              %w[strong b em i code a br span strike s del sub sup u].include?(child.name) ||
+              %w[strong b em i code a br span strike s del sub sup
+                 u].include?(child.name) ||
               (child.element? && contains_only_text_or_inline(child))
           end
         end
@@ -302,11 +276,11 @@ module Prosereflect
           list = OrderedList.new
 
           # Handle start attribute
-          start_val = (html_node['start'] || '1').to_i
+          start_val = (html_node["start"] || "1").to_i
           list.start = start_val
 
           # Process list items
-          html_node.css('> li').each do |li|
+          html_node.css("> li").each do |li|
             list.add_child(create_list_item_node(li))
           end
 
@@ -319,11 +293,11 @@ module Prosereflect
           list.bullet_style = nil
 
           # Handle style attribute if present
-          if html_node['style']&.include?('list-style-type')
-            style = case html_node['style']
-                    when /disc/ then 'disc'
-                    when /circle/ then 'circle'
-                    when /square/ then 'square'
+          if html_node["style"]&.include?("list-style-type")
+            style = case html_node["style"]
+                    when /disc/ then "disc"
+                    when /circle/ then "circle"
+                    when /square/ then "square"
                     end
             list.bullet_style = style
           end
@@ -337,7 +311,9 @@ module Prosereflect
           item = ListItem.new
 
           # Handle text content first
-          text_content = html_node.children.select { |child| child.text? || inline_element?(child) }
+          text_content = html_node.children.select do |child|
+            child.text? || inline_element?(child)
+          end
           if text_content.any?
             paragraph = Paragraph.new
             text_content.each do |child|
@@ -348,7 +324,9 @@ module Prosereflect
           end
 
           # Handle nested content
-          html_node.children.reject { |child| child.text? || inline_element?(child) }.each do |child|
+          html_node.children.reject do |child|
+            child.text? || inline_element?(child)
+          end.each do |child|
             node = convert_node(child)
             if node.is_a?(Array)
               node.each { |n| item.add_content(n) }
@@ -364,7 +342,8 @@ module Prosereflect
         def inline_element?(node)
           return false unless node.element?
 
-          %w[strong b em i code a br span strike s del sub sup u].include?(node.name)
+          %w[strong b em i code a br span strike s del sub sup
+             u].include?(node.name)
         end
 
         # Create a blockquote node from HTML blockquote
@@ -372,7 +351,7 @@ module Prosereflect
           quote = Blockquote.new
 
           # Handle cite attribute if present
-          quote.citation = html_node['cite'] if html_node['cite']
+          quote.citation = html_node["cite"] if html_node["cite"]
 
           # Process each child separately to maintain block structure
           html_node.children.each do |child|
@@ -401,8 +380,8 @@ module Prosereflect
           hr = HorizontalRule.new
 
           # Handle style attributes if present
-          if html_node['style']
-            style = html_node['style']
+          if html_node["style"]
+            style = html_node["style"]
 
             # Parse border-style
             hr.style = Regexp.last_match(1) if style =~ /border-style:\s*(solid|dashed|dotted)/
@@ -420,20 +399,20 @@ module Prosereflect
         # Create an image node from HTML img
         def create_image_node(html_node)
           # Skip images without src
-          return nil unless html_node['src']
+          return nil unless html_node["src"]
 
           image = Image.new
 
           # Handle required src attribute
-          image.src = html_node['src']
+          image.src = html_node["src"]
 
           # Handle optional attributes
-          image.alt = html_node['alt'] if html_node['alt']
-          image.title = html_node['title'] if html_node['title']
+          image.alt = html_node["alt"] if html_node["alt"]
+          image.title = html_node["title"] if html_node["title"]
 
           # Handle dimensions
-          width = html_node['width']&.to_i
-          height = html_node['height']&.to_i
+          width = html_node["width"]&.to_i
+          height = html_node["height"]&.to_i
           image.dimensions = [width, height] if width || height
 
           image
@@ -443,17 +422,17 @@ module Prosereflect
         def create_code_block_wrapper(html_node)
           wrapper = CodeBlockWrapper.new
           wrapper.attrs = {
-            'line_numbers' => false
+            "line_numbers" => false,
           }
 
-          code_node = html_node.at_css('code')
+          code_node = html_node.at_css("code")
           if code_node
             block = create_code_block(code_node)
             wrapper.add_child(block)
           end
 
-          wrapper.to_h['attrs'] = {
-            'line_numbers' => false
+          wrapper.to_h["attrs"] = {
+            "line_numbers" => false,
           }
           wrapper
         end
@@ -465,9 +444,9 @@ module Prosereflect
           language = extract_language(html_node)
 
           block.attrs = {
-            'content' => content,
-            'language' => language,
-            'line_numbers' => nil
+            "content" => content,
+            "language" => language,
+            "line_numbers" => nil,
           }
           block.content = content
 
@@ -475,9 +454,9 @@ module Prosereflect
         end
 
         def extract_language(html_node)
-          return nil unless html_node['class']
+          return nil unless html_node["class"]
 
-          return unless html_node['class'] =~ /language-(\w+)/
+          return unless html_node["class"] =~ /language-(\w+)/
 
           Regexp.last_match(1)
         end
@@ -493,13 +472,109 @@ module Prosereflect
         # Create a user mention node from HTML user-mention element
         def create_user_node(html_node)
           # Skip user mentions without data-id
-          return nil unless html_node['data-id']
+          return nil unless html_node["data-id"]
 
           user = User.new
-          user.id = html_node['data-id']
+          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/input.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module Input
+    autoload :Html, "#{__dir__}/input/html"
+  end
+end

data/lib/prosereflect/list_item.rb

@@ -1,22 +1,19 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'paragraph'
-require_relative 'text'
-require_relative 'hard_break'
-
 module Prosereflect
   # ListItem class represents a list item in ProseMirror.
   class ListItem < Node
-    PM_TYPE = 'list_item'
+    PM_TYPE = "list_item"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     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 = {})
@@ -57,9 +54,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/mark/base.rb

@@ -1,47 +1,45 @@
 # frozen_string_literal: true
 
-require 'lutaml/model'
-
 module Prosereflect
   module Mark
     class Base < Lutaml::Model::Serializable
-      PM_TYPE = 'mark'
+      PM_TYPE = "mark"
 
       attribute :type, :string, default: lambda {
         begin
           self.class.const_get(:PM_TYPE)
         rescue StandardError
-          'mark'
+          "mark"
         end
       }
       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 self.create(attrs = nil)
         new(type: const_get(:PM_TYPE), attrs: attrs)
       rescue NameError
-        new(type: 'mark', attrs: attrs)
+        new(type: "mark", attrs: attrs)
       end
 
       # Convert to hash for serialization
       def to_h
-        result = { 'type' => type }
-        result['attrs'] = attrs if attrs && !attrs.empty?
+        result = { "type" => type }
+        result["attrs"] = attrs if attrs && !attrs.empty?
         result
       end
 
       # Override initialize to ensure the type is set correctly
       def initialize(options = {})
-        super(options)
+        super
         # Only set the type to PM_TYPE if no type was provided in options
         self.type = begin
           options[:type] || self.class.const_get(:PM_TYPE)
         rescue StandardError
-          'mark'
+          "mark"
         end
       end
     end

data/lib/prosereflect/mark/bold.rb

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

data/lib/prosereflect/mark/code.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "code"
 # }
 module Prosereflect
   module Mark
     class Code < Base
-      PM_TYPE = 'code'
+      PM_TYPE = "code"
     end
   end
 end

data/lib/prosereflect/mark/italic.rb

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

data/lib/prosereflect/mark/link.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "link",
 #   attrs: {
@@ -12,7 +10,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Link < Base
-      PM_TYPE = 'link'
+      PM_TYPE = "link"
     end
   end
 end