yard 0.8.1 → 0.8.2

data/spec/handlers/c/override_comment_handler_spec.rb

@@ -4,6 +4,7 @@ describe YARD::Handlers::C::OverrideCommentHandler do
   [:class, :module].each do |type|
     it "should handle Document-#{type}" do
       parse(<<-eof)
+        void something;
         /* Document-#{type}: A
          * Foo bar baz
          */
@@ -11,6 +12,8 @@ describe YARD::Handlers::C::OverrideCommentHandler do
       eof
       Registry.at('A').type.should == type
       Registry.at('A').docstring.should == 'Foo bar baz'
+      Registry.at('A').file.should == '(stdin)'
+      Registry.at('A').line.should == 2
     end
   end
 

data/spec/handlers/class_condition_handler_spec.rb

@@ -48,6 +48,11 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassCondition
     verify_method :n
   end
 
+  it "should maintain visibility and scope state inside condition" do
+    Registry.at('A#m').visibility.should == :private
+    Registry.at('A#mnot').visibility.should == :private
+  end
+
   it "should not fail on complex conditions" do
     log.should_not_receive(:warn)
     log.should_not_receive(:error)

data/spec/handlers/dsl_handler_spec.rb

@@ -61,6 +61,7 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
     obj = Registry.at('Foo.xyz')
     obj.should_not be_nil
     obj.signature.should == 'def xyz(a, b, c)'
+    obj.parameters.should == [[:a, nil], [:b, nil], [:c, nil]]
     obj.source.should == 'foo_bar'
     obj.docstring.should == 'The foo method'
   end

data/spec/handlers/examples/class_condition_handler_001.rb.txt

@@ -58,4 +58,12 @@ class A
   else
     def q; end
   end
+
+  private
+
+  if a == 1
+    def m; end
+  else
+    def mnot; end
+  end
 end

data/spec/handlers/mixin_handler_spec.rb

@@ -17,7 +17,8 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler"
   end
 
   it "should set the type of non-existing modules to :module" do
-    P(:NOTEXIST).type.should == :module
+    o = Registry.at(:X).instance_mixins.find {|o| o.name == :NOTEXIST }
+    o.type.should == :module
   end
 
   it "should handle includes with multiple parameters" do

data/spec/i18n/locale_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::I18n::Locale do
+  def locale(name)
+    YARD::I18n::Locale.new(name)
+  end
+
+  before do
+    @locale = locale("fr")
+  end
+
+  describe "#name" do
+    it "should return name" do
+      locale("fr").name.should == "fr"
+    end
+  end
+
+  describe "#load" do
+    it "should return false for nonexistent PO" do
+      File.should_receive(:exist?).with('foo/fr.po').and_return(false)
+      @locale.load('foo').should == false
+    end
+
+    it "should return true for existent PO" do
+      data = <<-eop
+msgid ""
+msgstr ""
+"Language: fr\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+msgid "Hello"
+msgstr "Bonjour"
+eop
+      parser = GetText::PoParser.new
+      File.should_receive(:exist?).with('foo/fr.po').and_return(true)
+      GetText::PoParser.should_receive(:new).and_return(parser)
+      parser.should_receive(:parse_file) do |file, hash|
+        file.should == 'foo/fr.po'
+        parser.parse(data, hash)
+      end
+      @locale.load('foo').should == true
+      @locale.translate('Hello').should == "Bonjour"
+    end
+  end
+
+  describe "#translate" do
+    before do
+      messages = @locale.instance_variable_get(:@messages)
+      messages["Hello"] = "Bonjour"
+    end
+
+    it "should return translated string for existent string" do
+      @locale.translate("Hello") == "Bonjour"
+    end
+
+    it "should return original string for nonexistent string" do
+      @locale.translate("nonexistent") == "nonexistent"
+    end
+  end
+end

data/spec/i18n/text_spec.rb

@@ -1,71 +1,180 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe YARD::I18n::Text do
-  def extract_messages(input, options={})
-    text = YARD::I18n::Text.new(StringIO.new(input), options)
-    messages = []
-    text.extract_messages do |*message|
-      messages << message
+  describe "#extract_messages" do
+    def extract_messages(input, options={})
+      text = YARD::I18n::Text.new(StringIO.new(input), options)
+      messages = []
+      text.extract_messages do |*message|
+        messages << message
+      end
+      messages
     end
-    messages
-  end
 
-  describe "Header" do
-    it "should extract attribute" do
-      text = <<-eot
+    describe "Header" do
+      it "should extract attribute" do
+        text = <<-eot
 # @title Getting Started Guide
 
 # Getting Started with YARD
 eot
-      extract_messages(text, :have_header => true).should ==
-        [[:attribute, "title", "Getting Started Guide", 1],
-         [:paragraph, "# Getting Started with YARD", 3]]
-    end
+        extract_messages(text, :have_header => true).should ==
+          [[:attribute, "title", "Getting Started Guide", 1],
+           [:paragraph, "# Getting Started with YARD", 3]]
+      end
 
-    it "should ignore markup line" do
-      text = <<-eot
+      it "should ignore markup line" do
+        text = <<-eot
 #!markdown
 # @title Getting Started Guide
 
 # Getting Started with YARD
 eot
-      extract_messages(text, :have_header => true).should ==
-        [[:attribute, "title", "Getting Started Guide", 2],
-         [:paragraph, "# Getting Started with YARD", 4]]
-    end
+        extract_messages(text, :have_header => true).should ==
+          [[:attribute, "title", "Getting Started Guide", 2],
+           [:paragraph, "# Getting Started with YARD", 4]]
+      end
 
-    it "should terminate header block by markup line not at the first line" do
-      text = <<-eot
+      it "should terminate header block by markup line not at the first line" do
+        text = <<-eot
 # @title Getting Started Guide
 #!markdown
 
 # Getting Started with YARD
 eot
-      extract_messages(text, :have_header => true).should ==
-        [[:attribute, "title", "Getting Started Guide", 1],
-         [:paragraph, "#!markdown", 2],
-         [:paragraph, "# Getting Started with YARD", 4]]
+        extract_messages(text, :have_header => true).should ==
+          [[:attribute, "title", "Getting Started Guide", 1],
+           [:paragraph, "#!markdown", 2],
+           [:paragraph, "# Getting Started with YARD", 4]]
+      end
     end
-  end
 
-  describe "Body" do
-    it "should split to paragraphs" do
-      paragraph1 = <<-eop.strip
+    describe "Body" do
+      it "should split to paragraphs" do
+        paragraph1 = <<-eop.strip
 Note that class methods must not be referred to with the "::" namespace
 separator. Only modules, classes and constants should use "::".
 eop
-      paragraph2 = <<-eop.strip
+        paragraph2 = <<-eop.strip
 You can also do lookups on any installed gems. Just make sure to build the
 .yardoc databases for installed gems with:
 eop
-      text = <<-eot
+        text = <<-eot
 #{paragraph1}
 
 #{paragraph2}
 eot
-      extract_messages(text).should ==
-        [[:paragraph, paragraph1, 1],
-         [:paragraph, paragraph2, 4]]
+        extract_messages(text).should ==
+          [[:paragraph, paragraph1, 1],
+           [:paragraph, paragraph2, 4]]
+      end
+    end
+  end
+
+  describe "#translate" do
+    def locale
+      locale = YARD::I18n::Locale.new("fr")
+      messages = locale.instance_variable_get(:@messages)
+      messages["markdown"] = "markdown (markdown in fr)"
+      messages["Hello"] = "Bonjour (Hello in fr)"
+      messages["Paragraph 1."] = "Paragraphe 1."
+      messages["Paragraph 2."] = "Paragraphe 2."
+      locale
+    end
+
+    def translate(input, options={})
+      text = YARD::I18n::Text.new(StringIO.new(input), options)
+      text.translate(locale)
+    end
+
+    describe "Header" do
+      it "should extract attribute" do
+        text = <<-eot
+# @title Hello
+
+# Getting Started with YARD
+
+Paragraph.
+eot
+        translate(text, :have_header => true).should == <<-eot
+# @title Bonjour (Hello in fr)
+
+# Getting Started with YARD
+
+Paragraph.
+eot
+      end
+
+      it "should ignore markup line" do
+        text = <<-eot
+#!markdown
+# @title Hello
+
+# Getting Started with YARD
+
+Paragraph.
+eot
+        translate(text, :have_header => true).should == <<-eot
+#!markdown
+# @title Bonjour (Hello in fr)
+
+# Getting Started with YARD
+
+Paragraph.
+eot
+      end
+    end
+
+    describe "Body" do
+      it "should split to paragraphs" do
+        paragraph1 = <<-eop.strip
+Paragraph 1.
+eop
+        paragraph2 = <<-eop.strip
+Paragraph 2.
+eop
+        text = <<-eot
+#{paragraph1}
+
+#{paragraph2}
+eot
+        translate(text).should == <<-eot
+Paragraphe 1.
+
+Paragraphe 2.
+eot
+      end
+
+      it "should not modified non-translated message" do
+        nonexistent_paragraph = <<-eop.strip
+Nonexsitent paragraph.
+eop
+        text = <<-eot
+#{nonexistent_paragraph}
+eot
+        translate(text).should == <<-eot
+#{nonexistent_paragraph}
+eot
+      end
+
+      it "should keep empty lines" do
+        text = <<-eot
+Paragraph 1.
+
+  
+	
+
+Paragraph 2.
+eot
+        translate(text).should == <<-eot
+Paragraphe 1.
+
+  
+	
+
+Paragraphe 2.
+eot
+      end
     end
   end
 end

data/spec/logging_spec.rb

@@ -11,4 +11,25 @@ describe YARD::Logger do
       log.show_backtraces.should == false
     end
   end
+
+  describe '#backtrace' do
+    before { log.show_backtraces = true }
+    after { log.show_backtraces = false }
+
+    it "should log backtrace in error by default" do
+      log.should_receive(:error).with("RuntimeError: foo")
+      log.should_receive(:error).with("Stack trace:\n\tline1\n\tline2\n")
+      exc = RuntimeError.new("foo")
+      exc.set_backtrace(['line1', 'line2'])
+      log.enter_level(Logger::INFO) { log.backtrace(exc) }
+    end
+
+    it "should allow backtrace to be entered in other modes" do
+      log.should_receive(:warn).with("RuntimeError: foo")
+      log.should_receive(:warn).with("Stack trace:\n\tline1\n\tline2\n")
+      exc = RuntimeError.new("foo")
+      exc.set_backtrace(['line1', 'line2'])
+      log.enter_level(Logger::INFO) { log.backtrace(exc, :warn) }
+    end
+  end
 end

data/spec/parser/c_parser_spec.rb

@@ -85,6 +85,42 @@ describe YARD::Parser::C::CParser do
         constant.docstring.should == "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
       end
     end
+
+    describe 'Macros' do
+      it "should handle param## inside of macros" do
+        thr = Thread.new do
+          parse <<-eof
+          void
+          Init_gobject_gparamspecs(void)
+          {
+              VALUE cParamSpec = GTYPE2CLASS(G_TYPE_PARAM);
+              VALUE c;
+
+          #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
+            G_STMT_START {\
+              rbg_define_method(c, "initialize", typename##_initialize, 7); \
+              rbg_define_method(c, "minimum", typename##_minimum, 0); \
+              rbg_define_method(c, "maximum", typename##_maximum, 0); \
+              rbg_define_method(c, "range", typename##_range, 0); \
+            } G_STMT_END
+
+          #if 0
+              rbg_define_method(c, "default_value", typename##_default_value, 0); \
+              rb_define_alias(c, "default", "default_value"); \
+
+          #endif
+
+              c = G_DEF_CLASS(G_TYPE_PARAM_CHAR, "Char", cParamSpec);
+              DEF_NUMERIC_PSPEC_METHODS(c, char);
+          eof
+        end
+        thr.join(5)
+        if thr.alive?
+          fail "Did not parse in time"
+          thr.kill
+        end
+      end
+    end
   end
 
   describe 'Override comments' do

data/spec/parser/source_parser_spec.rb

@@ -465,7 +465,7 @@ describe YARD::Parser::SourceParser do
     end
 
     it "should parse a set of absolute paths" do
-      Dir.should_not_receive(:[]).and_return([])
+      Dir.should_not_receive(:[])
       File.should_receive(:file?).with('/path/to/file').and_return(true)
       File.should_receive(:read_binary).with('/path/to/file').and_return("")
       YARD.parse('/path/to/file')
@@ -594,13 +594,16 @@ describe YARD::Parser::SourceParser do
     end
 
     it "should attempt to parse files in order" do
-      msgs = []
-      log.should_receive(:debug) {|m| msgs << m }.at_least(:once)
-      in_order_parse 'parse_in_order_001', 'parse_in_order_002'
-      msgs[1].should =~ /Processing .+parse_in_order_001.+/
-      msgs[2].should =~ /Missing object MyModule/
-      msgs[3].should =~ /Processing .+parse_in_order_002.+/
-      msgs[4].should =~ /Re-processing .+parse_in_order_001.+/
+      log.enter_level(Logger::DEBUG) do
+        msgs = []
+        log.should_receive(:debug) {|m| msgs << m }.at_least(:once)
+        log.stub(:<<)
+        in_order_parse 'parse_in_order_001', 'parse_in_order_002'
+        msgs[1].should =~ /Parsing .+parse_in_order_001.+/
+        msgs[2].should =~ /Missing object MyModule/
+        msgs[3].should =~ /Parsing .+parse_in_order_002.+/
+        msgs[4].should =~ /Re-processing .+parse_in_order_001.+/
+      end
     end
 
     it "should attempt to order files by length (process toplevel files first)" do

data/spec/registry_spec.rb

@@ -169,6 +169,32 @@ describe YARD::Registry do
       Registry.resolve(P('MyObject'), '#foo', true).should be_nil
     end
 
+    it "should allow type=:typename to ensure resolved object is of a certain type" do
+      YARD.parse_string "class Foo; end"
+      Registry.resolve(Registry.root, 'Foo').should == Registry.at('Foo')
+      Registry.resolve(Registry.root, 'Foo', false, false, :method).should be_nil
+    end
+
+    it "should allow keep trying to find obj where type equals object type" do
+      YARD.parse_string <<-eof
+        module Foo
+          class Bar; end
+          def self.Bar; end
+        end
+      eof
+      Registry.resolve(P('Foo'), 'Bar').should == Registry.at('Foo::Bar')
+      Registry.resolve(P('Foo'), 'Bar', false, false, :method).should == 
+        Registry.at('Foo.Bar')
+    end
+
+    it "should return proxy fallback with given type if supplied" do
+      YARD.parse_string "module Foo; end"
+      proxy = Registry.resolve(P('Foo'), 'Bar', false, true, :method)
+      proxy.type.should == :method
+      proxy = Registry.resolve(P('Qux'), 'Bar', false, true, :method)
+      proxy.type.should == :method
+    end
+
     it "should only check 'Path' in lookup on root namespace" do
       Registry.should_receive(:at).once.with('Test').and_return(true)
       Registry.resolve(Registry.root, "Test")