ruby-lint 0.0.3 → 0.0.4

data/spec/ruby-lint/{analyze → analysis}/unused_variables.rb

@@ -1,8 +1,8 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe RubyLint::Analyze::UnusedVariables do
+describe RubyLint::Analysis::UnusedVariables do
   should 'warn for unused local variables' do
-    report = build_report('number = 1', RubyLint::Analyze::UnusedVariables)
+    report = build_report('number = 1', RubyLint::Analysis::UnusedVariables)
     entry  = report.entries[0]
 
     entry.is_a?(RubyLint::Report::Entry).should == true
@@ -12,19 +12,20 @@ describe RubyLint::Analyze::UnusedVariables do
     entry.message.should == 'unused local variable number'
   end
 
-  should 'warn for unused global variables' do
-    report = build_report('$number = 1', RubyLint::Analyze::UnusedVariables)
-    entry  = report.entries[0]
+  should 'not warn for used variables' do
+    code = <<-CODE
+number = 1
 
-    entry.is_a?(RubyLint::Report::Entry).should == true
+number
+    CODE
 
-    entry.line.should    == 1
-    entry.column.should  == 0
-    entry.message.should == 'unused global variable $number'
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
+
+    report.entries.empty?.should == true
   end
 
   should 'warn for unused constants' do
-    report = build_report('NUMBER = 10', RubyLint::Analyze::UnusedVariables)
+    report = build_report('NUMBER = 10', RubyLint::Analysis::UnusedVariables)
     entry  = report.entries[0]
 
     entry.is_a?(RubyLint::Report::Entry).should == true
@@ -34,6 +35,18 @@ describe RubyLint::Analyze::UnusedVariables do
     entry.message.should == 'unused constant NUMBER'
   end
 
+  should 'not warn for used constants' do
+    code = <<-CODE
+A = 10
+
+A
+    CODE
+
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
+
+    report.entries.empty?.should == true
+  end
+
   should 'warn for unused constant paths' do
     code = <<-CODE
 module A
@@ -42,7 +55,7 @@ end
 A::B = 10
     CODE
 
-    report = build_report(code, RubyLint::Analyze::UnusedVariables)
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
 
     report.entries.length.should == 1
 
@@ -51,8 +64,8 @@ A::B = 10
     entry.is_a?(RubyLint::Report::Entry).should == true
 
     entry.line.should    == 4
-    entry.column.should  == 3
-    entry.message.should == 'unused constant B'
+    entry.column.should  == 0
+    entry.message.should == 'unused constant A::B'
   end
 
   should 'warn for unused variables in a method scope' do
@@ -62,7 +75,7 @@ def some_method
 end
     CODE
 
-    report = build_report(code, RubyLint::Analyze::UnusedVariables)
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
     entry  = report.entries[0]
 
     entry.is_a?(RubyLint::Report::Entry).should == true
@@ -78,7 +91,7 @@ first  = 10
 second = first
     CODE
 
-    report = build_report(code, RubyLint::Analyze::UnusedVariables)
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
 
     report.entries.length.should == 1
 
@@ -98,7 +111,7 @@ class B
 end
     CODE
 
-    report = build_report(code, RubyLint::Analyze::UnusedVariables)
+    report = build_report(code, RubyLint::Analysis::UnusedVariables)
 
     report.entries.empty?.should == true
   end

data/spec/ruby-lint/ast/node.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::AST::Node do
+  should 'return the value for a scalar' do
+    s(:str, 'hello').children[0].should == 'hello'
+  end
+
+  should 'return the value for an Array' do
+    numbers = s(:array, s(:int, 10), s(:int, 20)).children
+
+    numbers.is_a?(Array).should == true
+    numbers.length.should       == 2
+
+    numbers[0].children[0].should == 10
+    numbers[1].children[0].should == 20
+  end
+
+  should 'return the value for a Hash' do
+    pairs = s(:hash, s(:pair, s(:str, 'number'), s(:int, 10))).children
+
+    pairs.is_a?(Array).should == true
+
+    pairs[0].children[1].children[0].should == 10
+  end
+
+  should 'should try to guess the Ruby class of a node' do
+    s(:str, 'foo').ruby_class.should == 'String'
+  end
+
+  should 'check if a node is a constant path' do
+    s(:const, s(:const, nil, :A), :B).constant_path?.should == true
+  end
+end

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

@@ -0,0 +1,31 @@
+require File.expand_path('../../../helper', __FILE__)
+require File.expand_path('../../../../lib/ruby-lint/cli', __FILE__)
+
+describe RubyLint::CLI do
+  describe 'analyze' do
+    before do
+      @command = RubyLint::CLI.options.commands['analyze']
+      @output  = StringIO.new
+
+      @command.output_destination = @output
+    end
+
+    should 'analyze a valid Ruby file' do
+      file = File.expand_path('../../../fixtures/valid.rb', __FILE__)
+
+      @command.parse([file])
+
+      @output.rewind
+      @output.read.empty?.should == true
+    end
+
+    should 'analyze an invalid Ruby file' do
+      file = File.expand_path('../../../fixtures/invalid.rb', __FILE__)
+
+      @command.parse([file])
+
+      @output.rewind
+      @output.read.should =~ /undefined method foobar/
+    end
+  end
+end

data/spec/ruby-lint/cli/ast.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../../helper', __FILE__)
+require File.expand_path('../../../../lib/ruby-lint/cli', __FILE__)
+
+describe RubyLint::CLI do
+  describe 'ast' do
+    before do
+      @command = RubyLint::CLI.options.commands['ast']
+      @output  = StringIO.new
+
+      @command.output_destination = @output
+    end
+
+    should 'show the AST of a Ruby file' do
+      file   = File.expand_path('../../../fixtures/valid.rb', __FILE__)
+      output = RubyLint::Parser.new.parse(File.read(file)).inspect
+
+      @command.parse([file])
+
+      @output.rewind
+      @output.read.strip.should == output
+    end
+  end
+end

data/spec/ruby-lint/configuration.rb

@@ -1,15 +1,54 @@
 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])
+  describe 'default options' do
+    before do
+      @configuration = RubyLint::Configuration.new
+    end
 
-    config.report_levels.should == [:test]
+    should 'set the default report levels' do
+      @configuration.report_levels.should == RubyLint::Report::DEFAULT_LEVELS
+    end
+
+    should 'set the default presenter' do
+      @configuration.default_presenter.should == RubyLint::Presenter::Text
+    end
+
+    should 'set the default analysis classes' do
+      @configuration.default_analysis_classes.empty?.should == false
+    end
+  end
+
+  describe 'setting options via the constructor' do
+    should 'set the report levels' do
+      conf = RubyLint::Configuration.new(:report_levels => ['info'])
+
+      conf.report_levels.should == [:info]
+    end
+
+    should 'set the presenter' do
+      conf = RubyLint::Configuration.new(:presenter => 'json')
+
+      conf.presenter.should == RubyLint::Presenter::JSON
+    end
+
+    should 'set the analysis classes' do
+      conf = RubyLint::Configuration.new(
+        :analysis_classes => ['undefined_methods']
+      )
+
+      conf.analysis_classes.should == [RubyLint::Analysis::UndefinedMethods]
+    end
   end
 
-  should 'set a default value for options' do
-    config = RubyLint::Configuration.new
+  describe 'setting options via a configuration file' do
+    should 'set the options from a YAML file' do
+      paths = [File.expand_path('../../fixtures/config.yml', __FILE__)]
+      conf  = RubyLint::Configuration.load_from_file(paths)
 
-    config.report_levels.should == RubyLint::Report::DEFAULT_LEVELS
+      conf.report_levels.should    == [:info]
+      conf.analysis_classes.should == [RubyLint::Analysis::UndefinedMethods]
+      conf.presenter.should        == RubyLint::Presenter::JSON
+    end
   end
 end

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

@@ -0,0 +1,31 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::Definition::ConstantProxy do
+  before do
+    @source = ruby_object.new(:name => 'global', :type => :global)
+    @proxy  = RubyLint::Definition::ConstantProxy.new(@source, 'Foo')
+  end
+
+  should 'create a new constant proxy' do
+    @proxy.proxy_source.should == @source
+    @proxy.proxy_name.should   == 'Foo'
+  end
+
+  should 'act like a RubyObject definition' do
+    @proxy.lookup(:const, 'Bar').nil?.should == true
+  end
+
+  should 'cache the definition when it exists' do
+    @proxy.name.nil?.should == true
+    @proxy.type.nil?.should == true
+
+    @proxy.lookup(:const, 'VERSION').nil?.should == true
+
+    @source.define_constant('Foo').define_constant('VERSION')
+
+    @proxy.name.should == 'Foo'
+    @proxy.type.should == :const
+
+    @proxy.lookup(:const, 'VERSION').is_a?(ruby_object).should == true
+  end
+end

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

@@ -2,14 +2,14 @@ require File.expand_path('../../../helper', __FILE__)
 
 describe RubyLint::Definition::RubyObject do
   before do
-    @first = ruby_object.new(:name => 'First', :type => :constant)
+    @first = ruby_object.new(:name => 'First', :type => :const)
   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
+      @first.lookup(:const, 'B').is_a?(ruby_object).should == true
     end
 
     should 'define a constant using a block' do
@@ -17,8 +17,8 @@ describe RubyLint::Definition::RubyObject do
         b.define_constant('C')
       end
 
-      @first.lookup(:constant, 'B') \
-        .lookup(:constant, 'C') \
+      @first.lookup(:const, 'B') \
+        .lookup(:const, 'C') \
         .is_a?(ruby_object) \
         .should == true
     end
@@ -29,11 +29,11 @@ describe RubyLint::Definition::RubyObject do
       end
 
       @first.define_constant('D') do |d|
-        d.inherits(@first.lookup(:constant, 'B'))
+        d.inherits(@first.lookup(:const, 'B'))
       end
 
-      @first.lookup(:constant, 'D') \
-        .lookup(:constant, 'C') \
+      @first.lookup(:const, 'D') \
+        .lookup(:const, 'C') \
         .is_a?(ruby_object) \
         .should == true
     end
@@ -42,8 +42,8 @@ describe RubyLint::Definition::RubyObject do
       @first.define_constant('A')
       @first.define_constant('A::B')
 
-      @first.lookup(:constant, 'A') \
-        .lookup(:constant, 'B') \
+      @first.lookup(:const, 'A') \
+        .lookup(:const, 'B') \
         .is_a?(ruby_object) \
         .should == true
     end
@@ -65,7 +65,7 @@ describe RubyLint::Definition::RubyObject do
     end
 
     should 'define a method\'s return value' do
-      string = ruby_object.new(:type => :string, :value => 'hello')
+      string = ruby_object.new(:type => :str, :value => 'hello')
 
       @first.define_method('example') do |example|
         example.returns(string)
@@ -100,13 +100,6 @@ describe RubyLint::Definition::RubyObject do
       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
 
@@ -132,11 +125,11 @@ describe RubyLint::Definition::RubyObject do
     should 'define a global variable' do
       @first.define_global_variable('$number', '10')
 
-      found = @first.lookup(:global_variable, '$number')
+      found = @first.lookup(:gvar, '$number')
 
       found.is_a?(ruby_object).should == true
-      found.type.should                == :global_variable
-      found.name.should                == '$number'
+      found.type.should               == :gvar
+      found.name.should               == '$number'
     end
   end
 end

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

@@ -1,175 +1,92 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe ruby_method do
-  before do
-    @method_def = ruby_method.new_from_node(
-      s(
-        :method_definition,
-        'example',
-        s(
-          :arguments,
-          s(:argument, s(:local_variable, 'required')),
-          s(
-            :optional_argument,
-            s(:local_variable, 'number', s(:integer, '10'))
-          ),
-          s(:rest_argument, s(:local_variable, 'rest')),
-          s(:more_argument, s(:local_variable, 'more')),
-          s(:block_argument, s(:local_variable, 'block'))
-        ),
-        s(:constant, 'String'),
-        s(:body, [s(:return, s(:local_variable, 'required'))])
-      )
-    )
-
-    @method_call = ruby_method.new_from_node(
-      s(
-        :method,
-        'example',
-        s(:arguments, s(:argument, s(:integer, '10'))),
-        s(:constant, 'String')
-      )
-    )
-  end
-
-  should 'return the correct method names' do
-    @method_def.name.should  == 'example'
-    @method_call.name.should == 'example'
-  end
-
-  should 'return the correct object types' do
-    @method_def.type.should  == :method_definition
-    @method_call.type.should == :method
-
-    @method_def.method?.should  == false
-    @method_call.method?.should == true
-  end
-
-  should 'return the method definition receiver' do
-    @method_def.receiver.is_a?(ruby_object).should == true
-    @method_def.receiver.name.should               == 'String'
-  end
-
-  should 'return the method call receiver' do
-    @method_call.receiver.is_a?(ruby_object).should == true
-    @method_call.receiver.name.should               == 'String'
-  end
-
-  should 'set the correct method definition type' do
-    @method_def.method_type.should == :method
-  end
-
-  describe 'method definition arguments' do
-    should 'return the required arguments' do
-      @method_def.arguments.length.should == 1
-
-      required = @method_def.arguments[0]
-
-      required.is_a?(ruby_object).should == true
-
-      required.name.should == 'required'
+describe RubyLint::Definition::RubyObject do
+  describe 'method definition DSL' do
+    before do
+      @method = ruby_method.new(:name => 'example', :type => :instance_method)
     end
 
-    should 'return the optional arguments' do
-      @method_def.optional_arguments.length.should == 1
+    describe 'return values' do
+      should 'return a static value' do
+        @method.returns(10)
 
-      number = @method_def.optional_arguments[0]
+        @method.return_value.should == 10
+      end
 
-      number.is_a?(ruby_object).should == true
+      should 'return a value using a block' do
+        @method.returns do
+          20
+        end
 
-      number.name.should == 'number'
-
-      number.value.is_a?(ruby_object).should == true
-
-      number.value.value.should == '10'
-    end
-
-    should 'return the rest argument' do
-      @method_def.rest_argument.nil?.should == false
-      @method_def.rest_argument.name.should == 'rest'
+        @method.return_value.is_a?(Proc).should == true
+        @method.return_value.call.should        == 20
+      end
     end
 
-    should 'return the more arguments' do
-      @method_def.more_arguments.length.should == 1
+    describe 'calling methods' do
+      before do
+        @method.returns(10)
+      end
 
-      param = @method_def.more_arguments[0]
+      should 'call the method directly' do
+        @method.call.should == 10
+      end
 
-      param.name.should       == 'more'
-      param.value.nil?.should == true
-    end
-
-    should 'return the block argument' do
-      @method_def.block_argument.nil?.should == false
-      @method_def.block_argument.name.should == 'block'
-    end
+      should 'call the method by name' do
+        container = ruby_object.new(
+          :name          => 'String',
+          :type          => :const,
+          :instance_type => :instance
+        )
 
-    should 'add method arguments to the definitions list' do
-      @method_def.lookup(:local_variable, 'required') \
-        .is_a?(ruby_object) \
-        .should == true
+        container.add_definition(@method)
 
-      @method_def.lookup(:local_variable, 'block') \
-        .is_a?(ruby_object) \
-        .should == true
-    end
-  end
+        container.call_method('example').should == 10
+      end
 
-  describe 'method call arguments' do
-    should 'return the specified arguments' do
-      @method_call.arguments.length.should == 1
+      should 'raise for calling an undefined method' do
+        container = ruby_object.new(
+          :name          => 'String',
+          :type          => :const,
+          :instance_type => :instance
+        )
 
-      param = @method_call.arguments[0]
+        error = should.raise?(NoMethodError) do
+          container.call_method('derp')
+        end
 
-      param.is_a?(ruby_object).should == true
-      param.type.should                                    == :integer
-      param.value.should                                   == '10'
+        error.message.should =~ /undefined method derp for/i
+      end
     end
 
-    should 'process a constant path' do
-      method = ruby_method.new_from_node(
-        s(
-          :method,
-          'example',
-          s(
-            :arguments,
-            s(
-              :argument,
-              s(:constant_path, s(:constant, 'First'), s(:constant, 'Second'))
-            )
-          ),
-          nil,
-          nil
-        )
-      )
-
-      param = method.arguments[0]
+    describe 'defining arguments' do
+      should 'define an argument' do
+        @method.define_argument('number')
 
-      param.is_a?(ruby_object).should == true
-      param.type.should == :constant
-      param.name.should == 'Second'
+        @method.lookup(:arg, 'number').is_a?(ruby_object).should  == true
+        @method.lookup(:lvar, 'number').is_a?(ruby_object).should == true
+      end
 
-      param.receiver.is_a?(ruby_object).should == true
-      param.receiver.type.should == :constant
-      param.receiver.name.should == 'First'
-    end
-  end
+      should 'define an optional argument' do
+        @method.define_optional_argument('number')
 
-  should 'list all the methods of a class' do
-    klass = ruby_object.new(
-      :type => :class,
-      :name => 'Example'
-    )
+        @method.lookup(:optarg, 'number').is_a?(ruby_object).should == true
+        @method.lookup(:lvar, 'number').is_a?(ruby_object).should   == true
+      end
 
-    method = ruby_method.new(
-      :name     => 'class_method',
-      :receiver => klass.lookup(:keyword, 'self')
-    )
+      should 'define a rest argument' do
+        @method.define_rest_argument('number')
 
-    klass.add(:method, method.name, method)
+        @method.lookup(:restarg, 'number').is_a?(ruby_object).should == true
+        @method.lookup(:lvar, 'number').is_a?(ruby_object).should   == true
+      end
 
-    methods = klass.list(:method)
+      should 'define a block argument' do
+        @method.define_block_argument('number')
 
-    methods.length.should  == 1
-    methods[0].name.should == 'class_method'
+        @method.lookup(:blockarg, 'number').is_a?(ruby_object).should == true
+        @method.lookup(:lvar, 'number').is_a?(ruby_object).should   == true
+      end
+    end
   end
 end