rubocop 0.0.0 → 0.1.0

data/Gemfile

@@ -8,6 +8,7 @@ source "http://rubygems.org"
 group :development do
   gem "rspec", "~> 2.8.0"
   gem "yard", "~> 0.7"
+  gem "redcarpet"
   gem "cucumber", ">= 0"
   gem "bundler", "~> 1.1.0"
   gem "jeweler", "~> 1.8.3"

data/Gemfile.lock

@@ -22,6 +22,7 @@ GEM
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
+    redcarpet (2.1.1)
     rspec (2.8.0)
       rspec-core (~> 2.8.0)
       rspec-expectations (~> 2.8.0)
@@ -44,6 +45,7 @@ DEPENDENCIES
   bundler (~> 1.1.0)
   cucumber
   jeweler (~> 1.8.3)
+  redcarpet
   rspec (~> 2.8.0)
   simplecov
   yard (~> 0.7)

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/bin/rubocop

@@ -1,8 +1,16 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(File.dirname(File.realpath(__FILE__)) + '/../lib')
 
 require 'rubocop'
+require 'benchmark'
 
 cli = Rubocop::CLI.new
-exit cli.run
+result = 0
+
+time = Benchmark.realtime do
+  result = cli.run
+end
+
+puts "Finished in #{time} seconds"
+exit result

data/lib/rubocop.rb

@@ -1,5 +1,20 @@
+# encoding: utf-8
+
+require 'ripper'
+
 require 'rubocop/cop/offence'
 require 'rubocop/cop/cop'
-require 'rubocop/cop/line_length_cop'
+require 'rubocop/cop/encoding'
+require 'rubocop/cop/line_length'
+require 'rubocop/cop/tab'
+require 'rubocop/cop/trailing_whitespace'
+require 'rubocop/cop/indentation'
+require 'rubocop/cop/empty_lines'
+require 'rubocop/cop/surrounding_space'
+require 'rubocop/cop/space_after_comma_etc'
+
+require 'rubocop/report/report'
+require 'rubocop/report/plain_text'
+require 'rubocop/report/emacs_style'
 
 require 'rubocop/cli'

data/lib/rubocop/cli.rb

@@ -1,11 +1,17 @@
+# encoding: utf-8
+
 require 'optparse'
 
 module Rubocop
   # The CLI is a class responsible of handling all the command line interface
   # logic.
   class CLI
-    def run
-      options = {}
+    # Entry point for the application logic. Here we
+    # do the command line arguments processing and inspect
+    # the target files
+    # @return [Fixnum] UNIX exit code
+    def run(args = ARGV)
+      options = { :mode => :default }
 
       OptionParser.new do |opts|
         opts.banner = "Usage: rubocop [options] [file1, file2, ...]"
@@ -13,27 +19,56 @@ module Rubocop
         opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
           options[:verbose] = v
         end
-      end.parse!
+        opts.on("-e", "--emacs", "Emacs style output") do
+          options[:mode] = :emacs_style
+        end
+      end.parse!(args)
+
+      cops = Cop::Cop.all
+      total_offences = 0
+
+      target_files(args).reject { |f| File.directory?(f) }.each do |file|
+        report = Report.create(file, options[:mode])
+        source = File.readlines(file).map { |line|
+          enc = line.encoding.name
+          # Get rid of invalid byte sequences
+          line.encode!('UTF-16', enc, :invalid => :replace, :replace => '')
+          line.encode!(enc, 'UTF-16')
 
-      cops = []
-      cops << Cop::LineLengthCop
+          line.chomp
+        }
 
-      target_files.each do |file|
         cops.each do |cop_klass|
           cop = cop_klass.new
-          cop.inspect(file)
-          cop.report
+          cop.inspect_source(file, source)
+          total_offences += cop.offences.count
+          report << cop if cop.has_report?
         end
+
+        report.display unless report.empty?
       end
 
-      return 0
+      print "\n#{target_files(args).count} files inspected, "
+      puts "#{total_offences} offences detected"
+
+      return total_offences == 0 ? 0 : 1
+    end
+
+    # Generate a list of target files by expanding globing patterns
+    # (if any). If args is empty recursively finds all Ruby source
+    # files in the current directory
+    # @return [Array] array of filenames
+    def target_files(args)
+      raw_target_files(args).reject { |name| name =~ /_flymake/ }
     end
 
-    def target_files
-      return Dir['**/*.rb'] if ARGV.empty?
+    def raw_target_files(args)
+      return Dir['**/*.rb'] if args.empty?
 
-      if glob = ARGV.detect { |arg| arg =~ /\*/ }
-        return Dir[glob]
+      if glob = args.detect { |arg| arg =~ /\*/ }
+        Dir[glob]
+      else
+        args
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -1,21 +1,78 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class Cop
       attr_accessor :offences
 
+      @all = []
+      @enabled = []
+      @config = {}
+
+      class << self
+        attr_accessor :all
+        attr_accessor :enabled
+        attr_accessor :config
+      end
+
+      def self.inherited(subclass)
+        puts "Registering cop #{subclass}"
+        all << subclass
+      end
+
+      def self.enabled
+        all.select(&:enabled?)
+      end
+
+      def self.enabled?
+        true
+      end
+
       def initialize
         @offences = []
       end
 
-      def report
-        @offences.each do |offence|
-          puts offence
+      def has_report?
+        !@offences.empty?
+      end
+
+      def inspect_source(file, source)
+        case method(:inspect).arity
+        when 2
+          inspect(file, source)
+        else
+          tokens = Ripper.lex(source.join("\n"))
+          sexp = Ripper.sexp(source.join("\n"))
+          inspect(file, source, tokens, sexp)
         end
       end
 
       def add_offence(file, line_number, line, message)
         @offences << Offence.new(file, line_number, line, message)
       end
+
+      private
+
+      def each_parent_of(sym, sexp)
+        parents = []
+        sexp.each { |elem|
+          if Array === elem
+            if elem[0] == sym
+              parents << sexp
+              elem = elem[1..-1]
+            end
+            each_parent_of(sym, elem) { |parent| parents << parent }
+          end
+        }
+        parents.uniq.each { |parent| yield parent }
+      end
+
+      def each(sym, sexp)
+        yield sexp if sexp[0] == sym
+        sexp.each { |elem|
+          each(sym, elem) { |s| yield s } if Array === elem
+        }
+      end
     end
   end
 end

data/lib/rubocop/cop/empty_lines.rb

@@ -0,0 +1,25 @@
+module Rubocop
+  module Cop
+    class EmptyLines < 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][0] - 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 { |child|
+            next_row_ix = child[1][-1][0] - 1
+            if source[current_row_ix..next_row_ix].grep(/^[ \t]*$/).empty?
+              add_offence(:convention, next_row_ix, source[next_row_ix],
+                          ERROR_MESSAGE)
+            end
+            current_row_ix = next_row_ix
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/encoding.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Encoding < Cop
+      ERROR_MESSAGE = 'Missing encoding comment.'
+      MAX_LINE_LENGTH = 80
+
+      def inspect(file, source, tokens, sexp)
+        unless source[0] =~ /#.*coding: (UTF|utf)-8/
+          message = sprintf(ERROR_MESSAGE)
+          add_offence(:convention, 0, 0, message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/grammar.rb

@@ -0,0 +1,74 @@
+module Rubocop
+  module Cop
+    class Grammar
+      def initialize(tokens)
+        @tokens_without_pos = tokens.map { |tok| tok[1..-1] }
+        @ix = 0
+        @table = {}
+        token_positions = tokens.map { |tok| tok[0] }
+        @index_by_pos = Hash[*token_positions.each_with_index.to_a.flatten(1)]
+        @special = { assign: '=' }
+      end
+
+      # Returns a hash mapping indexes in the token array to grammar
+      # paths, e.g.:
+      # {  0 => [:program, :assign, :var_field, :@ident],
+      #    1 => [:program, :assign],
+      #    2 => [:program, :assign, :@int],
+      #    4 => [:program, :assign, :var_field, :@ident],
+      #    5 => [:program, :assign],
+      #    7 => [:program, :assign, :@int],
+      #    9 => [:program, :assign, :var_field, :@ident],
+      #   11 => [:program, :assign],
+      #   12 => [:program, :assign, :@int] }
+      def correlate(sexp, path = [])
+        case sexp
+        when Array
+          case sexp[0]
+          when /^@/
+            # Leaves in the grammar have a corresponding token with a
+            # position, which we search for and advance @ix.
+            @ix = @index_by_pos[sexp[-1]]
+            @table[@ix] = path + [sexp[0]]
+            @ix += 1
+          when *@special.keys
+            # Here we don't advance @ix because there may be other
+            # tokens inbetween the current one and the one we get from
+            # @special.
+            find(path, sexp, [:on_op, @special[sexp[0]]])
+          when :block_var # "{ |...|" or "do |...|"
+            @ix = find(path, sexp, [:on_op, '|']) + 1
+            find(path, sexp, [:on_op, '|'])
+          end
+          path += [sexp[0]] if Symbol === sexp[0]
+          # Compensate for reverse order of if modifier
+          children = (sexp[0] == :if_mod) ? sexp.reverse : sexp
+
+          children.each { |elem|
+            case elem
+            when Array
+              correlate(elem, path) # Dive deeper
+            when Symbol
+              unless elem.to_s =~ /^@?[a-z_]+$/
+                # There's a trailing @ in some symbols in sexp,
+                # e.g. :-@, that don't appear in tokens. That's why we
+                # chomp it off.
+                find(path, [elem], [:on_op, elem.to_s.chomp('@')])
+              end
+            end
+          }
+        end
+        @table
+      end
+
+      private
+
+      def find(path, sexp, token_to_find)
+        offset = @tokens_without_pos[@ix..-1].index(token_to_find) or return
+        ix = @ix + offset
+        @table[ix] = path + [sexp[0]]
+        ix
+      end
+    end
+  end
+end

data/lib/rubocop/cop/indentation.rb

@@ -0,0 +1,55 @@
+module Rubocop
+  module Cop
+    class Indentation < Cop
+      ERROR_MESSAGE = 'Indent when as deep as case.'
+
+      def inspect(file, source, tokens, sexp)
+        case_tokens = find_keywords(tokens, 'case')
+        when_tokens = find_keywords(tokens, 'when')
+        each_when(sexp) { |case_ix|
+          when_pos = when_tokens.shift[0]
+          if when_pos[1] != case_tokens[case_ix][0][1]
+            index = when_pos[0] - 1
+            add_offence(:convention, index, source[index], ERROR_MESSAGE)
+          end
+        }
+      end
+
+      def find_keywords(tokens, keyword)
+        indexes = tokens.each_index.find_all { |ix|
+          keyword?(tokens, ix, keyword)
+        }
+        tokens.values_at(*indexes)
+      end
+
+      def keyword?(tokens, ix, keyword)
+        tokens[ix][1..-1] == [:on_kw, keyword] &&
+          tokens[ix - 1][1] != :on_symbeg
+      end
+
+      # Does a depth first search for :when, yielding the index of the
+      # corresponding :case for each one.
+      def each_when(sexp, case_ix = -1, &block)
+        case sexp[0]
+        when :case
+          case_ix += 1
+          case_ix = next_when(sexp, case_ix, &block)
+        when :when
+          yield case_ix
+          all_except_when = sexp.grep(Array).find_all { |s| s[0] != :when }
+          case_ix_deep = each_when(all_except_when, case_ix, &block)
+          case_ix_next = next_when(sexp, case_ix, &block)
+          case_ix = (case_ix_next == case_ix) ? case_ix_deep : case_ix_next
+        else
+          sexp.grep(Array).each { |s| case_ix = each_when(s, case_ix, &block) }
+        end
+        case_ix
+      end
+
+      def next_when(sexp, case_ix, &block)
+        nxt = sexp.grep(Array).find { |s| s[0] == :when } or return case_ix
+        each_when(nxt, case_ix, &block)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_length.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class LineLength < Cop
+      ERROR_MESSAGE = 'Line is too long. [%d/%d]'
+      MAX_LINE_LENGTH = 79
+
+      def inspect(file, source)
+        source.each_with_index do |line, index|
+          if line.length > MAX_LINE_LENGTH
+            message = sprintf(ERROR_MESSAGE, line.length, MAX_LINE_LENGTH)
+            add_offence(:convention, index, line, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offence.rb

@@ -1,17 +1,25 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class Offence
-      attr_accessor :filename, :line_number, :line, :message
+      attr_accessor :severity, :line_number, :line, :message
+
+      SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
 
-      def initialize(filename, line_number, line, message)
-        @filename = filename
+      def initialize(severity, line_number, line, message)
+        @severity = severity
         @line_number = line_number
         @line = line
         @message = message
       end
 
       def to_s
-        "#@filename:#@line_number:#{@line.chomp} - #@message"
+        "#{encode_severity}:#{sprintf("%3d", line_number)}: #{message}"
+      end
+
+      def encode_severity
+        @severity.to_s[0].upcase
       end
     end
   end