prosereflect 0.1.1 → 0.2.0

data/lib/prosereflect/parser.rb

@@ -1,27 +1,5 @@
 # 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 'table_header'
-require_relative 'hard_break'
-require_relative 'document'
-require_relative 'heading'
-require_relative 'mark/bold'
-require_relative 'mark/italic'
-require_relative 'mark/code'
-require_relative 'mark/link'
-require_relative 'ordered_list'
-require_relative 'bullet_list'
-require_relative 'list_item'
-require_relative 'blockquote'
-require_relative 'horizontal_rule'
-require_relative 'image'
-require_relative 'user'
-
 module Prosereflect
   class Parser
     def self.parse(data)
@@ -33,57 +11,57 @@ module Prosereflect
     def self.parse_node(data)
       return nil unless data.is_a?(Hash)
 
-      type = data['type']
-      text = data['text']
-      attrs = data['attrs']
-      marks_data = data['marks']
+      type = data["type"]
+      text = data["text"]
+      attrs = data["attrs"]
+      marks_data = data["marks"]
 
       # Find the right class based on type
       node_class = case type
-                   when 'doc'
+                   when "doc"
                      Document
-                   when 'paragraph'
+                   when "paragraph"
                      Paragraph
-                   when 'text'
+                   when "text"
                      Text
-                   when 'table'
+                   when "table"
                      Table
-                   when 'table_row'
+                   when "table_row"
                      TableRow
-                   when 'table_cell'
+                   when "table_cell"
                      TableCell
-                   when 'table_header'
+                   when "table_header"
                      TableHeader
-                   when 'hard_break'
+                   when "hard_break"
                      HardBreak
-                   when 'heading'
+                   when "heading"
                      Heading
-                   when 'ordered_list'
+                   when "ordered_list"
                      OrderedList
-                   when 'bullet_list'
+                   when "bullet_list"
                      BulletList
-                   when 'list_item'
+                   when "list_item"
                      ListItem
-                   when 'blockquote'
+                   when "blockquote"
                      Blockquote
-                   when 'horizontal_rule'
+                   when "horizontal_rule"
                      HorizontalRule
-                   when 'image'
+                   when "image"
                      Image
-                   when 'user'
+                   when "user"
                      User
                    else
                      Node
                    end
 
-      if type == 'text'
+      if type == "text"
         node = Text.new(text: text)
       else
         node = node_class.create(attrs)
 
         # Process content recursively
-        if data['content'].is_a?(Array)
-          data['content'].each do |content_data|
+        if data["content"].is_a?(Array)
+          data["content"].each do |content_data|
             child_node = parse_node(content_data)
             node.add_child(child_node) if child_node
           end
@@ -92,30 +70,30 @@ module Prosereflect
 
       # Handle special attributes for specific node types
       case type
-      when 'ordered_list'
-        node.start = attrs['start'].to_i if attrs && attrs['start']
-      when 'bullet_list'
-        node.bullet_style = attrs['bullet_style'] if attrs && attrs['bullet_style']
-      when 'blockquote'
-        node.citation = attrs['cite'] if attrs && attrs['cite']
-      when 'horizontal_rule'
+      when "ordered_list"
+        node.start = attrs["start"].to_i if attrs && attrs["start"]
+      when "bullet_list"
+        node.bullet_style = attrs["bullet_style"] if attrs && attrs["bullet_style"]
+      when "blockquote"
+        node.citation = attrs["cite"] if attrs && attrs["cite"]
+      when "horizontal_rule"
         if attrs
-          node.style = attrs['border_style'] if attrs['border_style']
-          node.width = attrs['width'] if attrs['width']
-          node.thickness = attrs['thickness'].to_i if attrs['thickness']
+          node.style = attrs["border_style"] if attrs["border_style"]
+          node.width = attrs["width"] if attrs["width"]
+          node.thickness = attrs["thickness"].to_i if attrs["thickness"]
         end
-      when 'image'
+      when "image"
         if attrs
-          node.src = attrs['src'] if attrs['src']
-          node.alt = attrs['alt'] if attrs['alt']
-          node.title = attrs['title'] if attrs['title']
-          node.dimensions = [attrs['width']&.to_i, attrs['height']&.to_i]
+          node.src = attrs["src"] if attrs["src"]
+          node.alt = attrs["alt"] if attrs["alt"]
+          node.title = attrs["title"] if attrs["title"]
+          node.dimensions = [attrs["width"]&.to_i, attrs["height"]&.to_i]
         end
-      when 'table_header'
+      when "table_header"
         if attrs
-          node.scope = attrs['scope'] if attrs['scope']
-          node.abbr = attrs['abbr'] if attrs['abbr']
-          node.colspan = attrs['colspan'] if attrs['colspan']
+          node.scope = attrs["scope"] if attrs["scope"]
+          node.abbr = attrs["abbr"] if attrs["abbr"]
+          node.colspan = attrs["colspan"] if attrs["colspan"]
         end
       end
 
@@ -125,8 +103,11 @@ module Prosereflect
     end
 
     def self.parse_document(data)
-      raise ArgumentError, 'Input cannot be nil' if data.nil?
-      raise ArgumentError, "Input must be a hash, got #{data.class}" unless data.is_a?(Hash)
+      raise ArgumentError, "Input cannot be nil" if data.nil?
+      unless data.is_a?(Hash)
+        raise ArgumentError,
+              "Input must be a hash, got #{data.class}"
+      end
 
       document = parse_node(data)
 

data/lib/prosereflect/table.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'table_row'
-require_relative 'table_header'
-
 module Prosereflect
   # TODO: support for table attributes
   # Table class represents a ProseMirror table.
   # It contains rows, each of which can contain cells.
   class Table < Node
-    PM_TYPE = 'table'
+    PM_TYPE = "table"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    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
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
     end
 
     def initialize(attributes = {})
@@ -84,10 +82,11 @@ module Prosereflect
     # 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?
+      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

data/lib/prosereflect/table_cell.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'paragraph'
-
 module Prosereflect
   class TableCell < Node
-    PM_TYPE = 'table_cell'
+    PM_TYPE = "table_cell"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    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
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
     end
 
     def initialize(attributes = {})
@@ -27,7 +26,7 @@ module Prosereflect
     def paragraphs
       return [] unless content
 
-      content.select { |node| node.is_a?(Paragraph) }
+      content.grep(Paragraph)
     end
 
     def text_content
@@ -51,10 +50,11 @@ module Prosereflect
     # 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?
+      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

data/lib/prosereflect/table_header.rb

@@ -1,22 +1,22 @@
 # 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'
+    PM_TYPE = "table_header"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    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
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
     end
 
     def initialize(attributes = {})
@@ -41,21 +41,21 @@ module Prosereflect
       return unless %w[row col rowgroup colgroup].include?(scope_value)
 
       self.attrs ||= {}
-      attrs['scope'] = scope_value
+      attrs["scope"] = scope_value
     end
 
     def scope
-      attrs&.[]('scope')
+      attrs&.[]("scope")
     end
 
     # Set abbreviated version of the header content
     def abbr=(abbr_text)
       self.attrs ||= {}
-      attrs['abbr'] = abbr_text
+      attrs["abbr"] = abbr_text
     end
 
     def abbr
-      attrs&.[]('abbr')
+      attrs&.[]("abbr")
     end
 
     # Set the number of columns this header spans
@@ -63,11 +63,11 @@ module Prosereflect
       return unless span.to_i.positive?
 
       self.attrs ||= {}
-      attrs['colspan'] = span.to_i
+      attrs["colspan"] = span.to_i
     end
 
     def colspan
-      attrs&.[]('colspan')
+      attrs&.[]("colspan")
     end
 
     # Get header attributes as a hash
@@ -75,16 +75,16 @@ module Prosereflect
       {
         scope: scope,
         abbr: abbr,
-        colspan: colspan
+        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?
+      if result["attrs"]
+        result["attrs"].compact!
+        result.delete("attrs") if result["attrs"].empty?
       end
       result
     end

data/lib/prosereflect/table_row.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'table_cell'
-
 module Prosereflect
   class TableRow < Node
-    PM_TYPE = 'table_row'
+    PM_TYPE = "table_row"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    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
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
     end
 
     def initialize(opts = {})
@@ -44,10 +43,11 @@ module Prosereflect
     # 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?
+      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

data/lib/prosereflect/text.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   class Text < Node
-    PM_TYPE = 'text'
+    PM_TYPE = "text"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
-    attribute :text, :string, default: ''
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
+    attribute :text, :string, default: ""
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'text', to: :text
-      map 'marks', to: :marks
+      map "type", to: :type, render_default: true
+      map "text", to: :text
+      map "marks", to: :marks
     end
 
-    def self.create(text = '', marks = nil)
+    def self.create(text = "", marks = nil)
       new(text: text, marks: marks)
     end
 
     def text_content
-      text || ''
+      text || ""
     end
 
     # Override the to_h method to include the text attribute
     def to_h
       result = super
-      result['text'] = text
+      result["text"] = text
       result
     end
   end

data/lib/prosereflect/user.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # User class represents a user mention in ProseMirror.
   class User < Node
-    PM_TYPE = 'user'
+    PM_TYPE = "user"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    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
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
+      map "content", to: :content
     end
 
     def initialize(attributes = {})
@@ -23,8 +23,8 @@ module Prosereflect
 
       return unless attributes[:attrs]
 
-      @id = attributes[:attrs]['id']
-      self.attrs = { 'id' => @id }
+      @id = attributes[:attrs]["id"]
+      self.attrs = { "id" => @id }
     end
 
     def self.create(attrs = nil)
@@ -35,16 +35,16 @@ module Prosereflect
     def id=(user_id)
       @id = user_id
       self.attrs ||= {}
-      attrs['id'] = user_id
+      attrs["id"] = user_id
     end
 
     def id
-      @id || attrs&.[]('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'
+      raise NotImplementedError, "User mention nodes cannot have children"
     end
 
     def content
@@ -53,10 +53,10 @@ module Prosereflect
 
     def to_h
       hash = super
-      hash['attrs'] = {
-        'id' => id
+      hash["attrs"] = {
+        "id" => id,
       }
-      hash['content'] = []
+      hash["content"] = []
       hash
     end
   end

data/lib/prosereflect/version.rb

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

data/lib/prosereflect.rb

@@ -1,23 +1,33 @@
 # frozen_string_literal: true
 
-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'
+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,34 +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 'nokogiri', '~> 1.18'
+  spec.add_dependency "lutaml-model", "~> 0.8"
+  spec.add_dependency "nokogiri", "~> 1.18"
 end