rubocop 1.3.0 → 1.5.0

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

@@ -17,26 +17,61 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Do not use if x; Use the ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
+        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return unless node.else_branch
+          return if node.parent&.if_type?
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, correct_to_ternary(node))
+          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+
+          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
+            corrector.replace(node, autocorrect(node))
           end
         end
 
         private
 
-        def correct_to_ternary(node)
+        def autocorrect(node)
+          return correct_elsif(node) if node.else_branch.if_type?
+
           else_code = node.else_branch ? node.else_branch.source : 'nil'
 
           "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
         end
+
+        def correct_elsif(node)
+          <<~RUBY.chop
+            if #{node.condition.source}
+              #{node.if_branch.source}
+            #{build_else_branch(node.else_branch).chop}
+            end
+          RUBY
+        end
+
+        def build_else_branch(second_condition)
+          result = <<~RUBY
+            elsif #{second_condition.condition.source}
+              #{second_condition.if_branch.source}
+          RUBY
+
+          if second_condition.else_branch
+            result += if second_condition.else_branch.if_type?
+                        build_else_branch(second_condition.else_branch)
+                      else
+                        <<~RUBY
+                          else
+                            #{second_condition.else_branch.source}
+                        RUBY
+                      end
+          end
+
+          result
+        end
       end
     end
   end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -74,7 +74,7 @@ module RuboCop
             parent &&
               (logical_operator?(parent) ||
               parent.send_type? &&
-              parent.arguments.any?(&method(:logical_operator?)))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -110,7 +110,7 @@ module RuboCop
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
             end
           end
 

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

@@ -21,21 +21,30 @@ module RuboCop
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
+          return if default_argument?(node)
           return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
           add_offense(offense_range(node)) do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
         end
 
-        private
-
         def ineligible_node?(node)
           node.camel_case_method? || node.implicit_call? || node.prefix_not?
         end
 
+        def default_argument?(node)
+          node.parent&.optarg_type?
+        end
+
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?

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

@@ -35,6 +35,8 @@ module RuboCop
 
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
 
+        def_node_matcher :double_negation?, '(send (send _ :!) :!)'
+
         def self.autocorrect_incompatible_with
           [Style::InverseMethods, Style::Not]
         end
@@ -47,7 +49,7 @@ module RuboCop
           return unless if_else?(node)
 
           condition = node.condition
-          return unless negated_condition?(condition)
+          return if double_negation?(condition) || !negated_condition?(condition)
 
           type = node.ternary? ? 'ternary' : 'if-else'
           add_offense(node, message: format(MSG, type: type)) do |corrector|

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

@@ -27,12 +27,13 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
-      class NumericLiterals < Cop
+      class NumericLiterals < Base
         # The parameter is called MinDigits (meaning the minimum number of
         # digits for which an offense can be registered), but essentially it's
         # a Max parameter (the maximum number of something that's allowed).
         include ConfigurableMax
         include IntegerNode
+        extend AutoCorrector
 
         MSG = 'Use underscores(_) as thousands separator and ' \
               'separate every 3 digits with them.'
@@ -46,12 +47,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, format_number(node))
-          end
-        end
-
         private
 
         def max_parameter_name
@@ -67,11 +62,19 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node) { self.max = int.size + 1 }
+            return unless (self.max = int.size + 1)
+
+            register_offense(node)
           when /\d{4}/, short_group_regex
-            add_offense(node) do
-              self.config_to_allow_offenses = { 'Enabled' => false }
-            end
+            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
+
+            register_offense(node)
+          end
+        end
+
+        def register_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, format_number(node))
           end
         end
 

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

@@ -0,0 +1,75 @@
+# 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 < Base
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+
+        def on_send(node)
+          return if node.receiver.nil?
+          return if node.arguments.count != 1
+          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_condition.rb

@@ -131,7 +131,8 @@ module RuboCop
         end
 
         def without_argument_parentheses_method?(node)
-          node.send_type? && !node.arguments.empty? && !node.parenthesized?
+          node.send_type? &&
+            !node.arguments.empty? && !node.parenthesized? && !node.operator_method?
         end
       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.start_index, !char_class_depth.zero?) if expr.type == :escape
+            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
 
             if expr.type == :set
               char_class_depth + (event == :enter ? 1 : -1)

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

@@ -33,17 +33,22 @@ module RuboCop
       #   end
       #
       class SoleNestedConditional < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Consider merging nested conditions into '\
               'outer `%<conditional_type>s` conditions.'
 
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 
-          branch = node.if_branch
-          return unless offending_branch?(branch)
+          if_branch = node.if_branch
+          return unless offending_branch?(if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
-          add_offense(branch.loc.keyword, message: message)
+          add_offense(if_branch.loc.keyword, message: message) do |corrector|
+            autocorrect(corrector, node, if_branch)
+          end
         end
 
         private
@@ -57,6 +62,47 @@ module RuboCop
             !(branch.modifier_form? && allow_modifier?)
         end
 
+        def autocorrect(corrector, node, if_branch)
+          if node.unless?
+            corrector.replace(node.loc.keyword, 'if')
+            corrector.insert_before(node.condition, '!')
+          end
+
+          and_operator = if_branch.unless? ? ' && !' : ' && '
+          if if_branch.modifier_form?
+            correct_for_gurad_condition_style(corrector, node, if_branch, and_operator)
+          else
+            correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+          end
+
+          correct_for_comment(corrector, node, if_branch)
+        end
+
+        def correct_for_gurad_condition_style(corrector, node, if_branch, and_operator)
+          corrector.insert_after(node.condition, "#{and_operator}#{if_branch.condition.source}")
+
+          range = range_between(
+            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
+          )
+          corrector.remove(range_with_surrounding_space(range: range, newlines: false))
+          corrector.remove(if_branch.loc.keyword)
+        end
+
+        def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+          range = range_between(
+            node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
+          )
+          corrector.replace(range, and_operator)
+          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+        end
+
+        def correct_for_comment(corrector, node, if_branch)
+          comments = processed_source.comments_before_line(if_branch.source_range.line)
+          comment_text = comments.map(&:text).join("\n") << "\n"
+
+          corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
+        end
+
         def allow_modifier?
           cop_config['AllowModifier']
         end

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

@@ -8,6 +8,7 @@ module RuboCop
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
+      #   something.map { _1.upcase }
       #
       #   # good
       #   something.map(&:upcase)
@@ -22,9 +23,9 @@ module RuboCop
 
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
         def_node_matcher :symbol_proc?, <<~PATTERN
-          (block
+          ({block numblock}
             ${(send ...) (super ...) zsuper}
-            $(args (arg _var))
+            ${(args (arg _)) %Integer}
             (send (lvar _var) $_))
         PATTERN
 
@@ -40,11 +41,12 @@ module RuboCop
             return if proc_node?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
             return if ignored_method?(dispatch_node.method_name)
-            return if destructuring_block_argument?(arguments_node)
+            return if node.block_type? && destructuring_block_argument?(arguments_node)
 
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
+        alias on_numblock on_block
 
         def destructuring_block_argument?(argument_node)
           argument_node.one? && argument_node.source.include?(',')

data/lib/rubocop/cop/util.rb

@@ -53,7 +53,7 @@ module RuboCop
       end
 
       def on_node(syms, sexp, excludes = [], &block)
-        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
+        return to_enum(:on_node, syms, sexp, excludes) unless block
 
         yield sexp if Array(syms).include?(sexp.type)
         return if Array(excludes).include?(sexp.type)

data/lib/rubocop/cop/variable_force/branch.rb

@@ -78,7 +78,7 @@ module RuboCop
           end
 
           def each_ancestor(include_self: false, &block)
-            return to_enum(__method__, include_self: include_self) unless block_given?
+            return to_enum(__method__, include_self: include_self) unless block
 
             yield self if include_self
             scan_ancestors(&block)

data/lib/rubocop/cop/variable_force/scope.rb

@@ -61,7 +61,7 @@ module RuboCop
         end
 
         def each_node(&block)
-          return to_enum(__method__) unless block_given?
+          return to_enum(__method__) unless block
 
           yield node if naked_top_level?
           scan_node(node, &block)

data/lib/rubocop/core_ext/hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Extensions to the core Hash class
+class Hash
+  unless method_defined?(:slice)
+    # Adds `Hash#slice` for Ruby 2.4.
+    # Returns a hash containing a subset of keys. If a given key is not
+    # in the hash, it will not be returned.
+    #
+    # @return [Hash] hash containing only the keys given.
+    #
+    # @example
+    #   { one: 1, two: 2 }.slice(:two, :three) #=> { two: 2 }
+    def slice(*keys)
+      h = {}
+      keys.each { |k| h[k] = self[k] if key?(k) }
+      h
+    end
+  end
+end

data/lib/rubocop/ext/regexp_node.rb

@@ -19,18 +19,13 @@ module RuboCop
         super
 
         str = with_interpolations_blanked
-        begin
-          @parsed_tree = Regexp::Parser.parse(str, options: options)
+        @parsed_tree = begin
+          Regexp::Parser.parse(str, options: options)
         rescue StandardError
-          @parsed_tree = nil
-        else
-          origin = loc.begin.end
-          source = @parsed_tree.to_s
-          @parsed_tree.each_expression(true) do |e|
-            e.origin = origin
-            e.source = source
-          end
+          nil
         end
+        origin = loc.begin.end
+        @parsed_tree&.each_expression(true) { |e| e.origin = origin }
       end
 
       def each_capture(named: ANY)