yard 0.7.5 → 0.8.0

data/spec/handlers/method_condition_handler_spec.rb

@@ -2,11 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodConditionHandler" do
   before(:all) { parse_file :method_condition_handler_001, __FILE__ }
-  
+
   it "should not parse regular if blocks in methods" do
     Registry.at('#b').should be_nil
   end
-  
+
   it "should parse if/unless blocks in the form X if COND" do
     Registry.at('#c').should_not be_nil
     Registry.at('#d').should_not be_nil

data/spec/handlers/method_handler_spec.rb

@@ -3,45 +3,45 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler" do
   before(:all) do
     log.enter_level(Logger::ERROR) do
-      parse_file :method_handler_001, __FILE__ 
+      parse_file :method_handler_001, __FILE__
     end
   end
-  
+
   it "should add methods to parent's #meths list" do
     P(:Foo).meths.should include(P("Foo#method1"))
   end
-  
+
   it "should parse/add class methods (self.method2)" do
     P(:Foo).meths.should include(P("Foo.method2"))
   end
-  
+
   it "should parse/add class methods from other namespaces (String.hello)" do
     P("String.hello").should be_instance_of(CodeObjects::MethodObject)
   end
-  
+
   [:[], :[]=, :allowed?, :/, :=~, :==, :`, :|, :*, :&, :%, :'^', :-@, :+@, :'~@'].each do |name|
     it "should allow valid method #{name}" do
       Registry.at("Foo##{name}").should_not be_nil
     end
   end
-  
+
   it "should allow self.methname" do
     Registry.at("Foo.new").should_not be_nil
   end
-  
+
   it "should mark dynamic methods as such" do
     P('Foo#dynamic').dynamic?.should == true
   end
-  
+
   it "should show that a method is explicitly defined (if it was originally defined implicitly by attribute)" do
     P('Foo#method1').is_explicit?.should == true
   end
-  
+
   it "should handle parameters" do
     P('Foo#[]').parameters.should == [['key', "'default'"]]
     P('Foo#/').parameters.should == [['x', "File.new('x', 'w')"], ['y', '2']]
   end
-  
+
   it "should handle opts = {} as parameter" do
     P('Foo#optsmeth').parameters.should == [['x', nil], ['opts', '{}']]
   end
@@ -69,87 +69,87 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler"
     o3.docstring.should be_empty
     o3.docstring.should be_blank
   end
-  
+
   it "should set a return tag if not set on #initialize" do
     meth = P('Foo#initialize')
-    
+
     meth.should have_tag(:return)
     meth.tag(:return).types.should == ["Foo"]
     meth.tag(:return).text.should == "a new instance of Foo"
   end
-  
+
   %w(inherited included method_added method_removed method_undefined).each do |meth|
     it "should set @private tag on #{meth} callback method if no docstring is set" do
       P('Foo.' + meth).should have_tag(:private)
     end
   end
-  
+
   it "should not set @private tag on extended callback method since docstring is set" do
     P('Foo.extended').should_not have_tag(:private)
   end
-  
+
   it "should add @return [Boolean] tag to methods ending in ? without return types" do
     meth = P('Foo#boolean?')
     meth.should have_tag(:return)
     meth.tag(:return).types.should == ['Boolean']
   end
-  
+
   it "should add Boolean type to return tag without types" do
     meth = P('Foo#boolean2?')
     meth.should have_tag(:return)
     meth.tag(:return).types.should == ['Boolean']
   end
-  
+
   it "should not change return type for method ending in ? with return types set" do
     meth = P('Foo#boolean3?')
     meth.should have_tag(:return)
     meth.tag(:return).types.should == ['NotBoolean', 'nil']
   end
-  
+
   it "should not change return type for method ending in ? with return types set by @overload" do
     meth = P('Foo#rainy?')
     meth.should have_tag(:overload)
     meth.tag(:overload).should have_tag(:return)
     meth.should_not have_tag(:return)
   end
-  
+
   it "should add method writer to existing attribute" do
     Registry.at('Foo#attr_name').should be_reader
     Registry.at('Foo#attr_name=').should be_writer
   end
-  
+
   it "should add method reader to existing attribute" do
     Registry.at('Foo#attr_name2').should be_reader
     Registry.at('Foo#attr_name2=').should be_writer
   end
-  
+
   it "should generate an options parameter if @option refers to an undocumented parameter" do
     meth = P('Foo#auto_opts')
     meth.should have_tag(:param)
     meth.tag(:param).name.should == "opts"
     meth.tag(:param).types.should == ["Hash"]
   end
-  
+
   it "should raise an undocumentable error when a method is defined on an object instance" do
     undoc_error "error = Foo; def error.at(foo) end"
     Registry.at('error').should be_nil
   end
-  
+
   it "should allow class method to be defined on constant reference object" do
     Registry.at('Foo.meth_on_const').should_not be_nil
     Registry.at('Foo.meth2_on_const').should_not be_nil
   end
-  
+
   it "should copy alias information on method (re-)definition to new method" do
     Registry.at('D').aliases.should be_empty
     Registry.at('D#b').is_alias?.should == false
     Registry.at('D#a').is_alias?.should == false
   end
-  
+
   it "should add macros for class methods" do
     macro = CodeObjects::MacroObject.find('prop')
     macro.should_not be_nil
-    macro.macro_data.should == "@method $1(value)\n$3\n@return [$2]"
+    macro.macro_data.should == "@!method $1(value)\n$3\n@return [$2]"
     macro.method_object.should == Registry.at('E.property')
     macro.should be_attached
     obj = Registry.at('E#foo')
@@ -158,22 +158,22 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler"
     obj.signature.should == 'def foo(value)'
     obj.tag(:return).types.should == ['String']
   end
-  
+
   it "should handle macros on any object" do
     macro = CodeObjects::MacroObject.find('xyz')
     macro.should_not be_nil
-    macro.macro_data.should == '@method $1'
+    macro.macro_data.should == '@!method $1'
   end
-  
+
   it "should skip macros on instance methods" do
     Registry.at('E#a').should be_nil
   end
-  
+
   it "should warn if the macro name is invalid" do
-    log.should_receive(:warn).with(/Invalid.+macro name.+Foo\.foo/)
-    YARD.parse_string "class Foo\n# @macro\ndef self.foo; end\nend"
+    log.should_receive(:warn).with(/Invalid directive.*@!macro/)
+    YARD.parse_string "class Foo\n# @!macro\ndef self.foo; end\nend"
   end
-  
+
   it "should handle 'def end' methods" do
     obj = Registry.at('F::A#foo')
     obj.should_not be_nil

data/spec/handlers/mixin_handler_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler" do
   before(:all) { parse_file :mixin_handler_001, __FILE__ }
-  
+
   it "should handle includes from classes or modules" do
     Registry.at(:X).instance_mixins.should include(P(:A))
     Registry.at(:Y).instance_mixins.should include(P(:A))
@@ -11,38 +11,42 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler"
   it "should handle includes in class << self" do
     Registry.at(:Y).class_mixins.should include(P(:A))
   end
-  
+
   it "should handle includes for modules that don't yet exist" do
     Registry.at(:X).instance_mixins.should include(P(nil, :NOTEXIST))
   end
-  
+
   it "should set the type of non-existing modules to :module" do
     P(:NOTEXIST).type.should == :module
   end
-  
+
   it "should handle includes with multiple parameters" do
     Registry.at(:X).should_not be_nil
   end
-  
+
   it "should handle complex include statements" do
     P(:Y).instance_mixins.should include(P('B::C'))
     P(:Y).instance_mixins.should include(P(:B))
   end
-  
+
   it "should treat a mixed in Constant by taking its value as the real object name" do
     P(:Y).instance_mixins.should include(Registry.at('B::D'))
   end
-  
+
+  it "should add includes in the correct order when include is given multiple arguments" do
+    P(:Z).instance_mixins.should == [P(:A), P(:B)]
+  end
+
   it "should avoid including self for unresolved mixins of the same name" do
     P("ABC::DEF::FOO").mixins.should == [P("ABC::FOO")]
     P("ABC::DEF::BAR").mixins.should == [P("ABC::BAR")]
   end
-  
+
   it "should raise undocumentable error if argument is variable" do
     undoc_error "module X; include invalid; end"
     Registry.at('X').mixins.should == []
   end
-  
+
   it "should parse all other arguments before erroring out on undocumentable error" do
     undoc_error "module X; include invalid, Y; end"
     Registry.at('X').mixins.should == [P('Y')]

data/spec/handlers/module_function_handler_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
+  after { Registry.clear }
+
+  def assert_module_function(namespace, name)
+    klass = Registry.at("#{namespace}.#{name}")
+    instance = Registry.at("#{namespace}##{name}")
+    klass.should_not be_nil
+    instance.should_not be_nil
+    klass.should be_module_function
+    instance.should_not be_module_function
+    klass.visibility.should == :public
+    instance.visibility.should == :private
+  end
+
+  it "should be able to create a module function with parameters" do
+    YARD.parse_string <<-eof
+      module Foo
+        def bar; end
+        def baz; end
+
+        module_function :bar, :baz
+      end
+    eof
+    assert_module_function('Foo', 'bar')
+    assert_module_function('Foo', 'baz')
+  end
+
+  it "should be able to set scope for duration of block without params" do
+    YARD.parse_string <<-eof
+      module Foo
+        def qux; end
+
+        module_function
+
+        def bar; end
+        def baz; end
+      end
+    eof
+    Registry.at('Foo.qux').should be_nil
+    assert_module_function('Foo', 'bar')
+    assert_module_function('Foo', 'baz')
+  end
+
+  it "should handle all method names in parameters" do
+    YARD.parse_string <<-eof
+      module Foo
+        def -(t); end
+        def ==(other); end
+        def a?; end
+        module_function :-, '==', :a?
+      end
+    eof
+    assert_module_function('Foo', '-')
+    assert_module_function('Foo', '==')
+    assert_module_function('Foo', 'a?')
+  end
+
+  it "should only accept strings and symbols" do
+    YARD.parse_string <<-eof
+      module Foo
+        module_function name
+        module_function *argument
+        module_function *(method_call)
+      end
+    eof
+    Registry.at('Foo#name').should be_nil
+    Registry.at('Foo#argument').should be_nil
+    Registry.at('Foo#method_call').should be_nil
+  end
+
+  it "should handle constants passed in as symbols" do
+    YARD.parse_string <<-eof
+      module Foo
+        def Foo; end
+        module_function :Foo
+      end
+    eof
+    assert_module_function('Foo', 'Foo')
+  end
+end

data/spec/handlers/module_handler_spec.rb

@@ -7,27 +7,27 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler"
     Registry.at(:ModName).should_not == nil
     Registry.at("ModName::OtherModName").should_not == nil
   end
-  
+
   it "should attach docstring" do
     Registry.at("ModName::OtherModName").docstring.should == "Docstring"
   end
-  
+
   it "should handle any formatting" do
     Registry.at(:StressTest).should_not == nil
   end
-  
+
   it "should handle complex module names" do
     Registry.at("A::B").should_not == nil
   end
-  
+
   it "should handle modules in the form ::ModName" do
     Registry.at("Kernel").should_not be_nil
   end
-  
+
   it "should list mixins in proper order" do
     Registry.at('D').mixins.should == [P(:C), P(:B), P(:A)]
   end
-  
+
   it "should create proper module when constant is in namespace" do
     Registry.at('Q::FOO::A').should_not be_nil
   end

data/spec/handlers/private_constant_handler_spec.rb

@@ -8,16 +8,16 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstan
     Registry.at('A::B').visibility.should == :private
     Registry.at('A::C').visibility.should == :private
   end
-  
+
   it "should make all other constants public" do
     Registry.at('A::D').visibility.should == :public
   end
-  
+
   it "should fail if parameter is not String, Symbol or Constant" do
     undoc_error 'class Foo; private_constant x; end'
     undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
   end unless LEGACY_PARSER
-  
+
   it "should fail if constant can't be recognized" do
     undoc_error 'class Foo2; private_constant :X end'
   end

data/spec/handlers/processor_spec.rb

@@ -2,21 +2,21 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Handlers::Processor do
   before do
-    @proc = Handlers::Processor.new
+    @proc = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
   end
-  
+
   it "should start with public visibility" do
     @proc.visibility.should == :public
   end
-  
+
   it "should start in instance scope" do
     @proc.scope.should == :instance
   end
-  
+
   it "should start in root namespace" do
     @proc.namespace.should == Registry.root
   end
-  
+
   it "should have a globals structure" do
     @proc.globals.should be_a(OpenStruct)
   end

data/spec/handlers/ruby/base_spec.rb

@@ -5,13 +5,17 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
 
   before do
     Handlers::Ruby::Base.stub!(:inherited)
-    @processor = Handlers::Processor.new(nil, false, :ruby)
+    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
   end
-  
+
+  after(:all) do
+    Handlers::Base.clear_subclasses
+  end
+
   def valid(handler, stmt)
     @processor.find_handlers(stmt).should include(handler)
   end
-  
+
   def invalid(handler, stmt)
     @processor.find_handlers(stmt).should_not include(handler)
   end
@@ -36,7 +40,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
     valid StringHandler, ast[0][0][0]
     invalid StringHandler, ast[0][1]
   end
-  
+
   it "should handle symbol input (matches AstNode#type)" do
     class SymbolHandler < Handlers::Ruby::Base
       handles :myNodeType
@@ -64,7 +68,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
     valid ASTHandler, s(:vcall, s(:ident, "hello_world"))
     invalid ASTHandler, s(:vcall, s(:ident, "NOTHELLOWORLD"))
   end
-  
+
   it "should handle #method_call(:methname) on a valid AST" do
     class MethCallHandler < Handlers::Ruby::Base
       handles method_call(:meth)
@@ -87,4 +91,4 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
     end
     invalid MethCallHandler, ast[9]
   end
-end if HAVE_RIPPER
+end if HAVE_RIPPER