ruby-lint 0.0.1a

data/spec/rlint/callback.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe 'Rlint::Callback' do
+  it 'Add an error to a report using Rlint::Callback' do
+    report   = Rlint::Report.new
+    callback = Rlint::Callback.new(report)
+
+    report.levels.each do |level|
+      report.messages[level].nil?.should == true
+
+      callback.send(level, "test #{level}", 1, 1)
+
+      report.messages[level].class.should  == Array
+      report.messages[level].length.should == 1
+
+      report.messages[level][0][:message].should == "test #{level}"
+    end
+  end
+
+  it 'Ignore errors (when disabled) when adding one using Rlint::Callback' do
+    report   = Rlint::Report.new('(rlint)', [:warning])
+    callback = Rlint::Callback.new(report)
+
+    callback.send(:error, 'test error', 1, 1)
+
+    report.messages[:error].nil?.should == true
+  end
+end

data/spec/rlint/constant_importer.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe 'Rlint::ConstantImporter' do
+  it 'Import methods from the Kernel constant' do
+    imported = Rlint::ConstantImporter.import([:Kernel])
+
+    imported.key?('Kernel').should == true
+
+    found = imported['Kernel'].lookup(:method, 'puts')
+
+    found.class.should == Rlint::Definition
+
+    found.token.class.should      == Rlint::Token::MethodDefinitionToken
+    found.token.name.should       == 'puts'
+    found.token.visibility.should == :public
+
+    found.token.parameters.class.should == Rlint::Token::ParametersToken
+
+    found.token.parameters.value.class.should  == Array
+    found.token.parameters.value.length.should == 0
+
+    found.token.parameters.rest.class.should == Rlint::Token::VariableToken
+    found.token.parameters.rest.name.should  == ''
+    found.token.parameters.rest.type.should  == :local_variable
+    found.token.parameters.rest.event.should == :local_variable
+  end
+end

data/spec/rlint/definition.rb

@@ -0,0 +1,96 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe 'Rlint::Definition' do
+  it 'Look up a symbol in a scope' do
+    scope = Rlint::Definition.new
+
+    scope.lookup(:local_variable, 'number').should == nil
+
+    scope.add(:local_variable, 'number', 10)
+
+    scope.lookup(:local_variable, 'number').should == 10
+  end
+
+  it 'Look up a symbol in a parent scope' do
+    parent = Rlint::Definition.new
+    child  = Rlint::Definition.new(parent)
+
+    parent.add(:local_variable, 'number', 10)
+    parent.add(:global_variable, '$number', 20)
+
+    parent.lookup(:local_variable, 'number').should   == 10
+    parent.lookup(:global_variable, '$number').should == 20
+
+    child.lookup(:local_variable, 'number').should   == nil
+    child.lookup(:global_variable, '$number').should == 20
+  end
+
+  it 'Create a scope with default Ruby constants and methods' do
+    scope = Rlint::Definition.new(nil, :lazy => true, :kernel => true)
+    found = scope.lookup(:constant, 'Kernel')
+
+    found.class.should == Rlint::Definition
+
+    method = found.lookup(:method, 'warn')
+
+    method.class.should == Rlint::Definition
+
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'warn'
+
+    method.token.parameters.value.class.should  == Array
+    method.token.parameters.value.length.should == 1
+
+    param = method.token.parameters.value[0]
+
+    param.class.should == Rlint::Token::VariableToken
+    param.name.should  == ''
+    param.type.should  == :local_variable
+  end
+
+  it 'Lazy import the Time class' do
+    scope = Rlint::Definition.new
+
+    scope.lookup(:constant, 'Time').nil?.should == true
+
+    scope = Rlint::Definition.new(nil, :lazy => true)
+
+    scope.lookup(:constant, 'Time').class.should == Rlint::Definition
+  end
+
+  it 'Lazy import the Encoding class and a child constant' do
+    scope = Rlint::Definition.new(nil, :lazy => true)
+    enc   = scope.lookup(:constant, 'Encoding')
+
+    enc.class.should == Rlint::Definition
+
+    enc.lookup(:constant, 'BINARY').class.should == Rlint::Definition
+  end
+
+  it 'Lazy import Rlint::Definition' do
+    scope = Rlint::Definition.new(nil, :lazy => true)
+
+    rlint = scope.lookup(:constant, 'Rlint')
+
+    rlint.class.should == Rlint::Definition
+
+    rlint_scope = rlint.lookup(:constant, 'Definition')
+
+    rlint_scope.class.should == Rlint::Definition
+
+    rlint_scope.lookup(:constant, 'LOOKUP_PARENT').class.should == Rlint::Definition
+  end
+
+  it 'Create a scope with multiple parent scopes' do
+    scope_1 = Rlint::Definition.new
+    scope_2 = Rlint::Definition.new
+
+    scope_1.add(:method, 'method_1', true)
+    scope_2.add(:method, 'method_2', true)
+
+    scope_3 = Rlint::Definition.new([scope_1, scope_2])
+
+    scope_3.lookup(:method, 'method_1').should == true
+    scope_3.lookup(:method, 'method_2').should == true
+  end
+end

data/spec/rlint/formatter/text.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Rlint::Formatter::Text' do
+  it 'Format a report in plain text' do
+    report_a  = Rlint::Report.new('a.rb')
+    report_b  = Rlint::Report.new('b.rb')
+    formatter = Rlint::Formatter::Text.new
+
+    report_a.add(:info, 'test info', 2, 1)
+
+    report_b.add(:error, 'test error', 1, 1)
+    report_b.add(:info, 'test info b.rb', 3, 1)
+
+    output_a = 'a.rb: info: line 2, column 1: test info'
+    output_b = "b.rb: error: line 1, column 1: test error\n" \
+      'b.rb: info: line 3, column 1: test info b.rb'
+
+    formatter.format(report_a).should == output_a
+    formatter.format(report_b).should == output_b
+  end
+end

data/spec/rlint/iterator.rb

@@ -0,0 +1,452 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe 'Rlint::Iterator' do
+  it 'Iterate over a simple AST' do
+    code = <<-CODE
+number = 10
+number
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :assigned
+      attr_reader :referenced
+
+      def on_assignment(token)
+        @assigned = true
+      end
+
+      def on_local_variable(token)
+        @referenced = true
+      end
+    end
+
+    iterator.bind(callback)
+
+    iterator.run(tokens)
+
+    iterator.callbacks[0].assigned.should   == true
+    iterator.callbacks[0].referenced.should == true
+  end
+
+  it 'Iterate over a multi dimensional AST' do
+    code = <<-CODE
+class Foo
+  def initialize
+    @number = 10
+  end
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :class_name
+      attr_reader :method_name
+      attr_reader :assigned
+
+      def on_class(token)
+        @class_name = token.name[0]
+      end
+
+      def on_method_definition(token)
+        @method_name = token.name
+      end
+
+      def on_assignment(token)
+        @assigned = true
+      end
+    end
+
+    iterator.bind(callback)
+
+    iterator.run(tokens)
+
+    iterator.callbacks[0].class_name.should  == 'Foo'
+    iterator.callbacks[0].method_name.should == 'initialize'
+    iterator.callbacks[0].assigned.should    == true
+  end
+
+  it 'Call an event after iterating over a node' do
+    code = <<-CODE
+def some_method
+  return 10
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :before
+      attr_reader :after
+
+      def on_method_definition(token)
+        @before = token.name
+      end
+
+      def after_method_definition(token)
+        @after = token.name
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    iterator.callbacks[0].before.should == 'some_method'
+    iterator.callbacks[0].after.should  == 'some_method'
+  end
+
+  it 'Iterate over a begin/rescue statement' do
+    code = <<-CODE
+begin
+  raise
+rescue RuntimeError => e
+  puts 'runtime error!'
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :method_names
+      attr_reader :exception
+      attr_reader :exception_var
+
+      def initialize(*args)
+        super
+
+        @method_names = []
+      end
+
+      def on_method(token)
+        @method_names << token.name
+      end
+
+      def on_constant(token)
+        @exception = token.name
+      end
+
+      def on_identifier(token)
+        @exception_var = token.name
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.method_names.should  == ['raise', 'puts']
+    obj.exception.should     == 'RuntimeError'
+    obj.exception_var.should == 'e'
+  end
+
+  it 'Iterate over an if statement' do
+    code = <<-CODE
+a, b, c, d, e, f = [1, 2, 3, 4, 5, 6]
+
+if a == b
+  first
+elsif c == d
+  second
+elsif e == f
+  third
+else
+  fourth
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :variables
+      attr_reader :methods
+
+      def initialize(*args)
+        super
+
+        @variables = []
+        @methods   = []
+      end
+
+      def on_local_variable(token)
+        @variables << token.name
+      end
+
+      def on_method(token)
+        @methods << token.name
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.variables.should == %w{a b c d e f}
+    obj.methods.should   == %w{first second third fourth}
+  end
+
+  it 'Iterate over a case statement' do
+    code = <<-CODE
+case number
+when 10
+  first
+when 20
+  second
+when 30
+  third
+else
+  fourth
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :methods
+      attr_reader :numbers
+
+      def initialize(*args)
+        super
+
+        @methods = []
+        @numbers = []
+      end
+
+      def on_method(token)
+        @methods << token.name
+      end
+
+      def on_integer(token)
+        @numbers << token.value
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.numbers.should == %w{10 20 30}
+    obj.methods.should == %w{number first second third fourth}
+  end
+
+  it 'Iterate over a for loop' do
+    code = <<-CODE
+for key, value in {:name => 'Ruby'}
+  puts key
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :symbol
+      attr_reader :string
+      attr_reader :names
+
+      def initialize(*args)
+        super
+
+        @names = []
+      end
+
+      def on_local_variable(token)
+        @names << token.name
+      end
+
+      def on_identifier(token)
+        @names << token.name
+      end
+
+      def on_symbol(token)
+        @symbol = token.name
+      end
+
+      def on_string(token)
+        @string = token.value
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.symbol.should == 'name'
+    obj.string.should == 'Ruby'
+    obj.names.should  == %w{key value key}
+  end
+
+  it 'Iterate over a while statement' do
+    code = <<-CODE
+while foo == 10
+  puts 20
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :numbers
+      attr_reader :methods
+
+      def initialize(*args)
+        super
+
+        @numbers = []
+        @methods = []
+      end
+
+      def on_identifier(token)
+        @methods << token.name
+      end
+
+      def on_method(token)
+        @methods << token.name
+      end
+
+      def on_integer(token)
+        @numbers << token.value
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.methods.should == %w{foo puts}
+    obj.numbers.should == %w{10 20}
+  end
+
+  it 'Iterate over a method definition' do
+    code = <<-CODE
+def foobar(required, optional = 10, *rest, more, &block)
+  return 20
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :variables
+      attr_reader :numbers
+
+      def initialize(*args)
+        super
+
+        @variables = []
+        @numbers   = []
+      end
+
+      def on_local_variable(token)
+        @variables << token.name
+      end
+
+      def on_integer(token)
+        @numbers << token.value
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.numbers.should   == %w{10 20}
+    obj.variables.should == %w{required optional rest more block}
+  end
+
+  it 'Iterate over a method call' do
+    tokens   = Rlint::Parser.new('puts "Foo", "Bar"').parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :params
+
+      def initialize(*args)
+        @params = []
+      end
+
+      def on_string(token)
+        @params << token.value
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    obj = iterator.callbacks[0]
+
+    obj.params.should == %w{Foo Bar}
+  end
+
+  it 'Call an event before and after iterating over all nodes' do
+    code = <<-CODE
+class Person
+  def initialize
+    @name = 'Matz'
+  end
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+    callback = Class.new(Rlint::Callback) do
+      attr_reader :start
+      attr_reader :finish
+
+      def initialize(*args)
+        super
+
+        @start  = 0
+        @finish = 0
+      end
+
+      def on_start
+        @start += 1
+      end
+
+      def on_finish
+        @finish += 1
+      end
+    end
+
+    iterator.bind(callback)
+    iterator.run(tokens)
+
+    iterator.callbacks[0].start.should  == 1
+    iterator.callbacks[0].finish.should == 1
+  end
+
+  it 'Share data between callback classes' do
+    code = <<-CODE
+def example_method
+  return 10
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    iterator = Rlint::Iterator.new
+
+    setter = Class.new(Rlint::Callback) do
+      def on_method_definition(token)
+        @storage[:method_name] = token.name
+      end
+    end
+
+    getter = Class.new(Rlint::Callback) do
+      attr_reader :storage
+    end
+
+    iterator.bind(setter)
+    iterator.bind(getter)
+    iterator.run(tokens)
+
+    iterator.callbacks[1].storage.class.should         == Hash
+    iterator.callbacks[1].storage[:method_name].should == 'example_method'
+  end
+end