ruby-lint 0.0.4 → 0.0.5

data/spec/ruby-lint/definition_builder/{ruby_method.rb → ruby_method_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../../../helper', __FILE__)
+require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::RubyMethod do
   describe 'defining a method without a receiver' do
@@ -8,19 +8,19 @@ describe RubyLint::DefinitionBuilder::RubyMethod do
       @builder = RubyLint::DefinitionBuilder::RubyMethod.new(node, @root)
     end
 
-    should 'return the name of the method' do
+    example 'return the name of the method' do
       @builder.build.name.should == 'example'
     end
 
-    should 'return the type of the method' do
+    example 'return the type of the method' do
       @builder.build.type.should == :instance_method
     end
 
-    should 'return the parent definitions' do
+    example 'return the parent definitions' do
       @builder.build.parents.should == [@root]
     end
 
-    should 'return the scope to define the method in' do
+    example 'return the scope to define the method in' do
       @builder.scope.should == @root
     end
   end
@@ -38,16 +38,16 @@ describe RubyLint::DefinitionBuilder::RubyMethod do
       )
     end
 
-    should 'return the name of the method' do
+    example 'return the name of the method' do
       @builder.build.name.should == 'example'
     end
 
-    should 'return the parent definitions' do
+    example 'return the parent definitions' do
       @builder.build.parents.should == [@root.lookup(:const, 'A')]
     end
 
-    should 'return the scope to define the method in' do
+    example 'return the scope to define the method in' do
       @builder.scope.should == @root.lookup(:const, 'A')
     end
   end
-end
+end

data/spec/ruby-lint/definition_builder/{ruby_module.rb → ruby_module_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../../../helper', __FILE__)
+require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::RubyModule do
   describe 'building a simple module' do
@@ -6,21 +6,22 @@ describe RubyLint::DefinitionBuilder::RubyModule 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')
     end
 
-    should 'return the name of the module' do
+    example 'return the name of the module' do
       @builder.build.name.should == 'A'
     end
 
-    should 'return the parent definitions' do
-      @builder.build.parents.should == [@root]
+    example 'return the parent definitions' do
+      @builder.build.parents.should == [@module, @root]
     end
 
-    should 'return the reference amount' do
+    example 'return the reference amount' do
       @builder.build.reference_amount.should == 1
     end
 
-    should 'return the scope to define the module in' do
+    example 'return the scope to define the module in' do
       @builder.scope.should == @root
     end
   end
@@ -33,17 +34,18 @@ describe RubyLint::DefinitionBuilder::RubyModule do
       @root.define_constant('A')
 
       @builder = RubyLint::DefinitionBuilder::RubyModule.new(node, @root)
+      @module  = RubyLint::GlobalScope.global_constant('Module')
     end
 
-    should 'return the name of the module' do
+    example 'return the name of the module' do
       @builder.build.name.should == 'B'
     end
 
-    should 'return the parent definitions' do
-      @builder.build.parents.should == [@root]
+    example 'return the parent definitions' do
+      @builder.build.parents.should == [@module, @root]
     end
 
-    should 'return the scope to define the module in' do
+    example 'return the scope to define the module in' do
       @builder.scope.should == @root.lookup(:const, 'A')
     end
   end

data/spec/ruby-lint/docstring/mapping.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe RubyLint::Docstring::Mapping do
+  let(:param_tag) { RubyLint::Docstring::ParamTag }
+  let(:return_tag) { RubyLint::Docstring::ReturnTag }
+
+  let(:tags) do
+    [
+      param_tag.new(:name => 'number', :types => ['Numeric']),
+      param_tag.new(:name => 'number2', :types => ['Integer']),
+      return_tag.new(:types => ['Numeric'])
+    ]
+  end
+
+  example 'map parameter tags by their names' do
+    mapping = RubyLint::Docstring::Mapping.new(tags)
+
+    mapping.param_tags['number'].types.should  == ['Numeric']
+    mapping.param_tags['number2'].types.should == ['Integer']
+  end
+
+  example 'map a return tag' do
+    mapping = RubyLint::Docstring::Mapping.new(tags)
+
+    mapping.return_tag.types.should == ['Numeric']
+  end
+end

data/spec/ruby-lint/docstring/parser_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe RubyLint::Docstring::Parser do
+  let(:parser) { RubyLint::Docstring::Parser.new }
+
+  context '@param tags' do
+    example 'parse a tag with just the parameter name' do
+      comments = ['# @param number']
+      tag      = parser.parse(comments)[0]
+
+      tag.is_a?(RubyLint::Docstring::ParamTag).should == true
+
+      tag.name.should == 'number'
+    end
+
+    example 'parse a tag with a parameter name and description' do
+      comments = ['# @param number The number.']
+      tag      = parser.parse(comments)[0]
+
+      tag.name.should        == 'number'
+      tag.description.should == 'The number.'
+    end
+
+    example 'parse a tag with a type' do
+      comments = ['# @param [Numeric] number']
+      tag      = parser.parse(comments)[0]
+
+      tag.name.should  == 'number'
+      tag.types.should == ['Numeric']
+    end
+
+    example 'parse a tag with a type and description' do
+      comments = ['# @param [Numeric] number The number.']
+      tag      = parser.parse(comments)[0]
+
+      tag.name.should        == 'number'
+      tag.types.should       == ['Numeric']
+      tag.description.should == 'The number.'
+    end
+
+    example 'parse a tag with a compound type' do
+      comments = ['# @param [Array<String>] names The names']
+      tag      = parser.parse(comments)[0]
+
+      tag.name.should        == 'names'
+      tag.description.should == 'The names'
+      tag.types.should       == ['Array']
+    end
+
+    example 'should parse a tag with a namespace in it' do
+      comments = ['# @param [Foo::Bar] baz']
+      tag      = parser.parse(comments)[0]
+
+      tag.name.should  == 'baz'
+      tag.types.should == ['Foo::Bar']
+    end
+  end
+
+  context '@return tags' do
+    example 'parse a tag with just the type' do
+      comments = ['# @return [Numeric]']
+      tag      = parser.parse(comments)[0]
+
+      tag.is_a?(RubyLint::Docstring::ReturnTag).should == true
+
+      tag.description.nil?.should == true
+      tag.types.should            == ['Numeric']
+    end
+
+    example 'parse a tag with the type and description' do
+      comments = ['# @return [Numeric] The number.']
+      tag      = parser.parse(comments)[0]
+
+      tag.is_a?(RubyLint::Docstring::ReturnTag).should == true
+
+      tag.types.should       == ['Numeric']
+      tag.description.should == 'The number.'
+    end
+
+    example 'parse a tag with the description' do
+      comments = ['# @return Hello']
+      tag      = parser.parse(comments)[0]
+
+      tag.types.should       == []
+      tag.description.should == 'Hello'
+    end
+  end
+end

data/spec/ruby-lint/extensions/{string.rb → string_spec.rb}

@@ -1,7 +1,7 @@
-require File.expand_path('../../../helper', __FILE__)
+require 'spec_helper'
 
 describe 'RubyLint String extensions' do
-  should 'snake_case a String' do
+  example 'snake_case a String' do
     'HelloWorld::Foo::Bar'.snake_case.should == 'hello_world_foo_bar'
   end
-end
+end

data/spec/ruby-lint/file_loader_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe RubyLint::FileLoader do
+  before :all do
+    @rails_dir = fixture_path('file_scanner/rails')
+    @lib_dir   = fixture_path('file_scanner/lib')
+  end
+
+  context 'rails projects' do
+    example 'finding a class' do
+      loader = RubyLint::FileLoader.new(:directories => [@rails_dir])
+      ast    = parse('User')
+
+      loader.iterate(ast)
+
+      loader.nodes.empty?.should == false
+
+      const = loader.nodes[1][0].children[0]
+
+      const.file
+        .should == fixture_path('file_scanner/rails/app/models/user.rb')
+    end
+
+    example 'finding a namespaced class' do
+      loader = RubyLint::FileLoader.new(:directories => [@rails_dir])
+      ast    = parse('Example::User')
+
+      loader.iterate(ast)
+
+      loader.nodes.empty?.should == false
+
+      const = loader.nodes[1][0].children[0]
+
+      const.file
+        .should == fixture_path('file_scanner/rails/app/models/example/user.rb')
+    end
+  end
+
+  context 'regular Ruby projects' do
+    example 'finding a class' do
+      loader = RubyLint::FileLoader.new(:directories => [@lib_dir])
+      ast    = parse('Example::User')
+
+      loader.iterate(ast)
+
+      loader.nodes.empty?.should == false
+
+      const = loader.nodes[0][0].children[0]
+
+      const.file.should == fixture_path('file_scanner/lib/example/user.rb')
+    end
+
+    example 'recursively find dependencies' do
+      loader = RubyLint::FileLoader.new(:directories => [@lib_dir])
+      ast    = parse('Example::Recursive::Source')
+
+      loader.iterate(ast)
+
+      nodes = loader.nodes.map do |pair|
+        pair[0].children[0]
+      end
+
+      nodes.length.should == 2
+
+      File.basename(nodes[0].file).should == 'target.rb'
+      File.basename(nodes[1].file).should == 'source.rb'
+    end
+  end
+end

data/spec/ruby-lint/file_scanner_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe RubyLint::FileScanner do
+  before :all do
+    @rails_dir = fixture_path('file_scanner/rails')
+    @lib_dir   = fixture_path('file_scanner/lib')
+  end
+
+  example 'raise when a non enumerable argument is given' do
+    lambda { RubyLint::FileScanner.new(10) }.should raise_error(TypeError)
+  end
+
+  example 'finding a class' do
+    scanner = RubyLint::FileScanner.new([@lib_dir])
+    paths   = scanner.scan('Example::User')
+
+    paths.should == [fixture_path('file_scanner/lib/example/user.rb')]
+  end
+
+  example 'finding a class using dashes for the directory names' do
+    scanner = RubyLint::FileScanner.new([@lib_dir])
+    paths   = scanner.scan('TestDashes::Foo')
+
+    paths.should == [fixture_path('file_scanner/lib/test-dashes/foo.rb')]
+  end
+
+  example 'finding a class using a Rails structure' do
+    scanner = RubyLint::FileScanner.new([@rails_dir])
+    paths   = scanner.scan('User')
+
+    paths.should == [
+      fixture_path('file_scanner/rails/app/models/user.rb'),
+      fixture_path('file_scanner/rails/app/models/example/user.rb')
+    ]
+  end
+
+  example 'finding a namespaced class using a Rails structure' do
+    scanner = RubyLint::FileScanner.new([@rails_dir])
+    paths   = scanner.scan('Example::User')
+
+    paths.should == [
+      fixture_path('file_scanner/rails/app/models/example/user.rb')
+    ]
+  end
+
+  example 'ignoring directories' do
+    scanner = RubyLint::FileScanner.new([@lib_dir], [@lib_dir])
+
+    scanner.scan('Example::User').empty?.should == true
+  end
+end

data/spec/ruby-lint/inspector_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require_relative '../../lib/ruby-lint/inspector'
+
+describe RubyLint::Inspector do
+  let(:inspector) { RubyLint::Inspector.new(Encoding) }
+
+  example 'return a list of child constants' do
+    inspector.inspect_constants.include?('Encoding::BINARY').should == true
+  end
+
+  example 'ignore a given constant' do
+    ins       = inspector
+    constants = ins.inspect_constants(ins.constant, ['Encoding::BINARY'])
+
+    constants.include?('Encoding::BINARY').should == false
+  end
+
+  example 'return the methods' do
+    names = inspector.inspect_methods.map(&:name)
+
+    names.include?(:find).should == true
+  end
+
+  example 'return the instance methods' do
+    names = inspector.inspect_instance_methods.map(&:name)
+
+    names.include?(:to_s).should == true
+  end
+
+  example 'ignore methods defined in Object' do
+    method = double(:fake_method, :name => :tainted?)
+    const  = double(:fake_constant, :methods => [:tainted?], :method => method)
+
+    inspector = RubyLint::Inspector.new(const)
+    methods   = inspector.inspect_methods.map(&:name)
+
+    methods.include?(:frozen?).should  == false
+    methods.include?(:tainted?).should == true
+  end
+
+  example 'return the superclass' do
+    inspector.inspect_superclass.should == Object
+  end
+end

data/spec/ruby-lint/{iterator.rb → iterator_spec.rb}

@@ -1,7 +1,7 @@
-require File.expand_path('../../helper', __FILE__)
+require 'spec_helper'
 
 describe 'RubyLint::Iterator' do
-  should 'call after_initialize if it is defined' do
+  example 'call after_initialize if it is defined' do
     iterator = Class.new(RubyLint::Iterator) do
       attr_reader :number
 
@@ -13,7 +13,7 @@ describe 'RubyLint::Iterator' do
     iterator.new.number.should == 10
   end
 
-  should 'iterate over a simple AST' do
+  example 'iterate over a simple AST' do
     ast = parse('10; 20; 30', false)
 
     iterator = Class.new(RubyLint::Iterator) do
@@ -59,7 +59,7 @@ describe 'RubyLint::Iterator' do
     ]
   end
 
-  should 'iterate over a multi dimensional AST' do
+  example 'iterate over a multi dimensional AST' do
     code = <<-CODE
 class Example
   def some_method
@@ -98,4 +98,39 @@ end
     iterator.options[:method].should == :some_method
     iterator.options[:call].should   == :puts
   end
+
+  example 'skipping child nodes' do
+    code = <<-CODE
+module A
+  class B
+  end
+end
+    CODE
+
+    ast      = parse(code, false)
+    iterator = Class.new(RubyLint::Iterator) do
+      attr_reader :options
+
+      def after_initialize
+        @options = {:module => false, :class => false}
+      end
+
+      def on_module(node)
+        options[:module] = true
+
+        skip_child_nodes!(node)
+      end
+
+      def on_class(node)
+        options[:class] = true
+      end
+    end
+
+    iterator = iterator.new
+
+    iterator.iterate(ast)
+
+    iterator.options[:module].should == true
+    iterator.options[:class].should  == false
+  end
 end