rbhint 0.85.1.rc2 → 0.87.1.rc1

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

@@ -50,7 +50,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const nil? :Date) _))
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         def_node_matcher :to_datetime?, <<~PATTERN

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

@@ -21,8 +21,8 @@ module RuboCop
               "file's directory."
 
         def_node_matcher :dir_replacement?, <<~PATTERN
-          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
-           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
         PATTERN
 
         def on_send(node)

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

@@ -25,13 +25,13 @@ module RuboCop
         STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
                   '`String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
+                         '(block (send (const {nil? cbase} :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
 
         def on_send(node)
           add_offense(node, message: ARR_MSG)  if offense_array_node?(node)

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

@@ -53,7 +53,7 @@ module RuboCop
 
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
-            (const nil? :File) :expand_path
+            (const {nil? cbase} :File) :expand_path
             $_
             $_)
         PATTERN
@@ -69,7 +69,7 @@ module RuboCop
           (send
             (send
               (send
-                (const nil? :Pathname) :new
+                (const {nil? cbase} :Pathname) :new
                 $_) :parent) :expand_path)
         PATTERN
 

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

@@ -60,6 +60,11 @@ module RuboCop
       #
       class ExponentialNotation < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa in [1, 10[.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
 
         def on_float(node)
           add_offense(node) if offense?(node)
@@ -104,14 +109,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :scientific
-            'Use a mantissa in [1, 10[.'
-          when :engineering
-            'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.'
-          when :integral
-            'Use an integer as mantissa, without trailing zero.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -41,6 +41,12 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          left_coerce: 'Prefer using `.to_f` on the left side.',
+          right_coerce: 'Prefer using `.to_f` on the right side.',
+          single_coerce: 'Prefer using `.to_f` on one side only.',
+          fdiv: 'Prefer using `fdiv` for float divisions.'
+        }.freeze
 
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
@@ -77,16 +83,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :left_coerce
-            'Prefer using `.to_f` on the left side.'
-          when :right_coerce
-            'Prefer using `.to_f` on the right side.'
-          when :single_coerce
-            'Prefer using `.to_f` on one side only.'
-          when :fdiv
-            'Prefer using `fdiv` for float divisions.'
-          end
+          MESSAGES[style]
         end
       end
     end

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/if_unless_modifier_of_if_unless.rb

@@ -33,6 +33,18 @@ module RuboCop
           add_offense(node, location: :keyword,
                             message: format(MSG, keyword: node.keyword))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            keyword = node.if? ? 'if' : 'unless'
+
+            corrector.replace(node, <<~RUBY.chop)
+              #{keyword} #{node.condition.source}
+              #{node.if_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   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/multiline_block_chain.rb

@@ -8,11 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #   Thread.list.find_all do |t|
+      #   # bad
+      #   Thread.list.select do |t|
       #     t.alive?
       #   end.map do |t|
       #     t.object_id
       #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
       class MultilineBlockChain < Cop
         include RangeHelp
 

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

@@ -150,14 +150,14 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
-            (send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})
             (send _ {:== :=== :!= :<= :>= :< :>} _)
-            (send (const nil? :ENV) :[] _)
-            (or (send (const nil? :ENV) :[] _) _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -14,6 +14,7 @@ module RuboCop
       #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
@@ -54,13 +55,9 @@ module RuboCop
 
         def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            allowed_methods.include?(send_node.method_name.to_s) &&
+            allowed_method?(send_node.method_name) &&
             send_node.arguments.one?
         end
-
-        def allowed_methods
-          cop_config['AllowedMethods'] || []
-        end
       end
     end
   end

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,