prosereflect 0.1.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/debug_loading.rb

@@ -0,0 +1,34 @@
+#!/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

data/lib/prosereflect/document.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  # Document class represents a ProseMirror document.
+  class Document < Node
+    def initialize(data = {})
+      super(data)
+      @type = 'doc'
+    end
+
+    def tables
+      find_children('table')
+    end
+
+    def paragraphs
+      find_children('paragraph')
+    end
+
+    def first_paragraph
+      find_first('paragraph')
+    end
+
+    def first_table
+      find_first('table')
+    end
+
+    # Create a new empty document
+    def self.create(attrs = nil)
+      doc = new({ 'type' => 'doc', 'content' => [] })
+      doc.instance_variable_set(:@attrs, attrs) if attrs
+      doc
+    end
+
+    # Add a paragraph with text to the document
+    def add_paragraph(text = nil, attrs = nil)
+      paragraph = Paragraph.create(attrs)
+
+      paragraph.add_text(text) if text
+
+      add_child(paragraph)
+      paragraph
+    end
+
+    # Add a table to the document
+    def add_table(attrs = nil)
+      table = Table.create(attrs)
+      add_child(table)
+      table
+    end
+
+    # Convert document to JSON
+    def to_json(*_args)
+      JSON.generate(to_h)
+    end
+
+    # Convert document to YAML
+    def to_yaml
+      to_h.to_yaml
+    end
+  end
+end

data/lib/prosereflect/hard_break.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  class HardBreak < Node
+    def text_content
+      "\n"
+    end
+
+    def text_content_with_breaks
+      "\n"
+    end
+
+    # Create a new hard break
+    def self.create(marks = nil)
+      node = new({ 'type' => 'hard_break' })
+      node.instance_variable_set(:@marks, marks) if marks
+      node
+    end
+  end
+end

data/lib/prosereflect/node.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Node
+    attr_reader :type, :attrs, :marks
+    attr_accessor :content
+
+    def initialize(data = {})
+      @type = data['type']
+      @attrs = data['attrs']
+      @content = parse_content(data['content'])
+      @marks = data['marks']
+    end
+
+    def parse_content(content_data)
+      return [] unless content_data
+
+      content_data.map { |item| Parser.parse(item) }
+    end
+
+    # Create a serializable hash representation of this node
+    def to_h
+      result = { 'type' => @type }
+      result['attrs'] = @attrs if @attrs
+      result['marks'] = @marks if @marks
+      result['content'] = @content.map(&:to_h) unless @content.empty?
+      result
+    end
+
+    # Add a child node to this node's content
+    def add_child(node)
+      @content ||= []
+      @content << node
+      node
+    end
+
+    def find_first(node_type)
+      return self if type == node_type
+
+      content.each do |child|
+        result = child.find_first(node_type)
+        return result if result
+      end
+      nil
+    end
+
+    # Create a node of the specified type with optional attributes
+    def self.create(node_type, attrs = nil)
+      node = new({ 'type' => node_type })
+      node.instance_variable_set(:@attrs, attrs) if attrs
+      node.instance_variable_set(:@content, [])
+      node
+    end
+
+    def find_all(node_type)
+      results = []
+      results << self if type == node_type
+      content.each do |child|
+        results.concat(child.find_all(node_type))
+      end
+      results
+    end
+
+    def find_children(node_type)
+      content.select { |child| child.type == node_type }
+    end
+
+    def text_content
+      content.map(&:text_content).join
+    end
+
+    # Hard breaks should add a newline in text content
+    def text_content_with_breaks
+      content.map(&:text_content_with_breaks).join
+    end
+  end
+end

data/lib/prosereflect/paragraph.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'text'
+require_relative 'hard_break'
+
+module Prosereflect
+  class Paragraph < Node
+    def text_nodes
+      content.select { |node| node.type == 'text' }
+    end
+
+    def text_content
+      result = ''
+      content.each do |node|
+        result += if node.type == 'text'
+                    node.text_content
+                  elsif node.type == 'hard_break'
+                    "\n"
+                  else
+                    node.text_content
+                  end
+      end
+      result
+    end
+
+    # Create a new paragraph
+    def self.create(attrs = nil)
+      para = new({ 'type' => 'paragraph', 'content' => [] })
+      para.instance_variable_set(:@attrs, attrs) if attrs
+      para
+    end
+
+    # Add text to the paragraph
+    def add_text(text, marks = nil)
+      return if text.nil? || text.empty?
+
+      text_node = Text.create(text, marks)
+      add_child(text_node)
+      text_node
+    end
+
+    # Add a hard break to the paragraph
+    def add_hard_break(marks = nil)
+      hard_break = HardBreak.create(marks)
+      add_child(hard_break)
+      hard_break
+    end
+  end
+end

data/lib/prosereflect/parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'text'
+require_relative 'paragraph'
+require_relative 'table'
+require_relative 'table_row'
+require_relative 'table_cell'
+require_relative 'hard_break'
+require_relative 'document'
+
+module Prosereflect
+  class Parser
+    def self.parse(data)
+      return nil unless data.is_a?(Hash)
+
+      parse_node(data)
+    end
+
+    def self.parse_node(data)
+      return nil unless data.is_a?(Hash)
+
+      case data['type']
+      when 'text'
+        Text.new(data)
+      when 'paragraph'
+        Paragraph.new(data)
+      when 'table'
+        Table.new(data)
+      when 'table_row'
+        TableRow.new(data)
+      when 'table_cell'
+        TableCell.new(data)
+      when 'hard_break'
+        HardBreak.new(data)
+      when 'doc', 'document'
+        Document.new(data)
+      else
+        Node.new(data)
+      end
+    end
+
+    def self.parse_document(data)
+      raise ArgumentError, 'Input must be a hash' if data.nil?
+      raise ArgumentError, 'Input must be a hash' unless data.is_a?(Hash)
+
+      if data['content']
+        Document.new(data)
+      elsif data['contents'] && data['contents']['en'] && data['contents']['en']['content']
+        Document.new({ 'content' => data['contents']['en']['content'] })
+      else
+        Document.new
+      end
+    end
+  end
+end

data/lib/prosereflect/table.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'table_row'
+
+module Prosereflect
+  class Table < Node
+    def rows
+      content.select { |node| node.type == 'table_row' }
+    end
+
+    def header_row
+      rows.first
+    end
+
+    def data_rows
+      rows[1..] || []
+    end
+
+    # Get cell at specific position (skips header)
+    def cell_at(row_index, col_index)
+      return nil if row_index.negative? || col_index.negative?
+
+      data_row = data_rows[row_index]
+      return nil unless data_row
+
+      data_row.cells[col_index]
+    end
+
+    # Create a new table
+    def self.create(attrs = nil)
+      table = new({ 'type' => 'table', 'content' => [] })
+      table.instance_variable_set(:@attrs, attrs) if attrs
+      table
+    end
+
+    # Add a header row to the table
+    def add_header(header_cells)
+      row = TableRow.create
+      header_cells.each do |cell_content|
+        row.add_cell(cell_content)
+      end
+      add_child(row)
+      row
+    end
+
+    # Add a data row to the table
+    def add_row(cell_contents = [])
+      row = TableRow.create
+      cell_contents.each do |cell_content|
+        row.add_cell(cell_content)
+      end
+      add_child(row)
+      row
+    end
+
+    # Add multiple rows at once
+    def add_rows(rows_data)
+      rows_data.each do |row_data|
+        add_row(row_data)
+      end
+    end
+  end
+end

data/lib/prosereflect/table_cell.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'paragraph'
+
+module Prosereflect
+  class TableCell < Node
+    def paragraphs
+      content.select { |node| node.type == 'paragraph' }
+    end
+
+    def text_content
+      paragraphs.map(&:text_content).join("\n")
+    end
+
+    def lines
+      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
+
+      paragraph.add_text(text) if text
+
+      add_child(paragraph)
+      paragraph
+    end
+  end
+end

data/lib/prosereflect/table_row.rb

@@ -0,0 +1,32 @@
+# 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' }
+    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
+    end
+
+    # Add a cell to the row
+    def add_cell(content_text = nil)
+      cell = TableCell.create
+
+      if content_text
+        paragraph = cell.add_paragraph
+        paragraph.add_text(content_text)
+      end
+
+      add_child(cell)
+      cell
+    end
+  end
+end

data/lib/prosereflect/text.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  class Text < Node
+    attr_reader :text
+    attr_accessor :marks
+
+    def initialize(data = {})
+      super
+      @text = data['text'] || ''
+    end
+
+    def text_content
+      @text || ''
+    end
+
+    def text_content_with_breaks
+      @text || ''
+    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
+    end
+
+    # Convert to hash representation
+    def to_h
+      result = super
+      result['text'] = @text if @text
+      result
+    end
+  end
+end

data/lib/prosereflect/version.rb

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

data/lib/prosereflect.rb

@@ -0,0 +1,17 @@
+# 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'
+
+module Prosereflect
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/prosereflect.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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.version = Prosereflect::VERSION
+  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.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+
+  # 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|\.)/}) }
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'lutaml-model', '~> 0.7'
+end

data/sig/prosemirror.rbs

@@ -0,0 +1,4 @@
+module Prosereflect
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end