prosereflect 0.2.0 → 0.3.0

data/spec/prosereflect/transform/replace_step_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::ReplaceStep do
+  describe "creation" do
+    it "creates replace step with from, to, and slice" do
+      slice = Prosereflect::Transform::Slice.empty
+      step = described_class.new(0, 5, slice)
+      expect(step.from).to eq(0)
+      expect(step.to).to eq(5)
+      expect(step.slice).to eq(slice)
+    end
+
+    it "creates replace step with default empty slice" do
+      step = described_class.new(0, 5)
+      expect(step.slice).to eq(Prosereflect::Transform::Slice.empty)
+    end
+  end
+
+  describe "get_map" do
+    it "returns step map for the replacement" do
+      step = described_class.new(2, 5, Prosereflect::Transform::Slice.empty)
+      step_map = step.get_map
+      expect(step_map).to be_a(Prosereflect::Transform::StepMap)
+    end
+  end
+
+  describe "step_type" do
+    it "returns replace" do
+      step = described_class.new(0, 5)
+      expect(step.step_type).to eq("replace")
+    end
+  end
+
+  describe "merge" do
+    it "merges adjacent empty deletions" do
+      # step1: delete 3-4
+      step1 = described_class.new(3, 4, Prosereflect::Transform::Slice.empty)
+      # step2: delete 4-5 (adjacent - step1's end equals step2's start)
+      step2 = described_class.new(4, 5, Prosereflect::Transform::Slice.empty)
+
+      merged = step1.merge(step2)
+      expect(merged).not_to be_nil
+    end
+
+    it "does not merge overlapping deletions" do
+      # step1: delete 1-3
+      step1 = described_class.new(1, 3, Prosereflect::Transform::Slice.empty)
+      # step2: delete 2-4 (overlaps with step1)
+      step2 = described_class.new(2, 4, Prosereflect::Transform::Slice.empty)
+
+      merged = step1.merge(step2)
+      expect(merged).to be_nil
+    end
+
+    it "merges adjacent deletions extending backward" do
+      # step1: delete 3-4
+      step1 = described_class.new(3, 4, Prosereflect::Transform::Slice.empty)
+      # step2: delete 2-3 (extends backward from step1)
+      step2 = described_class.new(2, 3, Prosereflect::Transform::Slice.empty)
+
+      merged = step2.merge(step1)
+      expect(merged).not_to be_nil
+    end
+
+    it "does not merge far apart steps" do
+      step1 = described_class.new(1, 2, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(5, 6, Prosereflect::Transform::Slice.empty)
+
+      merged = step1.merge(step2)
+      expect(merged).to be_nil
+    end
+  end
+
+  describe "can_extend_deletion?" do
+    it "returns true when other starts at this end with empty slice" do
+      step1 = described_class.new(2, 4, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(4, 6, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_extend_deletion?(step2)).to be true
+    end
+
+    it "returns false when other does not start at this end" do
+      step1 = described_class.new(2, 4, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(5, 7, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_extend_deletion?(step2)).to be false
+    end
+
+    it "returns false when self.slice is not empty" do
+      content = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")])
+      step1 = described_class.new(2, 4, Prosereflect::Transform::Slice.new(content))
+      step2 = described_class.new(4, 6, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_extend_deletion?(step2)).to be false
+    end
+  end
+
+  describe "can_prepend_deletion?" do
+    it "returns true when other ends at this start with empty slice" do
+      step1 = described_class.new(4, 6, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(2, 4, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_prepend_deletion?(step2)).to be true
+    end
+
+    it "returns false when other does not end at this start" do
+      step1 = described_class.new(4, 6, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(2, 3, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_prepend_deletion?(step2)).to be false
+    end
+  end
+
+  describe "can_append_content?" do
+    it "returns true when other starts at this end with content" do
+      step1 = described_class.new(2, 3, Prosereflect::Transform::Slice.empty)
+      content = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")])
+      step2 = described_class.new(3, 3, Prosereflect::Transform::Slice.new(content))
+      expect(step1.can_append_content?(step2)).to be true
+    end
+
+    it "returns false when other starts at different position" do
+      step1 = described_class.new(2, 3, Prosereflect::Transform::Slice.empty)
+      content = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")])
+      step2 = described_class.new(4, 4, Prosereflect::Transform::Slice.new(content))
+      expect(step1.can_append_content?(step2)).to be false
+    end
+
+    it "returns false when other has empty slice" do
+      step1 = described_class.new(2, 3, Prosereflect::Transform::Slice.empty)
+      step2 = described_class.new(3, 3, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_append_content?(step2)).to be false
+    end
+  end
+
+  describe "can_prepend_content?" do
+    it "returns true when other ends at this start with content" do
+      content1 = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "y")])
+      step1 = described_class.new(3, 3, Prosereflect::Transform::Slice.new(content1))
+      content2 = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")])
+      step2 = described_class.new(1, 3, Prosereflect::Transform::Slice.new(content2))
+      expect(step1.can_prepend_content?(step2)).to be true
+    end
+
+    it "returns false when other.slice is empty" do
+      content = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "y")])
+      step1 = described_class.new(3, 3, Prosereflect::Transform::Slice.new(content))
+      step2 = described_class.new(1, 3, Prosereflect::Transform::Slice.empty)
+      expect(step1.can_prepend_content?(step2)).to be false
+    end
+
+    it "returns false when other ends at different position" do
+      content = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "y")])
+      step1 = described_class.new(3, 3, Prosereflect::Transform::Slice.new(content))
+      content2 = Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")])
+      step2 = described_class.new(1, 2, Prosereflect::Transform::Slice.new(content2))
+      expect(step1.can_prepend_content?(step2)).to be false
+    end
+  end
+end

data/spec/prosereflect/transform/slice_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::Slice do
+  let(:content) { Prosereflect::Fragment.new([]) }
+
+  describe "creation" do
+    it "creates empty slice" do
+      slice = described_class.new(content)
+      expect(slice.empty?).to be true
+    end
+
+    it "creates slice with open boundaries" do
+      slice = described_class.new(content, 1, 1)
+      expect(slice.open_start).to eq(1)
+      expect(slice.open_end).to eq(1)
+    end
+  end
+
+  describe "empty?" do
+    it "returns true for empty slice" do
+      expect(described_class.empty.empty?).to be true
+    end
+  end
+
+  describe "size" do
+    it "returns 0 for empty slice" do
+      expect(described_class.empty.size).to eq(0)
+    end
+  end
+
+  describe "cut" do
+    it "returns same slice when cutting full range" do
+      slice = described_class.new(content)
+      result = slice.cut(0, slice.size)
+      expect(result.size).to eq(slice.size)
+    end
+  end
+
+  describe "equality" do
+    it "compares equal slices" do
+      slice1 = described_class.new(content)
+      slice2 = described_class.new(content)
+      expect(slice1).to eq(slice2)
+    end
+  end
+end

data/spec/prosereflect/transform/step_map_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::StepMap do
+  describe "creation" do
+    it "creates an empty step map" do
+      map = described_class.empty
+      expect(map.ranges).to eq([])
+    end
+
+    it "creates a delete step map" do
+      map = described_class.delete(5, 10)
+      expect(map.ranges).to eq([[5, 10, 5, 5]])
+    end
+
+    it "creates a replace step map" do
+      map = described_class.replace(5, 10, 5, 15)
+      expect(map.ranges).to eq([[5, 10, 5, 15]])
+    end
+  end
+
+  describe "map" do
+    it "maps position before any range unchanged" do
+      map = described_class.new([[5, 10, 5, 5]])
+      expect(map.map(3)).to eq(3)
+    end
+
+    it "maps position before range with offset" do
+      map = described_class.new([[5, 10, 3, 3]])
+      expect(map.map(3)).to eq(1)
+    end
+
+    it "maps position inside range" do
+      map = described_class.new([[5, 10, 3, 3]])
+      expect(map.map(7)).to eq(5)
+    end
+
+    it "maps position after range with offset" do
+      map = described_class.new([[5, 10, 3, 3]])
+      expect(map.map(15)).to eq(8)
+    end
+  end
+
+  describe "deleted?" do
+    it "returns false for position before range" do
+      map = described_class.new([[5, 10, 5, 5]])
+      expect(map.deleted?(3)).to be false
+    end
+
+    it "returns true for position inside range" do
+      map = described_class.new([[5, 10, 5, 5]])
+      expect(map.deleted?(7)).to be true
+    end
+
+    it "returns false for position after range" do
+      map = described_class.new([[5, 10, 5, 5]])
+      expect(map.deleted?(15)).to be false
+    end
+  end
+
+  describe "add_map" do
+    it "combines two independent maps" do
+      map1 = described_class.new([[0, 5, 0, 5]])
+      map2 = described_class.new([[10, 15, 10, 15]])
+      result = map1.add_map(map2)
+      expect(result.ranges.length).to eq(2)
+    end
+  end
+end

data/spec/prosereflect/transform/step_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::Step do
+  describe "creation" do
+    it "can be instantiated" do
+      step = described_class.new
+      expect(step).to be_a(described_class)
+    end
+  end
+
+  describe "merge" do
+    it "merges adjacent empty deletions extending backward" do
+      # step1: delete 3-4 (empty deletion at position 3)
+      step1 = Prosereflect::Transform::ReplaceStep.new(
+        3, 4,
+        Prosereflect::Transform::Slice.empty
+      )
+      # step2: delete 2-3 (empty deletion at position 2)
+      step2 = Prosereflect::Transform::ReplaceStep.new(
+        2, 3,
+        Prosereflect::Transform::Slice.empty
+      )
+
+      # step1's end (4) equals step2's start (2)? No, 4 != 2
+      # step1's start (3) equals step2's end (3)? Yes!
+      # can_prepend_deletion: other.to == @from && other.slice.empty?
+      # 3 == 3 && true = true
+      merged = step2.merge(step1)
+      expect(merged).not_to be_nil
+    end
+
+    it "does not merge steps that are far apart" do
+      step1 = Prosereflect::Transform::ReplaceStep.new(
+        2, 2,
+        Prosereflect::Transform::Slice.new(
+          Prosereflect::Fragment.new([Prosereflect::Text.new(text: "a")]),
+        )
+      )
+      # step2 is at position 4, far from step1 at position 2
+      step2 = Prosereflect::Transform::ReplaceStep.new(
+        4, 4,
+        Prosereflect::Transform::Slice.new(
+          Prosereflect::Fragment.new([Prosereflect::Text.new(text: "b")]),
+        )
+      )
+
+      merged = step1.merge(step2)
+      expect(merged).to be_nil
+    end
+
+    it "merges adjacent empty deletions" do
+      # step1: delete 3-4
+      step1 = Prosereflect::Transform::ReplaceStep.new(
+        3, 4,
+        Prosereflect::Transform::Slice.empty
+      )
+      # step2: delete 4-5 (adjacent - step1's end equals step2's start)
+      step2 = Prosereflect::Transform::ReplaceStep.new(
+        4, 5,
+        Prosereflect::Transform::Slice.empty
+      )
+
+      # can_extend_deletion: @to == other.from && @slice.empty?
+      # 4 == 4 && true = true
+      merged = step1.merge(step2)
+      expect(merged).not_to be_nil
+    end
+
+    it "does not merge overlapping deletions" do
+      # step1: delete 1-3
+      step1 = Prosereflect::Transform::ReplaceStep.new(
+        1, 3,
+        Prosereflect::Transform::Slice.empty
+      )
+      # step2: delete 2-4 (overlaps with step1)
+      step2 = Prosereflect::Transform::ReplaceStep.new(
+        2, 4,
+        Prosereflect::Transform::Slice.empty
+      )
+
+      merged = step1.merge(step2)
+      expect(merged).to be_nil
+    end
+
+    it "appends content when second step starts at first's end" do
+      # step1: replace 2-3 with empty
+      step1 = Prosereflect::Transform::ReplaceStep.new(
+        2, 3,
+        Prosereflect::Transform::Slice.empty
+      )
+      # step2: insert "x" at position 3 (step1's end)
+      step2 = Prosereflect::Transform::ReplaceStep.new(
+        3, 3,
+        Prosereflect::Transform::Slice.new(
+          Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")]),
+        )
+      )
+
+      # can_append_content: @to == other.from && !other.slice.empty?
+      merged = step1.merge(step2)
+      expect(merged).not_to be_nil
+    end
+  end
+
+  context "with ReplaceStep" do
+    describe "creation" do
+      it "creates replace step with from, to, and slice" do
+        slice = Prosereflect::Transform::Slice.empty
+        step = Prosereflect::Transform::ReplaceStep.new(0, 5, slice)
+        expect(step.from).to eq(0)
+        expect(step.to).to eq(5)
+        expect(step.slice).to eq(slice)
+      end
+
+      it "creates replace step with default empty slice" do
+        step = Prosereflect::Transform::ReplaceStep.new(0, 5)
+        expect(step.slice).to eq(Prosereflect::Transform::Slice.empty)
+      end
+    end
+
+    describe "get_map" do
+      it "returns step map for the replacement" do
+        step = Prosereflect::Transform::ReplaceStep.new(2, 5, Prosereflect::Transform::Slice.empty)
+        step_map = step.get_map
+        expect(step_map).to be_a(Prosereflect::Transform::StepMap)
+      end
+    end
+
+    describe "step_type" do
+      it "returns replace" do
+        step = Prosereflect::Transform::ReplaceStep.new(0, 5)
+        expect(step.step_type).to eq("replace")
+      end
+    end
+
+    describe "can_extend_deletion?" do
+      it "returns true when other starts at this end with empty slice" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(2, 4, Prosereflect::Transform::Slice.empty)
+        step2 = Prosereflect::Transform::ReplaceStep.new(4, 6, Prosereflect::Transform::Slice.empty)
+        expect(step1.can_extend_deletion?(step2)).to be true
+      end
+
+      it "returns false when other does not start at this end" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(2, 4, Prosereflect::Transform::Slice.empty)
+        step2 = Prosereflect::Transform::ReplaceStep.new(5, 7, Prosereflect::Transform::Slice.empty)
+        expect(step1.can_extend_deletion?(step2)).to be false
+      end
+    end
+
+    describe "can_prepend_deletion?" do
+      it "returns true when other ends at this start with empty slice" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(4, 6, Prosereflect::Transform::Slice.empty)
+        step2 = Prosereflect::Transform::ReplaceStep.new(2, 4, Prosereflect::Transform::Slice.empty)
+        expect(step1.can_prepend_deletion?(step2)).to be true
+      end
+
+      it "returns false when other does not end at this start" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(4, 6, Prosereflect::Transform::Slice.empty)
+        step2 = Prosereflect::Transform::ReplaceStep.new(2, 3, Prosereflect::Transform::Slice.empty)
+        expect(step1.can_prepend_deletion?(step2)).to be false
+      end
+    end
+
+    describe "can_append_content?" do
+      it "returns true when other starts at this end with content" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(2, 3, Prosereflect::Transform::Slice.empty)
+        step2 = Prosereflect::Transform::ReplaceStep.new(
+          3, 3,
+          Prosereflect::Transform::Slice.new(
+            Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")]),
+          )
+        )
+        expect(step1.can_append_content?(step2)).to be true
+      end
+    end
+
+    describe "can_prepend_content?" do
+      it "returns true when other ends at this start with content" do
+        # step1: insert "y" at position 3 (start=3, end=3)
+        step1 = Prosereflect::Transform::ReplaceStep.new(
+          3, 3,
+          Prosereflect::Transform::Slice.new(
+            Prosereflect::Fragment.new([Prosereflect::Text.new(text: "y")]),
+          )
+        )
+        # step2: insert "x" at position 1-3 (ends at position 3 where step1 starts)
+        step2 = Prosereflect::Transform::ReplaceStep.new(
+          1, 3,
+          Prosereflect::Transform::Slice.new(
+            Prosereflect::Fragment.new([Prosereflect::Text.new(text: "x")]),
+          )
+        )
+        expect(step1.can_prepend_content?(step2)).to be true
+      end
+
+      it "returns false when other.slice is empty" do
+        step1 = Prosereflect::Transform::ReplaceStep.new(
+          3, 3,
+          Prosereflect::Transform::Slice.new(
+            Prosereflect::Fragment.new([Prosereflect::Text.new(text: "y")]),
+          )
+        )
+        # step2 has empty slice
+        step2 = Prosereflect::Transform::ReplaceStep.new(1, 3, Prosereflect::Transform::Slice.empty)
+        expect(step1.can_prepend_content?(step2)).to be false
+      end
+    end
+  end
+end

data/spec/prosereflect/transform/structure_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::Structure do
+  let(:doc) do
+    Prosereflect::Parser.parse_document({
+                                          "type" => "doc",
+                                          "content" => [
+                                            {
+                                              "type" => "paragraph",
+                                              "content" => [
+                                                { "type" => "text", "text" => "Hello" },
+                                              ],
+                                            },
+                                            {
+                                              "type" => "paragraph",
+                                              "content" => [
+                                                { "type" => "text", "text" => "World" },
+                                              ],
+                                            },
+                                          ],
+                                        })
+  end
+
+  describe ".can_split?" do
+    it "returns false for negative position" do
+      expect(described_class.can_split?(doc, -1)).to be false
+    end
+
+    it "returns false for position beyond document" do
+      expect(described_class.can_split?(doc, 999)).to be false
+    end
+
+    it "returns true for valid position" do
+      expect(described_class.can_split?(doc, 1)).to be true
+    end
+
+    it "returns true for position 0" do
+      expect(described_class.can_split?(doc, 0)).to be true
+    end
+  end
+
+  describe ".can_join?" do
+    it "returns false for position 0" do
+      expect(described_class.can_join?(doc, 0)).to be false
+    end
+
+    it "returns false for position at end" do
+      expect(described_class.can_join?(doc, doc.node_size)).to be false
+    end
+
+    it "returns true for position between paragraphs" do
+      # Position 8 is between the two paragraphs (after "Hello" para, before "World" para)
+      expect(described_class.can_join?(doc, 8)).to be true
+    end
+  end
+
+  describe ".join_point?" do
+    it "returns nil for position at start" do
+      expect(described_class.join_point?(doc, 0)).to be false
+    end
+
+    it "returns nil at position within a paragraph" do
+      expect(described_class.join_point?(doc, 3)).to be false
+    end
+  end
+
+  describe ".lift_target" do
+    it "returns 0 for empty fragment" do
+      fragment = Prosereflect::Fragment.new([])
+      result = described_class.lift_target(fragment, 0, 5)
+      expect(result).to eq(0)
+    end
+
+    it "returns 0 for fragment with no defining nodes" do
+      text = Prosereflect::Text.new(text: "hello")
+      fragment = Prosereflect::Fragment.new([text])
+      result = described_class.lift_target(fragment, 0, 6)
+      expect(result).to eq(0)
+    end
+  end
+
+  describe ".find_wrapping" do
+    it "returns empty array for empty fragment" do
+      fragment = Prosereflect::Fragment.new([])
+      wrappers = described_class.find_wrapping(fragment, 0, 5, "paragraph")
+      expect(wrappers).to be_a(Array)
+    end
+
+    it "returns empty array for fragment with no defining nodes" do
+      text = Prosereflect::Text.new(text: "hello")
+      fragment = Prosereflect::Fragment.new([text])
+      wrappers = described_class.find_wrapping(fragment, 0, 6, "paragraph")
+      expect(wrappers).to eq([])
+    end
+  end
+end