@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/buffer.rb

@@ -1,369 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-module Parser
-  module Source
-
-    ##
-    # A buffer with source code. {Buffer} contains the source code itself,
-    # associated location information (name and first line), and takes care
-    # of encoding.
-    #
-    # A source buffer is immutable once populated.
-    #
-    # @!attribute [r] name
-    #  Buffer name. If the buffer was created from a file, the name corresponds
-    #  to relative path to the file.
-    #  @return [String] buffer name
-    #
-    # @!attribute [r] first_line
-    #  First line of the buffer, 1 by default.
-    #  @return [Integer] first line
-    #
-    # @api public
-    #
-    class Buffer
-      attr_reader :name, :first_line
-
-      ##
-      # @api private
-      #
-      ENCODING_RE =
-        /[\s#](en)?coding\s*[:=]\s*
-          (
-            # Special-case: there's a UTF8-MAC encoding.
-            (utf8-mac)
-          |
-            # Chew the suffix; it's there for emacs compat.
-            ([A-Za-z0-9_-]+?)(-unix|-dos|-mac)
-          |
-            ([A-Za-z0-9_-]+)
-          )
-        /x
-
-      ##
-      # Try to recognize encoding of `string` as Ruby would, i.e. by looking for
-      # magic encoding comment or UTF-8 BOM. `string` can be in any encoding.
-      #
-      # @param [String]  string
-      # @raise [Parser::UnknownEncodingInMagicComment] if the encoding is not recognized
-      # @return [String, nil] encoding name, if recognized
-      #
-      def self.recognize_encoding(string)
-        return if string.empty?
-
-        # extract the first two lines in an efficient way
-        string =~ /\A(.*)\n?(.*\n)?/
-        first_line, second_line = $1, $2
-
-        if first_line.start_with?("\xef\xbb\xbf".freeze) # BOM
-          return Encoding::UTF_8
-        elsif first_line[0, 2] == '#!'.freeze
-          encoding_line = second_line
-        else
-          encoding_line = first_line
-        end
-
-        return nil if encoding_line.nil? || encoding_line[0] != '#'
-
-        if (result = ENCODING_RE.match(encoding_line))
-          begin
-            Encoding.find(result[3] || result[4] || result[6])
-          rescue ArgumentError => e
-            raise Parser::UnknownEncodingInMagicComment, e.message
-          end
-        else
-          nil
-        end
-      end
-
-      ##
-      # Recognize encoding of `input` and process it so it could be lexed.
-      #
-      #  * If `input` does not contain BOM or magic encoding comment, it is
-      #    kept in the original encoding.
-      #  * If the detected encoding is binary, `input` is kept in binary.
-      #  * Otherwise, `input` is re-encoded into UTF-8 and returned as a
-      #    new string.
-      #
-      # This method mutates the encoding of `input`, but not its content.
-      #
-      # @param  [String] input
-      # @return [String]
-      # @raise  [EncodingError]
-      #
-      def self.reencode_string(input)
-        original_encoding = input.encoding
-        detected_encoding = recognize_encoding(input.force_encoding(Encoding::BINARY))
-
-        if detected_encoding.nil?
-          input.force_encoding(original_encoding)
-        elsif detected_encoding == Encoding::BINARY
-          input
-        else
-          input.
-            force_encoding(detected_encoding).
-            encode(Encoding::UTF_8)
-        end
-      end
-
-      def initialize(name, first_line = 1, source: nil)
-        @name        = name.to_s
-        @source      = nil
-        @first_line  = first_line
-
-        @lines       = nil
-        @line_begins = nil
-
-        # UTF-32-reencoded source for O(1) slicing
-        @slice_source = nil
-
-        # Cache for fast lookup
-        @line_index_for_position = {}
-
-        self.source = source if source
-      end
-
-      ##
-      # Populate this buffer from correspondingly named file.
-      #
-      # @example
-      #  Parser::Source::Buffer.new('foo/bar.rb').read
-      #
-      # @return [Buffer] self
-      # @raise  [ArgumentError] if already populated
-      #
-      def read
-        File.open(@name, 'rb') do |io|
-          self.source = io.read
-        end
-
-        self
-      end
-
-      ##
-      # Source code contained in this buffer.
-      #
-      # @return [String] source code
-      # @raise  [RuntimeError] if buffer is not populated yet
-      #
-      def source
-        if @source.nil?
-          raise RuntimeError, 'Cannot extract source from uninitialized Source::Buffer'
-        end
-
-        @source
-      end
-
-      ##
-      # Populate this buffer from a string with encoding autodetection.
-      # `input` is mutated if not frozen.
-      #
-      # @param [String] input
-      # @raise [ArgumentError] if already populated
-      # @raise [EncodingError] if `input` includes invalid byte sequence for the encoding
-      # @return [String]
-      #
-      def source=(input)
-        input = input.dup if input.frozen?
-        input = self.class.reencode_string(input)
-
-        unless input.valid_encoding?
-          raise EncodingError, "invalid byte sequence in #{input.encoding.name}"
-        end
-
-        self.raw_source = input
-      end
-
-      ##
-      # Populate this buffer from a string without encoding autodetection.
-      #
-      # @param [String] input
-      # @raise [ArgumentError] if already populated
-      # @return [String]
-      #
-      def raw_source=(input)
-        if @source
-          raise ArgumentError, 'Source::Buffer is immutable'
-        end
-
-        @source = input.gsub("\r\n".freeze, "\n".freeze).freeze
-
-        if !@source.ascii_only? &&
-           @source.encoding != Encoding::UTF_32LE &&
-           @source.encoding != Encoding::BINARY
-          @slice_source = @source.encode(Encoding::UTF_32LE)
-        end
-      end
-
-      def slice(start, length = nil)
-        if length.nil?
-          if start.is_a?(::Range)
-            length = start.size
-            start = start.begin
-          else
-            length = 1
-          end
-        end
-
-        if @slice_source.nil?
-          @source[start, length]
-        else
-          @slice_source[start, length].encode(@source.encoding)
-        end
-      end
-
-      ##
-      # Convert a character index into the source to a `[line, column]` tuple.
-      #
-      # @param  [Integer] position
-      # @return [[Integer, Integer]] `[line, column]`
-      #
-      def decompose_position(position)
-        line_index = line_index_for_position(position)
-        line_begin = line_begins[line_index]
-
-        [ @first_line + line_index , position - line_begin ]
-      end
-
-      ##
-      # Convert a character index into the source to a line number.
-      #
-      # @param  [Integer] position
-      # @return [Integer] line
-      # @api private
-      #
-      def line_for_position(position)
-        line_index_for_position(position) + @first_line
-      end
-
-      ##
-      # Convert a character index into the source to a column number.
-      #
-      # @param  [Integer] position
-      # @return [Integer] column
-      # @api private
-      #
-      def column_for_position(position)
-        line_index = line_index_for_position(position)
-        position - line_begins[line_index]
-      end
-
-      ##
-      # Return an `Array` of source code lines.
-      #
-      # @return [Array<String>]
-      #
-      def source_lines
-        @lines ||= begin
-          lines = @source.lines.to_a
-          lines << ''.dup if @source.end_with?("\n".freeze)
-
-          lines.each do |line|
-            line.chomp!("\n".freeze)
-            line.freeze
-          end
-
-          lines.freeze
-        end
-      end
-
-      ##
-      # Extract line `lineno` from source, taking `first_line` into account.
-      #
-      # @param  [Integer] lineno
-      # @return [String]
-      # @raise  [IndexError] if `lineno` is out of bounds
-      #
-      def source_line(lineno)
-        source_lines.fetch(lineno - @first_line).dup
-      end
-
-      ##
-      # Extract line `lineno` as a new `Range`, taking `first_line` into account.
-      #
-      # @param  [Integer] lineno
-      # @return [Range]
-      # @raise  [IndexError] if `lineno` is out of bounds
-      #
-      def line_range(lineno)
-        index = lineno - @first_line
-        if index < 0 || index + 1 >= line_begins.size
-          raise IndexError, 'Parser::Source::Buffer: range for line ' \
-            "#{lineno} requested, valid line numbers are #{@first_line}.." \
-            "#{@first_line + line_begins.size - 2}"
-        else
-          Range.new(self, line_begins[index], line_begins[index + 1] - 1)
-        end
-      end
-
-      ##
-      # @return [Range] A range covering the whole source
-      #
-      def source_range
-        @source_range ||= Range.new(self, 0, source.size)
-      end
-
-      ##
-      # Number of last line in the buffer
-      #
-      # @return [Integer]
-      #
-      def last_line
-        line_begins.size + @first_line - 2
-      end
-
-      # :nodoc:
-      def freeze
-        source_lines; line_begins; source_range # build cache
-        super
-      end
-
-      # :nodoc:
-      def inspect
-        "#<#{self.class} #{name}>"
-      end
-
-      private
-
-      # @returns [0, line_begin_of_line_1, ..., source.size + 1]
-      def line_begins
-        @line_begins ||= begin
-          begins = [0]
-          index = 0
-          while index = @source.index("\n".freeze, index)
-            index += 1
-            begins << index
-          end
-          begins << @source.size + 1
-          begins
-        end
-      end
-
-      # @returns 0-based line index of position
-      def line_index_for_position(position)
-        @line_index_for_position[position] || begin
-          index = bsearch(line_begins, position) - 1
-          @line_index_for_position[position] = index unless @line_index_for_position.frozen?
-          index
-        end
-      end
-
-      if Array.method_defined?(:bsearch_index) # RUBY_VERSION >= 2.3
-        def bsearch(line_begins, position)
-          line_begins.bsearch_index do |line_begin|
-            position < line_begin
-          end || line_begins.size - 1 # || only for out of bound values
-        end
-      else
-        def bsearch(line_begins, position)
-          @line_range ||= 0...line_begins.size
-          @line_range.bsearch do |i|
-            position < line_begins[i]
-          end || line_begins.size - 1 # || only for out of bound values
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-module Parser
-  module Source
-
-    ##
-    # A processor which associates AST nodes with comments based on their
-    # location in source code. It may be used, for example, to implement
-    # rdoc-style processing.
-    #
-    # @example
-    #   require 'parser/current'
-    #
-    #   ast, comments = Parser::CurrentRuby.parse_with_comments(<<-CODE)
-    #   # Class stuff
-    #   class Foo
-    #     # Attr stuff
-    #     # @see bar
-    #     attr_accessor :foo
-    #   end
-    #   CODE
-    #
-    #   p Parser::Source::Comment.associate(ast, comments)
-    #   # => {
-    #   #   (class (const nil :Foo) ...) =>
-    #   #     [#<Parser::Source::Comment (string):1:1 "# Class stuff">],
-    #   #   (send nil :attr_accessor (sym :foo)) =>
-    #   #     [#<Parser::Source::Comment (string):3:3 "# Attr stuff">,
-    #   #      #<Parser::Source::Comment (string):4:3 "# @see bar">]
-    #   # }
-    #
-    # @see {associate}
-    #
-    # @!attribute skip_directives
-    #  Skip file processing directives disguised as comments.
-    #  Namely:
-    #
-    #    * Shebang line,
-    #    * Magic encoding comment.
-    #
-    #  @return [Boolean]
-    #
-    # @api public
-    #
-    class Comment::Associator
-      attr_accessor :skip_directives
-
-      ##
-      # @param [Parser::AST::Node] ast
-      # @param [Array<Parser::Source::Comment>] comments
-      def initialize(ast, comments)
-        @ast         = ast
-        @comments    = comments
-
-        @skip_directives = true
-      end
-
-      ##
-      # Compute a mapping between AST nodes and comments.  Comment is
-      # associated with the node, if it is one of the following types:
-      #
-      # - preceding comment, it ends before the node start
-      # - sparse comment, it is located inside the node, after all child nodes
-      # - decorating comment, it starts at the same line, where the node ends
-      #
-      # This rule is unambiguous and produces the result
-      # one could reasonably expect; for example, this code
-      #
-      #     # foo
-      #     hoge # bar
-      #       + fuga
-      #
-      # will result in the following association:
-      #
-      #     {
-      #       (send (lvar :hoge) :+ (lvar :fuga)) =>
-      #         [#<Parser::Source::Comment (string):2:1 "# foo">],
-      #       (lvar :fuga) =>
-      #         [#<Parser::Source::Comment (string):3:8 "# bar">]
-      #     }
-      #
-      # Note that comments after the end of the end of a passed tree range are
-      # ignored (except root decorating comment).
-      #
-      # Note that {associate} produces unexpected result for nodes which are
-      # equal but have distinct locations; comments for these nodes are merged.
-      # You may prefer using {associate_by_identity} or {associate_locations}.
-      #
-      # @return [Hash<Parser::AST::Node, Array<Parser::Source::Comment>>]
-      # @deprecated Use {associate_locations}.
-      #
-      def associate
-        @map_using = :eql
-        do_associate
-      end
-
-      ##
-      # Same as {associate}, but uses `node.loc` instead of `node` as
-      # the hash key, thus producing an unambiguous result even in presence
-      # of equal nodes.
-      #
-      # @return [Hash<Parser::Source::Map, Array<Parser::Source::Comment>>]
-      #
-      def associate_locations
-        @map_using = :location
-        do_associate
-      end
-
-      ##
-      # Same as {associate}, but compares by identity, thus producing an unambiguous
-      # result even in presence of equal nodes.
-      #
-      # @return [Hash<Parser::Source::Node, Array<Parser::Source::Comment>>]
-      #
-      def associate_by_identity
-        @map_using = :identity
-        do_associate
-      end
-
-      private
-
-      POSTFIX_TYPES = Set[:if, :while, :while_post, :until, :until_post, :masgn].freeze
-      def children_in_source_order(node)
-        if POSTFIX_TYPES.include?(node.type)
-          # All these types have either nodes with expressions, or `nil`
-          # so a compact will do, but they need to be sorted.
-          node.children.compact.sort_by { |child| child.loc.expression.begin_pos }
-        else
-          node.children.select do |child|
-            child.is_a?(AST::Node) && child.loc && child.loc.expression
-          end
-        end
-      end
-
-      def do_associate
-        @mapping     = Hash.new { |h, k| h[k] = [] }
-        @mapping.compare_by_identity if @map_using == :identity
-        @comment_num = -1
-        advance_comment
-
-        advance_through_directives if @skip_directives
-
-        visit(@ast) if @ast
-
-        @mapping
-      end
-
-      def visit(node)
-        process_leading_comments(node)
-
-        return unless @current_comment
-
-        # If the next comment is beyond the last line of this node, we don't
-        # need to iterate over its subnodes
-        # (Unless this node is a heredoc... there could be a comment in its body,
-        # inside an interpolation)
-        node_loc = node.location
-        if @current_comment.location.line <= node_loc.last_line ||
-           node_loc.is_a?(Map::Heredoc)
-          children_in_source_order(node).each { |child| visit(child) }
-
-          process_trailing_comments(node)
-        end
-      end
-
-      def process_leading_comments(node)
-        return if node.type == :begin
-        while current_comment_before?(node) # preceding comment
-          associate_and_advance_comment(node)
-        end
-      end
-
-      def process_trailing_comments(node)
-        while current_comment_before_end?(node)
-          associate_and_advance_comment(node) # sparse comment
-        end
-        while current_comment_decorates?(node)
-          associate_and_advance_comment(node) # decorating comment
-        end
-      end
-
-      def advance_comment
-        @comment_num += 1
-        @current_comment = @comments[@comment_num]
-      end
-
-      def current_comment_before?(node)
-        return false if !@current_comment
-        comment_loc = @current_comment.location.expression
-        node_loc = node.location.expression
-        comment_loc.end_pos <= node_loc.begin_pos
-      end
-
-      def current_comment_before_end?(node)
-        return false if !@current_comment
-        comment_loc = @current_comment.location.expression
-        node_loc = node.location.expression
-        comment_loc.end_pos <= node_loc.end_pos
-      end
-
-      def current_comment_decorates?(node)
-        return false if !@current_comment
-        @current_comment.location.line == node.location.last_line
-      end
-
-      def associate_and_advance_comment(node)
-        key = @map_using == :location ? node.location : node
-        @mapping[key] << @current_comment
-        advance_comment
-      end
-
-      MAGIC_COMMENT_RE = /^#\s*(-\*-|)\s*(frozen_string_literal|warn_indent|warn_past_scope):.*\1$/
-
-      def advance_through_directives
-        # Skip shebang.
-        if @current_comment && @current_comment.text.start_with?('#!'.freeze)
-          advance_comment
-        end
-
-        # Skip magic comments.
-        if @current_comment && @current_comment.text =~ MAGIC_COMMENT_RE
-          advance_comment
-        end
-
-        # Skip encoding line.
-        if @current_comment && @current_comment.text =~ Buffer::ENCODING_RE
-          advance_comment
-        end
-      end
-    end
-
-  end
-end