prosereflect 0.2.0 → 0.3.0

data/spec/prosereflect/schema/node_type_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "conftest"
+
+RSpec.describe Prosereflect::Schema::NodeType do
+  include_context "test_schema"
+
+  describe "is_block?" do
+    it "returns true for block nodes" do
+      expect(schema.node_type("paragraph").is_block?).to be true
+      expect(schema.node_type("heading").is_block?).to be true
+      expect(schema.node_type("blockquote").is_block?).to be true
+    end
+
+    it "returns false for inline nodes" do
+      expect(schema.node_type("text").is_block?).to be false
+    end
+  end
+
+  describe "is_inline?" do
+    it "returns true for inline nodes" do
+      expect(schema.node_type("text").is_inline?).to be true
+    end
+
+    it "returns false for block nodes" do
+      expect(schema.node_type("paragraph").is_inline?).to be false
+    end
+  end
+
+  describe "text?" do
+    it "returns true only for text type" do
+      expect(schema.node_type("text").text?).to be true
+      expect(schema.node_type("paragraph").text?).to be false
+    end
+  end
+
+  describe "is_leaf?" do
+    it "returns true for nodes with empty content expression" do
+      expect(schema.node_type("text").is_leaf?).to be true
+      expect(schema.node_type("hard_break").is_leaf?).to be true
+      expect(schema.node_type("image").is_leaf?).to be true
+    end
+
+    it "returns false for nodes with content" do
+      expect(schema.node_type("paragraph").is_leaf?).to be false
+    end
+  end
+
+  describe "has_required_attrs?" do
+    it "returns true when node has required attributes" do
+      expect(schema.node_type("image").has_required_attrs?).to be true
+    end
+
+    it "returns false when all attrs have defaults" do
+      expect(schema.node_type("heading").has_required_attrs?).to be false
+    end
+  end
+
+  describe "default_attrs" do
+    it "returns defaults for all attrs" do
+      defaults = schema.node_type("heading").default_attrs
+      expect(defaults).to eq({ "level" => 1 })
+    end
+
+    it "returns nil if any required attr has no default" do
+      defaults = schema.node_type("image").default_attrs
+      expect(defaults).to be_nil
+    end
+  end
+
+  describe "compute_attrs" do
+    it "uses defaults when attrs not provided" do
+      attrs = schema.node_type("heading").compute_attrs(nil)
+      expect(attrs).to eq({ "level" => 1 })
+    end
+
+    it "overrides defaults with provided values" do
+      attrs = schema.node_type("heading").compute_attrs({ "level" => 3 })
+      expect(attrs).to eq({ "level" => 3 })
+    end
+
+    it "raises error for missing required attrs" do
+      expect do
+        schema.node_type("image").compute_attrs({})
+      end.to raise_error(Prosereflect::Schema::ValidationError)
+    end
+  end
+
+  describe "create" do
+    it "creates a node with computed attrs" do
+      node = schema.node_type("heading").create({ "level" => 2 }, nil, [])
+      expect(node.attrs["level"]).to eq(2)
+    end
+
+    it "raises error for text node" do
+      expect do
+        schema.node_type("text").create({}, nil, [])
+      end.to raise_error(Prosereflect::Schema::Error)
+    end
+  end
+
+  describe "valid_content?" do
+    it "returns true for valid content" do
+      frag = Prosereflect::Schema::Fragment.new([
+                                                  schema.node_type("paragraph").create(
+                                                    nil, [], []
+                                                  ),
+                                                ])
+      expect(schema.node_type("doc").valid_content?(frag)).to be true
+    end
+
+    it "returns false for invalid content" do
+      frag = Prosereflect::Schema::Fragment.new([
+                                                  schema.text(""),
+                                                ])
+      expect(schema.node_type("doc").valid_content?(frag)).to be false
+    end
+  end
+
+  describe "check_content" do
+    it "raises error for invalid content" do
+      frag = Prosereflect::Schema::Fragment.new([
+                                                  schema.text(""),
+                                                ])
+      expect do
+        schema.node_type("doc").check_content(frag)
+      end.to raise_error(Prosereflect::Schema::ValidationError)
+    end
+  end
+
+  describe "allows_mark_type?" do
+    it "returns true when mark is in mark_set" do
+      expect(schema.node_type("paragraph").allows_mark_type?(schema.mark_type("em"))).to be true
+      expect(schema.node_type("paragraph").allows_mark_type?(schema.mark_type("strong"))).to be true
+    end
+
+    it "returns false when mark is not in mark_set" do
+      expect(schema.node_type("code_block").allows_mark_type?(schema.mark_type("em"))).to be false
+    end
+  end
+end

data/spec/prosereflect/schema/schema_spec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "conftest"
+
+RSpec.describe Prosereflect::Schema do
+  include_context "test_schema"
+
+  describe "initialization" do
+    it "creates a schema with nodes and marks" do
+      expect(schema.nodes).to be_a(Hash)
+      expect(schema.marks).to be_a(Hash)
+      expect(schema.nodes.keys).to include("doc", "paragraph", "text")
+      expect(schema.marks.keys).to include("em", "strong", "link")
+    end
+
+    it "raises error for missing top node" do
+      expect do
+        described_class.new(
+          nodes_spec: { "text" => {} },
+          marks_spec: {},
+        )
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /missing its top node/)
+    end
+
+    it "raises error for missing text type" do
+      expect do
+        described_class.new(
+          nodes_spec: { "doc" => { content: "block+" } },
+          marks_spec: {},
+        )
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /every schema needs a 'text' type/)
+    end
+
+    it "raises error if text has attrs" do
+      expect do
+        described_class.new(
+          nodes_spec: {
+            "doc" => { content: "block+" },
+            "text" => { attrs: { "something" => {} } },
+          },
+          marks_spec: {},
+        )
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /text node type should not have attributes/)
+    end
+
+    it "raises error if node and mark share same name" do
+      expect do
+        described_class.new(
+          nodes_spec: {
+            "doc" => { content: "block+" },
+            "text" => {},
+            "bold" => {},
+          },
+          marks_spec: {
+            "bold" => {},
+          },
+        )
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /can not be both a node and a mark/)
+    end
+  end
+
+  describe "node_type" do
+    it "returns node type by name" do
+      node_type = schema.node_type("paragraph")
+      expect(node_type.name).to eq("paragraph")
+    end
+
+    it "raises error for unknown node type" do
+      expect do
+        schema.node_type("unknown")
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /Unknown node type/)
+    end
+  end
+
+  describe "mark_type" do
+    it "returns mark type by name" do
+      mark_type = schema.mark_type("em")
+      expect(mark_type.name).to eq("em")
+    end
+
+    it "raises error for unknown mark type" do
+      expect do
+        schema.mark_type("unknown")
+      end.to raise_error(Prosereflect::Schema::ValidationError,
+                         /Unknown mark type/)
+    end
+  end
+
+  describe "node" do
+    it "creates a node by type name" do
+      node = schema.node("paragraph")
+      expect(node.type.name).to eq("paragraph")
+    end
+
+    it "creates a node with attrs" do
+      node = schema.node("heading", { "level" => 2 })
+      expect(node.attrs["level"]).to eq(2)
+    end
+
+    it "creates a node with content" do
+      text = schema.text("Hello")
+      para = schema.node("paragraph", nil, [text])
+      expect(para.content.content.first.text).to eq("Hello")
+    end
+
+    it "validates content" do
+      text = schema.text("Hello")
+      expect do
+        # doc requires block+, not inline content directly
+        schema.node("doc", nil, [text])
+      end.to raise_error(Prosereflect::Schema::ValidationError)
+    end
+  end
+
+  describe "text" do
+    it "creates a text node" do
+      text_node = schema.text("Hello")
+      expect(text_node.text).to eq("Hello")
+      expect(text_node.type.name).to eq("text")
+    end
+
+    it "creates text with marks" do
+      em = schema.mark("em")
+      text_node = schema.text("Hello", [em])
+      expect(text_node.marks.length).to eq(1)
+    end
+  end
+
+  describe "mark" do
+    it "creates a mark by name" do
+      mark = schema.mark("em")
+      expect(mark.type.name).to eq("em")
+    end
+
+    it "creates a mark with attrs" do
+      mark = schema.mark("link", { "href" => "http://example.com" })
+      expect(mark.attrs["href"]).to eq("http://example.com")
+    end
+  end
+
+  describe "node_from_json" do
+    it "deserializes a node from JSON" do
+      json = {
+        "type" => "paragraph",
+        "content" => [
+          { "type" => "text", "text" => "Hello" },
+        ],
+      }
+
+      node = schema.node_from_json(json)
+      expect(node.type.name).to eq("paragraph")
+      expect(node.content.content.first.text).to eq("Hello")
+    end
+
+    it "deserializes marks" do
+      json = {
+        "type" => "paragraph",
+        "content" => [
+          { "type" => "text", "text" => "Hello",
+            "marks" => [{ "type" => "em" }] },
+        ],
+      }
+
+      node = schema.node_from_json(json)
+      expect(node.content.content.first.marks.length).to eq(1)
+    end
+  end
+
+  describe "mark_from_json" do
+    it "deserializes a mark from JSON" do
+      json = { "type" => "em" }
+      mark = schema.mark_from_json(json)
+      expect(mark.type.name).to eq("em")
+    end
+
+    it "deserializes mark with attrs" do
+      json = { "type" => "link", "attrs" => { "href" => "http://example.com" } }
+      mark = schema.mark_from_json(json)
+      expect(mark.attrs["href"]).to eq("http://example.com")
+    end
+  end
+
+  describe "top_node_type" do
+    it "returns the top node type" do
+      expect(schema.top_node_type.name).to eq("doc")
+    end
+  end
+end

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