ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/version.rb

@@ -1,3 +1,3 @@
 module RubyLint
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end # RubyLint

data/ruby-lint.gemspec

@@ -3,10 +3,10 @@ require File.expand_path('../lib/ruby-lint/version', __FILE__)
 Gem::Specification.new do |s|
   s.name        = 'ruby-lint'
   s.version     = RubyLint::VERSION
-  s.date        = '2012-11-15'
+  s.date        = '2013-04-22'
   s.authors     = ['Yorick Peterse']
   s.email       = 'yorickpeterse@gmail.com'
-  s.summary     = 'Static code analysis tool and linter for Ruby'
+  s.summary     = 'A linter and static code analysis tool for Ruby.'
   s.homepage    = 'https://github.com/yorickpeterse/ruby-lint/'
   s.description = s.summary
   s.executables = ['ruby-lint']
@@ -14,11 +14,22 @@ Gem::Specification.new do |s|
   s.files = File.read(File.expand_path('../MANIFEST', __FILE__)).split("\n")
 
   s.has_rdoc              = 'yard'
-  s.required_ruby_version = '>= 1.9.2'
+  s.required_ruby_version = '>= 1.9.3'
 
-  s.add_development_dependency('rake', ['>= 0.9.2.2'])
-  s.add_development_dependency('redcarpet', ['>= 2.1.1'])
-  s.add_development_dependency('bacon', ['>= 1.1.0'])
-  s.add_development_dependency('yard', ['>= 0.8.2.1'])
-  s.add_development_dependency('pry-rescue', ['>= 0.8'])
+  s.add_dependency 'ast'
+  s.add_dependency 'slop'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'bacon', ['>= 1.2.0']
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'pry-rescue'
+  s.add_development_dependency 'bacon-colored_output'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rubygems-openpgp'
+
+  # NOTE: This is to prevent Travis CI from soiling its pants. It's not a
+  # really nice solution but it seems to be the only way (at least for now).
+  if RUBY_PLATFORM != 'java'
+    s.add_development_dependency 'redcarpet', ['>= 2.1.1']
+  end
 end

data/spec/helper.rb

@@ -1,6 +1,14 @@
-require File.expand_path('../../lib/ruby-lint', __FILE__)
 require 'bacon'
+require 'bacon/colored_output'
+require_relative 'support/bacon'
 
-RubyLint::FIXTURES = File.expand_path('../fixtures', __FILE__)
+if ENV['COVERAGE']
+  require_relative 'support/simplecov'
+end
+
+require_relative '../lib/ruby-lint'
+require_relative 'support/building'
+require_relative 'support/parsing'
+require_relative 'support/definitions'
 
 Bacon.summary_on_exit

data/spec/ruby-lint/analyze/argument_amount.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::Analyze::ArgumentAmount do
+  should 'validate the amount of required arguments' do
+    code = <<-CODE
+def example(first, second)
+end
+
+example
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 4
+    entry.column.should  == 0
+    entry.message.should == 'wrong number of arguments (expected 2 but got 0)'
+  end
+
+  should 'validate argument amounts when using optional arguments' do
+    code = <<-CODE
+def example(first, second, third = nil)
+end
+
+example
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 4
+    entry.column.should  == 0
+    entry.message.should == 'wrong number of arguments ' \
+      '(expected 2..3 but got 0)'
+  end
+
+  should 'validate argument amounts when using rest arguments' do
+    code = <<-CODE
+def example(first, second, *args)
+end
+
+example
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 4
+    entry.column.should  == 0
+    entry.message.should == 'wrong number of arguments ' \
+      '(expected 2 but got 0)'
+  end
+
+  should 'validate argument amounts when using a required and rest argument' do
+    code = <<-CODE
+def example(required, *numbers)
+end
+
+example(10, 20, 30)
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+
+    report.entries.length.should == 0
+  end
+
+  should 'take variable assignments into account' do
+    code = <<-CODE
+name = 'Ruby'
+
+name.downcase
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+
+    report.entries.empty?.should == true
+  end
+
+  should 'not validate methods called on undefined receivers' do
+    code   = 'A.example_method'
+    report = build_report(code, RubyLint::Analyze::ArgumentAmount)
+
+    report.entries.empty?.should == true
+  end
+end

data/spec/ruby-lint/analyze/shadowing_variables.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Analyze::ShadowingVariables' do
-  it 'Warn for shadowing outer variables' do
+describe RubyLint::Analyze::ShadowingVariables do
+  should 'warn for shadowing outer variables' do
     code = <<-CODE
 number = 10
 
@@ -10,21 +10,76 @@ number = 10
 end
     CODE
 
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
+    report = build_report(code, RubyLint::Analyze::ShadowingVariables)
+    entry  = report.entries[0]
 
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::ShadowingVariables)
-    iterator.run(tokens)
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    report.messages[:warning].class.should  == Array
-    report.messages[:warning].length.should == 1
+    entry.line.should    == 3
+    entry.column.should  == 18
+    entry.message.should == 'shadowing outer local variable number'
+  end
+
+  should 'not warn for shadowed variables in a new scope' do
+    code = <<-CODE
+number = 10
+
+def example
+  [10, 20].each do |number|
+    puts number
+  end
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ShadowingVariables)
+
+    report.entries.empty?.should == true
+  end
+
+  should 'warn when shadowing variables after a new scope' do
+    code = <<-CODE
+number = 10
+
+def example; end
+
+[10, 20].each do |number|
+  puts number
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ShadowingVariables)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 5
+    entry.column.should  == 18
+    entry.message.should == 'shadowing outer local variable number'
+  end
+
+  should 'not fail when re-using the same block' do
+    code = <<-CODE
+number = 10
+
+A::B.example do |number|
+  number
+end
+
+A::B.example do |number|
+  number
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::ShadowingVariables)
+
+    report.entries.length.should == 2
+
+    first, second = report.entries
 
-    warning = report.messages[:warning][0]
+    first.line.should    == 3
+    first.column.should  == 17
 
-    warning[:message].should == 'shadowing outer local variable number'
-    warning[:line].should    == 3
-    warning[:column].should  == 18
+    second.line.should    == 7
+    second.column.should  == 17
   end
 end

data/spec/ruby-lint/analyze/undefined_methods.rb

@@ -0,0 +1,174 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::Analyze::UndefinedMethods do
+  should 'add an error for calling an undefined method' do
+    report = build_report('example_method', RubyLint::Analyze::UndefinedMethods)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined method example_method'
+  end
+
+  should 'add an error for calling an undefined method with a receiver' do
+    code = <<-CODE
+class << self
+  def example_method
+  end
+end
+
+String.example_method
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 6
+    entry.column.should  == 7
+    entry.message.should == 'undefined method example_method on String'
+  end
+
+  should 'add an error for calling an undefined method on a receiver instance' do
+    code   = '"hello".example_method'
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+    entry  = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 1
+    entry.column.should  == 8
+    entry.message.should == 'undefined method example_method ' \
+      'on an instance of String'
+  end
+
+  should 'add an error when calling a method defined in a different scope' do
+    code = <<-CODE
+class Person
+  def name
+    return 'name'
+  end
+
+  def greet
+    name
+  end
+end
+
+name
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.length.should == 1
+
+    entry = report.entries[0]
+
+    entry.is_a?(RubyLint::Report::Entry).should == true
+
+    entry.line.should    == 11
+    entry.column.should  == 0
+    entry.message.should == 'undefined method name'
+  end
+
+  describe 'core Ruby types' do
+    should 'not add errors for calling defined methods on a Fixnum' do
+      report = build_report('10.to_s', RubyLint::Analyze::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+
+    should 'not add errors for calling defined methods on a Float' do
+      report = build_report('(10.0).to_s', RubyLint::Analyze::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+
+    should 'not add errors for calling defined methods on a String' do
+      report = build_report('"10".to_s', RubyLint::Analyze::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+
+    should 'not add errors for calling defined methods on a Hash' do
+      report = build_report('{}.to_s', RubyLint::Analyze::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+
+    should 'not add errors for calling defined methods on an Array' do
+      report = build_report('[].to_s', RubyLint::Analyze::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+  end
+
+  should 'not add errors for variables created using blocks' do
+    code = <<-CODE
+[10, 20].each do |number|
+  number.to_s
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.empty?.should == true
+  end
+
+  should 'take variable assignments into account' do
+    code = <<-CODE
+name = 'Ruby'
+
+name.downcase
+name.downcasex
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.length.should == 1
+
+    entry = report.entries[0]
+
+    entry.line.should    == 4
+    entry.column.should  == 5
+    entry.message.should == 'undefined method downcasex on an instance of String'
+  end
+
+  should 'not add errors when calling a method on an undefined constant' do
+    code = 'A.example_method'
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.empty?.should == true
+  end
+
+  should 'not add errors for methods called on variables without values' do
+    code = <<-CODE
+def example(number)
+  number.to_s
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.empty?.should == true
+  end
+
+  should 'report the right receiver name in multiple variable assignments' do
+    code = <<-CODE
+number = 10
+
+first = second = number.foobar
+    CODE
+
+    report = build_report(code, RubyLint::Analyze::UndefinedMethods)
+
+    report.entries.length.should == 1
+
+    entry = report.entries[0]
+
+    entry.message.should == 'undefined method foobar on an instance of Fixnum'
+  end
+end

data/spec/ruby-lint/analyze/undefined_variables.rb

@@ -1,230 +1,121 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Analyze::UndefinedVariables' do
-  it 'Use of undefined variables' do
-    code = <<-CODE
-number = 10
-
-puts numberx
-puts @number
-puts @@number
-puts $number
-puts NUMBER
-
-# The code below should not add any errors.
-numberx  = 10
-@number  = 10
-@@number = 10
-$number  = 10
-NUMBER   = 10
-
-puts numberx
-puts @number
-puts @@number
-puts $number
-puts NUMBER
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
+describe RubyLint::Analyze::UndefinedVariables do
+  should 'add an error for using an undefined instance variable' do
+    report = build_report('@number', RubyLint::Analyze::UndefinedVariables)
+    entry  = report.entries[0]
 
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    report.messages[:error].class.should  == Array
-    report.messages[:error].length.should == 5
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined instance variable @number'
+  end
 
-    errors = report.messages[:error]
+  should 'add an error for using an undefined class variable' do
+    report = build_report('@@number', RubyLint::Analyze::UndefinedVariables)
+    entry  = report.entries[0]
 
-    errors[0][:message].should == 'undefined local variable or method numberx'
-    errors[0][:line].should    == 3
-    errors[0][:column].should  == 5
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    errors[1][:message].should == 'undefined instance variable @number'
-    errors[1][:line].should    == 4
-    errors[1][:column].should  == 5
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined class variable @@number'
+  end
 
-    errors[2][:message].should == 'undefined class variable @@number'
-    errors[2][:line].should    == 5
-    errors[2][:column].should  == 5
+  should 'add an error for using an undefined global variable' do
+    report = build_report('$number', RubyLint::Analyze::UndefinedVariables)
+    entry  = report.entries[0]
 
-    errors[3][:message].should == 'undefined global variable $number'
-    errors[3][:line].should    == 6
-    errors[3][:column].should  == 5
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    errors[4][:message].should == 'undefined constant NUMBER'
-    errors[4][:line].should    == 7
-    errors[4][:column].should  == 5
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined global variable $number'
   end
 
-  it 'Default global variables should not trigger errors' do
-    code     = Kernel.global_variables.join("\n")
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
+  should 'add an error for using an undefined constant' do
+    report = build_report('NUMBER', RubyLint::Analyze::UndefinedVariables)
+    entry  = report.entries[0]
 
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    report.messages[:error].nil?.should == true
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined constant NUMBER'
   end
 
-  it 'Use of undefined variables using a method scope' do
+  should 'add an error for using an undefined constant in a constant path' do
     code = <<-CODE
-a  = 10
-@a = 10
+# This is to ensure that the on_constant() callback isn't used to check for "B"
+# in the global scope.
+B = 10
 
-def number
-  b = 10
-
-  puts @a # @a should be available as it's an instance method
-  puts a  # a is defined outside of this scope
-  puts c  # c simply doesn't exist
+module A
 end
 
-puts a
-puts b # b was defined inside the method and isn't available outside it
+A::B
     CODE
 
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
-
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
-
-    report.messages[:error].class.should  == Array
-    report.messages[:error].length.should == 3
+    report = build_report(code, RubyLint::Analyze::UndefinedVariables)
+    entry  = report.entries[0]
 
-    errors = report.messages[:error]
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    errors[0][:message].should == 'undefined local variable or method a'
-    errors[0][:line].should    == 8
-    errors[0][:column].should  == 7
-
-    errors[1][:message].should == 'undefined local variable or method c'
-    errors[1][:line].should    == 9
-    errors[1][:column].should  == 7
-
-    errors[2][:message].should == 'undefined local variable or method b'
-    errors[2][:line].should    == 13
-    errors[2][:column].should  == 5
+    entry.line.should    == 8
+    entry.column.should  == 3
+    entry.message.should == 'undefined constant B'
   end
 
-  it 'Instance variables should be available outside a method' do
-    code = <<-CODE
-def number
-  @number = 10
-end
+  should 'add an error when the entire constant path does not exist' do
+    code   = 'A::B::C'
+    report = build_report(code, RubyLint::Analyze::UndefinedVariables)
 
-puts @number
-    CODE
+    report.entries.length.should == 1
 
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
+    entry = report.entries[0]
 
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
-
-    report.messages[:error].nil?.should == true
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'undefined constant A'
   end
 
-  it 'Instance variables should be available across a class\' methods' do
+  should 'not depend on the order of variable definitions' do
     code = <<-CODE
 class Person
-  def initialize
-    @name = 'Ruby'
+  def first
+    @number = 10
   end
 
-  def some_method
-    @name.upcase
-    @namex.upcase
+  def second
+    return @number
   end
 end
     CODE
 
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
-
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
-
-    report.messages[:error].class.should  == Array
-    report.messages[:error].length.should == 1
-
-    error = report.messages[:error][0]
+    report = build_report(code, RubyLint::Analyze::UndefinedVariables)
 
-    error[:message].should == 'undefined instance variable @namex'
-    error[:line].should    == 8
-    error[:column].should  == 4
+    report.entries.empty?.should == true
   end
 
-  it 'Add errors for non existing constant paths' do
-    code = <<-CODE
-A::B = 10
-
-module A
-
-end
-
-puts A::B
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
-
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
+  should 'not add errors when autoloading constants' do
+    code   = 'Encoding::BIG5'
+    report = build_report(code, RubyLint::Analyze::UndefinedVariables)
 
-    report.messages[:error].class.should  == Array
-    report.messages[:error].length.should == 2
-
-    errors = report.messages[:error]
-
-    errors[0][:message].should == 'undefined constant A'
-    errors[0][:line].should    == 1
-    errors[0][:column].should  == 0
-
-    errors[1][:message].should == 'undefined constant A::B'
-    errors[1][:line].should    == 7
-    errors[1][:column].should  == 5
+    report.entries.empty?.should == true
   end
 
-  it 'Look up a constant using an implicit constant path' do
+  should 'not error when inheriting data in a block' do
     code = <<-CODE
-module RubyLint
-  module Derp
-    Foobar.name
-    ConstantImporter.name
-  end
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    report   = RubyLint::Report.new
-    iterator = RubyLint::Iterator.new(report)
+NUMBER = 10
 
-    iterator.bind(RubyLint::Analyze::Definitions)
-    iterator.bind(RubyLint::Analyze::UndefinedVariables)
-    iterator.run(tokens)
-
-    report.messages[:error].class.should  == Array
-    report.messages[:error].length.should == 1
+example_method do
+  NUMBER
+end
+CODE
 
-    error = report.messages[:error][0]
+    report = build_report(code, RubyLint::Analyze::UndefinedVariables)
 
-    error[:message].should == 'undefined constant Foobar'
-    error[:line].should    == 3
-    error[:column].should  == 4
+    report.entries.empty?.should == true
   end
 end