challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/yard-0.8.6.1/spec/i18n/pot_generator_spec.rb

@@ -0,0 +1,262 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::I18n::PotGenerator do
+  def create_messages(messages)
+    yard_messages = YARD::I18n::Messages.new
+    add_messages(yard_messages, messages)
+    yard_messages
+  end
+
+  def add_messages(yard_messages, messages)
+    messages.each do |id, properties|
+      yard_message = yard_messages.register(id)
+      (properties[:locations] || []).each do |path, line|
+        yard_message.add_location(path, line)
+      end
+      (properties[:comments] || []).each do |comment|
+        yard_message.add_comment(comment)
+      end
+    end
+  end
+
+  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")
+      messages = {
+        "tag|see|Parser::SourceParser.parse" => {
+          :locations => [["yard.rb", 14]],
+          :comments => ["@see"],
+        },
+        "Parses a path or set of paths" => {
+          :locations => [["yard.rb", 12], ["yard/parser/source_parser.rb", 83]],
+          :comments => ["YARD.parse", "YARD::Parser::SourceParser.parse"],
+        }
+      }
+      add_messages(@generator.messages, messages)
+      @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_id)
+      pot = ""
+      message = YARD::I18n::Message.new(message_id)
+      @generator.send(:generate_message, pot, message)
+      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 == create_messages({
+        "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 == create_messages({
+        "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 == create_messages({
+        "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 == create_messages({
+        "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 == create_messages({
+        "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 == create_messages({
+        "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 == create_messages({
+        paragraph1 => {
+          :locations => [[path, 1]],
+          :comments => [],
+        },
+        paragraph2 => {
+          :locations => [[path, 4]],
+          :comments => [],
+        }
+      })
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/i18n/text_spec.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::I18n::Text do
+  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
+
+    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
+
+  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/vendor/bundle/gems/yard-0.8.6.1/spec/logging_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe YARD::Logger do
+  describe '#show_backtraces' do
+    it "should be true if debug level is on" do
+      log.show_backtraces = true
+      log.enter_level(Logger::DEBUG) do
+        log.show_backtraces = false
+        log.show_backtraces.should == true
+      end
+      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/vendor/bundle/gems/yard-0.8.6.1/spec/options_spec.rb

@@ -0,0 +1,171 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Options do
+  class FooOptions < YARD::Options
+    attr_accessor :foo
+    def initialize; self.foo = "abc" end
+  end
+
+  describe '.default_attr' do
+    it "should allow default attributes to be defined with symbols" do
+      class DefaultOptions1 < YARD::Options
+        default_attr :foo, 'HELLO'
+      end
+      o = DefaultOptions1.new
+      o.reset_defaults
+      o.foo.should == 'HELLO'
+    end
+
+    it "should call lambda if value is a Proc" do
+      class DefaultOptions2 < YARD::Options
+        default_attr :foo, lambda { 100 }
+      end
+      o = DefaultOptions2.new
+      o.reset_defaults
+      o.foo.should == 100
+    end
+  end
+
+  describe '#reset_defaults' do
+    it "should not define defaults until reset is called" do
+      class ResetDefaultOptions1 < YARD::Options
+        default_attr :foo, 'FOO'
+      end
+      ResetDefaultOptions1.new.foo.should be_nil
+      o = ResetDefaultOptions1.new
+      o.reset_defaults
+      o.foo.should == 'FOO'
+    end
+
+    it "should use defaults from superclass as well" do
+      class ResetDefaultOptions2 < YARD::Options
+        default_attr :foo, 'FOO'
+      end
+      class ResetDefaultOptions3 < ResetDefaultOptions2
+      end
+      o = ResetDefaultOptions3.new
+      o.reset_defaults
+      o.foo.should == 'FOO'
+    end
+  end
+
+  describe '#delete' do
+    it "should delete an option" do
+      o = FooOptions.new
+      o.delete(:foo)
+      o.to_hash.should == {}
+    end
+
+    it "should not error if an option is deleted that does not exist" do
+      o = FooOptions.new
+      o.delete(:foo)
+      o.delete(:foo)
+      o.to_hash.should == {}
+    end
+  end
+
+  describe '#[]' do
+    it "should handle getting option values using hash syntax" do
+      FooOptions.new[:foo].should == "abc"
+    end
+  end
+
+  describe '#[]=' do
+    it "should handle setting options using hash syntax" do
+      o = FooOptions.new
+      o[:foo] = "xyz"
+      o[:foo].should == "xyz"
+    end
+
+    it "should allow setting of unregistered keys" do
+      o = FooOptions.new
+      o[:bar] = "foo"
+      o[:bar].should == "foo"
+    end
+  end
+
+  describe '#method_missing' do
+    it "should allow setting of unregistered keys" do
+      o = FooOptions.new
+      o.bar = 'foo'
+      o.bar.should == 'foo'
+    end
+
+    it "should allow getting values of unregistered keys (return nil)" do
+      FooOptions.new.bar.should be_nil
+    end
+
+    it "should print debugging messages about unregistered keys" do
+      log.should_receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
+      FooOptions.new.bar
+      log.should_receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
+      FooOptions.new.bar = 1
+    end
+  end
+
+  describe '#update' do
+    it "should allow updating of options" do
+      FooOptions.new.update(:foo => "xyz").foo.should == "xyz"
+    end
+
+    it "should not ignore keys with no setter (OpenStruct behaviour)" do
+      o = FooOptions.new
+      o.update(:bar => "xyz")
+      o.to_hash.should == {:foo => "abc", :bar => "xyz"}
+    end
+  end
+
+  describe '#merge' do
+    it "should update a new object" do
+      o = FooOptions.new
+      o.merge(:foo => "xyz").object_id.should_not == o.object_id
+      o.merge(:foo => "xyz").to_hash.should == {:foo => "xyz"}
+    end
+
+    it "should add in values from original object" do
+      o = FooOptions.new
+      o.update(:bar => "foo")
+      o.merge(:baz => 1).to_hash.should == {:foo => "abc", :bar => "foo", :baz => 1}
+    end
+  end
+
+  describe '#to_hash' do
+    it "should convert all instance variables and symbolized keys" do
+      class ToHashOptions1 < YARD::Options
+        attr_accessor :foo, :bar, :baz
+        def initialize; @foo = 1; @bar = 2; @baz = "hello" end
+      end
+      o = ToHashOptions1.new
+      hash = o.to_hash
+      hash.keys.should include(:foo, :bar, :baz)
+      hash[:foo].should == 1
+      hash[:bar].should == 2
+      hash[:baz].should == "hello"
+    end
+
+    it "should use accessor when converting values to hash" do
+      class ToHashOptions2 < YARD::Options
+        def initialize; @foo = 1 end
+        def foo; "HELLO#{@foo}" end
+      end
+      o = ToHashOptions2.new
+      o.to_hash.should == {:foo => "HELLO1"}
+    end
+
+    it "should ignore ivars with no accessor" do
+      class ToHashOptions3 < YARD::Options
+        attr_accessor :foo
+        def initialize; @foo = 1; @bar = "NOIGNORE" end
+      end
+      o = ToHashOptions3.new
+      o.to_hash.should == {:foo => 1, :bar => "NOIGNORE"}
+    end
+  end
+
+  describe '#tap' do
+    it "should support #tap(&block) (even in 1.8.6)" do
+      o = FooOptions.new.tap {|o| o.foo = :BAR }
+      o.to_hash.should == {:foo => :BAR}
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/parser/base_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe YARD::Parser::Base do
+  describe '#initialize' do
+    class MyParser < Parser::Base; def initialize(a, b) end end
+
+    it "should take 2 arguments" do
+      lambda { YARD::Parser::Base.new }.should raise_error(ArgumentError,
+        /wrong (number|#) of arguments|given 0, expected 2/)
+    end
+
+    it "should raise NotImplementedError on #initialize" do
+      lambda { YARD::Parser::Base.new('a', 'b') }.should raise_error(NotImplementedError)
+    end
+
+    it "should raise NotImplementedError on #parse" do
+      lambda { MyParser.new('a', 'b').parse }.should raise_error(NotImplementedError)
+    end
+
+    it "should raise NotImplementedError on #tokenize" do
+      lambda { MyParser.new('a', 'b').tokenize }.should raise_error(NotImplementedError)
+    end
+  end
+end