prosereflect 0.2.0 → 0.3.0

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

data/lib/prosereflect/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosereflect
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/prosereflect.rb

@@ -11,6 +11,7 @@ module Prosereflect
   autoload :CodeBlock, "prosereflect/code_block"
   autoload :CodeBlockWrapper, "prosereflect/code_block_wrapper"
   autoload :Document, "prosereflect/document"
+  autoload :Fragment, "prosereflect/fragment"
   autoload :HardBreak, "prosereflect/hard_break"
   autoload :Heading, "prosereflect/heading"
   autoload :HorizontalRule, "prosereflect/horizontal_rule"
@@ -23,11 +24,13 @@ module Prosereflect
   autoload :Output, "prosereflect/output"
   autoload :Paragraph, "prosereflect/paragraph"
   autoload :Parser, "prosereflect/parser"
+  autoload :ResolvedPos, "prosereflect/resolved_pos"
   autoload :Table, "prosereflect/table"
   autoload :TableCell, "prosereflect/table_cell"
   autoload :TableHeader, "prosereflect/table_header"
   autoload :TableRow, "prosereflect/table_row"
   autoload :Text, "prosereflect/text"
+  autoload :Transform, "prosereflect/transform"
   autoload :User, "prosereflect/user"
   autoload :VERSION, "prosereflect/version"
 end

data/spec/fixtures/documents/formatted_text.yaml

@@ -0,0 +1,14 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: Hello
+        marks:
+          - type: bold
+      - type: text
+        text: " World"
+      - type: text
+        text: "!"
+        marks:
+          - type: italic

data/spec/fixtures/documents/heading_paragraph.yaml

@@ -0,0 +1,16 @@
+type: doc
+content:
+  - type: heading
+    attrs:
+      level: 1
+    content:
+      - type: text
+        text: Title
+  - type: paragraph
+    content:
+      - type: text
+        text: First paragraph
+  - type: paragraph
+    content:
+      - type: text
+        text: Second paragraph

data/spec/fixtures/documents/lists_doc.yaml

@@ -0,0 +1,32 @@
+type: doc
+content:
+  - type: bullet_list
+    content:
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Bullet 1
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Bullet 2
+  - type: ordered_list
+    attrs:
+      order: 1
+    content:
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Item 1
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Item 2

data/spec/fixtures/documents/mixed_content.yaml

@@ -0,0 +1,40 @@
+type: doc
+content:
+  - type: heading
+    attrs:
+      level: 2
+    content:
+      - type: text
+        text: Mixed Content
+  - type: paragraph
+    content:
+      - type: text
+        text: Normal text
+      - type: text
+        text: " bold"
+        marks:
+          - type: bold
+      - type: text
+        text: " and "
+      - type: text
+        text: italic
+        marks:
+          - type: italic
+      - type: text
+        text: " with a "
+      - type: text
+        text: link
+        marks:
+          - type: link
+            attrs:
+              href: https://example.com
+  - type: code_block
+    attrs:
+      language: ruby
+    content:
+      - type: text
+        text: puts 'hello'
+  - type: image
+    attrs:
+      src: https://example.com/image.png
+      alt: Example image

data/spec/fixtures/documents/nested_doc.yaml

@@ -0,0 +1,20 @@
+type: doc
+content:
+  - type: blockquote
+    content:
+      - type: paragraph
+        content:
+          - type: text
+            text: Quoted text
+      - type: paragraph
+        content:
+          - type: text
+            text: More quoted text
+  - type: horizontal_rule
+  - type: paragraph
+    content:
+      - type: text
+        text: "Line 1"
+      - type: hard_break
+      - type: text
+        text: "Line 2"

data/spec/fixtures/documents/simple_doc.yaml

@@ -0,0 +1,6 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: Hello World

data/spec/fixtures/documents/table_doc.yaml

@@ -0,0 +1,32 @@
+type: doc
+content:
+  - type: table
+    content:
+      - type: table_row
+        content:
+          - type: table_header
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Header 1
+          - type: table_header
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Header 2
+      - type: table_row
+        content:
+          - type: table_cell
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Cell 1
+          - type: table_cell
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Cell 2

data/spec/fixtures/documents/transform_test.yaml

@@ -0,0 +1,14 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: abcdef
+  - type: paragraph
+    content:
+      - type: text
+        text: ghijkl
+  - type: paragraph
+    content:
+      - type: text
+        text: mnopqr