rubocop 0.75.1 → 0.80.0

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

@@ -54,33 +54,42 @@ module RuboCop
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
 
         def on_def(node)
-          return unless node.body
-
           check_branch(node.body)
         end
         alias on_defs on_def
 
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def autocorrect(node)
           lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
-            end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
             end
-            return_kw = range_with_surrounding_space(range: node.loc.keyword,
-                                                     side: :right)
-            corrector.remove(return_kw)
           end
         end
 
         private
 
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node.source_range, 'nil')
+        end
+
+        def correct_with_arguments(return_node, corrector)
+          if return_node.arguments.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
+                                                 side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
@@ -93,13 +102,6 @@ module RuboCop
           corrector.insert_after(kids.last, '}')
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
         # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
@@ -148,12 +150,8 @@ module RuboCop
         end
 
         def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
-
-          return unless last_expr&.return_type?
-
-          check_return_node(last_expr)
+          last_expr = node.children.last
+          check_branch(last_expr)
         end
 
         def allow_multiple_return_values?

data/lib/rubocop/cop/style/{unneeded_sort.rb → redundant_sort.rb}

@@ -49,13 +49,13 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class UnneededSort < Cop
+      class RedundantSort < Cop
         include RangeHelp
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        def_node_matcher :unneeded_sort?, <<~MATCHER
+        def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
             (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
@@ -72,7 +72,7 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          unneeded_sort?(node) do |sort_node, sorter, accessor|
+          redundant_sort?(node) do |sort_node, sorter, accessor|
             range = range_between(
               sort_node.loc.selector.begin_pos,
               node.loc.expression.end_pos
@@ -87,7 +87,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          sort_node, sorter, accessor = unneeded_sort?(node)
+          sort_node, sorter, accessor = redundant_sort?(node)
 
           lambda do |corrector|
             # Remove accessor, e.g. `first` or `[-1]`.
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def base(accessor, arg)
-          if accessor == :first || (arg&.zero?)
+          if accessor == :first || arg&.zero?
             'min'
           elsif accessor == :last || arg == -1
             'max'

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

@@ -112,9 +112,8 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _check, body, = node.node_parts
-          _checked_variable, matching_receiver, = extract_parts(node)
-          method_call, = matching_receiver.parent
+          body = node.node_parts[1]
+          method_call = method_call(node)
 
           lambda do |corrector|
             corrector.remove(begin_range(node, body))
@@ -129,25 +128,29 @@ module RuboCop
         private
 
         def handle_comments(corrector, node, method_call)
-          return if processed_source.comments.empty?
+          comments = comments(node)
+          return if comments.empty?
 
           corrector.insert_before(method_call.loc.expression,
-                                  "#{comments(node).join("\n")}\n")
+                                  "#{comments.map(&:text).join("\n")}\n")
         end
 
         def comments(node)
-          comments = processed_source.comments.select do |comment|
-            comment.loc.first_line >= node.loc.first_line &&
-              comment.loc.last_line <= node.loc.last_line
+          processed_source.comments.select do |comment|
+            comment.loc.first_line > node.loc.first_line &&
+              comment.loc.last_line < node.loc.last_line
           end
-
-          comments.map(&:text)
         end
 
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
 
+        def method_call(node)
+          _checked_variable, matching_receiver, = extract_parts(node)
+          matching_receiver.parent
+        end
+
         def extract_parts(node)
           case node.type
           when :if

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

@@ -47,8 +47,8 @@ module RuboCop
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
 
           lines.each do |line, expr_on_line|
             # Every line with more than one expression on it is a

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

@@ -160,17 +160,15 @@ module RuboCop
         end
 
         def format_message(english, regular, global)
-          if !regular.empty? && !english.empty?
+          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)
-          elsif !regular.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          elsif !english.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          else
-            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end
         end
 

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

@@ -11,8 +11,8 @@ module RuboCop
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
-      # cop. For example, a `MinSize of `3` will not enforce a style on an array
-      # of 2 or fewer elements.
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
       #
       # @example EnforcedStyle: percent (default)
       #   # good

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

@@ -162,7 +162,7 @@ module RuboCop
         # `RedundantParentheses` cop is enabled, it will cause an infinite loop
         # as they compete to add and remove the parentheses respectively.
         def infinite_loop?
-          require_parentheses? &&
+          (require_parentheses? || require_parentheses_when_complex?) &&
             redundant_parentheses_enabled?
         end
 

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

@@ -68,28 +68,6 @@ module RuboCop
         def self.autocorrect_incompatible_with
           [Layout::HeredocArgumentClosingParenthesis]
         end
-
-        private
-
-        def avoid_autocorrect?(args)
-          args.last.hash_type? && args.last.braces? &&
-            braces_will_be_removed?(args)
-        end
-
-        # Returns true if running with --auto-correct would remove the braces
-        # of the last argument.
-        def braces_will_be_removed?(args)
-          brace_config = config.for_cop('Style/BracesAroundHashParameters')
-          return false unless brace_config.fetch('Enabled')
-          return false if brace_config['AutoCorrect'] == false
-
-          brace_style = brace_config['EnforcedStyle']
-          return true if brace_style == 'no_braces'
-
-          return false unless brace_style == 'context_dependent'
-
-          args.one? || !args[-2].hash_type?
-        end
       end
     end
   end

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

@@ -20,8 +20,14 @@ module RuboCop
       #   a, *b, _ = foo()
       #   # => The correction `a, *b, = foo()` is a syntax error
       #
-      #   # good if AllowNamedUnderscoreVariables is true
+      # @example AllowNamedUnderscoreVariables: true (default)
+      #   # good
       #   a, b, _something = foo()
+      #
+      # @example AllowNamedUnderscoreVariables: false
+      #   # bad
+      #   a, b, _something = foo()
+      #
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
         include RangeHelp

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

@@ -60,7 +60,7 @@ module RuboCop
             when :module
               return true
             else
-              return true if pnode.method_name == :instance_eval
+              return true if pnode.method?(:instance_eval)
             end
           end
           false
@@ -95,9 +95,9 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:to_sym) + [:initialize]
+        def allowed_methods
+          allowed_methods = cop_config['AllowedMethods']
+          Array(allowed_methods).map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -124,7 +124,7 @@ module RuboCop
         PATTERN
 
         def allowed_method?(node)
-          whitelist.include?(node.method_name) ||
+          allowed_methods.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end
 

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Checks for while and until statements that would fit on one line
       # if written as a modifier while/until. The maximum line length is
-      # configured in the `Metrics/LineLength` cop.
+      # configured in the `Layout/LineLength` cop.
       #
       # @example
       #   # bad

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

@@ -67,9 +67,16 @@ module RuboCop
 
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
 
+        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+
+        def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
+          (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
+        PATTERN
+
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node)
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node)
         end
@@ -135,6 +142,14 @@ module RuboCop
         def noncommutative_operator?(node)
           NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
       end
     end
   end

data/lib/rubocop/cop/team.rb

@@ -86,6 +86,11 @@ module RuboCop
         raise e.cause
       end
 
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
       private
 
       def offenses(processed_source)

data/lib/rubocop/cop/util.rb

@@ -9,7 +9,7 @@ module RuboCop
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
       LITERAL_REGEX =
-        /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/.freeze
+        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
 
       module_function
 

data/lib/rubocop/cop/utils/format_string.rb

@@ -44,15 +44,15 @@ module RuboCop
           attr_reader :begin_pos, :end_pos
           attr_reader :flags, :width, :precision, :name, :type
 
-          def initialize(string, **opts)
-            @source = string
-            @begin_pos = opts[:begin_pos]
-            @end_pos = opts[:end_pos]
-            @flags = opts[:flags]
-            @width = opts[:width]
-            @precision = opts[:precision]
-            @name = opts[:name]
-            @type = opts[:type]
+          def initialize(match)
+            @source = match[0]
+            @begin_pos = match.begin(0)
+            @end_pos = match.end(0)
+            @flags = match[:flags].to_s + match[:more_flags].to_s
+            @width = match[:width]
+            @precision = match[:precision]
+            @name = match[:name]
+            @type = match[:type]
           end
 
           def percent?
@@ -109,16 +109,8 @@ module RuboCop
 
         def parse
           @source.to_enum(:scan, SEQUENCE).map do
-            match = Regexp.last_match
             FormatSequence.new(
-              match[0],
-              begin_pos: match.begin(0),
-              end_pos: match.end(0),
-              flags: match[:flags].to_s + match[:more_flags].to_s,
-              width: match[:width],
-              precision: match[:precision],
-              name: match[:name],
-              type: match[:type]
+              Regexp.last_match
             )
           end
         end

data/lib/rubocop/cop/variable_force.rb

@@ -190,7 +190,10 @@ module RuboCop
       end
 
       def regexp_captured_names(node)
-        regexp_string = node.children[0].children[0] || ''
+        regexp_string = node.children.select(&:str_type?).map do |child|
+          child.children.first
+        end.join || ''
+
         regexp = Regexp.new(regexp_string)
 
         regexp.named_captures.keys
@@ -284,11 +287,7 @@ module RuboCop
       def process_scope(node)
         if TWISTED_SCOPE_TYPES.include?(node.type)
           # See the comment at the end of file for this behavior.
-          twisted_nodes = [node.children[0]]
-          twisted_nodes << node.children[1] if node.class_type?
-          twisted_nodes.compact!
-
-          twisted_nodes.each do |twisted_node|
+          twisted_nodes(node).each do |twisted_node|
             process_node(twisted_node)
             scanned_nodes << twisted_node
           end
@@ -298,6 +297,12 @@ module RuboCop
         skip_children!
       end
 
+      def twisted_nodes(node)
+        twisted_nodes = [node.children[0]]
+        twisted_nodes << node.children[1] if node.class_type?
+        twisted_nodes.compact
+      end
+
       def process_send(node)
         _receiver, method_name, args = *node
         return unless method_name == :binding