rubocop 1.9.1 → 1.22.3

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

@@ -27,11 +27,19 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method array_node(node)
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+
+        # @!method hash_node(node)
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+
+        # @!method str_node(node)
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
-        def_node_matcher :array_with_block,
-                         '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method array_with_block(node)
+        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
@@ -54,7 +62,7 @@ module RuboCop
             ARR_MSG
           elsif offense_hash_node?(node)
             HASH_MSG
-          elsif str_node(node) && !frozen_string_literals_enabled?
+          elsif str_node(node) && !frozen_strings?
             format(STR_MSG, prefer: preferred_string_literal)
           end
         end
@@ -75,20 +83,17 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) &&
-            !parentheses?(node.parent)
+          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
-          if hash_node(node) &&
-             first_argument_unparenthesized?(node)
+          if hash_node(node) && first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].source_range.begin_pos - 1,
-                          args[-1].source_range.end_pos)
+            range_between(args[0].source_range.begin_pos - 1, args[-1].source_range.end_pos)
           else
             node.source_range
           end
@@ -120,6 +125,13 @@ module RuboCop
             end
           end
         end
+
+        def frozen_strings?
+          return true if frozen_string_literals_enabled?
+
+          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
+          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+        end
       end
     end
   end

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

@@ -45,16 +45,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'
-        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
-                       'next line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, corrected(node))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
         end
         alias on_defs on_def
 
@@ -65,8 +62,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) ||
-            expanded_style? && expanded?(node)
+          (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
         def corrected(node)

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

@@ -13,38 +13,49 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        MSG = 'Unnecessary utf-8 encoding comment.'
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
         SHEBANG = '#!'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          line_number = encoding_line_number(processed_source)
-          return unless (@message = offense(processed_source, line_number))
+          comments.each do |line_number, comment|
+            next unless offense?(comment)
 
-          range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, message: @message) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: range, side: :right))
+            register_offense(line_number, comment)
           end
         end
 
         private
 
-        def offense(processed_source, line_number)
-          line = processed_source[line_number]
+        def comments
+          processed_source.lines.each.with_index.with_object({}) do |(line, line_number), comments|
+            next if line.start_with?(SHEBANG)
 
-          MSG_UNNECESSARY if encoding_omitable?(line)
+            comment = MagicComment.parse(line)
+            return comments unless comment.valid?
+
+            comments[line_number + 1] = comment
+          end
         end
 
-        def encoding_omitable?(line)
-          ENCODING_PATTERN.match?(line)
+        def offense?(comment)
+          comment.encoding_specified? && comment.encoding.casecmp('utf-8').zero?
         end
 
-        def encoding_line_number(processed_source)
-          line_number = 0
-          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
-          line_number
+        def register_offense(line_number, comment)
+          range = processed_source.buffer.line_range(line_number)
+
+          add_offense(range) do |corrector|
+            text = comment.without(:encoding)
+
+            if text.blank?
+              corrector.remove(range_with_surrounding_space(range: range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
         end
       end
     end

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

@@ -15,8 +15,7 @@ module RuboCop
       class EndBlock < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of `END` blocks. ' \
-              'Use `Kernel#at_exit` instead.'
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
           add_offense(node.loc.keyword) do |corrector|

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

@@ -11,6 +11,7 @@ module RuboCop
       # Other method definition types are not considered by this cop.
       #
       # The supported styles are:
+      #
       # * allow_single_line (default) - only single line endless method definitions are allowed.
       # * allow_always - all endless method definitions are allowed.
       # * disallow - all endless method definitions are disallowed.
@@ -78,9 +79,7 @@ module RuboCop
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) do |corrector|
-            correct_to_multiline(corrector, node)
-          end
+          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
 
         def correct_to_multiline(corrector, node)

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

@@ -12,6 +12,11 @@ module RuboCop
       # The cop also checks that the line number given relative to `__LINE__` is
       # correct.
       #
+      # This cop will autocorrect incorrect or missing filename and line number
+      # values. However, if `eval` is called without a binding argument, the cop
+      # will not attempt to automatically add a binding, or add filename and
+      # line values.
+      #
       # @example
       #   # bad
       #   eval <<-RUBY
@@ -36,7 +41,21 @@ module RuboCop
       #     def do_something
       #     end
       #   RUBY
+      #
+      # This cop works only when a string literal is given as a code string.
+      # No offense is reported if a string variable is given as below:
+      #
+      # @example
+      #   # not checked
+      #   code = <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #   eval code
+      #
       class EvalWithLocation < Base
+        extend AutoCorrector
+
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
         MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
@@ -46,10 +65,12 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
+        # @!method valid_eval_receiver?(node)
         def_node_matcher :valid_eval_receiver?, <<~PATTERN
           { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
+        # @!method line_with_offset?(node, sign, num)
         def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
@@ -66,31 +87,36 @@ module RuboCop
           code = node.arguments.first
           return unless code && (code.str_type? || code.dstr_type?)
 
+          check_location(node, code)
+        end
+
+        private
+
+        def check_location(node, code)
           file, line = file_and_line(node)
 
           if line
             check_file(node, file)
             check_line(node, code)
+          elsif file
+            check_file(node, file)
+            add_offense_for_missing_line(node, code)
           else
-            register_offense(node)
+            add_offense_for_missing_location(node, code)
           end
         end
 
-        private
-
-        def register_offense(node)
+        def register_offense(node, &block)
           msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
-          add_offense(node, message: msg)
+          add_offense(node, message: msg, &block)
         end
 
         def special_file_keyword?(node)
-          node.str_type? &&
-            node.source == '__FILE__'
+          node.str_type? && node.source == '__FILE__'
         end
 
         def special_line_keyword?(node)
-          node.int_type? &&
-            node.source == '__LINE__'
+          node.int_type? && node.source == '__LINE__'
         end
 
         def file_and_line(node)
@@ -98,6 +124,10 @@ module RuboCop
           [node.arguments[base], node.arguments[base + 1]]
         end
 
+        def with_binding?(node)
+          node.method?(:eval) ? node.arguments.size >= 2 : true
+        end
+
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
@@ -109,18 +139,16 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(method_name, actual, sign, line_diff)
-          expected =
-            if line_diff.zero?
-              '__LINE__'
-            else
-              "__LINE__ #{sign} #{line_diff}"
-            end
+        def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
+          expected = expected_line(sign, line_diff)
+          message = format(MSG_INCORRECT_LINE,
+                           method_name: method_name,
+                           actual: line_node.source,
+                           expected: expected)
 
-          format(MSG_INCORRECT_LINE,
-                 method_name: method_name,
-                 actual: actual.source,
-                 expected: expected)
+          add_offense(line_node.loc.expression, message: message) do |corrector|
+            corrector.replace(line_node, expected)
+          end
         end
 
         def check_file(node, file_node)
@@ -131,13 +159,14 @@ module RuboCop
                            expected: '__FILE__',
                            actual: file_node.source)
 
-          add_offense(file_node, message: message)
+          add_offense(file_node, message: message) do |corrector|
+            corrector.replace(file_node, '__FILE__')
+          end
         end
 
         def check_line(node, code)
           line_node = node.arguments.last
-          lineno_range = line_node.loc.expression
-          line_diff = string_first_line(code) - lineno_range.first_line
+          line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
           else
@@ -145,6 +174,10 @@ module RuboCop
           end
         end
 
+        def line_difference(line_node, code)
+          string_first_line(code) - line_node.loc.expression.first_line
+        end
+
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
@@ -156,20 +189,47 @@ module RuboCop
         def add_offense_for_same_line(node, line_node)
           return if special_line_keyword?(line_node)
 
-          add_offense(
-            line_node.loc.expression,
-            message: message_incorrect_line(node.method_name, line_node, nil, 0)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, nil, 0)
         end
 
         def add_offense_for_different_line(node, line_node, line_diff)
           sign = line_diff.positive? ? :+ : :-
           return if line_with_offset?(line_node, sign, line_diff.abs)
 
-          add_offense(
-            line_node.loc.expression,
-            message: message_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
+        end
+
+        def expected_line(sign, line_diff)
+          if line_diff.zero?
+            '__LINE__'
+          else
+            "__LINE__ #{sign} #{line_diff.abs}"
+          end
+        end
+
+        def add_offense_for_missing_line(node, code)
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+          end
+        end
+
+        def add_offense_for_missing_location(node, code)
+          if node.method?(:eval) && !with_binding?(node)
+            register_offense(node)
+            return
+          end
+
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.last_argument.source_range.end, ", __FILE__, #{line_str}")
+          end
+        end
+
+        def missing_line(node, code)
+          line_diff = line_difference(node.arguments.last, code)
+          sign = line_diff.positive? ? :+ : :-
+          expected_line(sign, line_diff)
         end
       end
     end

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

@@ -21,6 +21,7 @@ module RuboCop
         MSG = 'Replace with `Integer#%<method>s?`.'
         RESTRICT_ON_SEND = %i[== !=].freeze
 
+        # @!method even_odd_candidate?(node)
         def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))

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

@@ -54,6 +54,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[expand_path].freeze
 
+        # @!method file_expand_path(node)
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const {nil? cbase} :File) :expand_path
@@ -61,6 +62,7 @@ module RuboCop
             $_)
         PATTERN
 
+        # @!method pathname_parent_expand_path(node)
         def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
@@ -68,6 +70,7 @@ module RuboCop
                 $_) :parent) :expand_path)
         PATTERN
 
+        # @!method pathname_new_parent_expand_path(node)
         def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send
@@ -82,9 +85,7 @@ module RuboCop
           elsif (default_dir = pathname_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 
-            add_offense(node, message: PATHNAME_MSG) do |corrector|
-              autocorrect(corrector, node)
-            end
+            add_offense(node, message: PATHNAME_MSG) { |corrector| autocorrect(corrector, node) }
           elsif (default_dir = pathname_new_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 

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

@@ -45,6 +45,7 @@ module RuboCop
         MSG = 'Consider using explicit block argument in the '\
               "surrounding method's signature over `yield`."
 
+        # @!method yielding_block?(node)
         def_node_matcher :yielding_block?, <<~PATTERN
           (block $_ (args $...) (yield $...))
         PATTERN
@@ -66,17 +67,27 @@ module RuboCop
             # so this can cause crashes in haml_lint
             return unless def_node
 
+            block_name = extract_block_name(def_node)
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
-              add_block_argument(send_node, corrector)
-              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+              add_block_argument(send_node, corrector, block_name)
+              add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
             end
           end
         end
 
         private
 
+        def extract_block_name(def_node)
+          if def_node.block_argument?
+            def_node.arguments.last.name
+          else
+            'block'
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -90,25 +101,47 @@ module RuboCop
           end
         end
 
-        def add_block_argument(node, corrector)
+        def add_block_argument(node, corrector, block_name)
           if node.arguments?
-            last_arg = node.arguments.last
-            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-            replacement = ' &block'
-            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
-            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.call_type?
-            corrector.insert_after(node, '(&block)')
+            insert_argument(node, corrector, block_name)
+          elsif empty_arguments?(node)
+            corrector.replace(node.arguments, "(&#{block_name})")
+          elsif call_like?(node)
+            correct_call_node(node, corrector, block_name)
           else
-            corrector.insert_after(node.loc.name, '(&block)')
+            corrector.insert_after(node.loc.name, "(&#{block_name})")
           end
         end
 
+        def empty_arguments?(node)
+          # Is there an arguments node with only parentheses?
+          node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
+        end
+
+        def call_like?(node)
+          node.call_type? || node.zsuper_type? || node.super_type?
+        end
+
+        def insert_argument(node, corrector, block_name)
+          last_arg = node.arguments.last
+          arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+          replacement = " &#{block_name}"
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+        end
+
+        def correct_call_node(node, corrector, block_name)
+          corrector.insert_after(node, "(&#{block_name})")
+          return unless node.parenthesized?
+
+          args_begin = Util.args_begin(node)
+          args_end = Util.args_end(node)
+          range = range_between(args_begin.begin_pos, args_end.end_pos)
+          corrector.remove(range)
+        end
+
         def block_body_range(block_node, send_node)
-          range_between(
-            send_node.loc.expression.end_pos,
-            block_node.loc.end.end_pos
-          )
+          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -5,13 +5,12 @@ module RuboCop
     module Style
       # This cop enforces consistency when using exponential notation
       # for numbers in the code (eg 1.2e4). Different styles are supported:
-      # * `scientific` which enforces a mantissa between 1 (inclusive)
-      #                and 10 (exclusive).
-      # * `engineering` which enforces the exponent to be a multiple of 3
-      #                 and the mantissa to be between 0.1 (inclusive)
-      #                 and 10 (exclusive).
-      # * `integral` which enforces the mantissa to always be a whole number
-      #              without trailing zeroes.
+      #
+      # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
+      #   to be between 0.1 (inclusive) and 10 (exclusive).
+      # * `integral` which enforces the mantissa to always be a whole number without
+      #   trailing zeroes.
       #
       # @example EnforcedStyle: scientific (default)
       #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).

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

@@ -7,8 +7,16 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
-      # This cop is marked as unsafe, because if operand variable is a string object
-      # then `.to_f` will be removed and an error will occur.
+      # @safety
+      #   This cop is unsafe, because if the operand variable is a string object
+      #   then `.to_f` will be removed and an error will occur.
+      #
+      #   [source,ruby]
+      #   ----
+      #   a = '1.2'
+      #   b = '3.4'
+      #   a.to_f / b.to_f # Both `to_f` calls are required here
+      #   ----
       #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad
@@ -55,15 +63,19 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[/].freeze
 
+        # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN
+        # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ _)
         PATTERN
+        # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ (send _ :to_f))
         PATTERN
+        # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
           {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
         PATTERN

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

@@ -42,6 +42,7 @@ module RuboCop
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
+        # @!method formatter(node)
         def_node_matcher :formatter, <<~PATTERN
           {
             (send nil? ${:sprintf :format} _ _ ...)
@@ -50,6 +51,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
           (send {str dstr} :% {send_type? lvar_type?})
         PATTERN

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

@@ -89,6 +89,7 @@ module RuboCop
 
         private
 
+        # @!method format_string_in_typical_context?(node)
         def_node_matcher :format_string_in_typical_context?, <<~PATTERN
           {
             ^(send _ {:format :sprintf :printf} %0 ...)
@@ -145,10 +146,7 @@ module RuboCop
             next if seq.percent?
 
             detected_style = seq.style
-            token = contents.begin.adjust(
-              begin_pos: seq.begin_pos,
-              end_pos:   seq.end_pos
-            )
+            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
 
             yield(detected_style, token)
           end