ruby-lint 0.0.1a

data/spec/benchmarks/parse_parser.rb

@@ -0,0 +1,16 @@
+# This file runs a simple benchmark to see how fast (or slow) Rlint is.
+# It benchmarks how long it takes to parse the main parser file
+# (lib/rlint/parser.rb) itself.
+require File.expand_path('../../../lib/rlint', __FILE__)
+require 'benchmark'
+
+code   = File.read(File.expand_path('../../../lib/rlint/parser.rb', __FILE__))
+amount = ENV['AMOUNT'] ? ENV['AMOUNT'].to_i : 100
+
+Benchmark.bmbm(40) do |bench|
+  bench.report "Parse parser.rb #{amount} times" do
+    amount.times do
+      Rlint::Parser.new(code).parse
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../../lib/rlint', __FILE__)
+require 'bacon'
+
+Bacon.summary_on_exit

data/spec/rlint/analyze/coding_style.rb

@@ -0,0 +1,224 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::CodingStyle' do
+  it 'Check the casing of method names and variables' do
+    code = <<-CODE
+def getNumber(theNumber = 10)
+  valid_number = theNumber
+
+  return theNumber
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    messages = report.messages[:info]
+    message  = 'the use of camelCase for names is discouraged'
+
+    messages.class.should  == Array
+    messages.length.should == 4
+
+    messages[0][:message].should == message
+    messages[0][:line].should    == 1
+    messages[0][:column].should  == 4
+
+    messages[1][:message].should == message
+    messages[1][:line].should    == 1
+    messages[1][:column].should  == 14
+
+    messages[2][:message].should == message
+    messages[2][:line].should    == 2
+    messages[2][:column].should  == 17
+
+    messages[3][:message].should == message
+    messages[3][:line].should    == 4
+    messages[3][:column].should  == 9
+  end
+
+  it 'Check the length of method and variable names' do
+    code = <<-CODE
+def this_method_name_is_rather_long_dont_you_think
+  this_variable_name_is_also_rather_long = 10
+end
+
+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)
+
+    iterator.bind(Rlint::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"
+
+    messages[0][:message].should == message
+    messages[0][:line].should    == 1
+    messages[0][:column].should  == 4
+
+    messages[1][:message].should == message
+    messages[1][:line].should    == 2
+    messages[1][:column].should  == 2
+
+    messages[2][:message].should == message
+    messages[2][:line].should    == 7
+    messages[2][:column].should  == 0
+  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)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    info = report.messages[:info][0]
+
+    info[:message].should == 'the use of class variables is discouraged'
+    info[:line].should    == 1
+    info[:column].should  == 0
+  end
+
+  it 'Check for the use of parenthesis in various statements' do
+    code = <<-CODE
+if ( name == 'Ruby' )
+  puts 'This is some weird code'
+elsif ( name == 'Python')
+  puts 10
+end
+
+while ( true )
+  puts 'Infinite loop'
+end
+
+case ( number )
+when ( 10 )
+  puts 'The number is 10'
+else
+  puts 'Something else'
+end
+
+until ( number == 10 )
+  number += 1
+end
+
+unless ( foobar )
+  something
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    report.messages[:info].class.should  == Array
+    report.messages[:info].length.should == 7
+
+    message = 'the use of parenthesis for statements is discouraged'
+
+    [1, 3, 7, 11, 12, 18, 22].each_with_index do |line, index|
+      report.messages[:info][index][:message].should == message
+      report.messages[:info][index][:line].should    == line
+      report.messages[:info][index][:column].should  == 0
+    end
+  end
+
+  it 'Check for correct names for predicate methods' do
+    code = <<-CODE
+def invalid_name
+  return true
+end
+
+def valid_name?
+  return true
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    message = 'predicate methods should end with a question mark'
+
+    report.messages[:info].class.should  == Array
+    report.messages[:info].length.should == 1
+
+    report.messages[:info][0][:message].should == message
+    report.messages[:info][0][:line].should    == 1
+    report.messages[:info][0][:column].should  == 4
+  end
+
+  it 'Check for recommending alternative method names' do
+    code = <<-CODE
+[].collect { |a| }
+[].map { |a| }
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    message = 'it is recommended to use the method "map" instead of "collect"'
+
+    report.messages[:info].class.should  == Array
+    report.messages[:info].length.should == 1
+
+    report.messages[:info][0][:message].should == message
+    report.messages[:info][0][:line].should    == 1
+    report.messages[:info][0][:column].should  == 3
+  end
+
+  it 'Add warnings when modifying core Ruby constants' do
+    code = <<-CODE
+class String
+  def custom_method
+
+  end
+end
+
+def String.class_method
+
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::CodingStyle)
+    iterator.run(tokens)
+
+    report.messages[:warning].class.should  == Array
+    report.messages[:warning].length.should == 2
+
+    warnings = report.messages[:warning]
+
+    warnings[0][:message].should == 'modification of a core Ruby constant'
+    warnings[0][:line].should    == 1
+    warnings[0][:column].should  == 6
+
+    warnings[1][:message].should == 'modification of a core Ruby constant'
+    warnings[1][:line].should    == 7
+    warnings[1][:column].should  == 4
+  end
+end

data/spec/rlint/analyze/definitions/classes.rb

@@ -0,0 +1,114 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::Definitions: classes' do
+  it 'Define a class in the global scope' do
+    code = <<-CODE
+class Example
+  def example_method
+
+  end
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+    const = scope.lookup(:constant, 'Example')
+
+    const.class.should == Rlint::Definition
+
+    const.token.class.should      == Rlint::Token::ClassToken
+    const.token.name.should       == ['Example']
+    const.token.value.nil?.should == true
+
+    # Check the method that was defined inside the class.
+    scope.lookup(:instance_method, 'example_method').nil?.should == true
+
+    method = const.lookup(:instance_method, 'example_method')
+
+    method.class.should == Rlint::Definition
+
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'example_method'
+  end
+
+  it 'Define a class method inside a class' do
+    code = <<-CODE
+class Example
+  def self.example_method
+
+  end
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+
+    scope.lookup(:method, 'example_method').nil?.should == true
+
+    const = scope.lookup(:constant, 'Example')
+
+    const.class.should == Rlint::Definition
+
+    const.lookup(:instance_method, 'example_method').nil?.should == true
+    const.lookup(:method, 'example_method').class.should == Rlint::Definition
+  end
+
+  it 'Inherit methods from a parent class' do
+    code = <<-CODE
+class A
+  def parent_method
+
+  end
+end
+
+class B < A
+
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+
+    a = scope.lookup(:constant, 'A')
+    b = scope.lookup(:constant, 'B')
+
+    # check class A
+    a.class.should == Rlint::Definition
+
+    a.token.class.should  == Rlint::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
+
+    # check class B
+    b.class.should == Rlint::Definition
+
+    b.token.class.should  == Rlint::Token::ClassToken
+    b.token.name.should   == ['B']
+    b.token.parent.should == ['A']
+
+    b.lookup(:instance_method, 'parent_method') \
+      .class \
+      .should == Rlint::Definition
+
+    b.lookup(:method, :methods).class.should          == Rlint::Definition
+    b.lookup(:instance_method, :methods).class.should == Rlint::Definition
+  end
+end

data/spec/rlint/analyze/definitions/methods.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::Definitions: methods' do
+  it 'Build a list of globally defined methods' do
+    code = <<-CODE
+def example_method
+  return 10
+end
+
+def another_example_method
+  return 20
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+
+    scope.class.should == Rlint::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.token.name.should  == 'example_method'
+
+    method_2.class.should       == Rlint::Definition
+    method_2.token.class.should == Rlint::Token::MethodDefinitionToken
+    method_2.token.name.should  == 'another_example_method'
+  end
+
+  it 'Build a list of globally defined class methods' do
+    code = <<-CODE
+def self.example_method
+  return 10
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+
+    scope.class.should == Rlint::Definition
+
+    method = scope.lookup(:method, 'example_method')
+
+    method.class.should       == Rlint::Definition
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'example_method'
+  end
+
+  it 'Define a class method on the String class' do
+    code = <<-CODE
+def String.example_method
+  return 10
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.run(tokens)
+
+    scope = iterator.storage[:scope]
+
+    scope.class.should == Rlint::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
+
+    method = string.lookup(:method, 'example_method')
+
+    method.class.should       == Rlint::Definition
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'example_method'
+  end
+end