prosereflect 0.2.0 → 0.3.0

data/spec/prosereflect/input/html_spec.rb

@@ -648,9 +648,9 @@ RSpec.describe Prosereflect::Input::Html do
           "content" => [{
             "type" => "code_block",
             "attrs" => {
-              "content" => "def example\n  puts \"Hello\"\nend",
               "language" => "ruby",
             },
+            "content" => ["def example\n  puts \"Hello\"\nend"],
           }],
         }],
       }
@@ -794,4 +794,200 @@ RSpec.describe Prosereflect::Input::Html do
       expect(document.to_h).to eq(expected)
     end
   end
+
+  describe ".parse_with_schema" do
+    it "parses HTML and returns a document when validation is bypassed" do
+      html = "<p>Hello world</p>"
+      allow(described_class).to receive(:validate_against_schema)
+      document = described_class.send(:parse_with_schema, html, nil)
+      expect(document).to be_a(Prosereflect::Document)
+      expect(document.to_h["content"].first["type"]).to eq("paragraph")
+    end
+
+    it "preserves document content when validation is bypassed" do
+      html = "<p>Schema test</p>"
+      allow(described_class).to receive(:validate_against_schema)
+      document = described_class.send(:parse_with_schema, html, nil)
+      para = document.to_h["content"].first
+      text_node = para["content"].first
+      expect(text_node["text"]).to eq("Schema test")
+    end
+
+    it "parses complex HTML with validation bypassed" do
+      html = "<h1>Title</h1><p>Paragraph with <strong>bold</strong> text</p>"
+      allow(described_class).to receive(:validate_against_schema)
+      document = described_class.send(:parse_with_schema, html, nil)
+      content = document.to_h["content"]
+      expect(content.length).to eq(2)
+      expect(content[0]["type"]).to eq("heading")
+      expect(content[1]["type"]).to eq("paragraph")
+    end
+
+    it "rescues ValidationError and returns the document" do
+      html = "<p>Validation error test</p>"
+      allow(described_class).to receive(:validate_against_schema).and_raise(
+        Prosereflect::Input::Html::ValidationError, "Missing required content"
+      )
+      document = described_class.send(:parse_with_schema, html, nil)
+      expect(document).to be_a(Prosereflect::Document)
+      expect(document.to_h["content"].first["type"]).to eq("paragraph")
+    end
+  end
+
+  describe ".parse_with_rules" do
+    it "parses HTML with keep_empty option" do
+      html = "<p>Keep empty test</p>"
+      document = described_class.send(:parse_with_rules, html, rules: { keep_empty: true })
+      expect(document).to be_a(Prosereflect::Document)
+      expect(document.to_h["content"].first["type"]).to eq("paragraph")
+    end
+
+    it "parses HTML with empty rules" do
+      html = "<p>Empty rules test</p>"
+      document = described_class.send(:parse_with_rules, html, rules: {})
+      expect(document).to be_a(Prosereflect::Document)
+    end
+
+    it "preserves content with keep_empty false" do
+      html = "<p>Keep empty false</p>"
+      document = described_class.send(:parse_with_rules, html, rules: { keep_empty: false })
+      para = document.to_h["content"].first
+      text_node = para["content"].first
+      expect(text_node["text"]).to eq("Keep empty false")
+    end
+
+    it "accepts top_node option" do
+      html = "<p>Top node test</p>"
+      document = described_class.send(:parse_with_rules, html, rules: { top_node: "doc" })
+      expect(document.to_h["type"]).to eq("doc")
+    end
+  end
+
+  describe ".parse_node" do
+    it "parses a single HTML paragraph node" do
+      doc = Nokogiri::HTML("<p>Single node</p>")
+      html_node = doc.at_css("p")
+      result = described_class.send(:parse_node, html_node)
+      expect(result).to be_a(Prosereflect::Paragraph)
+    end
+
+    it "parses a text node" do
+      doc = Nokogiri::HTML("<p>text content</p>")
+      html_node = doc.at_css("p").children.first
+      result = described_class.send(:parse_node, html_node)
+      expect(result).to be_a(Prosereflect::Text)
+      expect(result.text).to eq("text content")
+    end
+
+    it "returns nil for empty text nodes with clear_null" do
+      doc = Nokogiri::HTML("<p> </p>")
+      html_node = doc.at_css("p").children.first
+      result = described_class.send(:parse_node, html_node, clear_null: true)
+      expect(result).to be_nil
+    end
+
+    it "returns nil for empty text nodes by default" do
+      doc = Nokogiri::HTML("<p>   </p>")
+      html_node = doc.at_css("p").children.first
+      result = described_class.send(:parse_node, html_node)
+      expect(result).to be_nil
+    end
+
+    it "accepts node option for parent context" do
+      doc = Nokogiri::HTML("<p>parent context</p>")
+      html_node = doc.at_css("p")
+      parent_node = Prosereflect::Document.new
+      result = described_class.send(:parse_node, html_node, node: parent_node)
+      expect(result).to be_a(Prosereflect::Paragraph)
+    end
+
+    it "accepts saved_styles option" do
+      doc = Nokogiri::HTML("<p>styled</p>")
+      html_node = doc.at_css("p")
+      result = described_class.send(:parse_node, html_node, saved_styles: [])
+      expect(result).to be_a(Prosereflect::Paragraph)
+    end
+  end
+
+  describe ".preserve_whitespace?" do
+    it "returns true for pre elements" do
+      doc = Nokogiri::HTML("<pre>code</pre>")
+      pre_node = doc.at_css("pre")
+      expect(described_class.send(:preserve_whitespace?, pre_node)).to be true
+    end
+
+    it "returns true for textarea elements" do
+      doc = Nokogiri::HTML("<textarea>text</textarea>")
+      textarea_node = doc.at_css("textarea")
+      expect(described_class.send(:preserve_whitespace?, textarea_node)).to be true
+    end
+
+    it "returns true for elements with white-space: pre style" do
+      doc = Nokogiri::HTML('<div style="white-space: pre">text</div>')
+      div_node = doc.at_css("div")
+      expect(described_class.send(:preserve_whitespace?, div_node)).to be true
+    end
+
+    it "returns false for paragraph elements" do
+      doc = Nokogiri::HTML("<p>text</p>")
+      p_node = doc.at_css("p")
+      expect(described_class.send(:preserve_whitespace?, p_node)).to be false
+    end
+
+    it "returns false for elements without white-space style" do
+      doc = Nokogiri::HTML('<div style="color: red">text</div>')
+      div_node = doc.at_css("div")
+      expect(described_class.send(:preserve_whitespace?, div_node)).to be false
+    end
+
+    it "returns false for elements without style attribute" do
+      doc = Nokogiri::HTML("<div>text</div>")
+      div_node = doc.at_css("div")
+      expect(described_class.send(:preserve_whitespace?, div_node)).to be false
+    end
+
+    it "returns false for elements with white-space but not pre" do
+      doc = Nokogiri::HTML('<div style="white-space: nowrap">text</div>')
+      div_node = doc.at_css("div")
+      expect(described_class.send(:preserve_whitespace?, div_node)).to be false
+    end
+  end
+
+  describe ".normalize_whitespace" do
+    it "replaces multiple spaces with a single space" do
+      expect(described_class.send(:normalize_whitespace, "hello   world")).to eq("hello world")
+    end
+
+    it "replaces tabs with spaces" do
+      expect(described_class.send(:normalize_whitespace, "hello\tworld")).to eq("hello world")
+    end
+
+    it "replaces newlines with spaces" do
+      expect(described_class.send(:normalize_whitespace, "hello\nworld")).to eq("hello world")
+    end
+
+    it "replaces carriage returns with spaces" do
+      expect(described_class.send(:normalize_whitespace, "hello\rworld")).to eq("hello world")
+    end
+
+    it "strips leading and trailing whitespace" do
+      expect(described_class.send(:normalize_whitespace, "  hello  ")).to eq("hello")
+    end
+
+    it "handles mixed whitespace" do
+      expect(described_class.send(:normalize_whitespace, "  hello \t\n world  ")).to eq("hello world")
+    end
+
+    it "returns empty string for whitespace-only input" do
+      expect(described_class.send(:normalize_whitespace, "   ")).to eq("")
+    end
+
+    it "handles an empty string" do
+      expect(described_class.send(:normalize_whitespace, "")).to eq("")
+    end
+
+    it "does not modify a clean string" do
+      expect(described_class.send(:normalize_whitespace, "hello world")).to eq("hello world")
+    end
+  end
 end

data/spec/prosereflect/node_spec.rb

@@ -423,4 +423,132 @@ RSpec.describe Prosereflect::Node do
       expect(node.to_h).to eq(expected)
     end
   end
+
+  describe "#node_size" do
+    it "returns 1 for empty node" do
+      node = described_class.create("empty")
+      expect(node.node_size).to eq(1)
+    end
+
+    it "includes text children" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("hello"))
+      # 1 (parent) + 6 (text "hello") = 7
+      expect(node.node_size).to eq(7)
+    end
+
+    it "sums multiple children" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("ab"))
+      node.add_child(Prosereflect::Text.create("cd"))
+      # 1 (parent) + 3 ("ab") + 3 ("cd") = 7
+      expect(node.node_size).to eq(7)
+    end
+
+    it "handles deeply nested content" do
+      doc = Prosereflect::Document.create
+      para = Prosereflect::Paragraph.create
+      para.add_child(Prosereflect::Text.create("hi"))
+      doc.add_child(para)
+      # 1 (doc) + 1 (para) + 3 (text "hi") = 5
+      expect(doc.node_size).to eq(5)
+    end
+  end
+
+  describe "#text?" do
+    it "returns false for regular nodes" do
+      expect(described_class.create("node").text?).to be false
+      expect(Prosereflect::Paragraph.create.text?).to be false
+      expect(Prosereflect::Document.create.text?).to be false
+    end
+
+    it "returns true for Text nodes" do
+      expect(Prosereflect::Text.create("hello").text?).to be true
+    end
+  end
+
+  describe "#cut" do
+    it "returns self for full range" do
+      node = described_class.create("node")
+      expect(node.cut(0, 1)).to eq(node)
+    end
+
+    it "returns self for default range" do
+      node = described_class.create("node")
+      expect(node.cut).to eq(node)
+    end
+
+    it "returns copy with subset of content" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("first"))
+      node.add_child(Prosereflect::Text.create("second"))
+      cut_node = node.cut(0, 1 + 7) # 1 parent + first text (7)
+      expect(cut_node).not_to eq(node)
+    end
+  end
+
+  describe "#nodes_between" do
+    it "yields children in range" do
+      node = described_class.create("parent")
+      t1 = Prosereflect::Text.create("ab")
+      t2 = Prosereflect::Text.create("cd")
+      node.add_child(t1)
+      node.add_child(t2)
+
+      visited = []
+      node.nodes_between(0, 6) { |n, _pos, _i| visited << n }
+      expect(visited).to include(t1)
+    end
+
+    it "does not yield for empty range" do
+      node = described_class.create("parent")
+      visited = []
+      node.nodes_between(0, 0) { |n| visited << n }
+      expect(visited).to be_empty
+    end
+  end
+
+  describe "#descendants" do
+    it "iterates over all descendants" do
+      doc = Prosereflect::Document.create
+      para = Prosereflect::Paragraph.create
+      text = Prosereflect::Text.create("hello")
+      para.add_child(text)
+      doc.add_child(para)
+
+      visited = []
+      doc.descendants { |n, _pos, _i| visited << n }
+      expect(visited).to include(para)
+    end
+  end
+
+  describe "#eq?" do
+    it "returns true for structurally equal nodes" do
+      n1 = described_class.create("node")
+      n2 = described_class.create("node")
+      expect(n1.eq?(n2)).to be true
+    end
+
+    it "returns false for different types" do
+      n1 = described_class.create("a")
+      n2 = described_class.create("b")
+      expect(n1.eq?(n2)).to be false
+    end
+  end
+
+  describe "#copy" do
+    it "creates a shallow copy with same type and attrs" do
+      node = described_class.create("node", "key" => "val")
+      copy = node.copy
+      expect(copy.to_h).to eq(node.to_h)
+      expect(copy).not_to equal(node)
+    end
+
+    it "creates copy with new content" do
+      node = described_class.create("parent")
+      copy = node.copy([Prosereflect::Text.create("new")])
+      expect(copy.content.length).to eq(1)
+      expect(node.content).to be_empty
+    end
+  end
 end

data/spec/prosereflect/output/whitespace_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "prosereflect/output/html"
+
+RSpec.describe Prosereflect::Output::DOMSerializer do # rubocop:disable RSpec/SpecFilePathFormat
+  let(:serializer) { described_class.new(nil) }
+
+  describe "#preserve_whitespace?" do
+    it "returns true for code_block nodes" do
+      code_block = Prosereflect::CodeBlock.new
+      expect(serializer.send(:preserve_whitespace?, code_block)).to be true
+    end
+
+    it "returns true for code_block_wrapper nodes" do
+      wrapper = Prosereflect::CodeBlockWrapper.new
+      expect(serializer.send(:preserve_whitespace?, wrapper)).to be true
+    end
+
+    it "returns true for pre type nodes" do
+      node = Prosereflect::Node.new("pre")
+      expect(serializer.send(:preserve_whitespace?, node)).to be true
+    end
+
+    it "returns true for nodes with white-space: pre in style attrs" do
+      node = Prosereflect::Node.new("paragraph")
+      node.attrs = { "style" => "white-space: pre; color: red" }
+      expect(serializer.send(:preserve_whitespace?, node)).to be true
+    end
+
+    it "returns false for paragraph nodes" do
+      paragraph = Prosereflect::Paragraph.new
+      expect(serializer.send(:preserve_whitespace?, paragraph)).to be false
+    end
+
+    it "returns false for heading nodes" do
+      heading = Prosereflect::Heading.new
+      heading.level = 1
+      expect(serializer.send(:preserve_whitespace?, heading)).to be false
+    end
+
+    it "returns false for nodes without white-space: pre style" do
+      node = Prosereflect::Node.new("paragraph")
+      node.attrs = { "style" => "color: red" }
+      expect(serializer.send(:preserve_whitespace?, node)).to be false
+    end
+
+    it "returns false for nodes with non-string style attrs" do
+      node = Prosereflect::Node.new("paragraph")
+      node.attrs = { "style" => 123 }
+      expect(serializer.send(:preserve_whitespace?, node)).to be false
+    end
+
+    it "returns false when node does not respond to type" do
+      expect(serializer.send(:preserve_whitespace?, "not a node")).to be false
+    end
+
+    it "returns false when node does not respond to attrs" do
+      node = Prosereflect::Node.new("text")
+      allow(node).to receive(:respond_to?).and_call_original
+      expect(serializer.send(:preserve_whitespace?, node)).to be false
+    end
+  end
+
+  describe "#whitespace_mode" do
+    it "returns :preserve for code_block nodes" do
+      code_block = Prosereflect::CodeBlock.new
+      expect(serializer.send(:whitespace_mode, code_block)).to eq(:preserve)
+    end
+
+    it "returns :preserve for code_block_wrapper nodes" do
+      wrapper = Prosereflect::CodeBlockWrapper.new
+      expect(serializer.send(:whitespace_mode, wrapper)).to eq(:preserve)
+    end
+
+    it "returns :collapse for paragraph nodes" do
+      paragraph = Prosereflect::Paragraph.new
+      expect(serializer.send(:whitespace_mode, paragraph)).to eq(:collapse)
+    end
+
+    it "returns :collapse for heading nodes" do
+      heading = Prosereflect::Heading.new
+      heading.level = 2
+      expect(serializer.send(:whitespace_mode, heading)).to eq(:collapse)
+    end
+
+    it "returns :preserve for nodes with white-space: pre style" do
+      node = Prosereflect::Node.new("paragraph")
+      node.attrs = { "style" => "white-space: pre" }
+      expect(serializer.send(:whitespace_mode, node)).to eq(:preserve)
+    end
+  end
+
+  describe "#collapse_whitespace" do
+    it "collapses multiple spaces into one" do
+      expect(serializer.send(:collapse_whitespace, "hello   world")).to eq("hello world")
+    end
+
+    it "collapses tabs into a single space" do
+      expect(serializer.send(:collapse_whitespace, "hello\tworld")).to eq("hello world")
+    end
+
+    it "collapses mixed tabs and spaces into a single space" do
+      expect(serializer.send(:collapse_whitespace, "hello \t  world")).to eq("hello world")
+    end
+
+    it "collapses leading spaces" do
+      expect(serializer.send(:collapse_whitespace, "  hello")).to eq(" hello")
+    end
+
+    it "collapses trailing spaces" do
+      expect(serializer.send(:collapse_whitespace, "hello  ")).to eq("hello ")
+    end
+
+    it "collapses both leading and trailing spaces" do
+      expect(serializer.send(:collapse_whitespace, "  hello   world  ")).to eq(" hello world ")
+    end
+
+    it "handles a single space string" do
+      expect(serializer.send(:collapse_whitespace, " ")).to eq(" ")
+    end
+
+    it "handles an empty string" do
+      expect(serializer.send(:collapse_whitespace, "")).to eq("")
+    end
+
+    it "does not modify a string with no extra whitespace" do
+      expect(serializer.send(:collapse_whitespace, "hello world")).to eq("hello world")
+    end
+  end
+
+  describe "#normalize_whitespace" do
+    it "replaces tabs with spaces" do
+      expect(serializer.send(:normalize_whitespace, "hello\tworld")).to eq("hello world")
+    end
+
+    it "replaces newlines with spaces" do
+      expect(serializer.send(:normalize_whitespace, "hello\nworld")).to eq("hello world")
+    end
+
+    it "replaces carriage returns with spaces" do
+      expect(serializer.send(:normalize_whitespace, "hello\rworld")).to eq("hello world")
+    end
+
+    it "replaces mixed whitespace with a single space" do
+      expect(serializer.send(:normalize_whitespace, "hello \t\n\r world")).to eq("hello world")
+    end
+
+    it "collapses multiple spaces into one" do
+      expect(serializer.send(:normalize_whitespace, "hello    world")).to eq("hello world")
+    end
+
+    it "handles a string with only whitespace" do
+      expect(serializer.send(:normalize_whitespace, "\t\n\r")).to eq(" ")
+    end
+
+    it "handles an empty string" do
+      expect(serializer.send(:normalize_whitespace, "")).to eq("")
+    end
+
+    it "does not modify a string with no extra whitespace" do
+      expect(serializer.send(:normalize_whitespace, "hello world")).to eq("hello world")
+    end
+  end
+
+  describe "#process_text_whitespace" do
+    context "when node preserves whitespace" do
+      it "returns text unchanged for code_block nodes" do
+        code_block = Prosereflect::CodeBlock.new
+        text = "  hello\n  world  "
+        expect(serializer.send(:process_text_whitespace, text, code_block)).to eq("  hello\n  world  ")
+      end
+
+      it "returns text unchanged for code_block_wrapper nodes" do
+        wrapper = Prosereflect::CodeBlockWrapper.new
+        text = "  hello\n  world  "
+        expect(serializer.send(:process_text_whitespace, text, wrapper)).to eq("  hello\n  world  ")
+      end
+
+      it "returns text unchanged for nodes with white-space: pre style" do
+        node = Prosereflect::Node.new("paragraph")
+        node.attrs = { "style" => "white-space: pre" }
+        text = "  hello\n  world  "
+        expect(serializer.send(:process_text_whitespace, text, node)).to eq("  hello\n  world  ")
+      end
+    end
+
+    context "when node collapses whitespace" do
+      it "collapses whitespace for paragraph nodes" do
+        paragraph = Prosereflect::Paragraph.new
+        text = "hello   world"
+        expect(serializer.send(:process_text_whitespace, text, paragraph)).to eq("hello world")
+      end
+
+      it "collapses whitespace for heading nodes" do
+        heading = Prosereflect::Heading.new
+        heading.level = 1
+        text = "hello   world"
+        expect(serializer.send(:process_text_whitespace, text, heading)).to eq("hello world")
+      end
+
+      it "collapses tabs and spaces for regular nodes" do
+        paragraph = Prosereflect::Paragraph.new
+        text = "  hello \t world  "
+        expect(serializer.send(:process_text_whitespace, text, paragraph)).to eq(" hello world ")
+      end
+    end
+  end
+
+  describe "DOMSerializer serialization" do
+    it "serializes a single node via #serialize_node" do
+      paragraph = Prosereflect::Paragraph.new
+      paragraph.add_text("Hello")
+
+      result = serializer.serialize_node(paragraph)
+      expect(result).to include("Hello")
+    end
+
+    it "returns text unchanged via #render_text when no schema is set" do
+      text = "bold text"
+      bold_mark = Prosereflect::Mark::Bold.new
+
+      result = serializer.render_text(text, [bold_mark])
+      # Without a schema, build_mark_serializers returns {},
+      # so apply_mark returns content unmodified
+      expect(result).to eq("bold text")
+    end
+
+    it "returns text unchanged via #render_text with multiple marks and no schema" do
+      text = "bold italic"
+      bold_mark = Prosereflect::Mark::Bold.new
+      italic_mark = Prosereflect::Mark::Italic.new
+
+      result = serializer.render_text(text, [bold_mark, italic_mark])
+      expect(result).to eq("bold italic")
+    end
+
+    it "renders text without marks via #render_text" do
+      result = serializer.render_text("plain text", [])
+      expect(result).to eq("plain text")
+    end
+
+    it "renders text with nil marks via #render_text" do
+      result = serializer.render_text("plain text", nil)
+      expect(result).to eq("plain text")
+    end
+  end
+end