rubocop 0.12.0 → 0.13.0

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

@@ -17,8 +17,8 @@ module Rubocop
 
           if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
               args.children.size == 1 && args != TARGET_ARGS
-            add_offence(:convention, args.children[0].loc.expression,
-                        sprintf(MSG, name))
+            convention(args.children[0], :expression,
+                       sprintf(MSG, name))
           end
         end
       end

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

@@ -12,8 +12,8 @@ module Rubocop
 
         def on_args(node)
           if args_count(node) > max_params
-            add_offence(:convention, node.loc.expression,
-                        sprintf(MSG, max_params))
+            convention(node, :expression,
+                       sprintf(MSG, max_params))
           end
         end
 
@@ -28,11 +28,11 @@ module Rubocop
         end
 
         def max_params
-          ParameterLists.config['Max']
+          cop_config['Max']
         end
 
         def count_keyword_args?
-          ParameterLists.config['CountKeywordArgs']
+          cop_config['CountKeywordArgs']
         end
       end
     end

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

@@ -31,7 +31,7 @@ module Rubocop
             # allow safe assignment
             return if safe_assignment?(cond) && safe_assignment_allowed?
 
-            add_offence(:convention, cond.loc.expression, MSG)
+            convention(cond, :expression)
           end
         end
 
@@ -40,7 +40,7 @@ module Rubocop
         end
 
         def safe_assignment_allowed?
-          ParenthesesAroundCondition.config['AllowSafeAssignment']
+          cop_config['AllowSafeAssignment']
         end
       end
     end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      class PerlBackrefs < Cop
+        MSG = 'Avoid the use of Perl-style backrefs.'
+
+        def on_nth_ref(node)
+          convention(node, :expression)
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            backref, = *node
+
+            corrector.replace(node.loc.expression,
+                              "Regexp.last_match[#{backref}]")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,9 +18,7 @@ module Rubocop
           #   ...)
           block_method, = *node
 
-          if block_method == TARGET
-            add_offence(:convention, block_method.loc.expression, MSG)
-          end
+          convention(block_method, :expression) if block_method == TARGET
         end
       end
     end

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

@@ -5,9 +5,9 @@ module Rubocop
     module Style
       # This cop checks whether the block arguments of a single-line
       # reduce(inject) call are named *a*(for accumulator) and *e*
-      # (for element)
+      # (for element).
       class ReduceArguments < Cop
-        MSG = 'Name reduce arguments |a, e| (accumulator, element).'
+        MSG = 'Name reduce block arguments |a, e| (accumulator, element).'
 
         ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
 
@@ -22,9 +22,11 @@ module Rubocop
           return unless receiver
           return unless [:reduce, :inject].include?(method_name)
 
-          unless args_node == ARGS_NODE
-            add_offence(:convention, node.loc.expression, MSG)
-          end
+          # discard second argument destructuring
+          _, element_node = *args_node
+          return unless element_node.type == :arg
+
+          convention(args_node, :expression) unless args_node == ARGS_NODE
         end
       end
     end

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

@@ -37,7 +37,7 @@ module Rubocop
         def check(node)
           return unless node && node.type == :kwbegin
 
-          add_offence(:convention, node.loc.begin, MSG)
+          convention(node, :begin)
         end
       end
     end

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

@@ -37,17 +37,24 @@ module Rubocop
 
         private
 
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression,
+                              node.loc.expression.source.sub('return ', ''))
+          end
+        end
+
         def check(node)
           return unless node
 
           if node.type == :return
-            add_offence(:convention, node.loc.keyword, MSG)
+            convention(node, :keyword)
           elsif node.type == :begin
             expressions = *node
             last_expr = expressions.last
 
             if last_expr && last_expr.type == :return
-              add_offence(:convention, last_expr.loc.keyword, MSG)
+              convention(last_expr, :keyword)
             end
           end
         end

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

@@ -13,7 +13,7 @@ module Rubocop
       class RedundantSelf < Cop
         MSG = 'Redundant `self` detected.'
 
-        def initialize
+        def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
           @local_variables = []
@@ -56,11 +56,18 @@ module Rubocop
             unless operator?(method_name) || keyword?(method_name) ||
                 @allowed_send_nodes.include?(node) ||
                 @local_variables.include?(method_name)
-              add_offence(:convention, receiver.loc.expression, MSG)
+              convention(node, :expression)
             end
           end
         end
 
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression,
+                              node.loc.expression.source.gsub(/self\./, ''))
+          end
+        end
+
         private
 
         def operator?(method_name)

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

@@ -9,18 +9,17 @@ module Rubocop
       class RegexpLiteral < Cop
         def on_regexp(node)
           slashes = node.loc.expression.source.count('/')
-          max = RegexpLiteral.max_slashes
           msg = if node.loc.begin.is?('/')
                   slashes -= 2 # subtract delimiters
-                  error_message('') if slashes > max
+                  error_message('') if slashes > max_slashes
                 else
-                  error_message('only ') if slashes <= max
+                  error_message('only ') if slashes <= max_slashes
                 end
-          add_offence(:convention, node.loc.expression, msg) if msg
+          convention(node, :expression, msg) if msg
         end
 
-        def self.max_slashes
-          RegexpLiteral.config['MaxSlashes']
+        def max_slashes
+          cop_config['MaxSlashes']
         end
 
         private
@@ -29,8 +28,8 @@ module Rubocop
           sprintf('Use %%r %sfor regular expressions matching more ' +
                   "than %d '/' character%s.",
                   word,
-                  RegexpLiteral.max_slashes,
-                  RegexpLiteral.max_slashes == 1 ? '' : 's')
+                  max_slashes,
+                  max_slashes == 1 ? '' : 's')
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Rubocop
         def on_rescue(node)
           return if ignored_node?(node)
 
-          add_offence(:convention, node.loc.expression, MSG)
+          convention(node, :expression)
         end
 
         def on_kwbegin(node)

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

@@ -27,11 +27,11 @@ module Rubocop
                 # know if the first semicolon on the line is a separator of
                 # expressions. It's just a guess.
                 column = processed_source[line - 1].index(';')
-                add_offence(:convention,
-                            source_range(processed_source.buffer,
-                                         processed_source[0...(line - 1)],
-                                         column, 1),
-                            MSG)
+                convention(nil,
+                           source_range(processed_source.buffer,
+                                        processed_source[0...(line - 1)],
+                                        column, 1),
+                           MSG)
               end
             end
           end
@@ -43,11 +43,11 @@ module Rubocop
           tokens_for_lines.each do |line, tokens|
             if tokens.last.type == :tSEMI # rubocop:disable SymbolName
               column = tokens.last.pos.column
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...(line - 1)],
-                                       column, 1),
-                          MSG)
+              convention(nil,
+                         source_range(processed_source.buffer,
+                                      processed_source[0...(line - 1)],
+                                      column, 1),
+                         MSG)
             end
           end
         end

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

@@ -29,8 +29,7 @@ module Rubocop
 
           on_node(:send, node, :rescue) do |send_node|
             if command?(:raise, send_node)
-              add_offence(:convention, send_node.loc.selector, FAIL_MSG)
-              do_autocorrect(send_node)
+              convention(send_node, :selector, FAIL_MSG)
             end
           end
         end
@@ -40,8 +39,7 @@ module Rubocop
 
           on_node(:send, node, :rescue) do |send_node|
             if command?(:fail, send_node)
-              add_offence(:convention, send_node.loc.selector, RAISE_MSG)
-              do_autocorrect(send_node)
+              convention(send_node, :selector, RAISE_MSG)
             end
           end
         end

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

@@ -9,7 +9,7 @@ module Rubocop
         MSG = 'Avoid single-line method definitions.'
 
         def allow_empty?
-          SingleLineMethods.config['AllowIfMethodIsEmpty']
+          cop_config['AllowIfMethodIsEmpty']
         end
 
         def on_def(node)
@@ -33,9 +33,7 @@ module Rubocop
           end
 
           if start_line == end_line && !(allow_empty? && empty_body)
-            add_offence(:convention,
-                        node.loc.expression,
-                        MSG)
+            convention(node, :expression)
           end
         end
       end

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

@@ -14,7 +14,7 @@ module Rubocop
           processed_source.tokens.each_cons(2) do |t1, t2|
             if kind(t1) && t1.pos.line == t2.pos.line &&
                 t2.pos.column == t1.pos.column + offset(t1)
-              add_offence(:convention, t1.pos, sprintf(MSG, kind(t1)))
+              convention(nil, t1.pos, sprintf(MSG, kind(t1)))
             end
           end
         end

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

@@ -16,7 +16,7 @@ module Rubocop
           kw = node.loc.keyword
           kw_offset = kw.begin_pos - exp.begin_pos
           if exp.source[kw_offset..-1].start_with?(kw.source + '(')
-            add_offence(:convention, kw, MSG)
+            convention(node, kw)
           end
         end
 

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

@@ -25,7 +25,7 @@ module Rubocop
                                                             expr.begin_pos - 1,
                                                             expr.begin_pos)
           if pos_before_left_paren.source =~ /\s/
-            add_offence(:convention, pos_before_left_paren, MSG)
+            convention(nil, pos_before_left_paren)
           end
         end
       end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Here we check if modifier keywords are preceded by a space.
+      class SpaceBeforeModifierKeyword < Cop
+        MSG = 'Put a space before the modifier keyword.'
+
+        def on_if(node)
+          if modifier?(node)
+            kw = node.loc.keyword
+            b = kw.begin_pos
+            left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
+            convention(node, left_of_kw) unless left_of_kw.is?(' ')
+          end
+        end
+
+        alias_method :on_while, :on_if
+        alias_method :on_until, :on_if
+
+        private
+
+        def modifier?(node)
+          node.loc.respond_to?(:end) && node.loc.end.nil? && !elsif?(node)
+        end
+
+        def elsif?(node)
+          node.loc.keyword.is?('elsif')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{avoid_perlisms.rb → special_global_vars.rb}

@@ -4,7 +4,9 @@ module Rubocop
   module Cop
     module Style
       # This cop looks for uses of Perl-style global variables.
-      class AvoidPerlisms < Cop
+      class SpecialGlobalVars < Cop
+        MSG = 'Prefer %s over %s.'
+
         PREFERRED_VARS = {
           '$:' => '$LOAD_PATH',
           '$"' => '$LOADED_FEATURES',
@@ -32,14 +34,21 @@ module Rubocop
 
         def on_gvar(node)
           global_var, = *node
-          global_var = global_var
 
-          if PREFERRED_VARS[global_var]
-            add_offence(
-              :convention,
-              node.loc.expression,
-              "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
-            )
+          convention(node, :expression) if PREFERRED_VARS[global_var]
+        end
+
+        def message(node)
+          global_var, = *node
+          MSG.format(PREFERRED_VARS[global_var], global_var)
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            global_var, = *node
+
+            corrector.replace(node.loc.expression,
+                              PREFERRED_VARS[global_var])
           end
         end
       end

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

@@ -19,8 +19,7 @@ module Rubocop
           # "\\\\"
           if node.loc.expression.source !~ /' | (?<! \\) \\{2}* \\ (?! \\)/x &&
               node.loc.begin && node.loc.begin.is?('"')
-            add_offence(:convention, node.loc.expression, MSG)
-            do_autocorrect(node)
+            convention(node, :expression)
           end
         end
 

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

@@ -67,7 +67,7 @@ module Rubocop
             case token.type
             when :tPOW
               if has_space?(token_before, token, token_after)
-                add_offence(:convention, token.pos, MSG_DETECTED)
+                convention(nil, token.pos, MSG_DETECTED)
               end
             when *BINARY_OPERATORS
               check_missing_space(token_before, token, token_after)
@@ -164,7 +164,7 @@ module Rubocop
         def check_missing_space(token_before, token, token_after)
           unless has_space?(token_before, token, token_after)
             text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
-            add_offence(:convention, token.pos, MSG_MISSING % text)
+            convention(nil, token.pos, MSG_MISSING.format(text))
           end
         end
 
@@ -223,8 +223,8 @@ module Rubocop
 
         def check(t1, t2, msg)
           unless space_between?(t1, t2)
-            brace_token = msg == MSG_LEFT ? t1 : t2
-            add_offence(:convention, brace_token.pos, msg)
+            brace_token = t1.text == '{' ? t1 : t2
+            convention(nil, brace_token.pos, msg)
           end
         end
       end
@@ -244,7 +244,7 @@ module Rubocop
                 range = Parser::Source::Range.new(processed_source.buffer,
                                                   t1.pos.end_pos,
                                                   t2.pos.begin_pos)
-                add_offence(:convention, range, format(MSG, kind))
+                convention(nil, range, format(MSG, kind))
               end
             end
           end
@@ -297,12 +297,13 @@ module Rubocop
           # No offence if line break inside.
           return if t1.pos.line < t2.pos.line
           has_space = space_between?(t1, t2)
-          is_offence, word = if self.class.config['EnforcedStyleIsWithSpaces']
+          is_offence, word = if cop_config['EnforcedStyleIsWithSpaces']
                                [!has_space, 'missing']
                              else
                                [has_space, 'detected']
                              end
-          add_offence(:convention, t1.pos, sprintf(MSG, word)) if is_offence
+          brace_token = t1.text == '{' ? t1 : t2
+          convention(nil, brace_token.pos, sprintf(MSG, word)) if is_offence
         end
       end
 
@@ -319,7 +320,7 @@ module Rubocop
             index = index_of_first_token(optarg)
             arg, equals, value = processed_source.tokens[index, 3]
             unless space_between?(arg, equals) && space_between?(equals, value)
-              add_offence(:convention, equals.pos, MSG)
+              convention(nil, equals.pos)
             end
           end
         end