rubocop 0.26.1 → 0.27.0

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

@@ -31,7 +31,7 @@ module RuboCop
             lineno = target_method_lineno(node)
             line = node.loc.expression.source_buffer.source_line(lineno)
             indentation_of_line = /\S.*/.match(line).begin(0)
-            indentation_of_line + 2
+            indentation_of_line + configured_indentation_width
           else
             args.first.loc.column
           end

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

@@ -63,12 +63,9 @@ module RuboCop
           replacement = (node.type == :and ? '&&' : '||')
           lambda do |corrector|
             [expr1, expr2].each do |expr|
-              next unless expr.type == :send
-              _receiver, method_name, *args = *expr
-              # don't clobber if we already have a starting paren
-              next unless !expr.loc.begin || expr.loc.begin.source != '('
-              # don't touch anything unless we are sure it is a method call.
-              next unless args.last && method_name.to_s =~ /[a-z]/
+              _receiver, _method_name, *args = *expr
+              next unless correctable?(expr)
+
               sb = expr.loc.expression.source_buffer
               begin_paren = expr.loc.selector.end_pos
               end_paren = begin_paren + 1
@@ -79,6 +76,17 @@ module RuboCop
             corrector.replace(node.loc.operator, replacement)
           end
         end
+
+        def correctable?(expr)
+          return false unless expr.type == :send
+          _receiver, method_name, *args = *expr
+          # don't clobber if we already have a starting paren
+          return false unless !expr.loc.begin || expr.loc.begin.source != '('
+          # don't touch anything unless we are sure it is a method call.
+          return false unless args.last && method_name.to_s =~ /[a-z]/
+
+          true
+        end
       end
     end
   end

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

@@ -14,7 +14,7 @@ module RuboCop
         def on_send(node)
           receiver_node, method_name, *arg_nodes = *node
           return unless receiver_node && receiver_node.type == :array &&
-            method_name == :* && arg_nodes[0].type == :str
+                        method_name == :* && arg_nodes[0].type == :str
 
           add_offense(node, :selector)
         end

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

@@ -13,15 +13,11 @@ module RuboCop
           end
         end
 
+        private
+
         def autocorrect(comment)
-          expr = comment.loc.expression
-          eq_begin = expr.resize("=begin\n".length)
-          eq_end = Parser::Source::Range.new(expr.source_buffer,
-                                             expr.end_pos - "\n=end".length,
-                                             expr.end_pos)
-          contents = Parser::Source::Range.new(expr.source_buffer,
-                                               eq_begin.end_pos,
-                                               eq_end.begin_pos)
+          eq_begin, eq_end, contents = parts(comment)
+
           @corrections << lambda do |corrector|
             corrector.remove(eq_begin)
             unless contents.length == 0
@@ -34,6 +30,18 @@ module RuboCop
             corrector.remove(eq_end)
           end
         end
+
+        def parts(comment)
+          expr = comment.loc.expression
+          eq_begin = expr.resize("=begin\n".length)
+          eq_end = Parser::Source::Range.new(expr.source_buffer,
+                                             expr.end_pos - "\n=end".length,
+                                             expr.end_pos)
+          contents = Parser::Source::Range.new(expr.source_buffer,
+                                               eq_begin.end_pos,
+                                               eq_end.begin_pos)
+          [eq_begin, eq_end, contents]
+        end
       end
     end
   end

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

@@ -28,28 +28,24 @@ module RuboCop
             if !braces?(arg) || all_hashes?(args)
               correct_style_detected
             else
-              add_offense(arg, :expression,
-                          'Redundant curly braces around a hash parameter.') do
-                opposite_style_detected
-              end
+              offense(arg, 'Redundant curly braces around a hash parameter.')
             end
           elsif braces?(arg)
             correct_style_detected
           else
-            add_offense(arg, :expression,
-                        'Missing curly braces around a hash parameter.') do
-              opposite_style_detected
-            end
+            offense(arg, 'Missing curly braces around a hash parameter.')
           end
         end
 
+        def offense(arg, msg)
+          add_offense(arg, :expression, msg) { opposite_style_detected }
+        end
+
         def autocorrect(node)
           @corrections << lambda do |corrector|
             if style == :no_braces
               corrector.remove(node.loc.begin)
               corrector.remove(node.loc.end)
-              remove_leading_whitespace(node, corrector)
-              remove_trailing_comma_and_whitespace(node, corrector)
             elsif style == :braces
               corrector.insert_before(node.loc.expression, '{')
               corrector.insert_after(node.loc.expression, '}')
@@ -57,26 +53,6 @@ module RuboCop
           end
         end
 
-        def remove_leading_whitespace(node, corrector)
-          corrector.remove(
-            Parser::Source::Range.new(
-              node.loc.expression.source_buffer,
-              node.loc.begin.end_pos,
-              node.children.first.loc.expression.begin_pos
-            )
-          )
-        end
-
-        def remove_trailing_comma_and_whitespace(node, corrector)
-          corrector.remove(
-            Parser::Source::Range.new(
-              node.loc.expression.source_buffer,
-              node.children.last.loc.expression.end_pos,
-              node.loc.end.begin_pos
-            )
-          )
-        end
-
         def non_empty_hash?(arg)
           arg && arg.type == :hash && arg.children.any?
         end

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

@@ -27,25 +27,33 @@ module RuboCop
         def check_when(when_node, case_node, base, indent, base_column)
           pos = when_node.loc.keyword
           expected_column = base_column +
-            (indent ? IndentationWidth::CORRECT_INDENTATION : 0)
+                            (indent ? configured_indentation_width : 0)
           if pos.column == expected_column
             correct_style_detected
           else
-            msg = 'Indent `when` ' + if indent
-                                       "one step more than `#{base}`."
-                                     else
-                                       "as deep as `#{base}`."
-                                     end
-            add_offense(when_node, pos, msg) do
-              if pos.column == base_column(case_node, alternative_style)
-                opposite_style_detected
-              else
-                unrecognized_style_detected
-              end
+            incorrect_style(when_node, case_node, base, pos, indent)
+          end
+        end
+
+        def incorrect_style(when_node, case_node, base, pos, indent)
+          msg = 'Indent `when` ' + if indent
+                                     "one step more than `#{base}`."
+                                   else
+                                     "as deep as `#{base}`."
+                                   end
+          add_offense(when_node, pos, msg) do
+            if pos.column == base_column(case_node, alternative_style)
+              opposite_style_detected
+            else
+              unrecognized_style_detected
             end
           end
         end
 
+        def configured_indentation_width
+          config.for_cop('IndentationWidth')['Width']
+        end
+
         def parameter_name
           'IndentWhenRelativeTo'
         end

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of unidiomatic method names
+      # This cop enforces the use of consistent method names
       # from the Enumerable module.
       #
-      # The current definition of the check is flawed and should be
-      # enhanced by check for by blocks & procs as arguments of the
-      # methods.
+      # Unfortunately we cannot actually know if a method is from
+      # Enumerable or not (static analysis limitation), so this cop
+      # can yield some false positives.
       class CollectionMethods < Cop
         MSG = 'Prefer `%s` over `%s`.'
 

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

@@ -8,7 +8,16 @@ module RuboCop
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'
 
+        JAVA_TYPES = [:byte, :boolean, :byte, :short, :char,
+                      :int, :long, :float, :double]
+
+        JAVA_TYPE_NODES =
+          JAVA_TYPES.map { |t| s(:send, s(:const, nil, :Java), t) }
+
         def on_send(node)
+          # ignore Java interop code like Java::int
+          return if JAVA_TYPE_NODES.include?(node)
+
           receiver, method_name, *_args = *node
 
           # discard methods with nil receivers and op methods(like [])

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

@@ -15,7 +15,7 @@ module RuboCop
           processed_source.comments.each do |comment|
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
-              !correct_annotation?(first_word, colon, space, note)
+                        !correct_annotation?(first_word, colon, space, note)
 
             start = comment.loc.expression.begin_pos + margin.length
             length = first_word.length + (colon || '').length

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

@@ -10,41 +10,41 @@ module RuboCop
         MSG = 'Incorrect indentation detected (column %d instead of %d).'
 
         def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            lines = processed_source.lines
-            own_line = lines[comment.loc.line - 1]
-            next unless own_line =~ /\A\s*#/
+          processed_source.comments.each { |comment| check(comment) }
+        end
 
-            next_line =
-              lines[comment.loc.line..-1].find { |line| !line.blank? }
+        private
 
-            correct_comment_indentation = correct_indentation(next_line)
-            column = comment.loc.column
+        def check(comment)
+          lines = processed_source.lines
+          own_line = lines[comment.loc.line - 1]
+          return unless own_line =~ /\A\s*#/
 
-            @column_delta = correct_comment_indentation - column
-            next if @column_delta == 0
+          next_line = lines[comment.loc.line..-1].find { |line| !line.blank? }
+          correct_comment_indentation = correct_indentation(next_line)
+          column = comment.loc.column
 
-            if two_alternatives?(next_line)
-              correct_comment_indentation +=
-                IndentationWidth::CORRECT_INDENTATION # Try the other
-              # We keep @column_delta unchanged so that autocorrect changes to
-              # the preferred style of aligning the comment with the keyword.
-            end
+          @column_delta = correct_comment_indentation - column
+          return if @column_delta == 0
 
-            next if column == correct_comment_indentation
-            add_offense(comment, comment.loc.expression,
-                        format(MSG, column, correct_comment_indentation))
+          if two_alternatives?(next_line)
+            # Try the other
+            correct_comment_indentation += configured_indentation_width
+            # We keep @column_delta unchanged so that autocorrect changes to
+            # the preferred style of aligning the comment with the keyword.
           end
-        end
 
-        private
+          return if column == correct_comment_indentation
+          add_offense(comment, comment.loc.expression,
+                      format(MSG, column, correct_comment_indentation))
+        end
 
         def correct_indentation(next_line)
           return 0 unless next_line
 
           indentation_of_next_line = next_line =~ /\S/
           indentation_of_next_line + if less_indented?(next_line)
-                                       IndentationWidth::CORRECT_INDENTATION
+                                       configured_indentation_width
                                      else
                                        0
                                      end

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

@@ -7,12 +7,12 @@ module RuboCop
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
       class DefWithParentheses < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'
 
-        def on_method(node, _method_name, args, _body)
+        def on_method_def(node, _method_name, args, _body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 

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

@@ -13,7 +13,7 @@ module RuboCop
         def on_send(node)
           _receiver, method_name, *args = *node
           return unless args.size == 1 &&
-            DEPRECATED_METHODS.include?(method_name)
+                        DEPRECATED_METHODS.include?(method_name)
 
           add_offense(node, :selector,
                       format(MSG,

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of double negation (!!) to convert something
-      # to a boolean value. As this is both cryptic and usually redundant it
+      # to a boolean value. As this is both cryptic and usually redundant, it
       # should be avoided.
       #
       # @example
@@ -14,6 +14,11 @@ module RuboCop
       #
       #   # good
       #   !something.nil?
+      #
+      # Please, note that when something is a boolean value
+      # !!something and !something.nil? are not the same thing.
+      # As you're unlikely to write code that can accept values of any type
+      # this is rarely a problem in practice.
       class DoubleNegation < Cop
         MSG = 'Avoid the use of double negation (`!!`).'
 

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

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the alignment of else keywords. Normally they should
+      # be aligned with an if/unless/while/until/begin/def keyword, but there
+      # are special cases when they should follow the same rules as the
+      # alignment of end.
+      class ElseAlignment < Cop
+        include AutocorrectAlignment
+        include CheckAssignment
+
+        MSG = 'Align `%s` with `%s`.'
+
+        def on_if(node, base = nil)
+          return if ignored_node?(node)
+          return unless node.loc.respond_to?(:else)
+          return if node.loc.else.nil?
+
+          else_range = node.loc.else
+          return unless begins_its_line?(else_range)
+
+          base_range = if base
+                         base.loc.expression
+                       else
+                         base = node
+                         until %w(if unless).include?(base.loc.keyword.source)
+                           base = base.parent
+                         end
+                         base.loc.keyword
+                       end
+
+          check_alignment(base_range, else_range)
+        end
+
+        def on_rescue(node)
+          return unless node.loc.else
+
+          grandparent = node.parent.parent
+          base = case node.parent.type
+                 when :def, :defs
+                   if grandparent && grandparent.type == :send
+                     grandparent.loc.selector
+                   else
+                     node.parent.loc.keyword
+                   end
+                 when :ensure
+                   grandparent.loc.begin
+                 else
+                   node.loc.keyword
+                 end
+          check_alignment(base, node.loc.else)
+        end
+
+        def on_case(node)
+          _cond, *whens, _else = *node
+          return unless node.loc.else
+          check_alignment(whens.last.loc.keyword, node.loc.else)
+        end
+
+        private
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check its indentation.
+          rhs = first_part_of_call_chain(rhs)
+          return unless rhs
+
+          end_config = config.for_cop('Lint/EndAlignment')
+          style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
+          base = style == 'variable' ? node : rhs
+
+          return if rhs.type != :if
+
+          on_if(rhs, base)
+          ignore_node(rhs)
+        end
+
+        def check_alignment(base_loc, else_range)
+          return unless begins_its_line?(else_range)
+
+          @column_delta = base_loc.column - else_range.column
+          return if @column_delta == 0
+
+          add_offense(else_range, else_range,
+                      format(MSG, else_range.source, base_loc.source[/^\S*/]))
+        end
+      end
+    end
+  end
+end