rubocop 0.2.1 → 0.3.0

data/.rubocop.yml

@@ -0,0 +1,89 @@
+# This is the default configuration file with all checking enabled. It is also
+# the configuration used to check the rubocop source code.
+
+Encoding:
+  Enabled: true
+
+LineLength:
+  Enabled: true
+
+Tab:
+  Enabled: true
+
+TrailingWhitespace:
+  Enabled: true
+
+Indentation:
+  Enabled: true
+
+EmptyLines:
+  Enabled: true
+
+SpaceAroundOperators:
+  Enabled: true
+
+SpaceAroundBraces:
+  Enabled: true
+
+SpaceInsideParens:
+  Enabled: true
+
+SpaceInsideBrackets:
+  Enabled: true
+
+SpaceAfterComma:
+  Enabled: true
+
+SpaceAfterSemicolon:
+  Enabled: true
+
+SpaceAfterColon:
+  Enabled: true
+
+HashSyntax:
+  Enabled: true
+
+EndOfLine:
+  Enabled: true
+
+NumericLiterals:
+  Enabled: true
+
+AlignParameters:
+  Enabled: true
+
+DefWithParentheses:
+  Enabled: true
+
+DefWithoutParentheses:
+  Enabled: true
+
+IfWithSemicolon:
+  Enabled: true
+
+MultilineIfThen:
+  Enabled: true
+
+OneLineConditional:
+  Enabled: true
+
+MultilineBlocks:
+  Enabled: true
+
+SingleLineBlocks:
+  Enabled: true
+
+ParameterLists:
+  Enabled: true
+
+StringLiterals:
+  Enabled: true
+
+MultilineTernaryOperator:
+  Enabled: true
+
+NestedTernaryOperator:
+  Enabled: true
+
+UnlessElse:
+  Enabled: true

data/Rakefile

@@ -31,9 +31,10 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+desc 'Run RSpec with code coverage'
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['spec'].execute
 end
 
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/rubocop.rb

@@ -22,6 +22,9 @@ require 'rubocop/cop/blocks'
 require 'rubocop/cop/parameter_lists'
 require 'rubocop/cop/string_literals'
 require 'rubocop/cop/ternary_operator'
+require 'rubocop/cop/unless_else'
+require 'rubocop/cop/ampersands_pipes_vs_and_or'
+require 'rubocop/cop/when_then'
 
 require 'rubocop/report/report'
 require 'rubocop/report/plain_text'

data/lib/rubocop/cli.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require 'optparse'
+require 'yaml'
 
 module Rubocop
   # The CLI is a class responsible of handling all the command line interface
@@ -22,11 +23,18 @@ module Rubocop
         opts.on('-e', '--emacs', 'Emacs style output') do
           $options[:mode] = :emacs_style
         end
+        opts.on('-c FILE', '--config FILE', 'Configuration file') do |f|
+          $options[:config] = YAML.load_file(f)
+        end
+        opts.on('-s', '--silent', 'Silence summary') do |s|
+          $options[:silent] = s
+        end
       end.parse!(args)
 
       cops = Cop::Cop.all
       show_cops_on_duty(cops) if $options[:verbose]
       total_offences = 0
+      @configs = {}
 
       target_files(args).each do |file|
         report = Report.create(file, $options[:mode])
@@ -38,18 +46,24 @@ module Rubocop
         tokens, sexp, correlations = CLI.rip_source(source)
 
         cops.each do |cop_klass|
-          cop = cop_klass.new
-          cop.correlations = correlations
-          cop.inspect(file, source, tokens, sexp)
-          total_offences += cop.offences.count
-          report << cop if cop.has_report?
+          config = $options[:config] || config_from_dotfile(File.dirname(file))
+          cop_config = config[cop_klass.name.split('::').last] if config
+          if cop_config.nil? || cop_config['Enabled']
+            cop = cop_klass.new
+            cop.correlations = correlations
+            cop.inspect(file, source, tokens, sexp)
+            total_offences += cop.offences.count
+            report << cop if cop.has_report?
+          end
         end
 
         report.display unless report.empty?
       end
 
-      print "\n#{target_files(args).count} files inspected, "
-      puts "#{total_offences} offences detected"
+      unless $options[:silent]
+        print "\n#{target_files(args).count} files inspected, "
+        puts "#{total_offences} offences detected"
+      end
 
       return total_offences == 0 ? 0 : 1
     end
@@ -70,6 +84,30 @@ module Rubocop
       [tokens, sexp, correlations]
     end
 
+    # Returns the configuration hash from .rubocop.yml searching
+    # upwards in the directory structure starting at the given
+    # directory where the inspected file is. If no .rubocop.yml is
+    # found there, the user's home directory is checked.
+    def config_from_dotfile(target_file_dir)
+      # @configs is a cache that maps directories to
+      # configurations. We search for .rubocop.yml only if we haven't
+      # already found it for the given directory.
+      unless @configs[target_file_dir]
+        dir = target_file_dir
+        while dir != '/'
+          path = File.join(dir, '.rubocop.yml')
+          if File.exist?(path)
+            @configs[target_file_dir] = YAML.load_file(path)
+            break
+          end
+          dir = File.expand_path('..', dir)
+        end
+        path = File.join(Dir.home, '.rubocop.yml')
+        @configs[target_file_dir] = YAML.load_file(path) if File.exist?(path)
+      end
+      @configs[target_file_dir]
+    end
+
     def show_cops_on_duty(cops)
       puts 'Reporting for duty:'
       cops.each { |c| puts c }

data/lib/rubocop/cop/ampersands_pipes_vs_and_or.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AmpersandsPipesVsAndOr < Cop
+      ERROR_MESSAGE =
+        'Use &&/|| for boolean expressions, and/or for control flow.'
+
+      def inspect(file, source, tokens, sexp)
+        [:if, :unless, :while, :until].each { |keyword| check(keyword, sexp) }
+      end
+
+      def check(keyword, sexp)
+        each(keyword, sexp) do |sub_sexp|
+          condition = sub_sexp[1]
+          if condition[0] == :binary && [:and, :or].include?(condition[2])
+            add_offence(:convention,
+                        sub_sexp.flatten.grep(Position).first.lineno,
+                        ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/blocks.rb

@@ -2,47 +2,58 @@
 
 module Rubocop
   module Cop
-    class Blocks < Cop
-      ERROR_MESSAGE = ['Avoid using {...} for multi-line blocks.',
-                       'Prefer {...} over do...end for single-line blocks.']
-
+    module Blocks
       def inspect(file, source, tokens, sexp)
         @file = file
 
-        # The reverse_correlations maps grammar path object ids to
+        # The @reverse_correlations maps grammar path object ids to
         # token indexes, so we can use it to find the corresponding }
         # for each {.
-        reverse_correlations = Hash.new([])
+        @reverse_correlations = Hash.new([])
         @correlations.each do |ix, path|
-          reverse_correlations[path.object_id] += [ix]
+          @reverse_correlations[path.object_id] += [ix]
         end
-        tokens.each_with_index do |t, ix|
-          case [t.type, t.text]
-          when [:on_lbrace, '{']
-            path = @correlations[ix] or next
-            if path.last == :brace_block
-              rbrace_ix = reverse_correlations[path.object_id] - [ix]
-              if rbrace_ix.empty?
-                fail "\n#@file:#{t.pos.lineno}:#{t.pos.column}: " +
-                  'Matching brace not found'
-              end
-              if tokens[*rbrace_ix].pos.lineno > t.pos.lineno
-                add_offence(:convention, t.pos.lineno, ERROR_MESSAGE[0])
-              end
-            end
-          when [:on_kw, 'do']
-            end_offset = tokens[ix..-1].index { |t2| t2.text == 'end' }
-            unless end_offset
+
+        tokens.each_index { |ix| check(tokens, ix) }
+      end
+    end
+
+    class MultilineBlocks < Cop
+      include Blocks
+      ERROR_MESSAGE = 'Avoid using {...} for multi-line blocks.'
+
+      def check(tokens, ix)
+        t = tokens[ix]
+        if [t.type, t.text] == [:on_lbrace, '{']
+          path = @correlations[ix] or return
+          if path.last == :brace_block
+            rbrace_ix = @reverse_correlations[path.object_id] - [ix]
+            if rbrace_ix.empty?
               fail "\n#@file:#{t.pos.lineno}:#{t.pos.column}: " +
-                'Matching end not found'
+                'Matching brace not found'
             end
-            end_token_ix = ix + end_offset
-            if tokens[end_token_ix].pos.lineno == t.pos.lineno
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE[1])
+            if tokens[*rbrace_ix].pos.lineno > t.pos.lineno
+              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
             end
           end
         end
       end
     end
+
+    class SingleLineBlocks < Cop
+      include Blocks
+      ERROR_MESSAGE = 'Prefer {...} over do...end for single-line blocks.'
+
+      def check(tokens, ix)
+        t = tokens[ix]
+        if [t.type, t.text] == [:on_kw, 'do']
+          end_offset = tokens[ix..-1].index { |t2| t2.text == 'end' } or return
+          end_token_ix = ix + end_offset
+          if tokens[end_token_ix].pos.lineno == t.pos.lineno
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
   end
 end

data/lib/rubocop/cop/cop.rb

@@ -35,12 +35,10 @@ module Rubocop
       attr_writer :correlations
 
       @all = []
-      @enabled = []
       @config = {}
 
       class << self
         attr_accessor :all
-        attr_accessor :enabled
         attr_accessor :config
       end
 
@@ -48,14 +46,6 @@ module Rubocop
         all << subclass
       end
 
-      def self.enabled
-        all.select(&:enabled?)
-      end
-
-      def self.enabled?
-        true
-      end
-
       def initialize
         @offences = []
       end
@@ -64,8 +54,8 @@ module Rubocop
         !@offences.empty?
       end
 
-      def add_offence(file, line_number, message)
-        @offences << Offence.new(file, line_number, message)
+      def add_offence(severity, line_number, message)
+        @offences << Offence.new(severity, line_number, message)
       end
 
       private
@@ -96,6 +86,11 @@ module Rubocop
       def whitespace?(token)
         [:on_sp, :on_ignored_nl, :on_nl].include?(token.type)
       end
+
+      def all_positions(sexp)
+        return [sexp[2]] if sexp[0] =~ /^@/
+        sexp.grep(Array).inject([]) { |memo, s| memo + all_positions(s) }
+      end
     end
   end
 end

data/lib/rubocop/cop/def_parentheses.rb

@@ -2,37 +2,50 @@
 
 module Rubocop
   module Cop
-    class DefParentheses < Cop
-      ERROR_MESSAGE = ['Use def with parentheses when there are arguments.',
-                       'Omit the parentheses in defs when the method ' +
-                       "doesn't accept any arguments."]
+    module DefParentheses
       EMPTY_PARAMS = [:params, nil, nil, nil, nil, nil]
 
       def inspect(file, source, tokens, sexp)
-        each(:def, sexp) do |def_sexp|
+        each(:def, sexp) { |def_sexp| check(tokens, def_sexp) }
+      end
+    end
+
+    class DefWithParentheses < Cop
+      include DefParentheses
+      def error_message
+        "Omit the parentheses in defs when the method doesn't accept any " +
+          'arguments.'
+      end
+
+      def check(tokens, def_sexp)
+        if def_sexp[2][0] == :paren && def_sexp[2][1] == EMPTY_PARAMS
           pos = def_sexp[1][-1]
-          case def_sexp[2][0]
-          when :params
-            if def_sexp[2] != EMPTY_PARAMS
-              add_offence(:convention, pos.lineno, ERROR_MESSAGE[0])
-            end
-          when :paren
-            if def_sexp[2][1] == EMPTY_PARAMS
-              method_name_ix = tokens.index { |t| t.pos == pos }
-              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)
-              end
-              if first_body_token.pos.lineno > pos.lineno
-                # Only report offence if there's a line break after
-                # the empty parens.
-                add_offence(:convention, pos.lineno, ERROR_MESSAGE[1])
-              end
-            end
+          method_name_ix = tokens.index { |t| t.pos == pos }
+          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)
+          end
+          if first_body_token.pos.lineno > pos.lineno
+            # Only report offence if there's a line break after
+            # the empty parens.
+            add_offence(:convention, pos.lineno, error_message)
           end
         end
       end
     end
+
+    class DefWithoutParentheses < Cop
+      include DefParentheses
+      def error_message
+        'Use def with parentheses when there are arguments.'
+      end
+
+      def check(tokens, def_sexp)
+        if def_sexp[2][0] == :params && def_sexp[2] != EMPTY_PARAMS
+          add_offence(:convention, def_sexp[1][-1].lineno, error_message)
+        end
+      end
+    end
   end
 end