prosereflect 0.1.1 → 0.2.0

data/lib/prosereflect/attribute.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-require 'lutaml/model'
-
 module Prosereflect
   module Attribute
+    autoload :Base, "#{__dir__}/attribute/base"
+    autoload :Href, "#{__dir__}/attribute/href"
+    autoload :Id, "#{__dir__}/attribute/id"
+    autoload :Bold, "#{__dir__}/attribute/bold"
   end
 end
-
-require_relative 'attribute/base'
-require_relative 'attribute/href'
-require_relative 'attribute/id'
-require_relative 'attribute/bold'

data/lib/prosereflect/blockquote.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'paragraph'
-
 module Prosereflect
   # It can contain other block-level content like paragraphs, lists, etc.
   class Blockquote < Node
-    PM_TYPE = 'blockquote'
+    PM_TYPE = "blockquote"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :citation, :string
     attribute :attrs, :hash
 
     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 = {})
@@ -56,12 +55,12 @@ module Prosereflect
     # Update citation/source for the blockquote
     def citation=(source)
       self.attrs ||= {}
-      attrs['citation'] = source
+      attrs["citation"] = source
     end
 
     # Get citation/source of the blockquote
     def citation
-      attrs&.[]('citation')
+      attrs&.[]("citation")
     end
 
     # Check if blockquote has a citation
@@ -72,7 +71,7 @@ module Prosereflect
     # Remove citation
     def remove_citation
       self.attrs ||= {}
-      attrs.delete('citation')
+      attrs.delete("citation")
     end
 
     def add_paragraph(text)

data/lib/prosereflect/bullet_list.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'list_item'
-
 module Prosereflect
   # BulletList class represents an unordered list in ProseMirror.
   class BulletList < Node
-    PM_TYPE = 'bullet_list'
+    PM_TYPE = "bullet_list"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :bullet_style, :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 = {})
       attributes[:content] ||= []
-      attributes[:attrs] ||= { 'bullet_style' => nil }
+      attributes[:attrs] ||= { "bullet_style" => nil }
       super
     end
 
@@ -31,11 +30,11 @@ module Prosereflect
     def bullet_style=(value)
       @bullet_style = value
       self.attrs ||= {}
-      attrs['bullet_style'] = value
+      attrs["bullet_style"] = value
     end
 
     def bullet_style
-      @bullet_style || attrs&.[]('bullet_style')
+      @bullet_style || attrs&.[]("bullet_style")
     end
 
     def add_item(text)
@@ -67,16 +66,18 @@ module Prosereflect
 
     # Get text content with proper formatting
     def text_content
-      return '' unless content
+      return "" unless content
 
-      content.map { |item| item.respond_to?(:text_content) ? item.text_content : '' }.join("\n")
+      content.map do |item|
+        item.respond_to?(:text_content) ? item.text_content : ""
+      end.join("\n")
     end
 
     # Override to_h to exclude empty attrs
     def to_h
       hash = super
-      hash['attrs'] ||= {}
-      hash['attrs']['bullet_style'] = bullet_style
+      hash["attrs"] ||= {}
+      hash["attrs"]["bullet_style"] = bullet_style
       hash
     end
   end

data/lib/prosereflect/code_block.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # CodeBlock class represents a code block in ProseMirror.
   class CodeBlock < Node
-    PM_TYPE = 'code_block'
+    PM_TYPE = "code_block"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :language, :string
     attribute :line_numbers, :boolean
     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 = {})
       attributes[:attrs] ||= {
-        'content' => nil,
-        'language' => nil
+        "content" => nil,
+        "language" => nil,
       }
       super
     end
@@ -33,38 +33,38 @@ module Prosereflect
     def language=(value)
       @language = value
       self.attrs ||= {}
-      attrs['language'] = value
+      attrs["language"] = value
     end
 
     def language
-      @language || attrs&.[]('language')
+      @language || attrs&.[]("language")
     end
 
     def line_numbers=(value)
       @line_numbers = value
       self.attrs ||= {}
-      attrs['line_numbers'] = value
+      attrs["line_numbers"] = value
     end
 
     def line_numbers
-      @line_numbers || attrs&.[]('line_numbers') || false
+      @line_numbers || attrs&.[]("line_numbers") || false
     end
 
     def content=(value)
       @content = value
       self.attrs ||= {}
-      attrs['content'] = value
+      attrs["content"] = value
     end
 
     def content
-      @content || attrs&.[]('content')
+      @content || attrs&.[]("content")
     end
 
     attr_reader :highlight_lines_str
 
     def highlight_lines=(lines)
       @highlight_lines_str = if lines.is_a?(Array)
-                               lines.join(',')
+                               lines.join(",")
                              else
                                lines.to_s
                              end
@@ -73,7 +73,7 @@ module Prosereflect
     def highlight_lines
       return [] unless @highlight_lines_str
 
-      @highlight_lines_str.split(',').map(&:to_i)
+      @highlight_lines_str.split(",").map(&:to_i)
     end
 
     def text_content
@@ -82,12 +82,12 @@ module Prosereflect
 
     def to_h
       hash = super
-      hash['attrs'] = {
-        'content' => content,
-        'language' => language
+      hash["attrs"] = {
+        "content" => content,
+        "language" => language,
       }
-      hash['attrs']['line_numbers'] = line_numbers if line_numbers
-      hash.delete('content')
+      hash["attrs"]["line_numbers"] = line_numbers if line_numbers
+      hash.delete("content")
       hash
     end
 
@@ -96,7 +96,7 @@ module Prosereflect
       {
         language: language,
         line_numbers: line_numbers,
-        highlight_lines: highlight_lines
+        highlight_lines: highlight_lines,
       }.compact
     end
 
@@ -118,14 +118,14 @@ module Prosereflect
       return content if lines.empty?
 
       min_indent = lines.reject(&:empty?)
-                        .map { |line| line[/^\s*/].length }
-                        .min || 0
+        .map { |line| line[/^\s*/].length }
+        .min || 0
 
       normalized_lines = lines.map do |line|
         if line.empty?
           line
         else
-          line[min_indent..] || ''
+          line[min_indent..] || ""
         end
       end
 

data/lib/prosereflect/code_block_wrapper.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'code_block'
-
 module Prosereflect
   # CodeBlockWrapper class represents a pre tag that wraps code blocks in ProseMirror.
   class CodeBlockWrapper < Node
-    PM_TYPE = 'code_block_wrapper'
+    PM_TYPE = "code_block_wrapper"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :line_numbers, :boolean
     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 = {})
       attributes[:content] ||= []
       attributes[:attrs] = {
-        'line_numbers' => false
+        "line_numbers" => false,
       }
       super
     end
@@ -33,11 +32,11 @@ module Prosereflect
     def line_numbers=(value)
       @line_numbers = value
       self.attrs ||= {}
-      attrs['line_numbers'] = value
+      attrs["line_numbers"] = value
     end
 
     def line_numbers
-      @line_numbers || attrs&.[]('line_numbers') || false
+      @line_numbers || attrs&.[]("line_numbers") || false
     end
 
     def add_code_block(code = nil)
@@ -57,8 +56,8 @@ module Prosereflect
 
     def to_h
       hash = super
-      hash['attrs'] = {
-        'line_numbers' => line_numbers
+      hash["attrs"] = {
+        "line_numbers" => line_numbers,
       }
       hash
     end

data/lib/prosereflect/document.rb

@@ -1,27 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'table'
-require_relative 'paragraph'
-require_relative 'image'
-require_relative 'bullet_list'
-require_relative 'ordered_list'
-require_relative 'blockquote'
-require_relative 'horizontal_rule'
-require_relative 'code_block_wrapper'
-require_relative 'heading'
-require_relative 'user'
-
 module Prosereflect
   # Document class represents a ProseMirror document.
   class Document < Node
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
-    PM_TYPE = 'doc'
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
+    PM_TYPE = "doc"
 
     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 self.create(attrs = nil)
@@ -33,12 +23,12 @@ module Prosereflect
       result = super
 
       # Handle array of attribute objects specially for serialization
-      if attrs.is_a?(Array) && attrs.all? { |attr| attr.is_a?(Prosereflect::Attribute::Base) }
+      if attrs.is_a?(Array) && attrs.all?(Prosereflect::Attribute::Base)
         attrs_hash = {}
         attrs.each do |attr|
           attrs_hash.merge!(attr.to_h)
         end
-        result['attrs'] = attrs_hash unless attrs_hash.empty?
+        result["attrs"] = attrs_hash unless attrs_hash.empty?
       end
 
       result
@@ -54,7 +44,7 @@ module Prosereflect
 
     # Add a heading to the document
     def add_heading(level)
-      heading = Heading.new(attrs: { 'level' => level })
+      heading = Heading.new(attrs: { "level" => level })
       add_child(heading)
       heading
     end
@@ -130,9 +120,11 @@ module Prosereflect
 
     # Get plain text content from all nodes
     def text_content
-      return '' unless content
+      return "" unless content
 
-      content.map { |node| node.respond_to?(:text_content) ? node.text_content : '' }.join("\n").strip
+      content.map do |node|
+        node.respond_to?(:text_content) ? node.text_content : ""
+      end.join("\n").strip
     end
   end
 end

data/lib/prosereflect/hard_break.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   class HardBreak < Node
-    PM_TYPE = 'hard_break'
+    PM_TYPE = "hard_break"
 
-    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 'marks', to: :marks
+      map "type", to: :type, render_default: true
+      map "marks", to: :marks
     end
 
     def self.create(marks = nil)

data/lib/prosereflect/heading.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'text'
-
 module Prosereflect
   class Heading < Node
-    PM_TYPE = 'heading'
+    PM_TYPE = "heading"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :level, :integer
     attribute :attrs, :hash
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'content', to: :content
-      map 'attrs', to: :attrs
-      map 'marks', to: :marks
+      map "type", to: :type, render_default: true
+      map "content", to: :content
+      map "attrs", to: :attrs
+      map "marks", to: :marks
     end
 
     def initialize(params = {})
@@ -25,7 +24,7 @@ module Prosereflect
       # Extract level from attrs if provided
       return unless params[:attrs]
 
-      @level = params[:attrs]['level']
+      @level = params[:attrs]["level"]
     end
 
     def self.create(attrs = nil)
@@ -35,15 +34,15 @@ module Prosereflect
     def level=(value)
       @level = value
       self.attrs ||= {}
-      attrs['level'] = value
+      attrs["level"] = value
     end
 
     def level
-      @level || attrs&.[]('level')
+      @level || attrs&.[]("level")
     end
 
     def text_content
-      return '' unless content
+      return "" unless content
 
       content.map(&:text_content).join
     end
@@ -56,8 +55,8 @@ module Prosereflect
 
     def to_h
       result = super
-      result['attrs'] ||= {}
-      result['attrs']['level'] = level if level
+      result["attrs"] ||= {}
+      result["attrs"]["level"] = level if level
       result
     end
   end

data/lib/prosereflect/horizontal_rule.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # HorizontalRule class represents a horizontal rule in ProseMirror.
   class HorizontalRule < Node
-    PM_TYPE = 'horizontal_rule'
+    PM_TYPE = "horizontal_rule"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :style, :string
     attribute :width, :string
     attribute :thickness, :integer
     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 = {})
@@ -31,36 +31,36 @@ module Prosereflect
     def style=(value)
       @style = value
       self.attrs ||= {}
-      attrs['style'] = value
+      attrs["style"] = value
     end
 
     def style
-      @style || attrs&.[]('style')
+      @style || attrs&.[]("style")
     end
 
     def width=(value)
       @width = value
       self.attrs ||= {}
-      attrs['width'] = value
+      attrs["width"] = value
     end
 
     def width
-      @width || attrs&.[]('width')
+      @width || attrs&.[]("width")
     end
 
     def thickness=(value)
       @thickness = value
       self.attrs ||= {}
-      attrs['thickness'] = value
+      attrs["thickness"] = value
     end
 
     def thickness
-      @thickness || attrs&.[]('thickness')
+      @thickness || attrs&.[]("thickness")
     end
 
     # Override content-related methods since horizontal rules don't have content
     def add_child(*)
-      raise NotImplementedError, 'Horizontal rule nodes cannot have children'
+      raise NotImplementedError, "Horizontal rule nodes cannot have children"
     end
 
     def content