rubocop 0.15.0 → 0.16.0

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

@@ -29,7 +29,7 @@ module Rubocop
           if OPS.include?(op)
             _receiver, _method, args = *node
 
-            convention(node, :selector) if args == NIL_NODE
+            add_offence(node, :selector) if args == NIL_NODE
           end
         end
       end

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

@@ -13,7 +13,7 @@ module Rubocop
           # not does not take any arguments
           if args.empty? && method_name == :! &&
               node.loc.selector.is?('not')
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
       end

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

@@ -6,7 +6,7 @@ module Rubocop
       # This cop checks for big numeric literals without _ between groups
       # of digits in them.
       class NumericLiterals < Cop
-        MSG = 'Separate every 3 digits in the integer portion of a number' \
+        MSG = 'Separate every 3 digits in the integer portion of a number ' \
           'with underscores(_).'
 
         def on_int(node)
@@ -27,7 +27,7 @@ module Rubocop
 
           if int.size >= min_digits
             if int =~ /\d{4}/ || int =~ /_\d{1,2}_/
-              convention(node, :expression)
+              add_offence(node, :expression)
             end
           end
         end

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
-            convention(args.children[0], :expression,
-                       sprintf(MSG, name))
+            add_offence(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
-            convention(node, :expression,
-                       sprintf(MSG, max_params))
+            add_offence(node, :expression,
+                        sprintf(MSG, max_params))
           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?
 
-            convention(cond, :expression)
+            add_offence(cond, :expression)
           end
         end
 
@@ -42,6 +42,13 @@ module Rubocop
         def safe_assignment_allowed?
           cop_config['AllowSafeAssignment']
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Rubocop
         MSG = 'Avoid the use of Perl-style backrefs.'
 
         def on_nth_ref(node)
-          convention(node, :expression)
+          add_offence(node, :expression)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that predicates are named properly.
+      #
+      # @example
+      #   # bad
+      #   def is_even?(value) ...
+      #
+      #   # good
+      #   def even?(value)
+      #
+      #   # bad
+      #   def has_value? ...
+      #
+      #   # good
+      #   def value? ...
+      class PredicateName < Cop
+        def on_def(node)
+          method_name, args, _body = *node
+          check(node, method_name.to_s, args)
+        end
+
+        def on_defs(node)
+          _scope, method_name, args, _body = *node
+          check(node, method_name.to_s, args)
+        end
+
+        private
+
+        def check(node, method_name, args)
+          prefix_blacklist.each do |prefix|
+            if method_name.start_with?(prefix)
+              add_offence(node, :name,
+                          message(method_name, prefix))
+            end
+          end
+        end
+
+        def message(method_name, prefix)
+          new_name = method_name.sub(prefix, '')
+          new_name << '?' unless method_name.end_with?('?')
+          "Rename #{method_name} to #{new_name}."
+        end
+
+        def prefix_blacklist
+          cop_config['NamePrefixBlacklist']
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -5,6 +5,8 @@ module Rubocop
     module Style
       # This cop checks the args passed to `fail` and `raise`.
       class RaiseArgs < Cop
+        include ConfigurableEnforcedStyle
+
         def on_send(node)
           return unless command?(:raise, node) || command?(:fail, node)
 
@@ -23,7 +25,7 @@ module Rubocop
 
           return unless args.size > 1
 
-          convention(node, :expression, message(selector))
+          add_offence(node, :expression, message(selector))
         end
 
         def check_exploded(node)
@@ -38,19 +40,11 @@ module Rubocop
 
             # Allow code like `raise Ex.new(arg1, arg2)`.
             unless constructor_args.size > 1
-              convention(node, :expression, message(selector))
+              add_offence(node, :expression, message(selector))
             end
           end
         end
 
-        def style
-          case cop_config['EnforcedStyle']
-          when 'compact' then :compact
-          when 'exploded' then :exploded
-          else fail 'Unknown style selected!'
-          end
-        end
-
         def message(method)
           case style
           when :compact

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

@@ -18,26 +18,16 @@ module Rubocop
       #     end
       #   end
       class RedundantBegin < Cop
-        MSG = 'Redundant `begin` block detected.'
-
-        def on_def(node)
-          _method_name, _args, body = *node
-
-          check(body)
-        end
+        include CheckMethods
 
-        def on_defs(node)
-          _scope, _method_name, _args, body = *node
-
-          check(body)
-        end
+        MSG = 'Redundant `begin` block detected.'
 
         private
 
-        def check(node)
-          return unless node && node.type == :kwbegin
+        def check(_node, _method_name, _args, body)
+          return unless body && body.type == :kwbegin
 
-          convention(node, :begin)
+          add_offence(body, :begin)
         end
       end
     end

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

@@ -24,7 +24,7 @@ module Rubocop
 
           first_arg, = *args
 
-          convention(first_arg, :expression) if first_arg == TARGET_NODE
+          add_offence(first_arg, :expression) if first_arg == TARGET_NODE
         end
       end
     end

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

@@ -21,19 +21,9 @@ module Rubocop
       # It should be extended to handle methods whose body is if/else
       # or a case expression with a default branch.
       class RedundantReturn < Cop
-        MSG = 'Redundant `return` detected.'
-
-        def on_def(node)
-          _method_name, _args, body = *node
-
-          check(body)
-        end
+        include CheckMethods
 
-        def on_defs(node)
-          _scope, _method_name, _args, body = *node
-
-          check(body)
-        end
+        MSG = 'Redundant `return` detected.'
 
         private
 
@@ -49,13 +39,13 @@ module Rubocop
           end
         end
 
-        def check(node)
-          return unless node
+        def check(_node, _method_name, _args, body)
+          return unless body
 
-          if node.type == :return
-            check_return_node(node)
-          elsif node.type == :begin
-            expressions = *node
+          if body.type == :return
+            check_return_node(body)
+          elsif body.type == :begin
+            expressions = *body
             last_expr = expressions.last
 
             if last_expr && last_expr.type == :return
@@ -68,7 +58,7 @@ module Rubocop
           return if cop_config['AllowMultipleReturnValues'] &&
             node.children.size > 1
 
-          convention(node, :keyword)
+          add_offence(node, :keyword)
         end
       end
     end

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

@@ -75,8 +75,8 @@ module Rubocop
           @local_variables = []
         end
 
-        def on_arg(node)
-          on_argument(node)
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
         end
 
         def on_blockarg(node)
@@ -94,9 +94,10 @@ module Rubocop
           receiver, method_name, *_args = *node
           if receiver && receiver.type == :self
             unless operator?(method_name) || keyword?(method_name) ||
+                constant_name?(method_name) ||
                 @allowed_send_nodes.include?(node) ||
                 @local_variables.include?(method_name)
-              convention(node, :expression)
+              add_offence(node, :expression)
             end
           end
         end
@@ -128,6 +129,10 @@ module Rubocop
            :yield].include?(method_name)
         end
 
+        def constant_name?(method_name)
+          method_name.match(/^[A-Z]/)
+        end
+
         def allow_self(node)
           if node.type == :send
             receiver, _method_name, *_args = *node

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

@@ -8,14 +8,15 @@ module Rubocop
       # value of the configuration parameter MaxSlashes.
       class RegexpLiteral < Cop
         def on_regexp(node)
-          slashes = node.loc.expression.source.count('/')
+          string_parts = node.children.select { |child| child.type == :str }
+          total_string = string_parts.map { |s| s.loc.expression.source }.join
+          slashes = total_string.count('/')
           msg = if node.loc.begin.is?('/')
-                  slashes -= 2 # subtract delimiters
                   error_message('') if slashes > max_slashes
                 else
                   error_message('only ') if slashes <= max_slashes
                 end
-          convention(node, :expression, msg) if msg
+          add_offence(node, :expression, msg) if msg
         end
 
         def max_slashes

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

@@ -5,37 +5,29 @@ module Rubocop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
+        include CheckMethods
+
         MSG = 'Avoid using rescue in its modifier form.'
 
         def on_rescue(node)
           return if ignored_node?(node)
 
-          convention(node, :expression)
+          add_offence(node, :expression)
         end
 
         def on_kwbegin(node)
           body, *_ = *node
-          check_rescue(body)
-        end
-
-        def on_def(node)
-          _method_name, _args, body = *node
-          check_rescue(body)
-        end
-
-        def on_defs(node)
-          _receiver, _method_name, _args, body = *node
-          check_rescue(body)
+          check(nil, nil, nil, body)
         end
 
-        def check_rescue(node)
-          return unless node
+        def check(_node, _method_name, _args, body)
+          return unless body
 
-          case node.type
+          case body.type
           when :rescue
-            ignore_node(node)
+            ignore_node(body)
           when :ensure
-            first_child = node.children.first
+            first_child = body.children.first
             if first_child && first_child.type == :rescue
               ignore_node(first_child)
             end

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

@@ -10,20 +10,16 @@ module Rubocop
 
         def investigate(processed_source)
           return unless processed_source.ast
+          @processed_source = processed_source
 
-          unless cop_config['AllowAsExpressionSeparator']
-            check_for_expr_separator(processed_source)
-          end
-          check_for_line_terminator(processed_source)
+          check_for_line_terminator
         end
 
-        private
-
-        def check_for_expr_separator(processed_source)
-          on_node(:begin, processed_source.ast) do |node|
+        def on_begin(node)
+          unless cop_config['AllowAsExpressionSeparator']
             exprs = node.children
 
-            next if exprs.size < 2
+            return if exprs.size < 2
 
             # create a map matching lines to the number of expressions on them
             exprs_lines = exprs.map { |e| e.loc.expression.line }
@@ -35,31 +31,33 @@ module Rubocop
                 # TODO: Find the correct position of the semicolon. We don't
                 # know if the first semicolon on the line is a separator of
                 # expressions. It's just a guess.
-                column = processed_source[line - 1].index(';')
-                convention(nil,
-                           source_range(processed_source.buffer,
-                                        processed_source[0...(line - 1)],
-                                        column, 1))
+                column = @processed_source[line - 1].index(';')
+                convention_on(line, column)
               end
             end
           end
         end
 
-        def check_for_line_terminator(processed_source)
-          tokens_for_lines = processed_source.tokens.group_by do |token|
+        private
+
+        def check_for_line_terminator
+          tokens_for_lines = @processed_source.tokens.group_by do |token|
             token.pos.line
           end
 
           tokens_for_lines.each do |line, tokens|
-            if tokens.last.type == :tSEMI # rubocop:disable SymbolName
-              column = tokens.last.pos.column
-              convention(nil,
-                         source_range(processed_source.buffer,
-                                      processed_source[0...(line - 1)],
-                                      column, 1))
+            if tokens.last.type == :tSEMI
+              convention_on(line, tokens.last.pos.column)
             end
           end
         end
+
+        def convention_on(line, column)
+          add_offence(nil,
+                      source_range(@processed_source.buffer,
+                                   @processed_source[0...(line - 1)], column,
+                                   1))
+        end
       end
     end
   end