rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/style/optional_boolean_parameter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where keyword arguments can be used instead of
+      # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behavior.
+      #
+      # @example
+      #   # bad
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
+      #   # bad - common hack before keyword args were introduced
+      #   def some_method(options = {})
+      #     bar = options.fetch(:bar, false)
+      #     puts bar
+      #   end
+      #
+      #   # good
+      #   def some_method(bar: false)
+      #     puts bar
+      #   end
+      #
+      # @example AllowedMethods: ['some_method']
+      #   # good
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
+      class OptionalBooleanParameter < Base
+        include AllowedMethods
+
+        MSG = 'Prefer keyword arguments for arguments with a boolean default value; ' \
+              'use `%<replacement>s` instead of `%<original>s`.'
+
+        def on_def(node)
+          return if allowed_method?(node.method_name)
+
+          node.arguments.each do |arg|
+            next unless arg.optarg_type?
+
+            add_offense(arg, message: format_message(arg)) if arg.default_value.boolean_type?
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def format_message(argument)
+          replacement = "#{argument.name}: #{argument.default_value.source}"
+
+          format(MSG, original: argument.source, replacement: replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/or_assignment.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for potential usage of the `||=` operator.
+      #
+      # @example
+      #   # bad
+      #   name = name ? name : 'Bozhidar'
+      #
+      #   # bad
+      #   name = if name
+      #            name
+      #          else
+      #            'Bozhidar'
+      #          end
+      #
+      #   # bad
+      #   unless name
+      #     name = 'Bozhidar'
+      #   end
+      #
+      #   # bad
+      #   name = 'Bozhidar' unless name
+      #
+      #   # good - set name to 'Bozhidar', only if it's nil or false
+      #   name ||= 'Bozhidar'
+      class OrAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use the double pipe equals operator `||=` instead.'
+
+        # @!method ternary_assignment?(node)
+        def_node_matcher :ternary_assignment?, <<~PATTERN
+          ({lvasgn ivasgn cvasgn gvasgn} _var
+            (if
+              ({lvar ivar cvar gvar} _var)
+              ({lvar ivar cvar gvar} _var)
+              $_))
+        PATTERN
+
+        # @!method unless_assignment?(node)
+        def_node_matcher :unless_assignment?, <<~PATTERN
+          (if
+            ({lvar ivar cvar gvar} _var) nil?
+            ({lvasgn ivasgn cvasgn gvasgn} _var
+              _))
+        PATTERN
+
+        def on_if(node)
+          return unless unless_assignment?(node)
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def on_lvasgn(node)
+          return unless (else_branch = ternary_assignment?(node))
+          return if else_branch.if_type?
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        private
+
+        def autocorrect(corrector, node)
+          if ternary_assignment?(node)
+            variable, default = take_variable_and_default_from_ternary(node)
+          else
+            variable, default = take_variable_and_default_from_unless(node)
+          end
+
+          corrector.replace(node, "#{variable} ||= #{default.source}")
+        end
+
+        def take_variable_and_default_from_ternary(node)
+          [node.name, node.expression.else_branch]
+        end
+
+        def take_variable_and_default_from_unless(node)
+          if node.if_branch
+            [node.if_branch.name, node.if_branch.expression]
+          else
+            [node.else_branch.name, node.else_branch.expression]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/parallel_assignment.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for simple usages of parallel assignment.
+      # This will only complain when the number of variables
+      # being assigned matched the number of assigning variables.
+      #
+      # @example
+      #   # bad
+      #   a, b, c = 1, 2, 3
+      #   a, b, c = [1, 2, 3]
+      #
+      #   # good
+      #   one, two = *foo
+      #   a, b = foo()
+      #   a, b = b, a
+      #
+      #   a = 1
+      #   b = 2
+      #   c = 3
+      class ParallelAssignment < Base
+        include RescueNode
+        extend AutoCorrector
+
+        MSG = 'Do not use parallel assignment.'
+
+        def on_masgn(node) # rubocop:disable Metrics/AbcSize
+          rhs = node.rhs
+          rhs = rhs.body if rhs.rescue_type?
+          rhs_elements = Array(rhs).compact # edge case for one constant
+
+          return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
+                    allowed_masign?(node.assignments, rhs_elements)
+
+          range = node.source_range.begin.join(rhs.source_range.end)
+
+          add_offense(range) do |corrector|
+            autocorrect(corrector, node, rhs)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, rhs)
+          order = find_valid_order(node.assignments, Array(rhs).compact)
+          correction = assignment_corrector(node, rhs, order)
+
+          corrector.replace(correction.correction_range, correction.correction)
+        end
+
+        def allowed_masign?(lhs_elements, rhs_elements)
+          lhs_elements.size != rhs_elements.size ||
+            !find_valid_order(lhs_elements,
+                              add_self_to_getters(rhs_elements))
+        end
+
+        def allowed_lhs?(elements)
+          # Account for edge cases using one variable with a comma
+          # E.g.: `foo, = *bar`
+          elements.one? || elements.any?(&:splat_type?)
+        end
+
+        def allowed_rhs?(node)
+          # Edge case for one constant
+          elements = Array(node).compact
+
+          # Account for edge case of `Constant::CONSTANT`
+          !node.array_type? || elements.any?(&:splat_type?)
+        end
+
+        def assignment_corrector(node, rhs, order)
+          if node.parent&.rescue_type?
+            _assignment, modifier = *node.parent
+          else
+            _assignment, modifier = *rhs.parent
+          end
+
+          if modifier_statement?(node.parent)
+            ModifierCorrector.new(node, rhs, modifier, config, order)
+          elsif rescue_modifier?(modifier)
+            RescueCorrector.new(node, rhs, modifier, config, order)
+          else
+            GenericCorrector.new(node, rhs, modifier, config, order)
+          end
+        end
+
+        def find_valid_order(left_elements, right_elements)
+          # arrange left_elements in an order such that no corresponding right
+          # element refers to a left element earlier in the sequence
+          # this can be done using an algorithm called a "topological sort"
+          # fortunately for us, Ruby's stdlib contains an implementation
+          assignments = left_elements.zip(right_elements)
+
+          begin
+            AssignmentSorter.new(assignments).tsort
+          rescue TSort::Cyclic
+            nil
+          end
+        end
+
+        # Converts (send nil :something) nodes to (send (:self) :something).
+        # This makes the sorting algorithm work for expressions such as
+        # `self.a, self.b = b, a`.
+        def add_self_to_getters(right_elements)
+          right_elements.map do |e|
+            implicit_self_getter?(e) { |var| s(:send, s(:self), var) } || e
+          end
+        end
+
+        # @!method implicit_self_getter?(node)
+        def_node_matcher :implicit_self_getter?, '(send nil? $_)'
+
+        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
+        # Newer versions have a better API, but that doesn't help us
+        class AssignmentSorter
+          include TSort
+          extend RuboCop::NodePattern::Macros
+
+          # @!method var_name(node)
+          def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
+
+          # @!method uses_var?(node)
+          def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
+
+          # @!method matching_calls(node, receiver, method_name)
+          def_node_search :matching_calls, '(send %1 %2 $...)'
+
+          def initialize(assignments)
+            @assignments = assignments
+          end
+
+          def tsort_each_node(...)
+            @assignments.each(...)
+          end
+
+          def tsort_each_child(assignment)
+            # yield all the assignments which must come after `assignment`
+            # (due to dependencies on the previous value of the assigned var)
+            my_lhs, _my_rhs = *assignment
+
+            @assignments.each do |other|
+              _other_lhs, other_rhs = *other
+
+              next unless dependency?(my_lhs, other_rhs)
+
+              yield other
+            end
+          end
+
+          def dependency?(lhs, rhs)
+            uses_var?(rhs, var_name(lhs)) ||
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
+          end
+
+          # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
+          # Does `rhs` access the same value which is assigned by `lhs`?
+          def accesses?(rhs, lhs)
+            if lhs.method?(:[]=)
+              # FIXME: Workaround `rubocop:disable` comment for JRuby.
+              # rubocop:disable Performance/RedundantEqualityComparisonBlock
+              matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
+              # rubocop:enable Performance/RedundantEqualityComparisonBlock
+            else
+              access_method = lhs.method_name.to_s.chop.to_sym
+              matching_calls(rhs, lhs.receiver, access_method).any?
+            end
+          end
+        end
+
+        def modifier_statement?(node)
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
+        end
+
+        # An internal class for correcting parallel assignment
+        class GenericCorrector
+          include Alignment
+
+          attr_reader :node, :rhs, :rescue_result, :config
+
+          def initialize(node, rhs, modifier, config, new_elements)
+            @node = node
+            @rhs = rhs
+            _, _, @rescue_result = *modifier
+            @config = config
+            @new_elements = new_elements
+          end
+
+          def correction
+            assignment.join("\n#{offset(node)}")
+          end
+
+          def correction_range
+            node.source_range
+          end
+
+          protected
+
+          def assignment
+            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs, rhs.loc)}" }
+          end
+
+          private
+
+          def source(node, loc)
+            # __FILE__ is treated as a StrNode but has no begin
+            if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
+              "'#{node.source}'"
+            elsif node.sym_type? && loc.begin.nil?
+              ":#{node.source}"
+            else
+              node.source
+            end
+          end
+
+          def extract_sources(node)
+            node.children.map(&:source)
+          end
+
+          def cop_config
+            @config.for_cop('Style/ParallelAssignment')
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # protected by rescue
+        class RescueCorrector < GenericCorrector
+          def correction
+            # If the parallel assignment uses a rescue modifier and it is the
+            # only contents of a method, then we want to make use of the
+            # implicit begin
+            if rhs.parent.parent.parent&.def_type?
+              super + def_correction(rescue_result)
+            else
+              begin_correction(rescue_result)
+            end
+          end
+
+          def correction_range
+            rhs.parent.parent.source_range
+          end
+
+          private
+
+          def def_correction(rescue_result)
+            "\nrescue" \
+              "\n#{offset(node)}#{rescue_result.source}"
+          end
+
+          def begin_correction(rescue_result)
+            "begin\n" \
+              "#{indentation(node)}" \
+              "#{assignment.join("\n#{indentation(node)}")}" \
+              "\n#{offset(node)}rescue\n" \
+              "#{indentation(node)}#{rescue_result.source}" \
+              "\n#{offset(node)}end"
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # guarded by if, unless, while, or until
+        class ModifierCorrector < GenericCorrector
+          def correction
+            parent = node.parent
+
+            "#{modifier_range(parent).source}\n" \
+              "#{indentation(node)}" \
+              "#{assignment.join("\n#{indentation(node)}")}" \
+              "\n#{offset(node)}end"
+          end
+
+          def correction_range
+            node.parent.source_range
+          end
+
+          private
+
+          def modifier_range(node)
+            node.loc.keyword.join(node.source_range.end)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/parentheses_around_condition.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the presence of superfluous parentheses around the
+      # condition of if/unless/while/until.
+      #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
+      # @example
+      #   # bad
+      #   x += 1 while (x < 10)
+      #   foo unless (bar || baz)
+      #
+      #   if (x > 10)
+      #   elsif (x < 3)
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #   foo unless bar || baz
+      #
+      #   if x > 10
+      #   elsif x < 3
+      #   end
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo unless (bar = baz)
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo unless (bar = baz)
+      #
+      # @example AllowInMultilineConditions: false (default)
+      #   # bad
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      #   # good
+      #    if x > 10 &&
+      #       y > 10
+      #    end
+      #
+      # @example AllowInMultilineConditions: true
+      #   # good
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      class ParenthesesAroundCondition < Base
+        include SafeAssignment
+        include Parentheses
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_if(node)
+          return if node.ternary?
+
+          process_control_op(node)
+        end
+
+        def on_while(node)
+          process_control_op(node)
+        end
+        alias on_until on_while
+
+        private
+
+        # @!method control_op_condition(node)
+        def_node_matcher :control_op_condition, <<~PATTERN
+          (begin $_ $...)
+        PATTERN
+
+        def process_control_op(node)
+          cond = node.condition
+
+          control_op_condition(cond) do |first_child, rest_children|
+            return if require_parentheses?(node, first_child)
+            return if semicolon_separated_expressions?(first_child, rest_children)
+            return if modifier_op?(first_child)
+            return if parens_allowed?(cond)
+
+            message = message(cond)
+            add_offense(cond, message: message) do |corrector|
+              ParenthesesCorrector.correct(corrector, cond)
+            end
+          end
+        end
+
+        def require_parentheses?(node, condition_body)
+          return false unless node.type?(:while, :until)
+          return false unless condition_body.any_block_type?
+
+          condition_body.send_node.block_literal? && condition_body.keywords?
+        end
+
+        def semicolon_separated_expressions?(first_exp, rest_exps)
+          return false unless (second_exp = rest_exps.first)
+
+          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
+
+          range.source.include?(';')
+        end
+
+        def modifier_op?(node)
+          return false if node.if_type? && node.ternary?
+          return true if node.rescue_type?
+
+          node.basic_conditional? && node.modifier_form?
+        end
+
+        def message(node)
+          kw = node.parent.keyword
+          article = kw == 'while' ? 'a' : 'an'
+          "Don't use parentheses around the condition of #{article} `#{kw}`."
+        end
+
+        def parens_allowed?(node)
+          parens_required?(node) ||
+            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (node.multiline? && allow_multiline_conditions?)
+        end
+
+        def allow_multiline_conditions?
+          cop_config['AllowInMultilineConditions']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/percent_literal_delimiters.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the consistent usage of `%`-literal delimiters.
+      #
+      # Specify the 'default' key to set all preferred delimiters at once. You
+      # can continue to specify individual preferred delimiters to override the
+      # default.
+      #
+      # @example
+      #   # Style/PercentLiteralDelimiters:
+      #   #   PreferredDelimiters:
+      #   #     default: '[]'
+      #   #     '%i':    '()'
+      #
+      #   # good
+      #   %w[alpha beta] + %i(gamma delta)
+      #
+      #   # bad
+      #   %W(alpha #{beta})
+      #
+      #   # bad
+      #   %I(alpha beta)
+      class PercentLiteralDelimiters < Base
+        include PercentLiteral
+        extend AutoCorrector
+
+        def on_array(node)
+          process(node, '%w', '%W', '%i', '%I')
+        end
+
+        def on_regexp(node)
+          process(node, '%r')
+        end
+
+        def on_str(node)
+          process(node, '%', '%Q', '%q')
+        end
+        alias on_dstr on_str
+
+        def on_sym(node)
+          process(node, '%s')
+        end
+
+        def on_xstr(node)
+          process(node, '%x')
+        end
+
+        private
+
+        def on_percent_literal(node)
+          type = type(node)
+          return if uses_preferred_delimiter?(node, type) ||
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
+
+          add_offense(node, message: message(type)) do |corrector|
+            opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
+
+            corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
+            corrector.replace(node.loc.end, closing_delimiter)
+          end
+        end
+
+        def message(type)
+          delimiters = preferred_delimiters_for(type)
+
+          "`#{type}`-literals should be delimited by " \
+            "`#{delimiters[0]}` and `#{delimiters[1]}`."
+        end
+
+        def preferred_delimiters_for(type)
+          PreferredDelimiters.new(type, @config, nil).delimiters
+        end
+
+        def uses_preferred_delimiter?(node, type)
+          preferred_delimiters_for(type)[0] == begin_source(node)[-1]
+        end
+
+        def contains_preferred_delimiter?(node, type)
+          contains_delimiter?(node, preferred_delimiters_for(type))
+        end
+
+        def include_same_character_as_used_for_delimiter?(node, type)
+          return false unless %w[%w %i].include?(type)
+
+          used_delimiters = matchpairs(begin_source(node)[-1])
+          contains_delimiter?(node, used_delimiters)
+        end
+
+        def contains_delimiter?(node, delimiters)
+          delimiters_regexp = Regexp.union(delimiters)
+
+          node.children.filter_map { |n| string_source(n) }.any?(delimiters_regexp)
+        end
+
+        def string_source(node)
+          if node.is_a?(String)
+            node.scrub
+          elsif node.respond_to?(:type) && node.type?(:str, :sym)
+            node.source
+          end
+        end
+
+        def matchpairs(begin_delimiter)
+          {
+            '(' => %w[( )],
+            '[' => %w[[ ]],
+            '{' => %w[{ }],
+            '<' => %w[< >]
+          }.fetch(begin_delimiter, [begin_delimiter])
+        end
+      end
+    end
+  end
+end