prosereflect 0.1.1 → 0.3.0

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

data/lib/prosereflect/transform/structure.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "step"
+require_relative "replace_step"
+
+module Prosereflect
+  module Transform
+    # Structure predicates and helpers for document manipulation
+    class Structure
+      class << self
+        # Check if we can split at a position
+        # Returns true if the position allows a split (e.g., inside a text node)
+        def can_split?(doc, pos, types = nil)
+          return false if pos.negative? || pos > doc.node_size
+
+          resolved = doc.resolve(pos)
+          parent = resolved.parent
+
+          return false unless parent.respond_to?(:content)
+
+          node_type = parent.respond_to?(:type) ? parent.type : nil
+
+          if types
+            types.all? { |t| t.respond_to?(:name) ? t.name == node_type : t == node_type }
+          else
+            true
+          end
+        end
+
+        # Find the target depth for lifting content out of a wrapper
+        # Returns the depth to which content should be lifted
+        def lift_target(fragment, from, to)
+          depth = 0
+          pos = 0
+
+          fragment.content.each do |node|
+            node_end = pos + node.node_size
+            break if pos >= to
+
+            # This node is within the range being lifted
+            if pos < to && node_end > from && node.respond_to?(:defining?) && node.defining?
+              depth += 1
+            end
+
+            pos = node_end
+          end
+
+          depth
+        end
+
+        # Find wrapper nodes needed to wrap a range
+        # Returns array of node types that would wrap the range
+        def find_wrapping(fragment, _from, to, node_type, attrs = nil)
+          wrappers = []
+          current_depth = 0
+          pos = 0
+
+          fragment.content.each do |node|
+            node_end = pos + node.node_size
+            break if pos >= to
+
+            if node.respond_to?(:defining?) && node.defining? && current_depth.zero?
+              # Found a defining node at the boundary
+              wrappers << build_wrapper(node_type, attrs)
+            end
+
+            pos = node_end
+          end
+
+          wrappers
+        end
+
+        # Check if nodes can be joined at a position
+        def can_join?(doc, pos)
+          return false if pos <= 0 || pos >= doc.node_size
+
+          resolved = doc.resolve(pos)
+
+          # We need to be at a boundary between two children
+          # Check the node at the depth where we're at a child boundary
+          depth = resolved.depth
+          return false unless depth.positive?
+
+          parent = resolved.node(depth - 1)
+          return false unless parent.respond_to?(:content)
+          return false if parent.content.nil?
+
+          index = resolved.index(depth)
+          return false unless index.positive? && index < parent.content.size
+
+          prev_node = parent.content[index - 1]
+          next_node = parent.content[index]
+
+          prev_node.type == next_node.type
+        end
+
+        # Find positions where a join can happen
+        def join_point?(doc, pos)
+          return false unless can_join?(doc, pos)
+
+          pos
+        end
+
+        private
+
+        def build_wrapper(node_type, attrs)
+          if node_type.is_a?(String)
+            Prosereflect::Node.from_h(
+              "type" => node_type,
+              "attrs" => attrs || {},
+              "content" => [],
+            )
+          else
+            node_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prosereflect/transform/transform.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require_relative "step"
+require_relative "step_map"
+require_relative "mapping"
+require_relative "slice"
+require_relative "replace_step"
+require_relative "replace_around_step"
+require_relative "mark_step"
+require_relative "attr_step"
+require_relative "insert_step"
+
+module Prosereflect
+  module Transform
+    # A chainable document transformation.
+    # Accumulates steps and their mappings.
+    class Transform
+      attr_reader :steps, :mapping
+
+      def initialize(doc)
+        @doc = doc
+        @steps = []
+        @mapping = Mapping.new
+      end
+
+      # Add a mark to all content in range
+      def add_mark(from, to, mark)
+        add_step(AddMarkStep.new(from, to, mark))
+      end
+
+      # Remove a mark from all content in range
+      def remove_mark(from, to, mark)
+        add_step(RemoveMarkStep.new(from, to, mark))
+      end
+
+      # Insert content at position
+      def insert(pos, content)
+        add_step(InsertStep.new(pos, content))
+      end
+
+      # Delete content in range
+      def delete(from, to)
+        add_step(DeleteStep.new(from, to))
+      end
+
+      # Replace content in range with slice
+      def replace(from, to, slice = Slice.empty)
+        add_step(ReplaceStep.new(from, to, slice))
+      end
+
+      # Replace content with specific nodes
+      def replace_with(from, to, *nodes)
+        content = Fragment.new(nodes.flatten)
+        slice = Slice.new(content)
+        add_step(ReplaceStep.new(from, to, slice))
+      end
+
+      # Set attribute on node at position
+      def set_node_attribute(pos, attrs)
+        add_step(AttrStep.new(pos, attrs))
+      end
+
+      # Set document attribute
+      def set_doc_attribute(attrs)
+        add_step(DocAttrStep.new(attrs))
+      end
+
+      # Apply all accumulated steps to the document
+      # Returns self for chaining
+      def apply
+        @steps.each do |step|
+          result = step.apply(@doc)
+          raise ApplyError, "Step #{step.class} failed: #{result.failed}" unless result.ok?
+
+          @doc = result.doc
+        end
+        self
+      end
+
+      # Apply and return the transformed document
+      def doc
+        # Apply pending steps
+        apply if @steps.any?
+        @doc
+      end
+
+      # Check if any steps have been applied
+      def empty?
+        @steps.empty?
+      end
+
+      # Get the number of steps
+      def size
+        @steps.length
+      end
+
+      # Add a step and track its mapping
+      def add_step(step)
+        @steps << step
+        @mapping.add_map(step.get_map)
+        self
+      end
+
+      # Get the mapping for all applied steps
+      def maps
+        @mapping.to_a
+      end
+
+      # Create a new transform with the same document
+      def clone
+        Transform.new(@doc)
+      end
+
+      # Roll back the last step
+      def rollback
+        return self if @steps.empty?
+
+        step = @steps.pop
+        @mapping = Mapping.new(maps: @mapping.to_a[0...-1])
+
+        inverted = step.invert(@doc)
+        result = inverted.apply(@doc)
+        if result.ok?
+          @doc = result.doc
+        end
+
+        self
+      end
+
+      # Check if we can step forward
+      def can_apply?
+        @steps.all? { |step| step.apply(@doc).ok? }
+      end
+
+      # Add mark using schema
+      def add_mark_by_type(from, to, mark_type_name, schema, attrs = nil)
+        mark_type = schema.mark_type(mark_type_name)
+        mark = mark_type.create(attrs)
+        add_mark(from, to, mark)
+      end
+
+      # Remove mark using schema
+      def remove_mark_by_type(from, to, mark_type_name, schema)
+        mark_type = schema.mark_type(mark_type_name)
+        mark = mark_type.create
+        remove_mark(from, to, mark)
+      end
+
+      # Lift content out of a wrapper node
+      # range: NodeRange representing the content to lift
+      # target: depth to lift to
+      def lift(range, target)
+        from_ = range.from
+        to_ = range.to
+        depth = range.depth
+
+        gap_start = position_before_depth(from_, depth + 1)
+        gap_end = position_after_depth(to_, depth + 1)
+        start = gap_start
+        end_pos = gap_end
+
+        before = Fragment.empty
+        open_start = 0
+        d = depth
+        splitting = false
+        while d > target
+          if splitting || node_index_at_depth(from_, d).positive?
+            splitting = true
+            before = Fragment.from(node_at_depth(from_, d).copy(before))
+            open_start += 1
+          else
+            start -= 1
+          end
+          d -= 1
+        end
+
+        after = Fragment.empty
+        open_end = 0
+        d = depth
+        splitting = false
+        while d > target
+          if splitting || position_after_depth(to_, d + 1) < node_end_at_depth(to_, d)
+            splitting = true
+            after = Fragment.from(node_at_depth(to_, d).copy(after))
+            open_end += 1
+          else
+            end_pos += 1
+          end
+          d -= 1
+        end
+
+        replace_around_step(
+          start,
+          end_pos,
+          gap_start,
+          gap_end,
+          Slice.new(before.append(after), open_start, open_end),
+          before.size - open_start,
+          true,
+        )
+        self
+      end
+
+      # Wrap content in nodes
+      # range: NodeRange representing the content to wrap
+      # wrappers: array of NodeTypeWithAttrs representing wrapper nodes
+      def wrap(range, wrappers)
+        content = Fragment.empty
+        i = wrappers.length - 1
+        while i >= 0
+          if content.size.positive?
+            match = wrappers[i].type.content_match.match_fragment(content)
+            unless match&.valid_end
+              raise TransformError, "Wrapper type given to Transform.wrap does not form valid content of its parent wrapper"
+            end
+          end
+          content = Fragment.from(
+            wrappers[i].type.create(wrappers[i].attrs, content),
+          )
+          i -= 1
+        end
+
+        start = range.start
+        end_pos = range.end
+        replace_around_step(
+          start,
+          end_pos,
+          start,
+          end_pos,
+          Slice.new(content, 0, 0),
+          wrappers.length,
+          true,
+        )
+        self
+      end
+
+      # Split a node at a position
+      def split(pos, depth = 1)
+        resolved = @doc.resolve(pos)
+        before = Fragment.empty
+        open_start = 0
+        open_end = 0
+
+        d = depth
+        while d.positive?
+          node = resolved.node(d)
+          if d == depth
+            before = Fragment.from(node.copy(Fragment.empty))
+            open_start = node.is_a?(Prosereflect::Node) && node.content&.size.to_i.positive? ? 1 : 0
+            open_end = 0
+          else
+            before = Fragment.from(node.copy(before))
+            open_start += 1
+          end
+          d -= 1
+        end
+
+        step = ReplaceAroundStep.new(
+          pos,
+          pos,
+          pos,
+          pos,
+          Slice.new(before, open_start, open_end),
+          open_start,
+          structure: false,
+        )
+        add_step(step)
+        self
+      end
+
+      # Join two nodes at a position
+      def join(pos, depth = 1)
+        resolved = @doc.resolve(pos)
+        d = depth
+        while d.positive?
+          # Check if we can join at this depth
+          parent = resolved.node(d - 1) if d >= 1
+          idx = resolved.index(d)
+
+          if parent&.content && idx.positive? && idx < parent.content.size
+            before_node = parent.content[idx - 1]
+            after_node = parent.content[idx]
+
+            if before_node.type == after_node.type
+              # Join point is at the boundary between before_node and after_node
+              join_from = resolved.start(d) - before_node.node_size
+              join_to = resolved.start(d) + after_node.node_size
+              replace(join_from, join_to, Slice.empty)
+            end
+          end
+          d -= 1
+        end
+        self
+      end
+
+      class ApplyError < StandardError; end
+      class TransformError < StandardError; end
+
+      def to_s
+        "<Transform steps=#{@steps.length}>"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def replace_around_step(from, to, gap_from, gap_to, slice, insert, structure)
+        add_step(ReplaceAroundStep.new(from, to, gap_from, gap_to, slice, insert, structure: structure))
+      end
+
+      def position_before_depth(pos, depth)
+        resolved = @doc.resolve(pos)
+        node = resolved.node(depth)
+        pos - (node.is_a?(Prosereflect::Node) ? 1 : 0)
+      end
+
+      def position_after_depth(pos, depth)
+        resolved = @doc.resolve(pos)
+        node = resolved.node(depth)
+        pos + (node.is_a?(Prosereflect::Node) ? 1 : 0)
+      end
+
+      def node_index_at_depth(pos, depth)
+        resolved = @doc.resolve(pos)
+        resolved.index(depth)
+      end
+
+      def node_at_depth(pos, depth)
+        resolved = @doc.resolve(pos)
+        resolved.node(depth)
+      end
+
+      def node_end_at_depth(pos, depth)
+        resolved = @doc.resolve(pos)
+        resolved.end(depth)
+      end
+    end
+  end
+end

data/lib/prosereflect/transform.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "transform/step_map"
+require_relative "transform/mapping"
+require_relative "transform/slice"
+require_relative "transform/step"
+require_relative "transform/replace_step"
+require_relative "transform/mark_step"
+require_relative "transform/attr_step"
+require_relative "transform/insert_step"
+require_relative "transform/structure"
+require_relative "transform/transform"
+
+module Prosereflect
+  # Transform system for chainable document transformations
+  # Based on ProseMirror's transform/step system
+  module Transform
+    class Error < StandardError; end
+
+    # Raised when a step cannot be applied to a document
+    class ApplyError < Error; end
+
+    # Raised when a step cannot be inverted
+    class InvertError < Error; end
+  end
+end