rubocop 0.12.0 → 0.13.0

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

@@ -28,9 +28,9 @@ module Rubocop
           return unless div_by_2?(receiver)
 
           if args == ZERO
-            add_offence(:convention, node.loc.expression, MSG_EVEN)
+            convention(node, :expression, MSG_EVEN)
           elsif args == ONE
-            add_offence(:convention, node.loc.expression, MSG_ODD)
+            convention(node, :expression, MSG_ODD)
           end
         end
 

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

@@ -16,9 +16,7 @@ module Rubocop
 
           if receiver_node && receiver_node.type == :array &&
               method_name == :* && arg_nodes[0].type == :str
-            add_offence(:convention,
-                        node.loc.selector,
-                        MSG)
+            convention(node, :selector)
           end
         end
       end

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

@@ -27,11 +27,15 @@ module Rubocop
               space = 1
               total = indentation + body_length + space + kw_length + space +
                 cond_length
-              total <= LineLength.max && !body_has_comment?(body, comments)
+              total <= max_line_length && !body_has_comment?(body, comments)
             end
           end
         end
 
+        def max_line_length
+          config.for_cop('LineLength')['Max']
+        end
+
         def length(sexp)
           sexp.loc.expression.source.lines.to_a.size
         end
@@ -71,7 +75,7 @@ module Rubocop
             next if if_else?(node)
 
             if check(node, processed_source.comments)
-              add_offence(:convention, node.loc.keyword, error_message)
+              convention(node, :keyword, error_message)
             end
           end
         end
@@ -108,7 +112,7 @@ module Rubocop
             next unless node.loc.end
 
             if check(node, processed_source.comments)
-              add_offence(:convention, node.loc.keyword, MSG)
+              convention(node, :keyword)
             end
           end
         end

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

@@ -17,7 +17,7 @@ module Rubocop
           if method_name == :% &&
               ([:str, :dstr].include?(receiver_node.type) ||
                arg_nodes[0].type == :array)
-            add_offence(:convention, node.loc.selector, MSG)
+            convention(node, :selector)
           end
         end
       end

data/lib/rubocop/cop/style/favor_unless_over_negated_if.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_offence(:convention, node.loc.expression, error_message)
+              convention(node, :expression, error_message)
             end
           end
         end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop enforces the presence of a final newline in each source file.
+      class FinalNewline < Cop
+        MSG = 'Source files should end with a newline(\n).'
+
+        def investigate(processed_source)
+          final_line = processed_source.raw_lines.to_a.last
+
+          unless final_line.end_with?("\n")
+            convention(nil,
+                       source_range(processed_source.buffer,
+                                    processed_source[0...-1],
+                                    final_line.length - 1, 1))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{avoid_for.rb → for.rb}

@@ -4,11 +4,11 @@ module Rubocop
   module Cop
     module Style
       # This cop looks for uses of the *for* keyword.
-      class AvoidFor < Cop
+      class For < Cop
         MSG = 'Prefer *each* over *for*.'
 
         def on_for(node)
-          add_offence(:convention, node.loc.keyword, MSG)
+          convention(node, :keyword)
         end
       end
     end

data/lib/rubocop/cop/style/{avoid_global_vars.rb → global_vars.rb}

@@ -5,7 +5,11 @@ module Rubocop
     module Style
       # This cops looks for uses of global variables.
       # It does not report offences for built-in global variables.
-      class AvoidGlobalVars < Cop
+      # Built-in global variables are allowed by default. Additionally
+      # users can allow additional variables via the AllowedVariables option.
+      #
+      # Note that backreferences like $1, $2, etc are not global variables.
+      class GlobalVars < Cop
         MSG = 'Do not introduce global variables.'
 
         # predefined global variables their English aliases
@@ -36,8 +40,21 @@ module Rubocop
           $stdin $stdout $stderr
           $DEBUG $FILENAME $VERBOSE $SAFE
           $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+          $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
         ).map(&:to_sym)
 
+        def user_vars
+          if cop_config['AllowedVariables']
+            cop_config['AllowedVariables'].map(&:to_sym)
+          else
+            []
+          end
+        end
+
+        def allowed_var?(global_var)
+          BUILT_IN_VARS.include?(global_var) || user_vars.include?(global_var)
+        end
+
         def on_gvar(node)
           check(node)
         end
@@ -49,11 +66,7 @@ module Rubocop
         def check(node)
           global_var, = *node
 
-          unless BUILT_IN_VARS.include?(global_var)
-            add_offence(:convention,
-                        node.loc.name,
-                        MSG)
-          end
+          convention(node, :name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -14,11 +14,9 @@ module Rubocop
           _receiver, method_name, *args = *node
 
           if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
-            add_offence(:convention,
-                        node.loc.selector,
-                        MSG.format(method_name,
-                                   proper_method_name(method_name)))
-            do_autocorrect(node)
+            convention(node, :selector,
+                       MSG.format(method_name,
+                                  proper_method_name(method_name)))
           end
         end
 

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

@@ -18,9 +18,9 @@ module Rubocop
           if sym_indices
             pairs.each do |pair|
               if pair.loc.operator && pair.loc.operator.is?('=>')
-                add_offence(:convention,
-                            pair.loc.expression.begin.join(pair.loc.operator),
-                            MSG)
+                convention(nil,
+                           pair.loc.expression.begin.join(pair.loc.operator),
+                           MSG)
               end
             end
           end
@@ -34,7 +34,7 @@ module Rubocop
           if key.type == :sym
             sym_name = key.to_a[0]
 
-            sym_name =~ /\A\w+\z/
+            sym_name =~ /\A[A-Za-z_]\w*\z/
           else
             false
           end

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

@@ -17,7 +17,7 @@ module Rubocop
           # We won't check modifier or ternary conditionals.
           if node.loc.expression.source =~ /\A(if|unless)\b/
             if offending_line(node)
-              add_offence(:convention, node.loc.expression, error_message)
+              convention(node, :expression, error_message)
             end
           end
         end

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

@@ -136,10 +136,10 @@ module Rubocop
                                    [expr.begin_pos,
                                     expr.begin_pos - indentation]
                                  end
-            add_offence(:convention,
-                        Parser::Source::Range.new(expr.source_buffer,
-                                                  begin_pos, end_pos),
-                        sprintf(MSG, indentation))
+            convention(nil,
+                       Parser::Source::Range.new(expr.source_buffer,
+                                                 begin_pos, end_pos),
+                       sprintf(MSG, indentation))
           end
         end
       end

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

@@ -24,9 +24,9 @@ module Rubocop
             lambda_length = lambda_length(node)
 
             if selector != '->' && lambda_length == 0
-              add_offence(:convention, block_method.loc.expression, SINGLE_MSG)
+              convention(block_method, :expression, SINGLE_MSG)
             elsif selector == '->' && lambda_length > 0
-              add_offence(:convention, block_method.loc.expression, MULTI_MSG)
+              convention(block_method, :expression, MULTI_MSG)
             end
           end
         end

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

@@ -14,7 +14,7 @@ module Rubocop
           processed_source.comments.each do |comment|
             if comment.text =~ /^#+[^#\s:+-]/
               unless comment.text.start_with?('#!') && comment.loc.line == 1
-                add_offence(:convention, comment.loc.expression, MSG)
+                convention(comment, :expression)
               end
             end
           end

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

@@ -10,20 +10,19 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
-            max = LineLength.max
             if line.length > max
               message = sprintf(MSG, line.length, max)
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index], max,
-                                       line.length - max),
-                          message)
+              convention(nil,
+                         source_range(processed_source.buffer,
+                                      processed_source[0...index], max,
+                                      line.length - max),
+                         message)
             end
           end
         end
 
-        def self.max
-          LineLength.config['Max']
+        def max
+          cop_config['Max']
         end
       end
     end

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

@@ -25,7 +25,7 @@ module Rubocop
             name = range.source.to_sym
             next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
 
-            add_offence(:convention, range, MSG)
+            convention(n, range)
           end
         end
 

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

@@ -10,10 +10,7 @@ module Rubocop
         def on_send(node)
           _receiver, _method_name, *args = *node
 
-          if args.empty? && node.loc.begin
-            add_offence(:convention, node.loc.begin, MSG)
-            do_autocorrect(node)
-          end
+          convention(node, :begin) if args.empty? && node.loc.begin
         end
 
         def autocorrect_action(node)

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

@@ -18,11 +18,11 @@ module Rubocop
         end
 
         def max_length
-          MethodLength.config['Max']
+          cop_config['Max']
         end
 
         def count_comments?
-          MethodLength.config['CountComments']
+          cop_config['CountComments']
         end
 
         private
@@ -32,7 +32,7 @@ module Rubocop
 
           if method_length > max_length
             message = sprintf(MSG, method_length, max_length)
-            add_offence(:convention, node.loc.keyword, message)
+            convention(node, :keyword, message)
           end
         end
 
@@ -41,7 +41,7 @@ module Rubocop
 
           return 0 unless lines
 
-          lines.map!(&:strip).reject!(&:empty?)
+          lines.reject!(&:blank?)
 
           lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
 

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

@@ -22,9 +22,7 @@ module Rubocop
 
           if body && body.type == :begin
             body.children.each do |body_node|
-              if body_node == TARGET_NODE
-                add_offence(:convention, body_node.loc.expression, MSG)
-              end
+              convention(body_node, :expression) if body_node == TARGET_NODE
             end
           end
         end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for chaining of a block after another block that spans
+      # multiple lines.
+      #
+      # @example
+      #
+      #   Thread.list.find_all do |t|
+      #     t.alive?
+      #   end.map do |t|
+      #     t.object_id
+      #   end
+      class MultilineBlockChain < Cop
+        MSG = 'Avoid multi-line chains of blocks.'
+
+        def on_block(node)
+          method, _args, _body = *node
+          on_node(:send, method) do |send_node|
+            receiver, _method_name, *_args = *send_node
+            if receiver && receiver.type == :block
+              # The begin and end could also be braces, but we call the
+              # variables do... and end...
+              do_kw_loc, end_kw_loc = receiver.loc.begin, receiver.loc.end
+
+              if do_kw_loc.line != end_kw_loc.line
+                range =
+                  Parser::Source::Range.new(end_kw_loc.source_buffer,
+                                            end_kw_loc.begin_pos,
+                                            method.loc.expression.end_pos)
+                convention(nil, range)
+                # Done. If there are more blocks in the chain, they will be
+                # found by subsequent calls to on_block.
+                break
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,9 +27,7 @@ module Rubocop
           if OPS.include?(op)
             _receiver, _method, args = *node
 
-            if args == NIL_NODE
-              add_offence(:convention, node.loc.selector, MSG)
-            end
+            convention(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')
-            add_offence(:convention, node.loc.selector, MSG)
+            convention(node, :selector)
           end
         end
       end

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

@@ -6,19 +6,39 @@ module Rubocop
       # This cop checks for big numeric literals without _ between groups
       # of digits in them.
       class NumericLiterals < Cop
-        MSG = 'Add underscores to large numeric literals to ' +
-          'improve their readability.'
+        MSG = 'Separate every 3 digits in the integer portion of a number' \
+          'with underscores(_).'
+
+        def min_digits
+          cop_config['MinDigits']
+        end
+
+        def enough_digits?(number)
+          number.to_s.size >= min_digits
+        end
 
         def on_int(node)
+          check(node)
+        end
+
+        def on_fload(node)
+          check(node)
+        end
+
+        def check(node)
           value, = *node
 
-          if value > 10000 &&
-              node.loc.expression.source.split('.').grep(/\d{6}/).any?
-            add_offence(:convention, node.loc.expression, MSG)
+          if enough_digits?(value)
+            int = integer_part(node)
+            if int =~ /\d{4}/ || int =~ /_\d{1,2}_/
+              convention(node, :expression)
+            end
           end
         end
 
-        alias_method :on_float, :on_int
+        def integer_part(node)
+          node.loc.expression.source.split('.').first
+        end
       end
     end
   end