plaid 14.10.0 → 14.11.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/single_line_block_params.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether the block parameters of a single-line
-      # method accepting a block match the names specified via configuration.
-      #
-      # For instance one can configure `reduce`(`inject`) to use |a, e| as
-      # parameters.
-      #
-      # Configuration option: Methods
-      # Should be set to use this cop. Array of hashes, where each key is the
-      # method name and value - array of argument names.
-      #
-      # @example Methods: [{reduce: %w[a b]}]
-      #   # bad
-      #   foo.reduce { |c, d| c + d }
-      #   foo.reduce { |_, _d| 1 }
-      #
-      #   # good
-      #   foo.reduce { |a, b| a + b }
-      #   foo.reduce { |a, _b| a }
-      #   foo.reduce { |a, (id, _)| a + id }
-      #   foo.reduce { true }
-      #
-      #   # good
-      #   foo.reduce do |c, d|
-      #     c + d
-      #   end
-      class SingleLineBlockParams < Base
-        MSG = 'Name `%<method>s` block params `|%<params>s|`.'
-
-        def on_block(node)
-          return unless node.single_line?
-
-          return unless eligible_method?(node)
-          return unless eligible_arguments?(node)
-
-          return if args_match?(node.send_node.method_name, node.arguments)
-
-          message = message(node.arguments)
-
-          add_offense(node.arguments, message: message)
-        end
-
-        private
-
-        def message(node)
-          method_name = node.parent.send_node.method_name
-          arguments   = target_args(method_name).join(', ')
-
-          format(MSG, method: method_name, params: arguments)
-        end
-
-        def eligible_arguments?(node)
-          node.arguments? && node.arguments.to_a.all?(&:arg_type?)
-        end
-
-        def eligible_method?(node)
-          node.send_node.receiver &&
-            method_names.include?(node.send_node.method_name)
-        end
-
-        def methods
-          cop_config['Methods']
-        end
-
-        def method_names
-          methods.map { |method| method_name(method).to_sym }
-        end
-
-        def method_name(method)
-          method.keys.first
-        end
-
-        def target_args(method_name)
-          method_name = method_name.to_s
-          method_hash = methods.find { |m| method_name(m) == method_name }
-          method_hash[method_name]
-        end
-
-        def args_match?(method_name, args)
-          actual_args = args.to_a.flat_map(&:to_a)
-
-          # Prepending an underscore to mark an unused parameter is allowed, so
-          # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
-
-          actual_args_no_underscores == target_args(method_name)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/single_line_methods.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for single-line method definitions that contain a body.
-      # It will accept single-line methods with no body.
-      #
-      # @example
-      #   # bad
-      #   def some_method; body end
-      #   def link_to(url); {:name => url}; end
-      #   def @table.columns; super; end
-      #
-      #   # good
-      #   def self.resource_class=(klass); end
-      #   def @table.columns; end
-      #
-      # @example AllowIfMethodIsEmpty: true (default)
-      #   # good
-      #   def no_op; end
-      #
-      # @example AllowIfMethodIsEmpty: false
-      #   # bad
-      #   def no_op; end
-      #
-      class SingleLineMethods < Base
-        include Alignment
-        extend AutoCorrector
-
-        MSG = 'Avoid single-line method definitions.'
-
-        def on_def(node)
-          return unless node.single_line?
-          return if allow_empty? && !node.body
-
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-        alias on_defs on_def
-
-        private
-
-        def autocorrect(corrector, node)
-          each_part(node.body) do |part|
-            LineBreakCorrector.break_line_before(
-              range: part, node: node, corrector: corrector,
-              configured_width: configured_indentation_width
-            )
-          end
-
-          LineBreakCorrector.break_line_before(
-            range: node.loc.end, node: node, corrector: corrector,
-            indent_steps: 0, configured_width: configured_indentation_width
-          )
-
-          move_comment(node, corrector)
-        end
-
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
-        end
-
-        def each_part(body)
-          return unless body
-
-          if body.begin_type?
-            body.each_child_node { |part| yield part.source_range }
-          else
-            yield body.source_range
-          end
-        end
-
-        def move_comment(node, corrector)
-          LineBreakCorrector.move_comment(
-            eol_comment: processed_source.comment_at_line(node.source_range.line),
-            node: node, corrector: corrector
-          )
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/slicing_with_range.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks that arrays are sliced with endless ranges instead of
-      # `ary[start..-1]` on Ruby 2.6+.
-      #
-      # @example
-      #   # bad
-      #   items[1..-1]
-      #
-      #   # good
-      #   items[1..]
-      class SlicingWithRange < Base
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.6
-
-        MSG = 'Prefer ary[n..] over ary[n..-1].'
-        RESTRICT_ON_SEND = %i[[]].freeze
-
-        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
-
-        def on_send(node)
-          return unless node.arguments.count == 1
-          return unless range_till_minus_one?(node.arguments.first)
-
-          add_offense(node.first_argument) do |corrector|
-            corrector.remove(node.first_argument.end)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # If the branch of a conditional consists solely of a conditional node,
-      # its conditions can be combined with the conditions of the outer branch.
-      # This helps to keep the nesting level from getting too deep.
-      #
-      # @example
-      #   # bad
-      #   if condition_a
-      #     if condition_b
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # good
-      #   if condition_a && condition_b
-      #     do_something
-      #   end
-      #
-      # @example AllowModifier: false (default)
-      #   # bad
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      # @example AllowModifier: true
-      #   # good
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      class SoleNestedConditional < Base
-        MSG = 'Consider merging nested conditions into '\
-              'outer `%<conditional_type>s` conditions.'
-
-        def on_if(node)
-          return if node.ternary? || node.else? || node.elsif?
-
-          branch = node.if_branch
-          return unless offending_branch?(branch)
-
-          message = format(MSG, conditional_type: node.keyword)
-          add_offense(branch.loc.keyword, message: message)
-        end
-
-        private
-
-        def offending_branch?(branch)
-          return false unless branch
-
-          branch.if_type? &&
-            !branch.else? &&
-            !branch.ternary? &&
-            !(branch.modifier_form? && allow_modifier?)
-        end
-
-        def allow_modifier?
-          cop_config['AllowModifier']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/special_global_vars.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      #
-      # This cop looks for uses of Perl-style global variables.
-      #
-      # @example EnforcedStyle: use_english_names (default)
-      #   # good
-      #   puts $LOAD_PATH
-      #   puts $LOADED_FEATURES
-      #   puts $PROGRAM_NAME
-      #   puts $ERROR_INFO
-      #   puts $ERROR_POSITION
-      #   puts $FIELD_SEPARATOR # or $FS
-      #   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
-      #   puts $INPUT_RECORD_SEPARATOR # or $RS
-      #   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
-      #   puts $INPUT_LINE_NUMBER # or $NR
-      #   puts $LAST_READ_LINE
-      #   puts $DEFAULT_OUTPUT
-      #   puts $DEFAULT_INPUT
-      #   puts $PROCESS_ID # or $PID
-      #   puts $CHILD_STATUS
-      #   puts $LAST_MATCH_INFO
-      #   puts $IGNORECASE
-      #   puts $ARGV # or ARGV
-      #   puts $MATCH
-      #   puts $PREMATCH
-      #   puts $POSTMATCH
-      #   puts $LAST_PAREN_MATCH
-      #
-      # @example EnforcedStyle: use_perl_names
-      #   # good
-      #   puts $:
-      #   puts $"
-      #   puts $0
-      #   puts $!
-      #   puts $@
-      #   puts $;
-      #   puts $,
-      #   puts $/
-      #   puts $\
-      #   puts $.
-      #   puts $_
-      #   puts $>
-      #   puts $<
-      #   puts $$
-      #   puts $?
-      #   puts $~
-      #   puts $=
-      #   puts $*
-      #   puts $&
-      #   puts $`
-      #   puts $'
-      #   puts $+
-      #
-      class SpecialGlobalVars < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) or `%<regular>s` over ' \
-        '`%<global>s`.'
-        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) over `%<global>s`.'
-        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
-
-        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
-          :$: => [:$LOAD_PATH],
-          :$" => [:$LOADED_FEATURES],
-          :$0 => [:$PROGRAM_NAME],
-          :$! => [:$ERROR_INFO],
-          :$@ => [:$ERROR_POSITION],
-          :$; => %i[$FIELD_SEPARATOR $FS],
-          :$, => %i[$OUTPUT_FIELD_SEPARATOR $OFS],
-          :$/ => %i[$INPUT_RECORD_SEPARATOR $RS],
-          :$\ => %i[$OUTPUT_RECORD_SEPARATOR $ORS],
-          :$. => %i[$INPUT_LINE_NUMBER $NR],
-          :$_ => [:$LAST_READ_LINE],
-          :$> => [:$DEFAULT_OUTPUT],
-          :$< => [:$DEFAULT_INPUT],
-          :$$ => %i[$PROCESS_ID $PID],
-          :$? => [:$CHILD_STATUS],
-          :$~ => [:$LAST_MATCH_INFO],
-          :$= => [:$IGNORECASE],
-          :$* => %i[$ARGV ARGV],
-          :$& => [:$MATCH],
-          :$` => [:$PREMATCH],
-          :$' => [:$POSTMATCH],
-          :$+ => [:$LAST_PAREN_MATCH]
-        }
-
-        PERL_VARS =
-          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
-
-        ENGLISH_VARS.merge!(
-          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
-        PERL_VARS.merge!(
-          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
-        ENGLISH_VARS.each_value(&:freeze).freeze
-        PERL_VARS.each_value(&:freeze).freeze
-
-        # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new(%i[
-                                     $LOAD_PATH
-                                     $LOADED_FEATURES
-                                     $PROGRAM_NAME
-                                     ARGV
-                                   ]).freeze
-
-        def on_gvar(node)
-          global_var, = *node
-
-          return unless (preferred = preferred_names(global_var))
-
-          if preferred.include?(global_var)
-            correct_style_detected
-          else
-            opposite_style_detected
-
-            add_offense(node, message: message(global_var)) do |corrector|
-              autocorrect(corrector, node, global_var)
-            end
-          end
-        end
-
-        def message(global_var)
-          if style == :use_english_names
-            format_english_message(global_var)
-          else
-            format(MSG_REGULAR,
-                   prefer: preferred_names(global_var).first,
-                   global: global_var)
-          end
-        end
-
-        def autocorrect(corrector, node, global_var)
-          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
-
-          corrector.replace(node, replacement(node, global_var))
-        end
-
-        private
-
-        def format_english_message(global_var)
-          regular, english = ENGLISH_VARS[global_var].partition do |var|
-            NON_ENGLISH_VARS.include? var
-          end
-
-          format_message(english, regular, global_var)
-        end
-
-        def format_message(english, regular, global)
-          if regular.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          elsif english.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          else
-            format(MSG_BOTH,
-                   prefer: format_list(english),
-                   regular: format_list(regular),
-                   global: global)
-          end
-        end
-
-        # For now, we assume that lists are 2 items or less. Easy grammar!
-        def format_list(items)
-          items.join('` or `')
-        end
-
-        def replacement(node, global_var)
-          parent_type = node.parent&.type
-          preferred_name = preferred_names(global_var).first
-
-          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
-
-          return english_name_replacement(preferred_name, node) if style == :use_english_names
-
-          "##{preferred_name}"
-        end
-
-        def preferred_names(global)
-          if style == :use_english_names
-            ENGLISH_VARS[global]
-          else
-            PERL_VARS[global]
-          end
-        end
-
-        def english_name_replacement(preferred_name, node)
-          return "\#{#{preferred_name}}" if node.begin_type?
-
-          "{#{preferred_name}}"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Check for parentheses around stabby lambda arguments.
-      # There are two different styles. Defaults to `require_parentheses`.
-      #
-      # @example EnforcedStyle: require_parentheses (default)
-      #   # bad
-      #   ->a,b,c { a + b + c }
-      #
-      #   # good
-      #   ->(a,b,c) { a + b + c}
-      #
-      # @example EnforcedStyle: require_no_parentheses
-      #   # bad
-      #   ->(a,b,c) { a + b + c }
-      #
-      #   # good
-      #   ->a,b,c { a + b + c}
-      class StabbyLambdaParentheses < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'
-        def on_send(node)
-          return unless stabby_lambda_with_args?(node)
-          return unless redundant_parentheses?(node) || missing_parentheses?(node)
-
-          arguments = node.block_node.arguments
-
-          add_offense(arguments) do |corrector|
-            case style
-            when :require_parentheses
-              missing_parentheses_corrector(corrector, arguments)
-            when :require_no_parentheses
-              unwanted_parentheses_corrector(corrector, arguments)
-            end
-          end
-        end
-
-        private
-
-        def missing_parentheses?(node)
-          style == :require_parentheses && !parentheses?(node)
-        end
-
-        def redundant_parentheses?(node)
-          style == :require_no_parentheses && parentheses?(node)
-        end
-
-        def message(_node)
-          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
-        end
-
-        def missing_parentheses_corrector(corrector, node)
-          corrector.wrap(node, '(', ')')
-        end
-
-        def unwanted_parentheses_corrector(corrector, node)
-          args_loc = node.loc
-
-          corrector.replace(args_loc.begin, '')
-          corrector.remove(args_loc.end)
-        end
-
-        def stabby_lambda_with_args?(node)
-          node.lambda_literal? && node.block_node.arguments?
-        end
-
-        def parentheses?(node)
-          node.block_node.arguments.loc.begin
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/stderr_puts.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop identifies places where `$stderr.puts` can be replaced by
-      # `warn`. The latter has the advantage of easily being disabled by,
-      # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
-      #
-      # @example
-      #   # bad
-      #   $stderr.puts('hello')
-      #
-      #   # good
-      #   warn('hello')
-      #
-      class StderrPuts < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG =
-          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
-        RESTRICT_ON_SEND = %i[puts].freeze
-
-        def_node_matcher :stderr_puts?, <<~PATTERN
-          (send
-            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
-            :puts $_
-            ...)
-        PATTERN
-
-        def on_send(node)
-          return unless stderr_puts?(node)
-
-          message = message(node)
-          add_offense(stderr_puts_range(node), message: message) do |corrector|
-            corrector.replace(stderr_puts_range(node), 'warn')
-          end
-        end
-
-        private
-
-        def message(node)
-          format(MSG, bad: "#{node.receiver.source}.#{node.method_name}")
-        end
-
-        def stderr_gvar?(sym)
-          sym == :$stderr
-        end
-
-        def stderr_puts_range(send)
-          range_between(
-            send.loc.expression.begin_pos,
-            send.loc.selector.end_pos
-          )
-        end
-      end
-    end
-  end
-end