rubocop 0.87.0 → 0.90.0

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

@@ -73,10 +73,11 @@ module RuboCop
       #   module Bar
       #     # ...
       #   end
-      class FrozenStringLiteralComment < Cop
+      class FrozenStringLiteralComment < Base
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
                            'true`.'
@@ -85,7 +86,7 @@ module RuboCop
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.tokens.empty?
 
           case style
@@ -98,23 +99,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            case style
-            when :never
-              remove_comment(corrector, node)
-            when :always_true
-              if frozen_string_literal_specified?
-                enable_comment(corrector)
-              else
-                insert_comment(corrector)
-              end
-            else
-              insert_comment(corrector)
-            end
-          end
-        end
-
         private
 
         def ensure_no_comment(processed_source)
@@ -160,51 +144,45 @@ module RuboCop
         end
 
         def missing_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING)
+          add_offense(range, message: MSG_MISSING) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def missing_true_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING_TRUE)
+          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def unnecessary_comment_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_UNNECESSARY)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_UNNECESSARY) do |corrector|
+            remove_comment(corrector, frozen_string_literal_comment)
+          end
         end
 
         def disabled_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_DISABLED)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_DISABLED) do |corrector|
+            enable_comment(corrector)
+          end
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos,
-                                                        side: :right))
+          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
         end
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
 
-          corrector.replace(line_range(comment.line),
-                            FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
         end
 
         def insert_comment(corrector)

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # `STDOUT/STDERR/STDIN` are constants, and while you can actually
+      # reassign (possibly to redirect some stream) constants in Ruby, you'll get
+      # an interpreter warning if you do so.
+      #
+      # @example
+      #   # bad
+      #   STDOUT.puts('hello')
+      #
+      #   hash = { out: STDOUT, key: value }
+      #
+      #   def m(out = STDOUT)
+      #     out.puts('hello')
+      #   end
+      #
+      #   # good
+      #   $stdout.puts('hello')
+      #
+      #   hash = { out: $stdout, key: value }
+      #
+      #   def m(out = $stdout)
+      #     out.puts('hello')
+      #   end
+      #
+      class GlobalStdStream < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<gvar_name>s` instead of `%<const_name>s`.'
+
+        STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
+
+        def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
+          (gvasgn %1 (const nil? _))
+        PATTERN
+
+        def on_const(node)
+          const_name = node.children[1]
+          return unless STD_STREAMS.include?(const_name)
+
+          gvar_name = gvar_name(const_name).to_sym
+          return if const_to_gvar_assignment?(node.parent, gvar_name)
+
+          add_offense(node, message: message(const_name)) do |corrector|
+            corrector.replace(node, gvar_name)
+          end
+        end
+
+        private
+
+        def message(const_name)
+          format(MSG, gvar_name: gvar_name(const_name), const_name: const_name)
+        end
+
+        def gvar_name(const_name)
+          "$#{const_name.to_s.downcase}"
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   FOO = 2
       #   foo = 2
       #   $stdin.read
-      class GlobalVars < Cop
+      class GlobalVars < Base
         MSG = 'Do not introduce global variables.'
 
         # built-in global variables and their English aliases
@@ -72,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, location: :name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -17,6 +17,7 @@ module RuboCop
       #   # good
       #   def test
       #     return unless something
+      #
       #     work
       #   end
       #
@@ -46,7 +47,7 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
-      class GuardClause < Cop
+      class GuardClause < Base
         include MinBodyLength
         include StatementModifier
 
@@ -87,7 +88,7 @@ module RuboCop
         private
 
         def check_ending_if(node)
-          return if accepted_form?(node, true) || !min_body_length?(node)
+          return if accepted_form?(node, ending: true) || !min_body_length?(node)
 
           register_offense(node, 'return', opposite_keyword(node))
         end
@@ -105,9 +106,8 @@ module RuboCop
             example = "#{conditional_keyword} #{condition.source}; " \
                       "#{scope_exiting_keyword}; end"
           end
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, example: example))
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example))
         end
 
         def guard_clause_source(guard_clause)
@@ -125,7 +125,7 @@ module RuboCop
           max && node.source_range.column + example.length > max
         end
 
-        def accepted_form?(node, ending = false)
+        def accepted_form?(node, ending: false)
           accepted_if?(node, ending) || node.condition.multiline? ||
             node.parent&.assignment?
         end

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

@@ -0,0 +1,69 @@
+# 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 last_array_item?(node)
+
+          if braces_style?
+            check_braces(node)
+          else
+            check_no_braces(node)
+          end
+        end
+
+        private
+
+        def last_array_item?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.array_type? && parent.children.last.equal?(node)
+        end
+
+        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_each_methods.rb

@@ -17,8 +17,9 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
+      class HashEachMethods < Base
         include Lint::UnusedArgument
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -30,12 +31,6 @@ module RuboCop
           register_kv_offense(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            correct_key_value_each(node, corrector)
-          end
-        end
-
         private
 
         def register_kv_offense(node)
@@ -45,7 +40,9 @@ module RuboCop
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 
-            add_offense(target, location: kv_range(target), message: msg)
+            add_offense(kv_range(target), message: msg) do |corrector|
+              correct_key_value_each(target, corrector)
+            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/hash_syntax.rb

@@ -73,7 +73,7 @@ module RuboCop
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          else
+          elsif node.source.include?('=>')
             ruby19_check(pairs)
           end
         end
@@ -140,11 +140,12 @@ module RuboCop
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
 
-          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
-            # Prefer { :production? => false } over { production?: false } and
-            # similarly for other non-alnum final characters (except quotes,
-            # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
+          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
+             # Prefer { :production? => false } over { production?: false } and
+             # similarly for other non-alnum final characters (except quotes,
+             # to prefer { "x y": 1 } over { :"x y" => 1 }).
+             !/[\p{Alnum}"']\z/.match?(sym_name)
+            return false
           end
 
           # Most hash keys can be matched against a simple regex.
@@ -174,7 +175,7 @@ module RuboCop
 
           corrector.replace(
             range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
           )
 
           hash_node = pair_node.parent
@@ -199,7 +200,8 @@ module RuboCop
         def autocorrect_hash_rockets(corrector, pair_node)
           op = pair_node.loc.operator
 
-          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
+          key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          corrector.replace(pair_node.key, key_with_hash_rocket)
           corrector.remove(range_with_surrounding_space(range: op))
         end