prosereflect 0.1.0 → 0.1.1

data/lib/prosereflect/code_block.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  # CodeBlock class represents a code block in ProseMirror.
+  class CodeBlock < Node
+    PM_TYPE = 'code_block'
+
+    attribute :type, :string, default: -> { 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
+    end
+
+    def initialize(attributes = {})
+      attributes[:attrs] ||= {
+        'content' => nil,
+        'language' => nil
+      }
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    def language=(value)
+      @language = value
+      self.attrs ||= {}
+      attrs['language'] = value
+    end
+
+    def language
+      @language || attrs&.[]('language')
+    end
+
+    def line_numbers=(value)
+      @line_numbers = value
+      self.attrs ||= {}
+      attrs['line_numbers'] = value
+    end
+
+    def line_numbers
+      @line_numbers || attrs&.[]('line_numbers') || false
+    end
+
+    def content=(value)
+      @content = value
+      self.attrs ||= {}
+      attrs['content'] = value
+    end
+
+    def content
+      @content || attrs&.[]('content')
+    end
+
+    attr_reader :highlight_lines_str
+
+    def highlight_lines=(lines)
+      @highlight_lines_str = if lines.is_a?(Array)
+                               lines.join(',')
+                             else
+                               lines.to_s
+                             end
+    end
+
+    def highlight_lines
+      return [] unless @highlight_lines_str
+
+      @highlight_lines_str.split(',').map(&:to_i)
+    end
+
+    def text_content
+      content.to_s
+    end
+
+    def to_h
+      hash = super
+      hash['attrs'] = {
+        'content' => content,
+        'language' => language
+      }
+      hash['attrs']['line_numbers'] = line_numbers if line_numbers
+      hash.delete('content')
+      hash
+    end
+
+    # Get code block attributes as a hash
+    def attributes
+      {
+        language: language,
+        line_numbers: line_numbers,
+        highlight_lines: highlight_lines
+      }.compact
+    end
+
+    # Add a line of code
+    def add_line(text)
+      text_node = Text.new(text: text)
+      add_child(text_node)
+    end
+
+    # Add multiple lines of code
+    def add_lines(lines)
+      lines.each { |line| add_line(line) }
+    end
+
+    private
+
+    def normalize_content(content)
+      lines = content.split("\n")
+      return content if lines.empty?
+
+      min_indent = lines.reject(&:empty?)
+                        .map { |line| line[/^\s*/].length }
+                        .min || 0
+
+      normalized_lines = lines.map do |line|
+        if line.empty?
+          line
+        else
+          line[min_indent..] || ''
+        end
+      end
+
+      normalized_lines.join("\n")
+    end
+  end
+end

data/lib/prosereflect/code_block_wrapper.rb

@@ -0,0 +1,66 @@
+# 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'
+
+    attribute :type, :string, default: -> { 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
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] ||= []
+      attributes[:attrs] = {
+        'line_numbers' => false
+      }
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    def line_numbers=(value)
+      @line_numbers = value
+      self.attrs ||= {}
+      attrs['line_numbers'] = value
+    end
+
+    def line_numbers
+      @line_numbers || attrs&.[]('line_numbers') || false
+    end
+
+    def add_code_block(code = nil)
+      block = CodeBlock.new
+      block.content = code if code
+      add_child(block)
+      block
+    end
+
+    def code_blocks
+      content
+    end
+
+    def text_content
+      code_blocks.map(&:text_content).join("\n")
+    end
+
+    def to_h
+      hash = super
+      hash['attrs'] = {
+        'line_numbers' => line_numbers
+      }
+      hash
+    end
+  end
+end

data/lib/prosereflect/document.rb

@@ -1,41 +1,67 @@
 # 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
-    def initialize(data = {})
-      super(data)
-      @type = 'doc'
+    attribute :type, :string, default: -> { 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
     end
 
-    def tables
-      find_children('table')
+    def self.create(attrs = nil)
+      new(attrs: attrs, content: [])
     end
 
-    def paragraphs
-      find_children('paragraph')
+    # Override the to_h method to handle attribute arrays
+    def to_h
+      result = super
+
+      # Handle array of attribute objects specially for serialization
+      if attrs.is_a?(Array) && attrs.all? { |attr| attr.is_a?(Prosereflect::Attribute::Base) }
+        attrs_hash = {}
+        attrs.each do |attr|
+          attrs_hash.merge!(attr.to_h)
+        end
+        result['attrs'] = attrs_hash unless attrs_hash.empty?
+      end
+
+      result
     end
 
-    def first_paragraph
-      find_first('paragraph')
+    def tables
+      find_children(Table)
     end
 
-    def first_table
-      find_first('table')
+    def paragraphs
+      find_children(Paragraph)
     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
+    # Add a heading to the document
+    def add_heading(level)
+      heading = Heading.new(attrs: { 'level' => level })
+      add_child(heading)
+      heading
     end
 
     # Add a paragraph with text to the document
     def add_paragraph(text = nil, attrs = nil)
-      paragraph = Paragraph.create(attrs)
+      paragraph = Paragraph.new(attrs: attrs)
 
       paragraph.add_text(text) if text
 
@@ -45,19 +71,68 @@ module Prosereflect
 
     # Add a table to the document
     def add_table(attrs = nil)
-      table = Table.create(attrs)
+      table = Table.new(attrs: attrs)
       add_child(table)
       table
     end
 
-    # Convert document to JSON
-    def to_json(*_args)
-      JSON.generate(to_h)
+    # Add an image to the document
+    def add_image(src, alt = nil, _attrs = {})
+      image = Image.new
+      image.src = src
+      image.alt = alt if alt
+      add_child(image)
+      image
+    end
+
+    # Add a user mention to the document
+    def add_user(id)
+      user = User.new
+      user.id = id
+      add_child(user)
+      user
     end
 
-    # Convert document to YAML
-    def to_yaml
-      to_h.to_yaml
+    # Add a bullet list to the document
+    def add_bullet_list(attrs = nil)
+      list = BulletList.new(attrs: attrs)
+      add_child(list)
+      list
+    end
+
+    # Add an ordered list to the document
+    def add_ordered_list(attrs = nil)
+      list = OrderedList.new(attrs: attrs)
+      add_child(list)
+      list
+    end
+
+    # Add a blockquote to the document
+    def add_blockquote(attrs = nil)
+      quote = Blockquote.new(attrs: attrs)
+      add_child(quote)
+      quote
+    end
+
+    # Add a horizontal rule to the document
+    def add_horizontal_rule(attrs = nil)
+      hr = HorizontalRule.new(attrs: attrs)
+      add_child(hr)
+      hr
+    end
+
+    # Add a code block wrapper to the document
+    def add_code_block_wrapper(attrs = nil)
+      wrapper = CodeBlockWrapper.new(attrs: attrs)
+      add_child(wrapper)
+      wrapper
+    end
+
+    # Get plain text content from all nodes
+    def text_content
+      return '' unless content
+
+      content.map { |node| node.respond_to?(:text_content) ? node.text_content : '' }.join("\n").strip
     end
   end
 end

data/lib/prosereflect/hard_break.rb

@@ -4,19 +4,21 @@ require_relative 'node'
 
 module Prosereflect
   class HardBreak < Node
-    def text_content
-      "\n"
-    end
+    PM_TYPE = 'hard_break'
 
-    def text_content_with_breaks
-      "\n"
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'marks', to: :marks
     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
+      new(marks: marks)
+    end
+
+    def text_content
+      "\n"
     end
   end
 end

data/lib/prosereflect/heading.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'text'
+
+module Prosereflect
+  class Heading < Node
+    PM_TYPE = 'heading'
+
+    attribute :type, :string, default: -> { 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
+    end
+
+    def initialize(params = {})
+      super
+      self.content ||= []
+
+      # Extract level from attrs if provided
+      return unless params[:attrs]
+
+      @level = params[:attrs]['level']
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    def level=(value)
+      @level = value
+      self.attrs ||= {}
+      attrs['level'] = value
+    end
+
+    def level
+      @level || attrs&.[]('level')
+    end
+
+    def text_content
+      return '' unless content
+
+      content.map(&:text_content).join
+    end
+
+    def add_text(text)
+      text_node = Text.new(text: text)
+      add_child(text_node)
+      text_node
+    end
+
+    def to_h
+      result = super
+      result['attrs'] ||= {}
+      result['attrs']['level'] = level if level
+      result
+    end
+  end
+end

data/lib/prosereflect/horizontal_rule.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  # HorizontalRule class represents a horizontal rule in ProseMirror.
+  class HorizontalRule < Node
+    PM_TYPE = 'horizontal_rule'
+
+    attribute :type, :string, default: -> { 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
+    end
+
+    def initialize(attributes = {})
+      attributes[:content] = []
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    def style=(value)
+      @style = value
+      self.attrs ||= {}
+      attrs['style'] = value
+    end
+
+    def style
+      @style || attrs&.[]('style')
+    end
+
+    def width=(value)
+      @width = value
+      self.attrs ||= {}
+      attrs['width'] = value
+    end
+
+    def width
+      @width || attrs&.[]('width')
+    end
+
+    def thickness=(value)
+      @thickness = value
+      self.attrs ||= {}
+      attrs['thickness'] = value
+    end
+
+    def 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'
+    end
+
+    def content
+      []
+    end
+  end
+end

data/lib/prosereflect/image.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Prosereflect
+  # Image class represents a ProseMirror image node.
+  # It handles image attributes like src, alt, title, dimensions, etc.
+  class Image < Node
+    PM_TYPE = 'image'
+
+    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :src, :string
+    attribute :alt, :string
+    attribute :title, :string
+    attribute :width, :integer
+    attribute :height, :integer
+    attribute :attrs, :hash
+
+    key_value do
+      map 'type', to: :type, render_default: true
+      map 'attrs', to: :attrs
+    end
+
+    def initialize(attributes = {})
+      # Images don't have content, they're self-contained
+      attributes[:content] = []
+
+      # Extract attributes from the attrs hash if provided
+      if attributes[:attrs]
+        @src = attributes[:attrs]['src']
+        @alt = attributes[:attrs]['alt']
+        @title = attributes[:attrs]['title']
+        @width = attributes[:attrs]['width']
+        @height = attributes[:attrs]['height']
+      end
+
+      super
+    end
+
+    def self.create(attrs = nil)
+      new(attrs: attrs)
+    end
+
+    # Update the image source URL
+    def src=(src_url)
+      @src = src_url
+      self.attrs ||= {}
+      attrs['src'] = src_url
+    end
+
+    # Update the alt text
+    def alt=(alt_text)
+      @alt = alt_text
+      self.attrs ||= {}
+      attrs['alt'] = alt_text
+    end
+
+    # Update the title (tooltip)
+    def title=(title_text)
+      @title = title_text
+      self.attrs ||= {}
+      attrs['title'] = title_text
+    end
+
+    # Update the width
+    def width=(value)
+      @width = value
+      self.attrs ||= {}
+      attrs['width'] = value
+    end
+
+    # Update the height
+    def height=(value)
+      @height = value
+      self.attrs ||= {}
+      attrs['height'] = value
+    end
+
+    # Update dimensions (width and height)
+    def dimensions=(dimensions)
+      width, height = dimensions
+      self.width = width if width
+      self.height = height if height
+    end
+
+    # Get image attributes as a hash
+    def image_attributes
+      {
+        src: src,
+        alt: alt,
+        title: title,
+        width: width,
+        height: height
+      }.compact
+    end
+
+    # Override content-related methods since images don't have content
+    def add_child(*)
+      raise NotImplementedError, 'Image nodes cannot have children'
+    end
+
+    def content
+      []
+    end
+
+    def src
+      @src || attrs&.[]('src')
+    end
+
+    def alt
+      @alt || attrs&.[]('alt')
+    end
+
+    def title
+      @title || attrs&.[]('title')
+    end
+
+    def width
+      @width || attrs&.[]('width')
+    end
+
+    def height
+      @height || attrs&.[]('height')
+    end
+  end
+end