rubocop 0.21.0 → 0.22.0

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

@@ -20,10 +20,9 @@ module Rubocop
 
         def on_send(node)
           _receiver, _method_name, *args = *node
+          return unless args.size == 1 && args.first.type == :block_pass
 
-          if args.size == 1 && args.first.type == :block_pass
-            check_method_node(node)
-          end
+          check_method_node(node)
         end
 
         def autocorrect(node)
@@ -38,14 +37,12 @@ module Rubocop
         def check_method_node(node)
           _receiver, method_name, *_args = *node
 
-          if preferred_methods[method_name]
-            add_offense(
-              node, :selector,
-              format(MSG,
-                     preferred_method(method_name),
-                     method_name)
-            )
-          end
+          return unless preferred_methods[method_name]
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name)
+                     )
         end
 
         def preferred_method(method)

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

@@ -14,15 +14,15 @@ module Rubocop
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             margin, first_word, colon, space, note = split_comment(comment)
-            if annotation?(comment) && !correct_annotation?(first_word, colon,
-                                                            space, note)
-              start = comment.loc.expression.begin_pos + margin.length
-              length = first_word.length + (colon || '').length
-              range = Parser::Source::Range.new(processed_source.buffer,
-                                                start,
-                                                start + length)
-              add_offense(nil, range)
-            end
+            next unless annotation?(comment) &&
+              !correct_annotation?(first_word, colon, space, note)
+
+            start = comment.loc.expression.begin_pos + margin.length
+            length = first_word.length + (colon || '').length
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              start,
+                                              start + length)
+            add_offense(nil, range)
           end
         end
 

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks the indentation of comments.
+      class CommentIndentation < Cop
+        include AutocorrectAlignment
+
+        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*#/
+
+            next_line =
+              lines[comment.loc.line..-1].find { |line| !line.blank? }
+
+            correct_comment_indentation = correct_indentation(next_line)
+            column = comment.loc.column
+
+            @column_delta = correct_comment_indentation - column
+            next if @column_delta == 0
+
+            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
+
+            next if column == correct_comment_indentation
+            add_offense(comment, comment.loc.expression,
+                        format(MSG, column, correct_comment_indentation))
+          end
+        end
+
+        private
+
+        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
+                                     else
+                                       0
+                                     end
+        end
+
+        def less_indented?(line)
+          keyword = 'end\b'
+          bracket = '[}\]]'
+          line =~ /^\s*(#{keyword}|#{bracket})/
+        end
+
+        def two_alternatives?(line)
+          keyword = '(else|elsif|when|rescue|ensure)\b'
+          line =~ /^\s*#{keyword}/
+        end
+      end
+    end
+  end
+end

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

@@ -19,9 +19,9 @@ module Rubocop
           # NewClass = something_that_returns_a_class
           # It's also ok to assign a class constant another class constant
           # SomeClass = SomeOtherClass
-          unless value && [:send, :block, :const].include?(value.type)
-            add_offense(node, :name) if const_name !~ SNAKE_CASE
-          end
+          return if value && [:send, :block, :const].include?(value.type)
+
+          add_offense(node, :name) if const_name !~ SNAKE_CASE
         end
       end
     end

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

@@ -28,11 +28,11 @@ module Rubocop
           on_node(DECISION_POINT_NODES, node) { complexity += 1 }
 
           max = cop_config['Max']
-          if complexity > max
-            add_offense(node, :keyword,
-                        format(MSG, method_name, complexity, max)) do
-              self.max = complexity
-            end
+          return unless complexity > max
+
+          add_offense(node, :keyword,
+                      format(MSG, method_name, complexity, max)) do
+            self.max = complexity
           end
         end
       end

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

@@ -12,13 +12,13 @@ module Rubocop
 
         def on_send(node)
           _receiver, method_name, *args = *node
+          return unless args.size == 1 &&
+            DEPRECATED_METHODS.include?(method_name)
 
-          if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
-            add_offense(node, :selector,
-                        format(MSG,
-                               method_name,
-                               proper_method_name(method_name)))
-          end
+          add_offense(node, :selector,
+                      format(MSG,
+                             method_name,
+                             proper_method_name(method_name)))
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for inject / reduce calls where the passed in object is
+      # returned at the end and so could be replace by each_with_object without
+      # the need to return the object at the end.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].inject({}) { |a, e| a[e] = e; a }
+      #
+      #   # good
+      #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
+      class EachWithObject < Cop
+        MSG = 'Use `each_with_object` instead of `%s`.'
+        METHODS = [:inject, :reduce]
+
+        def on_block(node)
+          method, args, body = *node
+          _, method_name, method_args = *method
+
+          return unless METHODS.include? method_name
+          return if method_args.type == :sym
+          return_value = body.children.last
+          return unless return_value.type == :lvar
+          first_arg, = *args
+          accumulator_var = *first_arg
+          return_var = *return_value
+          return unless accumulator_var == return_var
+
+          add_offense(method, :selector, format(MSG, method_name))
+        end
+      end
+    end
+  end
+end

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

@@ -23,14 +23,14 @@ module Rubocop
               # don't show up in the tokens
               ((prev_line + 1)...cur_line).each do |line|
                 # we check if the prev and current lines are empty
-                if processed_source[line - 2].empty? &&
-                    processed_source[line - 1].empty?
-                  range = source_range(processed_source.buffer,
-                                       processed_source[0...(line - 1)],
-                                       0,
-                                       1)
-                  add_offense(range, range)
-                end
+                next unless processed_source[line - 2].empty? &&
+                  processed_source[line - 1].empty?
+
+                range = source_range(processed_source.buffer,
+                                     processed_source[0...(line - 1)],
+                                     0,
+                                     1)
+                add_offense(range, range)
               end
             end
 

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

@@ -60,13 +60,13 @@ module Rubocop
         end
 
         def check_line(line, msg)
-          if processed_source.lines[line].empty?
-            range = source_range(processed_source.buffer,
-                                 processed_source[0...line],
-                                 0,
-                                 1)
-            add_offense(range, range, msg)
-          end
+          return unless processed_source.lines[line].empty?
+
+          range = source_range(processed_source.buffer,
+                               processed_source[0...line],
+                               0,
+                               1)
+          add_offense(range, range, msg)
         end
       end
     end

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

@@ -23,13 +23,12 @@ module Rubocop
           line_number = encoding_line_number(processed_source)
           message = offense(processed_source, line_number)
 
-          if message
-            add_offense(nil,
-                        source_range(processed_source.buffer,
-                                     processed_source[0...line_number],
-                                     0, 1),
-                        message)
-          end
+          return unless message
+          add_offense(nil,
+                      source_range(processed_source.buffer,
+                                   processed_source[0...line_number],
+                                   0, 1),
+                      message)
         end
 
         private

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

@@ -12,16 +12,16 @@ module Rubocop
           original_source = IO.read(buffer.name,
                                     encoding: buffer.source.encoding)
           original_source.lines.each_with_index do |line, index|
-            if line =~ /\r$/
-              add_offense(nil,
-                          source_range(buffer,
-                                       processed_source[0...index],
-                                       0, line.length),
-                          MSG)
-              # Usually there will be carriage return characters on all or none
-              # of the lines in a file, so we report only one offense.
-              break
-            end
+            next unless line =~ /\r$/
+
+            add_offense(nil,
+                        source_range(buffer,
+                                     processed_source[0...index],
+                                     0, line.length),
+                        MSG)
+            # Usually there will be carriage return characters on all or none
+            # of the lines in a file, so we report only one offense.
+            break
           end
         end
       end

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

@@ -11,17 +11,21 @@ module Rubocop
 
         def investigate(processed_source)
           file_path = processed_source.buffer.name
-
           return if config.file_to_include?(file_path)
 
           basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
+          return if snake_case?(basename)
+
+          add_offense(nil,
+                      source_range(processed_source.buffer,
+                                   processed_source[0..0],
+                                   0, 1))
+        end
+
+        private
 
-          unless basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
-            add_offense(nil,
-                        source_range(processed_source.buffer,
-                                     processed_source[0..0],
-                                     0, 1))
-          end
+        def snake_case?(basename)
+          basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
         end
       end
     end

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

@@ -3,16 +3,14 @@
 module Rubocop
   module Cop
     module Style
-      # This cop if/unless expression that can be replace with a guard clause.
+      # Use a guard clause instead of wrapping the code inside a conditional
+      # expression
       #
       # @example
-      #
       #   # bad
       #   def test
       #     if something
       #       work
-      #       work
-      #       work
       #     end
       #   end
       #
@@ -20,48 +18,60 @@ module Rubocop
       #   def test
       #     return unless something
       #     work
-      #     work
-      #     work
       #   end
       #
-      # It should be extended to handle methods whose body is if/else
-      # or a case expression with a default branch.
+      #   # also good
+      #   def test
+      #     work if something
+      #   end
       class GuardClause < Cop
-        include CheckMethods
+        include ConfigurableEnforcedStyle
         include IfNode
 
-        MSG = 'Use a guard clause instead of wrapping ' \
-              'the code inside a conditional expression.'
-
-        private
+        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
+              'conditional expression.'
 
-        def check(_node, _method_name, _args, body)
+        def on_def(node)
+          _, _, body = *node
           return unless body
 
-          if body.type == :if
+          if if?(body)
             check_if_node(body)
           elsif body.type == :begin
             expressions = *body
             last_expr = expressions.last
 
-            check_if_node(last_expr) if last_expr && last_expr.type == :if
+            check_if_node(last_expr) if if?(last_expr)
           end
         end
 
+        private
+
+        def if?(body)
+          body && body.type == :if
+        end
+
         def check_if_node(node)
-          _cond, _body, else_body = *node
+          _cond, body, else_body = *node
 
-          return if else_body
+          return if body && else_body
           # discard modifier ifs and ternary_ops
           return if modifier_if?(node) || ternary_op?(node)
           # discard short ifs
-          return unless if_length(node) > 3
+          return unless min_body_length?(node)
+
+          add_offense(node, :keyword, MSG)
+        end
 
-          add_offense(node, :keyword)
+        def min_body_length?(node)
+          (node.loc.end.line - node.loc.keyword.line) > min_body_length
         end
 
-        def if_length(node)
-          node.loc.end.line - node.loc.keyword.line + 1
+        def min_body_length
+          length = cop_config['MinBodyLength'] || 1
+          return length if length.is_a?(Integer) && length > 0
+
+          fail 'MinBodyLength needs to be a positive integer!'
         end
       end
     end

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

@@ -46,12 +46,12 @@ module Rubocop
         def on_send(node)
           super
           receiver, method_name, *args = *node
+          return unless visibility_and_def_on_same_line?(receiver, method_name,
+                                                         args)
 
-          if visibility_and_def_on_same_line?(receiver, method_name, args)
-            _method_name, _args, body = *args.first
-            check_indentation(node.loc.expression, body)
-            ignore_node(args.first)
-          end
+          _method_name, _args, body = *args.first
+          check_indentation(node.loc.expression, body)
+          ignore_node(args.first)
         end
 
         def check(node, _method_name, _args, body)
@@ -65,9 +65,10 @@ module Rubocop
 
         def on_while(node, base = node)
           _condition, body = *node
-          if node.loc.keyword.begin_pos == node.loc.expression.begin_pos
-            check_indentation(base.loc, body)
-          end
+          return unless node.loc.keyword.begin_pos ==
+            node.loc.expression.begin_pos
+
+          check_indentation(base.loc, body)
         end
 
         alias_method :on_until, :on_while
@@ -115,34 +116,32 @@ module Rubocop
           # 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
 
-          if rhs
-            end_config = config.for_cop('EndAlignment')
-            style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
-            base = style == 'variable' ? node : rhs
-
-            case rhs.type
-            when :if            then on_if(rhs, base)
-            when :while, :until then on_while(rhs, base)
-            else                     return
-            end
+          end_config = config.for_cop('EndAlignment')
+          style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
+          base = style == 'variable' ? node : rhs
 
-            ignore_node(rhs)
+          case rhs.type
+          when :if            then on_if(rhs, base)
+          when :while, :until then on_while(rhs, base)
+          else                     return
           end
+
+          ignore_node(rhs)
         end
 
         def check_if(node, body, else_clause, base_loc)
           return if ternary_op?(node)
 
           check_indentation(base_loc, body)
+          return unless else_clause
 
-          if else_clause
-            if elsif?(else_clause)
-              _condition, inner_body, inner_else_clause = *else_clause
-              check_if(else_clause, inner_body, inner_else_clause, base_loc)
-            else
-              check_indentation(node.loc.else, else_clause)
-            end
+          if elsif?(else_clause)
+            _condition, inner_body, inner_else_clause = *else_clause
+            check_if(else_clause, inner_body, inner_else_clause, base_loc)
+          else
+            check_indentation(node.loc.else, else_clause)
           end
         end