prosereflect 0.1.0 → 0.2.0

data/lib/prosereflect/table_cell.rb

@@ -1,12 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'paragraph'
-
 module Prosereflect
   class TableCell < Node
+    PM_TYPE = "table_cell"
+
+    attribute :type, :string, default: -> {
+      self.class.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.grep(Paragraph)
     end
 
     def text_content
@@ -17,13 +37,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 +46,17 @@ 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
+
+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: -> {
+      self.class.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"].compact!
+        result.delete("attrs") if result["attrs"].empty?
+      end
+      result
+    end
+  end
+end

data/lib/prosereflect/table_row.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-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: -> {
+      self.class.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 +39,17 @@ 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

@@ -1,36 +1,32 @@
 # frozen_string_literal: true
 
-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: -> {
+      self.class.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
+
+module Prosereflect
+  # User class represents a user mention in ProseMirror.
+  class User < Node
+    PM_TYPE = "user"
+
+    attribute :type, :string, default: -> {
+      self.class.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.2.0"
 end

data/lib/prosereflect.rb

@@ -1,17 +1,33 @@
 # frozen_string_literal: true
 
-require_relative 'prosereflect/version'
-require_relative 'prosereflect/node'
-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/document'
-require_relative 'prosereflect/parser'
+require "lutaml/model"
 
 module Prosereflect
   class Error < StandardError; end
-  # Your code goes here...
+
+  autoload :Attribute, "prosereflect/attribute"
+  autoload :Blockquote, "prosereflect/blockquote"
+  autoload :BulletList, "prosereflect/bullet_list"
+  autoload :CodeBlock, "prosereflect/code_block"
+  autoload :CodeBlockWrapper, "prosereflect/code_block_wrapper"
+  autoload :Document, "prosereflect/document"
+  autoload :HardBreak, "prosereflect/hard_break"
+  autoload :Heading, "prosereflect/heading"
+  autoload :HorizontalRule, "prosereflect/horizontal_rule"
+  autoload :Image, "prosereflect/image"
+  autoload :Input, "prosereflect/input"
+  autoload :ListItem, "prosereflect/list_item"
+  autoload :Mark, "prosereflect/mark"
+  autoload :Node, "prosereflect/node"
+  autoload :OrderedList, "prosereflect/ordered_list"
+  autoload :Output, "prosereflect/output"
+  autoload :Paragraph, "prosereflect/paragraph"
+  autoload :Parser, "prosereflect/parser"
+  autoload :Table, "prosereflect/table"
+  autoload :TableCell, "prosereflect/table_cell"
+  autoload :TableHeader, "prosereflect/table_header"
+  autoload :TableRow, "prosereflect/table_row"
+  autoload :Text, "prosereflect/text"
+  autoload :User, "prosereflect/user"
+  autoload :VERSION, "prosereflect/version"
 end

data/prosereflect.gemspec

@@ -1,33 +1,35 @@
 # frozen_string_literal: true
 
-require_relative 'lib/prosereflect/version'
+require_relative "lib/prosereflect/version"
 
 all_files_in_git = Dir.chdir(File.expand_path(__dir__)) do
   `git ls-files -z`.split("\x0")
 end
 
 Gem::Specification.new do |spec|
-  spec.name = 'prosereflect'
+  spec.name = "prosereflect"
   spec.version = Prosereflect::VERSION
-  spec.authors = ['Ribose']
-  spec.email = ['open.source@ribose.com']
+  spec.authors = ["Ribose"]
+  spec.email = ["open.source@ribose.com"]
 
-  spec.summary = 'Ruby model accessor for prosereflect document trees.'
-  spec.homepage = 'https://github.com/metanorma/prosereflect'
-  spec.license = 'BSD-2-Clause'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+  spec.summary = "Ruby model accessor for prosereflect document trees."
+  spec.homepage = "https://github.com/metanorma/prosereflect"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
   spec.files = all_files_in_git
-               .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
+    .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
 
-  spec.bindir = 'exe'
+  spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'lutaml-model', '~> 0.7'
+  spec.add_dependency "lutaml-model", "~> 0.8"
+  spec.add_dependency "nokogiri", "~> 1.18"
 end