dirwatch 0.0.8 → 0.0.9

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/source/comment/associator.rb

@@ -0,0 +1,210 @@
+# 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.
+      #
+      # @return [Hash<Parser::AST::Node, Array<Parser::Source::Comment>>]
+      # @deprecated Use {associate_locations}.
+      #
+      def associate
+        @map_using_locations = false
+        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_locations = true
+        do_associate
+      end
+
+      private
+
+      def do_associate
+        @mapping     = Hash.new { |h, k| h[k] = [] }
+        @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)
+          node.children.each do |child|
+            next unless child.is_a?(AST::Node) && child.loc && child.loc.expression
+            visit(child)
+          end
+
+          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_locations ? 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

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/source/map.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    ##
+    # {Map} relates AST nodes to the source code they were parsed from.
+    # More specifically, a {Map} or its subclass contains a set of ranges:
+    #
+    #  * `expression`: smallest range which includes all source corresponding
+    #    to the node and all `expression` ranges of its children.
+    #  * other ranges (`begin`, `end`, `operator`, ...): node-specific ranges
+    #    pointing to various interesting tokens corresponding to the node.
+    #
+    # Note that the {Map::Heredoc} map is the only one whose `expression` does
+    # not include other ranges. It only covers the heredoc marker (`<<HERE`),
+    # not the here document itself.
+    #
+    # All ranges except `expression` are defined by {Map} subclasses.
+    #
+    # Ranges (except `expression`) can be `nil` if the corresponding token is
+    # not present in source. For example, a hash may not have opening/closing
+    # braces, and so would its source map.
+    #
+    #     p Parser::CurrentRuby.parse('[1 => 2]').children[0].loc
+    #     # => <Parser::Source::Map::Collection:0x007f5492b547d8
+    #     #  @end=nil, @begin=nil,
+    #     #  @expression=#<Source::Range (string) 1...7>>
+    #
+    # The {file:doc/AST_FORMAT.md} document describes how ranges associated to source
+    # code tokens. For example, the entry
+    #
+    #     (array (int 1) (int 2))
+    #
+    #     "[1, 2]"
+    #      ^ begin
+    #           ^ end
+    #      ~~~~~~ expression
+    #
+    # means that if `node` is an {Parser::AST::Node} `(array (int 1) (int 2))`,
+    # then `node.loc` responds to `begin`, `end` and `expression`, and
+    # `node.loc.begin` returns a range pointing at the opening bracket, and so on.
+    #
+    # If you want to write code polymorphic by the source map (i.e. accepting
+    # several subclasses of {Map}), use `respond_to?` instead of `is_a?` to
+    # check whether the map features the range you need. Concrete {Map}
+    # subclasses may not be preserved between versions, but their interfaces
+    # will be kept compatible.
+    #
+    # You can visualize the source maps with `ruby-parse -E` command-line tool.
+    #
+    # @example
+    #  require 'parser/current'
+    #
+    #  p Parser::CurrentRuby.parse('[1, 2]').loc
+    #  # => #<Parser::Source::Map::Collection:0x007f14b80eccd8
+    #  #  @end=#<Source::Range (string) 5...6>,
+    #  #  @begin=#<Source::Range (string) 0...1>,
+    #  #  @expression=#<Source::Range (string) 0...6>>
+    #
+    # @!attribute [r] node
+    #  The node that is described by this map. Nodes and maps have 1:1 correspondence.
+    #  @return [Parser::AST::Node]
+    #
+    # @!attribute [r] expression
+    #  @return [Range]
+    #
+    # @api public
+    #
+    class Map
+      attr_reader :node
+      attr_reader :expression
+
+      ##
+      # @param [Range] expression
+      def initialize(expression)
+        @expression = expression
+      end
+
+      ##
+      # @api private
+      def initialize_copy(other)
+        super
+        @node = nil
+      end
+
+      ##
+      # @api private
+      def node=(node)
+        @node = node
+        freeze
+        @node
+      end
+
+      ##
+      # A shortcut for `self.expression.line`.
+      # @return [Integer]
+      #
+      def line
+        @expression.line
+      end
+
+      alias_method :first_line, :line
+
+      ##
+      # A shortcut for `self.expression.column`.
+      # @return [Integer]
+      #
+      def column
+        @expression.column
+      end
+
+      ##
+      # A shortcut for `self.expression.last_line`.
+      # @return [Integer]
+      #
+      def last_line
+        @expression.last_line
+      end
+
+      ##
+      # A shortcut for `self.expression.last_column`.
+      # @return [Integer]
+      #
+      def last_column
+        @expression.last_column
+      end
+
+      ##
+      # @api private
+      #
+      def with_expression(expression_l)
+        with { |map| map.update_expression(expression_l) }
+      end
+
+      ##
+      # Compares source maps.
+      # @return [Boolean]
+      #
+      def ==(other)
+        other.class == self.class &&
+          instance_variables.map do |ivar|
+            instance_variable_get(ivar) ==
+              other.send(:instance_variable_get, ivar)
+          end.reduce(:&)
+      end
+
+      ##
+      # Converts this source map to a hash with keys corresponding to
+      # ranges. For example, if called on an instance of {Collection},
+      # which adds the `begin` and `end` ranges, the resulting hash
+      # will contain keys `:expression`, `:begin` and `:end`.
+      #
+      # @example
+      #  require 'parser/current'
+      #
+      #  p Parser::CurrentRuby.parse('[1, 2]').loc.to_hash
+      #  # => {
+      #  #   :begin => #<Source::Range (string) 0...1>,
+      #  #   :end => #<Source::Range (string) 5...6>,
+      #  #   :expression => #<Source::Range (string) 0...6>
+      #  # }
+      #
+      # @return [Hash<Symbol, Parser::Source::Range>]
+      #
+      def to_hash
+        instance_variables.inject({}) do |hash, ivar|
+          next hash if ivar.to_sym == :@node
+          hash[ivar[1..-1].to_sym] = instance_variable_get(ivar)
+          hash
+        end
+      end
+
+      protected
+
+      def with(&block)
+        dup.tap(&block)
+      end
+
+      def update_expression(expression_l)
+        @expression = expression_l
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/source/map/collection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    class Map::Collection < Map
+      attr_reader :begin
+      attr_reader :end
+
+      def initialize(begin_l, end_l, expression_l)
+        @begin, @end = begin_l, end_l
+
+        super(expression_l)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/source/map/condition.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    class Map::Condition < Map
+      attr_reader :keyword
+      attr_reader :begin
+      attr_reader :else
+      attr_reader :end
+
+      def initialize(keyword_l, begin_l, else_l, end_l, expression_l)
+        @keyword = keyword_l
+        @begin, @else, @end = begin_l, else_l, end_l
+
+        super(expression_l)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/source/map/constant.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    class Map::Constant < Map
+      attr_reader :double_colon
+      attr_reader :name
+      attr_reader :operator
+
+      def initialize(double_colon, name, expression)
+        @double_colon, @name = double_colon, name
+
+        super(expression)
+      end
+
+      ##
+      # @api private
+      #
+      def with_operator(operator_l)
+        with { |map| map.update_operator(operator_l) }
+      end
+
+      protected
+
+      def update_operator(operator_l)
+        @operator = operator_l
+      end
+    end
+
+  end
+end