rubocop 1.0.0 → 1.4.0

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for lambdas that always return nil, which can be replaced
+      # with an empty lambda instead.
+      #
+      # @example
+      #   # bad
+      #   -> { nil }
+      #
+      #   lambda do
+      #     next nil
+      #   end
+      #
+      #   # good
+      #   -> {}
+      #
+      #   lambda do
+      #   end
+      #
+      #   -> (x) { nil if x }
+      #
+      class NilLambda < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use an empty lambda instead of always returning nil.'
+
+        def_node_matcher :nil_return?, <<~PATTERN
+          { ({return next break} nil) (nil) }
+        PATTERN
+
+        def on_block(node)
+          return unless node.lambda?
+          return unless nil_return?(node.body)
+
+          add_offense(node) do |corrector|
+            range = if node.single_line?
+                      range_with_surrounding_space(range: node.body.loc.expression)
+                    else
+                      range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,25 +13,32 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
+      # The exploded style has an `AllowedCompactTypes` configuration
+      # option that takes an Array of exception name Strings.
+      #
       # @example EnforcedStyle: exploded (default)
       #   # bad
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #
       #   # good
-      #   raise StandardError, "message"
-      #   fail "message"
+      #   raise StandardError, 'message'
+      #   fail 'message'
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
+      #   # With `AllowedCompactTypes` set to ['MyWrappedError']
+      #   raise MyWrappedError.new(obj)
+      #   raise MyWrappedError.new(obj), 'message'
+      #
       # @example EnforcedStyle: compact
       #   # bad
-      #   raise StandardError, "message"
+      #   raise StandardError, 'message'
       #   raise RuntimeError, arg1, arg2, arg3
       #
       #   # good
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #   raise MyCustomError.new(arg1, arg2, arg3)
-      #   fail "message"
+      #   fail 'message'
       class RaiseArgs < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -102,6 +109,8 @@ module RuboCop
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
 
+          return if allowed_non_exploded_type?(first_arg)
+
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)
 
@@ -123,6 +132,12 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(type)
+        end
+
         def requires_parens?(parent)
           parent.and_type? || parent.or_type? ||
             parent.if_type? && parent.ternary?

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a redundant argument passed to certain methods.
+      #
+      # Limitations:
+      #
+      # 1. This cop matches for method names only and hence cannot tell apart
+      #    methods with same name in different classes.
+      # 2. This cop is limited to methods with single parameter.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`) are set.
+      #    That depends on the nature of the target methods, of course.
+      #
+      # Method names and their redundant arguments can be configured like this:
+      #
+      # Methods:
+      #   join: ''
+      #   split: ' '
+      #   foo: 2
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   string.split
+      #   "first second".split
+      #   A.foo
+      class RedundantArgument < Cop
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+
+        def on_send(node)
+          return unless redundant_argument?(node)
+
+          add_offense(node, message: format(MSG, arg: node.arguments.first.source))
+        end
+
+        private
+
+        def redundant_argument?(node)
+          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
+          return false if redundant_argument.nil?
+
+          node.arguments.first == redundant_argument
+        end
+
+        def redundant_arg_for_method(method_name)
+          return nil unless cop_config['Methods'].key?(method_name)
+
+          @mem ||= {}
+          @mem[method_name] ||=
+            begin
+              arg = cop_config['Methods'].fetch(method_name)
+              buffer = Parser::Source::Buffer.new('(string)', 1)
+              buffer.source = arg.inspect
+              builder = RuboCop::AST::Builder.new
+              Parser::CurrentRuby.new(builder).parse(buffer)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,12 @@ module RuboCop
       #   # good
       #   r = /\s/
       #
+      #   # bad
+      #   r = %r{/[b]}
+      #
+      #   # good
+      #   r = %r{/b}
+      #
       #   # good
       #   r = /[ab]/
       class RedundantRegexpCharacterClass < Base
@@ -48,7 +54,7 @@ module RuboCop
           each_single_element_character_class(node) do |char_class|
             next unless redundant_single_element_character_class?(node, char_class)
 
-            yield node.loc.begin.adjust(begin_pos: 1 + char_class.ts, end_pos: char_class.te)
+            yield char_class.loc.body
           end
         end
 

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

@@ -82,7 +82,7 @@ module RuboCop
 
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+            yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
 
             if expr.type == :set
               char_class_depth + (event == :enter ? 1 : -1)

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

@@ -70,6 +70,9 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
+          # Make the obvious check first
+          return unless @processed_source.raw_source.include?(';')
+
           each_semicolon { |line, column| convention_on(line, column, true) }
         end
 

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where classes with only class methods can be
+      # replaced with a module. Classes should be used only when it makes sense to create
+      # instances out of them.
+      #
+      # This cop is marked as unsafe, because it is possible that this class is a parent
+      # for some other subclass, monkey-patched with instance methods or
+      # a dummy instance is instantiated from it somewhere.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def self.some_method
+      #       # body omitted
+      #     end
+      #
+      #     def self.some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     module_function
+      #
+      #     def some_method
+      #       # body omitted
+      #     end
+      #
+      #     def some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good - has instance method
+      #   class SomeClass
+      #     def instance_method; end
+      #     def self.class_method; end
+      #   end
+      #
+      class StaticClass < Base
+        include VisibilityHelp
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+
+          add_offense(class_node) if class_convertible_to_module?(class_node)
+        end
+
+        private
+
+        def class_convertible_to_module?(class_node)
+          nodes = class_elements(class_node)
+          return false if nodes.empty?
+
+          nodes.all? do |node|
+            node_visibility(node) == :public &&
+              node.defs_type? ||
+              sclass_convertible_to_module?(node) ||
+              node.equals_asgn? ||
+              extend_call?(node)
+          end
+        end
+
+        def extend_call?(node)
+          node.send_type? && node.method?(:extend)
+        end
+
+        def sclass_convertible_to_module?(node)
+          return false unless node.sclass_type?
+
+          class_elements(node).all? do |child|
+            node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def
+            []
+          elsif class_def.begin_type?
+            class_def.children
+          else
+            [class_def]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of shorthand-style swapping of 2 variables.
+      # Its autocorrection is marked as unsafe, because it can erroneously remove
+      # the temporary variable which is used later.
+      #
+      # @example
+      #   # bad
+      #   tmp = x
+      #   x = y
+      #   y = tmp
+      #
+      #   # good
+      #   x, y = y, x
+      #
+      class SwapValues < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace this and assignments at lines %<x_line>d '\
+          'and %<y_line>d with `%<replacement>s`.'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
+
+        def on_asgn(node)
+          return if allowed_assignment?(node)
+
+          tmp_assign = node
+          x_assign, y_assign = *node.right_siblings.take(2)
+          return unless x_assign && y_assign && swapping_values?(tmp_assign, x_assign, y_assign)
+
+          add_offense(node, message: message(x_assign, y_assign)) do |corrector|
+            range = correction_range(tmp_assign, y_assign)
+            corrector.replace(range, replacement(x_assign))
+          end
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def allowed_assignment?(node)
+          node.parent&.mlhs_type? || node.parent&.shorthand_asgn?
+        end
+
+        def swapping_values?(tmp_assign, x_assign, y_assign)
+          simple_assignment?(tmp_assign) &&
+            simple_assignment?(x_assign) &&
+            simple_assignment?(y_assign) &&
+            lhs(x_assign) == rhs(tmp_assign) &&
+            lhs(y_assign) == rhs(x_assign) &&
+            rhs(y_assign) == lhs(tmp_assign)
+        end
+
+        def simple_assignment?(node)
+          SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
+        end
+
+        def message(x_assign, y_assign)
+          format(
+            MSG,
+            x_line: x_assign.first_line,
+            y_line: y_assign.first_line,
+            replacement: replacement(x_assign)
+          )
+        end
+
+        def replacement(x_assign)
+          x = lhs(x_assign)
+          y = rhs(x_assign)
+          "#{x}, #{y} = #{y}, #{x}"
+        end
+
+        def lhs(node)
+          case node.type
+          when :casgn
+            namespace, name, = *node
+            if namespace
+              "#{namespace.const_name}::#{name}"
+            else
+              name.to_s
+            end
+          else
+            node.children[0].to_s
+          end
+        end
+
+        def rhs(node)
+          case node.type
+          when :casgn
+            node.children[2].source
+          else
+            node.children[1].source
+          end
+        end
+
+        def correction_range(tmp_assign, y_assign)
+          range_by_whole_lines(
+            range_between(tmp_assign.source_range.begin_pos, y_assign.source_range.end_pos)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -24,6 +24,15 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
+      #
+      # @example
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
       class WhileUntilModifier < Base
         include StatementModifier
         extend AutoCorrector