prosereflect 0.1.0 → 0.1.1

data/lib/prosereflect/mark/subscript.rb

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

data/lib/prosereflect/mark/superscript.rb

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

data/lib/prosereflect/mark/underline.rb

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

data/lib/prosereflect/mark.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module Mark
+  end
+end
+
+require_relative 'mark/bold'
+require_relative 'mark/italic'
+require_relative 'mark/code'
+require_relative 'mark/link'

data/lib/prosereflect/node.rb

@@ -1,42 +1,180 @@
 # frozen_string_literal: true
 
+require 'lutaml/model'
+require_relative 'attribute'
+require_relative 'mark'
+
 module Prosereflect
-  class Node
-    attr_reader :type, :attrs, :marks
-    attr_accessor :content
+  class Node < Lutaml::Model::Serializable
+    PM_TYPE = 'node'
+
+    attribute :type, :string
+    attribute :attrs, :hash
+    attribute :marks, Mark::Base, polymorphic: true, collection: true
+    attribute :content, Node, polymorphic: true, collection: true
 
-    def initialize(data = {})
-      @type = data['type']
-      @attrs = data['attrs']
-      @content = parse_content(data['content'])
-      @marks = data['marks']
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'attrs', to: :attrs
+      map 'marks', to: :marks
+      map 'content', to: :content
     end
 
-    def parse_content(content_data)
-      return [] unless content_data
+    def initialize(data = nil, attrs = nil)
+      if data.is_a?(String)
+        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']
+          data = data.dup
+          data.delete('marks')
+          data.delete(:marks)
+          super(data)
+          self.marks = marks_data
+        else
+          # Handle attrs properly
+          if data[:attrs] || data['attrs']
+            data = data.dup
+            data[:attrs] = process_attrs_data(data[:attrs] || data['attrs'])
+          end
+          super(data)
+        end
+      else
+        super()
+      end
+    end
 
-      content_data.map { |item| Parser.parse(item) }
+    def process_attrs_data(attrs_data)
+      if attrs_data.is_a?(Hash)
+        attrs_data.transform_keys(&:to_s)
+      else
+        attrs_data
+      end
+    end
+
+    def self.create(type = nil, attrs = nil)
+      new(type || self::PM_TYPE, attrs)
+    rescue NameError
+      new(type || 'node', attrs)
     end
 
-    # Create a serializable hash representation of this node
+    # Convert to hash for serialization
     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 = { '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) }
+          # 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?
+        end
+      end
+
+      if marks && !marks.empty?
+        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 }
+          else
+            raise ArgumentError, "Invalid mark type: #{mark.class}"
+          end
+        end
+      end
+
+      if content && !content.empty?
+        result['content'] = if content.is_a?(Array)
+                              content.map { |item| item.respond_to?(:to_h) ? item.to_h : item }
+                            else
+                              [content]
+                            end
+      end
+
       result
     end
 
+    alias to_hash to_h
+
+    def marks
+      return nil if @marks.nil?
+      return [] if @marks.empty?
+
+      @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 }
+        else
+          raise ArgumentError, "Invalid mark type: #{mark.class}"
+        end
+      end
+    end
+
+    def raw_marks
+      @marks
+    end
+
+    def marks=(value)
+      if value.nil?
+        @marks = nil
+      elsif value.is_a?(Array) && value.empty?
+        @marks = []
+      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]
+            begin
+              mark_class = Prosereflect::Mark.const_get(type.to_s.capitalize)
+              mark_class.new(attrs: attrs)
+            rescue NameError
+              Mark::Base.new(type: type, attrs: attrs)
+            end
+          elsif v.is_a?(Mark::Base)
+            v
+          elsif v.respond_to?(:type)
+            begin
+              mark_class = Prosereflect::Mark.const_get(v.type.to_s.capitalize)
+              mark_class.new(attrs: v.attrs)
+            rescue NameError
+              Mark::Base.new(type: v.type, attrs: v.attrs)
+            end
+          else
+            raise ArgumentError, "Invalid mark type: #{v.class}"
+          end
+        end
+      else
+        super
+      end
+    end
+
+    def parse_content(content_data)
+      return [] unless content_data
+
+      content_data.map { |item| Parser.parse(item) }
+    end
+
     # Add a child node to this node's content
     def add_child(node)
-      @content ||= []
-      @content << node
+      self.content ||= []
+      content << node
       node
     end
 
     def find_first(node_type)
       return self if type == node_type
 
+      return nil unless content
+
       content.each do |child|
         result = child.find_first(node_type)
         return result if result
@@ -44,34 +182,45 @@ module Prosereflect
       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))
+
+      content&.each do |child|
+        child_results = child.find_all(node_type)
+        results.concat(child_results) if child_results
       end
+
       results
     end
 
     def find_children(node_type)
-      content.select { |child| child.type == node_type }
+      return [] unless content
+
+      content.select { |child| child.is_a?(node_type) }
     end
 
     def text_content
+      return '' unless 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
+    # Ensures YAML serialization outputs plain data instead of a Ruby object
+    def to_yaml(*args)
+      to_h.to_yaml(*args)
+    end
+
+    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?
+        nil
+      else
+        attrs
+      end
     end
   end
 end

data/lib/prosereflect/ordered_list.rb

@@ -0,0 +1,85 @@
+# 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'
+
+    attribute :type, :string, default: -> { 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
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] ||= []
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    def start=(value)
+      @start = value
+      self.attrs ||= {}
+      attrs['start'] = value
+    end
+
+    def start
+      @start || attrs&.[]('start') || 1
+    end
+
+    def add_item(text)
+      item = ListItem.new
+      item.add_paragraph(text)
+      add_child(item)
+      item
+    end
+
+    def items
+      return [] unless content
+
+      content
+    end
+
+    # Add multiple items at once
+    def add_items(items_content)
+      items_content.each do |item_content|
+        add_item(item_content)
+      end
+    end
+
+    # Get item at specific position
+    def item_at(index)
+      return nil if index.negative?
+
+      items[index]
+    end
+
+    # Update the order (1 for numerical, 'a' for alphabetical, etc.)
+    def order=(order_value)
+      self.attrs ||= {}
+      attrs['order'] = order_value
+    end
+
+    # Get the order value
+    def order
+      attrs&.[]('order') || 1
+    end
+
+    # Get text content with proper formatting
+    def text_content
+      return '' unless content
+
+      content.map { |item| item.respond_to?(:text_content) ? item.text_content : '' }.join("\n")
+    end
+  end
+end