prosereflect 0.1.0 → 0.1.1

data/lib/prosereflect/table_cell.rb

@@ -5,8 +5,29 @@ require_relative 'paragraph'
 
 module Prosereflect
   class TableCell < Node
+    PM_TYPE = 'table_cell'
+
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'content', to: :content
+      map 'attrs', to: :attrs
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] ||= []
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(type: PM_TYPE, attrs: attrs, content: [])
+    end
+
     def paragraphs
-      content.select { |node| node.type == 'paragraph' }
+      return [] unless content
+
+      content.select { |node| node.is_a?(Paragraph) }
     end
 
     def text_content
@@ -17,13 +38,6 @@ module Prosereflect
       text_content.split("\n").map(&:strip).reject(&:empty?)
     end
 
-    # Create a new table cell
-    def self.create(attrs = nil)
-      cell = new({ 'type' => 'table_cell', 'content' => [] })
-      cell.instance_variable_set(:@attrs, attrs) if attrs
-      cell
-    end
-
     # Add a paragraph to the cell
     def add_paragraph(text = nil)
       paragraph = Paragraph.create
@@ -33,5 +47,16 @@ module Prosereflect
       add_child(paragraph)
       paragraph
     end
+
+    # Override to_h to handle empty content and attributes properly
+    def to_h
+      result = super
+      result['content'] ||= []
+      if result['attrs']
+        result['attrs'] = result['attrs'].is_a?(Hash) && result['attrs'][:attrs] ? result['attrs'][:attrs] : result['attrs']
+        result.delete('attrs') if result['attrs'].empty?
+      end
+      result
+    end
   end
 end

data/lib/prosereflect/table_header.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'table_cell'
+
+module Prosereflect
+  # TableHeader class represents a header cell in a table (<th> tag).
+  # It inherits from TableCell but adds header-specific attributes.
+  class TableHeader < TableCell
+    PM_TYPE = 'table_header'
+
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :scope, :string  # row, col, rowgroup, or colgroup
+    attribute :abbr, :string   # abbreviated version of content
+    attribute :colspan, :integer # number of columns this header spans
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'content', to: :content
+      map 'attrs', to: :attrs
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] ||= []
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(type: PM_TYPE, attrs: attrs, content: [])
+    end
+
+    # Add text to the last paragraph, or create a new one if none exists
+    def add_text(text, marks = nil)
+      last_paragraph = content&.last
+      last_paragraph = add_paragraph if !last_paragraph || !last_paragraph.is_a?(Paragraph)
+      last_paragraph.add_text(text, marks)
+      self
+    end
+
+    # Set the scope of the header (row, col, rowgroup, or colgroup)
+    def scope=(scope_value)
+      return unless %w[row col rowgroup colgroup].include?(scope_value)
+
+      self.attrs ||= {}
+      attrs['scope'] = scope_value
+    end
+
+    def scope
+      attrs&.[]('scope')
+    end
+
+    # Set abbreviated version of the header content
+    def abbr=(abbr_text)
+      self.attrs ||= {}
+      attrs['abbr'] = abbr_text
+    end
+
+    def abbr
+      attrs&.[]('abbr')
+    end
+
+    # Set the number of columns this header spans
+    def colspan=(span)
+      return unless span.to_i.positive?
+
+      self.attrs ||= {}
+      attrs['colspan'] = span.to_i
+    end
+
+    def colspan
+      attrs&.[]('colspan')
+    end
+
+    # Get header attributes as a hash
+    def header_attributes
+      {
+        scope: scope,
+        abbr: abbr,
+        colspan: colspan
+      }.compact
+    end
+
+    # Override to_h to exclude nil attributes
+    def to_h
+      result = super
+      if result['attrs']
+        result['attrs'].reject! { |_, v| v.nil? }
+        result.delete('attrs') if result['attrs'].empty?
+      end
+      result
+    end
+  end
+end

data/lib/prosereflect/table_row.rb

@@ -5,20 +5,32 @@ require_relative 'table_cell'
 
 module Prosereflect
   class TableRow < Node
-    def cells
-      content.select { |node| node.type == 'table_cell' }
+    PM_TYPE = 'table_row'
+
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'content', to: :content
+      map 'attrs', to: :attrs
+    end
+
+    def initialize(opts = {})
+      opts[:content] ||= []
+      super
     end
 
-    # Create a new table row
     def self.create(attrs = nil)
-      row = new({ 'type' => 'table_row', 'content' => [] })
-      row.instance_variable_set(:@attrs, attrs) if attrs
-      row
+      new(type: PM_TYPE, attrs: attrs, content: [])
+    end
+
+    def cells
+      content || []
     end
 
     # Add a cell to the row
-    def add_cell(content_text = nil)
-      cell = TableCell.create
+    def add_cell(content_text = nil, attrs: nil)
+      cell = TableCell.create(attrs)
 
       if content_text
         paragraph = cell.add_paragraph
@@ -28,5 +40,16 @@ module Prosereflect
       add_child(cell)
       cell
     end
+
+    # Override to_h to handle empty content and attributes properly
+    def to_h
+      result = super
+      result['content'] ||= []
+      if result['attrs']
+        result['attrs'] = result['attrs'].is_a?(Hash) && result['attrs'][:attrs] ? result['attrs'][:attrs] : result['attrs']
+        result.delete('attrs') if result['attrs'].empty?
+      end
+      result
+    end
   end
 end

data/lib/prosereflect/text.rb

@@ -4,33 +4,29 @@ require_relative 'node'
 
 module Prosereflect
   class Text < Node
-    attr_reader :text
-    attr_accessor :marks
+    PM_TYPE = 'text'
 
-    def initialize(data = {})
-      super
-      @text = data['text'] || ''
-    end
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :text, :string, default: ''
 
-    def text_content
-      @text || ''
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'text', to: :text
+      map 'marks', to: :marks
     end
 
-    def text_content_with_breaks
-      @text || ''
+    def self.create(text = '', marks = nil)
+      new(text: text, marks: marks)
     end
 
-    # Create a new text node
-    def self.create(text, marks = nil)
-      node = new({ 'type' => 'text', 'text' => text })
-      node.instance_variable_set(:@marks, marks) if marks
-      node
+    def text_content
+      text || ''
     end
 
-    # Convert to hash representation
+    # Override the to_h method to include the text attribute
     def to_h
       result = super
-      result['text'] = @text if @text
+      result['text'] = text
       result
     end
   end

data/lib/prosereflect/user.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  # User class represents a user mention in ProseMirror.
+  class User < Node
+    PM_TYPE = 'user'
+
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :id, :string
+    attribute :attrs, :hash
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'attrs', to: :attrs
+      map 'content', to: :content
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] = []
+      super
+
+      return unless attributes[:attrs]
+
+      @id = attributes[:attrs]['id']
+      self.attrs = { 'id' => @id }
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    # Update the user ID
+    def id=(user_id)
+      @id = user_id
+      self.attrs ||= {}
+      attrs['id'] = user_id
+    end
+
+    def id
+      @id || attrs&.[]('id')
+    end
+
+    # Override content-related methods since user mentions don't have content
+    def add_child(*)
+      raise NotImplementedError, 'User mention nodes cannot have children'
+    end
+
+    def content
+      []
+    end
+
+    def to_h
+      hash = super
+      hash['attrs'] = {
+        'id' => id
+      }
+      hash['content'] = []
+      hash
+    end
+  end
+end

data/lib/prosereflect/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosereflect
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/prosereflect.rb

@@ -2,14 +2,20 @@
 
 require_relative 'prosereflect/version'
 require_relative 'prosereflect/node'
+require_relative 'prosereflect/mark'
+require_relative 'prosereflect/attribute'
 require_relative 'prosereflect/text'
 require_relative 'prosereflect/paragraph'
 require_relative 'prosereflect/hard_break'
 require_relative 'prosereflect/table'
 require_relative 'prosereflect/table_row'
 require_relative 'prosereflect/table_cell'
+require_relative 'prosereflect/heading'
 require_relative 'prosereflect/document'
 require_relative 'prosereflect/parser'
+require_relative 'prosereflect/input/html'
+require_relative 'prosereflect/output/html'
+require_relative 'prosereflect/user'
 
 module Prosereflect
   class Error < StandardError; end

data/prosereflect.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'lutaml-model', '~> 0.7'
+  spec.add_dependency 'nokogiri', '~> 1.18'
 end