plaid 14.9.0 → 14.12.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/const_node.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `const` nodes.
+    class ConstNode < Node
+      # The `send` node associated with this block.
+      #
+      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+      def namespace
+        children[0]
+      end
+
+      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+      def short_name
+        children[1]
+      end
+
+      # The body of this block.
+      #
+      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+      #                   Note: some classes might have uppercase in which case this method
+      #                         returns false
+      def module_name?
+        short_name.match?(/[[:lower:]]/)
+      end
+      alias class_name? module_name?
+
+      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+      def absolute?
+        return false unless namespace
+
+        each_path.first.cbase_type?
+      end
+
+      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+      def relative?
+        !absolute?
+      end
+
+      # Yield nodes for the namespace
+      #
+      #   For `::Foo::Bar::BAZ` => yields:
+      #      s(:cbase), then
+      #      s(:const, :Foo), then
+      #      s(:const, s(:const, :Foo), :Bar)
+      def each_path(&block)
+        return to_enum(__method__) unless block_given?
+
+        descendants = []
+        last = self
+        loop do
+          last = last.children.first
+          break if last.nil?
+
+          descendants << last
+          break unless last.const_type?
+        end
+        descendants.reverse_each(&block)
+
+        self
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/def_node.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `def` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `def` nodes within RuboCop.
+    class DefNode < Node
+      include ParameterizedNode
+      include MethodIdentifierPredicates
+
+      # Checks whether this node body is a void context.
+      #
+      # @return [Boolean] whether the `def` node body is a void context
+      def void_context?
+        method?(:initialize) || assignment_method?
+      end
+
+      # Checks whether this method definition node forwards its arguments
+      # as per the feature added in Ruby 2.7.
+      #
+      # @note This is written in a way that may support lead arguments
+      #       which are rumored to be added in a later version of Ruby.
+      #
+      # @return [Boolean] whether the `def` node uses argument forwarding
+      def argument_forwarding?
+        arguments.any?(&:forward_args_type?) || arguments.any?(&:forward_arg_type?)
+      end
+
+      # The name of the defined method as a symbol.
+      #
+      # @return [Symbol] the name of the defined method
+      def method_name
+        children[-3]
+      end
+
+      # An array containing the arguments of the method definition.
+      #
+      # @return [Array<Node>] the arguments of the method definition
+      def arguments
+        children[-2]
+      end
+
+      # The body of the method definition.
+      #
+      # @note this can be either a `begin` node, if the method body contains
+      #       multiple expressions, or any other node, if it contains a single
+      #       expression.
+      #
+      # @return [Node] the body of the method definition
+      def body
+        children[-1]
+      end
+
+      # The receiver of the method definition, if any.
+      #
+      # @return [Node, nil] the receiver of the method definition, or `nil`.
+      def receiver
+        children[-4]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/defined_node.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `defined?` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `send` nodes within RuboCop.
+    class DefinedNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      def node_parts
+        [nil, :defined?, *to_a]
+      end
+
+      alias arguments children
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/ensure_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `ensure` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `ensure` nodes within RuboCop.
+    class EnsureNode < Node
+      # Returns the body of the `ensure` clause.
+      #
+      # @return [Node, nil] The body of the `ensure`.
+      def body
+        node_parts[1]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/float_node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `float` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available to
+    # all `float` nodes within RuboCop.
+    class FloatNode < Node
+      include BasicLiteralNode
+      include NumericNode
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/for_node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `for` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `for` nodes within RuboCop.
+    class ForNode < Node
+      # Returns the keyword of the `for` statement as a string.
+      #
+      # @return [String] the keyword of the `until` statement
+      def keyword
+        'for'
+      end
+
+      # Checks whether the `for` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `for` node has a `do` keyword
+      def do?
+        loc.begin&.is?('do')
+      end
+
+      # Checks whether this node body is a void context.
+      # Always `true` for `for`.
+      #
+      # @return [true] whether the `for` node body is a void context
+      def void_context?
+        true
+      end
+
+      # Returns the iteration variable of the `for` loop.
+      #
+      # @return [Node] The iteration variable of the `for` loop
+      def variable
+        node_parts[0]
+      end
+
+      # Returns the collection the `for` loop is iterating over.
+      #
+      # @return [Node] The collection the `for` loop is iterating over
+      def collection
+        node_parts[1]
+      end
+
+      # Returns the body of the `for` loop.
+      #
+      # @return [Node, nil] The body of the `for` loop.
+      def body
+        node_parts[2]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/forward_args_node.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `forward-args` nodes. This will be used in place
+    # of a plain node when the builder constructs the AST, making its methods
+    # available to all `forward-args` nodes within RuboCop.
+    #
+    # Not used with modern emitters:
+    #
+    #   $ ruby-parse -e "def foo(...); end"
+    #   (def :foo
+    #     (args
+    #       (forward-arg)) nil)
+    #   $ ruby-parse --legacy -e "->(foo) { bar }"
+    #   (def :foo
+    #     (forward-args) nil)
+    #
+    # Note the extra 's' with legacy form.
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+    class ForwardArgsNode < Node
+      include CollectionNode
+
+      # Node wraps itself in an array to be compatible with other
+      # enumerable argument types.
+      def to_a
+        [self]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/hash_node.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `hash` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `hash` nodes within RuboCop.
+    class HashNode < Node
+      # Returns an array of all the key value pairs in the `hash` literal.
+      #
+      # @note this may be different from children as `kwsplat` nodes are
+      # ignored.
+      #
+      # @return [Array<PairNode>] an array of `pair` nodes
+      def pairs
+        each_pair.to_a
+      end
+
+      # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes.
+      #
+      # @return[Boolean] whether the `hash` is empty
+      def empty?
+        children.empty?
+      end
+
+      # Calls the given block for each `pair` node in the `hash` literal.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_pair
+        return each_child_node(:pair).to_enum unless block_given?
+
+        each_child_node(:pair) do |pair|
+          yield(*pair)
+        end
+
+        self
+      end
+
+      # Returns an array of all the keys in the `hash` literal.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [Array<Node>] an array of keys in the `hash` literal
+      def keys
+        each_key.to_a
+      end
+
+      # Calls the given block for each `key` node in the `hash` literal.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_key(&block)
+        return pairs.map(&:key).to_enum unless block_given?
+
+        pairs.map(&:key).each(&block)
+
+        self
+      end
+
+      # Returns an array of all the values in the `hash` literal.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [Array<Node>] an array of values in the `hash` literal
+      def values
+        each_pair.map(&:value)
+      end
+
+      # Calls the given block for each `value` node in the `hash` literal.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_value(&block)
+        return pairs.map(&:value).to_enum unless block_given?
+
+        pairs.map(&:value).each(&block)
+
+        self
+      end
+
+      # Checks whether any of the key value pairs in the `hash` literal are on
+      # the same line.
+      #
+      # @note A multiline `pair` is considered to be on the same line if it
+      #       shares any of its lines with another `pair`
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [Boolean] whether any `pair` nodes are on the same line
+      def pairs_on_same_line?
+        pairs.each_cons(2).any? { |first, second| first.same_line?(second) }
+      end
+
+      # Checks whether this `hash` uses a mix of hash rocket and colon
+      # delimiters for its pairs.
+      #
+      # @note `kwsplat` nodes are ignored.
+      #
+      # @return [Boolean] whether the `hash` uses mixed delimiters
+      def mixed_delimiters?
+        pairs.map(&:delimiter).uniq.size > 1
+      end
+
+      # Checks whether the `hash` literal is delimited by curly braces.
+      #
+      # @return [Boolean] whether the `hash` literal is enclosed in braces
+      def braces?
+        loc.end&.is?('}')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/if_node.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `if` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `if` nodes within RuboCop.
+    class IfNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Checks whether this node is an `if` statement. (This is not true of
+      # ternary operators and `unless` statements.)
+      #
+      # @return [Boolean] whether the node is an `if` statement
+      def if?
+        keyword == 'if'
+      end
+
+      # Checks whether this node is an `unless` statement. (This is not true
+      # of ternary operators and `if` statements.)
+      #
+      # @return [Boolean] whether the node is an `unless` statement
+      def unless?
+        keyword == 'unless'
+      end
+
+      # Checks whether the `if` is an `elsif`. Parser handles these by nesting
+      # `if` nodes in the `else` branch.
+      #
+      # @return [Boolean] whether the node is an `elsif`
+      def elsif?
+        keyword == 'elsif'
+      end
+
+      # Checks whether the `if` node has an `else` clause.
+      #
+      # @note This returns `true` for nodes containing an `elsif` clause.
+      #       This is legacy behavior, and many cops rely on it.
+      #
+      # @return [Boolean] whether the node has an `else` clause
+      def else?
+        loc.respond_to?(:else) && loc.else
+      end
+
+      # Checks whether the `if` node is a ternary operator.
+      #
+      # @return [Boolean] whether the `if` node is a ternary operator
+      def ternary?
+        loc.respond_to?(:question)
+      end
+
+      # Returns the keyword of the `if` statement as a string. Returns an empty
+      # string for ternary operators.
+      #
+      # @return [String] the keyword of the `if` statement
+      def keyword
+        ternary? ? '' : loc.keyword.source
+      end
+
+      # Returns the inverse keyword of the `if` node as a string. Returns `if`
+      # for `unless` nodes and vice versa. Returns an empty string for ternary
+      # operators.
+      #
+      # @return [String] the inverse keyword of the `if` statement
+      def inverse_keyword
+        case keyword
+        when 'if' then 'unless'
+        when 'unless' then 'if'
+        else
+          ''
+        end
+      end
+
+      # Checks whether the `if` node is in a modifier form, i.e. a condition
+      # trailing behind an expression. Only `if` and `unless` nodes without
+      # other branches can be modifiers.
+      #
+      # @return [Boolean] whether the `if` node is a modifier
+      def modifier_form?
+        (if? || unless?) && super
+      end
+
+      # Chacks whether the `if` node has nested `if` nodes in any of its
+      # branches.
+      #
+      # @note This performs a shallow search.
+      #
+      # @return [Boolean] whether the `if` node contains nested conditionals
+      def nested_conditional?
+        node_parts[1..2].compact.each do |branch|
+          branch.each_node(:if) do |nested|
+            return true unless nested.elsif?
+          end
+        end
+
+        false
+      end
+
+      # Checks whether the `if` node has at least one `elsif` branch. Returns
+      # true if this `if` node itself is an `elsif`.
+      #
+      # @return [Boolean] whether the `if` node has at least one `elsif` branch
+      def elsif_conditional?
+        else_branch&.if_type? && else_branch&.elsif?
+      end
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is truthy.
+      #
+      # @note This is normalized for `unless` nodes.
+      #
+      # @return [Node] the truthy branch node of the `if` node
+      # @return [nil] if the truthy branch is empty
+      def if_branch
+        node_parts[1]
+      end
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is falsey.
+      #
+      # @note This is normalized for `unless` nodes.
+      #
+      # @return [Node] the falsey branch node of the `if` node
+      # @return [nil] when there is no else branch
+      def else_branch
+        node_parts[2]
+      end
+
+      # Custom destructuring method. This is used to normalize the branches
+      # for `if` and `unless` nodes, to aid comparisons and conversions.
+      #
+      # @return [Array<Node>] the different parts of the `if` statement
+      def node_parts
+        if unless?
+          condition, false_branch, true_branch = *self
+        else
+          condition, true_branch, false_branch = *self
+        end
+
+        [condition, true_branch, false_branch]
+      end
+
+      # Returns an array of all the branches in the conditional statement.
+      #
+      # @return [Array<Node>] an array of branch nodes
+      def branches
+        branches = [if_branch]
+
+        return branches unless else?
+
+        other_branches = if elsif_conditional?
+                           else_branch.branches
+                         else
+                           [else_branch]
+                         end
+        branches.concat(other_branches)
+      end
+
+      # @deprecated Use `branches.each`
+      def each_branch(&block)
+        return branches.to_enum(__method__) unless block_given?
+
+        branches.each(&block)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/index_node.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar]"
+    #   (index
+    #     (send nil :foo)
+    #     (sym :bar))
+    #   $ ruby-parse --legacy -e "foo[:bar]"
+    #   (send
+    #     (send nil :foo) :[]
+    #     (sym :bar))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexNode < Node
+      include ParameterizedNode::RestArguments
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        false
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]
+      end
+
+      private
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def first_argument_index
+        1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/indexasgn_node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar] = :baz"
+    #   (indexasgn
+    #     (send nil :foo)
+    #     (sym :bar)
+    #     (sym :baz))
+    #   $ ruby-parse --legacy -e "foo[:bar] = :baz"
+    #   (send
+    #     (send nil :foo) :[]=
+    #     (sym :bar)
+    #     (sym :baz))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexasgnNode < Node
+      include ParameterizedNode::RestArguments
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        true
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]=
+      end
+
+      private
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def first_argument_index
+        1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-ast-0.4.2/lib/rubocop/ast/node/int_node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `int` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available to
+    # all `int` nodes within RuboCop.
+    class IntNode < Node
+      include BasicLiteralNode
+      include NumericNode
+    end
+  end
+end