ruby-lint 0.0.1a → 0.0.1a1

data/spec/helper.rb

@@ -1,4 +1,6 @@
-require File.expand_path('../../lib/rlint', __FILE__)
+require File.expand_path('../../lib/ruby-lint', __FILE__)
 require 'bacon'
 
+RubyLint::FIXTURES = File.expand_path('../fixtures', __FILE__)
+
 Bacon.summary_on_exit

data/spec/{rlint → ruby-lint}/analyze/coding_style.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'Rlint::Analyze::CodingStyle' do
+describe 'RubyLint::Analyze::CodingStyle' do
   it 'Check the casing of method names and variables' do
     code = <<-CODE
 def getNumber(theNumber = 10)
@@ -10,11 +10,11 @@ def getNumber(theNumber = 10)
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     messages = report.messages[:info]
@@ -51,16 +51,16 @@ this_variable_is_fine = 10
 THIS_CONSTANT_NAME_IS_WAY_TOO_LONG = 10
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     messages = report.messages[:info]
     message  = "method and variable names should not be longer than " \
-      "#{Rlint::Analyze::CodingStyle::MAXIMUM_NAME_LENGTH} characters"
+      "#{RubyLint::Analyze::CodingStyle::MAXIMUM_NAME_LENGTH} characters"
 
     messages[0][:message].should == message
     messages[0][:line].should    == 1
@@ -76,11 +76,11 @@ THIS_CONSTANT_NAME_IS_WAY_TOO_LONG = 10
   end
 
   it 'Check for the use of class variables' do
-    tokens   = Rlint::Parser.new('@@number = 10').parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new('@@number = 10').parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     info = report.messages[:info][0]
@@ -118,11 +118,11 @@ unless ( foobar )
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     report.messages[:info].class.should  == Array
@@ -148,11 +148,11 @@ def valid_name?
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     message = 'predicate methods should end with a question mark'
@@ -171,11 +171,11 @@ end
 [].map { |a| }
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     message = 'it is recommended to use the method "map" instead of "collect"'
@@ -201,11 +201,11 @@ def String.class_method
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    report   = Rlint::Report.new
-    iterator = Rlint::Iterator.new(report)
+    tokens   = RubyLint::Parser.new(code).parse
+    report   = RubyLint::Report.new
+    iterator = RubyLint::Iterator.new(report)
 
-    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
     iterator.run(tokens)
 
     report.messages[:warning].class.should  == Array

data/spec/ruby-lint/analyze/complex/un.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Complex code analysis' do
+  it 'Analyze fixtures/stdlib/un.rb' do
+    code     = File.read(File.join(RubyLint::FIXTURES, 'stdlib/un.rb'))
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
+
+    iterator.bind(RubyLint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::CodingStyle)
+    iterator.bind(RubyLint::Analyze::MethodValidation)
+    iterator.bind(RubyLint::Analyze::ShadowingVariables)
+    iterator.bind(RubyLint::Analyze::UndefinedVariables)
+    iterator.bind(RubyLint::Analyze::UnusedVariables)
+    iterator.run(tokens)
+
+    scope   = iterator.storage[:scope]
+    methods = %w{setup cp ln mv rm mkdir rmdir install chmod
+      touch wait_writable mkmf httpd help}
+
+    scope.class.should == RubyLint::Definition
+
+    scope.lookup(:constant, 'FileUtils').class.should == RubyLint::Definition
+
+    methods.each do |method|
+      scope.lookup(:instance_method, method).class.should == RubyLint::Definition
+    end
+  end
+end

data/spec/{rlint → ruby-lint}/analyze/definitions/classes.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../helper', __FILE__)
 
-describe 'Rlint::Analyze::Definitions: classes' do
+describe 'RubyLint::Analyze::Definitions: classes' do
   it 'Define a class in the global scope' do
     code = <<-CODE
 class Example
@@ -10,18 +10,18 @@ class Example
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'Example')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
-    const.token.class.should      == Rlint::Token::ClassToken
+    const.token.class.should      == RubyLint::Token::ClassToken
     const.token.name.should       == ['Example']
     const.token.value.nil?.should == true
 
@@ -30,9 +30,9 @@ end
 
     method = const.lookup(:instance_method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -45,10 +45,10 @@ class Example
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
@@ -57,10 +57,10 @@ end
 
     const = scope.lookup(:constant, 'Example')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
     const.lookup(:instance_method, 'example_method').nil?.should == true
-    const.lookup(:method, 'example_method').class.should == Rlint::Definition
+    const.lookup(:method, 'example_method').class.should == RubyLint::Definition
   end
 
   it 'Inherit methods from a parent class' do
@@ -76,10 +76,10 @@ class B < A
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
@@ -88,27 +88,27 @@ end
     b = scope.lookup(:constant, 'B')
 
     # check class A
-    a.class.should == Rlint::Definition
+    a.class.should == RubyLint::Definition
 
-    a.token.class.should  == Rlint::Token::ClassToken
+    a.token.class.should  == RubyLint::Token::ClassToken
     a.token.name.should   == ['A']
     a.token.parent.should == ['Object']
 
-    a.lookup(:method, :methods).class.should          == Rlint::Definition
-    a.lookup(:instance_method, :methods).class.should == Rlint::Definition
+    a.lookup(:method, :methods).class.should          == RubyLint::Definition
+    a.lookup(:instance_method, :methods).class.should == RubyLint::Definition
 
     # check class B
-    b.class.should == Rlint::Definition
+    b.class.should == RubyLint::Definition
 
-    b.token.class.should  == Rlint::Token::ClassToken
+    b.token.class.should  == RubyLint::Token::ClassToken
     b.token.name.should   == ['B']
     b.token.parent.should == ['A']
 
     b.lookup(:instance_method, 'parent_method') \
       .class \
-      .should == Rlint::Definition
+      .should == RubyLint::Definition
 
-    b.lookup(:method, :methods).class.should          == Rlint::Definition
-    b.lookup(:instance_method, :methods).class.should == Rlint::Definition
+    b.lookup(:method, :methods).class.should          == RubyLint::Definition
+    b.lookup(:instance_method, :methods).class.should == RubyLint::Definition
   end
 end

data/spec/{rlint → ruby-lint}/analyze/definitions/methods.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../helper', __FILE__)
 
-describe 'Rlint::Analyze::Definitions: methods' do
+describe 'RubyLint::Analyze::Definitions: methods' do
   it 'Build a list of globally defined methods' do
     code = <<-CODE
 def example_method
@@ -12,25 +12,25 @@ def another_example_method
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
 
-    scope.class.should == Rlint::Definition
+    scope.class.should == RubyLint::Definition
 
     method_1 = scope.lookup(:instance_method, 'example_method')
     method_2 = scope.lookup(:instance_method, 'another_example_method')
 
-    method_1.class.should       == Rlint::Definition
-    method_1.token.class.should == Rlint::Token::MethodDefinitionToken
+    method_1.class.should       == RubyLint::Definition
+    method_1.token.class.should == RubyLint::Token::MethodDefinitionToken
     method_1.token.name.should  == 'example_method'
 
-    method_2.class.should       == Rlint::Definition
-    method_2.token.class.should == Rlint::Token::MethodDefinitionToken
+    method_2.class.should       == RubyLint::Definition
+    method_2.token.class.should == RubyLint::Token::MethodDefinitionToken
     method_2.token.name.should  == 'another_example_method'
   end
 
@@ -41,20 +41,20 @@ def self.example_method
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
 
-    scope.class.should == Rlint::Definition
+    scope.class.should == RubyLint::Definition
 
     method = scope.lookup(:method, 'example_method')
 
-    method.class.should       == Rlint::Definition
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.class.should       == RubyLint::Definition
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -65,27 +65,27 @@ def String.example_method
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
 
-    scope.class.should == Rlint::Definition
+    scope.class.should == RubyLint::Definition
 
     scope.lookup(:instance_method, 'example_method').nil?.should == true
     scope.lookup(:method, 'example_method').nil?.should          == true
 
     string = scope.lookup(:constant, 'String')
 
-    string.class.should == Rlint::Definition
+    string.class.should == RubyLint::Definition
 
     method = string.lookup(:method, 'example_method')
 
-    method.class.should       == Rlint::Definition
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.class.should       == RubyLint::Definition
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 end

data/spec/{rlint → ruby-lint}/analyze/definitions/modules.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../helper', __FILE__)
 
-describe 'Rlint::Analyze::Definitions: modules' do
+describe 'RubyLint::Analyze::Definitions: modules' do
   it 'Define a module in the global scope' do
     code = <<-CODE
 module Example
@@ -10,18 +10,18 @@ module Example
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'Example')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
-    const.token.class.should == Rlint::Token::Token
+    const.token.class.should == RubyLint::Token::Token
     const.token.type.should  == :module
     const.token.name.should  == ['Example']
 
@@ -29,9 +29,9 @@ end
 
     method = const.lookup(:instance_method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -44,18 +44,18 @@ module Example
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'Example')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
-    const.token.class.should == Rlint::Token::Token
+    const.token.class.should == RubyLint::Token::Token
     const.token.type.should  == :module
     const.token.name.should  == ['Example']
 
@@ -63,9 +63,9 @@ end
 
     method = const.lookup(:method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -82,24 +82,24 @@ class B
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'B')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
     const.lookup(:method, 'example_method').nil?.should == true
 
     method = const.lookup(:instance_method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -116,24 +116,24 @@ class B
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'B')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
     const.lookup(:instance_method, 'example_method').nil?.should == true
 
     method = const.lookup(:method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
@@ -152,55 +152,55 @@ class C
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
     const = scope.lookup(:constant, 'C')
 
-    const.class.should == Rlint::Definition
+    const.class.should == RubyLint::Definition
 
     const.lookup(:method, 'example_method').nil?.should == true
 
     method = const.lookup(:instance_method, 'example_method')
 
-    method.class.should == Rlint::Definition
+    method.class.should == RubyLint::Definition
 
-    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.class.should == RubyLint::Token::MethodDefinitionToken
     method.token.name.should  == 'example_method'
   end
 
   it 'Define a module in an existing module' do
     code = <<-CODE
-module Rlint
+module RubyLint
   module Derp
 
   end
 end
     CODE
 
-    tokens   = Rlint::Parser.new(code).parse
-    iterator = Rlint::Iterator.new
+    tokens   = RubyLint::Parser.new(code).parse
+    iterator = RubyLint::Iterator.new
 
-    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(RubyLint::Analyze::Definitions)
     iterator.run(tokens)
 
     scope = iterator.storage[:scope]
 
     scope.lookup(:constant, 'Derp').nil?.should == true
 
-    scope.lookup(:constant, 'Rlint').class.should == Rlint::Definition
+    scope.lookup(:constant, 'RubyLint').class.should == RubyLint::Definition
 
-    scope.lookup(:constant, 'Rlint') \
+    scope.lookup(:constant, 'RubyLint') \
       .lookup(:constant, 'Derp') \
       .class \
-      .should == Rlint::Definition
+      .should == RubyLint::Definition
 
-    rlint = scope.lookup(:constant, 'Rlint')
-    derp  = rlint.lookup(:constant, 'Derp')
+    ruby_lint = scope.lookup(:constant, 'RubyLint')
+    derp  = ruby_lint.lookup(:constant, 'Derp')
 
     derp.parent.length.should == 1
   end