rubocop 0.13.1 → 0.14.0

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

@@ -12,16 +12,7 @@ module Rubocop
           'than one line.'
 
         def on_array(node)
-          first_element = node.children.first
-
-          node.children.each_cons(2) do |prev, current|
-            if current.loc.line != prev.loc.line
-              @column_delta = first_element.loc.column - current.loc.column
-              if current.loc.column != first_element.loc.column
-                convention(current, :expression)
-              end
-            end
-          end
+          check_alignment(node.children)
         end
       end
     end

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

@@ -14,12 +14,22 @@ module Rubocop
 
           if [cop_config['EnforcedHashRocketStyle'],
               cop_config['EnforcedColonStyle']].include?('table')
+
+            lines_of_the_children = node.children.map do |pair|
+              key, _value = *pair
+              key.loc.line
+            end
+            on_the_same_line = lines_of_the_children.uniq.size == 1
+            return if on_the_same_line
+
             key_widths = node.children.map do |pair|
               key, _value = *pair
               key.loc.expression.source.length
             end
             @max_key_width = key_widths.max
-            if first_pair && value_delta(nil, first_pair, @max_key_width) != 0
+            if first_pair && !on_the_same_line &&
+              value_delta(nil, first_pair, @max_key_width) != 0
+
               @column_deltas = {}
               convention(first_pair, :expression)
             end
@@ -31,7 +41,7 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
@@ -120,6 +130,8 @@ module Rubocop
                                    key.loc.column +
                                      spaced_separator(current_pair).length +
                                      max_key_width
+                                 elsif first_pair.nil? # Only one pair?
+                                   value.loc.column
                                  else
                                    _key1, value1 = *first_pair
                                    value1.loc.column

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

@@ -17,17 +17,7 @@ module Rubocop
           return if method == :[]=
           return if args.size <= 1
 
-          first_arg_column = args.first.loc.expression.column
-
-          args.each_cons(2) do |prev, current|
-            current_pos = current.loc.expression
-
-            if current_pos.line > prev.loc.expression.line &&
-                current_pos.column != first_arg_column
-              @column_delta = first_arg_column - current_pos.column
-              convention(current, current_pos)
-            end
-          end
+          check_alignment(args)
         end
       end
     end

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

@@ -30,23 +30,25 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
-          correction = lambda do |corrector|
-            replacement = (node.type == :and ? '&&' : '||')
-            corrector.replace(node.loc.operator, replacement)
-          end
-
-          new_source = rewrite_node(node, correction)
+        def autocorrect(node)
+          c = correction(node)
+          new_source = rewrite_node(node, c)
 
           # Make the correction only if it doesn't change the AST.
-          if node == SourceParser.parse(new_source).ast
-            @corrections << correction
-          end
+          @corrections << c if node == SourceParser.parse(new_source).ast
         end
 
         def rewrite_node(node, correction)
           processed_source = SourceParser.parse(node.loc.expression.source)
-          Corrector.new(processed_source.buffer, [correction]).rewrite
+          c = correction(processed_source.ast)
+          Corrector.new(processed_source.buffer, [c]).rewrite
+        end
+
+        def correction(node)
+          lambda do |corrector|
+            replacement = (node.type == :and ? '&&' : '||')
+            corrector.replace(node.loc.operator, replacement)
+          end
         end
       end
     end

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

@@ -11,7 +11,7 @@ module Rubocop
           convention(node, :selector) if command?(:attr, node)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.selector, 'attr_reader')
           end

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

@@ -7,7 +7,20 @@ module Rubocop
       # the left or to the right, amount being determined by the instance
       # variable @column_delta.
       module AutocorrectAlignment
-        def autocorrect_action(node)
+        def check_alignment(items)
+          items.each_cons(2) do |prev, current|
+            if current.loc.line > prev.loc.line && start_of_line?(current.loc)
+              @column_delta = items.first.loc.column - current.loc.column
+              convention(current, :expression) if @column_delta != 0
+            end
+          end
+        end
+
+        def start_of_line?(loc)
+          loc.expression.source_line[0...loc.column] =~ /^\s*$/
+        end
+
+        def autocorrect(node)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get
           # the last value of @column_delta. A local variable fixes the
@@ -17,12 +30,24 @@ module Rubocop
           @corrections << lambda do |corrector|
             expr = node.loc.expression
             if column_delta > 0
-              corrector.replace(expr, ' ' * column_delta + expr.source)
+              corrector.replace(expr,
+                                expr.source.gsub(/^/, ' ' * column_delta))
             else
-              range = Parser::Source::Range.new(expr.source_buffer,
-                                                expr.begin_pos + column_delta,
-                                                expr.end_pos)
-              corrector.replace(range, expr.source)
+              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
+              end
             end
           end
         end

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

@@ -35,14 +35,22 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            if node.loc.begin.is?('{')
-              corrector.replace(node.loc.begin, 'do')
-              corrector.replace(node.loc.end, 'end')
+            b, e = node.loc.begin, node.loc.end
+            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')
+              corrector.replace(e, 'end')
             else
-              corrector.replace(node.loc.begin, '{')
-              corrector.replace(node.loc.end, '}')
+              corrector.replace(b, '{')
+              corrector.replace(e, '}')
             end
           end
         end

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

@@ -15,7 +15,7 @@ module Rubocop
             node.loc.expression.source.size.between?(2, 3)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             string = node.loc.expression.source[1..-1]
 

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks if the length a class exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ClassLength < Cop
+        MSG = 'Class definition is too long. [%d/%d]'
+
+        def on_class(node)
+          check(node)
+        end
+
+        def max_length
+          cop_config['Max']
+        end
+
+        def count_comments?
+          cop_config['CountComments']
+        end
+
+        private
+
+        def check(node)
+          method_length = Util.source_length(node.loc.expression.source,
+                                             count_comments?)
+
+          if method_length > max_length
+            message = sprintf(MSG, method_length, max_length)
+            convention(node, :keyword, message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.selector,
                               preferred_method(node.loc.selector.source))

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

@@ -22,7 +22,7 @@ module Rubocop
           method_name.match(/^[A-Z]/)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.dot, '.')
           end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This module provides functionality for checking if names match the
+      # configured EnforcedStyle.
+      module ConfigurableNaming
+        SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
+        CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
+
+        def check(node, range)
+          return unless range
+
+          name = range.source.to_sym
+          unless matches_config?(name) || Cop::OPERATOR_METHODS.include?(name)
+            convention(node, range, message(cop_config['EnforcedStyle']))
+          end
+        end
+
+        def matches_config?(name)
+          case cop_config['EnforcedStyle']
+          when 'snake_case'
+            name =~ SNAKE_CASE
+          when 'camelCase'
+            name =~ CAMEL_CASE
+          else
+            fail 'Illegal value for EnforcedStyle. Must be snake_case or ' +
+              'camelCase.'
+          end
+        end
+
+        # Returns a range containing the method name after the given regexp and
+        # a dot.
+        def after_dot(node, method_name_length, regexp)
+          expr = node.loc.expression
+          match = /\A#{regexp}\s*\.\s*/.match(expr.source)
+          return unless match
+          offset = match[0].length
+          begin_pos = expr.begin_pos + offset
+          Parser::Source::Range.new(expr.source_buffer, begin_pos,
+                                    begin_pos + method_name_length)
+        end
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module Rubocop
           convention(args, :begin) if args.children == [] && args.loc.begin
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
@@ -60,7 +60,7 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.insert_before(node.loc.expression, '(')
             corrector.insert_after(node.loc.expression, ')')

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

@@ -44,7 +44,7 @@ module Rubocop
         # TODO: Check block contents as well.
         alias_method :on_block, :ignore_node
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             name = case node
                    when ARRAY_NODE then '[]'

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

@@ -24,13 +24,17 @@ module Rubocop
         def on_send(node)
           receiver, method, args = *node
 
-          return unless method == :==
+          return unless [:==, :!=].include?(method)
           return unless div_by_2?(receiver)
 
           if args == ZERO
-            convention(node, :expression, MSG_EVEN)
+            convention(node,
+                       :expression,
+                       method == :== ? MSG_EVEN : MSG_ODD)
           elsif args == ONE
-            convention(node, :expression, MSG_ODD)
+            convention(node,
+                       :expression,
+                       method == :== ? MSG_ODD : MSG_EVEN)
           end
         end
 

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

@@ -20,7 +20,7 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.selector,
                               proper_method_name(node.loc.selector.source))

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

@@ -3,14 +3,25 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks for uses of the Ruby 1.8 hash literal syntax,
-      # when the 1.9 syntax is applicable as well.
+      # This cop checks hash literal syntax.
+      #
+      # It can enforce either the use of the class hash rocket syntax or
+      # the use of the newer Ruby 1.9 syntax (when applicable).
       #
       # A separate offence is registered for each problematic pair.
       class HashSyntax < Cop
-        MSG = 'Ruby 1.8 hash syntax detected'
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
+        MSG_HASH_ROCKETS = 'Always use hash rockets in hashes.'
 
         def on_hash(node)
+          case cop_config['EnforcedStyle']
+          when 'ruby19' then ruby19_check(node)
+          when 'hash_rockets' then hash_rockets_check(node)
+          else fail 'Unknown HashSyntax style'
+          end
+        end
+
+        def ruby19_check(node)
           pairs = *node
 
           sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
@@ -19,16 +30,34 @@ module Rubocop
             pairs.each do |pair|
               if pair.loc.operator && pair.loc.operator.is?('=>')
                 convention(pair,
-                           pair.loc.expression.begin.join(pair.loc.operator))
+                           pair.loc.expression.begin.join(pair.loc.operator),
+                           MSG_19)
               end
             end
           end
         end
 
-        def autocorrect_action(node)
+        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
+        end
+
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            replacement = node.loc.expression.source[1..-1]
-              .sub(/\s*=>\s*/, ': ')
+            if cop_config['EnforcedStyle'] == 'ruby19'
+              replacement = node.loc.expression.source[1..-1]
+                .sub(/\s*=>\s*/, ': ')
+            else
+              replacement = ':' + node.loc.expression.source
+                .sub(/:\s*/, ' => ')
+            end
             corrector.replace(node.loc.expression, replacement)
           end
         end