plaid 14.7.0 → 14.8.0

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/RedundantCopDisableDirective
-# rubocop:disable Style/DoubleCopDisableDirective
-
-module RuboCop
-  module Cop
-    module Style
-      # Detects double disable comments on one line. This is mostly to catch
-      # automatically generated comments that need to be regenerated.
-      #
-      # @example
-      #   # bad
-      #   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
-      #   end
-      #
-      #   # good
-      #   # rubocop:disable Metrics/AbcSize
-      #   def f # rubocop:disable Style/For
-      #   end
-      #   # rubocop:enable Metrics/AbcSize
-      #
-      #   # if both fit on one line
-      #   def f # rubocop:disable Style/For, Metrics/AbcSize
-      #   end
-      #
-      class DoubleCopDisableDirective < Base
-        extend AutoCorrector
-
-        # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
-        MSG = 'More than one disable comment on one line.'
-
-        def on_new_investigation
-          processed_source.comments.each do |comment|
-            next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
-
-            add_offense(comment) do |corrector|
-              prefix = if comment.text.start_with?('# rubocop:disable')
-                         '# rubocop:disable'
-                       else
-                         '# rubocop:todo'
-                       end
-
-              corrector.replace(comment, comment.text[/#{prefix} \S+/])
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
-      #
-      # When using `EnforcedStyle: allowed_in_returns`, allow double nagation in contexts
-      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double nagation
-      # should be forbidden always.
-      #
-      # @example
-      #   # bad
-      #   !!something
-      #
-      #   # good
-      #   !something.nil?
-      #
-      # @example EnforcedStyle: allowed_in_returns (default)
-      #   # good
-      #   def foo?
-      #     !!return_value
-      #   end
-      #
-      # @example EnforcedStyle: forbidden
-      #   # bad
-      #   def foo?
-      #     !!return_value
-      #   end
-      #
-      # Please, note that when something is a boolean value
-      # !!something and !something.nil? are not the same thing.
-      # As you're unlikely to write code that can accept values of any type
-      # this is rarely a problem in practice.
-      class DoubleNegation < Base
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Avoid the use of double negation (`!!`).'
-        RESTRICT_ON_SEND = %i[!].freeze
-
-        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
-
-        def on_send(node)
-          return unless double_negative?(node) && node.prefix_bang?
-          return if style == :allowed_in_returns && allowed_in_returns?(node)
-
-          add_offense(node.loc.selector)
-        end
-
-        private
-
-        def allowed_in_returns?(node)
-          node.parent&.return_type? || end_of_method_definition?(node)
-        end
-
-        def end_of_method_definition?(node)
-          return false unless (def_node = find_def_node_from_ascendant(node))
-
-          last_child = def_node.child_nodes.last
-
-          last_child.last_line == node.last_line
-        end
-
-        def find_def_node_from_ascendant(node)
-          return unless (parent = node.parent)
-          return parent if parent.def_type? || parent.defs_type?
-
-          find_def_node_from_ascendant(node.parent)
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for loops which iterate a constant number of times,
-      # using a Range literal and `#each`. This can be done more readably using
-      # `Integer#times`.
-      #
-      # This check only applies if the block takes no parameters.
-      #
-      # @example
-      #   # bad
-      #   (1..5).each { }
-      #
-      #   # good
-      #   5.times { }
-      #
-      # @example
-      #   # bad
-      #   (0...10).each {}
-      #
-      #   # good
-      #   10.times {}
-      class EachForSimpleLoop < Base
-        extend AutoCorrector
-
-        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
-              'number of times.'
-
-        def on_block(node)
-          return unless offending_each_range(node)
-
-          send_node = node.send_node
-
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
-            range_type, min, max = offending_each_range(node)
-
-            max += 1 if range_type == :irange
-
-            corrector.replace(node.send_node, "#{max - min}.times")
-          end
-        end
-
-        private
-
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop looks for inject / reduce calls where the passed in object is
-      # returned at the end and so could be replaced by each_with_object without
-      # the need to return the object at the end.
-      #
-      # However, we can't replace with each_with_object if the accumulator
-      # parameter is assigned to within the block.
-      #
-      # @example
-      #   # bad
-      #   [1, 2].inject({}) { |a, e| a[e] = e; a }
-      #
-      #   # good
-      #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
-      class EachWithObject < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Use `each_with_object` instead of `%<method>s`.'
-        METHODS = %i[inject reduce].freeze
-
-        def_node_matcher :each_with_object_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
-        PATTERN
-
-        def on_block(node)
-          each_with_object_candidate?(node) do |method, args, body|
-            _, method_name, method_arg = *method
-            return if simple_method_arg?(method_arg)
-
-            return_value = return_value(body)
-            return unless return_value
-            return unless first_argument_returned?(args, return_value)
-            return if accumulator_param_assigned_to?(body, args)
-
-            message = format(MSG, method: method_name)
-            add_offense(method.loc.selector, message: message) do |corrector|
-              autocorrect(corrector, node, return_value)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node, return_value)
-          corrector.replace(node.send_node.loc.selector, 'each_with_object')
-
-          first_arg, second_arg = *node.arguments
-
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
-
-          if return_value_occupies_whole_line?(return_value)
-            corrector.remove(whole_line_expression(return_value))
-          else
-            corrector.remove(return_value)
-          end
-        end
-
-        def simple_method_arg?(method_arg)
-          method_arg&.basic_literal?
-        end
-
-        # if the accumulator parameter is assigned to in the block,
-        # then we can't convert to each_with_object
-        def accumulator_param_assigned_to?(body, args)
-          first_arg, = *args
-          accumulator_var, = *first_arg
-
-          body.each_descendant.any? do |n|
-            next unless n.assignment?
-
-            lhs, _rhs = *n
-            lhs.equal?(accumulator_var)
-          end
-        end
-
-        def return_value(body)
-          return unless body
-
-          return_value = body.begin_type? ? body.children.last : body
-          return_value if return_value&.lvar_type?
-        end
-
-        def first_argument_returned?(args, return_value)
-          first_arg, = *args
-          accumulator_var, = *first_arg
-          return_var, = *return_value
-
-          accumulator_var == return_var
-        end
-
-        def return_value_occupies_whole_line?(node)
-          whole_line_expression(node).source.strip == node.source
-        end
-
-        def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for pipes for empty block parameters. Pipes for empty
-      # block parameters do not cause syntax errors, but they are redundant.
-      #
-      # @example
-      #   # bad
-      #   a do ||
-      #     do_something
-      #   end
-      #
-      #   # bad
-      #   a { || do_something }
-      #
-      #   # good
-      #   a do
-      #   end
-      #
-      #   # good
-      #   a { do_something }
-      class EmptyBlockParameter < Base
-        include EmptyParameter
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Omit pipes for the empty block parameters.'
-
-        def on_block(node)
-          send_node = node.send_node
-          check(node) unless send_node.send_type? && send_node.lambda_literal?
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
-
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for case statements with an empty condition.
-      #
-      # @example
-      #
-      #   # bad:
-      #   case
-      #   when x == 0
-      #     puts 'x is 0'
-      #   when y == 0
-      #     puts 'y is 0'
-      #   else
-      #     puts 'neither is 0'
-      #   end
-      #
-      #   # good:
-      #   if x == 0
-      #     puts 'x is 0'
-      #   elsif y == 0
-      #     puts 'y is 0'
-      #   else
-      #     puts 'neither is 0'
-      #   end
-      #
-      #   # good: (the case condition node is not empty)
-      #   case n
-      #   when 0
-      #     puts 'zero'
-      #   when 1
-      #     puts 'one'
-      #   else
-      #     puts 'more'
-      #   end
-      class EmptyCaseCondition < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
-
-        def on_case(case_node)
-          return if case_node.condition
-
-          branch_bodies = [
-            *case_node.when_branches.map(&:body),
-            case_node.else_branch
-          ].compact
-
-          return if branch_bodies.any? do |body|
-            body.return_type? ||
-            body.each_descendant.any?(&:return_type?)
-          end
-
-          add_offense(case_node.loc.keyword) do |corrector|
-            autocorrect(corrector, case_node)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, case_node)
-          when_branches = case_node.when_branches
-
-          correct_case_when(corrector, case_node, when_branches)
-          correct_when_conditions(corrector, when_branches)
-        end
-
-        def correct_case_when(corrector, case_node, when_nodes)
-          case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
-
-          corrector.replace(case_range, 'if')
-
-          keep_first_when_comment(case_range, corrector)
-
-          when_nodes[1..-1].each do |when_node|
-            corrector.replace(when_node.loc.keyword, 'elsif')
-          end
-        end
-
-        def correct_when_conditions(corrector, when_nodes)
-          when_nodes.each do |when_node|
-            conditions = when_node.conditions
-
-            next unless conditions.size > 1
-
-            range = range_between(conditions.first.source_range.begin_pos,
-                                  conditions.last.source_range.end_pos)
-
-            corrector.replace(range, conditions.map(&:source).join(' || '))
-          end
-        end
-
-        def keep_first_when_comment(case_range, corrector)
-          indent = ' ' * case_range.column
-          comments = processed_source.each_comment_in_lines(
-            case_range.first_line...case_range.last_line
-          ).map { |comment| "#{indent}#{comment.text}\n" }.join
-
-          line_beginning = case_range.adjust(begin_pos: -case_range.column)
-          corrector.insert_before(line_beginning, comments)
-        end
-      end
-    end
-  end
-end

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

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for empty else-clauses, possibly including comments and/or an
-      # explicit `nil` depending on the EnforcedStyle.
-      #
-      # @example EnforcedStyle: empty
-      #   # warn only on empty else
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   else
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     nil
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   end
-      #
-      # @example EnforcedStyle: nil
-      #   # warn on else with nil in it
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   else
-      #     nil
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   end
-      #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   else
-      #     nil
-      #   end
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   else
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   end
-      class EmptyElse < Base
-        include OnNormalIfUnless
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Redundant `else`-clause.'
-
-        def on_normal_if_unless(node)
-          check(node)
-        end
-
-        def on_case(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          empty_check(node) if empty_style?
-          nil_check(node) if nil_style?
-        end
-
-        def nil_style?
-          style == :nil || style == :both
-        end
-
-        def empty_style?
-          style == :empty || style == :both
-        end
-
-        def empty_check(node)
-          return unless node.else? && !node.else_branch
-
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def nil_check(node)
-          return unless node.else_branch&.nil_type?
-
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def autocorrect(corrector, node)
-          return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node.loc)
-
-          end_pos = base_node(node).loc.end.begin_pos
-          corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-        end
-
-        def comment_in_else?(loc)
-          return false if loc.else.nil? || loc.end.nil?
-
-          processed_source.contains_comment?(loc.else.join(loc.end))
-        end
-
-        def base_node(node)
-          return node if node.case_type?
-          return node unless node.elsif?
-
-          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
-            parent.loc.end
-          end
-        end
-
-        def autocorrect_forbidden?(type)
-          [type, 'both'].include?(missing_else_style)
-        end
-
-        def missing_else_style
-          missing_cfg = config.for_cop('Style/MissingElse')
-          missing_cfg.fetch('Enabled') ? missing_cfg['EnforcedStyle'] : nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for parentheses for empty lambda parameters. Parentheses
-      # for empty lambda parameters do not cause syntax errors, but they are
-      # redundant.
-      #
-      # @example
-      #   # bad
-      #   -> () { do_something }
-      #
-      #   # good
-      #   -> { do_something }
-      #
-      #   # good
-      #   -> (arg) { do_something(arg) }
-      class EmptyLambdaParameter < Base
-        include EmptyParameter
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Omit parentheses for the empty lambda parameters.'
-
-        def on_block(node)
-          send_node = node.send_node
-          return unless send_node.send_type?
-
-          check(node) if node.send_node.lambda_literal?
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
-
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end