rubocop 0.1.0 → 0.2.0

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p327

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+script: bundle exec rspec

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
@@ -6,11 +6,11 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 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"
-  gem "simplecov"
+  gem 'rspec', '~> 2.8.0'
+  gem 'yard', '~> 0.7'
+  gem 'redcarpet'
+  gem 'cucumber', '>= 0'
+  gem 'bundler', '~> 1.1.0'
+  gem 'jeweler', '~> 1.8.3'
+  gem 'simplecov'
 end

data/README.md

@@ -1,6 +1,22 @@
+[![Build Status](https://travis-ci.org/bbatsov/rubocop.png?branch=master)](https://travis-ci.org/bbatsov/rubocop)
+
 # rubocop
 
-Ruby code style checker.
+Ruby code style checker based on the [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide).
+
+## Basic Usage
+
+Running `rubocop` with no arguments will check all Ruby source files in the current folder:
+
+```bash
+$ rubocop
+```
+
+Alternatively you can `rubocop` a list of files and folders to check:
+
+```bash
+$ rubocop app spec lib/something.rb
+```
 
 ## Contributing to Rubocop
  

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/bin/rubocop

@@ -12,5 +12,5 @@ time = Benchmark.realtime do
   result = cli.run
 end
 
-puts "Finished in #{time} seconds"
+puts "Finished in #{time} seconds" if $options[:verbose]
 exit result

data/features/step_definitions/rubocop_steps.rb

@@ -0,0 +1 @@
+# encoding: utf-8

data/features/support/env.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'bundler'
 begin
   Bundler.setup(:default, :development)

data/lib/rubocop.rb

@@ -12,6 +12,12 @@ require 'rubocop/cop/indentation'
 require 'rubocop/cop/empty_lines'
 require 'rubocop/cop/surrounding_space'
 require 'rubocop/cop/space_after_comma_etc'
+require 'rubocop/cop/hash_syntax'
+require 'rubocop/cop/end_of_line'
+require 'rubocop/cop/numeric_literals'
+require 'rubocop/cop/align_parameters'
+require 'rubocop/cop/def_parentheses'
+require 'rubocop/cop/if_then_else'
 
 require 'rubocop/report/report'
 require 'rubocop/report/plain_text'

data/lib/rubocop/cli.rb

@@ -11,36 +11,39 @@ module Rubocop
     # the target files
     # @return [Fixnum] UNIX exit code
     def run(args = ARGV)
-      options = { :mode => :default }
+      $options = { mode: :default }
 
       OptionParser.new do |opts|
         opts.banner = "Usage: rubocop [options] [file1, file2, ...]"
 
         opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-          options[:verbose] = v
+          $options[:verbose] = v
         end
         opts.on("-e", "--emacs", "Emacs style output") do
-          options[:mode] = :emacs_style
+          $options[:mode] = :emacs_style
         end
       end.parse!(args)
 
       cops = Cop::Cop.all
+      show_cops_on_duty(cops) if $options[:verbose]
       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|
+      target_files(args).each do |file|
+        report = Report.create(file, $options[:mode])
+        source = File.readlines(file).map do |line|
           enc = line.encoding.name
           # Get rid of invalid byte sequences
-          line.encode!('UTF-16', enc, :invalid => :replace, :replace => '')
+          line.encode!('UTF-16', enc, invalid: :replace, replace: '')
           line.encode!(enc, 'UTF-16')
 
           line.chomp
-        }
+        end
+
+        tokens, sexp = CLI.rip_source(source)
 
         cops.each do |cop_klass|
           cop = cop_klass.new
-          cop.inspect_source(file, source)
+          cop.inspect(file, source, tokens, sexp)
           total_offences += cop.offences.count
           report << cop if cop.has_report?
         end
@@ -54,22 +57,39 @@ module Rubocop
       return total_offences == 0 ? 0 : 1
     end
 
+    def self.rip_source(source)
+      tokens = Ripper.lex(source.join("\n")).map { |t| Cop::Token.new(*t) }
+      sexp = Ripper.sexp(source.join("\n"))
+      Cop::Position.make_position_objects(sexp)
+      [tokens, sexp]
+    end
+
+    def show_cops_on_duty(cops)
+      puts "Reporting for duty:"
+      cops.each { |c| puts c }
+      puts "*******************"
+    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 raw_target_files(args)
       return Dir['**/*.rb'] if args.empty?
 
-      if glob = args.detect { |arg| arg =~ /\*/ }
-        Dir[glob]
-      else
-        args
+      files = []
+
+      args.each do |target|
+        if File.directory?(target)
+          files << Dir["#{target}/**/*.rb"]
+        elsif target =~ /\*/
+          files << Dir[target]
+        else
+          files << target
+        end
       end
+
+      files.flatten
     end
   end
 end

data/lib/rubocop/cop/align_parameters.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AlignParameters < Cop
+      ERROR_MESSAGE = 'Align the parameters of a method call if they span ' +
+        'more than one line.'
+
+      def inspect(file, source, tokens, sexp)
+        @file = file
+        @tokens = tokens
+        @token_indexes = {}
+        @tokens.each_with_index { |t, ix| @token_indexes[t.pos] = ix }
+
+        each(:method_add_arg, sexp) do |method_add_arg|
+          args = get_args(method_add_arg) or next
+          first_arg, rest_of_args = divide_args(args)
+          @first_lparen_ix = get_lparen_ix(method_add_arg)
+          pos_of_1st_arg = position_of(first_arg) or next # Give up.
+          rest_of_args.each do |arg|
+            pos = position_of(arg) or next # Give up if no position found.
+            if pos.lineno != pos_of_1st_arg.lineno
+              if pos.column != pos_of_1st_arg.column
+                add_offence(:convention, pos.lineno, ERROR_MESSAGE)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def get_args(method_add_arg)
+        fcall = method_add_arg[1]
+        return nil if fcall[0] != :fcall
+        return nil if fcall[1][0..1] == [:@ident, "lambda"]
+        arg_paren = method_add_arg[2..-1][0]
+        return nil if arg_paren[0] != :arg_paren || arg_paren[1].nil?
+
+        # A command (call wihtout parentheses) as first parameter
+        # means there's only one parameter.
+        return nil if [:command, :command_call].include?(arg_paren[1][0][0])
+
+        args_add_block = arg_paren[1]
+        unless args_add_block[0] == :args_add_block
+          fail "\n#{@file}: #{method_add_arg}"
+        end
+        args_add_block[1].empty? ? [args_add_block[2]] : args_add_block[1]
+      end
+
+      def divide_args(args)
+        if args[0] == :args_add_star
+          first_arg = args[1]
+          rest_of_args = args[2..-1]
+        else
+          first_arg = args[0]
+          rest_of_args = args[1..-1]
+        end
+        [first_arg, rest_of_args]
+      end
+
+      def get_lparen_ix(method_add_arg)
+        method_name_pos = method_add_arg[1][1][-1]
+        method_name_ix = @token_indexes[method_name_pos]
+        method_name_ix +
+          @tokens[method_name_ix..-1].map(&:type).index(:on_lparen)
+      end
+
+      def position_of(sexp)
+        # Indentation inside a string literal is irrelevant.
+        return nil if sexp[0] == :string_literal
+
+        pos = find_pos_in_sexp(sexp) or return nil # Nil means not found.
+        ix = find_first_non_whitespace_token(pos) or return nil
+        @tokens[ix].pos
+      end
+
+      def find_pos_in_sexp(sexp)
+        return sexp[2] if Position === sexp[2]
+        sexp.grep(Array).each do |s|
+          pos = find_pos_in_sexp(s) and return pos
+        end
+        nil
+      end
+
+      def find_first_non_whitespace_token(pos)
+        ix = @token_indexes[pos]
+        newline_found = false
+        start_ix = ix.downto(0) do |i|
+          case @tokens[i].text
+          when '('
+            break i + 1 if i == @first_lparen_ix
+          when "\n"
+            newline_found = true
+          when /\t/
+            # Bail out if tabs are used. Too difficult to calculate column.
+            return nil
+          when ','
+            if newline_found
+              break i + 1
+            else
+              # Bail out if there's a preceding comma on the same line.
+              return nil
+            end
+          end
+        end
+        offset = @tokens[start_ix..-1].index { |t| not whitespace?(t) }
+        start_ix + offset
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -2,6 +2,34 @@
 
 module Rubocop
   module Cop
+    class Position < Struct.new :lineno, :column
+      # Does a recursive search and replaces each [lineno, column] array
+      # in the sexp with a Position object.
+      def self.make_position_objects(sexp)
+        if sexp[0] =~ /^@/
+          sexp[2] = Position.new(*sexp[2])
+        else
+          sexp.grep(Array).each { |s| make_position_objects(s) }
+        end
+      end
+
+      # The point of this class is to provide named attribute access.
+      # So we don't want backwards compatibility with array indexing.
+      undef_method :[]
+    end
+
+    class Token
+      attr_reader :pos, :type, :text
+
+      def initialize(pos, type, text)
+        @pos, @type, @text = Position.new(*pos), type, text
+      end
+
+      def to_s
+        "[[#{@pos.lineno}, #{@pos.column}], #@type, #{@text.inspect}]"
+      end
+    end
+
     class Cop
       attr_accessor :offences
 
@@ -16,7 +44,6 @@ module Rubocop
       end
 
       def self.inherited(subclass)
-        puts "Registering cop #{subclass}"
         all << subclass
       end
 
@@ -36,42 +63,37 @@ module Rubocop
         !@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)
+      def add_offence(file, line_number, message)
+        @offences << Offence.new(file, line_number, message)
       end
 
       private
 
       def each_parent_of(sym, sexp)
         parents = []
-        sexp.each { |elem|
+        sexp.each do |elem|
           if Array === elem
             if elem[0] == sym
-              parents << sexp
+              parents << sexp unless parents.include?(sexp)
               elem = elem[1..-1]
             end
-            each_parent_of(sym, elem) { |parent| parents << parent }
+            each_parent_of(sym, elem) do |parent|
+              parents << parent unless parents.include?(parent)
+            end
           end
-        }
-        parents.uniq.each { |parent| yield parent }
+        end
+        parents.each { |parent| yield parent }
       end
 
       def each(sym, sexp)
         yield sexp if sexp[0] == sym
-        sexp.each { |elem|
+        sexp.each do |elem|
           each(sym, elem) { |s| yield s } if Array === elem
-        }
+        end
+      end
+
+      def whitespace?(token)
+        [:on_sp, :on_ignored_nl, :on_nl].include?(token.type)
       end
     end
   end

data/lib/rubocop/cop/def_parentheses.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+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."]
+      EMPTY_PARAMS = [:params, nil, nil, nil, nil, nil]
+
+      def inspect(file, source, tokens, sexp)
+        each(:def, sexp) do |def_sexp|
+          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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/empty_lines.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class EmptyLines < Cop
@@ -7,17 +9,16 @@ module Rubocop
         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
+          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 { |child|
-            next_row_ix = child[1][-1][0] - 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, source[next_row_ix],
-                          ERROR_MESSAGE)
+              add_offence(:convention, next_row_ix + 1, ERROR_MESSAGE)
             end
             current_row_ix = next_row_ix
-          }
+          end
         end
       end
     end