prosereflect 0.1.1 → 0.2.0

data/lib/prosereflect/mark/italic.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "italic"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Italic < Base
-      PM_TYPE = 'italic'
+      PM_TYPE = "italic"
     end
   end
 end

data/lib/prosereflect/mark/link.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "link",
 #   attrs: {
@@ -12,7 +10,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Link < Base
-      PM_TYPE = 'link'
+      PM_TYPE = "link"
     end
   end
 end

data/lib/prosereflect/mark/strike.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "strike"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Strike < Base
-      PM_TYPE = 'strike'
+      PM_TYPE = "strike"
     end
   end
 end

data/lib/prosereflect/mark/subscript.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "subscript"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Subscript < Base
-      PM_TYPE = 'subscript'
+      PM_TYPE = "subscript"
     end
   end
 end

data/lib/prosereflect/mark/superscript.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "superscript"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Superscript < Base
-      PM_TYPE = 'superscript'
+      PM_TYPE = "superscript"
     end
   end
 end

data/lib/prosereflect/mark/underline.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 # {
 #   type: "underline"
 # }
@@ -9,7 +7,7 @@ require_relative 'base'
 module Prosereflect
   module Mark
     class Underline < Base
-      PM_TYPE = 'underline'
+      PM_TYPE = "underline"
     end
   end
 end

data/lib/prosereflect/mark.rb

@@ -2,10 +2,14 @@
 
 module Prosereflect
   module Mark
+    autoload :Base, "#{__dir__}/mark/base"
+    autoload :Bold, "#{__dir__}/mark/bold"
+    autoload :Italic, "#{__dir__}/mark/italic"
+    autoload :Code, "#{__dir__}/mark/code"
+    autoload :Link, "#{__dir__}/mark/link"
+    autoload :Strike, "#{__dir__}/mark/strike"
+    autoload :Subscript, "#{__dir__}/mark/subscript"
+    autoload :Superscript, "#{__dir__}/mark/superscript"
+    autoload :Underline, "#{__dir__}/mark/underline"
   end
 end
-
-require_relative 'mark/bold'
-require_relative 'mark/italic'
-require_relative 'mark/code'
-require_relative 'mark/link'

data/lib/prosereflect/node.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require 'lutaml/model'
-require_relative 'attribute'
-require_relative 'mark'
-
 module Prosereflect
   class Node < Lutaml::Model::Serializable
-    PM_TYPE = 'node'
+    PM_TYPE = "node"
 
     attribute :type, :string
     attribute :attrs, :hash
@@ -14,10 +10,10 @@ module Prosereflect
     attribute :content, Node, polymorphic: true, collection: true
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'attrs', to: :attrs
-      map 'marks', to: :marks
-      map 'content', to: :content
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
+      map "marks", to: :marks
+      map "content", to: :content
     end
 
     def initialize(data = nil, attrs = nil)
@@ -25,18 +21,18 @@ module Prosereflect
         super(type: data, attrs: attrs, content: [])
       elsif data.is_a?(Hash)
         # Handle marks in a special way to preserve expected behavior in tests
-        if data[:marks] || data['marks']
-          marks_data = data[:marks] || data['marks']
+        if data[:marks] || data["marks"]
+          marks_data = data[:marks] || data["marks"]
           data = data.dup
-          data.delete('marks')
+          data.delete("marks")
           data.delete(:marks)
           super(data)
           self.marks = marks_data
         else
           # Handle attrs properly
-          if data[:attrs] || data['attrs']
+          if data[:attrs] || data["attrs"]
             data = data.dup
-            data[:attrs] = process_attrs_data(data[:attrs] || data['attrs'])
+            data[:attrs] = process_attrs_data(data[:attrs] || data["attrs"])
           end
           super(data)
         end
@@ -56,33 +52,35 @@ module Prosereflect
     def self.create(type = nil, attrs = nil)
       new(type || self::PM_TYPE, attrs)
     rescue NameError
-      new(type || 'node', attrs)
+      new(type || "node", attrs)
     end
 
     # Convert to hash for serialization
     def to_h
-      result = { 'type' => type }
+      result = { "type" => type }
 
       if attrs && !attrs.empty?
         if attrs.is_a?(Hash)
-          result['attrs'] = process_node_attributes(attrs, type)
-        elsif attrs.is_a?(Array) && attrs.all? { |attr| attr.respond_to?(:to_h) }
+          result["attrs"] = process_node_attributes(attrs, type)
+        elsif attrs.is_a?(Array) && attrs.all? do |attr|
+          attr.respond_to?(:to_h)
+        end
           # Convert array of attribute objects to a hash
           attrs_array = attrs.map do |attr|
             attr.is_a?(Prosereflect::Attribute::Base) ? attr.to_h : attr
           end
-          result['attrs'] = attrs_array unless attrs_array.empty?
+          result["attrs"] = attrs_array unless attrs_array.empty?
         end
       end
 
       if marks && !marks.empty?
-        result['marks'] = marks.map do |mark|
+        result["marks"] = marks.map do |mark|
           if mark.is_a?(Hash)
             mark
           elsif mark.respond_to?(:to_h)
             mark.to_h
           elsif mark.respond_to?(:type)
-            { 'type' => mark.type.to_s }
+            { "type" => mark.type.to_s }
           else
             raise ArgumentError, "Invalid mark type: #{mark.class}"
           end
@@ -90,8 +88,10 @@ module Prosereflect
       end
 
       if content && !content.empty?
-        result['content'] = if content.is_a?(Array)
-                              content.map { |item| item.respond_to?(:to_h) ? item.to_h : item }
+        result["content"] = if content.is_a?(Array)
+                              content.map do |item|
+                                item.respond_to?(:to_h) ? item.to_h : item
+                              end
                             else
                               [content]
                             end
@@ -112,7 +112,7 @@ module Prosereflect
         elsif mark.respond_to?(:to_h)
           mark.to_h
         elsif mark.respond_to?(:type)
-          { 'type' => mark.type.to_s }
+          { "type" => mark.type.to_s }
         else
           raise ArgumentError, "Invalid mark type: #{mark.class}"
         end
@@ -131,8 +131,8 @@ module Prosereflect
       elsif value.is_a?(Array)
         @marks = value.map do |v|
           if v.is_a?(Hash)
-            type = v['type'] || v[:type]
-            attrs = v['attrs'] || v[:attrs]
+            type = v["type"] || v[:type]
+            attrs = v["attrs"] || v[:attrs]
             begin
               mark_class = Prosereflect::Mark.const_get(type.to_s.capitalize)
               mark_class.new(attrs: attrs)
@@ -197,11 +197,11 @@ module Prosereflect
     def find_children(node_type)
       return [] unless content
 
-      content.select { |child| child.is_a?(node_type) }
+      content.grep(node_type)
     end
 
     def text_content
-      return '' unless content
+      return "" unless content
 
       content.map(&:text_content).join
     end
@@ -214,9 +214,9 @@ module Prosereflect
     private
 
     def process_node_attributes(attrs, node_type)
-      if attrs['attrs'].is_a?(Hash)
-        attrs['attrs']
-      elsif node_type == 'bullet_list' && attrs['bullet_style'].nil?
+      if attrs["attrs"].is_a?(Hash)
+        attrs["attrs"]
+      elsif node_type == "bullet_list" && attrs["bullet_style"].nil?
         nil
       else
         attrs

data/lib/prosereflect/ordered_list.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'list_item'
-
 module Prosereflect
   # OrderedList class represents a numbered list in ProseMirror.
   class OrderedList < Node
-    PM_TYPE = 'ordered_list'
+    PM_TYPE = "ordered_list"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :start, :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 = {})
@@ -30,11 +29,11 @@ module Prosereflect
     def start=(value)
       @start = value
       self.attrs ||= {}
-      attrs['start'] = value
+      attrs["start"] = value
     end
 
     def start
-      @start || attrs&.[]('start') || 1
+      @start || attrs&.[]("start") || 1
     end
 
     def add_item(text)
@@ -67,19 +66,21 @@ module Prosereflect
     # Update the order (1 for numerical, 'a' for alphabetical, etc.)
     def order=(order_value)
       self.attrs ||= {}
-      attrs['order'] = order_value
+      attrs["order"] = order_value
     end
 
     # Get the order value
     def order
-      attrs&.[]('order') || 1
+      attrs&.[]("order") || 1
     end
 
     # 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
   end
 end

data/lib/prosereflect/output/html.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
-require_relative '../document'
+require "nokogiri"
 
 module Prosereflect
   module Output
@@ -16,7 +15,7 @@ module Prosereflect
           end
 
           doc = Nokogiri::HTML(builder.to_html)
-          html = doc.at_css('div').children.to_html
+          html = doc.at_css("div").children.to_html
 
           code_blocks = {}
           html.scan(%r{<code[^>]*>(.*?)</code>}m).each_with_index do |match, i|
@@ -27,7 +26,7 @@ module Prosereflect
           end
 
           # Remove newlines and spaces
-          html = html.gsub(/\n\s*/, '')
+          html = html.gsub(/\n\s*/, "")
 
           code_blocks.each do |placeholder, content|
             html.sub!(placeholder, content)
@@ -43,41 +42,41 @@ module Prosereflect
           return unless node
 
           case node.type
-          when 'doc'
+          when "doc"
             process_document(node, builder)
-          when 'paragraph'
+          when "paragraph"
             process_paragraph(node, builder)
-          when 'heading'
+          when "heading"
             process_heading(node, builder)
-          when 'text'
+          when "text"
             process_text(node, builder)
-          when 'table'
+          when "table"
             process_table(node, builder)
-          when 'table_row'
+          when "table_row"
             process_table_row(node, builder)
-          when 'table_cell'
+          when "table_cell"
             process_table_cell(node, builder)
-          when 'table_header'
+          when "table_header"
             process_table_header(node, builder)
-          when 'hard_break'
+          when "hard_break"
             builder.br
-          when 'image'
+          when "image"
             process_image(node, builder)
-          when 'user'
+          when "user"
             process_user(node, builder)
-          when 'bullet_list'
+          when "bullet_list"
             process_bullet_list(node, builder)
-          when 'ordered_list'
+          when "ordered_list"
             process_ordered_list(node, builder)
-          when 'list_item'
+          when "list_item"
             process_list_item(node, builder)
-          when 'blockquote'
+          when "blockquote"
             process_blockquote(node, builder)
-          when 'horizontal_rule'
+          when "horizontal_rule"
             process_horizontal_rule(node, builder)
-          when 'code_block_wrapper'
+          when "code_block_wrapper"
             process_code_block_wrapper(node, builder)
-          when 'code_block'
+          when "code_block"
             process_code_block(node, builder)
           else
             # Default handling for unknown nodes - treat as a container
@@ -124,27 +123,27 @@ module Prosereflect
           remaining_marks = marks[1..]
 
           mark_type = if current_mark.is_a?(Hash)
-                        current_mark['type']
+                        current_mark["type"]
                       elsif current_mark.respond_to?(:type)
                         current_mark.type
                       else
-                        'unknown'
+                        "unknown"
                       end
 
           case mark_type
-          when 'bold'
+          when "bold"
             builder.strong do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'italic'
+          when "italic"
             builder.em do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'code'
+          when "code"
             builder.code do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'link'
+          when "link"
             href = find_href_attribute(current_mark)
             if href
               builder.a(href: href) do
@@ -153,19 +152,19 @@ module Prosereflect
             else
               apply_marks(text, remaining_marks, builder)
             end
-          when 'strike'
+          when "strike"
             builder.del do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'underline'
+          when "underline"
             builder.u do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'subscript'
+          when "subscript"
             builder.sub do
               apply_marks(text, remaining_marks, builder)
             end
-          when 'superscript'
+          when "superscript"
             builder.sup do
               apply_marks(text, remaining_marks, builder)
             end
@@ -178,23 +177,23 @@ module Prosereflect
         # Find href attribute in a link mark
         def find_href_attribute(mark)
           if mark.is_a?(Hash)
-            if mark['attrs'].is_a?(Hash)
-              return mark['attrs']['href']
-            elsif mark['attrs'].is_a?(Array)
-              href_attr = mark['attrs'].find { |a| a.is_a?(Prosereflect::Attribute::Href) || (a.is_a?(Hash) && a['type'] == 'href') }
-              return href_attr['href'] if href_attr.is_a?(Hash) && href_attr['href']
+            if mark["attrs"].is_a?(Hash)
+              return mark["attrs"]["href"]
+            elsif mark["attrs"].is_a?(Array)
+              href_attr = mark["attrs"].find { |a| a.is_a?(Prosereflect::Attribute::Href) || (a.is_a?(Hash) && a["type"] == "href") }
+              return href_attr["href"] if href_attr.is_a?(Hash) && href_attr["href"]
               return href_attr.href if href_attr.respond_to?(:href)
             end
           elsif mark.respond_to?(:attrs)
             attrs = mark.attrs
             if attrs.is_a?(Hash)
-              return attrs['href']
+              return attrs["href"]
             elsif attrs.is_a?(Array)
               href_attr = attrs.find { |attr| attr.is_a?(Prosereflect::Attribute::Href) }
               return href_attr&.href if href_attr
 
-              hash_attr = attrs.find { |attr| attr.is_a?(Hash) && attr['href'] }
-              return hash_attr['href'] if hash_attr
+              hash_attr = attrs.find { |attr| attr.is_a?(Hash) && attr["href"] }
+              return hash_attr["href"] if hash_attr
             end
           end
           nil
@@ -206,7 +205,9 @@ module Prosereflect
             rows = node.rows || node.content
             return if rows.empty?
 
-            has_header = rows.first&.content&.any? { |cell| cell.type == 'table_header' }
+            has_header = rows.first&.content&.any? do |cell|
+              cell.type == "table_header"
+            end
 
             if has_header
               builder.thead do
@@ -233,7 +234,7 @@ module Prosereflect
         # Process a table cell
         def process_table_cell(node, builder)
           builder.td do
-            if node.content&.size == 1 && node.content.first.type == 'paragraph'
+            if node.content&.size == 1 && node.content.first.type == "paragraph"
               node.content.first.content&.each do |child|
                 process_node(child, builder)
               end
@@ -251,7 +252,7 @@ module Prosereflect
           attrs[:colspan] = node.colspan if node.colspan
 
           builder.th(attrs) do
-            if node.content&.size == 1 && node.content.first.type == 'paragraph'
+            if node.content&.size == 1 && node.content.first.type == "paragraph"
               node.content.first.content&.each do |child|
                 process_node(child, builder)
               end
@@ -265,7 +266,7 @@ module Prosereflect
         def process_image(node, builder)
           attrs = {
             src: node.src,
-            alt: node.alt
+            alt: node.alt,
           }
           attrs[:title] = node.title if node.title
           attrs[:width] = node.width if node.width
@@ -283,7 +284,7 @@ module Prosereflect
         def process_bullet_list(node, builder)
           builder.ul do
             node.content&.each do |child|
-              if child.type == 'list_item'
+              if child.type == "list_item"
                 process_node(child, builder)
               else
                 builder.li do
@@ -330,7 +331,7 @@ module Prosereflect
           attrs[:style] << "border-style: #{node.style}" if node.style
           attrs[:style] << "width: #{node.width}" if node.width
           attrs[:style] << "border-width: #{node.thickness}px" if node.thickness
-          attrs[:style] = attrs[:style].join('; ') unless attrs[:style].empty?
+          attrs[:style] = attrs[:style].join("; ") unless attrs[:style].empty?
 
           builder.hr(attrs)
         end
@@ -339,9 +340,10 @@ module Prosereflect
         def process_code_block_wrapper(node, builder)
           attrs = {}
           if node.attrs
-            attrs['data-line-numbers'] = 'true' if node.attrs['line_numbers']
-            if node.attrs['highlight_lines'].is_a?(Array) && !node.attrs['highlight_lines'].empty? && node.attrs['highlight_lines'] != [0]
-              attrs['data-highlight-lines'] = node.attrs['highlight_lines'].join(',')
+            attrs["data-line-numbers"] = "true" if node.attrs["line_numbers"]
+            if node.attrs["highlight_lines"].is_a?(Array) && !node.attrs["highlight_lines"].empty? && node.attrs["highlight_lines"] != [0]
+              attrs["data-highlight-lines"] =
+                node.attrs["highlight_lines"].join(",")
             end
           end
 
@@ -353,7 +355,7 @@ module Prosereflect
         # Process a code block node
         def process_code_block(node, builder)
           attrs = {}
-          attrs['class'] = "language-#{node.language}" if node.language
+          attrs["class"] = "language-#{node.language}" if node.language
 
           builder.code(attrs) do
             builder.text node.content

data/lib/prosereflect/output.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module Output
+    autoload :Html, "#{__dir__}/output/html"
+  end
+end

data/lib/prosereflect/paragraph.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'text'
-require_relative 'hard_break'
-
 module Prosereflect
   class Paragraph < Node
-    PM_TYPE = 'paragraph'
+    PM_TYPE = "paragraph"
 
-    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 '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 = {})
@@ -29,13 +27,13 @@ module Prosereflect
     def text_nodes
       return [] unless content
 
-      content.select { |node| node.is_a?(Text) }
+      content.grep(Text)
     end
 
     def text_content
-      return '' unless content
+      return "" unless content
 
-      result = ''
+      result = ""
       content.each do |node|
         result += node.text_content
       end