ruby-lint 1.0.3 → 1.1.0

data/spec/ruby-lint/definition_builder/ruby_class_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::RubyClass do
   describe 'using an implicit parent class' do
-    before do
+    before :all do
       node     = s(:class, s(:const, nil, :A), nil, s(:nil))
-      @root    = ruby_object.new(:name => 'root')
-      @builder = RubyLint::DefinitionBuilder::RubyClass.new(node, @root)
+      @vm      = RubyLint::VirtualMachine.new
+      @builder = RubyLint::DefinitionBuilder::RubyClass.new(node, @vm)
     end
 
     example 'return the name of the class' do
@@ -30,21 +30,20 @@ describe RubyLint::DefinitionBuilder::RubyClass do
     end
 
     example 'return the scope to define the class in' do
-      @builder.scope.should == @root
+      @builder.scope.should == @vm.current_scope
     end
   end
 
   describe 'using an explicit parent class' do
-    before do
-      node  = s(:class, s(:const, nil, :A), s(:const, nil, :B), s(:nil))
-      @root = ruby_object.new(:name => 'root')
-
-      @root.define_constant('B')
+    before :all do
+      node   = s(:class, s(:const, nil, :A), s(:const, nil, :B), s(:nil))
+      @vm    = RubyLint::VirtualMachine.new
+      parent = @vm.definitions.define_constant('B')
 
       @builder = RubyLint::DefinitionBuilder::RubyClass.new(
         node,
-        @root,
-        :parent => @root.lookup(:const, 'B')
+        @vm,
+        :parent => parent
       )
     end
 
@@ -62,12 +61,12 @@ describe RubyLint::DefinitionBuilder::RubyClass do
     end
 
     example 'return the scope to define the class in' do
-      @builder.scope.should == @root
+      @builder.scope.should == @vm.current_scope
     end
   end
 
   describe 'using constant paths' do
-    before do
+    before :all do
       node = s(
         :class,
         s(:const, s(:const, nil, :A), :B),
@@ -75,15 +74,15 @@ describe RubyLint::DefinitionBuilder::RubyClass do
         s(:nil)
       )
 
-      @root = ruby_object.new(:name => 'root')
+      @vm = RubyLint::VirtualMachine.new
 
-      @root.define_constant('A')
+      @vm.definitions.define_constant('A')
 
-      d_const = @root.define_constant('C').define_constant('D')
+      d_const = @vm.definitions.define_constant('C').define_constant('D')
 
       @builder = RubyLint::DefinitionBuilder::RubyClass.new(
         node,
-        @root,
+        @vm,
         :parent => d_const
       )
     end
@@ -102,7 +101,7 @@ describe RubyLint::DefinitionBuilder::RubyClass do
     end
 
     example 'return the scope to define the class in' do
-      @builder.scope.should == @root.lookup(:const, 'A')
+      @builder.scope.should == @vm.definitions.lookup(:const, 'A')
     end
   end
-end
+end

data/spec/ruby-lint/definition_builder/ruby_method_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::RubyMethod do
   describe 'defining a method without a receiver' do
-    before do
+    before :all do
       node     = s(:def, :example, s(:args), s(:nil))
-      @root    = ruby_object.new(:name => 'root', :instance_type => :instance)
-      @builder = RubyLint::DefinitionBuilder::RubyMethod.new(node, @root)
+      @vm      = RubyLint::VirtualMachine.new
+      @builder = RubyLint::DefinitionBuilder::RubyMethod.new(node, @vm)
     end
 
     example 'return the name of the method' do
@@ -17,23 +17,23 @@ describe RubyLint::DefinitionBuilder::RubyMethod do
     end
 
     example 'return the parent definitions' do
-      @builder.build.parents.should == [@root]
+      @builder.build.parents.should == [@vm.current_scope]
     end
 
     example 'return the scope to define the method in' do
-      @builder.scope.should == @root
+      @builder.scope.should == @vm.current_scope
     end
   end
 
   describe 'defining a method with a constant as a receiver' do
-    before do
+    before :all do
       node    = s(:defs, s(:const, nil, :A), :example, s(:args), s(:nil))
-      @root   = ruby_object.new(:name => 'root', :instance_type => :instance)
-      a_const = @root.define_constant('A')
+      @vm     = RubyLint::VirtualMachine.new
+      a_const = @vm.definitions.define_constant('A')
 
       @builder = RubyLint::DefinitionBuilder::RubyMethod.new(
         node,
-        @root,
+        @vm,
         :receiver => a_const
       )
     end
@@ -43,11 +43,11 @@ describe RubyLint::DefinitionBuilder::RubyMethod do
     end
 
     example 'return the parent definitions' do
-      @builder.build.parents.should == [@root.lookup(:const, 'A')]
+      @builder.build.parents.should == [@vm.definitions.lookup(:const, 'A')]
     end
 
     example 'return the scope to define the method in' do
-      @builder.scope.should == @root.lookup(:const, 'A')
+      @builder.scope.should == @vm.definitions.lookup(:const, 'A')
     end
   end
-end
+end

data/spec/ruby-lint/definition_builder/ruby_module_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::RubyModule do
   describe 'building a simple module' do
-    before do
+    before :all do
       node     = s(:module, s(:const, nil, :A), s(:nil))
-      @root    = ruby_object.new(:name => 'root')
-      @builder = RubyLint::DefinitionBuilder::RubyModule.new(node, @root)
-      @module  = RubyLint::GlobalScope.global_constant('Module')
+      @vm      = RubyLint::VirtualMachine.new
+      @builder = RubyLint::DefinitionBuilder::RubyModule.new(node, @vm)
+      @module  = @vm.definitions.lookup(:const, 'Module')
     end
 
     example 'return the name of the module' do
@@ -14,7 +14,7 @@ describe RubyLint::DefinitionBuilder::RubyModule do
     end
 
     example 'return the parent definitions' do
-      @builder.build.parents.should == [@module, @root]
+      @builder.build.parents.should == [@module, @vm.current_scope]
     end
 
     example 'return the reference amount' do
@@ -22,19 +22,19 @@ describe RubyLint::DefinitionBuilder::RubyModule do
     end
 
     example 'return the scope to define the module in' do
-      @builder.scope.should == @root
+      @builder.scope.should == @vm.current_scope
     end
   end
 
   describe 'using constant paths' do
-    before do
-      node  = s(:module, s(:const, s(:const, nil, :A), :B), s(:nil))
-      @root = ruby_object.new(:name => 'root')
+    before :all do
+      node = s(:module, s(:const, s(:const, nil, :A), :B), s(:nil))
+      @vm  = RubyLint::VirtualMachine.new
 
-      @root.define_constant('A')
+      @vm.definitions.define_constant('A')
 
-      @builder = RubyLint::DefinitionBuilder::RubyModule.new(node, @root)
-      @module  = RubyLint::GlobalScope.global_constant('Module')
+      @builder = RubyLint::DefinitionBuilder::RubyModule.new(node, @vm)
+      @module  = @vm.definitions.lookup(:const, 'Module')
     end
 
     example 'return the name of the module' do
@@ -42,11 +42,11 @@ describe RubyLint::DefinitionBuilder::RubyModule do
     end
 
     example 'return the parent definitions' do
-      @builder.build.parents.should == [@module, @root]
+      @builder.build.parents.should == [@module, @vm.current_scope]
     end
 
     example 'return the scope to define the module in' do
-      @builder.scope.should == @root.lookup(:const, 'A')
+      @builder.scope.should == @vm.definitions.lookup(:const, 'A')
     end
   end
 end

data/spec/ruby-lint/definitions/argv_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe 'ruby-lint definitions' do
   context 'ARGV' do
-    before do
-      @const = RubyLint::GlobalScope.global_constant('ARGV')
+    before :all do
+      root   = load_definitions('ARGV', 'Array')
+      @const = root.lookup(:const, 'ARGV')
     end
 
     example 'treat ARGV as an instance' do

data/spec/ruby-lint/definitions/env_spec.rb

@@ -2,10 +2,12 @@ require 'spec_helper'
 
 describe 'ruby-lint definitions' do
   context 'ENV' do
-    example 'treat ENV as an instance' do
-      const = RubyLint::GlobalScope.global_constant('ENV')
+    before :all do
+      @const = load_definitions('ENV').lookup(:const, 'ENV')
+    end
 
-      const.instance?.should == true
+    example 'treat ENV as an instance' do
+      @const.instance?.should == true
     end
   end
 end

data/spec/ruby-lint/definitions/file_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'ruby-lint definitions' do
+  context 'File' do
+    before :all do
+      @file = load_definitions('File').lookup(:const, 'File')
+    end
+
+    example 'File.read should be defined' do
+      @file.has_definition?(:method, 'read').should == true
+    end
+
+    example 'File.open should be defined' do
+      @file.has_definition?(:method, 'open').should == true
+    end
+  end
+end

data/spec/ruby-lint/definitions/fixnum_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'ruby-lint definitions' do
+  context 'Fixnum' do
+    before :all do
+      root    = load_definitions('Fixnum', 'Integer', 'Numeric')
+      @fixnum = root.lookup(:const, 'Fixnum')
+    end
+
+    example 'inherit from Integer' do
+      @fixnum.parents.map(&:name).include?('Integer').should == true
+    end
+
+    example 'respond to methods from Numeric' do
+      @fixnum.has_definition?(:instance_method, '%').should == true
+    end
+  end
+end

data/spec/ruby-lint/definitions/io_spec.rb

@@ -2,11 +2,13 @@ require 'spec_helper'
 
 describe 'ruby-lint definitions' do
   context 'IO' do
+    before :all do
+      @root = load_definitions('STDERR', 'STDOUT', 'STDIN')
+    end
+
     example 'treat STDERR/STDOUT/STDIN as instances' do
       %w{STDERR STDOUT STDIN}.each do |name|
-        const = RubyLint::GlobalScope.global_constant(name)
-
-        const.instance?.should == true
+        @root.lookup(:const, name).instance?.should == true
       end
     end
   end

data/spec/ruby-lint/definitions/kernel_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'ruby-lint definitions' do
+  context 'Kernel' do
+    before :all do
+      @root   = load_definitions('Kernel')
+      @kernel = @root.lookup(:const, 'Kernel')
+    end
+
+    example 'The method is_a?() should be a class method' do
+      @kernel.defines?(:method, 'is_a?').should == true
+    end
+
+    example 'The method is_a?() should be an instance method' do
+      @kernel.defines?(:instance_method, 'is_a?').should == true
+    end
+  end
+end

data/spec/ruby-lint/definitions/range_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'ruby-lint definitions' do
+  context 'Range' do
+    before :all do
+      @range = load_definitions('Range', 'Enumerable').lookup(:const, 'Range')
+    end
+
+    example 'Enumerable should be a parent' do
+      @range.parents.map(&:name).include?('Enumerable').should == true
+    end
+
+    example 'inherit methods from Enumrable' do
+      @range.has_definition?(:instance_method, 'map').should == true
+    end
+
+    example 'do not define Enumerable methods directly' do
+      @range.defines?(:instance_method, 'map').should == false
+    end
+  end
+end

data/spec/ruby-lint/definitions/string_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'ruby-lint definitions' do
+  context 'String' do
+    before :all do
+      @string = load_definitions('String').lookup(:const, 'String')
+    end
+
+    example 'define self as a class method' do
+      @string.lookup(:method, 'self').return_value.class?.should == true
+    end
+
+    example 'define self as an instance method' do
+      @string.lookup(:instance_method, 'self')
+        .return_value
+        .instance?
+        .should == true
+    end
+  end
+end

data/spec/ruby-lint/file_list_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RubyLint::FileList do
+  before :all do
+    @list = RubyLint::FileList.new
+  end
+
+  example 'list a set of files' do
+    path = fixture_path('valid.rb')
+
+    @list.process([path]).should == [path]
+  end
+
+  example 'list a set of directories' do
+    @list.process([fixture_path('deeply')]).should == [
+      fixture_path('deeply/nested/file.rb')
+    ]
+  end
+
+  example 'raise for non existing files' do
+    block = lambda { @list.process(['yeah-right']) }
+
+    block.should raise_error(Errno::ENOENT)
+  end
+end

data/spec/ruby-lint/file_scanner_spec.rb

@@ -23,6 +23,18 @@ describe RubyLint::FileScanner do
     scanner.directories.include?(app).should == false
   end
 
+  example 'glob Ruby source files in a single directory' do
+    scanner = RubyLint::FileScanner.new([@lib_dir])
+
+    scanner.glob_ruby_files.empty?.should == false
+  end
+
+  example 'glob Ruby source files in multiple directories' do
+    scanner = RubyLint::FileScanner.new([@lib_dir, @rails_dir])
+
+    scanner.glob_ruby_files.empty?.should == false
+  end
+
   example 'finding a class' do
     scanner = RubyLint::FileScanner.new([@lib_dir])
     paths   = scanner.scan('Example::User')

data/spec/ruby-lint/inspector_spec.rb

@@ -1,44 +1,224 @@
 require 'spec_helper'
-require_relative '../../lib/ruby-lint/inspector'
 
 describe RubyLint::Inspector do
-  let(:inspector) { RubyLint::Inspector.new(Encoding) }
+  context 'inspecting constants' do
+    before :all do
+      inspector  = RubyLint::Inspector.new(Encoding)
+      @constants = inspector.inspect_constants
+    end
 
-  example 'return a list of child constants' do
-    inspector.inspect_constants.include?('Encoding::BINARY').should == true
+    example 'include the source constant' do
+      @constants.include?('Encoding').should == true
+    end
+
+    example 'include the child constants' do
+      @constants.include?('Encoding::BINARY').should     == true
+      @constants.include?('Encoding::ASCII_8BIT').should == true
+    end
+  end
+
+  context 'ignoring duplicates' do
+    before :all do
+      inspector  = RubyLint::Inspector.new(Encoding)
+      @constants = inspector.inspect_constants(
+        inspector.constant,
+        ['Encoding::BINARY']
+      )
+    end
+
+    example 'ignore duplicates' do
+      @constants.include?('Encoding::BINARY').should == false
+    end
+
+    example 'include other constants' do
+      @constants.include?('Encoding::ASCII_8BIT').should == true
+    end
+  end
+
+  context 'dealing with recursive constant lists' do
+    before :all do
+      # This ignores all constants except those defined on the right hand side
+      # of the subtraction. This speeds up the tests quite a bit (we don't care
+      # about constants such as CGI and Parser in this case).
+      ignore = Object.constants.map(&:to_s) - %w{Object Class Module Encoding}
+
+      inspector  = RubyLint::Inspector.new(Object)
+      @constants = inspector.inspect_constants(inspector.constant, ignore)
+    end
+
+    example 'include Class and Module' do
+      @constants.include?('Class').should  == true
+      @constants.include?('Module').should == true
+    end
+
+    example 'exclude recursive constants' do
+      @constants.include?('Class::Object').should  == false
+      @constants.include?('Module::Object').should == false
+    end
+
+    example 'include other regular constants' do
+      @constants.include?('Encoding').should         == true
+      @constants.include?('Encoding::BINARY').should == true
+    end
+  end
+
+  context 'Ruby implementation shenanigans' do
+    before :all do
+      mod = Module.new { include Enumerable }
+
+      inspector  = RubyLint::Inspector.new(mod)
+      @constants = inspector.inspect_constants
+    end
+
+    # This test was added since Rubinius defines `Range::Enumerator` which is
+    # an alias of `Enumerable::Enumerator`.
+    example 'ignore constants from a different root constant' do
+      @constants.include?('Enumerable::Enumerator').should == false
+    end
   end
 
-  example 'ignore a given constant' do
-    ins       = inspector
-    constants = ins.inspect_constants(ins.constant, ['Encoding::BINARY'])
+  context 'inspecting parent classes' do
+    before :all do
+      @inspector = RubyLint::Inspector.new(Object)
+    end
 
-    constants.include?('Encoding::BINARY').should == false
+    example 'return the parent class' do
+      @inspector.inspect_superclass.should == BasicObject
+    end
   end
 
-  example 'return the methods' do
-    names = inspector.inspect_methods.map(&:name)
+  context 'inspecting anonymous parent classes' do
+    before :all do
+      parent = Class.new
+      klass  = Class.new(parent)
 
-    names.include?(:find).should == true
+      @inspector = RubyLint::Inspector.new(klass)
+    end
+
+    example 'ignore anonymous parent classes' do
+      @inspector.inspect_superclass.nil?.should == true
+    end
   end
 
-  example 'return the instance methods' do
-    names = inspector.inspect_instance_methods.map(&:name)
+  context 'inspecting included modules' do
+    before :all do
+      klass = Class.new { include Enumerable }
+      child = Class.new(klass) { include Enumerable }
+
+      @modules       = RubyLint::Inspector.new(klass).inspect_modules
+      @child_modules = RubyLint::Inspector.new(child).inspect_modules
+    end
+
+    example 'include Enumerable' do
+      @modules.include?(Enumerable).should == true
+    end
 
-    names.include?(:to_s).should == true
+    example 'ignore modules that are already included in the parent' do
+      @child_modules.empty?.should == true
+    end
   end
 
-  example 'ignore methods defined in Object' do
-    method = double(:fake_method, :name => :tainted?)
-    const  = double(:fake_constant, :methods => [:tainted?], :method => method)
+  context 'inspecing included modules with anonymous modules' do
+    before :all do
+      mod   = Module.new { def foo; end }
+      klass = Class.new { include mod }
 
-    inspector = RubyLint::Inspector.new(const)
-    methods   = inspector.inspect_methods.map(&:name)
+      @modules = RubyLint::Inspector.new(klass).inspect_modules
+    end
 
-    methods.include?(:frozen?).should  == false
-    methods.include?(:tainted?).should == true
+    example 'ignore anonymous modules' do
+      @modules.empty?.should == true
+    end
   end
 
-  example 'return the superclass' do
-    inspector.inspect_superclass.should == Object
+  context 'inspecting class methods' do
+    before :all do
+      inspector = RubyLint::Inspector.new(Encoding)
+      @methods  = inspector.inspect_methods.map(&:name)
+    end
+
+    example 'include a method' do
+      @methods.include?(:find).should == true
+    end
+  end
+
+  context 'inspecting instance methods' do
+    before :all do
+      inspector = RubyLint::Inspector.new(Encoding)
+      @methods  = inspector.inspect_instance_methods.map(&:name)
+    end
+
+    example 'include a method' do
+      @methods.include?(:to_s).should == true
+    end
+  end
+
+  context 'exclude methods defined in a parent class' do
+    before :all do
+      parent    = Class.new { def foo; end }
+      child     = Class.new(parent) { def bar; end }
+      inspector = RubyLint::Inspector.new(child)
+      @methods  = inspector.inspect_instance_methods.map(&:name)
+    end
+
+    example 'exclude parent methods' do
+      @methods.include?(:foo).should == false
+    end
+
+    example 'include the instance methods of the source' do
+      @methods.include?(:bar).should == true
+    end
+  end
+
+  context 'exclude methods defined in an included module' do
+    before :all do
+      mod       = Module.new { def foo; end }
+      klass     = Class.new { include(mod); def bar; end }
+      inspector = RubyLint::Inspector.new(klass)
+      @methods  = inspector.inspect_instance_methods.map(&:name)
+    end
+
+    example 'do not include methods from included modules' do
+      @methods.include?(:foo).should == false
+    end
+
+    example 'include methods defined directly in the class' do
+      @methods.include?(:bar).should == true
+    end
+  end
+
+  context 'excluding parent methods when extending Object' do
+    before :all do
+      child     = Class.new(Object) { def foo; end }
+      inspector = RubyLint::Inspector.new(child)
+      @methods  = inspector.inspect_instance_methods.map(&:name)
+    end
+
+    example 'only include methods of the sub class' do
+      @methods.should == [:foo]
+    end
+  end
+
+  context 'including initialize methods' do
+    before :all do
+      @no_init = Class.new
+      @init    = Class.new { def initialize; end }
+
+      @no_init_methods = RubyLint::Inspector.new(@no_init)
+        .inspect_instance_methods
+        .map(&:name)
+
+      @init_methods = RubyLint::Inspector.new(@init)
+        .inspect_instance_methods
+        .map(&:name)
+    end
+
+    example 'exclude initialize if it is not defined directly' do
+      @no_init_methods.include?(:initialize).should == false
+    end
+
+    example 'include initialize if it is defined directly' do
+      @init_methods.include?(:initialize).should == true
+    end
   end
 end