rubocop 0.20.0 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bfa5cdcf23439710744d9065a22970e4c30918d
-  data.tar.gz: c931f4765d359ef1bf54ebb76c5393e6d0c223de
+  metadata.gz: e091003352d55c98a9579dc743d9ab5542a32229
+  data.tar.gz: a1840b93e9ee0d9cac37c4a9e3749acf17fca02b
 SHA512:
-  metadata.gz: cd67703e4e607f48f45618e3c28a250528dd658ab9d7258e93ad678978e6c17f1d0c47d57a4eafe0adbd1f796450de89f4d62fa144c008f343db8dfc314b32c6
-  data.tar.gz: c9812cfa4889a4f15c1f81bef017f5e256551cbcc43716f501609a06ef8d518b6514ed98a7c1784cadfe805db23b6e5180932551767b8e35b88050fbde557c30
+  metadata.gz: 6f9ac51993ab31b7b6c0a9ffdd1ab5136a024cf5d341891e71ad5af0f1ef08cbb09f77759dbe8aefd0a64f04a306b64649f1c53c6977b0c2d4436786d04ed5ef
+  data.tar.gz: 8a78d285ece4159fade45e13ee06af7286632a1176130760dbd8c2599efc288ee6d7abf88775a1a3127e2879b2fe475219ed19fadd069125a7763ee00352e724

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master (unreleased)
 
+## 0.20.1 (05/04/2014)
+
+### Bugs fixed
+
+* [#940](https://github.com/bbatsov/rubocop/issues/940): Fixed `UselessAccessModifier` not handling `attr_*` correctly. ([@fshowalter][])
+* `NegatedIf` properly handles negated `unless` condition. ([@bbatsov][])
+* `NegatedWhile` properly handles negated `until` condition. ([@bbatsov][])
+* [#925](https://github.com/bbatsov/rubocop/issues/925): Do not disable the `Syntax` cop in output from `--auto-gen-config`. ([@jonas054][])
+* [#943](https://github.com/bbatsov/rubocop/issues/943): Fix auto-correction interference problem between `SpaceAfterComma` and other cops. ([@jonas054][])
+* [#954](https://github.com/bbatsov/rubocop/pull/954): Fix auto-correction bug in `NilComparison`. ([@bbatsov][])
+* [#953](https://github.com/bbatsov/rubocop/pull/953): Fix auto-correction bug in `NonNilCheck`. ([@bbatsov][])
+* [#952](https://github.com/bbatsov/rubocop/pull/952): Handle implicit receiver in `StringConversionInInterpolation`. ([@bbatsov][])
+* [#956](https://github.com/bbatsov/rubocop/pull/956): Apply `ClassMethods` check only on `class`/`module` bodies. ([@bbatsov][])
+* [#945](https://github.com/bbatsov/rubocop/issues/945): Fix SpaceBeforeFirstArg cop for multiline argument and exclude assignments. ([@cschramm][])
+* [#948](https://github.com/bbatsov/rubocop/issues/948): `Blocks` cop avoids auto-correction if it would introduce a semantic change. ([@jonas054][])
+* [#946](https://github.com/bbatsov/rubocop/issues/946): Allow non-nil checks that are the final expressions of predicate method definitions in `NonNilCheck`. ([@bbatsov][])
+* [#957](https://github.com/bbatsov/rubocop/issues/957): Allow space + comment inside parentheses, braces, and square brackets. ([@jonas054][])
+
 ## 0.20.0 (02/04/2014)
 
 ### New features
@@ -56,7 +74,6 @@
 * [#927](https://github.com/bbatsov/rubocop/issues/927): Let `--auto-gen-config` overwrite an existing `rubocop-todo.yml` file instead of asking the user to remove it. ([@jonas054][])
 * [#936](https://github.com/bbatsov/rubocop/issues/936): Allow `_other` as well as `other` in `OpMethod`. ([@bbatsov][])
 
-
 ## 0.19.1 (17/03/2014)
 
 ### Bugs fixed
@@ -831,3 +848,4 @@
 [@hiroponz]: https://github.com/hiroponz
 [@tamird]: https://github.com/tamird
 [@fshowalter]: https://github.com/fshowalter
+[@cschramm]: https://github.com/cschramm

data/lib/rubocop.rb

@@ -47,6 +47,7 @@ require 'rubocop/cop/variable_inspector/variable_table'
 require 'rubocop/cop/mixin/annotation_comment'
 require 'rubocop/cop/mixin/array_syntax'
 require 'rubocop/cop/mixin/autocorrect_alignment'
+require 'rubocop/cop/mixin/autocorrect_unless_changing_ast'
 require 'rubocop/cop/mixin/check_assignment'
 require 'rubocop/cop/mixin/check_methods'
 require 'rubocop/cop/mixin/configurable_max'

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

@@ -20,6 +20,7 @@ module Rubocop
           _receiver, method_name, *args = *node
           return if args.empty?
           return if operator?(method_name)
+          return if method_name.to_s.end_with?('=')
 
           # Setter calls with parentheses are parsed this way. The parentheses
           # belong to the argument, not the send node.
@@ -28,7 +29,7 @@ module Rubocop
           arg1 = args.first.loc.expression
           arg1_with_space = range_with_surrounding_space(arg1, :left)
 
-          add_offense(nil, arg1) if arg1_with_space.source =~ /^\S/
+          add_offense(nil, arg1) if arg1_with_space.source =~ /\A\S/
         end
       end
     end

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

@@ -10,17 +10,22 @@ module Rubocop
       #
       #   "result is #{something.to_s}"
       class StringConversionInInterpolation < Cop
-        MSG = 'Redundant use of `Object#to_s` in interpolation.'
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
             next unless final_node && final_node.type == :send
 
-            _receiver, method_name, *args = *final_node
+            receiver, method_name, *args = *final_node
 
             if method_name == :to_s && args.empty?
-              add_offense(final_node, :selector)
+              add_offense(
+                final_node,
+                :selector,
+                receiver ? MSG_DEFAULT : MSG_SELF
+              )
             end
           end
         end
@@ -32,7 +37,11 @@ module Rubocop
             receiver, _method_name, *_args = *node
             corrector.replace(
               node.loc.expression,
-              receiver.loc.expression.source
+              if receiver
+                receiver.loc.expression.source
+              else
+                'self'
+              end
             )
           end
         end

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

@@ -21,7 +21,7 @@ module Rubocop
           body_nodes = body.type == :begin ? body.children : [body]
 
           body_nodes.each do |child_node|
-            check_for_access_modifier(child_node)
+            check_for_access_modifier(child_node) ||
             check_for_instance_method(child_node)
           end
 
@@ -39,7 +39,8 @@ module Rubocop
         end
 
         def check_for_instance_method(node)
-          return unless node.type == :def
+          return unless node.type == :def ||
+            node.type == :send
 
           @access_modifier_node = nil
         end

data/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # This module does auto-correction of nodes that could become grammatically
+    # different after the correction. If the code change would alter the
+    # abstract syntax tree, it is not done.
+    module AutocorrectUnlessChangingAST
+      def autocorrect(node)
+        c = correction(node)
+        new_source = rewrite_node(node, c)
+
+        # Make the correction only if it doesn't change the AST.
+        @corrections << c if node == SourceParser.parse(new_source).ast
+      end
+
+      def rewrite_node(node, correction)
+        processed_source = SourceParser.parse(node.loc.expression.source)
+        c = correction(processed_source.ast)
+        Corrector.new(processed_source.buffer, [c]).rewrite
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -15,7 +15,7 @@ module Rubocop
         if condition.type == :send
           _object, method = *condition
           if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
-            add_offense(node, :expression, error_message)
+            add_offense(node, :expression)
           end
         end
       end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -25,7 +25,7 @@ module Rubocop
 
       def autocorrect(token)
         @corrections << lambda do |corrector|
-          corrector.insert_after(token.pos, ' ')
+          corrector.replace(token.pos, token.pos.source + ' ')
         end
       end
     end

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -13,6 +13,10 @@ module Rubocop
         left, right, kind = specifics
         processed_source.tokens.each_cons(2) do |t1, t2|
           if t1.type == left || t2.type == right
+            # If the second token is a comment, that means that a line break
+            # follows, and that the rules for space inside don't apply.
+            next if t2.type == :tCOMMENT
+
             if t2.pos.line == t1.pos.line && space_between?(t1, t2)
               range = Parser::Source::Range.new(processed_source.buffer,
                                                 t1.pos.end_pos,

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

@@ -5,6 +5,8 @@ module Rubocop
     module Style
       # This cop checks for uses of *and* and *or*.
       class AndOr < Cop
+        include AutocorrectUnlessChangingAST
+
         MSG = 'Use `%s` instead of `%s`.'
 
         OPS = { 'and' => '&&', 'or' => '||' }
@@ -30,20 +32,6 @@ module Rubocop
           end
         end
 
-        def autocorrect(node)
-          c = correction(node)
-          new_source = rewrite_node(node, c)
-
-          # Make the correction only if it doesn't change the AST.
-          @corrections << c if node == SourceParser.parse(new_source).ast
-        end
-
-        def rewrite_node(node, correction)
-          processed_source = SourceParser.parse(node.loc.expression.source)
-          c = correction(processed_source.ast)
-          Corrector.new(processed_source.buffer, [c]).rewrite
-        end
-
         def correction(node)
           lambda do |corrector|
             replacement = (node.type == :and ? '&&' : '||')

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

@@ -6,6 +6,8 @@ module Rubocop
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
       class Blocks < Cop
+        include AutocorrectUnlessChangingAST
+
         MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
         SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
 
@@ -35,8 +37,10 @@ module Rubocop
           end
         end
 
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
+        private
+
+        def correction(node)
+          lambda do |corrector|
             b, e = node.loc.begin, node.loc.end
             if b.is?('{')
               # If the left brace is immediately preceded by a word character,
@@ -53,8 +57,6 @@ module Rubocop
           end
         end
 
-        private
-
         def get_block(node)
           case node.type
           when :block

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

@@ -8,8 +8,30 @@ module Rubocop
       class ClassMethods < Cop
         MSG = 'Use `self.%s` instead of `%s.%s`.'
 
-        # TODO: Check if we're in a class/module
-        def on_defs(node)
+        def on_class(node)
+          _name, _superclass, body = *node
+          check(body)
+        end
+
+        def on_module(node)
+          _name, body = *node
+          check(body)
+        end
+
+        private
+
+        def check(node)
+          return unless node
+
+          if node.type == :defs
+            check_defs(node)
+          elsif node.type == :begin
+            defs_nodes = node.children.compact.select { |n| n.type == :defs }
+            defs_nodes.each { |n| check_defs(n) }
+          end
+        end
+
+        def check_defs(node)
           definee, method_name, _args, _body = *node
 
           if definee.type == :const
@@ -19,8 +41,6 @@ module Rubocop
           end
         end
 
-        private
-
         def message(class_name, method_name)
           format(MSG, method_name, class_name, method_name)
         end

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

@@ -8,6 +8,8 @@ module Rubocop
       class NegatedIf < Cop
         include NegativeConditional
 
+        MSG = 'Favor `%s` over `%s` for negative conditions.'
+
         def on_if(node)
           return unless node.loc.respond_to?(:keyword)
           return if node.loc.keyword.is?('elsif')
@@ -15,8 +17,12 @@ module Rubocop
           check(node)
         end
 
-        def error_message
-          'Favor `unless` over `if` for negative conditions.'
+        def message(node)
+          if node.loc.keyword.is?('if')
+            format(MSG, 'unless', 'if')
+          else
+            format(MSG, 'if', 'unless')
+          end
         end
 
         private
@@ -26,7 +32,10 @@ module Rubocop
             condition, _body, _rest = *node
             # unwrap the negated portion of the condition (a send node)
             pos_condition, _method, = *condition
-            corrector.replace(node.loc.keyword, 'unless')
+            corrector.replace(
+              node.loc.keyword,
+              node.loc.keyword.is?('if') ? 'unless' : 'if'
+            )
             corrector.replace(condition.loc.expression,
                               pos_condition.loc.expression.source)
           end

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

@@ -7,12 +7,22 @@ module Rubocop
       class NegatedWhile < Cop
         include NegativeConditional
 
+        MSG = 'Favor `%s` over `%s` for negative conditions.'
+
         def on_while(node)
           check(node)
         end
 
-        def error_message
-          'Favor `until` over `while` for negative conditions.'
+        def on_until(node)
+          check(node)
+        end
+
+        def message(node)
+          if node.type == :while
+            format(MSG, 'until', 'while')
+          else
+            format(MSG, 'while', 'until')
+          end
         end
 
         private
@@ -22,7 +32,9 @@ module Rubocop
             condition, _body, _rest = *node
             # unwrap the negated portion of the condition (a send node)
             pos_condition, _method, = *condition
-            corrector.replace(node.loc.keyword, 'until')
+            corrector.replace(
+              node.loc.keyword,
+              node.type == :while ? 'until' : 'while')
             corrector.replace(condition.loc.expression,
                               pos_condition.loc.expression.source)
           end

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

@@ -32,7 +32,7 @@ module Rubocop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             expr = node.loc.expression
-            new_code = expr.source.sub(/\s*==\s*nil/, '.nil?')
+            new_code = expr.source.sub(/\s*={2,3}\s*nil/, '.nil?')
             corrector.replace(expr, new_code)
           end
         end

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

@@ -13,12 +13,30 @@ module Rubocop
       #
       #  # good
       #  if x
+      #
+      # Non-nil checks are allowed if they are the final nodes of predicate.
+      #
+      #  # good
+      #  def signed_in?
+      #    !current_user.nil?
+      #  end
       class NonNilCheck < Cop
         MSG = 'Explicit non-nil checks are usually redundant.'
 
         NIL_NODE = s(:nil)
 
+        def on_def(node)
+          method_name, _args, body = *node
+          process_method(method_name, body)
+        end
+
+        def on_defs(node)
+          _scope, method_name, _args, body = *node
+          process_method(method_name, body)
+        end
+
         def on_send(node)
+          return if ignored_node?(node)
           receiver, method, args = *node
 
           return unless [:!=, :!].include?(method)
@@ -32,6 +50,18 @@ module Rubocop
 
         private
 
+        def process_method(name, body)
+          # only predicate methods are handled differently
+          return unless name.to_s.end_with?('?')
+          return unless body
+
+          if body.type != :begin
+            ignore_node(body)
+          elsif body.type == :begin
+            ignore_node(body.children.last)
+          end
+        end
+
         def nil_check?(node)
           return false unless node && node.type == :send
 
@@ -60,8 +90,12 @@ module Rubocop
         def autocorrect_non_nil(node, inner_node)
           @corrections << lambda do |corrector|
             receiver, _method, _args = *inner_node
-            corrector.replace(node.loc.expression,
-                              receiver.loc.expression.source)
+            if receiver
+              corrector.replace(node.loc.expression,
+                                receiver.loc.expression.source)
+            else
+              corrector.replace(node.loc.expression, 'self')
+            end
           end
         end
       end

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

@@ -5,6 +5,8 @@ module Rubocop
     module Style
       # This cop checks for uses if the keyword *not* instead of !.
       class Not < Cop
+        include AutocorrectUnlessChangingAST
+
         MSG = 'Use `!` instead of `not`.'
 
         def on_send(node)
@@ -19,20 +21,6 @@ module Rubocop
 
         private
 
-        def autocorrect(node)
-          c = correction(node)
-          new_source = rewrite_node(node, c)
-
-          # Make the correction only if it doesn't change the AST.
-          @corrections << c if node == SourceParser.parse(new_source).ast
-        end
-
-        def rewrite_node(node, correction)
-          processed_source = SourceParser.parse(node.loc.expression.source)
-          c = correction(processed_source.ast)
-          Corrector.new(processed_source.buffer, [c]).rewrite
-        end
-
         def correction(node)
           lambda do |corrector|
             old_source = node.loc.expression.source

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

@@ -30,6 +30,7 @@ module Rubocop
         def check(t1, t2)
           # No offense if line break inside.
           return if t1.pos.line < t2.pos.line
+          return if t2.type == :tCOMMENT # Also indicates there's a line break.
 
           is_empty_braces = t1.text == '{' && t2.text == '}'
           expect_space = if is_empty_braces

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -29,6 +29,10 @@ module Rubocop
 
       def finished(inspected_files)
         output.puts HEADING
+
+        # Syntax isn't a real cop and it can't be disabled.
+        @cops_with_offenses.delete('Syntax')
+
         @cops_with_offenses.sort.each do |cop_name, offense_count|
           output.puts
           cfg = self.class.config_to_allow_offenses[cop_name]

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module Rubocop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.20.0'
+    STRING = '0.20.1'
 
     MSG = '%s (using Parser %s, running on %s %s %s)'
 

data/relnotes/v0.20.1.md

@@ -0,0 +1,24 @@
+RuboCop 0.20.1 is a bugfix-only release. Below is a list of the bugs we've fixed since 0.20.0:
+
+## 0.20.1 (05/04/2014)
+
+### Bugs fixed
+
+* [#940](https://github.com/bbatsov/rubocop/issues/940): Fixed `UselessAccessModifier` not handling `attr_*` correctly. ([@fshowalter][])
+* `NegatedIf` properly handles negated `unless` condition. ([@bbatsov][])
+* `NegatedWhile` properly handles negated `until` condition. ([@bbatsov][])
+* [#925](https://github.com/bbatsov/rubocop/issues/925): Do not disable the `Syntax` cop in output from `--auto-gen-config`. ([@jonas054][])
+* [#943](https://github.com/bbatsov/rubocop/issues/943): Fix auto-correction interference problem between `SpaceAfterComma` and other cops. ([@jonas054][])
+* [#954](https://github.com/bbatsov/rubocop/pull/954): Fix auto-correction bug in `NilComparison`. ([@bbatsov][])
+* [#953](https://github.com/bbatsov/rubocop/pull/953): Fix auto-correction bug in `NonNilCheck`. ([@bbatsov][])
+* [#952](https://github.com/bbatsov/rubocop/pull/952): Handle implicit receiver in `StringConversionInInterpolation`. ([@bbatsov][])
+* [#956](https://github.com/bbatsov/rubocop/pull/956): Apply `ClassMethods` check only on `class`/`module` bodies. ([@bbatsov][])
+* [#945](https://github.com/bbatsov/rubocop/issues/945): Fix SpaceBeforeFirstArg cop for multiline argument and exclude assignments. ([@cschramm][])
+* [#948](https://github.com/bbatsov/rubocop/issues/948): `Blocks` cop avoids auto-correction if it would introduce a semantic change. ([@jonas054][])
+* [#946](https://github.com/bbatsov/rubocop/issues/946): Allow non-nil checks that are the final expressions of predicate method definitions in `NonNilCheck`. ([@bbatsov][])
+* [#957](https://github.com/bbatsov/rubocop/issues/957): Allow space + comment inside parentheses, braces, and square brackets. ([@jonas054][])
+
+[@bbatsov]: https://github.com/bbatsov
+[@jonas054]: https://github.com/jonas054
+[@fshowalter]: https://github.com/fshowalter
+[@cschramm]: https://github.com/cschramm

data/spec/rubocop/cli_spec.rb

@@ -271,6 +271,44 @@ describe Rubocop::CLI, :isolated_environment do
                   ''].join("\n"))
       end
 
+      it 'can correct WordArray and SpaceAfterComma offenses' do
+        create_file('example.rb',
+                    ['# encoding: utf-8',
+                     "f(type: ['offline','offline_payment'],",
+                     "  bar_colors: ['958c12','953579','ff5800','0085cc'])"])
+        expect(cli.run(%w(-D --auto-correct --format o))).to eq(1)
+        expect($stdout.string)
+          .to eq(['',
+                  '4  SpaceAfterComma',
+                  '2  WordArray',
+                  '--',
+                  '6  Total',
+                  '',
+                  ''].join("\n"))
+        expect(IO.read('example.rb'))
+          .to eq(['# encoding: utf-8',
+                  'f(type: %w(offline offline_payment),',
+                  '  bar_colors: %w(958c12 953579 ff5800 0085cc))',
+                  ''].join("\n"))
+      end
+
+      it 'can correct SpaceAfterComma and HashSyntax offenses' do
+        create_file('example.rb',
+                    ['# encoding: utf-8',
+                     "I18n.t('description',:property_name => property.name)"])
+        expect(cli.run(%w(-D --auto-correct --format emacs))).to eq(1)
+        expect($stdout.string)
+          .to eq(["#{abs('example.rb')}:2:21: C: [Corrected] " \
+                  "SpaceAfterComma: Space missing after comma.",
+                  "#{abs('example.rb')}:2:22: C: [Corrected] " \
+                  "HashSyntax: Use the new Ruby 1.9 hash syntax.",
+                  ''].join("\n"))
+        expect(IO.read('example.rb'))
+          .to eq(['# encoding: utf-8',
+                  "I18n.t('description', property_name: property.name)",
+                  ''].join("\n"))
+      end
+
       it 'can correct HashSyntax and SpaceAroundOperators offenses' do
         create_file('example.rb',
                     ['# encoding: utf-8',
@@ -499,6 +537,43 @@ describe Rubocop::CLI, :isolated_environment do
         end
       end
 
+      it 'does not generate configuration for the Syntax cop' do
+        create_file('example1.rb', ['# encoding: utf-8',
+                                    'x = < ', # Syntax error
+                                    'puts x'])
+        create_file('example2.rb', ['# encoding: utf-8',
+                                    "\tx = 0",
+                                    'puts x'])
+        expect(cli.run(['--auto-gen-config'])).to eq(1)
+        expect($stderr.string).to eq('')
+        expected =
+          ['# This configuration was generated by `rubocop --auto-gen-config`',
+           /# on .* using RuboCop version .*/,
+           '# The point is for the user to remove these configuration records',
+           '# one by one as the offenses are removed from the code base.',
+           '# Note that changes in the inspected code, or installation of new',
+           '# versions of RuboCop, may require this file to be generated ' \
+           'again.',
+           '',
+           '# Offense count: 1',
+           '# Cop supports --auto-correct.',
+           'IndentationConsistency:',
+           '  Enabled: false',
+           '',
+           '# Offense count: 1',
+           'Tab:',
+           '  Enabled: false']
+        actual = IO.read('rubocop-todo.yml').split($RS)
+        expect(actual.length).to eq(expected.length)
+        expected.each_with_index do |line, ix|
+          if line.is_a?(String)
+            expect(actual[ix]).to eq(line)
+          else
+            expect(actual[ix]).to match(line)
+          end
+        end
+      end
+
       it 'generates a todo list that removes the reports' do
         create_file('example.rb', ['# encoding: utf-8',
                                    'y.gsub!(%r{abc/xyz}, "#{x}")'])

data/spec/rubocop/cop/lint/space_before_first_arg_spec.rb

@@ -26,6 +26,16 @@ describe Rubocop::Cop::Lint::SpaceBeforeFirstArg do
       inspect_source(cop, ['something[:x]'])
       expect(cop.offenses).to be_empty
     end
+
+    it 'accepts a method call with space before a multiline arg' do
+      inspect_source(cop, "something [\n  'foo',\n  'bar'\n]")
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts an assignment without space before first arg' do
+      inspect_source(cop, ['a.something=c', 'a.something,b=c,d'])
+      expect(cop.offenses).to be_empty
+    end
   end
 
   context 'for method calls with parentheses' do

data/spec/rubocop/cop/lint/string_conversion_in_interpolation_spec.rb

@@ -8,6 +8,8 @@ describe Rubocop::Cop::Lint::StringConversionInInterpolation do
   it 'registers an offense for #to_s in interpolation' do
     inspect_source(cop, '"this is the #{result.to_s}"')
     expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Redundant use of `Object#to_s` in interpolation.'])
   end
 
   it 'detects #to_s in an interpolation with several expressions' do
@@ -25,6 +27,13 @@ describe Rubocop::Cop::Lint::StringConversionInInterpolation do
     expect(cop.offenses).to be_empty
   end
 
+  it 'does not explode on implicit receiver' do
+    inspect_source(cop, '"#{to_s}"')
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use `self` instead of `Object#to_s` in interpolation.'])
+  end
+
   it 'does not explode on empty interpolation' do
     inspect_source(cop, '"this is #{} silly"')
     expect(cop.offenses).to be_empty
@@ -34,4 +43,9 @@ describe Rubocop::Cop::Lint::StringConversionInInterpolation do
     corrected = autocorrect_source(cop, ['"some #{something.to_s}"'])
     expect(corrected).to eq '"some #{something}"'
   end
+
+  it 'autocorrects implicit receiver by replacing to_s with self' do
+    corrected = autocorrect_source(cop, ['"some #{to_s}"'])
+    expect(corrected).to eq '"some #{self}"'
+  end
 end

data/spec/rubocop/cop/lint/useless_access_modifier_spec.rb

@@ -49,6 +49,44 @@ describe Rubocop::Cop::Lint::UselessAccessModifier do
     end
   end
 
+  context 'when an access modifier is followed by attr_*' do
+    let(:source) do
+      [
+        'class SomeClass',
+        '  protected',
+        '  attr_accessor :some_property',
+        'end'
+      ]
+    end
+
+    it 'does not register an offense' do
+      inspect_source(cop, source)
+      expect(cop.offenses.size).to eq(0)
+    end
+  end
+
+  context 'when an access modifier is followed by a ' \
+    'class method defined on constant' do
+    let(:source) do
+      [
+        'class SomeClass',
+        '  protected',
+        '  def SomeClass.some_method',
+        '  end',
+        'end'
+      ]
+    end
+
+    it 'registers an offense' do
+      inspect_source(cop, source)
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.message)
+        .to eq('Useless `protected` access modifier.')
+      expect(cop.offenses.first.line).to eq(2)
+      expect(cop.highlights).to eq(['protected'])
+    end
+  end
+
   context 'when consecutive access modifiers' do
     let(:source) do
       [

data/spec/rubocop/cop/style/blocks_spec.rb

@@ -27,6 +27,12 @@ describe Rubocop::Cop::Style::Blocks do
     expect(new_source).to eq('block { |x| }')
   end
 
+  it 'does not auto-correct do-end if {} would change the meaning' do
+    src = "s.subspec 'Subspec' do |sp| end"
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(src)
+  end
+
   context 'when there are braces around a multi-line block' do
     it 'registers an offense in the simple case' do
       inspect_source(cop, ['each { |x|',

data/spec/rubocop/cop/style/class_methods_spec.rb

@@ -43,7 +43,7 @@ describe Rubocop::Cop::Style::ClassMethods do
 
   it 'does not register an offense outside class/module bodies' do
     inspect_source(cop,
-                   ['def self.some_method',
+                   ['def Test.some_method',
                     '  do_something',
                     'end'])
     expect(cop.offenses).to be_empty

data/spec/rubocop/cop/style/negated_if_spec.rb

@@ -17,6 +17,17 @@ describe Rubocop::Cop::Style::NegatedIf do
        'conditions.'] * 2)
   end
 
+  it 'registers an offense for unless with exclamation point condition' do
+    inspect_source(cop,
+                   ['unless !a_condition',
+                    '  some_method',
+                    'end',
+                    'some_method unless !a_condition'
+                   ])
+    expect(cop.messages).to eq(['Favor `if` over `unless` for negative ' \
+                                'conditions.'] * 2)
+  end
+
   it 'registers an offense for if with "not" condition' do
     inspect_source(cop,
                    ['if not a_condition',
@@ -78,4 +89,10 @@ describe Rubocop::Cop::Style::NegatedIf do
     corrected = autocorrect_source(cop, 'something if !x.even?')
     expect(corrected).to eq 'something unless x.even?'
   end
+
+  it 'autocorrects by replacing unless not with if' do
+    corrected = autocorrect_source(cop, 'something unless !x.even?')
+    expect(corrected).to eq 'something if x.even?'
+  end
+
 end

data/spec/rubocop/cop/style/negated_while_spec.rb

@@ -16,6 +16,17 @@ describe Rubocop::Cop::Style::NegatedWhile do
       ['Favor `until` over `while` for negative conditions.'] * 2)
   end
 
+  it 'registers an offense for until with exclamation point condition' do
+    inspect_source(cop,
+                   ['until !a_condition',
+                    '  some_method',
+                    'end',
+                    'some_method until !a_condition'
+                   ])
+    expect(cop.messages)
+      .to eq(['Favor `while` over `until` for negative conditions.'] * 2)
+  end
+
   it 'registers an offense for while with "not" condition' do
     inspect_source(cop,
                    ['while (not a_condition)',
@@ -43,4 +54,9 @@ describe Rubocop::Cop::Style::NegatedWhile do
     corrected = autocorrect_source(cop, 'something while !x.even?')
     expect(corrected).to eq 'something until x.even?'
   end
+
+  it 'autocorrects by replacing until not with while' do
+    corrected = autocorrect_source(cop, 'something until !x.even?')
+    expect(corrected).to eq 'something while x.even?'
+  end
 end

data/spec/rubocop/cop/style/nil_comparison_spec.rb

@@ -21,4 +21,9 @@ describe Rubocop::Cop::Style::NilComparison do
     corrected = autocorrect_source(cop, 'x == nil')
     expect(corrected).to eq 'x.nil?'
   end
+
+  it 'autocorrects by replacing === nil with .nil?' do
+    corrected = autocorrect_source(cop, 'x === nil')
+    expect(corrected).to eq 'x.nil?'
+  end
 end

data/spec/rubocop/cop/style/non_nil_check_spec.rb

@@ -23,6 +23,36 @@ describe Rubocop::Cop::Style::NonNilCheck do
     expect(cop.highlights).to eq(['not x.nil?'])
   end
 
+  it 'does not register an offense if only expression in predicate' do
+    inspect_source(cop, ['def signed_in?',
+                         '  !current_user.nil?',
+                         'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense if only expression in class predicate' do
+    inspect_source(cop, ['def Test.signed_in?',
+                         '  !current_user.nil?',
+                         'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense if last expression in predicate' do
+    inspect_source(cop, ['def signed_in?',
+                         '  something',
+                         '  !current_user.nil?',
+                         'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense if last expression in class predicate' do
+    inspect_source(cop, ['def Test.signed_in?',
+                         '  something',
+                         '  !current_user.nil?',
+                         'end'])
+    expect(cop.offenses).to be_empty
+  end
+
   it 'autocorrects by removing != nil' do
     corrected = autocorrect_source(cop, 'x != nil')
     expect(corrected).to eq 'x'
@@ -32,4 +62,9 @@ describe Rubocop::Cop::Style::NonNilCheck do
     corrected = autocorrect_source(cop, '!x.nil?')
     expect(corrected).to eq 'x'
   end
+
+  it 'does not blow up when autocorrecting implicit receiver' do
+    corrected = autocorrect_source(cop, '!nil?')
+    expect(corrected).to eq 'self'
+  end
 end

data/spec/rubocop/cop/style/space_inside_block_braces_spec.rb

@@ -34,6 +34,12 @@ describe Rubocop::Cop::Style::SpaceInsideBlockBraces do
       expect(cop.messages).to be_empty
     end
 
+    it 'accepts empty braces with comment and line break inside' do
+      inspect_source(cop, ['  each { # Comment',
+                           '  }'])
+      expect(cop.messages).to be_empty
+    end
+
     it 'registers an offense for empty braces with space inside' do
       inspect_source(cop, ['each { }'])
       expect(cop.messages).to eq(['Space inside empty braces detected.'])

data/spec/rubocop/cop/style/space_inside_brackets_spec.rb

@@ -26,6 +26,13 @@ describe Rubocop::Cop::Style::SpaceInsideBrackets do
     expect(cop.messages).to be_empty
   end
 
+  it 'accepts space inside square brackets if with comment' do
+    inspect_source(cop, ['a = [ # Comment',
+                         '     1, 2',
+                         '    ]'])
+    expect(cop.messages).to be_empty
+  end
+
   it 'accepts square brackets as method name' do
     inspect_source(cop, ['def Vector.[](*array)',
                          'end'])

data/spec/rubocop/cop/style/space_inside_hash_literal_braces_spec.rb

@@ -107,7 +107,7 @@ describe Rubocop::Cop::Style::SpaceInsideHashLiteralBraces, :config do
       expect(cop.offenses).to be_empty
     end
 
-    it 'accepts multiline hashes for no space' do
+    it 'accepts multiline hash' do
       inspect_source(cop,
                      ['h = {',
                       '      a: 1,',
@@ -115,6 +115,15 @@ describe Rubocop::Cop::Style::SpaceInsideHashLiteralBraces, :config do
                       '}'])
       expect(cop.offenses).to be_empty
     end
+
+    it 'accepts multiline hash with comment' do
+      inspect_source(cop,
+                     ['h = { # Comment',
+                      '      a: 1,',
+                      '      b: 2,',
+                      '}'])
+      expect(cop.offenses).to be_empty
+    end
   end
 
   it 'accepts hashes with spaces by default' do

data/spec/rubocop/cop/style/space_inside_parens_spec.rb

@@ -25,6 +25,18 @@ describe Rubocop::Cop::Style::SpaceInsideParens do
     expect(cop.messages).to be_empty
   end
 
+  it 'accepts parentheses with line break' do
+    inspect_source(cop, ['f(',
+                         '  1)'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts parentheses with comment and line break' do
+    inspect_source(cop, ['f( # Comment',
+                         '  1)'])
+    expect(cop.messages).to be_empty
+  end
+
   it 'auto-corrects unwanted space' do
     new_source = autocorrect_source(cop, ['f( 3)',
                                           'g(3 )'])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.20.1
 platform: ruby
 authors:
 - Bozhidar Batsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-02 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rainbow
@@ -234,6 +234,7 @@ files:
 - lib/rubocop/cop/mixin/annotation_comment.rb
 - lib/rubocop/cop/mixin/array_syntax.rb
 - lib/rubocop/cop/mixin/autocorrect_alignment.rb
+- lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb
 - lib/rubocop/cop/mixin/check_assignment.rb
 - lib/rubocop/cop/mixin/check_methods.rb
 - lib/rubocop/cop/mixin/code_length.rb
@@ -421,6 +422,7 @@ files:
 - relnotes/v0.19.0.md
 - relnotes/v0.19.1.md
 - relnotes/v0.20.0.md
+- relnotes/v0.20.1.md
 - rubocop-todo.yml
 - rubocop.gemspec
 - spec/.rubocop.yml