rubocop 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35c6cb48366134b80f6d3f42fc1486a99ed49a7f
-  data.tar.gz: d4375b85c570dee03df158ca32485af07784cf3e
+  metadata.gz: 2ad204405cb1d04fa810d54f45d8b01725f3fb1c
+  data.tar.gz: 1240e7d221d6ae7e05ec4dc59bcc633afa96c3cc
 SHA512:
-  metadata.gz: f48afa6ead4a29e196af51a92e1c5d248fe02272782edbe0b3d18e866a5707d1b0d1bd258c137ca751ab9fdc08dff713e9cb2c830679a8b987d8294cee561ffc
-  data.tar.gz: 5fb1c77cb3960f39e1b7edbd5b6babfe8227b6801feff13f3ab04a0768693916275f30c77a083d934b69f02733fe87da15c720b55fd11b4d22632b8bb9e1b4a1
+  metadata.gz: 1c8a7da40e56a46adb7a668379062a17fcf978a6df0d7c975b911e0aa1ff700ae38365aab8b1a0dbad0a70c2f2c05b461f5c49ca3c36ebc8825d04d654c90eb0
+  data.tar.gz: a180b2850a1946a6fb9b693be6ebe04ae3930fad2b1d341bbb2791347a2c32872a21ca518c277331fc3136c0e483070ea70717f46fd5f54fb426cda27b6dd373

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## master (unreleased)
 
+## 0.9.1 (05/07/2013)
+
+### New features
+
+* Added `-l/--lint` option to allow doing only linting with no style checks (similar to running `ruby -wc`).
+
+### Changes
+
+* Removed the `BlockAlignSchema` configuration option from `EndAlignment`. We now support only the default alignment schema - `StartOfAssignment`.
+* Made the preferred collection methods in `CollectionMethods` configurable.
+* Made the `DotPosition` cop configurable - now both `leading` and `trailing` styles are supported.
+
+### Bugs fixed
+
+* [#318](https://github.com/bbatsov/rubocop/issues/318) - correct some special cases of block end alignment
+* [#317](https://github.com/bbatsov/rubocop/issues/317) - fix a false positive in `LiteralInCondition`
+* [#321](https://github.com/bbatsov/rubocop/issues/321) - Ignore variables whose name start with `_` in `ShadowingOuterLocalVariable`
+* [#322](https://github.com/bbatsov/rubocop/issues/322) - Fix exception of `UnusedLocalVariable` and `ShadowingOuterLocalVariable` when inspecting keyword splat argument
+* [#316](https://github.com/bbatsov/rubocop/issues/316) - Correct nested postfix unless in `MultilineIfThen`
+* [#327](https://github.com/bbatsov/rubocop/issues/327) - Fix false offences for block expression that span on two lines in `EndAlignment`
+* [#332](https://github.com/bbatsov/rubocop/issues/332) - Fix exception of `UnusedLocalVariable` and `ShadowingOuterLocalVariable` when inspecting named captures
+* [#333](https://github.com/bbatsov/rubocop/issues/333) - Fix a case that `EnsureReturn` throws an exception when ensure has no body
+
 ## 0.9.0 (01/07/2013)
 
 ### New features

data/README.md

@@ -49,6 +49,7 @@ Command flag           | Description
 `-o/--out`             | Write output to a file instead of STDOUT
 `-r/--require`         | Require Ruby file
 `-R/--rails`           | Run extra Rails cops
+`-l/--lint`            | Run only lint cops
 `-a/--auto-correct`    | Auto-correct certain offences.
 `-s/--silent`          | Suppress the final summary
 `--only`               | Run only the specified cop

data/config/default.yml

@@ -56,3 +56,15 @@ BlockNesting:
 # character.
 RegexpLiteral:
   MaxSlashes: 1
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect: 'map'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+# Muli-line method chaining should be done with leading dots.
+DotPosition:
+  Style: 'leading'

data/config/enabled.yml

@@ -362,7 +362,6 @@ AssignmentInCondition:
 # Align ends correctly.
 EndAlignment:
   Enabled: true
-  BlockAlignSchema: StartOfAssignment
 
 # Possible use of operator/literal/variable in void context.
 Void:

data/lib/rubocop.rb

@@ -63,6 +63,9 @@ require 'rubocop/cop/style/favor_sprintf'
 require 'rubocop/cop/style/favor_unless_over_negated_if'
 require 'rubocop/cop/style/hash_syntax'
 require 'rubocop/cop/style/if_then_else'
+require 'rubocop/cop/style/if_with_semicolon'
+require 'rubocop/cop/style/multiline_if_then'
+require 'rubocop/cop/style/one_line_conditional'
 require 'rubocop/cop/style/lambda'
 require 'rubocop/cop/style/leading_comment_space'
 require 'rubocop/cop/style/line_continuation'

data/lib/rubocop/cli.rb

@@ -37,7 +37,10 @@ module Rubocop
       end
 
       # filter out Rails cops unless requested
-      @cops.reject! { |cop_klass| cop_klass.rails? } unless @options[:rails]
+      @cops.reject!(&:rails?) unless @options[:rails]
+
+      # filter out style cops when --lint is passed
+      @cops.select!(&:lint?) if @options[:lint]
 
       target_files = target_files(args)
       target_files.each(&:freeze).freeze
@@ -181,6 +184,9 @@ module Rubocop
         opts.on('-R', '--rails', 'Run extra Rails cops.') do |r|
           @options[:rails] = r
         end
+        opts.on('-l', '--lint', 'Run only lint cops.') do |l|
+          @options[:lint] = l
+        end
         opts.on('-a', '--auto-correct', 'Auto-correct offences.') do |a|
           @options[:autocorrect] = a
         end

data/lib/rubocop/cop/cop.rb

@@ -32,20 +32,35 @@ module Rubocop
       @config = {}
 
       class << self
-        attr_accessor :all
         attr_accessor :config
       end
 
+      def self.all
+        @all.clone
+      end
+
       def self.inherited(subclass)
-        all << subclass
+        @all << subclass
       end
 
       def self.cop_name
         name.to_s.split('::').last
       end
 
+      def self.cop_type
+        name.to_s.split('::')[-2].downcase.to_sym
+      end
+
+      def self.style?
+        cop_type == :style
+      end
+
+      def self.lint?
+        cop_type == :lint
+      end
+
       def self.rails?
-        false
+        cop_type == :rails
       end
 
       def initialize
@@ -116,8 +131,8 @@ module Rubocop
                        column_count)
         newline_length = 1
         begin_pos = preceding_lines.reduce(0) do |a, e|
-                      a + e.length + newline_length
-                    end + begin_column
+          a + e.length + newline_length
+        end + begin_column
         Parser::Source::Range.new(source_buffer, begin_pos,
                                   begin_pos + column_count)
       end

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

@@ -5,23 +5,19 @@ module Rubocop
     module Lint
       # This cop checks whether the end keywords are aligned properly.
       #
-      # There are two ways to align the end of a block.
-      # Set BlockAlignSchema to StartOfAssignment if you want to
-      # align the end to the beginning of assignment expression.
-      # This is the default behavior.
+      # For keywords (if, def, etc.) the end is aligned with the start
+      # of the keyword.
+      # For blocks - with the start of the expression where the block
+      # is defined.
+      #
       # @example
       #
+      #   variable = if true
+      #              end
+      #
       #   variable = lambda do |i|
       #     i
       #   end
-      #
-      # Set BlockAlignSchema to StartOfBlockCommand if you want to
-      # align the end to the beginning of the expression that called the block.
-      # @example
-      #
-      #   variable = lambda do |i|
-      #                i
-      #              end
       class EndAlignment < Cop
         MSG = 'end at %d, %d is not aligned with %s at %d, %d'
 
@@ -78,14 +74,25 @@ module Rubocop
           super
         end
 
-        def on_lvasgn(node)
-          if align_with_start_of_assignment?
-            _, children = *node
-            process_block_assignment(node, children)
+        def on_and(node)
+          return if already_processed_node?(node)
+
+          _left, right = *node
+          if right.type == :block
+            check_block_alignment(node.loc.expression, right.loc)
+            @inspected_blocks << right
           end
           super
         end
 
+        alias_method :on_or, :on_and
+
+        def on_lvasgn(node)
+          _, children = *node
+          process_block_assignment(node, children)
+          super
+        end
+
         alias_method :on_ivasgn,   :on_lvasgn
         alias_method :on_cvasgn,   :on_lvasgn
         alias_method :on_gvasgn,   :on_lvasgn
@@ -93,43 +100,50 @@ module Rubocop
         alias_method :on_or_asgn,  :on_lvasgn
 
         def on_casgn(node)
-          if align_with_start_of_assignment?
-            _, _, children = *node
-            process_block_assignment(node, children)
-          end
+          _, _, children = *node
+          process_block_assignment(node, children)
           super
         end
 
         def on_op_asgn(node)
-          if align_with_start_of_assignment?
-            variable, _op, args = *node
-            process_block_assignment(variable, args)
-          end
+          variable, _op, args = *node
+          process_block_assignment(variable, args)
           super
         end
 
         def on_send(node)
-          if align_with_start_of_assignment?
-            receiver, method, args = *node
-            if attribute_writer?(method)
-              process_block_assignment(receiver, args)
-            end
-          end
+          _receiver, _method, *args = *node
+          process_block_assignment(node, args.last)
           super
         end
 
         def on_masgn(node)
-          if align_with_start_of_assignment?
-            variables, args = *node
-            process_block_assignment(variables, args)
-          end
+          variables, args = *node
+          process_block_assignment(variables, args)
           super
         end
 
         private
 
         def process_block_assignment(begin_node, block_node)
-          if block_node && block_node.type == :block
+          return unless block_node
+          return if already_processed_node?(block_node)
+
+          while block_node.type == :send
+            receiver, _method, args = *block_node
+            if receiver && [:block, :send].include?(receiver.type)
+              block_node = receiver
+            elsif args && [:block, :send].include?(args.type)
+              block_node = args
+            else
+              break
+            end
+          end
+          if block_node.type == :block
+            # Align with the expression that is on the same line
+            # where the block is defined
+            return if block_is_on_next_line?(begin_node, block_node)
+
             @inspected_blocks << block_node
             check_block_alignment(begin_node.loc.expression, block_node.loc)
           end
@@ -137,7 +151,6 @@ module Rubocop
 
         def check_block_alignment(start_loc, block_loc)
           end_loc = block_loc.end
-
           if block_loc.begin.line != end_loc.line &&
                start_loc.column != end_loc.column
             add_offence(:warning,
@@ -167,12 +180,8 @@ module Rubocop
           @inspected_blocks.include?(node)
         end
 
-        def attribute_writer?(method)
-          method.to_s[-1] == '='
-        end
-
-        def align_with_start_of_assignment?
-          EndAlignment.config['BlockAlignSchema'] == 'StartOfAssignment'
+        def block_is_on_next_line?(begin_node, block_node)
+          begin_node.loc.line != block_node.loc.line
         end
       end
     end

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

@@ -12,7 +12,7 @@ module Rubocop
 
           on_node(:return, ensure_body) do |e|
             add_offence(:warning, e.loc.expression, MSG)
-          end
+          end if ensure_body
 
           super
         end

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

@@ -3,8 +3,20 @@
 module Rubocop
   module Cop
     module Lint
-      # This cop checks for literals used as operands in and/or
-      # expressions in the conditions of if/while/until.
+      # This cop checks for literals used as the conditions or as
+      # operands in and/or expressions serving as the conditions of
+      # if/while/until.
+      #
+      # @example
+      #
+      #   if 20
+      #     do_something
+      #   end
+      #
+      #   if some_var && true
+      #     do_something
+      #   end
+      #
       class LiteralInCondition < Cop
         MSG = 'Literal %s appeared in a condition.'
 
@@ -46,15 +58,53 @@ module Rubocop
         def check_for_literal(node)
           cond, = *node
 
-          on_node([:and, :or], cond) do |logic_node|
-            *operands = *logic_node
-            operands.each do |op|
-              if LITERALS.include?(op.type)
-                add_offence(:warning, op.loc.expression,
-                            format(MSG, op.loc.expression.source))
+          # if the cond node is literal we obviously have a problem
+          if literal?(cond)
+            add_offence(:warning, cond.loc.expression,
+                        format(MSG, cond.loc.expression.source))
+          else
+            # alternatively we have to consider a logical node with a
+            # literal argument
+            check_node(cond)
+          end
+        end
+
+        def not?(node)
+          return false unless node && node.type == :send
 
-              end
+          _receiver, method_name, *_args = *node
+
+          method_name == :!
+        end
+
+        def literal?(node)
+          LITERALS.include?(node.type)
+        end
+
+        def check_node(node)
+          return unless node
+
+          if not?(node)
+            receiver, = *node
+
+            handle_node(receiver)
+          elsif [:and, :or].include?(node.type)
+            *operands = *node
+            operands.each do |op|
+              handle_node(op)
             end
+          elsif node.type == :begin && node.children.size == 1
+            child_node = node.children.first
+            handle_node(child_node)
+          end
+        end
+
+        def handle_node(node)
+          if literal?(node)
+            add_offence(:warning, node.loc.expression,
+                        format(MSG, node.loc.expression.source))
+          elsif [:send, :and, :or, :begin].include?(node.type)
+            check_node(node)
           end
         end
       end

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

@@ -20,6 +20,7 @@ module Rubocop
           # Only block scope can reference outer local variables.
           return unless variable_table.current_scope.node.type == :block
           return unless ARGUMENT_DECLARATION_TYPES.include?(entry.node.type)
+          return if entry.name.to_s.start_with?('_')
 
           outer_local_variable = variable_table.find_variable_entry(entry.name)
           return unless outer_local_variable

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

@@ -17,10 +17,6 @@ module Rubocop
                      :validates_presence_of,
                      :validates_size_of]
 
-        def self.rails?
-          true
-        end
-
         def on_send(node)
           receiver, method_name, *_args = *node
 

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

@@ -12,22 +12,40 @@ module Rubocop
       class CollectionMethods < Cop
         MSG = 'Prefer %s over %s.'
 
-        PREFERRED_METHODS = {
-          collect: 'map',
-          inject: 'reduce',
-          detect: 'find',
-          find_all: 'select'
-        }
+        def self.preferred_methods
+          Util.symbolize_keys(config['PreferredMethods'])
+        end
+
+        def on_block(node)
+          method, _args, _body = *node
+
+          check_method_node(method)
+
+          super
+        end
 
         def on_send(node)
-          receiver, method_name, *_args = *node
+          _receiver, _method_name, *args = *node
+
+          if args.size == 1 && args.first.type == :block_pass
+            check_method_node(node)
+          end
+
+          super
+        end
+
+        private
+
+        def check_method_node(node)
+          _receiver, method_name, *_args = *node
 
-          # a simple(but flawed way) to reduce false positives
-          if receiver && PREFERRED_METHODS[method_name]
+          if self.class.preferred_methods[method_name]
             add_offence(
               :convention,
               node.loc.selector,
-              sprintf(MSG, PREFERRED_METHODS[method_name], method_name)
+              sprintf(MSG,
+                      self.class.preferred_methods[method_name],
+                      method_name)
             )
           end
         end