ruby-lint 0.0.2 → 0.0.3

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

@@ -1,225 +1,105 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Analyze::UnusedVariables' do
-  it 'Add warnings for unused variables in the global scope' do
-    code = <<-CODE
-number   = 10
-@number  = 10
-@@number = 10
-$number  = 10
-
-number_2   = 10
-@number_2  = 10
-@@number_2 = 10
-$number_2  = 10
-
-puts number_2
-puts @number_2
-puts @@number_2
-puts $number_2
-    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::UnusedVariables)
-    iterator.run(tokens)
+describe RubyLint::Analyze::UnusedVariables do
+  should 'warn for unused local variables' do
+    report = build_report('number = 1', RubyLint::Analyze::UnusedVariables)
+    entry  = report.entries[0]
 
-    report.messages[:warning].class.should  == Array
-    report.messages[:warning].length.should == 4
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    warnings = report.messages[:warning]
-
-    warnings[0][:message].should == 'assigned but unused local variable number'
-    warnings[0][:line].should    == 1
-    warnings[0][:column].should  == 0
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'unused local variable number'
+  end
 
-    warnings[1][:message].should == 'assigned but unused instance ' \
-      'variable @number'
+  should 'warn for unused global variables' do
+    report = build_report('$number = 1', RubyLint::Analyze::UnusedVariables)
+    entry  = report.entries[0]
 
-    warnings[1][:line].should    == 2
-    warnings[1][:column].should  == 0
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    warnings[2][:message].should == 'assigned but unused class ' \
-      'variable @@number'
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'unused global variable $number'
+  end
 
-    warnings[2][:line].should    == 3
-    warnings[2][:column].should  == 0
+  should 'warn for unused constants' do
+    report = build_report('NUMBER = 10', RubyLint::Analyze::UnusedVariables)
+    entry  = report.entries[0]
 
-    warnings[3][:message].should == 'assigned but unused global ' \
-      'variable $number'
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    warnings[3][:line].should    == 4
-    warnings[3][:column].should  == 0
+    entry.line.should    == 1
+    entry.column.should  == 0
+    entry.message.should == 'unused constant NUMBER'
   end
 
-  it 'Add warnings for unused variables in a method definition scope' do
+  should 'warn for unused constant paths' do
     code = <<-CODE
-def example
-  number   = 10
-  @number  = 10
-  @@number = 10
-  $number  = 10
-
-  number_2   = 10
-  @number_2  = 10
-  @@number_2 = 10
-  $number_2  = 10
-
-  puts number_2
-  puts @number_2
-  puts @@number_2
-  puts $number_2
+module A
 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::UnusedVariables)
-    iterator.run(tokens)
-
-    report.messages[:warning].class.should  == Array
-    report.messages[:warning].length.should == 4
-
-    warnings = report.messages[:warning]
-
-    warnings[0][:message].should == 'assigned but unused local variable number'
-    warnings[0][:line].should    == 2
-    warnings[0][:column].should  == 2
-
-    warnings[1][:message].should == 'assigned but unused instance ' \
-      'variable @number'
+A::B = 10
+    CODE
 
-    warnings[1][:line].should    == 3
-    warnings[1][:column].should  == 2
+    report = build_report(code, RubyLint::Analyze::UnusedVariables)
 
-    warnings[2][:message].should == 'assigned but unused class ' \
-      'variable @@number'
+    report.entries.length.should == 1
 
-    warnings[2][:line].should    == 4
-    warnings[2][:column].should  == 2
+    entry = report.entries[0]
 
-    warnings[3][:message].should == 'assigned but unused global ' \
-      'variable $number'
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    warnings[3][:line].should    == 5
-    warnings[3][:column].should  == 2
+    entry.line.should    == 4
+    entry.column.should  == 3
+    entry.message.should == 'unused constant B'
   end
 
-  it 'Add warnings for unused variables in a class definition scope' do
+  should 'warn for unused variables in a method scope' do
     code = <<-CODE
-class Example
-  number   = 10
-  @number  = 10
-  @@number = 10
-  $number  = 10
-
-  number_2   = 10
-  @number_2  = 10
-  @@number_2 = 10
-  $number_2  = 10
-
-  puts number_2
-  puts @number_2
-  puts @@number_2
-  puts $number_2
+def some_method
+  number = 10
 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::UnusedVariables)
-    iterator.run(tokens)
-
-    report.messages[:warning].class.should  == Array
-    report.messages[:warning].length.should == 4
+    report = build_report(code, RubyLint::Analyze::UnusedVariables)
+    entry  = report.entries[0]
 
-    warnings = report.messages[:warning]
+    entry.is_a?(RubyLint::Report::Entry).should == true
 
-    warnings[0][:message].should == 'assigned but unused local variable number'
-    warnings[0][:line].should    == 2
-    warnings[0][:column].should  == 2
-
-    warnings[1][:message].should == 'assigned but unused instance ' \
-      'variable @number'
-
-    warnings[1][:line].should    == 3
-    warnings[1][:column].should  == 2
-
-    warnings[2][:message].should == 'assigned but unused class ' \
-      'variable @@number'
-
-    warnings[2][:line].should    == 4
-    warnings[2][:column].should  == 2
-
-    warnings[3][:message].should == 'assigned but unused global ' \
-      'variable $number'
-
-    warnings[3][:line].should    == 5
-    warnings[3][:column].should  == 2
+    entry.line.should    == 2
+    entry.column.should  == 2
+    entry.message.should == 'unused local variable number'
   end
 
-  it 'Add warnings for unused variables in a module definition scope' do
+  should 'not add a warning when assigning a variable to another variable' do
     code = <<-CODE
-module Example
-  number   = 10
-  @number  = 10
-  @@number = 10
-  $number  = 10
-
-  number_2   = 10
-  @number_2  = 10
-  @@number_2 = 10
-  $number_2  = 10
-
-  puts number_2
-  puts @number_2
-  puts @@number_2
-  puts $number_2
-end
+first  = 10
+second = first
     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::UnusedVariables)
-    iterator.run(tokens)
+    report = build_report(code, RubyLint::Analyze::UnusedVariables)
 
-    report.messages[:warning].class.should  == Array
-    report.messages[:warning].length.should == 4
+    report.entries.length.should == 1
 
-    warnings = report.messages[:warning]
+    entry = report.entries[0]
 
-    warnings[0][:message].should == 'assigned but unused local variable number'
-    warnings[0][:line].should    == 2
-    warnings[0][:column].should  == 2
-
-    warnings[1][:message].should == 'assigned but unused instance ' \
-      'variable @number'
-
-    warnings[1][:line].should    == 3
-    warnings[1][:column].should  == 2
+    entry.line.should    == 2
+    entry.column.should  == 0
+    entry.message.should == 'unused local variable second'
+  end
 
-    warnings[2][:message].should == 'assigned but unused class ' \
-      'variable @@number'
+  should 'not add warnings when defining classes and modules' do
+    code = <<-CODE
+module A
+end
 
-    warnings[2][:line].should    == 4
-    warnings[2][:column].should  == 2
+class B
+end
+    CODE
 
-    warnings[3][:message].should == 'assigned but unused global ' \
-      'variable $number'
+    report = build_report(code, RubyLint::Analyze::UnusedVariables)
 
-    warnings[3][:line].should    == 5
-    warnings[3][:column].should  == 2
+    report.entries.empty?.should == true
   end
 end

data/spec/ruby-lint/configuration.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe RubyLint::Configuration do
+  should 'set a option using the constructor method' do
+    config = RubyLint::Configuration.new(:report_levels => [:test])
+
+    config.report_levels.should == [:test]
+  end
+
+  should 'set a default value for options' do
+    config = RubyLint::Configuration.new
+
+    config.report_levels.should == RubyLint::Report::DEFAULT_LEVELS
+  end
+end

data/spec/ruby-lint/constant_loader.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe RubyLint::ConstantLoader do
+  after do
+    RubyLint.global_scope.definitions[:constant].delete('ERB')
+  end
+
+  should 'lazy load using a constant' do
+    constant = 'ERB'
+    ast      = parse(constant)
+    iterator = RubyLint::ConstantLoader.new
+
+    RubyLint.global_scope.lookup(:constant, constant).nil?.should == true
+
+    iterator.iterate(ast)
+
+    RubyLint.global_scope.lookup(:constant, constant).nil?.should == false
+  end
+
+  should 'lazy load using a constant path' do
+    constant = 'Enumerable'
+    ast      = parse('Enumerable::Enumerator')
+    iterator = RubyLint::ConstantLoader.new
+
+    RubyLint.global_scope.lookup(:constant, constant).nil?.should == true
+
+    iterator.iterate(ast)
+
+    RubyLint.global_scope.lookup(:constant, constant).nil?.should     == false
+    RubyLint.global_scope.lookup(:constant, 'Enumerator').nil?.should == true
+  end
+end

data/spec/ruby-lint/definition/dsl.rb

@@ -0,0 +1,142 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::Definition::RubyObject do
+  before do
+    @first = ruby_object.new(:name => 'First', :type => :constant)
+  end
+
+  describe 'definining constants using a DSL' do
+    should 'define a constant' do
+      @first.define_constant('B')
+
+      @first.lookup(:constant, 'B').is_a?(ruby_object).should == true
+    end
+
+    should 'define a constant using a block' do
+      @first.define_constant('B') do |b|
+        b.define_constant('C')
+      end
+
+      @first.lookup(:constant, 'B') \
+        .lookup(:constant, 'C') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'inherit from another object' do
+      @first.define_constant('B') do |b|
+        b.define_constant('C')
+      end
+
+      @first.define_constant('D') do |d|
+        d.inherits(@first.lookup(:constant, 'B'))
+      end
+
+      @first.lookup(:constant, 'D') \
+        .lookup(:constant, 'C') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'define a constant using a constant path' do
+      @first.define_constant('A')
+      @first.define_constant('A::B')
+
+      @first.lookup(:constant, 'A') \
+        .lookup(:constant, 'B') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+
+  describe 'defining methods using a DSL' do
+    should 'define a method' do
+      @first.define_method('example')
+
+      @first.lookup(:method, 'example').is_a?(ruby_method).should == true
+    end
+
+    should 'define an instance method' do
+      @first.define_instance_method('example')
+
+      @first.lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'define a method\'s return value' do
+      string = ruby_object.new(:type => :string, :value => 'hello')
+
+      @first.define_method('example') do |example|
+        example.returns(string)
+      end
+
+      @first.lookup(:method, 'example') \
+        .return_value \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'add a required argument' do
+      arg = method_with_argument(@first, :argument).arguments.first
+
+      arg.is_a?(ruby_object).should == true
+      arg.name.should                == 'number'
+    end
+
+    should 'add a optional argument' do
+      arg = method_with_argument(@first, :optional_argument) \
+        .optional_arguments \
+        .first
+
+      arg.is_a?(ruby_object).should == true
+      arg.name.should                == 'number'
+    end
+
+    should 'add a rest argument' do
+      arg = method_with_argument(@first, :rest_argument).rest_argument
+
+      arg.is_a?(ruby_object).should == true
+      arg.name.should                == 'number'
+    end
+
+    should 'add a more argument' do
+      arg = method_with_argument(@first, :more_argument).more_arguments.first
+
+      arg.is_a?(ruby_object).should == true
+      arg.name.should                == 'number'
+    end
+
+    should 'add a block argument' do
+      arg = method_with_argument(@first, :block_argument).block_argument
+
+      arg.is_a?(ruby_object).should == true
+      arg.name.should                == 'number'
+    end
+
+    should 'easily define constructor methods' do
+      @first.define_constructors do |method|
+        method.define_argument('name')
+      end
+
+      @first.lookup(:method, 'new').arguments[0].name.should == 'name'
+
+      @first.lookup(:instance_method, 'initialize') \
+        .arguments[0] \
+        .name \
+        .should == 'name'
+    end
+  end
+
+  describe 'defining global variables using a DSL' do
+    should 'define a global variable' do
+      @first.define_global_variable('$number', '10')
+
+      found = @first.lookup(:global_variable, '$number')
+
+      found.is_a?(ruby_object).should == true
+      found.type.should                == :global_variable
+      found.name.should                == '$number'
+    end
+  end
+end