prosereflect 0.1.1 → 0.3.0

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,56 @@
 # 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
+
+    # Text node size is text length + 1 (for the opening token)
+    def node_size
+      (text || "").length + 1
+    end
+
+    # Text nodes are text nodes
+    def text?
+      true
+    end
+
+    # Return a copy of this text node with content restricted to range
+    def cut(from = 0, to = nil)
+      txt = text || ""
+      to ||= txt.length
+      self.class.new(text: txt[from...to], marks: raw_marks)
+    end
+
+    # Check equality with another text node
+    def eq?(other)
+      return false unless other.is_a?(self.class)
+
+      text == other.text && to_h == other.to_h
     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/transform/attr_step.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "step"
+require_relative "step_map"
+
+module Prosereflect
+  module Transform
+    # Set or remove attributes on a node at a position
+    class AttrStep < Step
+      attr_reader :pos, :attrs
+
+      def initialize(pos, attrs)
+        super()
+        @pos = pos
+        @attrs = attrs
+      end
+
+      def apply(doc)
+        return Result.fail("Invalid position") if @pos.negative? || @pos > doc.node_size
+
+        begin
+          new_doc = set_node_attrs(doc)
+          Result.ok(new_doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def get_map
+        StepMap.new
+      end
+
+      def invert(doc)
+        # Find what attrs were changed and revert them
+        old_attrs = get_old_attrs(doc)
+        AttrStep.new(@pos, old_attrs)
+      end
+
+      def step_type
+        "setAttr"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["pos"] = @pos
+        json["attrs"] = @attrs
+        json
+      end
+
+      def self.from_json(_schema, json)
+        new(json["pos"], json["attrs"])
+      end
+
+      private
+
+      def set_node_attrs(doc)
+        target_node = find_node_at(doc, @pos)
+        return doc unless target_node
+
+        new_attrs = compute_new_attrs(target_node)
+        replace_node_with_new_attrs(doc, target_node, new_attrs)
+      end
+
+      def compute_new_attrs(target_node)
+        new_attrs = target_node.attrs.merge(@attrs)
+        new_attrs.compact!
+        new_attrs
+      end
+
+      def replace_node_with_new_attrs(doc, target_node, new_attrs)
+        new_content = doc.content.to_a.map { |node| replace_node(node, target_node, new_attrs) }
+        doc.class.new(content: Fragment.new(new_content), attrs: doc.attrs.dup)
+      end
+
+      def replace_node(node, target_node, new_attrs)
+        return node unless node == target_node
+
+        node.class.new(
+          content: node.content,
+          marks: node.marks,
+          attrs: new_attrs,
+        )
+      end
+
+      def find_node_at(doc, pos)
+        result = nil
+        doc.nodes_between(pos, pos + 1) do |node|
+          result = node
+        end
+        result
+      end
+
+      def get_old_attrs(doc)
+        target_node = find_node_at(doc, @pos)
+        return {} unless target_node
+
+        # Return only the attrs that we're changing
+        @attrs.keys.each_with_object({}) do |key, old|
+          old[key] = target_node.attrs[key] if target_node.attrs.key?(key)
+        end
+      end
+    end
+
+    # Set or remove document-level attributes
+    class DocAttrStep < Step
+      attr_reader :attrs
+
+      def initialize(attrs)
+        super()
+        @attrs = attrs
+      end
+
+      def apply(doc)
+        new_doc = set_doc_attrs(doc)
+        Result.ok(new_doc)
+      rescue StandardError => e
+        Result.fail(e.message)
+      end
+
+      def get_map
+        StepMap.new
+      end
+
+      def invert(doc)
+        old_attrs = get_old_doc_attrs(doc)
+        DocAttrStep.new(old_attrs)
+      end
+
+      def step_type
+        "setDocAttr"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["attrs"] = @attrs
+        json
+      end
+
+      def self.from_json(_schema, json)
+        new(json["attrs"])
+      end
+
+      private
+
+      def set_doc_attrs(doc)
+        new_attrs = doc.attrs.merge(@attrs).compact
+        doc.class.new(content: doc.content, attrs: new_attrs)
+      end
+
+      def get_old_doc_attrs(doc)
+        @attrs.keys.each_with_object({}) do |key, old|
+          old[key] = doc.attrs[key] if doc.attrs.key?(key)
+        end
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/insert_step.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "step"
+require_relative "step_map"
+require_relative "replace_step"
+require_relative "slice"
+
+module Prosereflect
+  module Transform
+    # Insert content at a position
+    class InsertStep < Step
+      attr_reader :pos, :content
+
+      def initialize(pos, content)
+        super()
+        @pos = pos
+        @content = content.is_a?(Fragment) ? content : Fragment.new(content)
+      end
+
+      def apply(doc)
+        return Result.fail("Invalid position") if @pos.negative? || @pos > doc.node_size
+
+        begin
+          slice = Slice.new(@content)
+          replace_step = ReplaceStep.new(@pos, @pos, slice)
+          replace_step.apply(doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def get_map
+        delta = @content.size
+        StepMap.new([[@pos, @pos, @pos, @pos + delta]])
+      end
+
+      def invert(_doc)
+        DeleteStep.new(@pos, @pos + @content.size)
+      end
+
+      def step_type
+        "insert"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["pos"] = @pos
+        json["content"] = @content.to_a.map(&:to_h)
+        json
+      end
+
+      def self.from_json(_schema, json)
+        content = (json["content"] || []).map { |h| Prosereflect::Node.from_h(h) }
+        new(json["pos"], Fragment.new(content))
+      end
+    end
+
+    # Delete content in a range
+    class DeleteStep < Step
+      attr_reader :from, :to
+
+      def initialize(from, to)
+        super()
+        @from = from
+        @to = to
+      end
+
+      def apply(doc)
+        return Result.fail("Invalid positions") if @from > @to
+        return Result.fail("from < 0") if @from.negative?
+        return Result.fail("to > doc size") if @to > doc.node_size
+
+        begin
+          replace_step = ReplaceStep.new(@from, @to, Slice.empty)
+          replace_step.apply(doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def get_map
+        StepMap.delete(@from, @to)
+      end
+
+      def invert(doc)
+        # Find what was deleted
+        deleted = content_between(doc, @from, @to)
+        InsertStep.new(@from, deleted)
+      end
+
+      def step_type
+        "delete"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["from"] = @from
+        json["to"] = @to
+        json
+      end
+
+      def self.from_json(_schema, json)
+        new(json["from"], json["to"])
+      end
+
+      private
+
+      def content_between(doc, from, to)
+        result = []
+        doc.nodes_between(from, to) { |node| result << node }
+        Fragment.new(result)
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/mapping.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "step_map"
+
+module Prosereflect
+  module Transform
+    # Tracks position changes through a series of steps.
+    # Maps positions forward through the transformation.
+    class Mapping
+      attr_reader :maps
+      attr_accessor :from, :to
+
+      def initialize(maps: [])
+        @maps = maps.dup
+        @from = 0
+        @to = maps.length
+      end
+
+      # Add a step map to this mapping
+      def add_map(step_map, index = nil)
+        if index
+          @maps.insert(index, step_map)
+        else
+          @maps << step_map
+        end
+        @to = @maps.length
+      end
+
+      # Map a position through all steps in this mapping
+      def map(pos, on_del: nil) # rubocop:disable Lint:UnusedMethodArgument
+        @maps.each do |step_map|
+          pos = step_map.map(pos)
+        end
+        pos
+      end
+
+      # Map a position with deletion tracking
+      def map_result(pos, on_del: nil)
+        deleted = false
+        @maps.each do |step_map|
+          result = step_map.map_result(pos, on_del: on_del)
+          deleted ||= result.deleted
+          pos = result.pos
+        end
+        { pos: pos, deleted: deleted }
+      end
+
+      # Map a position backwards through the mapping
+      def map_reverse(pos)
+        result = pos
+        (0...@maps.length).each do |i|
+          step_map = @maps[@maps.length - 1 - i]
+          result = step_map.map_reverse(result)
+        end
+        result
+      end
+
+      # Check if a position was deleted
+      def map_deletes(pos)
+        @maps.any? { |step_map| step_map.deleted?(pos) }
+      end
+
+      # Get the mapping as an array of step maps
+      def to_a
+        @maps.dup
+      end
+
+      # Create from a single step map
+      def self.from_step_map(step_map)
+        new(maps: [step_map])
+      end
+
+      def to_s
+        "<Mapping maps=#{@maps.length}>"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end