yard 0.2.2 → 0.2.3

data/spec/generators/full_doc_generator_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), *%w|.. spec_helper|)
+
+class YARD::Generators::FullDocGenerator
+  public :generate_files, :readme_file_exists? # public for test
+end
+
+describe YARD::Generators::FullDocGenerator do
+  it "should know about absence of 'readme' file" do
+    generator = Generators::FullDocGenerator.new(:readme => nil)
+    generator.readme_file_exists?.should == false
+  end
+
+  it "should know about existence of 'readme' file" do
+    generator = Generators::FullDocGenerator.new(:readme => __FILE__)
+    generator.readme_file_exists?.should == true
+  end
+
+  it "should allow absence of 'readme' file" do
+    serializer = mock('serializer')
+    generator_options = {
+      :format     => :html,
+      :serializer => serializer,
+      :readme     => nil
+    }
+    generator = Generators::FullDocGenerator.new(generator_options)
+    serializer.should_not_receive(:serialize)
+    lambda { generator.generate_files }.should_not raise_error(Errno::ENOENT)
+  end
+end

data/spec/generators/helpers/html_helper_spec.rb

@@ -1,9 +1,19 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
 describe YARD::Generators::Helpers::HtmlHelper, "basic HTML methods" do
   include YARD::Generators::Helpers::HtmlHelper
   
   it "should use #h to escape HTML" do
     h('Usage: foo "bar" <baz>').should == "Usage: foo &quot;bar&quot; &lt;baz&gt;"
   end
+  
+  it "should use #fix_typewriter to convert +text+ to <tt>text</tt>" do
+    fix_typewriter("Some +typewriter text+.").should == "Some <tt>typewriter text</tt>."
+    fix_typewriter("Not +typewriter text.").should == "Not +typewriter text."
+    fix_typewriter("Alternating +type writer+ text +here+.").should == "Alternating <tt>type writer</tt> text <tt>here</tt>."
+    fix_typewriter("No ++problem.").should == "No ++problem."
+    fix_typewriter("Math + stuff +is ok+").should == "Math + stuff <tt>is ok</tt>"
+  end
 end
 
 describe YARD::Generators::Helpers::HtmlHelper, "#link_object" do
@@ -53,4 +63,68 @@ describe YARD::Generators::Helpers::HtmlHelper, '#url_for' do
     meth = CodeObjects::MethodObject.new(yard, :meth)
     url_for(meth).should == 'YARD.html#meth-instance_method'
   end
+
+  it "should properly urlencode methods with punctuation in links" do
+    obj = CodeObjects::MethodObject.new(nil, :/)
+    serializer = mock(:serializer)
+    serializer.stub!(:serialized_path).and_return("file.html")
+    stub!(:serializer).and_return(serializer)
+    stub!(:current_object).and_return(obj)
+    url_for(obj).should == "#%2F-instance_method"
+  end
+end
+
+describe YARD::Generators::Helpers::HtmlHelper, '#anchor_for' do
+  include YARD::Generators::Helpers::HtmlHelper
+  
+  it "should not urlencode data when called directly" do
+    obj = CodeObjects::MethodObject.new(nil, :/)
+    anchor_for(obj).should == "/-instance_method"
+  end
+end
+
+describe YARD::Generators::Helpers::HtmlHelper, '#resolve_links' do
+  include YARD::Generators::Helpers::HtmlHelper
+  
+  def parse_link(link)
+    results = {}
+    link =~ /<a (.+?)>(.+?)<\/a>/
+    params, results[:inner_text] = $1, $2
+    params.split(/\s+/).each do |match|
+      key, value = *match.split('=')
+      results[key.to_sym] = value.gsub(/^["'](.+)["']$/, '\1')
+    end
+    results
+  end
+
+  it "should link static files with file: prefix" do
+    stub!(:serializer).and_return Serializers::FileSystemSerializer.new
+    stub!(:current_object).and_return Registry.root
+
+    parse_link(resolve_links("{file:TEST.txt#abc}")).should == {
+      :inner_text => "TEST.txt",
+      :title => "TEST.txt",
+      :href => "TEST.txt.html#abc"
+    }
+    parse_link(resolve_links("{file:TEST.txt title}")).should == {
+      :inner_text => "title",
+      :title => "title",
+      :href => "TEST.txt.html"
+    }
+  end
+  
+  it "should create regular links with http:// or https:// prefixes" do
+    parse_link(resolve_links("{http://example.com}")).should == {
+      :inner_text => "http://example.com",
+      :target => "_parent",
+      :href => "http://example.com",
+      :title => "http://example.com"
+    }
+    parse_link(resolve_links("{http://example.com title}")).should == {
+      :inner_text => "title",
+      :target => "_parent",
+      :href => "http://example.com",
+      :title => "title"
+    }
+  end
 end

data/spec/generators/helpers/markup_helper_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module YARD::Generators::Helpers::MarkupHelper
+  public :load_markup_provider, :markup_class, :markup_provider
+end
+
+class MyMock
+  attr_accessor :options
+  include YARD::Generators::Helpers::MarkupHelper
+end
+
+describe YARD::Generators::Helpers::MarkupHelper do
+  before do
+    @gen = mock('Generator')
+    @gen.extend(YARD::Generators::Helpers::MarkupHelper)
+  end
+  
+  def generator_should_exit
+    STDERR.should_receive(:puts)
+    @gen.should_receive(:exit)
+  end
+  
+  it "should exit on an invalid markup type" do
+    generator_should_exit
+    @gen.stub!(:options).and_return({:markup => :invalid})
+    
+    # it will raise since providers == nil
+    # but in reality it would have already `exit`ed.
+    @gen.load_markup_provider rescue nil 
+  end
+
+  it "should exit on when an invalid markup provider is specified" do
+    generator_should_exit
+    @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :invalid})
+    
+    # it will raise since providers == nil
+    # but in reality it would have already `exit`ed.
+    @gen.load_markup_provider rescue nil
+    @gen.markup_class.should == nil
+  end
+  
+  it "should load nothing if rdoc is specified" do
+    @gen.stub!(:options).and_return({:markup => :rdoc})
+    @gen.load_markup_provider
+    @gen.markup_class.should == YARD::Generators::Helpers::MarkupHelper::SimpleMarkup
+  end
+  
+  it "should search through available markup providers for the markup type if none is set" do
+    @gen.should_receive(:require).with('bluecloth').and_return(true)
+    @gen.stub!(:options).and_return({:markup => :markdown})
+    # this only raises an exception because we mock out require to avoid 
+    # loading any libraries but our implementation tries to return the library 
+    # name as a constant
+    @gen.load_markup_provider rescue nil
+    @gen.markup_provider.should == :bluecloth
+  end
+  
+  it "should continue searching if some of the providers are unavailable" do
+    @gen.should_receive(:require).with('bluecloth').and_raise(LoadError)
+    @gen.should_receive(:require).with('maruku').and_raise(LoadError)
+    @gen.should_receive(:require).with('rpeg-markdown').and_return(true)
+    @gen.stub!(:options).and_return({:markup => :markdown})
+    # this only raises an exception because we mock out require to avoid 
+    # loading any libraries but our implementation tries to return the library 
+    # name as a constant
+    @gen.load_markup_provider rescue nil
+    @gen.markup_provider.should == :"rpeg-markdown"
+  end
+  
+  it "should override the search if `:markup_provider` is set in options" do
+    @gen.should_receive(:require).with('rdiscount').and_return(true)
+    @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+    @gen.load_markup_provider rescue nil
+    @gen.markup_provider.should == :rdiscount
+  end
+
+  it "should fail if no provider is found" do
+    generator_should_exit
+    YARD::Generators::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
+      @gen.should_receive(:require).with(p[:lib].to_s).and_raise(LoadError)
+    end
+    @gen.stub!(:options).and_return({:markup => :markdown})
+    @gen.load_markup_provider rescue nil
+    @gen.markup_provider.should == nil
+  end
+
+  it "should fail if overridden provider is not found" do
+    generator_should_exit
+    @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
+    @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+    @gen.load_markup_provider rescue nil
+    @gen.markup_provider.should == nil
+  end
+end
+

data/spec/handlers/alias_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::Handlers::AliasHandler do
+describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AliasHandler" do
   before do
     Registry.clear 
     parse_file :alias_handler_001, __FILE__
@@ -11,11 +11,19 @@ describe YARD::Handlers::AliasHandler do
   end
   
   it "should handle the Ruby 'alias' keyword syntax" do
-    ['A#c', 'A#d?', 'A#[]', 'A#[]=', 'A#@-', 'A#%', 'A#*'].each do |a|
+    ['A#c', 'A#d?', 'A#[]', 'A#[]=', 'A#-@', 'A#%', 'A#*'].each do |a|
       P(a).should be_instance_of(CodeObjects::MethodObject)
     end
   end
   
+  it "should handle keywords as the alias name" do
+    P('A#for').should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should allow ConstantNames to be specified as aliases" do
+    P('A#ConstantName').should be_instance_of(CodeObjects::MethodObject)
+  end
+  
   it "should create a new method object for the alias" do
     P("A#b").should be_instance_of(CodeObjects::MethodObject)
   end
@@ -37,6 +45,11 @@ describe YARD::Handlers::AliasHandler do
     P("B#t").is_alias?.should == true 
     P('B#r?').is_alias?.should == true
   end
+
+  it "should allow operators and keywords to be specified as symbols" do
+    P('B#<<').should be_instance_of(CodeObjects::MethodObject)
+    P('B#for').should be_instance_of(CodeObjects::MethodObject)
+  end
   
   it "should raise an UndocumentableError if only one parameter is passed" do
     undoc_error "alias_method :q"
@@ -47,4 +60,4 @@ describe YARD::Handlers::AliasHandler do
     undoc_error "alias_method variable, ClassName"
     undoc_error "alias_method variable, other_variable"
   end
-end
+end

data/spec/handlers/attribute_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::Handlers::AttributeHandler do
+describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AttributeHandler" do
   before { parse_file :attribute_handler_001, __FILE__ }
   
   def read_write(namespace, name, read, write, scope = :instance)

data/spec/handlers/base_spec.rb

@@ -12,154 +12,28 @@ describe YARD::Handlers::Base, "#handles and inheritance" do
     class TestHandler < Handlers::Base; end
   end
   
-  it "should handle a string input" do
-    class TestStringHandler < Handlers::Base
-      handles "hello"
-    end
-
-    TestStringHandler.handles?(TokenList.new("hello world")).should == true
-    TestStringHandler.handles?(TokenList.new("nothello world")).should == false
-  end
-  
-  it "should handle regex input" do
-    class TestRegexHandler < Handlers::Base
-      handles /^nothello$/
-    end
-
-    TestRegexHandler.handles?(TokenList.new("nothello")).should == true
-    TestRegexHandler.handles?(TokenList.new("not hello hello")).should == false
-  end
-
-  it "should handle token input" do
-    class TestTokenHandler < Handlers::Base
-      handles TkMODULE
-    end
-
-    TestTokenHandler.handles?(TokenList.new("module")).should == true
-    TestTokenHandler.handles?(TokenList.new("if")).should == false
-  end
-  
   it "should raise NotImplementedError if process is called on a class with no #process" do
     class TestNotImplementedHandler < Handlers::Base
-      handles TkMODULE
     end
     
     lambda { TestNotImplementedHandler.new(0, 0).process }.should raise_error(NotImplementedError)
   end
-end
-
-describe YARD::Handlers::Base, "#tokval" do 
-  include RubyToken
-  
-  before { @handler = Handlers::Base.new(nil, nil) } 
-  
-  def tokval(code, *types)
-    @handler.send(:tokval, TokenList.new(code).first, *types)
-  end
-  
-  it "should return the String's value without quotes" do
-    tokval('"hello"').should == "hello"
-  end
-  
-  it "should not allow interpolated strings with TkSTRING" do
-    tokval('"#{c}"', RubyToken::TkSTRING).should be_nil
-  end
-  
-  it "should return a Symbol's value as a String (as if it was done via :name.to_sym)" do
-    tokval(':sym').should == :sym
-  end
-  
-  it "should return nil for any non accepted type" do
-    tokval('identifier').should be_nil
-    tokval(':sym', RubyToken::TkId).should be_nil
-  end
-  
-  it "should accept TkVal tokens by default" do
-    tokval('2.5').should == 2.5
-    tokval(':sym').should == :sym
-  end
-  
-  it "should accept any ID type if TkId is set" do
-    tokval('variable', RubyToken::TkId).should == "variable"
-    tokval('CONSTANT', RubyToken::TkId).should == "CONSTANT"
-  end
-  
-  it "should allow extra token types to be accepted" do 
-    tokval('2.5', RubyToken::TkFLOAT).should == 2.5
-    tokval('2', RubyToken::TkFLOAT).should be_nil
-    tokval(':symbol', RubyToken::TkFLOAT).should be_nil
-  end
-  
-  it "should allow :string for any string type" do
-    tokval('"hello"', :string).should == "hello"
-    tokval('"#{c}"', :string).should == '#{c}'
-  end
   
-  it "should not include interpolated strings when using :attr" do
-    tokval('"#{c}"', :attr).should be_nil
-  end
-  
-  it "should allow any number type with :number" do
-    tokval('2.5', :number).should == 2.5
-    tokval('2', :number).should == 2
-  end
-  
-  it "should should allow method names with :identifier" do
-    tokval('methodname?', :identifier).should == "methodname?"
+  it "should allow multiple handles arguments" do
+    Handlers::Base.should_receive(:inherited).once
+    class TestHandler1 < Handlers::Base
+      handles :a, :b, :c
+    end
+    TestHandler1.handlers.should == [:a, :b, :c]
   end
-  
-  #it "should obey documentation expectations" do docspec end
-end
 
-describe YARD::Handlers::Base, "#tokval_list" do 
-  before { @handler = Handlers::Base.new(nil, nil) } 
-  
-  def tokval_list(code, *types)
-    @handler.send(:tokval_list, TokenList.new(code), *types)
-  end
-  
-  it "should return the list of tokvalues" do
-    tokval_list(":a, :b, \"\#{c}\", 'd'", :attr).should == [:a, :b, 'd']
-    tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d", RubyToken::Token).should  == [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
-  end
-  
-  it "should try to skip any invalid tokens" do
-    tokval_list(":a, :b, \"\#{c}\", :d", :attr).should  == [:a, :b, :d]
-    tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr).should  == [:a, :b, :d]
-    tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2", RubyToken::TkId).should  == ['CONST1', 'identifier', 'CONST2']
-  end
-  
-  it "should ignore a token if another invalid token is read before a comma" do
-    tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL).should == [:a, :c]
-  end
-  
-  it "should stop on most keywords" do
-    tokval_list(':a rescue :x == 5', RubyToken::Token).should == [:a]
-  end
-  
-  it "should handle ignore parentheses that begin the token list" do
-    tokval_list('(:a, :b, :c)', :attr).should == [:a, :b, :c]
-  end
-  
-  it "should end when a closing parenthesis was found" do
-    tokval_list(':a, :b, :c), :d', :attr).should == [:a, :b, :c]
-  end
-  
-  it "should ignore parentheses around items in a list" do
-    tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr).should == [:a, :b, :c, :e, :g]
-    tokval_list(':a, (((:f)))', :attr).should == [:a, :f]
-    tokval_list(':a, ([:f]), :c)', RubyToken::Token).should == [:a, '[:f]', :c]
-  end
-  
-  it "should not stop on a true/false/self keyword (cannot handle nil)" do
-    tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ', RubyToken::Token).should == [:a, true, :b, 'self', false, :c, 'File', 'super']
-  end
-  
-  it "should ignore invalid commas" do
-    tokval_list(":a, :b, , :d").should == [:a, :b, :d]
-  end
-  
-  it "should return an empty list if no matches were found" do
-    tokval_list('attr_accessor :x').should == []
+  it "should allow multiple handles calls" do
+    Handlers::Base.should_receive(:inherited).once
+    class TestHandler2 < Handlers::Base
+      handles :a
+      handles :b
+      handles :c
+    end
+    TestHandler2.handlers.should == [:a, :b, :c]
   end
-end
+end

data/spec/handlers/class_condition_handler_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassConditionHandler" do
+  before do
+    Registry.clear 
+    parse_file :class_condition_handler_001, __FILE__
+  end
+  
+  def verify_method(*names)
+    names.each {|name| Registry.at("A##{name}").should_not be_nil }
+    names.each {|name| Registry.at("A##{name}not").should be_nil }
+  end
+  
+  it "should parse all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
+  
+  it "should parse all unless blocks for complex conditions" do
+    verify_method :g
+  end
+  
+  it "should not parse conditionals inside methods" do
+    verify_method :h
+  end
+  
+  it "should only parse then block if condition is literal value `true`" do
+    verify_method :p
+  end
+  
+  it "should only parse else block if condition is literal value `false`" do
+    verify_method :q
+  end
+
+  it "should only parse then block if condition is literal integer != 0" do
+    verify_method :o
+  end
+
+  it "should only parse else block if condition is literal integer == 0" do
+    verify_method :n
+  end
+  
+  it "should invert block to parse for literal condition if it's an unless block" do
+    verify_method :e
+  end
+  
+  it "should handle conditions such as 'defined? VALUE'" do
+    verify_method :j, :k
+  end
+end if RUBY19