prosereflect 0.1.1 → 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