rubocop 0.51.0 → 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,12 +5,24 @@ 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)'
@@ -28,7 +40,8 @@ module RuboCop
             return if frozen_string_literals_enabled?
 
             add_offense(node,
-                        message: format(STR_MSG, preferred_string_literal))
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
           end
         end
 
@@ -67,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,10 +11,7 @@ module RuboCop
       # Note: A method definition is not considered empty if it contains
       #       comments.
       #
-      # @example
-      #
-      #   # EnforcedStyle: compact (default)
-      #
+      # @example EnforcedStyle: compact (default)
       #   # bad
       #   def foo(bar)
       #   end
@@ -31,10 +28,7 @@ module RuboCop
       #
       #   def self.foo(bar); end
       #
-      # @example
-      #
-      #   # EnforcedStyle: expanded
-      #
+      # @example EnforcedStyle: expanded
       #   # bad
       #   def foo(bar); end
       #
@@ -61,14 +55,14 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, corrected(node))
           end
         end
 
+        private
+
         def message(_node)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end

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

@@ -21,7 +21,8 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range, :right))
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
           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

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

@@ -10,11 +10,13 @@ module RuboCop
       #
       #   # bad
       #   if x % 2 == 0
+      #   end
       #
       #   # good
       #   if x.even?
+      #   end
       class EvenOdd < Cop
-        MSG = 'Replace with `Integer#%s?`.'.freeze
+        MSG = 'Replace with `Integer#%<method>s?`.'.freeze
 
         def_node_matcher :even_odd_candidate?, <<-PATTERN
           (send
@@ -27,7 +29,7 @@ module RuboCop
         def on_send(node)
           even_odd_candidate?(node) do |_base_number, method, arg|
             replacement_method = replacement_method(arg, method)
-            add_offense(node, message: format(MSG, replacement_method))
+            add_offense(node, message: format(MSG, method: replacement_method))
           end
         end
 

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that `#module_function` is used over `extend self`.
+      #
+      # @example EnforcedStyle: module_function (default)
+      #
+      #   # bad
+      #   module Foo
+      #     extend self
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     module_function
+      #   end
+      #
+      # @example EnforcedStyle: extend_self
+      #
+      #   # bad
+      #   module Foo
+      #     module_function
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     extend self
+      #   end
+      class ExtendSelf < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%<enforced>s` instead of `%<alternate>s`.'.freeze
+
+        def_node_matcher :extend_self?, <<-PATTERN
+          (send nil? :extend (self))
+        PATTERN
+
+        def_node_matcher :module_function?, <<-PATTERN
+          (send nil? :module_function)
+        PATTERN
+
+        def_node_matcher :module_scope?, <<-PATTERN
+          {^(module ...) ^^(module _ ({begin kwbegin} ...))}
+        PATTERN
+
+        def on_send(node)
+          return unless module_scope?(node)
+          return unless module_function_enforced? && extend_self?(node) ||
+                        extend_self_enforced? && module_function?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, enforced_source)
+          end
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, enforced: enforced_source, alternate: alternate_source)
+        end
+
+        def enforced_source
+          case style
+          when :module_function then 'module_function'
+          when :extend_self     then 'extend self'
+          end
+        end
+
+        def alternate_source
+          case style
+          when :module_function then 'extend self'
+          when :extend_self     then 'module_function'
+          end
+        end
+
+        def module_function_enforced?
+          style == :module_function
+        end
+
+        def extend_self_enforced?
+          style == :extend_self
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,17 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of flip flop operator
+      #
+      # @example
+      #   # bad
+      #   (1..20).each do |x|
+      #     puts x if (x == 5) .. (x == 10)
+      #   end
+      #
+      #   # good
+      #   (1..20).each do |x|
+      #     puts x if (x >= 5) && (x <= 10)
+      #   end
       class FlipFlop < Cop
         MSG = 'Avoid the use of flip flop operators.'.freeze
 

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

@@ -10,10 +10,35 @@ module RuboCop
       # manner for all cases, so only two scenarios are considered -
       # if the first argument is a string literal and if the second
       # argument is an array literal.
+      #
+      # @example EnforcedStyle: format(default)
+      #   # bad
+      #   puts sprintf('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts format('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts sprintf('%10s', 'hoge')
+      #
+      #   # good
+      #   puts '%10s' % 'hoge'
+      #
       class FormatString < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Favor `%s` over `%s`.'.freeze
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'.freeze
 
         def_node_matcher :formatter, <<-PATTERN
         {
@@ -35,7 +60,9 @@ module RuboCop
         end
 
         def message(detected_style)
-          format(MSG, method_name(style), method_name(detected_style))
+          format(MSG,
+                 prefer: method_name(style),
+                 current: method_name(detected_style))
         end
 
         def method_name(style_name)