prosereflect 0.2.0 → 0.3.0

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

data/lib/prosereflect/transform/mark_step.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require_relative "step"
+require_relative "step_map"
+
+module Prosereflect
+  module Transform
+    # Base class for mark-related steps
+    class MarkStep < Step
+      attr_reader :from, :to, :mark
+
+      def initialize(from, to, mark)
+        super()
+        @from = from
+        @to = to
+        @mark = mark
+      end
+
+      def get_map
+        StepMap.new
+      end
+    end
+
+    # Add a mark to all content in a range
+    class AddMarkStep < MarkStep
+      def apply(doc)
+        return Result.fail("Invalid positions") if @from > @to || @from.negative?
+
+        begin
+          new_doc = add_mark_to_range(doc)
+          Result.ok(new_doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def invert(_doc)
+        RemoveMarkStep.new(@from, @to, @mark)
+      end
+
+      def merge(other)
+        return nil unless other.is_a?(AddMarkStep)
+        return nil unless other.mark == @mark
+
+        if @to == other.from
+          AddMarkStep.new(@from, other.to, @mark)
+        elsif @from == other.to
+          AddMarkStep.new(other.from, @to, @mark)
+        end
+      end
+
+      def step_type
+        "addMark"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["mark"] = @mark.to_h
+        json
+      end
+
+      def self.from_json(_schema, json)
+        mark = Prosereflect::Mark.from_h(json["mark"])
+        new(json["from"], json["to"], mark)
+      end
+
+      private
+
+      def add_mark_to_range(doc)
+        new_content = doc.content.map { |node| apply_mark_to_node(node) }
+        doc.class.new(content: Fragment.new(new_content), attrs: doc.attrs.dup)
+      end
+
+      def apply_mark_to_node(node)
+        return node unless node.is_a?(Prosereflect::Text)
+
+        Prosereflect::Text.new(
+          text: node.text,
+          marks: (node.marks || []) + [@mark],
+          attrs: node.attrs.dup,
+        )
+      end
+
+      def remove_mark_from_range(doc)
+        new_content = doc.content.map { |node| remove_mark_from_node_single(node) }
+        doc.class.new(content: Fragment.new(new_content), attrs: doc.attrs.dup)
+      end
+
+      def remove_mark_from_node_single(node)
+        return node unless node.is_a?(Prosereflect::Text)
+
+        new_marks = (node.marks || []).reject { |m| m.type == @mark.type }
+        Prosereflect::Text.new(
+          text: node.text,
+          marks: new_marks,
+          attrs: node.attrs.dup,
+        )
+      end
+    end
+
+    # Remove a mark from all content in a range
+    class RemoveMarkStep < MarkStep
+      def apply(doc)
+        return Result.fail("Invalid positions") if @from > @to || @from.negative?
+
+        begin
+          new_doc = remove_mark_from_range(doc)
+          Result.ok(new_doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def invert(_doc)
+        AddMarkStep.new(@from, @to, @mark)
+      end
+
+      def merge(other)
+        return nil unless other.is_a?(RemoveMarkStep)
+        return nil unless other.mark == @mark
+
+        if @to == other.from
+          RemoveMarkStep.new(@from, other.to, @mark)
+        elsif @from == other.to
+          RemoveMarkStep.new(other.from, @to, @mark)
+        end
+      end
+
+      def step_type
+        "removeMark"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["mark"] = @mark.to_h
+        json
+      end
+
+      def self.from_json(_schema, json)
+        mark = Prosereflect::Mark.from_h(json["mark"])
+        new(json["from"], json["to"], mark)
+      end
+    end
+
+    # Add mark to a specific node (not range-based)
+    class AddNodeMarkStep < Step
+      attr_reader :pos, :mark
+
+      def initialize(pos, mark)
+        super()
+        @pos = pos
+        @mark = mark
+      end
+
+      def apply(doc)
+        return Result.fail("Invalid position") if @pos.negative? || @pos > doc.node_size
+
+        begin
+          new_doc = add_mark_to_node(doc)
+          Result.ok(new_doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def get_map
+        StepMap.new
+      end
+
+      def invert(_doc)
+        RemoveNodeMarkStep.new(@pos, @mark)
+      end
+
+      def step_type
+        "addNodeMark"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["pos"] = @pos
+        json["mark"] = @mark.to_h
+        json
+      end
+
+      def self.from_json(_schema, json)
+        mark = Prosereflect::Mark.from_h(json["mark"])
+        new(json["pos"], mark)
+      end
+
+      private
+
+      def add_mark_to_node(doc)
+        new_content = doc.content.map { |node| add_mark_to_single_node(node) }
+        doc.class.new(content: Fragment.new(new_content), attrs: doc.attrs.dup)
+      end
+
+      def add_mark_to_single_node(node)
+        new_marks = (node.marks || []) + [@mark]
+        node.class.new(
+          content: node.content,
+          marks: new_marks,
+          attrs: node.attrs.dup,
+        )
+      end
+    end
+
+    # Remove mark from a specific node
+    class RemoveNodeMarkStep < Step
+      attr_reader :pos, :mark
+
+      def initialize(pos, mark)
+        super()
+        @pos = pos
+        @mark = mark
+      end
+
+      def apply(doc)
+        return Result.fail("Invalid position") if @pos.negative? || @pos > doc.node_size
+
+        begin
+          new_doc = remove_mark_from_node(doc)
+          Result.ok(new_doc)
+        rescue StandardError => e
+          Result.fail(e.message)
+        end
+      end
+
+      def get_map
+        StepMap.new
+      end
+
+      def invert(_doc)
+        AddNodeMarkStep.new(@pos, @mark)
+      end
+
+      def step_type
+        "removeNodeMark"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["pos"] = @pos
+        json["mark"] = @mark.to_h
+        json
+      end
+
+      def self.from_json(_schema, json)
+        mark = Prosereflect::Mark.from_h(json["mark"])
+        new(json["pos"], mark)
+      end
+
+      private
+
+      def remove_mark_from_node(doc)
+        new_content = doc.content.map { |node| remove_mark_from_single_node(node) }
+        doc.class.new(content: Fragment.new(new_content), attrs: doc.attrs.dup)
+      end
+
+      def remove_mark_from_single_node(node)
+        new_marks = (node.marks || []).reject { |m| m.type == @mark.type }
+        node.class.new(
+          content: node.content,
+          marks: new_marks,
+          attrs: node.attrs.dup,
+        )
+      end
+    end
+  end
+end