prosereflect 0.1.1 → 0.3.0

data/spec/prosereflect/schema/conftest.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "prosereflect"
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+# Standard test schema matching prosemirror-py test_builder
+RSpec.shared_context "test_schema" do
+  let(:test_schema) do
+    Prosereflect::Schema.new(
+      nodes_spec: {
+        "doc" => { content: "block+" },
+        "paragraph" => { content: "inline*", group: "block" },
+        "heading" => { content: "inline*",
+                       attrs: { "level" => { default: 1 } }, group: "block" },
+        "blockquote" => { content: "block+", group: "block" },
+        "code_block" => { content: "text*", marks: "", code: true,
+                          group: "block" },
+        "horizontal_rule" => { group: "block" },
+        "text" => { group: "inline" },
+        "image" => { inline: true, group: "inline", atom: true,
+                     attrs: { "src" => {}, "alt" => { default: "" }, "title" => { default: "" } } },
+        "hard_break" => { inline: true, group: "inline", atom: true },
+        "ordered_list" => { content: "list_item+", group: "block",
+                            attrs: { "order" => { default: 1 } } },
+        "bullet_list" => { content: "list_item+", group: "block" },
+        "list_item" => { content: "paragraph block*", defining: true },
+      },
+      marks_spec: {
+        "link" => { attrs: { "href" => { default: "" }, "title" => { default: "" } },
+                    inclusive: false },
+        "em" => { group: "mark" },
+        "strong" => { group: "mark" },
+        "code" => { group: "mark" },
+      },
+    )
+  end
+
+  let(:schema) { test_schema }
+end
+
+RSpec.shared_context "custom_schema" do
+  let(:custom_schema) do
+    Prosereflect::Schema.new(
+      nodes_spec: {
+        "doc" => { content: "block+" },
+        "paragraph" => { content: "inline*", group: "block" },
+        "text" => { group: "inline" },
+      },
+      marks_spec: {
+        "bold" => {},
+        "italic" => {},
+        "link" => { attrs: { "href" => {} }, inclusive: false,
+                    excludes: "emoji" },
+        "emoji" => { group: "mark" },
+      },
+    )
+  end
+
+  let(:schema) { custom_schema }
+end

data/spec/prosereflect/schema/content_match_spec.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "conftest"
+
+RSpec.describe Prosereflect::Schema::ContentMatch do
+  include_context "test_schema"
+
+  def get(expression)
+    described_class.parse(expression, schema.nodes)
+  end
+
+  def match(expression, types)
+    m = get(expression)
+    ts = types.split.map { |t| schema.nodes[t] }
+    i = 0
+    while m && i < ts.length
+      m = m.match_type(ts[i])
+      i += 1
+    end
+    m ? m.valid_end : false
+  end
+
+  describe "parsing content expressions" do
+    it "parses empty expression" do
+      expect(get("").valid_end).to be true
+    end
+
+    it "parses 'image*' with no content" do
+      expect(match("image*", "")).to be true
+    end
+
+    it "parses 'image*' with image" do
+      expect(match("image*", "image")).to be true
+    end
+
+    it "parses 'image*' with multiple images" do
+      expect(match("image*", "image image image image")).to be true
+    end
+
+    it "rejects 'image*' with image and text" do
+      expect(match("image*", "image text")).to be false
+    end
+
+    it "parses 'inline*' with inline content" do
+      expect(match("inline*", "image text")).to be true
+    end
+
+    it "rejects 'inline*' with paragraph" do
+      expect(match("inline*", "paragraph")).to be false
+    end
+  end
+
+  describe "choice expressions" do
+    it "parses '(paragraph | heading)' with paragraph" do
+      expect(match("(paragraph | heading)", "paragraph")).to be true
+    end
+
+    it "parses '(paragraph | heading)' with heading" do
+      expect(match("(paragraph | heading)", "heading")).to be true
+    end
+
+    it "rejects '(paragraph | heading)' with image" do
+      expect(match("(paragraph | heading)", "image")).to be false
+    end
+  end
+
+  describe "sequence expressions" do
+    it "parses 'paragraph horizontal_rule paragraph'" do
+      expect(match("paragraph horizontal_rule paragraph",
+                   "paragraph horizontal_rule paragraph")).to be true
+    end
+
+    it "rejects 'paragraph horizontal_rule' when given extra paragraph" do
+      expect(match("paragraph horizontal_rule",
+                   "paragraph horizontal_rule paragraph")).to be false
+    end
+
+    it "rejects 'paragraph horizontal_rule paragraph' when missing final paragraph" do
+      expect(match("paragraph horizontal_rule paragraph",
+                   "paragraph horizontal_rule")).to be false
+    end
+
+    it "rejects when order doesn't match" do
+      expect(match("paragraph horizontal_rule",
+                   "horizontal_rule paragraph horizontal_rule")).to be false
+    end
+  end
+
+  describe "optional expressions (*)" do
+    it "parses 'heading paragraph*' with just heading" do
+      expect(match("heading paragraph*", "heading")).to be true
+    end
+
+    it "parses 'heading paragraph*' with multiple paragraphs" do
+      expect(match("heading paragraph*",
+                   "heading paragraph paragraph")).to be true
+    end
+
+    it "parses 'paragraph paragraph*' with paragraph" do
+      expect(match("paragraph paragraph*", "paragraph")).to be true
+    end
+  end
+
+  describe "required expressions (+)" do
+    it "parses 'heading paragraph+' with heading and paragraph" do
+      expect(match("heading paragraph+", "heading paragraph")).to be true
+    end
+
+    it "parses 'heading paragraph+' with multiple paragraphs" do
+      expect(match("heading paragraph+",
+                   "heading paragraph paragraph")).to be true
+    end
+
+    it "rejects 'heading paragraph+' with only heading" do
+      expect(match("heading paragraph+", "heading")).to be false
+    end
+
+    it "rejects 'paragraph paragraph+' when first is not paragraph" do
+      expect(match("paragraph paragraph+",
+                   "horizontal_rule paragraph")).to be false
+    end
+  end
+
+  describe "optional single (?)" do
+    it "parses 'image?' with image" do
+      expect(match("image?", "image")).to be true
+    end
+
+    it "parses 'image?' with empty" do
+      expect(match("image?", "")).to be true
+    end
+
+    it "rejects 'image?' with multiple images" do
+      expect(match("image?", "image image")).to be false
+    end
+  end
+
+  describe "repeated choice with +" do
+    it "parses '(heading paragraph+)+' correctly" do
+      expect(match("(heading paragraph+)+",
+                   "heading paragraph heading paragraph paragraph")).to be true
+    end
+
+    it "rejects when extra content at end" do
+      expect(match("(heading paragraph+)+",
+                   "heading paragraph heading paragraph paragraph horizontal_rule")).to be false
+    end
+  end
+
+  describe "range expressions" do
+    it "parses 'hard_break{2}' with two breaks" do
+      expect(match("hard_break{2}", "hard_break hard_break")).to be true
+    end
+
+    it "rejects 'hard_break{2}' with only one" do
+      expect(match("hard_break{2}", "hard_break")).to be false
+    end
+
+    it "rejects 'hard_break{2}' with three" do
+      expect(match("hard_break{2}",
+                   "hard_break hard_break hard_break")).to be false
+    end
+
+    it "parses 'hard_break{2,4}' with 2-4 breaks" do
+      expect(match("hard_break{2,4}", "hard_break hard_break")).to be true
+      expect(match("hard_break{2,4}",
+                   "hard_break hard_break hard_break")).to be true
+      expect(match("hard_break{2,4}",
+                   "hard_break hard_break hard_break hard_break")).to be true
+    end
+
+    it "rejects 'hard_break{2,4}' with too few" do
+      expect(match("hard_break{2,4}", "hard_break")).to be false
+    end
+
+    it "rejects 'hard_break{2,4}' with too many" do
+      expect(match("hard_break{2,4}",
+                   "hard_break hard_break hard_break hard_break hard_break")).to be false
+    end
+
+    it "parses 'hard_break{2,}' (unbounded)" do
+      expect(match("hard_break{2,}", "hard_break hard_break")).to be true
+      expect(match("hard_break{2,}",
+                   "hard_break hard_break hard_break hard_break")).to be true
+    end
+
+    it "rejects 'hard_break{2,}' with only one" do
+      expect(match("hard_break{2,}", "hard_break")).to be false
+    end
+  end
+
+  describe "mixed expressions" do
+    it "parses 'hard_break{2,4} text*'" do
+      expect(match("hard_break{2,4} text*", "hard_break hard_break")).to be true
+      expect(match("hard_break{2,4} text*",
+                   "hard_break hard_break text text")).to be true
+    end
+
+    it "rejects 'hard_break{2,4} text*' with invalid content" do
+      expect(match("hard_break{2,4} text*",
+                   "hard_break hard_break image")).to be false
+    end
+
+    it "parses 'hard_break{2,4} image?'" do
+      expect(match("hard_break{2,4} image?",
+                   "hard_break hard_break image")).to be true
+      expect(match("hard_break{2,4} image?",
+                   "hard_break hard_break")).to be true
+    end
+  end
+
+  describe "edge_count" do
+    it "returns number of edges" do
+      m = get("paragraph | heading")
+      expect(m.edge_count).to eq(2)
+    end
+
+    it "returns 0 for empty match" do
+      m = get("")
+      expect(m.edge_count).to eq(0)
+    end
+  end
+
+  describe "edge" do
+    it "returns edge at index" do
+      m = get("paragraph | heading")
+      expect(m.edge(0).type.name).to eq("paragraph")
+      expect(m.edge(1).type.name).to eq("heading")
+    end
+
+    it "raises error for out of bounds index" do
+      m = get("paragraph")
+      expect { m.edge(1) }.to raise_error(Prosereflect::Schema::ContentMatchError)
+    end
+  end
+end

data/spec/prosereflect/schema/mark_spec.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "conftest"
+
+RSpec.describe Prosereflect::Schema::Mark do
+  include_context "test_schema"
+
+  # Use test_schema by default
+  let(:schema) { test_schema }
+
+  describe ".same_set" do
+    it "returns true for identical mark sets" do
+      em1 = schema.mark_type("em").create
+      em2 = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      expect(described_class.same_set([em1, strong], [em2, strong])).to be true
+    end
+
+    it "returns false for different mark sets" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+      code = schema.mark_type("code").create
+
+      expect(described_class.same_set([em, strong], [em, code])).to be false
+    end
+
+    it "returns false for sets of different lengths" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      expect(described_class.same_set([em, strong], [em])).to be false
+    end
+
+    it "returns true for empty sets" do
+      expect(described_class.same_set([], [])).to be true
+    end
+
+    it "compares marks with same type but different attrs" do
+      link1 = schema.mark_type("link").create({ "href" => "http://foo" })
+      link2 = schema.mark_type("link").create({ "href" => "http://bar" })
+
+      expect(described_class.same_set([link1], [link2])).to be false
+    end
+
+    it "compares marks with same type and same attrs" do
+      link1 = schema.mark_type("link").create({ "href" => "http://foo" })
+      link2 = schema.mark_type("link").create({ "href" => "http://foo" })
+
+      expect(described_class.same_set([link1], [link2])).to be true
+    end
+  end
+
+  describe "#eq?" do
+    it "returns true for marks with same type and attrs" do
+      link1 = schema.mark_type("link").create({ "href" => "http://foo" })
+      link2 = schema.mark_type("link").create({ "href" => "http://foo" })
+
+      expect(link1.eq?(link2)).to be true
+    end
+
+    it "returns false for marks with different attrs" do
+      link1 = schema.mark_type("link").create({ "href" => "http://foo" })
+      link2 = schema.mark_type("link").create({ "href" => "http://bar" })
+
+      expect(link1.eq?(link2)).to be false
+    end
+
+    it "returns false for marks with different types" do
+      link = schema.mark_type("link").create({ "href" => "http://foo" })
+      em = schema.mark_type("em").create
+
+      expect(link.eq?(em)).to be false
+    end
+
+    it "returns true for same object" do
+      link = schema.mark_type("link").create({ "href" => "http://foo" })
+
+      expect(link.eq?(link)).to be true
+    end
+  end
+
+  describe "#add_to_set" do
+    it "adds mark to empty set" do
+      em = schema.mark_type("em").create
+
+      result = em.add_to_set([])
+
+      expect(result.length).to eq(1)
+      expect(result.first.type.name).to eq("em")
+    end
+
+    it "returns original set if mark already exists" do
+      em = schema.mark_type("em").create
+      existing_set = [em]
+
+      result = em.add_to_set(existing_set)
+
+      expect(result).to equal(existing_set)
+    end
+
+    it "adds mark to set with other marks of different types" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      result = em.add_to_set([strong])
+
+      expect(result.length).to eq(2)
+      expect(result.map { |x| x.type.name }).to include("em", "strong")
+    end
+
+    it "adds link mark with different href replacing existing link" do
+      link1 = schema.mark_type("link").create({ "href" => "http://foo" })
+      link2 = schema.mark_type("link").create({ "href" => "http://bar" })
+      em = schema.mark_type("em").create
+
+      result = link2.add_to_set([link1, em])
+
+      # link2 should replace link1, em should remain
+      expect(result.length).to eq(2)
+      link_result = result.find { |m| m.type.name == "link" }
+      expect(link_result.attrs["href"]).to eq("http://bar")
+    end
+
+    it "maintains rank ordering" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+      code = schema.mark_type("code").create
+
+      # Add marks in different order and verify sorting
+      result = code.add_to_set([em, strong])
+
+      # Should be sorted by rank (em=0, strong=1, code=2)
+      expect(result.map { |x| x.type.name }).to eq(["em", "strong", "code"])
+    end
+  end
+
+  describe "#remove_from_set" do
+    it "removes mark from set" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      result = em.remove_from_set([em, strong])
+
+      expect(result.length).to eq(1)
+      expect(result.first.type.name).to eq("strong")
+    end
+
+    it "returns unchanged set if mark not present" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+      code = schema.mark_type("code").create
+
+      result = em.remove_from_set([strong, code])
+
+      expect(result.length).to eq(2)
+    end
+
+    it "returns empty set when removing only mark" do
+      em = schema.mark_type("em").create
+
+      result = em.remove_from_set([em])
+
+      expect(result).to be_empty
+    end
+  end
+
+  describe "#is_in_set?" do
+    it "returns true when mark is in set" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      expect(em.is_in_set?([em, strong])).to be true
+    end
+
+    it "returns false when mark is not in set" do
+      em = schema.mark_type("em").create
+      strong = schema.mark_type("strong").create
+
+      expect(em.is_in_set?([strong])).to be false
+    end
+  end
+
+  context "with custom schema exclusion rules" do
+    # Custom schema with link excludes emoji
+    let(:custom_schema) do
+      Prosereflect::Schema.new(
+        nodes_spec: {
+          "doc" => { content: "block+" },
+          "paragraph" => { content: "inline*", group: "block" },
+          "text" => { group: "inline" },
+        },
+        marks_spec: {
+          "bold" => {},
+          "italic" => {},
+          "link" => { attrs: { "href" => {} }, inclusive: false,
+                      excludes: "emoji" },
+          "emoji" => { group: "mark" },
+        },
+      )
+    end
+
+    let(:schema) { custom_schema }
+
+    describe ".same_set" do
+      it "returns true for identical mark sets" do
+        bold1 = schema.mark_type("bold").create
+        bold2 = schema.mark_type("bold").create
+        italic = schema.mark_type("italic").create
+
+        expect(described_class.same_set([bold1, italic], [bold2, italic])).to be true
+      end
+    end
+
+    describe "#add_to_set" do
+      it "link excludes emoji - emoji removed when link added" do
+        # link excludes emoji in this schema
+        link = schema.mark_type("link").create({ "href" => "http://example" })
+        emoji = schema.mark_type("emoji").create
+
+        result = link.add_to_set([emoji])
+
+        # emoji should be removed because link excludes emoji
+        expect(result.map { |x| x.type.name }).not_to include("emoji")
+        expect(result.map { |x| x.type.name }).to include("link")
+      end
+
+      it "link can be added to empty set" do
+        link = schema.mark_type("link").create({ "href" => "http://example" })
+
+        result = link.add_to_set([])
+
+        expect(result.length).to eq(1)
+        expect(result.first.type.name).to eq("link")
+      end
+
+      it "emoji does not exclude link but link excludes emoji" do
+        # emoji has no excludes, but link excludes emoji
+        # So when we try to add emoji to [link], it should fail
+        # because link excludes emoji
+        link = schema.mark_type("link").create({ "href" => "http://example" })
+        emoji = schema.mark_type("emoji").create
+
+        result = emoji.add_to_set([link])
+
+        # link already in set, and link excludes emoji, so emoji not added
+        expect(result.map { |x| x.type.name }).to eq(["link"])
+      end
+    end
+
+    describe "bold and italic coexist" do
+      it "bold and italic can coexist in a set" do
+        bold = schema.mark_type("bold").create
+        italic = schema.mark_type("italic").create
+
+        result = bold.add_to_set([italic])
+
+        expect(result.length).to eq(2)
+        expect(result.map { |x| x.type.name }).to include("bold", "italic")
+      end
+
+      it "italic and bold can coexist in a set" do
+        bold = schema.mark_type("bold").create
+        italic = schema.mark_type("italic").create
+
+        result = italic.add_to_set([bold])
+
+        expect(result.length).to eq(2)
+        expect(result.map { |x| x.type.name }).to include("bold", "italic")
+      end
+    end
+  end
+end

data/spec/prosereflect/schema/mark_type_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "conftest"
+
+RSpec.describe Prosereflect::Schema::MarkType do
+  include_context "test_schema"
+
+  describe "create" do
+    it "creates a mark with attrs" do
+      mark = schema.mark_type("link").create({ "href" => "http://example.com" })
+      expect(mark.attrs["href"]).to eq("http://example.com")
+    end
+
+    it "uses default instance when no attrs provided" do
+      mark_type = schema.mark_type("link")
+      mark = mark_type.create(nil)
+      # The instance should have the default title
+      expect(mark.type).to eq(mark_type)
+    end
+  end
+
+  describe "remove_from_set" do
+    it "removes mark from set" do
+      mark_type = schema.mark_type("em")
+      mark = mark_type.create
+      mark_set = [mark]
+
+      result = mark_type.remove_from_set(mark_set)
+      expect(result).to be_empty
+    end
+
+    it "keeps other marks" do
+      em_mark = schema.mark_type("em").create
+      strong_mark = schema.mark_type("strong").create
+      mark_set = [em_mark, strong_mark]
+
+      result = schema.mark_type("em").remove_from_set(mark_set)
+      expect(result).to eq([strong_mark])
+    end
+  end
+
+  describe "is_in_set?" do
+    it "returns true when mark is in set" do
+      mark = schema.mark_type("em").create
+      mark_set = [mark]
+
+      expect(schema.mark_type("em").is_in_set?(mark_set)).to be true
+    end
+
+    it "returns false when mark is not in set" do
+      mark = schema.mark_type("em").create
+      mark_set = [mark]
+
+      expect(schema.mark_type("strong").is_in_set?(mark_set)).to be false
+    end
+  end
+
+  describe "excludes?" do
+    it "returns false by default" do
+      expect(schema.mark_type("em").excludes?(schema.mark_type("strong"))).to be false
+    end
+  end
+
+  describe "with custom_schema (exclusions)" do
+    include_context "custom_schema"
+
+    it "link excludes emoji" do
+      expect(custom_schema.mark_type("link").excludes?(custom_schema.mark_type("emoji"))).to be true
+    end
+
+    it "emoji does not exclude link" do
+      expect(custom_schema.mark_type("emoji").excludes?(custom_schema.mark_type("link"))).to be false
+    end
+  end
+
+  describe "inclusive?" do
+    it "returns false for link (non-inclusive)" do
+      expect(schema.mark_type("link").inclusive?).to be false
+    end
+
+    it "returns true for em (inclusive by default)" do
+      expect(schema.mark_type("em").inclusive?).to be true
+    end
+  end
+end