ruby-lint 0.0.1a

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

@@ -0,0 +1,207 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::Definitions: modules' do
+  it 'Define a module in the global scope' do
+    code = <<-CODE
+module 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::Token
+    const.token.type.should  == :module
+    const.token.name.should  == ['Example']
+
+    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 in a module' do
+    code = <<-CODE
+module 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]
+    const = scope.lookup(:constant, 'Example')
+
+    const.class.should == Rlint::Definition
+
+    const.token.class.should == Rlint::Token::Token
+    const.token.type.should  == :module
+    const.token.name.should  == ['Example']
+
+    scope.lookup(:method, 'example_method').nil?.should == true
+
+    method = const.lookup(:method, 'example_method')
+
+    method.class.should == Rlint::Definition
+
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'example_method'
+  end
+
+  it 'Include a module into a class' do
+    code = <<-CODE
+module A
+  def example_method
+
+  end
+end
+
+class B
+  include 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]
+    const = scope.lookup(:constant, 'B')
+
+    const.class.should == Rlint::Definition
+
+    const.lookup(: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 'Extend a class using a module' do
+    code = <<-CODE
+module A
+  def example_method
+
+  end
+end
+
+class B
+  extend 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]
+    const = scope.lookup(:constant, 'B')
+
+    const.class.should == Rlint::Definition
+
+    const.lookup(:instance_method, 'example_method').nil?.should == true
+
+    method = const.lookup(:method, 'example_method')
+
+    method.class.should == Rlint::Definition
+
+    method.token.class.should == Rlint::Token::MethodDefinitionToken
+    method.token.name.should  == 'example_method'
+  end
+
+  it 'Include a module using a constant path' do
+    code = <<-CODE
+module A
+  module B
+    def example_method
+
+    end
+  end
+end
+
+class C
+  include A::B
+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, 'C')
+
+    const.class.should == Rlint::Definition
+
+    const.lookup(: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 module in an existing module' do
+    code = <<-CODE
+module Rlint
+  module Derp
+
+  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(:constant, 'Derp').nil?.should == true
+
+    scope.lookup(:constant, 'Rlint').class.should == Rlint::Definition
+
+    scope.lookup(:constant, 'Rlint') \
+      .lookup(:constant, 'Derp') \
+      .class \
+      .should == Rlint::Definition
+
+    rlint = scope.lookup(:constant, 'Rlint')
+    derp  = rlint.lookup(:constant, 'Derp')
+
+    derp.parent.length.should == 1
+  end
+end

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

@@ -0,0 +1,103 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::Definitions: variables' do
+  it 'Build a list of variables defined in the global scope' do
+    code = <<-CODE
+number   = 10
+@number  = 10
+@@number = 10
+$number  = 10
+NUMBER   = 10
+    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
+
+    lvar  = scope.lookup(:local_variable, 'number')
+    ivar  = scope.lookup(:instance_variable, '@number')
+    cvar  = scope.lookup(:class_variable, '@@number')
+    gvar  = scope.lookup(:global_variable, '$number')
+    const = scope.lookup(:constant, 'NUMBER')
+
+    lvar.class.should             == Rlint::Definition
+    lvar.token.class.should       == Rlint::Token::AssignmentToken
+    lvar.token.name.should        == 'number'
+    lvar.token.type.should        == :local_variable
+    lvar.token.value.class.should == Rlint::Token::Token
+    lvar.token.value.type.should  == :integer
+    lvar.token.value.value.should == '10'
+
+    ivar.class.should             == Rlint::Definition
+    ivar.token.class.should       == Rlint::Token::AssignmentToken
+    ivar.token.name.should        == '@number'
+    ivar.token.type.should        == :instance_variable
+    ivar.token.value.class.should == Rlint::Token::Token
+    ivar.token.value.type.should  == :integer
+    ivar.token.value.value.should == '10'
+
+    cvar.class.should             == Rlint::Definition
+    cvar.token.class.should       == Rlint::Token::AssignmentToken
+    cvar.token.name.should        == '@@number'
+    cvar.token.type.should        == :class_variable
+    cvar.token.value.class.should == Rlint::Token::Token
+    cvar.token.value.type.should  == :integer
+    cvar.token.value.value.should == '10'
+
+    gvar.class.should             == Rlint::Definition
+    gvar.token.class.should       == Rlint::Token::AssignmentToken
+    gvar.token.name.should        == '$number'
+    gvar.token.type.should        == :global_variable
+    gvar.token.value.class.should == Rlint::Token::Token
+    gvar.token.value.type.should  == :integer
+    gvar.token.value.value.should == '10'
+
+    const.class.should             == Rlint::Definition
+    const.token.class.should       == Rlint::Token::AssignmentToken
+    const.token.name.should        == 'NUMBER'
+    const.token.type.should        == :constant
+    const.token.value.class.should == Rlint::Token::Token
+    const.token.value.type.should  == :integer
+    const.token.value.value.should == '10'
+  end
+
+  it 'Build a list of variables defined inside a method' do
+    code = <<-CODE
+def example_method
+  number = 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.lookup(:local_variable, 'number').nil?.should == true
+
+    method = scope.lookup(:instance_method, 'example_method')
+
+    method.class.should == Rlint::Definition
+
+    method.token.class.should      == Rlint::Token::MethodDefinitionToken
+    method.token.name.should       == 'example_method'
+    method.token.value.nil?.should == true
+
+    variable = method.lookup(:local_variable, 'number')
+
+    variable.class.should             == Rlint::Definition
+    variable.token.name.should        == 'number'
+    variable.token.value.class.should == Rlint::Token::Token
+    variable.token.value.type.should  == :integer
+    variable.token.value.value.should == '10'
+  end
+end

data/spec/rlint/analyze/method_validation.rb

@@ -0,0 +1,177 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Rlint::Analyze::MethodValidation' do
+  it 'Calling undefined methods' do
+    code = <<-CODE
+def defined_method; end
+
+undefined_method
+defined_method
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(Rlint::Analyze::MethodValidation)
+    iterator.bind(Rlint::Analyze::UndefinedVariables)
+    iterator.run(tokens)
+
+    report.messages[:error].class.should  == Array
+    report.messages[:error].length.should == 1
+
+    error = report.messages[:error][0]
+
+    error[:message].should == 'undefined local variable or method ' \
+      'undefined_method'
+
+    error[:line].should   == 3
+    error[:column].should == 0
+  end
+
+  it 'Calling non existing methods on constants' do
+    code = <<-CODE
+String.new
+String.newx
+Foobar.new
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(Rlint::Analyze::MethodValidation)
+    iterator.bind(Rlint::Analyze::UndefinedVariables)
+    iterator.run(tokens)
+
+    report.messages[:error].class.should  == Array
+    report.messages[:error].length.should == 2
+
+    errors = report.messages[:error]
+
+    errors[0][:message].should == 'undefined class method newx'
+    errors[0][:line].should    == 2
+    errors[0][:column].should  == 7
+
+    errors[1][:message].should == 'undefined constant Foobar'
+    errors[1][:line].should    == 3
+    errors[1][:column].should  == 0
+  end
+
+  it 'Calling non existing methods on variables and values directly' do
+    code = <<-CODE
+name = 'Ruby'
+
+name.upcase
+name.upcasexx
+foo.upcase
+
+''.downcase
+''.downcasex
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(Rlint::Analyze::MethodValidation)
+    iterator.bind(Rlint::Analyze::UndefinedVariables)
+    iterator.run(tokens)
+
+    report.messages[:error].class.should  == Array
+    report.messages[:error].length.should == 3
+
+    errors = report.messages[:error]
+
+    errors[0][:message].should == 'undefined instance method upcasexx'
+    errors[0][:line].should    == 4
+    errors[0][:column].should  == 5
+
+    errors[1][:message].should == 'undefined instance method downcasex'
+    errors[1][:line].should    == 8
+    errors[1][:column].should  == 3
+
+    errors[2][:message].should == 'undefined local variable or method foo'
+    errors[2][:line].should    == 5
+    errors[2][:column].should  == 0
+  end
+
+  it 'Method parameters should be added as local variables' do
+    code = <<-CODE
+def uppercase(name = 'Ruby', *args, &block)
+  name.upcase
+  namex.upcase
+  args.flatten
+  block.call
+end
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(Rlint::Analyze::MethodValidation)
+    iterator.bind(Rlint::Analyze::UndefinedVariables)
+    iterator.run(tokens)
+
+    report.messages[:error].class.should  == Array
+    report.messages[:error].length.should == 1
+
+    error = report.messages[:error][0]
+
+    error[:message].should == 'undefined local variable or method namex'
+    error[:line].should    == 3
+    error[:column].should  == 2
+  end
+
+  it 'Calling methods on a constant path' do
+    code = <<-CODE
+A::B.invalid_method
+
+module A; end
+
+A::B.invalid_method
+
+module A
+  module B
+    def self.valid_method
+
+    end
+  end
+end
+
+A::B.invalid_method
+A::B.valid_method
+    CODE
+
+    tokens   = Rlint::Parser.new(code).parse
+    report   = Rlint::Report.new
+    iterator = Rlint::Iterator.new(report)
+
+    iterator.bind(Rlint::Analyze::Definitions)
+    iterator.bind(Rlint::Analyze::UndefinedVariables)
+    iterator.bind(Rlint::Analyze::MethodValidation)
+    iterator.run(tokens)
+
+    report.messages[:error].class.should  == Array
+    report.messages[:error].length.should == 3
+
+    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    == 5
+    errors[1][:column].should  == 0
+
+    errors[2][:message].should == 'undefined class method invalid_method'
+    errors[2][:line].should    == 15
+    errors[2][:column].should  == 5
+  end
+end