rubocop 0.11.1 → 0.12.0

data/lib/rubocop/cop/rails/read_attribute.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for the use of the read_attribute method.
+      #
+      # @example
+      #
+      #   # bad
+      #   read_attributed(:attr)
+      #
+      #   # good
+      #   self[:attr]
+      class ReadAttribute < Cop
+        MSG = 'Prefer self[:attribute] over read_attribute(:attribute).'
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          if receiver.nil? && method_name == :read_attribute
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,7 +17,11 @@ module Rubocop
         def investigate(processed_source)
           ast = processed_source.ast
           return unless ast
-          on_node([:class, :module, :sclass], ast) do |class_node|
+          on_node([:class, :module, :sclass, :block], ast) do |class_node|
+            if class_node.type == :block && !class_constructor?(class_node)
+              next
+            end
+
             class_start_col = class_node.loc.expression.column
 
             # we'll have to walk all class children nodes
@@ -50,6 +54,13 @@ module Rubocop
 
         private
 
+        def class_constructor?(block_node)
+          send_node = block_node.children.first
+          receiver_node, method_name, *_ = *send_node
+          return false unless method_name == :new
+          %w(Class Module).include?(Util.const_name(receiver_node))
+        end
+
         def modifier_node?(node)
           [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
         end

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

@@ -10,6 +10,13 @@ module Rubocop
         def on_send(node)
           if command?(:attr, node)
             add_offence(:convention, node.loc.selector, MSG)
+            do_autocorrect(node)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector, 'attr_reader')
           end
         end
       end

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

@@ -32,6 +32,13 @@ module Rubocop
           end
         end
 
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+
         private
 
         def check_method_node(node)
@@ -42,11 +49,16 @@ module Rubocop
               :convention,
               node.loc.selector,
               sprintf(MSG,
-                      self.class.preferred_methods[method_name],
+                      preferred_method(method_name),
                       method_name)
             )
+            do_autocorrect(node)
           end
         end
+
+        def preferred_method(method)
+          self.class.preferred_methods[method.to_sym]
+        end
       end
     end
   end

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

@@ -17,7 +17,7 @@ module Rubocop
 
           # We cannot know the result of method calls line
           # NewClass = something_that_returns_a_class
-          unless value && value.type == :send
+          unless value && [:send, :block].include?(value.type)
             if const_name !~ SNAKE_CASE
               add_offence(:convention, node.loc.name, MSG)
             end

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

@@ -19,6 +19,7 @@ module Rubocop
           _, args = *node
           if args.children == [] && args.loc.begin
             add_offence(:convention, args.loc.begin, MSG)
+            do_autocorrect(args)
           end
         end
 
@@ -31,6 +32,14 @@ module Rubocop
           _, _, args = *node
           if args.children == [] && args.loc.begin
             add_offence(:convention, args.loc.begin, MSG)
+            do_autocorrect(args)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
       end
@@ -46,6 +55,7 @@ module Rubocop
 
           if args.children.size > 0 && args.loc.begin.nil?
             add_offence(:convention, args.loc.expression, MSG)
+            do_autocorrect(args)
           end
         end
 
@@ -54,6 +64,14 @@ module Rubocop
 
           if args.children.size > 0 && args.loc.begin.nil?
             add_offence(:convention, args.loc.expression, MSG)
+            do_autocorrect(args)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(node.loc.expression, '(')
+            corrector.insert_after(node.loc.expression, ')')
           end
         end
       end

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

@@ -29,7 +29,7 @@ module Rubocop
           on_node(:class, ast) do |node|
             _name, _superclass, body = *node
 
-            if body != nil && ast_with_comments[node].empty?
+            if body && ast_with_comments[node].empty?
               add_offence(:convention, node.loc.keyword, format(MSG, 'class'))
             end
           end

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

@@ -36,19 +36,33 @@ module Rubocop
             add_offence(:convention,
                         node.loc.expression,
                         ARR_MSG)
+            do_autocorrect(node)
           when HASH_NODE
             add_offence(:convention,
                         node.loc.expression,
                         HASH_MSG)
+            do_autocorrect(node)
           when STR_NODE
             add_offence(:convention,
                         node.loc.expression,
                         STR_MSG)
+            do_autocorrect(node)
           end
         end
 
         # TODO: Check block contents as well.
         alias_method :on_block, :ignore_node
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            name = case node
+                   when ARRAY_NODE then '[]'
+                   when HASH_NODE then '{}'
+                   when STR_NODE then "''"
+                   end
+            corrector.replace(node.loc.expression, name)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for places where Fixnum#even? or Fixnum#odd?
+      # should have been used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #
+      #   # good
+      #   if x.even?
+      class EvenOdd < Cop
+        MSG_EVEN = 'Use Fixnum.even?'
+        MSG_ODD = 'Use Fixnum.odd?'
+
+        ZERO = s(:int, 0)
+        ONE = s(:int, 1)
+        TWO = s(:int, 2)
+
+        def on_send(node)
+          receiver, method, args = *node
+
+          return unless method == :==
+          return unless div_by_2?(receiver)
+
+          if args == ZERO
+            add_offence(:convention, node.loc.expression, MSG_EVEN)
+          elsif args == ONE
+            add_offence(:convention, node.loc.expression, MSG_ODD)
+          end
+        end
+
+        private
+
+        def div_by_2?(node)
+          return unless node
+
+          # check for scenarios like (x % 2) == 0
+          if node.type == :begin && node.children.size == 1
+            node = node.children.first
+          end
+
+          return unless node.type == :send
+
+          _receiver, method, args = *node
+
+          method == :% && args == TWO
+        end
+      end
+    end
+  end
+end

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

@@ -71,7 +71,7 @@ module Rubocop
             next if if_else?(node)
 
             if check(node, processed_source.comments)
-              add_offence(:convention, node.loc.expression, error_message)
+              add_offence(:convention, node.loc.keyword, error_message)
             end
           end
         end
@@ -108,7 +108,7 @@ module Rubocop
             next unless node.loc.end
 
             if check(node, processed_source.comments)
-              add_offence(:convention, node.loc.expression, MSG)
+              add_offence(:convention, node.loc.keyword, MSG)
             end
           end
         end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the deprecated methods Hash#has_key?
+      # and Hash#has_value?
+      class HashMethods < Cop
+        MSG = '%s is deprecated in favor of %s.'
+
+        DEPRECATED_METHODS = [:has_key?, :has_value?]
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
+            add_offence(:convention,
+                        node.loc.selector,
+                        MSG.format(method_name,
+                                   proper_method_name(method_name)))
+            do_autocorrect(node)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              proper_method_name(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def proper_method_name(method_name)
+          method_name.to_s.sub(/has_/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for indentation that doesn't use two spaces.
+      #
+      # @example
+      #
+      # class A
+      #  def test
+      #   puts 'hello'
+      #  end
+      # end
+      class IndentationWidth < Cop
+        CORRECT_INDENTATION = 2
+        MSG = "Use #{CORRECT_INDENTATION} (not %d) spaces for indentation."
+
+        def on_kwbegin(node)
+          node.children.each { |c| check_indentation(node.loc.end, c) }
+        end
+
+        def on_block(node)
+          _method, _args, body = *node
+          # Check body against end/} indentation. Checking against variable
+          # assignments, etc, would be more difficult.
+          check_indentation(node.loc.end, body)
+        end
+
+        def on_module(node)
+          _module_name, *members = *node
+          members.each { |m| check_indentation(node.loc.keyword, m) }
+        end
+
+        def on_class(node)
+          _class_name, _base_class, *members = *node
+          members.each { |m| check_indentation(node.loc.keyword, m) }
+        end
+
+        def on_def(node)
+          _method_name, _args, body = *node
+          check_indentation(node.loc.keyword, body)
+        end
+
+        def on_defs(node)
+          _scope, _method_name, _args, body = *node
+          check_indentation(node.loc.keyword, body)
+        end
+
+        def on_for(node)
+          _variable, _collection, body = *node
+          check_indentation(node.loc.keyword, body)
+        end
+
+        def on_while(node)
+          _condition, body = *node
+          check_indentation(node.loc.keyword, body)
+        end
+
+        alias_method :on_until, :on_while
+
+        def on_case(node)
+          _condition, *branches = *node
+          latest_when = nil
+          branches.compact.each do |b|
+            if b.type == :when
+              _condition, body = *b
+              # Check "when" body against "when" keyword indentation.
+              check_indentation(b.loc.keyword, body)
+              latest_when = b
+            else
+              # Since it's not easy to get the position of the "else" keyword,
+              # we check "else" body against latest "when" keyword indentation.
+              check_indentation(latest_when.loc.keyword, b)
+            end
+          end
+        end
+
+        def on_if(node)
+          return if ternary_op?(node)
+          return if modifier_if?(node)
+
+          case node.loc.keyword.source
+          when 'if'     then _condition, body, else_clause = *node
+          when 'unless' then _condition, else_clause, body = *node
+          else               _condition, body = *node
+          end
+
+          check_if(node, body, else_clause) if body
+        end
+
+        private
+
+        def check_if(node, body, else_clause)
+          return if ternary_op?(node)
+          # Don't check if expression is on same line as "then" keyword.
+          check_indentation(node.loc.keyword, body)
+          if else_clause
+            if elsif?(else_clause)
+              _condition, inner_body, inner_else_clause = *else_clause
+              check_if(else_clause, inner_body, inner_else_clause)
+            else
+              check_indentation(node.loc.keyword, else_clause)
+            end
+          end
+        end
+
+        def modifier_if?(node)
+          node.loc.end.nil?
+        end
+
+        def ternary_op?(node)
+          node.loc.respond_to?(:question)
+        end
+
+        def elsif?(node)
+          node.loc.respond_to?(:keyword) && node.loc.keyword &&
+            node.loc.keyword.is?('elsif')
+        end
+
+        def check_indentation(base_loc, body_node)
+          return unless body_node
+          return if body_node.loc.line == base_loc.line
+          # Don't check indentation if the line doesn't start with the body.
+          # For example lines like "else do_something".
+          first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
+          return unless body_node.loc.column == first_char_pos_on_line
+
+          indentation = body_node.loc.column - base_loc.column
+          if indentation != CORRECT_INDENTATION
+            expr = body_node.loc.expression
+            begin_pos, end_pos = if indentation >= 0
+                                   [expr.begin_pos - indentation,
+                                    expr.begin_pos]
+                                 else
+                                   [expr.begin_pos,
+                                    expr.begin_pos - indentation]
+                                 end
+            add_offence(:convention,
+                        Parser::Source::Range.new(expr.source_buffer,
+                                                  begin_pos, end_pos),
+                        sprintf(MSG, indentation))
+          end
+        end
+      end
+    end
+  end
+end