prosereflect 0.1.1 → 0.2.0

data/spec/prosereflect/text_spec.rb

@@ -1,274 +1,275 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect::Text do
-  describe 'initialization' do
-    it 'initializes as a text node' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
-      expect(text.type).to eq('text')
-      expect(text.text).to eq('Hello')
+  describe "initialization" do
+    it "initializes as a text node" do
+      text = described_class.new({ "type" => "text", "text" => "Hello" })
+      expect(text.type).to eq("text")
+      expect(text.text).to eq("Hello")
     end
 
-    it 'initializes with empty text' do
-      text = described_class.new({ 'type' => 'text' })
-      expect(text.text).to eq('')
+    it "initializes with empty text" do
+      text = described_class.new({ "type" => "text" })
+      expect(text.text).to eq("")
     end
 
-    it 'initializes with marks' do
+    it "initializes with marks" do
       marks = [
         Prosereflect::Mark::Bold.new,
-        Prosereflect::Mark::Italic.new
+        Prosereflect::Mark::Italic.new,
       ]
-      text = described_class.new(text: 'Hello', marks: marks)
+      text = described_class.new(text: "Hello", marks: marks)
 
       expect(text.raw_marks).to eq(marks)
     end
   end
 
-  describe '.create' do
-    it 'creates a simple text node' do
-      text = described_class.create('Hello world')
+  describe ".create" do
+    it "creates a simple text node" do
+      text = described_class.create("Hello world")
 
       expected = {
-        'type' => 'text',
-        'text' => 'Hello world'
+        "type" => "text",
+        "text" => "Hello world",
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates a text node with marks' do
-      text = described_class.create('Formatted text', [
+    it "creates a text node with marks" do
+      text = described_class.create("Formatted text", [
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Formatted text',
-        'marks' => [
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+        "type" => "text",
+        "text" => "Formatted text",
+        "marks" => [
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates a text node with marks and attributes' do
-      text = described_class.create('Link text', [
-                                      Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com', 'title' => 'Example' }),
-                                      Prosereflect::Mark::Bold.new
+    it "creates a text node with marks and attributes" do
+      text = described_class.create("Link text", [
+                                      Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com",
+                                                                            "title" => "Example" }),
+                                      Prosereflect::Mark::Bold.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Link text',
-        'marks' => [
+        "type" => "text",
+        "text" => "Link text",
+        "marks" => [
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com',
-              'title' => 'Example'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+              "title" => "Example",
+            },
           },
-          { 'type' => 'bold' }
-        ]
+          { "type" => "bold" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe 'text structure' do
-    it 'creates text with special characters' do
-      text = described_class.create('Special chars: →, ←, ©, ®, ™')
+  describe "text structure" do
+    it "creates text with special characters" do
+      text = described_class.create("Special chars: →, ←, ©, ®, ™")
 
       expected = {
-        'type' => 'text',
-        'text' => 'Special chars: →, ←, ©, ®, ™'
+        "type" => "text",
+        "text" => "Special chars: →, ←, ©, ®, ™",
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'creates text with multiple marks and attributes' do
-      text = described_class.create('Complex text', [
+    it "creates text with multiple marks and attributes" do
+      text = described_class.create("Complex text", [
                                       Prosereflect::Mark::Bold.new,
                                       Prosereflect::Mark::Italic.new,
                                       Prosereflect::Mark::Strike.new,
-                                      Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com' }),
-                                      Prosereflect::Mark::Underline.new
+                                      Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com" }),
+                                      Prosereflect::Mark::Underline.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Complex text',
-        'marks' => [
-          { 'type' => 'bold' },
-          { 'type' => 'italic' },
-          { 'type' => 'strike' },
+        "type" => "text",
+        "text" => "Complex text",
+        "marks" => [
+          { "type" => "bold" },
+          { "type" => "italic" },
+          { "type" => "strike" },
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+            },
           },
-          { 'type' => 'underline' }
-        ]
+          { "type" => "underline" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe 'text operations' do
-    describe '#text_content' do
-      it 'returns the text content regardless of marks' do
-        text = described_class.create('Sample text', [
+  describe "text operations" do
+    describe "#text_content" do
+      it "returns the text content regardless of marks" do
+        text = described_class.create("Sample text", [
                                         Prosereflect::Mark::Bold.new,
-                                        Prosereflect::Mark::Italic.new
+                                        Prosereflect::Mark::Italic.new,
                                       ])
 
-        expect(text.text_content).to eq('Sample text')
+        expect(text.text_content).to eq("Sample text")
       end
 
-      it 'returns empty string for empty text' do
-        text = described_class.create('')
-        expect(text.text_content).to eq('')
+      it "returns empty string for empty text" do
+        text = described_class.create("")
+        expect(text.text_content).to eq("")
       end
 
-      it 'preserves whitespace and special characters' do
+      it "preserves whitespace and special characters" do
         text = described_class.create("  Multiple   spaces  \t\nand\ttabs  ")
         expect(text.text_content).to eq("  Multiple   spaces  \t\nand\ttabs  ")
       end
     end
 
-    describe '#marks' do
-      it 'preserves mark order' do
-        text = described_class.new(text: 'Hello')
+    describe "#marks" do
+      it "preserves mark order" do
+        text = described_class.new(text: "Hello")
         marks = [
           Prosereflect::Mark::Bold.new,
           Prosereflect::Mark::Italic.new,
-          Prosereflect::Mark::Strike.new
+          Prosereflect::Mark::Strike.new,
         ]
         text.marks = marks
 
         expect(text.raw_marks.map(&:type)).to eq(%w[bold italic strike])
       end
 
-      it 'handles empty marks array' do
-        text = described_class.create('No marks', [])
+      it "handles empty marks array" do
+        text = described_class.create("No marks", [])
         expect(text.marks).to eq([])
-        expect(text.to_h).not_to have_key('marks')
+        expect(text.to_h).not_to have_key("marks")
       end
 
-      it 'handles nil marks' do
-        text = described_class.create('No marks', nil)
+      it "handles nil marks" do
+        text = described_class.create("No marks", nil)
         expect(text.marks).to be_nil
-        expect(text.to_h).not_to have_key('marks')
+        expect(text.to_h).not_to have_key("marks")
       end
     end
   end
 
-  describe 'mark attributes' do
-    it 'preserves mark attributes in serialization' do
-      text = described_class.create('Styled text', [
+  describe "mark attributes" do
+    it "preserves mark attributes in serialization" do
+      text = described_class.create("Styled text", [
                                       Prosereflect::Mark::Link.new(attrs: {
-                                                                     'href' => 'https://example.com',
-                                                                     'title' => 'Example Link',
-                                                                     'target' => '_blank'
+                                                                     "href" => "https://example.com",
+                                                                     "title" => "Example Link",
+                                                                     "target" => "_blank",
                                                                    }),
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Styled text',
-        'marks' => [
+        "type" => "text",
+        "text" => "Styled text",
+        "marks" => [
           {
-            'type' => 'link',
-            'attrs' => {
-              'href' => 'https://example.com',
-              'title' => 'Example Link',
-              'target' => '_blank'
-            }
+            "type" => "link",
+            "attrs" => {
+              "href" => "https://example.com",
+              "title" => "Example Link",
+              "target" => "_blank",
+            },
           },
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
 
-    it 'handles marks with empty attributes' do
-      text = described_class.create('Test text', [
+    it "handles marks with empty attributes" do
+      text = described_class.create("Test text", [
                                       Prosereflect::Mark::Link.new(attrs: {}),
                                       Prosereflect::Mark::Bold.new,
-                                      Prosereflect::Mark::Italic.new
+                                      Prosereflect::Mark::Italic.new,
                                     ])
 
       expected = {
-        'type' => 'text',
-        'text' => 'Test text',
-        'marks' => [
-          { 'type' => 'link' },
-          { 'type' => 'bold' },
-          { 'type' => 'italic' }
-        ]
+        "type" => "text",
+        "text" => "Test text",
+        "marks" => [
+          { "type" => "link" },
+          { "type" => "bold" },
+          { "type" => "italic" },
+        ],
       }
 
       expect(text.to_h).to eq(expected)
     end
   end
 
-  describe '#to_h' do
-    it 'creates a hash representation with text' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
+  describe "#to_h" do
+    it "creates a hash representation with text" do
+      text = described_class.new({ "type" => "text", "text" => "Hello" })
       hash = text.to_h
 
-      expect(hash['type']).to eq('text')
-      expect(hash['text']).to eq('Hello')
+      expect(hash["type"]).to eq("text")
+      expect(hash["text"]).to eq("Hello")
     end
 
-    it 'includes marks in hash representation when present' do
-      mark = Prosereflect::Mark::Base.new(type: 'bold')
+    it "includes marks in hash representation when present" do
+      mark = Prosereflect::Mark::Base.new(type: "bold")
       marks = [mark]
-      text = described_class.new(text: 'Bold text', marks: marks)
+      text = described_class.new(text: "Bold text", marks: marks)
 
       hash = text.to_h
-      expect(hash['marks']).to eq([{ 'type' => 'bold' }])
+      expect(hash["marks"]).to eq([{ "type" => "bold" }])
     end
   end
 
-  describe 'inheritance' do
-    it 'is a Node' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Test' })
+  describe "inheritance" do
+    it "is a Node" do
+      text = described_class.new({ "type" => "text", "text" => "Test" })
       expect(text).to be_a(Prosereflect::Node)
     end
   end
 
-  describe 'with marks' do
-    it 'can have multiple marks' do
-      bold_mark = Prosereflect::Mark::Base.new(type: 'bold')
-      italic_mark = Prosereflect::Mark::Base.new(type: 'italic')
-      underline_mark = Prosereflect::Mark::Base.new(type: 'underline')
+  describe "with marks" do
+    it "can have multiple marks" do
+      bold_mark = Prosereflect::Mark::Base.new(type: "bold")
+      italic_mark = Prosereflect::Mark::Base.new(type: "italic")
+      underline_mark = Prosereflect::Mark::Base.new(type: "underline")
       marks = [bold_mark, italic_mark, underline_mark]
 
-      text = described_class.new(text: 'Formatted text', marks: marks)
+      text = described_class.new(text: "Formatted text", marks: marks)
 
       expect(text.marks.size).to eq(3)
     end
 
-    it 'can have marks with attributes' do
-      text = described_class.new(text: 'Hello')
-      mark = Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com' })
+    it "can have marks with attributes" do
+      text = described_class.new(text: "Hello")
+      mark = Prosereflect::Mark::Link.new(attrs: { "href" => "https://example.com" })
       text.marks = [mark]
 
-      expect(text.raw_marks[0].attrs['href']).to eq('https://example.com')
+      expect(text.raw_marks[0].attrs["href"]).to eq("https://example.com")
     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,16 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
-require 'yaml'
-require 'json'
-require 'prosereflect'
+require "bundler/setup"
+require "yaml"
+require "json"
+require "prosereflect"
 
 # 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!