prosereflect 0.1.1 → 0.3.0

data/spec/prosereflect/test_builder/marks_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../fixtures/test_builder/helpers"
+
+RSpec.describe TestBuilder do # rubocop:disable RSpec/SpecFilePathFormat
+  describe ".extract_markers" do
+    it "extracts an anchor marker and its position" do
+      _content, positions = described_class.extract_markers('doc(p("hello<|a> world"))')
+      expect(positions).to include("a")
+      expect(positions["a"]).to eq(12)
+    end
+
+    it "extracts a cursor position marker" do
+      _content, positions = described_class.extract_markers('doc(p("hello<|> world"))')
+      expect(positions).to include(:cursor)
+      expect(positions[:cursor]).to eq(12)
+    end
+
+    it "extracts a numbered position marker" do
+      _content, positions = described_class.extract_markers('doc(p("hello<1> world"))')
+      expect(positions).to include(1)
+      expect(positions[1]).to eq(12)
+    end
+
+    it "extracts multiple markers from a single string" do
+      _content, positions = described_class.extract_markers('doc(p("hello<|a> world<|b>"))')
+      expect(positions).to include("a", "b")
+      expect(positions["a"]).to be < positions["b"]
+    end
+
+    it "returns an empty positions hash when no markers are present" do
+      _content, positions = described_class.extract_markers('doc(p("hello world"))')
+      expect(positions).to be_empty
+    end
+
+    it "returns the content string with all markers removed" do
+      content, _positions = described_class.extract_markers('doc(p("hello<|a> world<1>"))')
+      expect(content).to eq('doc(p("hello world"))')
+    end
+
+    it "removes a cursor marker from the content string" do
+      content, _positions = described_class.extract_markers('doc(p("hello<|> world"))')
+      expect(content).to eq('doc(p("hello world"))')
+    end
+
+    it "returns a two-element array of [cleaned_string, positions_hash]" do
+      result = described_class.extract_markers('doc(p("hello<|> world"))')
+      expect(result).to be_a(Array)
+      expect(result.size).to eq(2)
+      expect(result[0]).to be_a(String)
+      expect(result[1]).to be_a(Hash)
+    end
+  end
+
+  describe ".parse" do
+    it "delegates to Builder#parse" do
+      builder = described_class.for_schema(nil)
+      expect(builder).to be_a(TestBuilder::Builder)
+    end
+
+    it "returns nil when extract_content returns nil" do
+      # For strings where extract_content cannot find matching outer parens,
+      # parse returns nil.
+      doc = described_class.parse("hello")
+      expect(doc).to be_nil
+    end
+  end
+
+  describe ".for_schema" do
+    it "returns a Builder instance" do
+      builder = described_class.for_schema(nil)
+      expect(builder).to be_a(TestBuilder::Builder)
+    end
+
+    it "assigns the schema to the builder" do
+      schema = Prosereflect::Schema.new(
+        nodes_spec: {
+          "doc" => { content: "block+" },
+          "paragraph" => { content: "inline*", group: "block" },
+          "text" => { group: "inline" },
+        },
+        marks_spec: {
+          "em" => { group: "mark" },
+          "strong" => { group: "mark" },
+        },
+      )
+      builder = described_class.for_schema(schema)
+      expect(builder.schema).to eq(schema)
+    end
+
+    it "creates a builder with nil schema by default" do
+      builder = described_class.for_schema(nil)
+      expect(builder.schema).to be_nil
+    end
+  end
+
+  describe TestBuilder::Builder do
+    describe "#parse_content" do
+      it "parses a bare string literal into a string" do
+        builder = described_class.new
+        result = builder.parse_content('"hello"')
+        expect(result).to eq("hello")
+      end
+    end
+
+    describe "#schema" do
+      it "is nil by default" do
+        builder = described_class.new
+        expect(builder.schema).to be_nil
+      end
+
+      it "stores the provided schema" do
+        schema = Prosereflect::Schema.new(
+          nodes_spec: {
+            "doc" => { content: "block+" },
+            "paragraph" => { content: "inline*", group: "block" },
+            "text" => { group: "inline" },
+          },
+          marks_spec: {},
+        )
+        builder = described_class.new(schema: schema)
+        expect(builder.schema).to eq(schema)
+      end
+    end
+  end
+end

data/spec/prosereflect/text_spec.rb

@@ -1,274 +1,275 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect::Text do
-  describe 'initialization' do
-    it 'initializes as a text node' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
-      expect(text.type).to eq('text')
-      expect(text.text).to eq('Hello')
+  describe "initialization" do
+    it "initializes as a text node" do
+      text = described_class.new({ "type" => "text", "text" => "Hello" })
+      expect(text.type).to eq("text")
+      expect(text.text).to eq("Hello")
     end
 
-    it 'initializes with empty text' do
-      text = described_class.new({ 'type' => 'text' })
-      expect(text.text).to eq('')
+    it "initializes with empty text" do
+      text = described_class.new({ "type" => "text" })
+      expect(text.text).to eq("")
     end
 
-    it 'initializes with marks' do
+    it "initializes with marks" do
       marks = [
         Prosereflect::Mark::Bold.new,
-        Prosereflect::Mark::Italic.new
+        Prosereflect::Mark::Italic.new,
       ]
-      text = described_class.new(text: 'Hello', marks: marks)
+      text = described_class.new(text: "Hello", marks: marks)
 
       expect(text.raw_marks).to eq(marks)
     end
   end
 
-  describe '.create' do
-    it 'creates a simple text node' do
-      text = described_class.create('Hello world')
+  describe ".create" do
+    it "creates a simple text node" do
+      text = described_class.create("Hello world")
 
       expected = {
-        'type' => 'text',
-        'text' => 'Hello world'
+        "type" => "text",
+        "text" => "Hello world",
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates a text node with marks' do
-      text = described_class.create('Formatted text', [
+    it "creates a text node with marks" do
+      text = described_class.create("Formatted text", [
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Formatted text',
-        'marks' => [
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+        "type" => "text",
+        "text" => "Formatted text",
+        "marks" => [
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates a text node with marks and attributes' do
-      text = described_class.create('Link text', [
-                                      Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com', 'title' => 'Example' }),
-                                      Prosereflect::Mark::Bold.new
+    it "creates a text node with marks and attributes" do
+      text = described_class.create("Link text", [
+                                      Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com",
+                                                                            "title" => "Example" }),
+                                      Prosereflect::Mark::Bold.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Link text',
-        'marks' => [
+        "type" => "text",
+        "text" => "Link text",
+        "marks" => [
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com',
-              'title' => 'Example'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+              "title" => "Example",
+            },
           },
-          { 'type' => 'bold' }
-        ]
+          { "type" => "bold" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe 'text structure' do
-    it 'creates text with special characters' do
-      text = described_class.create('Special chars: →, ←, ©, ®, ™')
+  describe "text structure" do
+    it "creates text with special characters" do
+      text = described_class.create("Special chars: →, ←, ©, ®, ™")
 
       expected = {
-        'type' => 'text',
-        'text' => 'Special chars: →, ←, ©, ®, ™'
+        "type" => "text",
+        "text" => "Special chars: →, ←, ©, ®, ™",
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates text with multiple marks and attributes' do
-      text = described_class.create('Complex text', [
+    it "creates text with multiple marks and attributes" do
+      text = described_class.create("Complex text", [
                                       Prosereflect::Mark::Bold.new,
                                       Prosereflect::Mark::Italic.new,
                                       Prosereflect::Mark::Strike.new,
-                                      Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com' }),
-                                      Prosereflect::Mark::Underline.new
+                                      Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com" }),
+                                      Prosereflect::Mark::Underline.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Complex text',
-        'marks' => [
-          { 'type' => 'bold' },
-          { 'type' => 'italic' },
-          { 'type' => 'strike' },
+        "type" => "text",
+        "text" => "Complex text",
+        "marks" => [
+          { "type" => "bold" },
+          { "type" => "italic" },
+          { "type" => "strike" },
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+            },
           },
-          { 'type' => 'underline' }
-        ]
+          { "type" => "underline" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe 'text operations' do
-    describe '#text_content' do
-      it 'returns the text content regardless of marks' do
-        text = described_class.create('Sample text', [
+  describe "text operations" do
+    describe "#text_content" do
+      it "returns the text content regardless of marks" do
+        text = described_class.create("Sample text", [
                                         Prosereflect::Mark::Bold.new,
-                                        Prosereflect::Mark::Italic.new
+                                        Prosereflect::Mark::Italic.new,
                                       ])
 
-        expect(text.text_content).to eq('Sample text')
+        expect(text.text_content).to eq("Sample text")
       end
 
-      it 'returns empty string for empty text' do
-        text = described_class.create('')
-        expect(text.text_content).to eq('')
+      it "returns empty string for empty text" do
+        text = described_class.create("")
+        expect(text.text_content).to eq("")
       end
 
-      it 'preserves whitespace and special characters' do
+      it "preserves whitespace and special characters" do
         text = described_class.create("  Multiple   spaces  \t\nand\ttabs  ")
         expect(text.text_content).to eq("  Multiple   spaces  \t\nand\ttabs  ")
       end
     end
 
-    describe '#marks' do
-      it 'preserves mark order' do
-        text = described_class.new(text: 'Hello')
+    describe "#marks" do
+      it "preserves mark order" do
+        text = described_class.new(text: "Hello")
         marks = [
           Prosereflect::Mark::Bold.new,
           Prosereflect::Mark::Italic.new,
-          Prosereflect::Mark::Strike.new
+          Prosereflect::Mark::Strike.new,
         ]
         text.marks = marks
 
         expect(text.raw_marks.map(&:type)).to eq(%w[bold italic strike])
       end
 
-      it 'handles empty marks array' do
-        text = described_class.create('No marks', [])
+      it "handles empty marks array" do
+        text = described_class.create("No marks", [])
         expect(text.marks).to eq([])
-        expect(text.to_h).not_to have_key('marks')
+        expect(text.to_h).not_to have_key("marks")
       end
 
-      it 'handles nil marks' do
-        text = described_class.create('No marks', nil)
+      it "handles nil marks" do
+        text = described_class.create("No marks", nil)
         expect(text.marks).to be_nil
-        expect(text.to_h).not_to have_key('marks')
+        expect(text.to_h).not_to have_key("marks")
       end
     end
   end
 
-  describe 'mark attributes' do
-    it 'preserves mark attributes in serialization' do
-      text = described_class.create('Styled text', [
+  describe "mark attributes" do
+    it "preserves mark attributes in serialization" do
+      text = described_class.create("Styled text", [
                                       Prosereflect::Mark::Link.new(attrs: {
-                                                                     'href' => 'https://example.com',
-                                                                     'title' => 'Example Link',
-                                                                     'target' => '_blank'
+                                                                     "href" => "https://example.com",
+                                                                     "title" => "Example Link",
+                                                                     "target" => "_blank",
                                                                    }),
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Styled text',
-        'marks' => [
+        "type" => "text",
+        "text" => "Styled text",
+        "marks" => [
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com',
-              'title' => 'Example Link',
-              'target' => '_blank'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+              "title" => "Example Link",
+              "target" => "_blank",
+            },
           },
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'handles marks with empty attributes' do
-      text = described_class.create('Test text', [
+    it "handles marks with empty attributes" do
+      text = described_class.create("Test text", [
                                       Prosereflect::Mark::Link.new(attrs: {}),
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Test text',
-        'marks' => [
-          { 'type' => 'link' },
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+        "type" => "text",
+        "text" => "Test text",
+        "marks" => [
+          { "type" => "link" },
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe '#to_h' do
-    it 'creates a hash representation with text' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
+  describe "#to_h" do
+    it "creates a hash representation with text" do
+      text = described_class.new({ "type" => "text", "text" => "Hello" })
       hash = text.to_h
 
-      expect(hash['type']).to eq('text')
-      expect(hash['text']).to eq('Hello')
+      expect(hash["type"]).to eq("text")
+      expect(hash["text"]).to eq("Hello")
     end
 
-    it 'includes marks in hash representation when present' do
-      mark = Prosereflect::Mark::Base.new(type: 'bold')
+    it "includes marks in hash representation when present" do
+      mark = Prosereflect::Mark::Base.new(type: "bold")
       marks = [mark]
-      text = described_class.new(text: 'Bold text', marks: marks)
+      text = described_class.new(text: "Bold text", marks: marks)
 
       hash = text.to_h
-      expect(hash['marks']).to eq([{ 'type' => 'bold' }])
+      expect(hash["marks"]).to eq([{ "type" => "bold" }])
     end
   end
 
-  describe 'inheritance' do
-    it 'is a Node' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Test' })
+  describe "inheritance" do
+    it "is a Node" do
+      text = described_class.new({ "type" => "text", "text" => "Test" })
       expect(text).to be_a(Prosereflect::Node)
     end
   end
 
-  describe 'with marks' do
-    it 'can have multiple marks' do
-      bold_mark = Prosereflect::Mark::Base.new(type: 'bold')
-      italic_mark = Prosereflect::Mark::Base.new(type: 'italic')
-      underline_mark = Prosereflect::Mark::Base.new(type: 'underline')
+  describe "with marks" do
+    it "can have multiple marks" do
+      bold_mark = Prosereflect::Mark::Base.new(type: "bold")
+      italic_mark = Prosereflect::Mark::Base.new(type: "italic")
+      underline_mark = Prosereflect::Mark::Base.new(type: "underline")
       marks = [bold_mark, italic_mark, underline_mark]
 
-      text = described_class.new(text: 'Formatted text', marks: marks)
+      text = described_class.new(text: "Formatted text", marks: marks)
 
       expect(text.marks.size).to eq(3)
     end
 
-    it 'can have marks with attributes' do
-      text = described_class.new(text: 'Hello')
-      mark = Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com' })
+    it "can have marks with attributes" do
+      text = described_class.new(text: "Hello")
+      mark = Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com" })
       text.marks = [mark]
 
-      expect(text.raw_marks[0].attrs['href']).to eq('https://example.com')
+      expect(text.raw_marks[0].attrs["href"]).to eq("https://example.com")
     end
   end
 end