rubocop 0.6.1 → 0.7.0

data/lib/rubocop/cop/class_methods.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ClassMethods < Cop
+      ERROR_MESSAGE = 'Prefer self over class/module for class/module methods.'
+
+      def inspect(file, source, tokens, sexp)
+        # defs nodes correspond to class & module methods
+        each(:defs, sexp) do |s|
+          if s[1][0] == :var_ref && s[1][1][0] == :@const
+            add_offence(:convention,
+                        s[1][1][2].lineno,
+                        ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/colon_method_call.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ColonMethodCall < Cop
+      ERROR_MESSAGE = 'Do not use :: for method invocation.'
+
+      def inspect(file, source, tokens, sexp)
+        state = :outside
+        tokens.each do |t|
+          state = case [state, t.type]
+                  when [:outside, :on_const]
+                    :const
+
+                  when [:outside, :on_ident]
+                    :ident
+
+                  when [:const, :on_op]
+                    t.text == '::' ? :const_colon : :outside
+
+                  when [:ident, :on_op]
+                    t.text == '::' ? :ident_colon : :outside
+
+                  when [:ident_colon, :on_ident]
+                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+                    :ident
+
+                  when [:const_colon, :on_ident]
+                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+                    :ident
+
+                  when [:ident_colon, :on_const]
+                    :const
+
+                  when [:const_colon, :on_const]
+                    :const
+                  else
+                    :outside
+            end || state
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -32,6 +32,7 @@ module Rubocop
 
     class Cop
       attr_accessor :offences
+      attr_accessor :debug
       attr_writer :correlations, :disabled_lines
 
       @all = []
@@ -46,8 +47,13 @@ module Rubocop
         all << subclass
       end
 
+      def self.cop_name
+        name.to_s.split('::').last
+      end
+
       def initialize
         @offences = []
+        @debug = false
       end
 
       def has_report?
@@ -56,13 +62,13 @@ module Rubocop
 
       def add_offence(severity, line_number, message)
         unless @disabled_lines && @disabled_lines.include?(line_number)
-          message = $options[:debug] ? "#{name}: #{message}" : message
+          message = debug ? "#{name}: #{message}" : message
           @offences << Offence.new(severity, line_number, message)
         end
       end
 
       def name
-        self.class.to_s.split('::')[-1]
+        self.class.cop_name
       end
 
       private
@@ -108,6 +114,28 @@ module Rubocop
         return [sexp[2]] if sexp[0] =~ /^@/
         sexp.grep(Array).reduce([]) { |a, e| a + all_positions(e) }
       end
+
+      def keywords(tokens)
+        # we need to keep track of the previous token to avoid
+        # interpreting :some_keyword as the keyword some_keyword
+        prev = Token.new(0, :init, '')
+        # same goes for defs so we need to track those as well
+        keywords = []
+
+        tokens.each do |t|
+          keywords << t if prev.type != :on_symbeg && t.type == :on_kw
+          # def with name that's a kw confuses Ripper.lex
+          penultimate = keywords[-2]
+          keywords.pop if penultimate && penultimate.text == 'def'
+          prev = t
+        end
+
+        keywords
+      end
+
+      def each_keyword(keyword, tokens)
+        keywords(tokens).select { |t| t.text == keyword }.each { |t| yield t }
+      end
     end
   end
 end

data/lib/rubocop/cop/def_parentheses.rb

@@ -27,7 +27,7 @@ module Rubocop
           start = method_name_ix + 1
           rparen_ix = start + tokens[start..-1].index { |t| t.text == ')' }
           first_body_token = tokens[(rparen_ix + 1)..-1].find do |t|
-            not whitespace?(t)
+            !whitespace?(t)
           end
           if first_body_token.pos.lineno > pos.lineno
             # Only report offence if there's a line break after

data/lib/rubocop/cop/empty_line_between_defs.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EmptyLineBetweenDefs < Cop
+      ERROR_MESSAGE = 'Use empty lines between defs.'
+
+      def inspect(file, source, tokens, sexp)
+        each_parent_of(:def, sexp) do |parent|
+          defs = parent.select { |child| child[0] == :def }
+          identifier_of_first_def = defs[0][1]
+          current_row_ix = identifier_of_first_def[-1].lineno - 1
+          # The first def doesn't need to have an empty line above it,
+          # so we iterate starting at index 1.
+          defs[1..-1].each do |child|
+            next_row_ix = child[1][-1].lineno - 1
+            if source[current_row_ix..next_row_ix].grep(/^[ \t]*$/).empty?
+              add_offence(:convention, next_row_ix + 1, ERROR_MESSAGE)
+            end
+            current_row_ix = next_row_ix
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/empty_lines.rb

@@ -3,22 +3,19 @@
 module Rubocop
   module Cop
     class EmptyLines < Cop
-      ERROR_MESSAGE = 'Use empty lines between defs.'
+      ERROR_MESSAGE = 'Extra blank line detected.'
 
       def inspect(file, source, tokens, sexp)
-        each_parent_of(:def, sexp) do |parent|
-          defs = parent.select { |child| child[0] == :def }
-          identifier_of_first_def = defs[0][1]
-          current_row_ix = identifier_of_first_def[-1].lineno - 1
-          # The first def doesn't need to have an empty line above it,
-          # so we iterate starting at index 1.
-          defs[1..-1].each do |child|
-            next_row_ix = child[1][-1].lineno - 1
-            if source[current_row_ix..next_row_ix].grep(/^[ \t]*$/).empty?
-              add_offence(:convention, next_row_ix + 1, ERROR_MESSAGE)
-            end
-            current_row_ix = next_row_ix
+        previous_token = Token.new(0, :init, '')
+
+        tokens.each do |t|
+          if t.type == :on_ignored_nl && previous_token.type == :on_ignored_nl
+            add_offence(:convention,
+                        t.pos.lineno,
+                        ERROR_MESSAGE)
           end
+
+          previous_token = t
         end
       end
     end

data/lib/rubocop/cop/eval.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Eval < Cop
+      ERROR_MESSAGE = 'The use of eval is a serious security risk.'
+
+      def inspect(file, source, tokens, sexp)
+        each(:command, sexp) { |s| process_ident(s[1]) }
+        each(:fcall, sexp) { |s| process_ident(s[1]) }
+      end
+
+      def process_ident(sexp)
+        if sexp[0] == :@ident && sexp[1] == 'eval'
+          add_offence(:security,
+                      sexp[2].lineno,
+                      ERROR_MESSAGE)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_join.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class FavorJoin < Cop
+      ERROR_MESSAGE = 'Favor Array#join over Array#*.'
+
+      def inspect(file, source, tokens, sexp)
+        each(:binary, sexp) do |s|
+          op1 = s[1]
+          operator = s[2]
+          op2 = s[3]
+
+          # we care only about the * operator
+          next unless matching?(operator, op1, op2)
+
+          pos = all_positions(s[1]).first
+          lineno = pos.lineno if pos
+
+          add_offence(
+            :convention,
+            lineno,
+            ERROR_MESSAGE
+          ) if lineno
+        end
+      end
+
+      private
+
+      def matching?(operator, op1, op2)
+        return false unless operator == :*
+
+        op1[0] == :array and op2[0] == :string_literal
+      end
+    end
+  end
+end

data/lib/rubocop/cop/grammar.rb

@@ -18,6 +18,7 @@ module Rubocop
         @special = {
           assign:      [[:on_op,     '=']],
           brace_block: [[:on_lbrace, '{']],
+          hash:        [[:on_lbrace, '{']],
           ifop:        [[:on_op, '?'], [:on_op, ':']]
         }
       end
@@ -99,8 +100,7 @@ module Rubocop
 
           children.each do |elem|
             case elem
-            when Array
-              correlate(elem, path) # Dive deeper
+            when Array then correlate(elem, path) # Dive deeper
             when Symbol
               unless elem.to_s =~ /^@?[a-z_]+$/
                 # There's a trailing @ in some symbols in sexp,

data/lib/rubocop/cop/hash_literal.rb

@@ -6,16 +6,55 @@ module Rubocop
       ERROR_MESSAGE = 'Use hash literal {} instead of Hash.new.'
 
       def inspect(file, source, tokens, sexp)
+        offences = preliminary_scan(sexp)
+
+        # find Hash.new()
         each(:method_add_arg, sexp) do |s|
-          potential_class = s[1][1][1]
+          next if s[1][0] != :call
+
+          receiver = s[1][1][1]
+          method_name = s[1][3][1]
 
-          if potential_class && potential_class[1] == 'Hash' &&
-              s[1][3][1] == 'new' && s[2] == [:arg_paren, nil]
+          if receiver && receiver[1] == 'Hash' &&
+              method_name == 'new' && s[2] == [:arg_paren, nil]
+            offences.delete(Offence.new(:convention,
+                                        receiver[2].lineno,
+                                        ERROR_MESSAGE))
             add_offence(:convention,
-                        potential_class[2].lineno,
+                        receiver[2].lineno,
                         ERROR_MESSAGE)
           end
+
+          # check for false positives
+          if receiver && receiver[1] == 'Hash' &&
+              method_name == 'new' && s[2] != [:arg_paren, nil]
+            offences.delete(Offence.new(:convention,
+                                        receiver[2].lineno,
+                                        ERROR_MESSAGE))
+          end
+        end
+
+        offences.each { |o| add_offence(*o.explode) }
+      end
+
+      def preliminary_scan(sexp)
+        offences = []
+
+        # find Hash.new
+        # there will be some false positives here, which
+        # we'll eliminate later on
+        each(:call, sexp) do |s|
+          receiver = s[1][1]
+
+          if receiver && receiver[1] == 'Hash' &&
+              s[3][1] == 'new'
+            offences << Offence.new(:convention,
+                                    receiver[2].lineno,
+                                    ERROR_MESSAGE)
+          end
         end
+
+        offences
       end
     end
   end

data/lib/rubocop/cop/hash_syntax.rb

@@ -10,8 +10,8 @@ module Rubocop
           keys = assoclist_from_args[1].map { |assoc_new| assoc_new[1][0] }
           # If at least one of the keys in the hash is neither a symbol (:a)
           # nor a label (a:), we can't require the new syntax.
-          return if keys.find do |key|
-            not [:symbol_literal, :@label].include?(key)
+          return if keys.any? do |key|
+            ![:symbol_literal, :@label].include?(key)
           end
         end
         each(:assoc_new, sexp) do |assoc_new|

data/lib/rubocop/cop/if_then_else.rb

@@ -5,7 +5,7 @@ module Rubocop
     module IfThenElse
       def inspect(file, source, tokens, sexp)
         tokens.each_with_index do |t, ix|
-          if t.type == :on_kw && ['if', 'unless'].include?(t.text)
+          if t.type == :on_kw && %w(if unless).include?(t.text)
             if kind_of_if(tokens, ix + 1) == self.class
               add_offence(:convention, t.pos.lineno, error_message)
             end

data/lib/rubocop/cop/leading_comment_space.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class LeadingCommentSpace < Cop
+      ERROR_MESSAGE = 'Missing space after #.'
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each_index do |ix|
+          t = tokens[ix]
+          if t.type == :on_comment && t.text =~ /^#+[^#\s]/
+            unless t.text.start_with?('#!') && t.pos.lineno == 1
+              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_continuation.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class LineContinuation < Cop
+      ERROR_MESSAGE = 'Avoid the use of the line continuation character(/).'
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each_index do |ix|
+          t = tokens[ix]
+          if t.type == :on_sp && t.text == "\\\n"
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_length.rb

@@ -16,7 +16,7 @@ module Rubocop
       end
 
       def self.max
-        LineLength.config ? LineLength.config['Max'] || 79 : 79
+        LineLength.config['Max']
       end
     end
   end

data/lib/rubocop/cop/method_and_variable_snake_case.rb

@@ -5,25 +5,26 @@ module Rubocop
     class MethodAndVariableSnakeCase < Cop
       ERROR_MESSAGE = 'Use snake_case for methods and variables.'
       SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
+      CONSTANT = /^[A-Z]/
 
       def inspect(file, source, tokens, sexp)
-        each(:def, sexp) { |s| check(s[1]) }
+        each(:def, sexp) { |s| check(*s[1]) }
 
         each(:assign, sexp) do |s|
           case s[1][0]
           when :var_field
-            check(s[1][1])
+            check(*s[1][1]) unless s[1][1][1] =~ CONSTANT
           when :field
             if s[1][1][0] == :var_ref && s[1][1][1][0..1] == [:@kw, 'self']
-              check(s[1][3])
+              check(*s[1][3])
             end
           end
         end
       end
 
-      def check(sexp)
-        if [:@ivar, :@ident].include?(sexp[0]) && sexp[1] !~ SNAKE_CASE
-          add_offence(:convention, sexp[2].lineno, ERROR_MESSAGE)
+      def check(type, name, pos)
+        if [:@ivar, :@ident, :@const].include?(type) && name !~ SNAKE_CASE
+          add_offence(:convention, pos.lineno, ERROR_MESSAGE)
         end
       end
     end