rubocop 0.87.1 → 0.88.0

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

@@ -75,11 +75,11 @@ module RuboCop
 
         # rubocop:disable Style/FormatStringToken
         def message_text(style)
-          case style
-          when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template then 'template tokens (like `%{foo}`)'
-          when :unannotated then 'unannotated tokens (like `%s`)'
-          end
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
         end
         # rubocop:enable Style/FormatStringToken
 

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for presence or absence of braces around hash literal as a last
+      # array item depending on configuration.
+      #
+      # @example EnforcedStyle: braces (default)
+      #   # bad
+      #   [1, 2, one: 1, two: 2]
+      #
+      #   # good
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      # @example EnforcedStyle: no_braces
+      #   # bad
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      #   # good
+      #   [1, 2, one: 1, two: 2]
+      #
+      class HashAsLastArrayItem < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        def on_hash(node)
+          return unless node.parent&.array_type?
+
+          if braces_style?
+            check_braces(node)
+          else
+            check_no_braces(node)
+          end
+        end
+
+        private
+
+        def check_braces(node)
+          return if node.braces?
+
+          add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
+            corrector.wrap(node, '{', '}')
+          end
+        end
+
+        def check_no_braces(node)
+          return unless node.braces?
+
+          add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def braces_style?
+          style == :braces
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where `case-when` represents a simple 1:1
+      # mapping and can be replaced with a hash lookup.
+      #
+      # @example MinBranchesCount: 3 (default)
+      #   # bad
+      #   case country
+      #   when 'europe'
+      #     'http://eu.example.com'
+      #   when 'america'
+      #     'http://us.example.com'
+      #   when 'australia'
+      #     'http://au.example.com'
+      #   end
+      #
+      #   # good
+      #   SITES = {
+      #     'europe'    => 'http://eu.example.com',
+      #     'america'   => 'http://us.example.com',
+      #     'australia' => 'http://au.example.com'
+      #   }
+      #   SITES[country]
+      #
+      # @example MinBranchesCount: 4
+      #   # good
+      #   case country
+      #   when 'europe'
+      #     'http://eu.example.com'
+      #   when 'america'
+      #     'http://us.example.com'
+      #   when 'australia'
+      #     'http://au.example.com'
+      #   end
+      #
+      class HashLikeCase < Base
+        MSG = 'Consider replacing `case-when` with a hash lookup.'
+
+        def_node_matcher :hash_like_case?, <<~PATTERN
+          (case
+            _
+            (when
+              ${str_type? sym_type?}
+              $[!nil? recursive_basic_literal?])+ nil?)
+        PATTERN
+
+        def on_case(node)
+          return if node.when_branches.size < min_branches_count
+
+          hash_like_case?(node) do |condition_nodes, body_nodes|
+            if nodes_of_same_type?(condition_nodes) &&
+               nodes_of_same_type?(body_nodes)
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def nodes_of_same_type?(nodes)
+          nodes.all? { |node| node.type == nodes.first.type }
+        end
+
+        def min_branches_count
+          length = cop_config['MinBranchesCount'] || 3
+          return length if length.is_a?(Integer) && length.positive?
+
+          raise 'MinBranchesCount needs to be a positive integer!'
+        end
+      end
+    end
+  end
+end

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

@@ -41,11 +41,8 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
-        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
-                              gvasgn ivasgn masgn].freeze
-
         def on_if(node)
-          msg = if eligible_node?(node)
+          msg = if single_line_as_modifier?(node)
                   MSG_USE_MODIFIER unless named_capture_in_condition?(node)
                 elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
@@ -125,13 +122,15 @@ module RuboCop
           node.condition.match_with_lvasgn_type?
         end
 
-        def eligible_node?(node)
-          !non_eligible_if?(node) && !node.chained? &&
-            !node.nested_conditional? && single_line_as_modifier?(node)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) ||
+            node.chained? ||
+            node.nested_conditional? ||
+            super
         end
 
-        def non_eligible_if?(node)
-          node.ternary? || node.modifier_form? || node.elsif? || node.else?
+        def non_simple_if_unless?(node)
+          node.ternary? || node.elsif? || node.else?
         end
 
         def another_statement_on_same_line?(node)
@@ -153,8 +152,9 @@ module RuboCop
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression
           # (due to the low operator precedence of modifier-if)
-          return false if node.parent.nil?
-          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+          parent = node.parent
+          return false if parent.nil?
+          return true if parent.assignment? || parent.operator_keyword?
 
           node.parent.send_type? && !node.parent.parenthesized?
         end

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

@@ -119,17 +119,7 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
-
-          if empty_else_cop_enabled?
-            if empty_else_style == :empty
-              add_offense(node)
-            elsif empty_else_style == :nil
-              add_offense(node)
-            end
-          end
-
-          add_offense(node)
+          add_offense(node) unless node.else?
         end
 
         def message(node)

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

@@ -54,15 +54,14 @@ module RuboCop
         }.freeze
 
         def on_send(node)
+          numeric, replacement = check(node)
+          return unless numeric
+
           return if ignored_method?(node.method_name) ||
                     node.each_ancestor(:send, :block).any? do |ancestor|
                       ignored_method?(ancestor.method_name)
                     end
 
-          numeric, replacement = check(node)
-
-          return unless numeric
-
           add_offense(node,
                       message: format(MSG,
                                       prefer: replacement,

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

@@ -30,7 +30,7 @@ module RuboCop
         def on_masgn(node)
           lhs, rhs = *node
           lhs_elements = *lhs
-          rhs_elements = [*rhs].compact # edge case for one constant
+          rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
@@ -42,7 +42,7 @@ module RuboCop
           lambda do |corrector|
             left, right = *node
             left_elements = *left
-            right_elements = [*right].compact
+            right_elements = Array(right).compact
             order = find_valid_order(left_elements, right_elements)
             correction = assignment_corrector(node, order)
 
@@ -69,7 +69,7 @@ module RuboCop
 
         def allowed_rhs?(node)
           # Edge case for one constant
-          elements = [*node].compact
+          elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
           !node.array_type? ||

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

@@ -102,7 +102,7 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s) }
+            .any? { |s| delimiters_regexp.match?(s.scrub) }
         end
 
         def string_source(node)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous `.rb` extension in
+      # the filename provided to `require` and `require_relative`.
+      #
+      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      #       and so on to the name until found. If the file named cannot be found,
+      #       a `LoadError` will be raised.
+      #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`
+      #       if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`,
+      #       but that seems harmless.
+      #
+      # @example
+      #   # bad
+      #   require 'foo.rb'
+      #   require_relative '../foo.rb'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'foo.so'
+      #   require_relative '../foo'
+      #   require_relative '../foo.so'
+      #
+      class RedundantFileExtensionInRequire < Cop
+        MSG = 'Redundant `.rb` file extension detected.'
+
+        def_node_matcher :require_call?, <<~PATTERN
+          (send nil? {:require :require_relative} $str_type?)
+        PATTERN
+
+        def on_send(node)
+          require_call?(node) do |name_node|
+            add_offense(name_node) if name_node.value.end_with?('.rb')
+          end
+        end
+
+        def autocorrect(node)
+          correction = node.value.sub(/\.rb\z/, '')
+
+          lambda do |corrector|
+            corrector.replace(node, "'#{correction}'")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -135,9 +135,10 @@ module RuboCop
         end
 
         def suffix(sorter)
-          if sorter == :sort
+          case sorter
+          when :sort
             ''
-          elsif sorter == :sort_by
+          when :sort_by
             '_by'
           end
         end

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

@@ -34,9 +34,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if style == :require_parentheses
+          case style
+          when :require_parentheses
             missing_parentheses_corrector(node)
-          elsif style == :require_no_parentheses
+          when :require_no_parentheses
             unwanted_parentheses_corrector(node)
           end
         end

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

@@ -33,8 +33,8 @@ module RuboCop
       #     end
       #   end
       #
-      class TrailingMethodEndStatement < Cop
-        include Alignment
+      class TrailingMethodEndStatement < Base
+        extend AutoCorrector
 
         MSG = 'Place the end statement of a multi-line method on ' \
               'its own line.'
@@ -42,13 +42,11 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node, location: end_token(node).pos)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            break_line_before_end(node, corrector)
-            remove_semicolon(node, corrector)
+          add_offense(node.loc.end) do |corrector|
+            corrector.insert_before(
+              node.loc.end,
+              "\n" + ' ' * node.loc.keyword.column
+            )
           end
         end
 
@@ -60,30 +58,9 @@ module RuboCop
             body_and_end_on_same_line?(node)
         end
 
-        def end_token(node)
-          tokens(node).reverse.find(&:end?)
-        end
-
         def body_and_end_on_same_line?(node)
-          end_token(node).line == token_before_end(node).line
-        end
-
-        def token_before_end(node)
-          i = tokens(node).index(end_token(node))
-          tokens(node)[i - 1]
-        end
-
-        def break_line_before_end(node, corrector)
-          corrector.insert_before(
-            end_token(node).pos,
-            "\n" + ' ' * configured_indentation_width
-          )
-        end
-
-        def remove_semicolon(node, corrector)
-          return unless token_before_end(node).semicolon?
-
-          corrector.remove(token_before_end(node).pos)
+          last_child = node.children.last
+          last_child.loc.last_line == node.loc.end.last_line
         end
       end
     end

data/lib/rubocop/cop/variable_force/variable.rb

@@ -42,10 +42,10 @@ module RuboCop
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branches = Set.new
+          consumed_branches = nil
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branches.include?(assignment.branch)
+            next if consumed_branches&.include?(assignment.branch)
 
             assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
 
@@ -58,7 +58,9 @@ module RuboCop
 
             break if !assignment.branch || assignment.branch == reference.branch
 
-            consumed_branches << assignment.branch unless assignment.branch.may_run_incompletely?
+            unless assignment.branch.may_run_incompletely?
+              (consumed_branches ||= Set.new) << assignment.branch
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity

data/lib/rubocop/file_finder.rb

@@ -9,33 +9,33 @@ module RuboCop
       @root_level = level
     end
 
-    def self.root_level?(path)
-      @root_level == path.to_s
+    def self.root_level?(path, stop_dir)
+      (@root_level || stop_dir) == path.to_s
     end
 
-    def find_file_upwards(filename, start_dir)
-      traverse_files_upwards(filename, start_dir) do |file|
+    def find_file_upwards(filename, start_dir, stop_dir = nil)
+      traverse_files_upwards(filename, start_dir, stop_dir) do |file|
         # minimize iteration for performance
         return file if file
       end
     end
 
-    def find_files_upwards(filename, start_dir)
-      files = []
-      traverse_files_upwards(filename, start_dir) do |file|
-        files << file
+    def find_last_file_upwards(filename, start_dir, stop_dir = nil)
+      last_file = nil
+      traverse_files_upwards(filename, start_dir, stop_dir) do |file|
+        last_file = file
       end
-      files
+      last_file
     end
 
     private
 
-    def traverse_files_upwards(filename, start_dir)
+    def traverse_files_upwards(filename, start_dir, stop_dir)
       Pathname.new(start_dir).expand_path.ascend do |dir|
-        break if FileFinder.root_level?(dir)
-
         file = dir + filename
         yield(file.to_s) if file.exist?
+
+        break if FileFinder.root_level?(dir, stop_dir)
       end
     end
   end