prosereflect 0.1.0 → 0.1.1

data/spec/prosereflect/text_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 RSpec.describe Prosereflect::Text do
   describe 'initialization' do
     it 'initializes as a text node' do
@@ -14,42 +16,212 @@ RSpec.describe Prosereflect::Text do
     end
 
     it 'initializes with marks' do
-      marks = [{ 'type' => 'bold' }, { 'type' => 'italic' }]
-      text = described_class.new({
-                                   'type' => 'text',
-                                   'text' => 'Formatted text',
-                                   'marks' => marks
-                                 })
+      marks = [
+        Prosereflect::Mark::Bold.new,
+        Prosereflect::Mark::Italic.new
+      ]
+      text = described_class.new(text: 'Hello', marks: marks)
 
-      expect(text.marks).to eq(marks)
+      expect(text.raw_marks).to eq(marks)
     end
   end
 
   describe '.create' do
-    it 'creates a text node with content' do
+    it 'creates a simple text node' do
       text = described_class.create('Hello world')
-      expect(text.type).to eq('text')
-      expect(text.text).to eq('Hello world')
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Hello world'
+      }
+
+      expect(text.to_h).to eq(expected)
     end
 
     it 'creates a text node with marks' do
-      marks = [{ 'type' => 'bold' }]
-      text = described_class.create('Bold text', marks)
+      text = described_class.create('Formatted text', [
+                                      Prosereflect::Mark::Bold.new,
+                                      Prosereflect::Mark::Italic.new
+                                    ])
+
+      expected = {
+        '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
+                                    ])
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Link text',
+        'marks' => [
+          {
+            'type' => 'link',
+            'attrs' => {
+              'href' => 'https://example.com',
+              'title' => 'Example'
+            }
+          },
+          { 'type' => 'bold' }
+        ]
+      }
 
-      expect(text.text).to eq('Bold text')
-      expect(text.marks).to eq(marks)
+      expect(text.to_h).to eq(expected)
     end
   end
 
-  describe '#text_content' do
-    it 'returns the text content' do
-      text = described_class.new({ 'type' => 'text', 'text' => 'Sample text' })
-      expect(text.text_content).to eq('Sample text')
+  describe 'text structure' do
+    it 'creates text with special characters' do
+      text = described_class.create('Special chars: →, ←, ©, ®, ™')
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Special chars: →, ←, ©, ®, ™'
+      }
+
+      expect(text.to_h).to eq(expected)
     end
 
-    it 'returns empty string when text is nil' do
-      text = described_class.new({ 'type' => 'text' })
-      expect(text.text_content).to eq('')
+    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
+                                    ])
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Complex text',
+        'marks' => [
+          { 'type' => 'bold' },
+          { 'type' => 'italic' },
+          { 'type' => 'strike' },
+          {
+            'type' => 'link',
+            'attrs' => {
+              'href' => 'https://example.com'
+            }
+          },
+          { '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', [
+                                        Prosereflect::Mark::Bold.new,
+                                        Prosereflect::Mark::Italic.new
+                                      ])
+
+        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('')
+      end
+
+      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')
+        marks = [
+          Prosereflect::Mark::Bold.new,
+          Prosereflect::Mark::Italic.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', [])
+        expect(text.marks).to eq([])
+        expect(text.to_h).not_to have_key('marks')
+      end
+
+      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')
+      end
+    end
+  end
+
+  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'
+                                                                   }),
+                                      Prosereflect::Mark::Bold.new,
+                                      Prosereflect::Mark::Italic.new
+                                    ])
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Styled text',
+        'marks' => [
+          {
+            'type' => 'link',
+            'attrs' => {
+              'href' => 'https://example.com',
+              'title' => 'Example Link',
+              'target' => '_blank'
+            }
+          },
+          { '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', [
+                                      Prosereflect::Mark::Link.new(attrs: {}),
+                                      Prosereflect::Mark::Bold.new,
+                                      Prosereflect::Mark::Italic.new
+                                    ])
+
+      expected = {
+        'type' => 'text',
+        'text' => 'Test text',
+        'marks' => [
+          { 'type' => 'link' },
+          { 'type' => 'bold' },
+          { 'type' => 'italic' }
+        ]
+      }
+
+      expect(text.to_h).to eq(expected)
     end
   end
 
@@ -63,15 +235,12 @@ RSpec.describe Prosereflect::Text do
     end
 
     it 'includes marks in hash representation when present' do
-      marks = [{ 'type' => 'bold' }]
-      text = described_class.new({
-                                   'type' => 'text',
-                                   'text' => 'Bold text',
-                                   'marks' => marks
-                                 })
+      mark = Prosereflect::Mark::Base.new(type: 'bold')
+      marks = [mark]
+      text = described_class.new(text: 'Bold text', marks: marks)
 
       hash = text.to_h
-      expect(hash['marks']).to eq(marks)
+      expect(hash['marks']).to eq([{ 'type' => 'bold' }])
     end
   end
 
@@ -84,33 +253,22 @@ RSpec.describe Prosereflect::Text do
 
   describe 'with marks' do
     it 'can have multiple marks' do
-      marks = [
-        { 'type' => 'bold' },
-        { 'type' => 'italic' },
-        { 'type' => 'underline' }
-      ]
+      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({
-                                   'type' => 'text',
-                                   '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
-      marks = [
-        { 'type' => 'link', 'attrs' => { 'href' => 'https://example.com' } }
-      ]
-
-      text = described_class.new({
-                                   'type' => 'text',
-                                   'text' => 'Link text',
-                                   'marks' => marks
-                                 })
+      text = described_class.new(text: 'Hello')
+      mark = Prosereflect::Mark::Link.new(attrs: { 'href' => 'https://example.com' })
+      text.marks = [mark]
 
-      expect(text.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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+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
+      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')
+    end
+
+    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')
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes correctly' do
+      user.id = '789'
+      expect(user.to_h).to eq({
+                                'type' => 'user',
+                                'attrs' => { 'id' => '789' },
+                                'content' => []
+                              })
+    end
+  end
+
+  describe 'integration with Document' do
+    it 'can be added to a document' do
+      document = Prosereflect::Document.create
+      user = document.add_user('123')
+
+      expect(user).to be_a(described_class)
+      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
+      document = Prosereflect::Document.create
+      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
+      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')
+    end
+  end
+end

data/spec/prosereflect_spec.rb

@@ -53,5 +53,10 @@ RSpec.describe Prosereflect do
     context 'with JSON format' do
       include_examples 'format round-trip', :json
     end
+
+    context 'with HTML format' do
+      include_examples 'format round-trip', :html
+      include_examples 'html conversion'
+    end
   end
 end

data/spec/support/shared_examples.rb

@@ -30,7 +30,7 @@ RSpec.shared_examples 'a parsable format' do |format|
                       when :yaml
                         YAML.safe_load(document.to_yaml)
                       when :json
-                        JSON.parse(document.to_json)
+                        document.to_h
                       end
 
     # Compare the structures
@@ -129,7 +129,7 @@ RSpec.shared_examples 'document creation' do
 
   it 'creates a document with attributes' do
     attrs = { 'version' => '1.0' }
-    document = Prosereflect::Document.create(attrs)
+    document = Prosereflect::Document.new(attrs: attrs)
     expect(document.attrs).to eq(attrs)
   end
 
@@ -196,25 +196,54 @@ RSpec.shared_examples 'format round-trip' do |format|
     expect(parsed_doc.find_all('hard_break').size).to eq(document.find_all('hard_break').size)
 
     # Verify table structure
-    table_in_parsed = parsed_doc.first_table
-    expect(table_in_parsed.rows.size).to eq(document.first_table.rows.size)
-    expect(table_in_parsed.header_row.cells.size).to eq(document.first_table.header_row.cells.size)
+    table_in_parsed = parsed_doc.find_first('table')
+    expect(table_in_parsed.rows.size).to eq(document.find_first('table').rows.size)
+    expect(table_in_parsed.header_row.cells.size).to eq(document.find_first('table').header_row.cells.size)
   end
 
   def round_trip_conversion(doc, format)
     case format
     when :yaml
-      yaml = doc.to_yaml
-      parsed = Prosereflect::Parser.parse_document(YAML.safe_load(yaml))
-      # Compare structures
-      expect(YAML.safe_load(parsed.to_yaml)).to be_equivalent_yaml(YAML.safe_load(doc.to_yaml))
-      parsed
+      Prosereflect::Parser.parse_document(YAML.safe_load(doc.to_yaml))
     when :json
-      json = doc.to_json
-      parsed = Prosereflect::Parser.parse_document(JSON.parse(json))
-      # Compare structures
-      expect(JSON.parse(parsed.to_json)).to be_equivalent_json(JSON.parse(doc.to_json))
-      parsed
+      Prosereflect::Parser.parse_document(doc.to_h)
+    when :html
+      html = Prosereflect::Output::Html.convert(doc)
+      Prosereflect::Input::Html.parse(html)
     end
   end
 end
+
+RSpec.shared_examples 'html conversion' do
+  it 'converts to HTML and back' do
+    # Create a document with various elements
+    document = Prosereflect::Document.create
+
+    # Add paragraph with formatted text
+    para = document.add_paragraph('Plain text')
+    para.add_text(' bold text', [Prosereflect::Mark::Bold.new])
+    para.add_hard_break
+    para.add_text('After line break', [Prosereflect::Mark::Italic.new])
+
+    # Add a table
+    table = document.add_table
+    table.add_header(['Header 1', 'Header 2'])
+    table.add_row(['Cell 1', 'Cell 2'])
+
+    # Convert to HTML
+    html = Prosereflect::Output::Html.convert(document)
+    expect(html).to be_a(String)
+    expect(html).not_to be_empty
+
+    # Convert back to document model
+    parsed_doc = Prosereflect::Input::Html.parse(html)
+    expect(parsed_doc).to be_a(Prosereflect::Document)
+
+    # Check content was preserved
+    expect(parsed_doc.content.size).to be > 0
+    expect(parsed_doc.text_content).to include('Plain text')
+    expect(parsed_doc.text_content).to include('bold text')
+    expect(parsed_doc.text_content).to include('After line break')
+    expect(parsed_doc.find_all('table').size).to eq(1)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prosereflect
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 2025-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
 description:
 email:
 - open.source@ribose.com
@@ -40,17 +54,44 @@ files:
 - Gemfile
 - README.adoc
 - Rakefile
-- debug_loading.rb
 - lib/prosereflect.rb
+- lib/prosereflect/attribute.rb
+- lib/prosereflect/attribute/base.rb
+- lib/prosereflect/attribute/bold.rb
+- lib/prosereflect/attribute/href.rb
+- lib/prosereflect/attribute/id.rb
+- lib/prosereflect/blockquote.rb
+- lib/prosereflect/bullet_list.rb
+- lib/prosereflect/code_block.rb
+- lib/prosereflect/code_block_wrapper.rb
 - lib/prosereflect/document.rb
 - lib/prosereflect/hard_break.rb
+- lib/prosereflect/heading.rb
+- lib/prosereflect/horizontal_rule.rb
+- lib/prosereflect/image.rb
+- lib/prosereflect/input/html.rb
+- lib/prosereflect/list_item.rb
+- lib/prosereflect/mark.rb
+- lib/prosereflect/mark/base.rb
+- lib/prosereflect/mark/bold.rb
+- lib/prosereflect/mark/code.rb
+- lib/prosereflect/mark/italic.rb
+- lib/prosereflect/mark/link.rb
+- lib/prosereflect/mark/strike.rb
+- lib/prosereflect/mark/subscript.rb
+- lib/prosereflect/mark/superscript.rb
+- lib/prosereflect/mark/underline.rb
 - lib/prosereflect/node.rb
+- lib/prosereflect/ordered_list.rb
+- lib/prosereflect/output/html.rb
 - lib/prosereflect/paragraph.rb
 - lib/prosereflect/parser.rb
 - lib/prosereflect/table.rb
 - lib/prosereflect/table_cell.rb
+- lib/prosereflect/table_header.rb
 - lib/prosereflect/table_row.rb
 - lib/prosereflect/text.rb
+- lib/prosereflect/user.rb
 - lib/prosereflect/version.rb
 - prosereflect.gemspec
 - sig/prosemirror.rbs
@@ -92,13 +133,16 @@ files:
 - spec/fixtures/ituob-1001/ituob-1001-Q708_ISPC.yaml
 - spec/prosereflect/document_spec.rb
 - spec/prosereflect/hard_break_spec.rb
+- spec/prosereflect/input/html_spec.rb
 - spec/prosereflect/node_spec.rb
+- spec/prosereflect/output/html_spec.rb
 - spec/prosereflect/paragraph_spec.rb
 - spec/prosereflect/parser_spec.rb
 - spec/prosereflect/table_cell_spec.rb
 - spec/prosereflect/table_row_spec.rb
 - spec/prosereflect/table_spec.rb
 - spec/prosereflect/text_spec.rb
+- spec/prosereflect/user_spec.rb
 - spec/prosereflect/version_spec.rb
 - spec/prosereflect_spec.rb
 - spec/spec_helper.rb

data/debug_loading.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-puts 'Debug script to check class loading'
-
-begin
-  puts '1. Adding lib to path'
-  $LOAD_PATH.unshift File.expand_path('lib', __dir__)
-  puts "Load path: #{$LOAD_PATH.inspect}"
-
-  puts "\n2. Requiring prosereflect"
-  require 'prosereflect'
-  puts 'Successfully required prosereflect'
-
-  puts "\n3. Checking Prosereflect module"
-  puts "Prosereflect defined? #{!defined?(Prosereflect).nil?}"
-  puts "Prosereflect is a #{Prosereflect.class}"
-
-  puts "\n4. Checking individual classes"
-  classes = %w[Node Document Paragraph Text HardBreak Table TableRow TableCell Parser]
-  classes.each do |klass|
-    full_class = "Prosereflect::#{klass}"
-    is_defined = begin
-      !defined?(Object.const_get(full_class)).nil?
-    rescue StandardError
-      false
-    end
-    puts "#{full_class} defined? #{is_defined}"
-    puts "  #{full_class} is a #{Object.const_get(full_class).class}" if is_defined
-  end
-rescue StandardError => e
-  puts "ERROR: #{e.class}: #{e.message}"
-  puts e.backtrace
-end