prosereflect 0.2.0 → 0.3.0

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

data/lib/prosereflect/transform/step.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "step_map"
+require_relative "mapping"
+
+module Prosereflect
+  module Transform
+    # Base class for all document transformations.
+    # A step represents an atomic document change.
+    class Step
+      # Apply this step to a document
+      # Returns a Result with the new document or an error
+      def apply(_doc)
+        raise NotImplementedError, "#{self.class} must implement #apply"
+      end
+
+      # Get the step map for position tracking
+      def get_map
+        raise NotImplementedError, "#{self.class} must implement #get_map"
+      end
+
+      # Merge this step with another if possible
+      # Returns a new step or nil if not mergeable
+      def merge(_other)
+        nil
+      end
+
+      # Return an inverted step that undoes this one
+      # Takes the document as input to compute the inverse
+      def invert(_doc)
+        raise NotImplementedError, "#{self.class} must implement #invert"
+      end
+
+      # Get a JSON representation
+      def to_json(*_args)
+        {
+          "stepType" => step_type,
+          "pos" => pos,
+          "to" => to,
+        }.compact
+      end
+
+      # Create a step from JSON
+      def self.from_json(_schema, _json)
+        raise NotImplementedError, "#{self.class} must implement #from_json"
+      end
+
+      # The type name of this step
+      def step_type
+        raise NotImplementedError, "#{self.class} must implement #step_type"
+      end
+
+      # Position where this step applies
+      def pos
+        0
+      end
+
+      # End position (for range steps)
+      def to
+        pos
+      end
+
+      # Result of applying a step
+      class Result
+        attr_reader :doc, :failed
+
+        def initialize(doc: nil, failed: nil)
+          @doc = doc
+          @failed = failed
+        end
+
+        # Check if the step was successfully applied
+        def ok?
+          !@failed && @doc
+        end
+
+        # Create a successful result
+        def self.ok(doc)
+          new(doc: doc)
+        end
+
+        # Create a failed result
+        def self.fail(reason)
+          new(failed: reason)
+        end
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/step_map.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module Transform
+    # Maps positions through a step.
+    # Represents how positions change when a step is applied.
+    class StepMap
+      attr_reader :ranges # Array of [old_start, old_end, new_start, new_end]
+
+      def initialize(ranges = [])
+        @ranges = ranges
+      end
+
+      # Map a position through this step map
+      # Returns the new position
+      def map(pos)
+        offset = 0
+        @ranges.each do |old_start, old_end, new_start, new_end|
+          if pos <= old_start
+            return pos + (new_start - old_start)
+          elsif pos < old_end
+            return new_start + (pos - old_start)
+          elsif pos >= old_end
+            offset += (new_end - old_end)
+          end
+        end
+        pos + offset
+      end
+
+      # Map a position, returning result with deletion information
+      def map_result(pos, on_del: nil) # rubocop:disable Lint:UnusedMethodArgument
+        new_pos = map(pos)
+        deleted = deleted?(pos)
+        Result.new(pos: new_pos, deleted: deleted, transformed: new_pos != pos)
+      end
+
+      # Check if a position was deleted by this step
+      def deleted?(pos)
+        @ranges.any? do |old_start, old_end, _new_start, _new_end|
+          pos >= old_start && pos < old_end
+        end
+      end
+
+      # Add another map to this one (composition)
+      def add_map(other)
+        return StepMap.new(other.ranges.dup) if @ranges.empty?
+        return StepMap.new(@ranges.dup) if other.ranges.empty?
+
+        StepMap.new(merge_ranges_arrays(@ranges.dup, other.ranges.dup))
+      end
+
+      def merge_ranges_arrays(ranges1, ranges2)
+        return ranges1 if ranges2.empty?
+        return ranges2 if ranges1.empty?
+
+        head1 = ranges1.first
+        head2 = ranges2.first
+        merged_head = compute_merged_head(head1, head2, ranges1, ranges2)
+        tail = compute_tail(head1, head2, ranges1, ranges2)
+        [merged_head] + tail
+      end
+
+      def compute_merged_head(head1, head2, _ranges1, _ranges2)
+        if head1[1] <= head2[0]
+          head1
+        elsif head2[1] <= head1[0]
+          head2
+        else
+          merge_ranges(head1, head2)
+        end
+      end
+
+      def compute_tail(head1, head2, ranges1, ranges2)
+        if head1[1] <= head2[0]
+          merge_ranges_arrays(ranges1[1..], ranges2)
+        elsif head2[1] <= head1[0]
+          merge_ranges_arrays(ranges1, ranges2[1..])
+        else
+          merge_ranges_arrays(ranges1[1..], ranges2[1..])
+        end
+      end
+
+      # Create an empty step map
+      def self.empty
+        new
+      end
+
+      # Create a step map for a single deletion
+      def self.delete(from, to)
+        new([[from, to, from, from]])
+      end
+
+      # Create a step map for a single replacement
+      def self.replace(from, to, target_from, target_to)
+        delta = target_to - target_from
+        new([[from, to, target_from, target_from + delta]])
+      end
+
+      def to_s
+        "<StepMap #{@ranges.inspect}>"
+      end
+
+      def inspect
+        to_s
+      end
+
+      # Result of mapping a position
+      Result = Struct.new(:pos, :deleted, :transformed, keyword_init: true) do
+        def initialize(pos: 0, deleted: false, transformed: false)
+          super
+        end
+      end
+
+      private
+
+      def merge_ranges(range1, range2)
+        [
+          [range1[0], range2[0]].min,
+          [range1[1], range2[1]].max,
+          [range1[2], range2[2]].min,
+          [range1[3], range2[3]].max,
+        ]
+      end
+    end
+  end
+end