prosereflect 0.1.1 → 0.3.0

data/spec/prosereflect/transform/transform_spec.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Transform::Transform do
+  let(:doc) { Prosereflect::Document.new }
+
+  describe "creation" do
+    it "creates transform with document" do
+      transform = described_class.new(doc)
+      expect(transform.doc).to eq(doc)
+    end
+
+    it "starts with empty steps" do
+      transform = described_class.new(doc)
+      expect(transform.size).to eq(0)
+    end
+  end
+
+  describe "add_mark" do
+    it "adds mark step to transform" do
+      transform = described_class.new(doc)
+      mark = Prosereflect::Mark::Bold.new
+      transform.add_mark(0, 10, mark)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "remove_mark" do
+    it "adds remove mark step to transform" do
+      transform = described_class.new(doc)
+      mark = Prosereflect::Mark::Bold.new
+      transform.remove_mark(0, 10, mark)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "insert" do
+    it "adds insert step to transform" do
+      transform = described_class.new(doc)
+      text = Prosereflect::Text.new(text: "hello")
+      transform.insert(0, text)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "delete" do
+    it "adds delete step to transform" do
+      transform = described_class.new(doc)
+      transform.delete(0, 5)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "replace" do
+    it "adds replace step to transform" do
+      transform = described_class.new(doc)
+      slice = Prosereflect::Transform::Slice.empty
+      transform.replace(0, 5, slice)
+      expect(transform.size).to eq(1)
+    end
+
+    it "defaults to empty slice" do
+      transform = described_class.new(doc)
+      transform.replace(0, 5)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "replace_with" do
+    it "adds replace step with nodes" do
+      transform = described_class.new(doc)
+      text = Prosereflect::Text.new(text: "x")
+      transform.replace_with(0, 5, text)
+      expect(transform.size).to eq(1)
+    end
+
+    it "accepts multiple nodes" do
+      transform = described_class.new(doc)
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      transform.replace_with(0, 5, t1, t2)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "set_node_attribute" do
+    it "adds attr step to transform" do
+      transform = described_class.new(doc)
+      transform.set_node_attribute(0, { "level" => 2 })
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "set_doc_attribute" do
+    it "adds doc attr step to transform" do
+      transform = described_class.new(doc)
+      transform.set_doc_attribute({ "meta" => 1 })
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "empty?" do
+    it "returns true for new transform" do
+      transform = described_class.new(doc)
+      expect(transform.empty?).to be true
+    end
+
+    it "returns false after adding step" do
+      transform = described_class.new(doc)
+      transform.delete(0, 5)
+      expect(transform.empty?).to be false
+    end
+  end
+
+  describe "clone" do
+    it "creates new transform with same document" do
+      transform = described_class.new(doc)
+      cloned = transform.clone
+      expect(cloned.doc).to eq(doc)
+    end
+
+    it "clone does not share steps" do
+      transform = described_class.new(doc)
+      transform.delete(0, 5)
+      cloned = transform.clone
+      expect(cloned.size).to eq(0)
+    end
+  end
+
+  describe "rollback" do
+    it "returns self for chaining on empty transform" do
+      transform = described_class.new(doc)
+      result = transform.rollback
+      expect(result).to eq(transform)
+    end
+  end
+
+  describe "maps" do
+    it "returns empty mapping array for new transform" do
+      transform = described_class.new(doc)
+      expect(transform.maps).to eq([])
+    end
+
+    it "returns mapping after adding steps" do
+      transform = described_class.new(doc)
+      transform.delete(0, 5)
+      expect(transform.maps.length).to eq(1)
+    end
+  end
+
+  describe "size" do
+    it "returns number of steps" do
+      transform = described_class.new(doc)
+      expect(transform.size).to eq(0)
+
+      transform.delete(0, 5)
+      expect(transform.size).to eq(1)
+
+      transform.delete(0, 5)
+      expect(transform.size).to eq(2)
+    end
+  end
+
+  describe "add_step" do
+    it "returns self for chaining" do
+      transform = described_class.new(doc)
+      step = Prosereflect::Transform::ReplaceStep.new(0, 5)
+      result = transform.add_step(step)
+      expect(result).to eq(transform)
+    end
+
+    it "tracks mapping" do
+      transform = described_class.new(doc)
+      step = Prosereflect::Transform::ReplaceStep.new(0, 5)
+      transform.add_step(step)
+      expect(transform.maps.length).to eq(1)
+    end
+  end
+
+  describe "split" do
+    it "adds split step to transform" do
+      doc_with_content = Prosereflect::Parser.parse_document({
+                                                               "type" => "doc",
+                                                               "content" => [
+                                                                 {
+                                                                   "type" => "paragraph",
+                                                                   "content" => [
+                                                                     { "type" => "text", "text" => "Hello World" },
+                                                                   ],
+                                                                 },
+                                                               ],
+                                                             })
+      transform = described_class.new(doc_with_content)
+      transform.split(5)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "join" do
+    it "adds join step to transform" do
+      doc_with_two_paras = Prosereflect::Parser.parse_document({
+                                                                 "type" => "doc",
+                                                                 "content" => [
+                                                                   {
+                                                                     "type" => "paragraph",
+                                                                     "content" => [
+                                                                       { "type" => "text", "text" => "Hello" },
+                                                                     ],
+                                                                   },
+                                                                   {
+                                                                     "type" => "paragraph",
+                                                                     "content" => [
+                                                                       { "type" => "text", "text" => "World" },
+                                                                     ],
+                                                                   },
+                                                                 ],
+                                                               })
+      transform = described_class.new(doc_with_two_paras)
+      transform.join(8)
+      expect(transform.size).to eq(1)
+    end
+  end
+
+  describe "to_s" do
+    it "returns string representation" do
+      transform = described_class.new(doc)
+      expect(transform.to_s).to include("Transform")
+    end
+  end
+
+  describe "inspect" do
+    it "returns same as to_s" do
+      transform = described_class.new(doc)
+      expect(transform.inspect).to eq(transform.to_s)
+    end
+  end
+end

data/spec/prosereflect/user_spec.rb

@@ -1,73 +1,76 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect::User do
   let(:user) { described_class.new }
 
-  describe '#initialize' do
-    it 'creates a user mention node with empty content' do
+  describe "#initialize" do
+    it "creates a user mention node with empty content" do
       expect(user.content).to eq([])
     end
   end
 
-  describe '#id' do
-    it 'gets and sets the user id' do
-      user.id = '123'
-      expect(user.id).to eq('123')
+  describe "#id" do
+    it "gets and sets the user id" do
+      user.id = "123"
+      expect(user.id).to eq("123")
     end
 
-    it 'gets id from attrs' do
-      user = described_class.new(attrs: { 'id' => '456' })
-      expect(user.id).to eq('456')
+    it "gets id from attrs" do
+      user = described_class.new(attrs: { "id" => "456" })
+      expect(user.id).to eq("456")
     end
   end
 
-  describe '#add_child' do
-    it 'raises NotImplementedError' do
-      expect { user.add_child(double) }.to raise_error(NotImplementedError, 'User mention nodes cannot have children')
+  describe "#add_child" do
+    it "raises NotImplementedError" do
+      expect do
+        user.add_child(double)
+      end.to raise_error(NotImplementedError,
+                         "User mention nodes cannot have children")
     end
   end
 
-  describe '#to_h' do
-    it 'serializes correctly' do
-      user.id = '789'
+  describe "#to_h" do
+    it "serializes correctly" do
+      user.id = "789"
       expect(user.to_h).to eq({
-                                'type' => 'user',
-                                'attrs' => { 'id' => '789' },
-                                'content' => []
+                                "type" => "user",
+                                "attrs" => { "id" => "789" },
+                                "content" => [],
                               })
     end
   end
 
-  describe 'integration with Document' do
-    it 'can be added to a document' do
+  describe "integration with Document" do
+    it "can be added to a document" do
       document = Prosereflect::Document.create
-      user = document.add_user('123')
+      user = document.add_user("123")
 
       expect(user).to be_a(described_class)
-      expect(user.id).to eq('123')
+      expect(user.id).to eq("123")
       expect(document.content.size).to eq(1)
       expect(document.content.first).to be_a(described_class)
     end
   end
 
-  describe 'HTML conversion' do
-    it 'converts to HTML correctly' do
+  describe "HTML conversion" do
+    it "converts to HTML correctly" do
       document = Prosereflect::Document.create
-      document.add_user('123')
+      document.add_user("123")
 
       html = Prosereflect::Output::Html.convert(document)
       expect(html).to eq('<user-mention data-id="123"></user-mention>')
     end
 
-    it 'parses from HTML correctly' do
+    it "parses from HTML correctly" do
       html = '<user-mention data-id="123"></user-mention>'
       document = Prosereflect::Input::Html.parse(html)
 
       expect(document.content.size).to eq(1)
       expect(document.content.first).to be_a(described_class)
-      expect(document.content.first.id).to eq('123')
+      expect(document.content.first.id).to eq("123")
     end
   end
 end

data/spec/prosereflect_spec.rb

@@ -1,62 +1,64 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect do
-  let(:fixtures_path) { File.join(__dir__, 'fixtures') }
+  let(:fixtures_path) { File.join(__dir__, "fixtures") }
 
-  it 'has a version number' do
-    expect(Prosereflect::VERSION).not_to be nil
+  it "has a version number" do
+    expect(Prosereflect::VERSION).not_to be_nil
+    expect(Prosereflect::VERSION).to be_a(String)
+    expect(Prosereflect::VERSION).to match(/\d+\.\d+\.\d+/)
   end
 
   # Test YAML parsing for different fixtures
-  Dir.glob(File.join(__dir__, 'fixtures', '*/*.yaml')).each do |yaml_file|
+  Dir.glob(File.join(__dir__, "fixtures", "*/*.yaml")).each do |yaml_file|
     context "with YAML fixture #{File.basename(yaml_file)}" do
       let(:file_content) { File.read(yaml_file) }
 
-      include_examples 'a parsable format', :yaml
+      it_behaves_like "a parsable format", :yaml
 
       # Test table functionality for DP fixtures
-      if yaml_file.include?('DP')
-        include_examples 'a document with tables'
-        include_examples 'document traversal'
-        include_examples 'text content extraction'
+      if yaml_file.include?("DP")
+        it_behaves_like "a document with tables"
+        it_behaves_like "document traversal"
+        it_behaves_like "text content extraction"
       end
     end
   end
 
   # Test JSON parsing for different fixtures
-  Dir.glob(File.join(__dir__, 'fixtures', '*/*.json')).each do |json_file|
+  Dir.glob(File.join(__dir__, "fixtures", "*/*.json")).each do |json_file|
     context "with JSON fixture #{File.basename(json_file)}" do
       let(:file_content) { File.read(json_file) }
 
-      include_examples 'a parsable format', :json
+      it_behaves_like "a parsable format", :json
 
       # Test table functionality for DP fixtures
-      if json_file.include?('DP')
-        include_examples 'a document with tables'
-        include_examples 'document traversal'
-        include_examples 'text content extraction'
+      if json_file.include?("DP")
+        it_behaves_like "a document with tables"
+        it_behaves_like "document traversal"
+        it_behaves_like "text content extraction"
       end
     end
   end
 
-  describe 'Document creation' do
-    include_examples 'document creation'
+  describe "Document creation" do
+    it_behaves_like "document creation"
   end
 
-  describe 'Round-trip format conversion' do
-    context 'with YAML format' do
-      include_examples 'format round-trip', :yaml
+  describe "Round-trip format conversion" do
+    context "with YAML format" do
+      it_behaves_like "format round-trip", :yaml
     end
 
-    context 'with JSON format' do
-      include_examples 'format round-trip', :json
+    context "with JSON format" do
+      it_behaves_like "format round-trip", :json
     end
 
-    context 'with HTML format' do
-      include_examples 'format round-trip', :html
-      include_examples 'html conversion'
+    context "with HTML format" do
+      it_behaves_like "format round-trip", :html
+      it_behaves_like "html conversion"
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
-require 'yaml'
-require 'json'
-require 'prosereflect'
+require "bundler/setup"
+require "yaml"
+require "json"
+require "prosereflect"
+require "prosereflect/schema"
 
 # Load shared examples
-Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |f| require f }
+Dir[File.join(__dir__, "support", "**", "*.rb")].each { |f| require f }
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = '.rspec_status'
+  config.example_status_persistence_file_path = ".rspec_status"
 
   # Disable RSpec exposing methods globally on `Module` and `main`
   config.disable_monkey_patching!

data/spec/support/matchers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'json'
+require "yaml"
+require "json"
 
 # Custom RSpec matcher for comparing JSON structures
 RSpec::Matchers.define :be_equivalent_json do |expected|
@@ -64,7 +64,7 @@ RSpec::Matchers.define :have_equivalent_structure do |expected|
     # Parse strings if needed
     expected_data = case expected
                     when String
-                      if expected.strip.start_with?('{', '[')
+                      if expected.strip.start_with?("{", "[")
                         begin
                           JSON.parse(expected)
                         rescue StandardError
@@ -79,7 +79,7 @@ RSpec::Matchers.define :have_equivalent_structure do |expected|
 
     actual_data = case actual
                   when String
-                    if actual.strip.start_with?('{', '[')
+                    if actual.strip.start_with?("{", "[")
                       begin
                         JSON.parse(actual)
                       rescue StandardError
@@ -98,7 +98,7 @@ RSpec::Matchers.define :have_equivalent_structure do |expected|
   failure_message do |actual|
     expected_data = case expected
                     when String
-                      if expected.strip.start_with?('{', '[')
+                      if expected.strip.start_with?("{", "[")
                         begin
                           JSON.parse(expected)
                         rescue StandardError
@@ -113,7 +113,7 @@ RSpec::Matchers.define :have_equivalent_structure do |expected|
 
     actual_data = case actual
                   when String
-                    if actual.strip.start_with?('{', '[')
+                    if actual.strip.start_with?("{", "[")
                       begin
                         JSON.parse(actual)
                       rescue StandardError