yard 0.7.5 → 0.8.0

data/spec/handlers/ruby/legacy/base_spec.rb

@@ -6,13 +6,17 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
   before do
     Handlers::Ruby::Legacy::Base.stub!(:inherited)
     Handlers::Ruby::Legacy::MixinHandler.stub!(:inherited) # fixes a Ruby1.9 issue
-    @processor = Handlers::Processor.new(nil, false, :ruby18)
+    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby18))
   end
-  
+
+  after(:all) do
+    Handlers::Base.clear_subclasses
+  end
+
   def stmt(string)
     Statement.new(TokenList.new(string))
   end
-  
+
   it "should only handle Handlers inherited from Ruby::Legacy::Base class" do
     class IgnoredHandler < Handlers::Base
       handles "hello"
@@ -50,7 +54,7 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
     TestTokenHandler.handles?(stmt("module")).should be_true
     TestTokenHandler.handles?(stmt("if")).should be_false
   end
-  
+
   it "should parse a do/end or { } block with #parse_block" do
     class MyBlockHandler < Handlers::Ruby::Legacy::Base
       handles /\AmyMethod\b/
@@ -58,14 +62,14 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
         parse_block(:owner => "test")
       end
     end
-    
+
     class MyBlockInnerHandler < Handlers::Ruby::Legacy::Base
       handles "inner"
       def self.reset; @@reached = false end
       def self.reached?; @@reached ||= false end
       def process; @@reached = true end
     end
-    
+
     Handlers::Base.stub!(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
     Parser::SourceParser.parser_type = :ruby18
     Parser::SourceParser.parse_string "myMethod do inner end"
@@ -75,4 +79,4 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
     MyBlockInnerHandler.should be_reached
     Parser::SourceParser.parser_type = :ruby
   end
-end
+end

data/spec/handlers/spec_helper.rb

@@ -17,7 +17,7 @@ end
 class StubbedProcessor < Processor
   def process(statements)
     statements.each_with_index do |stmt, index|
-      find_handlers(stmt).each do |handler| 
+      find_handlers(stmt).each do |handler|
         handler.new(self, stmt).process
       end
     end
@@ -27,8 +27,7 @@ end
 class StubbedSourceParser < Parser::SourceParser
   StubbedSourceParser.parser_type = :ruby
   def post_process
-    post = StubbedProcessor.new(@file, @load_order_errors, @parser_type, @globals)
+    post = StubbedProcessor.new(self)
     post.process(@parser.enumerator)
   end
 end
-  

data/spec/handlers/visibility_handler_spec.rb

@@ -2,32 +2,32 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
   before(:all) { parse_file :visibility_handler_001, __FILE__ }
-  
+
   it "should be able to set visibility to public" do
     Registry.at("Testing#pub").visibility.should == :public
     Registry.at("Testing#pub2").visibility.should == :public
   end
-  
+
   it "should be able to set visibility to private" do
     Registry.at("Testing#priv").visibility.should == :private
   end
-  
+
   it "should be able to set visibility to protected" do
     Registry.at("Testing#prot").visibility.should == :protected
   end
-  
+
   it "should support parameters and only set visibility on those methods" do
     Registry['Testing#notpriv'].visibility.should == :protected
     Registry['Testing#notpriv2'].visibility.should == :protected
     Registry['Testing#notpriv?'].visibility.should == :protected
   end
-  
+
   it "should only accept strings and symbols" do
     Registry.at('Testing#name').should be_nil
     Registry.at('Testing#argument').should be_nil
     Registry.at('Testing#method_call').should be_nil
   end
-  
+
   it "should handle constants passed in as symbols" do
     Registry.at('Testing#Foo').visibility.should == :private
   end

data/spec/handlers/yield_handler_spec.rb

@@ -2,17 +2,17 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
   before(:all) { parse_file :yield_handler_001, __FILE__ }
-  
+
   it "should only parse yield blocks in methods" do
     P(:Testing).tag(:yield).should be_nil
     P(:Testing).tag(:yieldparam).should be_nil
   end
-  
+
   it "should handle an empty yield statement" do
     P('Testing#mymethod').tag(:yield).should be_nil
     P('Testing#mymethod').tag(:yieldparam).should be_nil
   end
-  
+
   it "should not document a yield statement in a method with either @yield or @yieldparam" do
     P('Testing#mymethod2').tag(:yield).types.should == ['a', 'b']
     P('Testing#mymethod2').tag(:yield).text.should == "Blah"
@@ -24,25 +24,25 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler"
     P('Testing#mymethod4').tag(:yieldparam).name.should == '_self'
     P('Testing#mymethod4').tag(:yieldparam).text.should == 'BLAH'
   end
-  
+
   it "should handle any arbitrary yield statement" do
     P('Testing#mymethod5').tag(:yield).types.should == [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
   end
-  
+
   it "should handle parentheses" do
     P('Testing#mymethod6').tag(:yield).types.should == ['b', 'a']
   end
-  
+
   it "should only document the first yield statement in a method (limitation of yield handler)" do
     P('Testing#mymethod7').tag(:yield).types.should == ['a']
   end
-  
+
   it "should handle `self` keyword and list object type as yieldparam for _self" do
     P('Testing#mymethod8').tag(:yield).types.should == ['_self']
     P('Testing#mymethod8').tag(:yieldparam).types.should == ['Testing']
     P('Testing#mymethod8').tag(:yieldparam).text.should == "the object that the method was called on"
   end
-  
+
   it "should handle `super` keyword and document it under _super" do
     P('Testing#mymethod9').tag(:yield).types.should == ['_super']
     P('Testing#mymethod9').tag(:yieldparam).types.should be_nil

data/spec/i18n/pot_generator_spec.rb

@@ -0,0 +1,244 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::I18n::PotGenerator do
+  before do
+    @generator = YARD::I18n::PotGenerator.new("..")
+  end
+
+  describe "Generate" do
+    it "should generate the default header" do
+      @generator.generate.should == <<-'eoh'
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2011-11-20 22:17+0900\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+eoh
+    end
+
+    it "should generate messages in location order" do
+      @generator.stub!(:header).and_return("HEADER\n\n")
+      @generator.messages["tag|see|Parser::SourceParser.parse"] = {
+        :locations => [["yard.rb", 14]],
+        :comments => ["@see"],
+      }
+      @generator.messages["Parses a path or set of paths"] = {
+        :locations => [["yard.rb", 12], ["yard/parser/source_parser.rb", 83]],
+        :comments => ["YARD.parse", "YARD::Parser::SourceParser.parse"],
+      }
+      @generator.generate.should == <<-'eoh'
+HEADER
+
+# YARD.parse
+# YARD::Parser::SourceParser.parse
+#: ../yard.rb:12
+#: ../yard/parser/source_parser.rb:83
+msgid "Parses a path or set of paths"
+msgstr ""
+
+# @see
+#: ../yard.rb:14
+msgid "tag|see|Parser::SourceParser.parse"
+msgstr ""
+
+eoh
+    end
+  end
+
+  describe "Escape" do
+    def generate_message_pot(message)
+      pot = ""
+      options = {
+        :comments => [],
+        :locations => [],
+      }
+      @generator.send(:generate_message, pot, message, options)
+      pot
+    end
+
+    it "should escape <\\>" do
+      generate_message_pot("hello \\ world").should == <<-'eop'
+msgid "hello \\ world"
+msgstr ""
+
+eop
+    end
+
+    it "should escape <\">" do
+      generate_message_pot("hello \" world").should == <<-'eop'
+msgid "hello \" world"
+msgstr ""
+
+eop
+    end
+
+    it "should escape <\\n>" do
+      generate_message_pot("hello \n world").should == <<-'eop'
+msgid "hello \n"
+" world"
+msgstr ""
+
+eop
+    end
+  end
+
+  describe "Object" do
+    before do
+      Registry.clear
+      @yard = YARD::CodeObjects::ModuleObject.new(:root, :YARD)
+    end
+
+    it "should extract docstring" do
+      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
+        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
+      end
+      @generator.parse_objects([object])
+      @generator.messages.should == {
+        "An alias to {Parser::SourceParser}'s parsing method" => {
+          :locations => [],
+          :comments => ["YARD.parse"],
+        }
+      }
+    end
+
+    it "should extract location" do
+      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
+        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
+        o.files = [["yard.rb", 12]]
+      end
+      @generator.parse_objects([object])
+      @generator.messages.should == {
+        "An alias to {Parser::SourceParser}'s parsing method" => {
+          :locations => [["yard.rb", 13]],
+          :comments => ["YARD.parse"],
+        }
+      }
+    end
+
+    it "should extract tag name" do
+      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
+        o.docstring = "@see Parser::SourceParser.parse"
+        o.files = [["yard.rb", 12]]
+      end
+      @generator.parse_objects([object])
+      @generator.messages.should == {
+        "tag|see|Parser::SourceParser.parse" => {
+          :locations => [["yard.rb", 12]],
+          :comments => ["@see"],
+        },
+      }
+    end
+
+    it "should extract tag text" do
+      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
+        o.docstring = <<-eod
+@example Parse a glob of files
+  YARD.parse('lib/**/*.rb')
+eod
+        o.files = [["yard.rb", 12]]
+      end
+      @generator.parse_objects([object])
+      @generator.messages.should == {
+        "tag|example|Parse a glob of files" => {
+          :locations => [["yard.rb", 12]],
+          :comments => ["@example"],
+        },
+        "YARD.parse('lib/**/*.rb')" => {
+          :locations => [["yard.rb", 12]],
+          :comments => ["@example Parse a glob of files"],
+        }
+      }
+    end
+
+    it "should extract tag types" do
+      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
+        o.docstring = <<-eod
+@param [String, Array<String>] paths a path, glob, or list of paths to
+  parse
+eod
+        o.files = [["yard.rb", 12]]
+      end
+      @generator.parse_objects([object])
+      @generator.messages.should == {
+        "tag|param|paths" => {
+          :locations => [["yard.rb", 12]],
+          :comments => ["@param [String, Array<String>]"],
+        },
+        "a path, glob, or list of paths to\nparse" => {
+          :locations => [["yard.rb", 12]],
+          :comments => ["@param [String, Array<String>] paths"],
+        }
+      }
+    end
+  end
+
+  describe "File" do
+    it "should extract attribute" do
+      path = "GettingStarted.md"
+      text = <<-eor
+# @title Getting Started Guide
+
+# Getting Started with YARD
+eor
+      File.stub!(:open).with(path).and_yield(StringIO.new(text))
+      File.stub!(:read).with(path).and_return(text)
+      file = YARD::CodeObjects::ExtraFileObject.new(path)
+      @generator.parse_files([file])
+      @generator.messages.should == {
+        "Getting Started Guide" => {
+          :locations => [[path, 1]],
+          :comments => ["title"],
+        },
+        "# Getting Started with YARD" => {
+          :locations => [[path, 3]],
+          :comments => [],
+        }
+      }
+    end
+
+    it "should extract paragraphs" do
+      path = "README.md"
+      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
+You can also do lookups on any installed gems. Just make sure to build the
+.yardoc databases for installed gems with:
+eop
+      text = <<-eot
+#{paragraph1}
+
+#{paragraph2}
+eot
+      File.stub!(:open).with(path).and_yield(StringIO.new(text))
+      File.stub!(:read).with(path).and_return(text)
+      file = YARD::CodeObjects::ExtraFileObject.new(path)
+      @generator.parse_files([file])
+      @generator.messages.should == {
+        paragraph1 => {
+          :locations => [[path, 1]],
+          :comments => [],
+        },
+        paragraph2 => {
+          :locations => [[path, 4]],
+          :comments => [],
+        }
+      }
+    end
+  end
+end

data/spec/i18n/text_spec.rb

@@ -0,0 +1,69 @@
+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
+    end
+    messages
+  end
+
+  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
+
+    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
+
+    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]]
+    end
+  end
+
+  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
+You can also do lookups on any installed gems. Just make sure to build the
+.yardoc databases for installed gems with:
+eop
+      text = <<-eot
+#{paragraph1}
+
+#{paragraph2}
+eot
+      extract_messages(text).should ==
+        [[:paragraph, paragraph1, 1],
+         [:paragraph, paragraph2, 4]]
+    end
+  end
+end