ruby-lint 1.1.0 → 2.0.0

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

@@ -1,88 +0,0 @@
-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_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe 'RubyLint String extensions' do
-  example 'snake_case a String' do
-    'HelloWorld::Foo::Bar'.snake_case.should == 'hello_world_foo_bar'
-  end
-end

data/spec/ruby-lint/file_list_spec.rb

@@ -1,25 +0,0 @@
-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_loader_spec.rb

@@ -1,69 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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 'set the default directories' do
-    scanner = RubyLint::FileScanner.new
-
-    scanner.directories.empty?.should == false
-  end
-
-  example 'do not include non existing directories' do
-    app     = File.join(Dir.pwd, 'app')
-    scanner = RubyLint::FileScanner.new
-
-    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')
-
-    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
-
-  example 'do not scan when there are no directories' do
-    scanner = RubyLint::FileScanner.new([])
-
-    scanner.should_not receive(:glob_ruby_files)
-
-    scanner.scan('Foo')
-  end
-end

data/spec/ruby-lint/inspector_spec.rb

@@ -1,224 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::Inspector do
-  context 'inspecting constants' do
-    before :all do
-      inspector  = RubyLint::Inspector.new(Encoding)
-      @constants = inspector.inspect_constants
-    end
-
-    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
-
-  context 'inspecting parent classes' do
-    before :all do
-      @inspector = RubyLint::Inspector.new(Object)
-    end
-
-    example 'return the parent class' do
-      @inspector.inspect_superclass.should == BasicObject
-    end
-  end
-
-  context 'inspecting anonymous parent classes' do
-    before :all do
-      parent = Class.new
-      klass  = Class.new(parent)
-
-      @inspector = RubyLint::Inspector.new(klass)
-    end
-
-    example 'ignore anonymous parent classes' do
-      @inspector.inspect_superclass.nil?.should == true
-    end
-  end
-
-  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
-
-    example 'ignore modules that are already included in the parent' do
-      @child_modules.empty?.should == true
-    end
-  end
-
-  context 'inspecing included modules with anonymous modules' do
-    before :all do
-      mod   = Module.new { def foo; end }
-      klass = Class.new { include mod }
-
-      @modules = RubyLint::Inspector.new(klass).inspect_modules
-    end
-
-    example 'ignore anonymous modules' do
-      @modules.empty?.should == true
-    end
-  end
-
-  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