docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/parser-3.3.7.2/lib/parser/source/tree_rewriter/action.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+    ##
+    # @api private
+    #
+    # Actions are arranged in a tree and get combined so that:
+    # 
+    # * Children are strictly contained by their parent
+    # * Siblings are all disjointed from one another and ordered
+    # * Only actions with `replacement == nil` may have children
+    #
+    class TreeRewriter::Action
+      attr_reader :range, :replacement, :insert_before, :insert_after
+
+      def initialize(range, enforcer,
+           insert_before: '',
+           replacement: nil,
+           insert_after: '',
+           children: []
+        )
+        @range, @enforcer, @children, @insert_before, @replacement, @insert_after =
+          range, enforcer, children.freeze, insert_before.freeze, replacement, insert_after.freeze
+
+        freeze
+      end
+
+      def combine(action)
+        return self if action.empty? # Ignore empty action
+        do_combine(action)
+      end
+
+      def empty?
+        @insert_before.empty? &&
+          @insert_after.empty? &&
+          @children.empty? &&
+          (@replacement == nil || (@replacement.empty? && @range.empty?))
+      end
+
+      def ordered_replacements
+        reps = []
+        reps << [@range.begin, @insert_before] unless @insert_before.empty?
+        reps << [@range, @replacement] if @replacement
+        reps.concat(@children.flat_map(&:ordered_replacements))
+        reps << [@range.end, @insert_after] unless @insert_after.empty?
+        reps
+      end
+
+      def nested_actions
+        actions = []
+        actions << [:wrap, @range, @insert_before, @insert_after] if !@insert_before.empty? ||
+                                                                     !@insert_after.empty?
+        actions << [:replace, @range, @replacement] if @replacement
+        actions.concat(@children.flat_map(&:nested_actions))
+      end
+
+      def insertion?
+        !insert_before.empty? || !insert_after.empty? || (replacement && !replacement.empty?)
+      end
+
+      ##
+      # A root action has its range set to the whole source range, even
+      # though it typically does not act on that range.
+      # This method returns the action as if it was a child action with
+      # its range contracted.
+      # @return [Action]
+      def contract
+        raise 'Empty actions can not be contracted' if empty?
+        return self if insertion?
+        range = @range.with(
+          begin_pos: children.first.range.begin_pos,
+          end_pos: children.last.range.end_pos,
+        )
+        with(range: range)
+      end
+
+      ##
+      # @return [Action] that has been moved to the given source_buffer and with the given offset
+      # No check is done on validity of resulting range.
+      def moved(source_buffer, offset)
+        moved_range = ::Parser::Source::Range.new(
+          source_buffer,
+          @range.begin_pos + offset,
+          @range.end_pos + offset
+        )
+        with(
+          range: moved_range,
+          children: children.map { |child| child.moved(source_buffer, offset) }
+        )
+      end
+
+      protected
+
+      attr_reader :children
+
+      def with(range: @range, enforcer: @enforcer, children: @children, insert_before: @insert_before, replacement: @replacement, insert_after: @insert_after)
+        children = swallow(children) if replacement
+        self.class.new(range, enforcer, children: children, insert_before: insert_before, replacement: replacement, insert_after: insert_after)
+      end
+
+      # Assumes range.contains?(action.range) && action.children.empty?
+      def do_combine(action)
+        if action.range == @range
+          merge(action)
+        else
+          place_in_hierarchy(action)
+        end
+      end
+
+      def place_in_hierarchy(action)
+        family = analyse_hierarchy(action)
+
+        if family[:fusible]
+          fuse_deletions(action, family[:fusible], [*family[:sibbling_left], *family[:child], *family[:sibbling_right]])
+        else
+          extra_sibbling = if family[:parent]  # action should be a descendant of one of the children
+            family[:parent].do_combine(action)
+          elsif family[:child]                 # or it should become the parent of some of the children,
+            action.with(children: family[:child], enforcer: @enforcer)
+              .combine_children(action.children)
+          else                                 # or else it should become an additional child
+            action
+          end
+          with(children: [*family[:sibbling_left], extra_sibbling, *family[:sibbling_right]])
+        end
+      end
+
+      # Assumes `more_children` all contained within `@range`
+      def combine_children(more_children)
+        more_children.inject(self) do |parent, new_child|
+          parent.place_in_hierarchy(new_child)
+        end
+      end
+
+      def fuse_deletions(action, fusible, other_sibblings)
+        without_fusible = with(children: other_sibblings)
+        fused_range = [action, *fusible].map(&:range).inject(:join)
+        fused_deletion = action.with(range: fused_range)
+        without_fusible.do_combine(fused_deletion)
+      end
+
+      # Similar to @children.bsearch_index || size
+      # except allows for a starting point
+      # and `bsearch_index` is only Ruby 2.3+
+      def bsearch_child_index(from = 0)
+        size = @children.size
+        (from...size).bsearch { |i| yield @children[i] } || size
+      end
+
+      # Returns the children in a hierarchy with respect to `action`:
+      #   :sibbling_left, sibbling_right (for those that are disjoint from `action`)
+      #   :parent (in case one of our children contains `action`)
+      #   :child (in case `action` strictly contains some of our children)
+      #   :fusible (in case `action` overlaps some children but they can be fused in one deletion)
+      #   or raises a `CloberingError`
+      # In case a child has equal range to `action`, it is returned as `:parent`
+      # Reminder: an empty range 1...1 is considered disjoint from 1...10
+      def analyse_hierarchy(action)
+        r = action.range
+        # left_index is the index of the first child that isn't completely to the left of action
+        left_index = bsearch_child_index { |child| child.range.end_pos > r.begin_pos }
+        # right_index is the index of the first child that is completely on the right of action
+        start = left_index == 0 ? 0 : left_index - 1  # See "corner case" below for reason of -1
+        right_index = bsearch_child_index(start) { |child| child.range.begin_pos >= r.end_pos }
+        center = right_index - left_index
+        case center
+        when 0
+          # All children are disjoint from action, nothing else to do
+        when -1
+          # Corner case: if a child has empty range == action's range
+          # then it will appear to be both disjoint and to the left of action,
+          # as well as disjoint and to the right of action.
+          # Since ranges are equal, we return it as parent
+          left_index -= 1  # Fix indices, as otherwise this child would be
+          right_index += 1 # considered as a sibbling (both left and right!)
+          parent = @children[left_index]
+        else
+          overlap_left = @children[left_index].range.begin_pos <=> r.begin_pos
+          overlap_right = @children[right_index-1].range.end_pos <=> r.end_pos
+
+          # For one child to be the parent of action, we must have:
+          if center == 1 && overlap_left <= 0 && overlap_right >= 0
+            parent = @children[left_index]
+          else
+            # Otherwise consider all non disjoint elements (center) to be contained...
+            contained = @children[left_index...right_index]
+            fusible = check_fusible(action,
+              (contained.shift if overlap_left < 0),  # ... but check first and last one
+              (contained.pop if overlap_right > 0)    # ... for overlaps
+            )
+          end
+        end
+
+        {
+          parent: parent,
+          sibbling_left: @children[0...left_index],
+          sibbling_right: @children[right_index...@children.size],
+          fusible: fusible,
+          child: contained,
+        }
+      end
+
+      # @param [Array(Action | nil)] fusible
+      def check_fusible(action, *fusible)
+        fusible.compact!
+        return if fusible.empty?
+        fusible.each do |child|
+          kind = action.insertion? || child.insertion? ? :crossing_insertions : :crossing_deletions
+          @enforcer.call(kind) { {range: action.range, conflict: child.range} }
+        end
+        fusible
+      end
+
+      # Assumes action.range == range && action.children.empty?
+      def merge(action)
+        call_enforcer_for_merge(action)
+        with(
+          insert_before: "#{action.insert_before}#{insert_before}",
+          replacement: action.replacement || @replacement,
+          insert_after: "#{insert_after}#{action.insert_after}",
+        ).combine_children(action.children)
+      end
+
+      def call_enforcer_for_merge(action)
+        @enforcer.call(:different_replacements) do
+          if @replacement && action.replacement && @replacement != action.replacement
+            {range: @range, replacement: action.replacement, other_replacement: @replacement}
+          end
+        end
+      end
+
+      def swallow(children)
+        @enforcer.call(:swallowed_insertions) do
+          insertions = children.select(&:insertion?)
+
+          {range: @range, conflict: insertions.map(&:range)} unless insertions.empty?
+        end
+        []
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/parser-3.3.7.2/lib/parser/source/tree_rewriter.rb

@@ -0,0 +1,431 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    ##
+    # {TreeRewriter} performs the heavy lifting in the source rewriting process.
+    # It schedules code updates to be performed in the correct order.
+    #
+    # For simple cases, the resulting source will be obvious.
+    #
+    # Examples for more complex cases follow. Assume these examples are acting on
+    # the source `'puts(:hello, :world)`. The methods #wrap, #remove, etc.
+    # receive a Range as first argument; for clarity, examples below use english
+    # sentences and a string of raw code instead.
+    #
+    # ## Overlapping ranges:
+    #
+    # Any two rewriting actions on overlapping ranges will fail and raise
+    # a `ClobberingError`, unless they are both deletions (covered next).
+    #
+    # * wrap ':hello, ' with '(' and ')'
+    # * wrap ', :world' with '(' and ')'
+    #  => CloberringError
+    #
+    # ## Overlapping deletions:
+    #
+    # * remove ':hello, '
+    # * remove ', :world'
+    #
+    # The overlapping ranges are merged and `':hello, :world'` will be removed.
+    # This policy can be changed. `:crossing_deletions` defaults to `:accept`
+    # but can be set to `:warn` or `:raise`.
+    #
+    # ## Multiple actions at the same end points:
+    #
+    # Results will always be independent on the order they were given.
+    # Exception: rewriting actions done on exactly the same range (covered next).
+    #
+    # Example:
+    # * replace ', ' by ' => '
+    # * wrap ':hello, :world' with '{' and '}'
+    # * replace ':world' with ':everybody'
+    # * wrap ':world' with '[', ']'
+    #
+    # The resulting string will be `'puts({:hello => [:everybody]})'`
+    # and this result is independent on the order the instructions were given in.
+    #
+    # Note that if the two "replace" were given as a single replacement of ', :world'
+    # for ' => :everybody', the result would be a `ClobberingError` because of the wrap
+    # in square brackets.
+    #
+    # ## Multiple wraps on same range:
+    # * wrap ':hello' with '(' and ')'
+    # * wrap ':hello' with '[' and ']'
+    #
+    # The wraps are combined in order given and results would be `'puts([(:hello)], :world)'`.
+    #
+    # ## Multiple replacements on same range:
+    # * replace ':hello' by ':hi', then
+    # * replace ':hello' by ':hey'
+    #
+    # The replacements are made in the order given, so the latter replacement
+    # supersedes the former and ':hello' will be replaced by ':hey'.
+    #
+    # This policy can be changed. `:different_replacements` defaults to `:accept`
+    # but can be set to `:warn` or `:raise`.
+    #
+    # ## Swallowed insertions:
+    # wrap 'world' by '__', '__'
+    # replace ':hello, :world' with ':hi'
+    #
+    # A containing replacement will swallow the contained rewriting actions
+    # and `':hello, :world'` will be replaced by `':hi'`.
+    #
+    # This policy can be changed for swallowed insertions. `:swallowed_insertions`
+    # defaults to `:accept` but can be set to `:warn` or `:raise`
+    #
+    # ## Implementation
+    # The updates are organized in a tree, according to the ranges they act on
+    # (where children are strictly contained by their parent), hence the name.
+    #
+    # @!attribute [r] source_buffer
+    #  @return [Source::Buffer]
+    #
+    # @!attribute [r] diagnostics
+    #  @return [Diagnostic::Engine]
+    #
+    # @api public
+    #
+    class TreeRewriter
+      attr_reader :source_buffer
+      attr_reader :diagnostics
+
+      ##
+      # @param [Source::Buffer] source_buffer
+      #
+      def initialize(source_buffer,
+                     crossing_deletions: :accept,
+                     different_replacements: :accept,
+                     swallowed_insertions: :accept)
+        @diagnostics = Diagnostic::Engine.new
+        @diagnostics.consumer = -> diag { $stderr.puts diag.render }
+
+        @source_buffer = source_buffer
+        @in_transaction = false
+
+        @policy = {crossing_deletions: crossing_deletions,
+                   different_replacements: different_replacements,
+                   swallowed_insertions: swallowed_insertions}.freeze
+        check_policy_validity
+
+        @enforcer = method(:enforce_policy)
+        # We need a range that would be jugded as containing all other ranges,
+        # including 0...0 and size...size:
+        all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
+        @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
+      end
+
+      ##
+      # Returns true iff no (non trivial) update has been recorded
+      #
+      # @return [Boolean]
+      #
+      def empty?
+        @action_root.empty?
+      end
+
+      ##
+      # Merges the updates of argument with the receiver.
+      # Policies of the receiver are used.
+      # This action is atomic in that it won't change the receiver
+      # unless it succeeds.
+      #
+      # @param [Rewriter] with
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def merge!(with)
+        raise 'TreeRewriter are not for the same source_buffer' unless
+          source_buffer == with.source_buffer
+
+        @action_root = @action_root.combine(with.action_root)
+        self
+      end
+
+      ##
+      # Returns a new rewriter that consists of the updates of the received
+      # and the given argument. Policies of the receiver are used.
+      #
+      # @param [Rewriter] with
+      # @return [Rewriter] merge of receiver and argument
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def merge(with)
+        dup.merge!(with)
+      end
+
+      ##
+      # For special cases where one needs to merge a rewriter attached to a different source_buffer
+      # or that needs to be offset. Policies of the receiver are used.
+      #
+      # @param [TreeRewriter] rewriter from different source_buffer
+      # @param [Integer] offset
+      # @return [Rewriter] self
+      # @raise [IndexError] if action ranges (once offset) don't fit the current buffer
+      #
+      def import!(foreign_rewriter, offset: 0)
+        return self if foreign_rewriter.empty?
+
+        contracted = foreign_rewriter.action_root.contract
+        merge_effective_range = ::Parser::Source::Range.new(
+          @source_buffer,
+          contracted.range.begin_pos + offset,
+          contracted.range.end_pos + offset,
+        )
+        check_range_validity(merge_effective_range)
+
+        merge_with = contracted.moved(@source_buffer, offset)
+
+        @action_root = @action_root.combine(merge_with)
+        self
+      end
+
+      ##
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def replace(range, content)
+        combine(range, replacement: content)
+      end
+
+      ##
+      # Inserts the given strings before and after the given range.
+      #
+      # @param [Range] range
+      # @param [String, nil] insert_before
+      # @param [String, nil] insert_after
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def wrap(range, insert_before, insert_after)
+        combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
+      end
+
+      ##
+      # Shortcut for `replace(range, '')`
+      #
+      # @param [Range] range
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def remove(range)
+        replace(range, ''.freeze)
+      end
+
+
+      ##
+      # Shortcut for `wrap(range, content, nil)`
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def insert_before(range, content)
+        wrap(range, content, nil)
+      end
+
+      ##
+      # Shortcut for `wrap(range, nil, content)`
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def insert_after(range, content)
+        wrap(range, nil, content)
+      end
+
+      ##
+      # Applies all scheduled changes to the `source_buffer` and returns
+      # modified source as a new string.
+      #
+      # @return [String]
+      #
+      def process
+        source     = @source_buffer.source
+
+        chunks = []
+        last_end = 0
+        @action_root.ordered_replacements.each do |range, replacement|
+          chunks << source[last_end...range.begin_pos] << replacement
+          last_end = range.end_pos
+        end
+        chunks << source[last_end...source.length]
+        chunks.join
+      end
+
+      ##
+      # Returns a representation of the rewriter as an ordered list of replacements.
+      #
+      #     rewriter.as_replacements # => [ [1...1, '('],
+      #                                     [2...4, 'foo'],
+      #                                     [5...6, ''],
+      #                                     [6...6, '!'],
+      #                                     [10...10, ')'],
+      #                                   ]
+      #
+      # This representation is sufficient to recreate the result of `process` but it is
+      # not sufficient to recreate completely the rewriter for further merging/actions.
+      # See `as_nested_actions`
+      #
+      # @return [Array<Range, String>] an ordered list of pairs of range & replacement
+      #
+      def as_replacements
+        @action_root.ordered_replacements
+      end
+
+      ##
+      # Returns a representation of the rewriter as nested insertions (:wrap) and replacements.
+      #
+      #     rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
+      #                               [:wrap, 2...6, '', '!'],  # aka "insert_after"
+      #                               [:replace, 2...4, 'foo'],
+      #                               [:replace, 5...6, ''],  # aka "removal"
+      #                             ],
+      #
+      # Contrary to `as_replacements`, this representation is sufficient to recreate exactly
+      # the rewriter.
+      #
+      # @return [Array<(Symbol, Range, String{, String})>]
+      #
+      def as_nested_actions
+        @action_root.nested_actions
+      end
+
+      ##
+      # Provides a protected block where a sequence of multiple rewrite actions
+      # are handled atomically. If any of the actions failed by clobbering,
+      # all the actions are rolled back. Transactions can be nested.
+      #
+      # @raise [RuntimeError] when no block is passed
+      #
+      def transaction
+        unless block_given?
+          raise "#{self.class}##{__method__} requires block"
+        end
+
+        previous = @in_transaction
+        @in_transaction = true
+        restore_root = @action_root
+
+        yield
+
+        restore_root = nil
+
+        self
+      ensure
+        @action_root = restore_root if restore_root
+        @in_transaction = previous
+      end
+
+      def in_transaction?
+        @in_transaction
+      end
+
+      # :nodoc:
+      def inspect
+        "#<#{self.class} #{source_buffer.name}: #{action_summary}>"
+      end
+
+      ##
+      # @api private
+      # @deprecated Use insert_after or wrap
+      #
+      def insert_before_multi(range, text)
+        self.class.warn_of_deprecation
+        insert_before(range, text)
+      end
+
+      ##
+      # @api private
+      # @deprecated Use insert_after or wrap
+      #
+      def insert_after_multi(range, text)
+        self.class.warn_of_deprecation
+        insert_after(range, text)
+      end
+
+      DEPRECATION_WARNING = [
+        'TreeRewriter#insert_before_multi and insert_before_multi exist only for legacy compatibility.',
+        'Please update your code to use `wrap`, `insert_before` or `insert_after` instead.'
+      ].join("\n").freeze
+
+      extend Deprecation
+
+      protected
+
+      attr_reader :action_root
+
+      private
+
+      def action_summary
+        replacements = as_replacements
+        case replacements.size
+        when 0 then return 'empty'
+        when 1..3 then #ok
+        else
+          replacements = replacements.first(3)
+          suffix = '…'
+        end
+        parts = replacements.map do |(range, str)|
+          if str.empty? # is this a deletion?
+            "-#{range.to_range}"
+          elsif range.size == 0 # is this an insertion?
+            "+#{str.inspect}@#{range.begin_pos}"
+          else # it is a replacement
+            "^#{str.inspect}@#{range.to_range}"
+          end
+        end
+        parts << suffix if suffix
+        parts.join(', ')
+      end
+
+      ACTIONS = %i[accept warn raise].freeze
+      def check_policy_validity
+        invalid = @policy.values - ACTIONS
+        raise ArgumentError, "Invalid policy: #{invalid.join(', ')}" unless invalid.empty?
+      end
+
+      def combine(range, attributes)
+        range = check_range_validity(range)
+        action = TreeRewriter::Action.new(range, @enforcer, **attributes)
+        @action_root = @action_root.combine(action)
+        self
+      end
+
+      def check_range_validity(range)
+        if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
+          raise IndexError, "The range #{range.to_range} is outside the bounds of the source"
+        end
+        range
+      end
+
+      def enforce_policy(event)
+        return if @policy[event] == :accept
+        return unless (values = yield)
+        trigger_policy(event, **values)
+      end
+
+      POLICY_TO_LEVEL = {warn: :warning, raise: :error}.freeze
+      def trigger_policy(event, range: raise, conflict: nil, **arguments)
+        action = @policy[event] || :raise
+        diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], event, arguments, range)
+        @diagnostics.process(diag)
+        if conflict
+          range, *highlights = conflict
+          diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], :"#{event}_conflict", arguments, range, highlights)
+          @diagnostics.process(diag)
+        end
+        raise Parser::ClobberingError, "Parser::Source::TreeRewriter detected clobbering" if action == :raise
+      end
+    end
+  end
+end