@appthreat/atom 2.1.10 → 2.1.11

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/parser-3.3.7.0/lib/parser/source/tree_rewriter/action.rb

@@ -1,243 +0,0 @@
-# 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

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/parser-3.3.7.0/lib/parser/source/tree_rewriter.rb

@@ -1,431 +0,0 @@
-# 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