rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,40 +5,102 @@ module RuboCop
     module Style
       # This cop is designed to help upgrade to Ruby 3.0. It will add the
       # comment `# frozen_string_literal: true` to the top of files to
-      # enable frozen string literals. Frozen string literals will be default
+      # enable frozen string literals. Frozen string literals may be default
       # in Ruby 3.0. The comment will be added below a shebang and encoding
       # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      #
+      # @example EnforcedStyle: when_needed (default)
+      #   # The `when_needed` style will add the frozen string literal comment
+      #   # to files only when the `TargetRubyVersion` is set to 2.3+.
+      #   # bad
+      #   module Foo
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Foo
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: always
+      #   # The `always` style will always add the frozen string literal comment
+      #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+      #   # called on a string literal.
+      #   # bad
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: never
+      #   # The `never` will enforce that the frozen string literal comment does
+      #   # not exist in a file.
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Baz
+      #     # ...
+      #   end
       class FrozenStringLiteralComment < Cop
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
 
-        MSG = 'Missing frozen string literal comment.'.freeze
+        MSG = 'Missing magic comment `# frozen_string_literal: true`.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'.freeze
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
           return if style == :when_needed && target_ruby_version < 2.3
           return if processed_source.tokens.empty?
 
-          return if frozen_string_literal_comment_exists?(processed_source)
-
-          offense(processed_source)
+          if frozen_string_literal_comment_exists?
+            check_for_no_comment(processed_source)
+          else
+            check_for_comment(processed_source)
+          end
         end
 
-        def autocorrect(_node)
+        def autocorrect(node) # rubocop:disable Metrics/MethodLength
           lambda do |corrector|
-            last_special_comment = last_special_comment(processed_source)
-            if last_special_comment.nil?
-              corrector.insert_before(processed_source.tokens[0].pos,
-                                      "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+            if style == :never
+              corrector.remove(range_with_surrounding_space(range: node.pos,
+                                                            side: :right))
             else
-              corrector.insert_after(last_special_comment.pos,
-                                     "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+              last_special_comment = last_special_comment(processed_source)
+              if last_special_comment.nil?
+                corrector.insert_before(processed_source.tokens[0].pos,
+                                        "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+              else
+                corrector.insert_after(last_special_comment.pos,
+                                       "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+              end
             end
           end
         end
 
         private
 
+        def check_for_no_comment(processed_source)
+          unnecessary_comment_offense(processed_source) if style == :never
+        end
+
+        def check_for_comment(processed_source)
+          offense(processed_source) unless style == :never
+        end
+
         def last_special_comment(processed_source)
           token_number = 0
           if processed_source.tokens[token_number].text.start_with?(SHEBANG)
@@ -55,12 +116,26 @@ module RuboCop
           token
         end
 
+        def frozen_string_literal_comment(processed_source)
+          processed_source.tokens.find do |token|
+            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          end
+        end
+
         def offense(processed_source)
           last_special_comment = last_special_comment(processed_source)
-          last_special_comment ||= processed_source.tokens[0]
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment, range, MSG)
+          add_offense(last_special_comment, location: range)
+        end
+
+        def unnecessary_comment_offense(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)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,12 +9,22 @@ module RuboCop
       # users can allow additional variables via the AllowedVariables option.
       #
       # Note that backreferences like $1, $2, etc are not global variables.
+      #
+      # @example
+      #   # bad
+      #   $foo = 2
+      #   bar = $foo + 5
+      #
+      #   # good
+      #   FOO = 2
+      #   foo = 2
+      #   $stdin.read
       class GlobalVars < Cop
         MSG = 'Do not introduce global variables.'.freeze
 
-        # predefined global variables their English aliases
+        # built-in global variables and their English aliases
         # http://www.zenspider.com/Languages/Ruby/QuickRef.html
-        BUILT_IN_VARS = %w(
+        BUILT_IN_VARS = %w[
           $: $LOAD_PATH
           $" $LOADED_FEATURES
           $0 $PROGRAM_NAME
@@ -42,7 +51,7 @@ module RuboCop
           $DEBUG $FILENAME $VERBOSE $SAFE
           $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
           $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
-        ).map(&:to_sym)
+        ].map(&:to_sym)
 
         def user_vars
           cop_config['AllowedVariables'].map(&:to_sym)
@@ -63,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, :name) unless allowed_var?(global_var)
+          add_offense(node, location: :name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -37,94 +36,55 @@ module RuboCop
       #   raise 'exception' if something
       #   ok
       class GuardClause < Cop
-        include ConfigurableEnforcedStyle
-        include IfNode
         include MinBodyLength
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
               'conditional expression.'.freeze
 
-        def_node_matcher :single_line_control_flow_exit?, <<-PATTERN
-          [{(send nil {:raise :fail} ...) return break next} single_line?]
-        PATTERN
-
         def on_def(node)
-          _, _, body = *node
+          body = node.body
+
           return unless body
 
-          if if?(body)
-            check_trailing_if(body)
-          elsif body.begin_type?
-            last_expr = body.children.last
-            check_trailing_if(last_expr) if if?(last_expr)
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type? && body.children.last.if_type?
+            check_ending_if(body.children.last)
           end
         end
+        alias on_defs on_def
 
         def on_if(node)
-          return if accept_form?(node)
-          return unless any_single_line_control_flow_exit?(node)
-          return if line_too_long_when_corrected?(node)
+          return if accepted_form?(node) || !contains_guard_clause?(node)
 
-          add_offense(node, :keyword, MSG)
+          add_offense(node, location: :keyword)
         end
 
         private
 
-        def accept_form?(node)
-          cond, body, else_body = *node
-          return true unless body && else_body
-          return true if modifier_if?(node) || ternary?(node) || elsif?(node)
-
-          cond.multiline?
-        end
-
-        def any_single_line_control_flow_exit?(node)
-          _cond, body, else_body = *node
+        def check_ending_if(node)
+          return if accepted_form?(node, true) || !min_body_length?(node)
 
-          single_line_control_flow_exit?(body) ||
-            single_line_control_flow_exit?(else_body)
+          add_offense(node, location: :keyword)
         end
 
-        def if?(node)
-          node && node.if_type?
-        end
-
-        def elsif?(node)
-          return false unless node.parent && node.parent.if_type?
-          _condition, _if_branch, else_branch = *node.parent
-          else_branch.equal?(node)
-        end
-
-        def check_trailing_if(node)
-          cond, body, else_body = *node
-
-          return if body && else_body
-          # discard modifier ifs and ternary_ops
-          return if modifier_if?(node) || ternary?(node)
-          return if cond.multiline?
-          # discard short ifs
-          return unless min_body_length?(node)
-          return if line_too_long_when_corrected?(node)
-
-          add_offense(node, :keyword, MSG)
+        def accepted_form?(node, ending = false)
+          accepted_if?(node, ending) || node.condition.multiline?
         end
 
-        def line_too_long_when_corrected?(node)
-          cond, body, else_body = *node
+        def accepted_if?(node, ending)
+          return true if node.modifier_form? || node.ternary?
 
-          if single_line_control_flow_exit?(body) || !else_body
-            line_too_long?(node, body, 'if', cond)
+          if ending
+            node.else?
           else
-            line_too_long?(node, else_body, 'unless', cond)
+            !node.else? || node.elsif?
           end
         end
 
-        def line_too_long?(node, body, keyword, condition)
-          max    = config.for_cop('Metrics/LineLength')['Max'] || 80
-          indent = node.loc.column
-          source = body && body.source || ''
-          # 2 is for spaces on left and right of keyword
-          indent + (source + keyword + condition.source).length + 2 > max
+        def contains_guard_clause?(node)
+          node.if_branch && node.if_branch.guard_clause? ||
+            node.else_branch && node.else_branch.guard_clause?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,60 +9,106 @@ module RuboCop
       # the use of the newer Ruby 1.9 syntax (when applicable).
       #
       # A separate offense is registered for each problematic pair.
+      #
+      # The supported styles are:
+      #
+      # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
+      #   all symbols for keys
+      # * hash_rockets - forces use of hash rockets for all hashes
+      # * no_mixed_keys - simply checks for hashes with mixed syntaxes
+      # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
+      #   syntax hashes
+      #
+      # @example EnforcedStyle: ruby19 (default)
+      #   # bad
+      #   {:a => 2}
+      #   {b: 1, :c => 2}
+      #
+      #   # good
+      #   {a: 2, b: 1}
+      #   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
+      #   {d: 1, 'e' => 2} # technically not forbidden
+      #
+      # @example EnforcedStyle: hash_rockets
+      #   # bad
+      #   {a: 1, b: 2}
+      #   {c: 1, 'd' => 5}
+      #
+      #   # good
+      #   {:a => 1, :b => 2}
+      #
+      # @example EnforcedStyle: no_mixed_keys
+      #   # bad
+      #   {:a => 1, b: 2}
+      #   {c: 1, 'd' => 2}
+      #
+      #   # good
+      #   {:a => 1, :b => 2}
+      #   {c: 1, d: 2}
+      #
+      # @example EnforcedStyle: ruby19_no_mixed_keys
+      #   # bad
+      #   {:a => 1, :b => 2}
+      #   {c: 2, 'd' => 3} # should just use hash rockets
+      #
+      #   # good
+      #   {a: 1, b: 2}
+      #   {:c => 3, 'd' => 4}
       class HashSyntax < Cop
         include ConfigurableEnforcedStyle
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'.freeze
-        MSG_RUBY19_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
+        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
-        @force_hash_rockets = false
-
         def on_hash(node)
-          if cop_config['UseHashRocketsWithSymbolValues']
-            pairs = *node
-            @force_hash_rockets = pairs.any? { |p| symbol_value?(p) }
-          end
+          pairs = node.pairs
 
-          if style == :hash_rockets || @force_hash_rockets
-            hash_rockets_check(node)
+          return if pairs.empty?
+
+          if style == :hash_rockets || force_hash_rockets?(pairs)
+            hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys
-            ruby19_no_mixed_keys_check(node)
+            ruby19_no_mixed_keys_check(pairs)
+          elsif style == :no_mixed_keys
+            no_mixed_keys_check(pairs)
           else
-            ruby19_check(node)
+            ruby19_check(pairs)
           end
         end
 
-        def ruby19_check(node)
-          pairs = *node
-
+        def ruby19_check(pairs)
           check(pairs, '=>', MSG_19) if sym_indices?(pairs)
         end
 
-        def hash_rockets_check(node)
-          pairs = *node
-
+        def hash_rockets_check(pairs)
           check(pairs, ':', MSG_HASH_ROCKETS)
         end
 
-        def ruby19_no_mixed_keys_check(node)
-          pairs = *node
-
-          if @force_hash_rockets
+        def ruby19_no_mixed_keys_check(pairs)
+          if force_hash_rockets?
             check(pairs, ':', MSG_HASH_ROCKETS)
           elsif sym_indices?(pairs)
             check(pairs, '=>', MSG_19)
           else
-            check(pairs, ':', MSG_RUBY19_NO_MIXED_KEYS)
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          end
+        end
+
+        def no_mixed_keys_check(pairs)
+          if !sym_indices?(pairs)
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          else
+            check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :hash_rockets || @force_hash_rockets
+            if style == :hash_rockets || force_hash_rockets?
               autocorrect_hash_rockets(corrector, node)
-            elsif style == :ruby19_no_mixed_keys
-              autocorrect_ruby19_no_mixed_keys(corrector, node)
+            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+              autocorrect_no_mixed_keys(corrector, node)
             else
               autocorrect_ruby19(corrector, node)
             end
@@ -81,22 +126,14 @@ module RuboCop
 
         private
 
-        def symbol_value?(pair)
-          _key, value = *pair
-
-          value.sym_type?
-        end
-
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         end
 
         def word_symbol_pair?(pair)
-          key, _value = *pair
-
-          return false unless key.sym_type?
+          return false unless pair.key.sym_type?
 
-          acceptable_19_syntax_symbol?(key.source)
+          acceptable_19_syntax_symbol?(pair.key.source)
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
@@ -118,10 +155,9 @@ module RuboCop
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
-            if pair.loc.operator && pair.loc.operator.is?(delim)
-              add_offense(pair,
-                          pair.source_range.begin.join(pair.loc.operator),
-                          msg) do
+            if pair.delimiter == delim
+              location = pair.source_range.begin.join(pair.loc.operator)
+              add_offense(pair, location: location, message: msg) do
                 opposite_style_detected
               end
             else
@@ -130,33 +166,47 @@ module RuboCop
           end
         end
 
-        def autocorrect_ruby19(corrector, node)
-          key = node.children.first.source_range
-          op = node.loc.operator
+        def autocorrect_ruby19(corrector, pair_node)
+          key = pair_node.key
+          op = pair_node.loc.operator
 
-          range = Parser::Source::Range.new(key.source_buffer,
-                                            key.begin_pos, op.end_pos)
-          range = range_with_surrounding_space(range, :right)
-          corrector.replace(range,
-                            range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+          range = range_between(key.source_range.begin_pos, op.end_pos)
+          range = range_with_surrounding_space(range: range, side: :right)
+
+          space = argument_without_space?(pair_node.parent) ? ' ' : ''
+
+          corrector.replace(
+            range,
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+          )
+        end
+
+        def argument_without_space?(node)
+          node.argument? &&
+            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
-        def autocorrect_hash_rockets(corrector, node)
-          key = node.children.first.source_range
-          op = node.loc.operator
+        def autocorrect_hash_rockets(corrector, pair_node)
+          key = pair_node.key.source_range
+          op = pair_node.loc.operator
 
-          corrector.insert_after(key, ' => ')
+          corrector.insert_after(key, pair_node.inverse_delimiter(true))
           corrector.insert_before(key, ':')
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(range_with_surrounding_space(range: op))
         end
 
-        def autocorrect_ruby19_no_mixed_keys(corrector, node)
-          op = node.loc.operator
-
-          if op.is?(':')
-            autocorrect_hash_rockets(corrector, node)
+        def autocorrect_no_mixed_keys(corrector, pair_node)
+          if pair_node.colon?
+            autocorrect_hash_rockets(corrector, pair_node)
           else
-            autocorrect_ruby19(corrector, node)
+            autocorrect_ruby19(corrector, pair_node)
+          end
+        end
+
+        def force_hash_rockets?(pairs = [])
+          @force_hash_rockets ||= begin
+            cop_config['UseHashRocketsWithSymbolValues'] &&
+              pairs.map(&:value).any?(&:sym_type?)
           end
         end
       end