prosereflect 0.1.1 → 0.3.0

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

data/lib/prosereflect/transform/replace_around_step.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "step"
+
+module Prosereflect
+  module Transform
+    # Replaces a range of the document with a slice of content,
+    # but also replaces the content before and after the gap.
+    # Used by lift and wrap operations.
+    class ReplaceAroundStep < Step
+      attr_reader :from, :to, :gap_from, :gap_to, :slice, :insert, :structure
+
+      def initialize(from, to, gap_from, gap_to, slice, insert, structure: false)
+        super()
+        @from = from
+        @to = to
+        @gap_from = gap_from
+        @gap_to = gap_to
+        @slice = slice
+        @insert = insert
+        @structure = structure
+      end
+
+      def apply(doc)
+        # Check structure constraint
+        if @structure && (content_between(doc, @from, @gap_from) || content_between(doc, @gap_to, @to))
+          return Result.fail("Structure gap-replace would overwrite content")
+        end
+
+        # Get the gap content
+        gap = doc.slice(@gap_from, @gap_to)
+        if gap.open_start || gap.open_end
+          return Result.fail("Gap is not a flat range")
+        end
+
+        # Try to insert slice into gap
+        inserted = @slice.insert_at(@insert, gap.content)
+        unless inserted
+          return Result.fail("Content does not fit in gap")
+        end
+
+        # Apply the replacement
+        new_doc = apply_replace_around(doc, inserted)
+        Result.ok(new_doc)
+      rescue StandardError => e
+        Result.fail(e.message)
+      end
+
+      def get_map
+        StepMap.new([
+                      @from,
+                      @gap_from - @from,
+                      @insert,
+                      @gap_to,
+                      @to - @gap_to,
+                      @slice.size - @insert,
+                    ])
+      end
+
+      def invert(doc)
+        gap = @gap_to - @gap_from
+        removed = doc.slice(@from, @to).remove_between(
+          @gap_from - @from,
+          @gap_to - @from,
+        )
+        ReplaceAroundStep.new(
+          @from,
+          @from + @slice.size + gap,
+          @from + @insert,
+          @from + @insert + gap,
+          removed,
+          @gap_from - @from,
+          @structure,
+        )
+      end
+
+      def map(mapping)
+        from_mapped = mapping.map_result(@from, 1)
+        to_mapped = mapping.map_result(@to, -1)
+
+        gap_from_mapped = if @from == @gap_from
+                            from_mapped.pos
+                          else
+                            mapping.map(@gap_from, -1)
+                          end
+
+        gap_to_mapped = if @to == @gap_to
+                          to_mapped.pos
+                        else
+                          mapping.map(@gap_to, 1)
+                        end
+
+        if (from_mapped.deleted && to_mapped.deleted) || gap_from_mapped < from_mapped.pos || gap_to_mapped > to_mapped.pos
+          return nil
+        end
+
+        ReplaceAroundStep.new(
+          from_mapped.pos,
+          to_mapped.pos,
+          gap_from_mapped,
+          gap_to_mapped,
+          @slice,
+          @insert,
+          @structure,
+        )
+      end
+
+      def step_type
+        "replaceAround"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["from"] = @from
+        json["to"] = @to
+        json["gapFrom"] = @gap_from
+        json["gapTo"] = @gap_to
+        json["slice"] = @slice.content.to_a.map(&:to_h)
+        json["insert"] = @insert
+        json["structure"] = @structure
+        json
+      end
+
+      def self.from_json(_schema, json)
+        from_val = json["from"]
+        to_val = json["to"]
+        gap_from_val = json["gapFrom"]
+        gap_to_val = json["gapTo"]
+        insert_val = json["insert"]
+        structure_val = json["structure"] || false
+
+        slice_json = json["slice"] || []
+        slice_content = slice_json.map { |h| Prosereflect::Node.from_h(h) }
+        slice = Slice.new(Fragment.new(slice_content))
+
+        new(from_val, to_val, gap_from_val, gap_to_val, slice, insert_val, structure: structure_val)
+      end
+
+      private
+
+      def content_between(doc, from, to)
+        return nil if from >= to
+
+        result = []
+        doc.nodes_between(from, to) { |node| result << node }
+        result.empty? ? nil : Fragment.new(result)
+      end
+
+      def apply_replace_around(doc, inserted)
+        # Get content before and after the replaced range
+        before = content_before(doc, @from)
+        after = content_after(doc, @to)
+
+        # Build new document
+        new_content = []
+        new_content.concat(before) unless before.empty?
+        new_content.concat(inserted.content.to_a) unless inserted.empty?
+        new_content.concat(after) unless after.empty?
+
+        rebuild_doc(doc, new_content)
+      end
+
+      def content_before(doc, pos)
+        result = []
+        doc.nodes_between(0, pos) { |node| result << node }
+        result
+      end
+
+      def content_after(doc, pos)
+        result = []
+        doc.nodes_between(pos, doc.node_size) { |node| result << node }
+        result
+      end
+
+      def rebuild_doc(doc, new_content)
+        attrs = doc.attrs.dup
+        doc.class.new(content: Fragment.new(new_content), attrs: attrs)
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/replace_step.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "step"
+
+module Prosereflect
+  module Transform
+    # Replaces a range of the document with a slice of content.
+    class ReplaceStep < Step
+      attr_reader :from, :to, :slice
+
+      def initialize(from, to, slice = Slice.empty)
+        super()
+        @from = from
+        @to = to
+        @slice = slice
+      end
+
+      def apply(doc)
+        # Validate positions
+        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
+
+        # Build the new document
+        new_doc = apply_replace(doc)
+        Result.ok(new_doc)
+      rescue StandardError => e
+        Result.fail(e.message)
+      end
+
+      def get_map
+        delta = @slice.size - (@to - @from)
+        StepMap.new([[@from, @to, @from, @from + delta]])
+      end
+
+      def invert(doc)
+        # Find what was removed
+        removed = content_between(doc, @from, @to)
+        ReplaceStep.new(@from, @from + @slice.size, removed)
+      end
+
+      def merge(other)
+        return nil unless other.is_a?(ReplaceStep)
+
+        return extend_deletion(other) if can_extend_deletion?(other)
+        return prepend_deletion(other) if can_prepend_deletion?(other)
+        return append_content(other) if can_append_content?(other)
+        return prepend_content(other) if can_prepend_content?(other)
+
+        nil
+      end
+
+      def can_extend_deletion?(other)
+        @to == other.from && @slice.empty?
+      end
+
+      def extend_deletion(other)
+        ReplaceStep.new(@from, other.to, Slice.empty)
+      end
+
+      def can_prepend_deletion?(other)
+        other.to == @from && other.slice.empty?
+      end
+
+      def prepend_deletion(other)
+        ReplaceStep.new(other.from, @to, Slice.empty)
+      end
+
+      def can_append_content?(other)
+        @to == other.from && !other.slice.empty?
+      end
+
+      def append_content(other)
+        new_content = join_slices(@slice, other.slice)
+        ReplaceStep.new(@from, other.to, new_content)
+      end
+
+      def can_prepend_content?(other)
+        other.to == @from && !other.slice.empty?
+      end
+
+      def prepend_content(other)
+        new_content = join_slices(other.slice, @slice)
+        ReplaceStep.new(other.from, @to, new_content)
+      end
+
+      def step_type
+        "replace"
+      end
+
+      def to_json(*_args)
+        json = super
+        json["from"] = @from
+        json["to"] = @to
+        json["slice"] = @slice.content.map(&:to_h)
+        json
+      end
+
+      def self.from_json(_schema, json)
+        from_val = json["from"]
+        to_val = json["to"]
+        slice_json = json["slice"] || []
+        slice_content = slice_json.map { |h| Prosereflect::Node.from_h(h) }
+        slice = Slice.new(Fragment.new(slice_content))
+        new(from_val, to_val, slice)
+      end
+
+      private
+
+      def apply_replace(doc)
+        # Get content before, during, and after the replaced range
+        before = content_before(doc, @from)
+        after = content_after(doc, @to)
+
+        # Build new document
+        new_content = []
+        new_content.concat(before) unless before.empty?
+        new_content.concat(@slice.content.to_a) unless @slice.empty?
+        new_content.concat(after) unless after.empty?
+
+        rebuild_doc(doc, new_content)
+      end
+
+      def content_before(doc, pos)
+        result = []
+        doc.nodes_between(0, pos) { |node| result << node }
+        result
+      end
+
+      def content_after(doc, pos)
+        result = []
+        doc.nodes_between(pos, doc.node_size) { |node| result << node }
+        result
+      end
+
+      def content_between(doc, from, to)
+        result = []
+        doc.nodes_between(from, to) { |node| result << node }
+        Fragment.new(result)
+      end
+
+      def join_slices(left, right)
+        new_content = Fragment.new(left.content.to_a + right.content.to_a)
+        Slice.new(new_content, left.open_start, right.open_end)
+      end
+
+      def rebuild_doc(doc, new_content)
+        # Create a new document with the same structure but new content
+        attrs = doc.attrs.dup
+        Fragment.new(new_content)
+        # For simplicity, return a new Document with the new content
+        # In reality this would preserve the doc type
+        doc.class.new(content: Fragment.new(new_content), attrs: attrs)
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/slice.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module Transform
+    # Represents a slice of a document - a contiguous portion that can be
+    # inserted, deleted, or moved. Tracks open boundaries for proper joining.
+    class Slice
+      attr_reader :content, :open_start, :open_end
+
+      def initialize(content, open_start = 0, open_end = 0)
+        @content = content
+        @open_start = open_start
+        @open_end = open_end
+      end
+
+      # Check if this slice is empty (no content and no open boundaries)
+      def empty?
+        @content.empty? && @open_start.zero? && @open_end.zero?
+      end
+
+      # Total size of the slice including open boundaries
+      def size
+        content_size + @open_start + @open_end
+      end
+
+      # Size of just the content
+      def content_size
+        size = 0
+        @content.each { |node| size += node.node_size }
+        size
+      end
+
+      # Cut the slice at given boundaries
+      def cut(from = 0, to = nil)
+        to ||= size
+
+        if from.zero? && to == size
+          return self
+        end
+
+        result = cut_internal(from, to)
+        Slice.new(result[:content], result[:open_start], result[:open_end])
+      end
+
+      # Check equality
+      def eq?(other)
+        return false unless other.is_a?(Slice)
+
+        @open_start == other.open_start &&
+          @open_end == other.open_end &&
+          @content.to_a.map(&:to_h) == other.content.to_a.map(&:to_h)
+      end
+
+      alias == eq?
+
+      def to_s
+        "<Slice open_start=#{@open_start} open_end=#{@open_end} content=#{@content.length} items>"
+      end
+
+      def inspect
+        to_s
+      end
+
+      # Create an empty slice
+      def self.empty
+        new(Fragment.new([]), 0, 0)
+      end
+
+      private
+
+      def cut_internal(from, to)
+        return { content: @content, open_start: @open_start, open_end: @open_end } if from >= to
+
+        # Simplified cut - just adjusts open flags
+        new_open_start = @open_start
+        new_open_end = @open_end
+        new_content = @content
+
+        if from.positive?
+          new_open_start = [new_open_start - from, 0].max
+        end
+
+        if to < size
+          new_open_end = [new_open_end - (size - to), 0].max
+        end
+
+        { content: new_content, open_start: new_open_start, open_end: new_open_end }
+      end
+    end
+  end
+end