rubocop 0.49.1 → 0.52.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # for empty lambda parameters do not cause syntax errors, but they are
+      # redundant.
+      #
+      # @example
+      #   # bad
+      #   -> () { do_something }
+      #
+      #   # good
+      #   -> { do_something }
+      #
+      #   # good
+      #   -> (arg) { do_something(arg) }
+      class EmptyLambdaParameter < Cop
+        include EmptyParameter
+
+        MSG = 'Omit parentheses for the empty lambda parameters.'.freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless send_node.send_type?
+          check(node) if node.send_node.stabby_lambda?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.send_node
+            range = range_between(
+              send_node.loc.expression.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,31 +5,43 @@ module RuboCop
     module Style
       # This cop checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
       class EmptyLiteral < Cop
         include FrozenStringLiteral
 
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
-        STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
+        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
+                  '`String.new`.'.freeze
 
-        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? :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_with_block,
-                         '(block (send (const nil :Array) :new) args _)'
+                         '(block (send (const nil? :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil :Hash) :new) args _)'
+                         '(block (send (const nil? :Hash) :new) args _)'
 
         def on_send(node)
-          add_offense(node, :expression, ARR_MSG) if offense_array_node?(node)
-
-          add_offense(node, :expression, HASH_MSG) if offense_hash_node?(node)
+          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
+          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
 
           str_node(node) do
             return if frozen_string_literals_enabled?
 
-            add_offense(node, :expression,
-                        format(STR_MSG, preferred_string_literal))
+            add_offense(node,
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
           end
         end
 
@@ -68,9 +80,8 @@ module RuboCop
             # to rewrite the arguments to wrap them in parenthesis.
             _receiver, _method_name, *args = *node.parent
 
-            Parser::Source::Range.new(node.parent.loc.expression,
-                                      args[0].loc.expression.begin_pos - 1,
-                                      args[-1].loc.expression.end_pos)
+            range_between(args[0].loc.expression.begin_pos - 1,
+                          args[-1].loc.expression.end_pos)
           else
             node.source_range
           end

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

@@ -11,18 +11,15 @@ module RuboCop
       # Note: A method definition is not considered empty if it contains
       #       comments.
       #
-      # @example
-      #
-      #   # EnforcedStyle: compact (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: compact (default)
+      #   # bad
       #   def foo(bar)
       #   end
       #
       #   def self.foo(bar)
       #   end
       #
-      #   @good
+      #   # good
       #   def foo(bar); end
       #
       #   def foo(bar)
@@ -31,36 +28,32 @@ module RuboCop
       #
       #   def self.foo(bar); end
       #
-      #   # EnforcedStyle: expanded
-      #
-      #   @bad
+      # @example EnforcedStyle: expanded
+      #   # bad
       #   def foo(bar); end
       #
       #   def self.foo(bar); end
       #
-      #   @good
+      #   # good
       #   def foo(bar)
       #   end
       #
       #   def self.foo(bar)
       #   end
       class EmptyMethod < Cop
-        include OnMethodDef
         include ConfigurableEnforcedStyle
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
                        'next line.'.freeze
 
-        def on_method_def(node, _method_name, _args, body)
-          return if body || comment_lines?(node)
-          return if compact_style? && compact?(node)
-          return if expanded_style? && expanded?(node)
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
 
-          add_offense(node, node.source_range, message)
+          add_offense(node)
         end
-
-        private
+        alias on_defs on_def
 
         def autocorrect(node)
           lambda do |corrector|
@@ -68,19 +61,30 @@ module RuboCop
           end
         end
 
-        def message
+        private
+
+        def message(_node)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end
 
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
         def corrected(node)
-          method_name, args, _body, scope = method_def_node_parts(node)
+          arguments = node.arguments? ? node.arguments.source : ''
+          scope     = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
 
-          arguments = !args.children.empty? ? args.source : ''
-          indent    = ' ' * node.loc.column
-          joint     = compact_style? ? '; ' : "\n#{indent}"
-          scope     = scope ? 'self.' : ''
+        def joint(node)
+          indent = ' ' * node.loc.column
 
-          ["def #{scope}#{method_name}#{arguments}", 'end'].join(joint)
+          compact_style? ? '; ' : "\n#{indent}"
         end
 
         def comment_lines?(node)

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

@@ -3,23 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the source file has a utf-8 encoding
-      # comment or not.
-      # Setting this check to "always" and "when_needed" makes sense only
-      # for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
-      # default source file encoding. There are three styles:
-      #
-      # when_needed - only enforce an encoding comment if there are non ASCII
-      #               characters, otherwise report an offense
-      # always - enforce encoding comment in all files
-      # never - enforce no encoding comment in all files
+      # This cop checks ensures source files have no utf-8 encoding comments.
       class Encoding < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG_MISSING = 'Missing utf-8 encoding comment.'.freeze
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
-        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
@@ -29,56 +16,26 @@ module RuboCop
           return unless (@message = offense(processed_source, line_number))
 
           range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, range, @message)
+          add_offense(range, location: range, message: @message)
         end
 
         def autocorrect(range)
-          if @message == MSG_MISSING
-            raise encoding_mismatch_message unless matching_encoding?
-
-            lambda do |corrector|
-              corrector.insert_before(range, "#{encoding}\n")
-            end
-          else
-            # Need to remove unnecessary encoding comment
-            lambda do |corrector|
-              corrector.remove(range_with_surrounding_space(range, :right))
-            end
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
           end
         end
 
         private
 
-        def encoding
-          cop_config[AUTO_CORRECT_ENCODING_COMMENT]
-        end
-
-        def matching_encoding?
-          encoding =~ ENCODING_PATTERN
-        end
-
-        def encoding_mismatch_message
-          "#{encoding} does not match #{ENCODING_PATTERN}"
-        end
-
         def offense(processed_source, line_number)
           line = processed_source[line_number]
 
-          if !encoding_present?(line) && !encoding_omitable?
-            MSG_MISSING
-          elsif encoding_present?(line) && encoding_omitable?
-            MSG_UNNECESSARY
-          end
-        end
-
-        def encoding_present?(line)
-          MagicComment.parse(line).encoding
+          MSG_UNNECESSARY if encoding_omitable?(line)
         end
 
-        def encoding_omitable?
-          return true if style == :never
-
-          style != :always && processed_source.buffer.source.ascii_only?
+        def encoding_omitable?(line)
+          line =~ ENCODING_PATTERN
         end
 
         def encoding_line_number(processed_source)

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

@@ -9,7 +9,7 @@ module RuboCop
               'Use `Kernel#at_exit` instead.'.freeze
 
         def on_postexe(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks `eval` method usage. `eval` can receive source location
+      # metadata, that are filename and line number. The metadata is used by
+      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      #
+      # @example
+      #   # bad
+      #   eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # bad
+      #   C.class_eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      class EvalWithLocation < Cop
+        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
+              'as they are used by backtraces.'.freeze
+        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
+                             'as they are used by backtraces.'.freeze
+
+        def_node_matcher :eval_without_location?, <<-PATTERN
+          {
+            (send nil? :eval ${str dstr})
+            (send nil? :eval ${str dstr} _)
+            (send nil? :eval ${str dstr} _ #special_file_keyword?)
+            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
+
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr})
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword?)
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword? _)
+          }
+        PATTERN
+
+        def_node_matcher :line_with_offset?, <<-PATTERN
+          {
+            (send #special_line_keyword? %1 (int %2))
+            (send (int %2) %1 #special_line_keyword?)
+          }
+        PATTERN
+
+        def on_send(node)
+          eval_without_location?(node) do |code|
+            if with_lineno?(node)
+              on_with_lineno(node, code)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def special_file_keyword?(node)
+          node.str_type? &&
+            node.source == '__FILE__'
+        end
+
+        def special_line_keyword?(node)
+          node.int_type? &&
+            node.source == '__LINE__'
+        end
+
+        # FIXME: It's a Style/ConditionalAssignment's false positive.
+        # rubocop:disable Style/ConditionalAssignment
+        def with_lineno?(node)
+          if node.method_name == :eval
+            node.arguments.size == 4
+          else
+            node.arguments.size == 3
+          end
+        end
+        # rubocop:enable Style/ConditionalAssignment
+
+        def message_incorrect_line(actual, sign, line_diff)
+          expected =
+            if line_diff.zero?
+              '__LINE__'
+            else
+              "__LINE__ #{sign} #{line_diff}"
+            end
+          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        end
+
+        def on_with_lineno(node, code)
+          line_node = node.arguments.last
+          lineno_range = line_node.loc.expression
+          line_diff = string_first_line(code) - lineno_range.first_line
+          if line_diff.zero?
+            add_offense_for_same_line(node, line_node)
+          else
+            add_offense_for_different_line(node, line_node, line_diff)
+          end
+        end
+
+        def string_first_line(str_node)
+          if str_node.heredoc?
+            str_node.loc.heredoc_body.first_line
+          else
+            str_node.loc.expression.first_line
+          end
+        end
+
+        def add_offense_for_same_line(node, line_node)
+          return if special_line_keyword?(line_node)
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, nil, 0)
+          )
+        end
+
+        def add_offense_for_different_line(node, line_node, line_diff)
+          sign = line_diff > 0 ? :+ : :-
+          return if line_with_offset?(line_node, sign, line_diff.abs)
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, sign, line_diff)
+          )
+        end
+      end
+    end
+  end
+end