yard 0.6.1 → 0.6.2

data/spec/cli/server_spec.rb

@@ -1,20 +1,27 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
+class Server::WebrickAdapter; def start; end end
+
 describe YARD::CLI::Server do
   before do
     @no_verify_libraries = false
+    @no_adapter_mock = false
     @libraries = {}
     @options = {:single_library => true, :caching => false}
     @server_options = {:Port => 8808}
     @adapter = mock(:adapter)
+    @adapter.stub!(:setup)
     @cli = YARD::CLI::Server.new
-    @cli.stub!(:adapter).and_return(@adapter)
   end
   
   def rack_required
     begin; require 'rack'; rescue LoadError; pending "rack required for this test" end
   end
   
+  def unstub_adapter
+    @no_adapter_mock = true
+  end
+  
   def run(*args)
     if @libraries.empty?
       library = Server::LibraryVersion.new(File.basename(Dir.pwd), nil, '.yardoc')
@@ -23,8 +30,11 @@ describe YARD::CLI::Server do
     unless @no_verify_libraries
       @libraries.values.each {|libs| libs.each {|lib| File.should_receive(:exist?).at_least(1).times.with(lib.yardoc_file).and_return(true) } }
     end
-    @adapter.should_receive(:new).with(@libraries, @options, @server_options).and_return(@adapter)
-    @adapter.should_receive(:start)
+    unless @no_adapter_mock
+      @cli.stub!(:adapter).and_return(@adapter)
+      @adapter.should_receive(:new).with(@libraries, @options, @server_options).and_return(@adapter)
+      @adapter.should_receive(:start)
+    end
     @cli.run(*args.flatten)
   end
 
@@ -94,7 +104,6 @@ describe YARD::CLI::Server do
   
   it "should default to Rack adapter if exists on system" do
     rack_required
-    @cli.unstub(:adapter)
     @cli.should_receive(:require).with('rubygems').and_return(false)
     @cli.should_receive(:require).with('rack').and_return(true)
     @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
@@ -102,7 +111,6 @@ describe YARD::CLI::Server do
   end
 
   it "should fall back to WEBrick adapter if Rack is not on system" do
-    @cli.unstub(:adapter)
     @cli.should_receive(:require).with('rubygems').and_return(false)
     @cli.should_receive(:require).with('rack').and_raise(LoadError)
     @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
@@ -137,4 +145,26 @@ describe YARD::CLI::Server do
     run '-g'
     run '--gems'
   end
+  
+  it "should load template paths after adapter template paths" do
+    unstub_adapter
+    @cli.adapter = Server::WebrickAdapter
+    run '-t', 'foo'
+    Templates::Engine.template_paths.last.should == 'foo'
+  end
+  
+  it "should load ruby code (-e) after adapter" do
+    unstub_adapter
+    @cli.adapter = Server::WebrickAdapter
+    File.open(File.dirname(__FILE__) + '/tmp.adapterscript.rb', 'w') do |f|
+      begin
+        f.puts "YARD::Templates::Engine.register_template_path 'foo'"
+        f.flush
+        run '-e', f.path
+        Templates::Engine.template_paths.last.should == 'foo'
+      ensure
+        File.unlink(f.path)
+      end
+    end
+  end
 end

data/spec/cli/stats_spec.rb

@@ -45,6 +45,21 @@ A#foo
 eof
   end
   
+  it "should list no undocumented objects with --list-undoc when objects are undocumented" do
+    Registry.clear
+    YARD.parse_string <<-eof
+      # documentation
+      def foo; end
+    eof
+    @stats.run('--list-undoc')
+    @output.string.should ==  "Files:           1\n" +
+                              "Modules:         0 (    0 undocumented)\n" +
+                              "Classes:         0 (    0 undocumented)\n" +
+                              "Constants:       0 (    0 undocumented)\n" +
+                              "Methods:         1 (    0 undocumented)\n" +
+                              " 100.00% documented\n"
+  end
+  
   it "should list undocumented objects in compact mode with --list-undoc --compact" do
     @stats.run('--list-undoc', '--compact')
     @output.string.should == <<-eof

data/spec/cli/yardoc_spec.rb

@@ -261,7 +261,7 @@ describe YARD::CLI::Yardoc do
 
     it "should not call #tag on namespace if namespace is proxy with --no-private" do
       ns = mock(:namespace)
-      ns.stub!(:type).and_return(:proxy)
+      ns.should_receive(:is_a?).with(CodeObjects::Proxy).and_return(true)
       ns.should_not_receive(:tag)
       obj = mock(:object)
       obj.stub!(:type).and_return(:class)
@@ -272,6 +272,21 @@ describe YARD::CLI::Yardoc do
       @yardoc.options[:verifier].call(obj).should == true
     end
 
+    # @bug gh-197
+    it "should not call #tag on namespace if namespace is proxy with --no-private" do
+      Registry.clear
+      YARD.parse_string "module Qux; class Foo::Bar; end; end"
+      foobar = Registry.at('Foo::Bar')
+      foobar.namespace.type = :module
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(foobar).should == true
+    end
+    
+    it "should not call #tag on proxy object" do # @bug gh-197
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(P('ProxyClass')).should == true
+    end
+
     it "should hide methods inside a 'private' class/module with --no-private" do
       Registry.clear
       YARD.parse_string <<-eof
@@ -467,4 +482,27 @@ describe YARD::CLI::Yardoc do
       Tags::Library.transitive_tags.should include(:foo)
     end
   end
+  
+  describe 'Safe mode' do
+    before do
+      YARD::Config.stub!(:options).and_return(:safe_mode => true)
+    end
+    
+    it "should not allow --load or -e in safe mode" do
+      @yardoc.should_not_receive(:require)
+      @yardoc.run('--load', 'foo')
+      @yardoc.run('-e', 'foo')
+    end
+
+    it "should not allow --query in safe mode" do
+      @yardoc.run('--query', 'foo')
+      @yardoc.options[:verifier].expressions.should_not include("foo")
+    end
+    
+    it "should not allow modifying the template paths" do
+      YARD::Templates::Engine.should_not_receive(:register_template_path)
+      @yardoc.run('-p', 'foo')
+      @yardoc.run('--template-path', 'foo')
+    end
+  end
 end

data/spec/code_objects/base_spec.rb

@@ -240,6 +240,8 @@ describe YARD::CodeObjects::Base do
       Registry.at('C::B::C::Apple').relative_path('C::B::C::Ant').should == 'Ant'
       YARD.parse_string 'module OMG::ABC; end; class Object; end'
       Registry.at('OMG::ABC').relative_path('Object').should == "Object"
+      YARD.parse_string("class YARD::Config; MYCONST = 1; end")
+      Registry.at('YARD::Config').relative_path('YARD::Config::MYCONST').should == "MYCONST"
     end
     
     it "should return a relative path for class methods" do

data/spec/code_objects/method_object_spec.rb

@@ -143,5 +143,10 @@ describe YARD::CodeObjects::MethodObject do
       eof
       Registry.at('B#foo').overridden_method.should be_nil
     end
+    
+    it "should return nil if namespace is a proxy" do
+      YARD.parse_string "def ARGV.foo; end"
+      Registry.at('ARGV.foo').overridden_method.should be_nil
+    end
   end
 end

data/spec/code_objects/proxy_spec.rb

@@ -38,11 +38,10 @@ describe YARD::CodeObjects::Proxy do
     P(:YARD).respond_to?(:children).should == true
     P(:NOTYARD).respond_to?(:children).should == false
 
-    private_method = P(:instantiated).private_methods.first
-    P(:YARD).respond_to?(private_method).should == false
-    P(:YARD).respond_to?(private_method, true).should == true
-    P(:NOTYARD).respond_to?(private_method).should == false
-    P(:NOTYARD).respond_to?(private_method, true).should == true
+    P(:YARD).respond_to?(:initialize).should == false
+    P(:YARD).respond_to?(:initialize, true).should == true
+    P(:NOTYARD).respond_to?(:initialize).should == false
+    P(:NOTYARD).respond_to?(:initialize, true).should == true
   end
   
   it "should make itself obvious that it's a proxy" do
@@ -97,4 +96,20 @@ describe YARD::CodeObjects::Proxy do
     resolved.namespace.should == Registry.root
     resolved.name.should == :YARD
   end
+  
+  it "should ensure that the correct object was resolved" do
+    foo = ModuleObject.new(:root, :Foo)
+    foobar = ModuleObject.new(foo, :Bar)
+    foobaz = ClassObject.new(foo, :Baz)
+    
+    # Remember, we're looking for Qux::Bar, not just 'Bar'
+    proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
+    proxy.type.should == :proxy
+    
+    qux = ModuleObject.new(foo, :Qux)
+    quxbar = ModuleObject.new(qux, :Bar)
+    
+    # Now it should resolve
+    proxy.type.should == :module
+  end
 end

data/spec/config_spec.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe YARD::Config do
+  describe '.load' do
+    before do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+    end
+
+    it "should use default options if no ~/.yard/config is found" do
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      YARD::Config.load
+      YARD::Config.options.should == YARD::Config::DEFAULT_CONFIG_OPTIONS
+    end
+    
+    it "should overwrite options with data in ~/.yard/config" do
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      YAML.should_receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return({'test' => true})
+      YARD::Config.load
+      YARD::Config.options[:test].should be_true
+    end
+    
+    it "should ignore any plugins specified in '~/.yard/ignored_plugins'" do
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      File.should_receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
+      YARD::Config.load
+      YARD::Config.options[:ignored_plugins].should == ['yard-plugin', 'yard-plugin2']
+      YARD::Config.should_not_receive(:require).with('yard-plugin2')
+      YARD::Config.load_plugin('yard-plugin2').should == false
+    end
+  end
+  
+  describe '.save' do
+    it "should save options to config file" do
+      YARD::Config.stub!(:options).and_return(:a => 1, :b => %w(a b c))
+      file = mock(:file)
+      File.should_receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
+      file.should_receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
+      YARD::Config.save
+    end
+  end
+  
+  describe '.load_plugin' do
+    it "should load a plugin by 'name' as 'yard-name'" do
+      YARD::Config.should_receive(:require).with('yard-foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('foo').should == true
+    end
+    
+    it "should not load plugins like 'doc-*'" do
+      YARD::Config.should_not_receive(:require).with('yard-doc-core')
+      YARD::Config.load_plugin('doc-core')
+      YARD::Config.load_plugin('yard-doc-core')
+    end
+    
+    it "should load plugin by 'yard-name' as 'yard-name'" do
+      YARD::Config.should_receive(:require).with('yard-foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('yard-foo').should == true
+    end
+    
+    it "should load plugin by 'yard_name' as 'yard_name'" do
+      YARD::Config.should_receive(:require).with('yard_foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard_foo'/).once
+      log.show_backtraces = false
+      YARD::Config.load_plugin('yard_foo').should == true
+    end
+    
+    it "should log error if plugin is not found" do
+      YARD::Config.should_receive(:require).with('yard-foo').and_raise(LoadError)
+      log.should_receive(:warn).with(/Error loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('yard-foo').should == false
+    end
+    
+    it "should sanitize plugin name (remove /'s)" do
+      YARD::Config.should_receive(:require).with('yard-foofoo')
+      YARD::Config.load_plugin('foo/foo').should == true
+    end
+    
+    it "should ignore plugins in :ignore_plugins" do
+      YARD::Config.stub!(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
+      YARD::Config.load_plugin('foo').should == false
+      YARD::Config.load_plugin('bar').should == false
+    end
+  end
+  
+  describe '.load_plugins' do
+    it "should load gem plugins if :load_plugins is true" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      YARD::Config.should_receive(:require).with('rubygems')
+      YARD::Config.load_plugins
+    end
+    
+    it "should ignore gem loading if RubyGems cannot load" do
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      YARD::Config.should_receive(:require).with('rubygems').and_raise(LoadError)
+      YARD::Config.load_plugins.should == false
+    end
+    
+    it "should load certain plugins automatically when specified in :autoload_plugins" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      YARD::Config.stub!(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
+      YARD::Config.should_receive(:require).with('yard-plugin').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should parse --plugin from command line arguments" do
+      YARD::Config.should_receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
+      YARD::Config.should_receive(:load_plugin).with('foo').and_return(true)
+      YARD::Config.should_receive(:load_plugin).with('bar').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should load --plugin arguments from .yardopts" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).once.and_return(true)
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      File.should_receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).once.and_return('--plugin foo')
+      YARD::Config.should_receive(:load_plugin).with('foo')
+      YARD::Config.load
+    end
+    
+    it "should load any gem plugins starting with 'yard_' or 'yard-'" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
+      plugins = {
+        'yard' => mock('yard'), 
+        'yard_plugin' => mock('yard_plugin'), 
+        'yard-plugin' => mock('yard-plugin'),
+        'my-yard-plugin' => mock('yard-plugin'),
+        'rspec' => mock('rspec'),
+      }
+      plugins.each do |k, v|
+        v.should_receive(:name).at_least(1).times.and_return(k)
+      end
+      
+      source_mock = mock(:source_index)
+      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
+      Gem.should_receive(:source_index).and_return(source_mock)
+      YARD::Config.should_receive(:load_plugin).with('yard_plugin').and_return(false)
+      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should log an error if a gem raises an error" do
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      plugins = {
+        'yard-plugin' => mock('yard-plugin')
+      }
+      plugins.each do |k, v|
+        v.should_receive(:name).at_least(1).times.and_return(k)
+      end
+      
+      source_mock = mock(:source_index)
+      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
+      Gem.should_receive(:source_index).and_return(source_mock)
+      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
+      log.should_receive(:warn).with(/Error loading plugin 'yard-plugin'/)
+      YARD::Config.load_plugins.should == false
+    end
+  end
+end

data/spec/handlers/alias_handler_spec.rb

@@ -48,6 +48,13 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AliasHandler" do
     P('B#for').should be_instance_of(CodeObjects::MethodObject)
   end
   
+  it "should handle keywords in alias names" do
+    P('B#do').is_alias?.should == true
+    P('B#x2').is_alias?.should == true
+    P(:B).aliases[P('B#do')].should == :x
+    P(:B).aliases[P('B#x2')].should == :do
+  end
+  
   it "should raise an UndocumentableError if only one parameter is passed" do
     undoc_error "alias_method :q"
   end

data/spec/handlers/base_spec.rb

@@ -108,4 +108,68 @@ describe YARD::Handlers::Base do
       process PushStateHandler3
     end
   end
+  
+  describe '.in_file' do
+    def parse(filename, src = "class A; end")
+      parser = Parser::SourceParser.new
+      parser.instance_variable_set("@file", filename)
+      parser.parse(StringIO.new(src))
+    end
+    
+    def create_handler(stmts)
+      @@counter ||= 0
+      sklass = Parser::SourceParser.parser_type == :ruby ? "Base" : "Legacy::Base"
+      instance_eval(<<-eof)
+        class ::InFileHandler#{@@counter += 1} < Handlers::Ruby::#{sklass}
+          handles /^class/
+          #{stmts}
+          def process; MethodObject.new(:root, :FOO) end
+        end
+      eof
+    end
+    
+    def test_handler(file, stmts, creates = true)
+      Registry.clear
+      Registry.at('#FOO').should be_nil
+      create_handler(stmts)
+      parse(file)
+      Registry.at('#FOO').send(creates ? :should_not : :should, be_nil)
+      Handlers::Base.subclasses.delete_if {|k,v| k.to_s =~ /^InFileHandler/ }
+    end
+    
+    [:ruby, :ruby18].each do |parser_type|
+      next if parser_type == :ruby && !RUBY19
+      describe "Parser type = #{parser_type.inspect}" do
+        Parser::SourceParser.parser_type = parser_type
+        it "should allow handler to be specific to a file" do
+          test_handler 'file_a.rb', 'in_file "file_a.rb"', true
+        end
+        
+        it "should ignore handler if filename does not match" do
+          test_handler 'file_b.rb', 'in_file "file_a.rb"', false
+        end
+
+        it "should only test filename part when given a String" do
+          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false
+        end
+        
+        it "should test exact match for entire String" do
+          test_handler 'file_a.rb', 'in_file "file"', false
+        end
+
+        it "should allow a Regexp as argument and test against full path" do
+          test_handler 'file_a.rbx', 'in_file /\.rbx$/', true
+          test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true
+          test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true
+        end
+
+        it "should allow multiple in_file declarations" do
+          stmts = 'in_file "x"; in_file /y/; in_file "foo.rb"'
+          test_handler 'foo.rb', stmts, true
+          test_handler 'xyzzy.rb', stmts, true
+          test_handler 'x', stmts, true
+        end
+      end
+    end
+  end
 end