rubocop 0.14.1 → 0.15.0

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

@@ -29,28 +29,48 @@ module Rubocop
 
           @corrections << lambda do |corrector|
             expr = node.loc.expression
-            if column_delta > 0
-              corrector.replace(expr,
-                                expr.source.gsub(/^/, ' ' * column_delta))
-            else
-              offset = 0
-              expr.source.each_line do |line|
-                b = expr.begin_pos + offset
-                if offset == 0
-                  range = Parser::Source::Range.new(expr.source_buffer,
-                                                    b + column_delta,
-                                                    b + line.length)
-                  corrector.replace(range, line)
-                else
-                  range = Parser::Source::Range.new(expr.source_buffer,
-                                                    b, b + line.length)
-                  corrector.replace(range, line[-column_delta..-1])
-                end
-                offset += line.length
+            each_line(expr) do |line_begin_pos, line|
+              starts_with_space =
+                expr.source_buffer.source[line_begin_pos] =~ / /
+              pos_to_remove = if column_delta > 0 || starts_with_space
+                                line_begin_pos
+                              else
+                                line_begin_pos - column_delta.abs
+                              end
+              range = Parser::Source::Range.new(expr.source_buffer,
+                                                pos_to_remove,
+                                                pos_to_remove +
+                                                column_delta.abs)
+              if column_delta > 0
+                corrector.insert_before(range, ' ' * column_delta)
+              else
+                remove(range, corrector)
               end
             end
           end
         end
+
+        def remove(range, corrector)
+          original_stderr = $stderr
+          $stderr = StringIO.new # Avoid error messages on console
+          corrector.remove(range)
+        rescue RuntimeError
+          range = Parser::Source::Range.new(range.source_buffer,
+                                            range.begin_pos + 1,
+                                            range.end_pos + 1)
+          retry if range.source =~ /^ +$/
+        ensure
+          $stderr = original_stderr
+        end
+
+        def each_line(expr)
+          offset = 0
+          expr.source.each_line do |line|
+            line_begin_pos = expr.begin_pos + offset
+            yield line_begin_pos, line
+            offset += line.length
+          end
+        end
       end
     end
   end

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

@@ -41,12 +41,10 @@ module Rubocop
             if b.is?('{')
               # If the left brace is immediately preceded by a word character,
               # then we need a space before `do` to get valid Ruby code.
-              padding = if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\w/
-                          ' '
-                        else
-                          ''
-                        end
-              corrector.replace(b, padding + 'do')
+              if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\w/
+                corrector.insert_before(b, ' ')
+              end
+              corrector.replace(b, 'do')
               corrector.replace(e, 'end')
             else
               corrector.replace(b, '{')

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

@@ -8,19 +8,19 @@ module Rubocop
         def on_send(node)
           _receiver, method_name, *args = *node
 
-          return unless args.size == 1
           # discard attr writer methods.
           return if method_name.to_s.end_with?('=')
           # discard operator methods
           return if OPERATOR_METHODS.include?(method_name)
 
           # we care only for the first argument
-          arg = args.first
+          arg = args.last
           return unless arg && arg.type == :hash && arg.children.any?
 
           has_braces = !arg.loc.begin.nil?
+          all_hashes = args.length > 1 && args.all? { |a| a.type == :hash }
 
-          if style == :no_braces && has_braces
+          if style == :no_braces && has_braces && !all_hashes
             convention(arg,
                        :expression,
                        'Redundant curly braces around a hash parameter.')

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks that the cyclomatic complexity of methods is not higher
+      # than the configured maximum. The cyclomatic complexity is the number of
+      # linearly independent paths through a method. The algorithm counts
+      # decision points and adds one.
+      #
+      # An if statement (or unless or ?:) increases the complexity by one. An
+      # else branch does not, since it doesn't add a decision point. The &&
+      # operator (or keyword and) can be converted to a nested if statement,
+      # and ||/or is shorthand for a sequence of ifs, so they also add one.
+      # Loops can be said to have an exit condition, so they add one.
+      class CyclomaticComplexity < Cop
+        MSG = 'Cyclomatic complexity for %s is too high. [%d/%d]'
+        DECISION_POINT_NODES = [:if, :while, :until, :for, :rescue, :when,
+                                :and, :or]
+
+        def on_def(node)
+          method_name, _args, _body = *node
+          check(node, method_name)
+        end
+
+        def on_defs(node)
+          _scope, method_name, _args, _body = *node
+          check(node, method_name)
+        end
+
+        private
+
+        def check(node, method_name)
+          complexity = 1
+          on_node(DECISION_POINT_NODES, node) { complexity += 1 }
+
+          max = cop_config['Max']
+          if complexity > max
+            convention(node, :keyword,
+                       sprintf(MSG, method_name, complexity, max))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Access modifiers should be surrounded by blank lines.
+      class EmptyLinesAroundAccessModifier < Cop
+        MSG = 'Keep a blank line before and after %s.'
+
+        PRIVATE_NODE = s(:send, nil, :private)
+        PROTECTED_NODE = s(:send, nil, :protected)
+        PUBLIC_NODE = s(:send, nil, :public)
+
+        def on_send(node)
+          return unless modifier_node?(node)
+
+          return if empty_lines_around?(node)
+
+          convention(node, :expression)
+        end
+
+        private
+
+        def empty_lines_around?(node)
+          send_line = node.loc.line
+          previous_line = processed_source[send_line - 2]
+          next_line = processed_source[send_line]
+
+          (class_def?(previous_line.lstrip) ||
+           previous_line.blank?) &&
+            next_line.blank?
+        end
+
+        def class_def?(line)
+          %w(class module).any? { |keyword| line.start_with?(keyword) }
+        end
+
+        def message(node)
+          format(MSG, node.loc.selector.source)
+        end
+
+        def modifier_node?(node)
+          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for two or more consecutive blank lines.
+      class EmptyLinesAroundBody < Cop
+        MSG_BEG = 'Extra blank line detected at body beginning.'
+        MSG_END = 'Extra blank line detected at body end.'
+
+        def on_class(node)
+          check_node(node)
+        end
+
+        def on_module(node)
+          check_node(node)
+        end
+
+        def on_sclass(node)
+          check_node(node)
+        end
+
+        def on_def(node)
+          check_node(node)
+        end
+
+        def on_defs(node)
+          check_node(node)
+        end
+
+        private
+
+        def check_node(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          check_source(start_line, end_line)
+        end
+
+        def check_source(start_line, end_line)
+          if processed_source.lines[start_line].blank?
+            range = source_range(processed_source.buffer,
+                                 processed_source[0...start_line],
+                                 0,
+                                 1)
+            convention(nil, range, MSG_BEG)
+          end
+
+          if processed_source.lines[end_line - 2].blank?
+            range = source_range(processed_source.buffer,
+                                 processed_source[0...(end_line - 2)],
+                                 0,
+                                 1)
+            convention(nil, range, MSG_END)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,13 +8,17 @@ module Rubocop
         MSG = 'Carriage return character detected.'
 
         def investigate(processed_source)
-          processed_source.lines.each_with_index do |line, index|
+          original_source = IO.read(processed_source.buffer.name)
+          original_source.lines.each_with_index do |line, index|
             if line =~ /\r$/
               convention(nil,
                          source_range(processed_source.buffer,
                                       processed_source[0...index],
-                                      line.length - 1, 1),
+                                      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 offence.
+              break
             end
           end
         end

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

@@ -23,7 +23,7 @@ module Rubocop
             else
               indentation = sexp.loc.keyword.column
               kw_length = sexp.loc.keyword.size
-              cond_length = cond.loc.expression.size
+              cond_length = conditional_length(cond)
               space = 1
               total = indentation + body_length + space + kw_length + space +
                 cond_length
@@ -40,6 +40,16 @@ module Rubocop
           sexp.loc.expression.source.lines.to_a.size
         end
 
+        def conditional_length(conditional_node)
+          node = if conditional_node.type == :match_current_line
+                   conditional_node.children.first
+                 else
+                   conditional_node
+                 end
+
+          node.loc.expression.size
+        end
+
         def body_length(body)
           if body && body.loc.expression
             body.loc.expression.size

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

@@ -11,10 +11,16 @@ module Rubocop
           final_line = processed_source.raw_lines.to_a.last
 
           unless final_line.nil? || final_line.end_with?("\n")
-            convention(nil,
-                       source_range(processed_source.buffer,
-                                    processed_source[0...-1],
-                                    final_line.length - 1, 1))
+            range = source_range(processed_source.buffer,
+                                 processed_source[0...-1],
+                                 final_line.length - 1, 1)
+            convention(range, range)
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(range, "\n")
           end
         end
       end

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

@@ -26,44 +26,55 @@ module Rubocop
 
           sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
 
-          if sym_indices
-            pairs.each do |pair|
-              if pair.loc.operator && pair.loc.operator.is?('=>')
-                convention(pair,
-                           pair.loc.expression.begin.join(pair.loc.operator),
-                           MSG_19)
-              end
-            end
-          end
+          check(pairs, '=>', MSG_19) if sym_indices
         end
 
         def hash_rockets_check(node)
           pairs = *node
 
-          pairs.each do |pair|
-            if pair.loc.operator && pair.loc.operator.is?(':')
-              convention(pair,
-                         pair.loc.expression.begin.join(pair.loc.operator),
-                         MSG_HASH_ROCKETS)
-            end
-          end
+          check(pairs, ':', MSG_HASH_ROCKETS)
         end
 
         def autocorrect(node)
+          key = node.children.first.loc.expression
+          op = node.loc.operator
+          if cop_config['EnforcedStyle'] == 'ruby19' &&
+              !space_before_operator?(op, key) &&
+              config.for_cop('SpaceAroundOperators')['Enabled']
+            # Don't do the correction if there is no space before '=>'. The
+            # combined corrections of this cop and SpaceAroundOperators could
+            # produce code with illegal syntax.
+            fail CorrectionNotPossible
+          end
+
           @corrections << lambda do |corrector|
             if cop_config['EnforcedStyle'] == 'ruby19'
-              replacement = node.loc.expression.source[1..-1]
-                .sub(/\s*=>\s*/, ': ')
+              corrector.insert_after(key, ' ')
+              corrector.replace(key, key.source.sub(/^:(.*)/, '\1:'))
             else
-              replacement = ':' + node.loc.expression.source
-                .sub(/:\s*/, ' => ')
+              corrector.insert_after(key, ' => ')
+              corrector.insert_before(key, ':')
             end
-            corrector.replace(node.loc.expression, replacement)
+            corrector.remove(range_with_surrounding_space(op))
           end
         end
 
         private
 
+        def space_before_operator?(op, key)
+          op.begin_pos - key.begin_pos - key.source.length > 0
+        end
+
+        def check(pairs, delim, msg)
+          pairs.each do |pair|
+            if pair.loc.operator && pair.loc.operator.is?(delim)
+              convention(pair,
+                         pair.loc.expression.begin.join(pair.loc.operator),
+                         msg)
+            end
+          end
+        end
+
         def word_symbol_pair?(pair)
           key, _value = *pair
 

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

@@ -19,6 +19,15 @@ module Rubocop
             end
           end
         end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          b = expr.begin_pos
+          hash_mark = Parser::Source::Range.new(expr.source_buffer, b, b + 1)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(hash_mark, ' ')
+          end
+        end
       end
     end
   end

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

@@ -8,12 +8,22 @@ module Rubocop
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
+          _receiver, method_name, *args = *node
+
+          # methods starting with a capital letter should be skipped
+          return if method_name =~ /\A[A-Z]/
 
           convention(node, :begin) if args.empty? && node.loc.begin
         end
 
         def autocorrect(node)
+          # Bail out if the call is going to be auto-corrected by EmptyLiteral.
+          if config.for_cop('EmptyLiteral')['Enabled'] &&
+              [EmptyLiteral::HASH_NODE,
+               EmptyLiteral::ARRAY_NODE,
+               EmptyLiteral::STR_NODE].include?(node)
+            fail CorrectionNotPossible
+          end
           @corrections << lambda do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)