rubocop 0.13.0 → 0.13.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93f1416caf62b3dbb7452feeeb5be8b017bf3926
+  data.tar.gz: 6de08a58bf2d425bb08411fd33f0e20e9515bba6
+SHA512:
+  metadata.gz: 59017f0bc97a22ee8b1ed0795d14cafa479992b8e5338af31c8db0dd0dc3c9b0a999799a2a01cf6843e6f39c10e03cacd87c88bdcf3d8455962f1187be033fc2
+  data.tar.gz: a54661cf2a09e2078ed40b5fb0e3649356d82a2fb2a6f4821b9837e1c1975a0df23c4f25178b7ed782f17b04634d696cfc87316e2f587929d9ead94c195d701b

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master (unreleased)
 
+## 0.13.1 (19/09/2013)
+
+### New features
+
+* `HashSyntax` cop does auto-correction.
+* Allow calls to self to fix name clash with argument [#484](https://github.com/bbatsov/rubocop/pull/484)
+* Renamed `SpaceAroundBraces` to `SpaceAroundBlockBraces`.
+* `SpaceAroundBlockBraces` now has a `NoSpaceBeforeBlockParameters` config option to enforce a style for blocks with parameters like `{|foo| puts }`.
+* New cop `LambdaCall` tracks uses of the obscure `lambda.(...)` syntax
+
+### Bugs fixed
+
+* Fix crash on empty input file in `FinalNewline`.
+* [#485](https://github.com/bbatsov/rubocop/issues/485) - Fix crash on multiple-assignment and op-assignment in `UselessSetterCall`.
+* [#497](https://github.com/bbatsov/rubocop/issues/497) - Fix crash in `UselessComparison` and `NilComparison`
+
+## 0.13.0 (13/09/2013)
+
 ### New features
 
 * New configuration parameter `AllowAdjacentOneLineDefs` for `EmptyLineBetweenDefs`.

data/config/default.yml

@@ -22,6 +22,10 @@ MethodLength:
   CountComments: false  # count full line comments?
   Max: 10
 
+SpaceAroundBlockBraces:
+  Description: 'Use spaces around { and before } in blocks.'
+  NoSpaceBeforeBlockParameters: false
+
 ParameterLists:
   Description: 'Avoid parameter lists longer than five parameters.'
   Max: 5

data/config/enabled.yml

@@ -44,8 +44,8 @@ SpaceAroundOperators:
   Description: 'Use spaces around operators.'
   Enabled: true
 
-SpaceAroundBraces:
-  Description: 'Use spaces around { and before }.'
+SpaceAroundBlockBraces:
+  Description: 'Use spaces around { and before } in blocks.'
   Enabled: true
 
 SpaceInsideParens:
@@ -127,7 +127,7 @@ Blocks:
 
 
 ParameterLists:
-  Description: Avoid parameter lists longer than three or four parameters.
+  Description: 'Avoid parameter lists longer than three or four parameters.'
   Enabled: true
 
 StringLiterals:
@@ -194,6 +194,10 @@ Lambda:
   Description: 'Use the new lambda literal syntax for single-line blocks.'
   Enabled: true
 
+LambdaCall:
+  Description: 'Use lambda.call(...) instead of lambda.(...).'
+  Enabled: true
+
 Proc:
   Description: 'Use proc instead of Proc.new.'
   Enabled: true
@@ -239,7 +243,7 @@ VariableInterpolation:
   Enabled: true
 
 Semicolon:
-  Desription: "Don't use semicolons to terminate expressions."
+  Description: "Don't use semicolons to terminate expressions."
   Enabled: true
 
 FavorSprintf:
@@ -441,11 +445,11 @@ SpaceAfterMethodName:
   Enabled: true
 
 HashMethods:
-  Description: Checks for use of deprecated Hash methods.
+  Description: 'Checks for use of deprecated Hash methods.'
   Enabled: true
 
 MultilineBlockChain:
-  Description: Avoid multi-line chains of blocks.
+  Description: 'Avoid multi-line chains of blocks.'
   Enabled: true
 
 AlignHash:
@@ -461,7 +465,7 @@ AlignArray:
   Enabled: true
 
 SpaceBeforeModifierKeyword:
-  Description: Put a space before the modifier keyword.
+  Description: 'Put a space before the modifier keyword.'
   Enabled: true
 
 #################### Lint ################################
@@ -532,11 +536,11 @@ ParenthesesAsGroupedExpression:
 ##################### Rails ##################################
 
 HasAndBelongsToMany:
-  Description: Prefer has_many :through to has_and_belongs_to_many.
+  Description: 'Prefer has_many :through to has_and_belongs_to_many.'
   Enabled: true
 
 ReadAttribute:
-  Description: Prefer self[:attribute] over read_attribute(:attribute).
+  Description: 'Prefer self[:attribute] over read_attribute(:attribute).'
   Enabled: true
 
 Validation:

data/lib/rubocop.rb

@@ -1,12 +1,13 @@
 # encoding: utf-8
 
-require 'backports/2.0.0/array/bsearch'
 require 'rainbow'
 require 'English'
 require 'parser/current'
 require 'ast/sexp'
 require 'powerpack'
 
+require 'rubocop/backports/bsearch'
+
 require 'rubocop/cop/util'
 require 'rubocop/cop/offence'
 require 'rubocop/cop/cop'
@@ -41,6 +42,8 @@ require 'rubocop/cop/lint/useless_comparison'
 require 'rubocop/cop/lint/useless_setter_call'
 require 'rubocop/cop/lint/void'
 
+require 'rubocop/cop/style/autocorrect_alignment'
+require 'rubocop/cop/style/string_help'
 require 'rubocop/cop/style/access_control'
 require 'rubocop/cop/style/alias'
 require 'rubocop/cop/style/align_array'
@@ -87,6 +90,7 @@ require 'rubocop/cop/style/if_then_else'
 require 'rubocop/cop/style/if_with_semicolon'
 require 'rubocop/cop/style/indentation_width'
 require 'rubocop/cop/style/lambda'
+require 'rubocop/cop/style/lambda_call'
 require 'rubocop/cop/style/leading_comment_space'
 require 'rubocop/cop/style/line_length'
 require 'rubocop/cop/style/method_and_variable_snake_case'

data/lib/rubocop/backports/bsearch.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+# rubocop:disable LineLength
+# rubocop:disable BlockNesting
+
+unless Array.method_defined? :bsearch
+  # Backport of Array#bsearch from Ruby 2.0.
+  # Needed to boost Parser's performance under Ruby 1.9.
+  class Array
+    def bsearch
+      return to_enum(__method__) unless block_given?
+      from = 0
+      to   = size - 1
+      satisfied = nil
+      while from <= to
+        midpoint = (from + to).div(2)
+        result = yield(cur = self[midpoint])
+        case result
+        when Numeric
+          return cur if result == 0
+          result = result < 0
+        when true
+          satisfied = cur
+        when nil, false
+          # nothing to do
+        else
+          fail TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)"
+        end
+
+        if result
+          to = midpoint - 1
+        else
+          from = midpoint + 1
+        end
+      end
+      satisfied
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_comparison.rb

@@ -14,6 +14,8 @@ module Rubocop
         OPS = %w(== === != < > <= >= <=>)
 
         def on_send(node)
+          # lambda.() does not have a selector
+          return unless node.loc.selector
           op = node.loc.selector.source
 
           if OPS.include?(op)

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -14,6 +14,7 @@ module Rubocop
       #  end
       class UselessSetterCall < Cop
         MSG = 'Useless setter call to local variable %s.'
+        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
 
         def on_def(node)
           _name, args, body = *node
@@ -42,9 +43,10 @@ module Rubocop
 
           return unless setter_call_to_local_variable?(last_expr)
 
+          tracker = MethodVariableTracker.new(args, body)
           receiver, = *last_expr
           var_name, = *receiver
-          return if contains_object_passed_as_argument?(var_name, body, args)
+          return if tracker.contain_object_passed_as_argument?(var_name)
 
           warning(receiver,
                   :name,
@@ -58,26 +60,99 @@ module Rubocop
           method =~ /\w=$/
         end
 
-        def contains_object_passed_as_argument?(lvar_name, body, args)
-          variable_table = {}
+        # This class tracks variable assignments in a method body
+        # and if a variable contains object passed as argument at the end of
+        # the method.
+        class MethodVariableTracker
+          def initialize(args_node, body_node)
+            @args_node = args_node
+            @body_node = body_node
+          end
+
+          def contain_object_passed_as_argument?(variable_name)
+            return @table[variable_name] if @table
+
+            @table = {}
+
+            @args_node.children.each do |arg_node|
+              arg_name, = *arg_node
+              @table[arg_name] = true
+            end
+
+            scan(@body_node) do |node|
+              case node.type
+              when :masgn
+                process_multiple_assignment(node)
+              when :or_asgn, :and_asgn
+                process_logical_operator_assignment(node)
+              when :op_asgn
+                process_binary_operator_assignment(node)
+              when *ASSIGNMENT_TYPES
+                _, rhs_node = *node
+                process_assignment(node, rhs_node)
+              end
+            end
 
-          args.children.each do |arg_node|
-            arg_name, = *arg_node
-            variable_table[arg_name] = true
+            @table[variable_name]
           end
 
-          on_node([:lvasgn, :ivasgn, :cvasgn, :gvasgn], body) do |asgn_node|
-            lhs_var_name, rhs_node = *asgn_node
+          def scan(node, &block)
+            catch(:skip_children) do
+              yield node
+
+              node.children.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                scan(child, &block)
+              end
+            end
+          end
+
+          def process_multiple_assignment(masgn_node)
+            mlhs_node, mrhs_node = *masgn_node
+
+            mlhs_node.children.each_with_index do |lhs_node, index|
+              next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+              lhs_variable_name, = *lhs_node
+              rhs_node = mrhs_node.children[index]
+
+              if mrhs_node.type == :array && rhs_node
+                process_assignment(lhs_variable_name, rhs_node)
+              else
+                table[lhs_variable_name] = false
+              end
+            end
+
+            throw :skip_children
+          end
+
+          def process_logical_operator_assignment(asgn_node)
+            lhs_node, rhs_node = *asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            process_assignment(lhs_node, rhs_node)
+
+            throw :skip_children
+          end
+
+          def process_binary_operator_assignment(op_asgn_node)
+            lhs_node, = *op_asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            lhs_variable_name, = *lhs_node
+            @table[lhs_variable_name] = false
+
+            throw :skip_children
+          end
+
+          def process_assignment(asgn_node, rhs_node)
+            lhs_variable_name, = *asgn_node
 
             if [:lvar, :ivar, :cvar, :gvar].include?(rhs_node.type)
-              rhs_var_name, = *rhs_node
-              variable_table[lhs_var_name] = variable_table[rhs_var_name]
+              rhs_variable_name, = *rhs_node
+              @table[lhs_variable_name] = @table[rhs_variable_name]
             else
-              variable_table[lhs_var_name] = false
+              @table[lhs_variable_name] = false
             end
           end
-
-          variable_table[lvar_name]
         end
       end
     end

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

@@ -6,6 +6,8 @@ module Rubocop
       # Here we check if the elements of a multi-line array literal are
       # aligned.
       class AlignArray < Cop
+        include AutocorrectAlignment
+
         MSG = 'Align the elements of an array literal if they span more ' +
           'than one line.'
 
@@ -21,26 +23,6 @@ module Rubocop
             end
           end
         end
-
-        def autocorrect_action(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
-          # problem.
-          column_delta = @column_delta
-
-          @corrections << lambda do |corrector|
-            expr = node.loc.expression
-            if column_delta > 0
-              corrector.replace(expr, ' ' * column_delta + expr.source)
-            else
-              range = Parser::Source::Range.new(expr.source_buffer,
-                                                expr.begin_pos + column_delta,
-                                                expr.end_pos)
-              corrector.replace(range, expr.source)
-            end
-          end
-        end
       end
     end
   end

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

@@ -6,6 +6,8 @@ module Rubocop
       # Here we check if the parameters on a multi-line method call are
       # aligned.
       class AlignParameters < Cop
+        include AutocorrectAlignment
+
         MSG = 'Align the parameters of a method call if they span ' +
           'more than one line.'
 
@@ -27,26 +29,6 @@ module Rubocop
             end
           end
         end
-
-        def autocorrect_action(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
-          # problem.
-          column_delta = @column_delta
-
-          @corrections << lambda do |corrector|
-            expr = node.loc.expression
-            if column_delta > 0
-              corrector.replace(expr, ' ' * column_delta + expr.source)
-            else
-              range = Parser::Source::Range.new(expr.source_buffer,
-                                                expr.begin_pos + column_delta,
-                                                expr.end_pos)
-              corrector.replace(range, expr.source)
-            end
-          end
-        end
       end
     end
   end

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

@@ -10,7 +10,7 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            convention(comment, :expression) if comment.text =~ /[^\x00-\x7f]/
+            convention(comment, :expression) unless comment.text.ascii_only?
           end
         end
       end

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

@@ -11,7 +11,7 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.tokens.each do |t|
-            if t.type == :tIDENTIFIER && t.text =~ /[^\x00-\x7f]/
+            if t.type == :tIDENTIFIER && !t.text.ascii_only?
               convention(nil, t.pos)
             end
           end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This module does auto-correction of nodes that should just be moved to
+      # the left or to the right, amount being determined by the instance
+      # variable @column_delta.
+      module AutocorrectAlignment
+        def autocorrect_action(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
+          # problem.
+          column_delta = @column_delta
+
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            if column_delta > 0
+              corrector.replace(expr, ' ' * column_delta + expr.source)
+            else
+              range = Parser::Source::Range.new(expr.source_buffer,
+                                                expr.begin_pos + column_delta,
+                                                expr.end_pos)
+              corrector.replace(range, expr.source)
+            end
+          end
+        end
+      end
+    end
+  end
+end