nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/serializers/data/serialized_yardoc/checksums

@@ -0,0 +1 @@
+test.rb 80e5834ff1e98223761615c0917ff9b77b7ae057

data/vendor/bundle/gems/yard-0.7.4/spec/serializers/data/serialized_yardoc/proxy_types

@@ -0,0 +1,2 @@
+{I"Object:EF:
+class

data/vendor/bundle/gems/yard-0.7.4/spec/serializers/file_system_serializer_spec.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'stringio'
+
+describe YARD::Serializers::FileSystemSerializer do
+  before do
+    FileUtils.stub!(:mkdir_p)
+    File.stub!(:open)
+  end
+  
+  describe '#basepath' do
+    it "should default the base path to the 'doc/'" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.basepath.should == 'doc'
+    end
+  end
+
+  describe '#extension' do
+    it "should default the file extension to .html" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.extension.should == "html"
+    end
+  end
+  
+  describe '#serialized_path' do
+    it "should allow no extension to be used" do
+      obj = Serializers::FileSystemSerializer.new :extension => nil
+      yard = CodeObjects::ClassObject.new(nil, :FooBar)
+      obj.serialized_path(yard).should == 'FooBar'
+    end
+
+    it "should serialize to top-level-namespace for root" do
+      obj = Serializers::FileSystemSerializer.new :extension => nil
+      obj.serialized_path(Registry.root).should == "top-level-namespace"
+    end
+
+    it "should return serialized_path for a String" do
+      s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
+      s.serialized_path('test.txt').should == 'test.txt'
+    end
+    
+    it "should remove special chars from path" do
+      m = CodeObjects::MethodObject.new(nil, 'a')
+      s = Serializers::FileSystemSerializer.new
+
+      { :/ => '_2F_i.html',
+        :gsub! => 'gsub_21_i.html', 
+        :ask? => 'ask_3F_i.html', 
+        :=== => '_3D_3D_3D_i.html', 
+        :+ => '_2B_i.html', 
+        :- => '-_i.html', 
+        :[]= => '_5B_5D_3D_i.html',
+        :<< => '_3C_3C_i.html',
+        :>= => '_3E_3D_i.html',
+        :` => '_60_i.html',
+        :& => '_26_i.html',
+        :* => '_2A_i.html',
+        :| => '_7C_i.html',
+        :/ => '_2F_i.html',
+        :=~ => '_3D_7E_i.html'
+      }.each do |meth, value|
+        m.stub!(:name).and_return(meth)
+        s.serialized_path(m).should == value
+      end
+    end
+    
+    it "should handle ExtraFileObject's" do
+      s = Serializers::FileSystemSerializer.new
+      e = CodeObjects::ExtraFileObject.new('filename.txt', '')
+      s.serialized_path(e).should == 'file.filename.html'
+    end
+
+    it "should differentiate instance and class methods from serialized path" do
+      s = Serializers::FileSystemSerializer.new
+      m1 = CodeObjects::MethodObject.new(nil, 'meth')
+      m2 = CodeObjects::MethodObject.new(nil, 'meth', :class)
+      s.serialized_path(m1).should_not == s.serialized_path(m2)
+    end
+    
+    it "should serialize path from overload tag" do
+      YARD.parse_string <<-'eof'
+        class Foo
+          # @overload bar
+          def bar; end
+        end
+      eof
+      
+      serializer = Serializers::FileSystemSerializer.new
+      object = Registry.at('Foo#bar').tag(:overload)
+      serializer.serialized_path(object).should == "Foo/bar_i.html"
+    end
+  end
+  
+  describe '#serialize' do
+    it "should serialize to the correct path" do
+      yard = CodeObjects::ClassObject.new(nil, :FooBar)
+      meth = CodeObjects::MethodObject.new(yard, :baz, :class)
+      meth2 = CodeObjects::MethodObject.new(yard, :baz)
+
+      { 'foo/FooBar/baz_c.txt' => meth,
+        'foo/FooBar/baz_i.txt' => meth2,
+        'foo/FooBar.txt' => yard }.each do |path, obj|
+        io = StringIO.new
+        File.should_receive(:open).with(path, 'wb').and_yield(io)
+        io.should_receive(:write).with("data")
+
+        s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
+        s.serialize(obj, "data")
+      end
+    end
+
+    it "should guarantee the directory exists" do
+      o1 = CodeObjects::ClassObject.new(nil, :Really)
+      o2 = CodeObjects::ClassObject.new(o1, :Long)
+      o3 = CodeObjects::ClassObject.new(o2, :PathName)
+      obj = CodeObjects::MethodObject.new(o3, :foo)
+
+      FileUtils.should_receive(:mkdir_p).once.with('doc/Really/Long/PathName')
+
+      s = Serializers::FileSystemSerializer.new
+      s.serialize(obj, "data")
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/serializers/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+include YARD

data/vendor/bundle/gems/yard-0.7.4/spec/serializers/yardoc_serializer_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+instance_eval do
+  class YARD::Serializers::YardocSerializer
+    public :dump
+    public :internal_dump
+  end
+end
+
+describe YARD::Serializers::YardocSerializer do
+  before do
+    @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
+
+    Registry.clear
+    @foo = CodeObjects::ClassObject.new(:root, :Foo)
+    @bar = CodeObjects::MethodObject.new(@foo, :bar)
+  end
+
+  describe '#dump' do
+    it "should maintain object equality when loading a dumped object" do
+      newfoo = @serializer.internal_dump(@foo)
+      newfoo.should equal(@foo)
+      newfoo.should == @foo
+      @foo.should equal(newfoo)
+      @foo.should == newfoo
+      newfoo.hash.should == @foo.hash
+    end
+    
+    it "should maintain hash key equality when loading a dumped object" do
+      newfoo = @serializer.internal_dump(@foo)
+      {@foo => 1}.should have_key(newfoo)
+      {newfoo => 1}.should have_key(@foo)
+    end
+  end
+  
+  describe '#serialize' do
+    it "should accept a hash of codeobjects (and write to root)" do
+      data = {:root => Registry.root}
+      marshaldata = Marshal.dump(data)
+      filemock = mock(:file)
+      filemock.should_receive(:write).with(marshaldata)
+      File.should_receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
+      @serializer.serialize(data)
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/server/adapter_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::Adapter do
+  after(:all) { Server::Adapter.shutdown }
+
+  describe '#add_library' do
+    it "should add a library" do
+      lib = LibraryVersion.new('yard')
+      a = Adapter.new({})
+      a.libraries.should be_empty
+      a.add_library(lib)
+      a.libraries['yard'].should == [lib]
+    end
+  end
+  
+  describe '#start' do
+    it "should not implement #start" do
+      lambda { Adapter.new({}).start }.should raise_error(NotImplementedError)
+    end
+  end
+  
+  describe '.setup' do
+    it 'should add template paths and helpers' do
+      Adapter.setup
+      Templates::Template.extra_includes.should include(DocServerHelper)
+      Templates::Engine.template_paths.should include(YARD::ROOT + '/yard/server/templates')
+    end
+  end
+  
+  describe '.shutdown' do
+    it 'should cleanup template paths and helpers' do
+      Adapter.setup
+      Adapter.shutdown
+      Templates::Template.extra_includes.should_not include(DocServerHelper)
+      Templates::Engine.template_paths.should_not include(YARD::ROOT + '/yard/server/templates')
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/server/commands/base_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class MyProcCommand < Base
+  def initialize(&block) self.class.send(:define_method, :run, &block) end
+end
+
+class MyCacheCommand < Base
+  def run; cache 'foo' end
+end
+
+describe YARD::Server::Commands::Base do
+  describe '#cache' do
+    before do
+      @command = MyCacheCommand.new(:adapter => mock_adapter, :caching => true)
+      @command.request = OpenStruct.new
+    end
+
+    it "should not cache if caching == false" do
+      File.should_not_receive(:open)
+      @command.caching = false
+      @command.run
+    end
+    
+    it "should require document root to cache" do
+      File.should_not_receive(:open)
+      @command.adapter.document_root = nil
+      @command.run
+    end
+    
+    it "should cache to path/to/file.html and create directories" do
+      FileUtils.should_receive(:mkdir_p).with('/public/path/to')
+      File.should_receive(:open).with('/public/path/to/file.html', anything)
+      @command.request.path = '/path/to/file.html'
+      @command.run
+    end
+  end
+  
+  describe '#redirect' do
+    it "should return a valid redirection" do
+      cmd = MyProcCommand.new { redirect '/foo' }
+      cmd.call(mock_request('/foo')).should == 
+        [302, {"Content-Type" => "text/html", "Location" => "/foo"}, [""]]
+    end
+  end
+  
+  describe '#call' do
+    it "should handle a NotFoundError and use message as body" do
+      cmd = MyProcCommand.new { raise NotFoundError, "hello world" }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["hello world"]
+    end
+
+    it "should not use message as body if not provided in NotFoundError" do
+      cmd = MyProcCommand.new { raise NotFoundError }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["Not found: /foo"]
+    end
+
+    it "should handle 404 status code from #run" do
+      cmd = MyProcCommand.new { self.status = 404 }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["Not found: /foo"]
+    end
+    
+    it "should not override body if status is 404 and body is defined" do
+      cmd = MyProcCommand.new { self.body = "foo"; self.status = 404 }
+      s, h, b = *cmd.call(mock_request('/bar'))
+      s.should == 404
+      b.should == ['foo']
+    end
+    
+    it "should handle body as Array" do
+      cmd = MyProcCommand.new { self.body = ['a', 'b', 'c'] }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      b.should == %w(a b c)
+    end
+    
+    it "should allow headers to be defined" do
+      cmd = MyProcCommand.new { self.headers['Foo'] = 'BAR' }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      h['Foo'].should == 'BAR'
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/server/commands/library_command_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ostruct'
+
+describe YARD::Server::Commands::LibraryCommand do
+  before do
+    Templates::Engine.stub!(:render)
+    Templates::Engine.stub!(:generate)
+    YARD.stub!(:parse)
+    Registry.stub!(:load)
+    Registry.stub!(:save)
+
+    @cmd = LibraryCommand.new(:adapter => mock_adapter)
+    @request = OpenStruct.new(:xhr? => false, :path => "/foo")
+    @library = OpenStruct.new(:source_path => '.')
+    @cmd.library = @library
+    @cmd.stub!(:load_yardoc).and_return(nil)
+  end
+  
+  def call
+    lambda { @cmd.call(@request) }.should raise_error(NotImplementedError)
+  end
+  
+  describe "#call" do
+    it "should raise NotImplementedError" do
+      call
+    end
+    
+    it "should set :rdoc as the default markup in incremental mode" do
+      @cmd.incremental = true
+      call
+      @cmd.options[:markup].should == :rdoc
+    end
+
+    it "should set :rdoc as the default markup in regular mode" do
+      call
+      @cmd.options[:markup].should == :rdoc
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/server/commands/static_file_command_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Server::Commands::StaticFileCommand do
+  before do
+    adapter = mock_adapter
+    adapter.document_root = '/c'
+    @cmd = StaticFileCommand.new(:adapter => adapter)
+  end
+  
+  describe '#run' do
+    def run(path, status = nil, body = nil)
+      s, h, b = *@cmd.call(mock_request(path))
+      body.should == b.first if body
+      status.should == s if status
+      [s, h, b]
+    end
+    
+    it "should search through document root before static paths" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.reverse.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run '/path/to/file.txt'
+    end
+    
+    it "should return file contents if found" do
+      path = File.join(StaticFileCommand::STATIC_PATHS.last, '/path/to/file.txt')
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      File.should_receive(:exist?).with(path).and_return(true)
+      File.should_receive(:read).with(path).and_return('FOO')
+      run('/path/to/file.txt', 200, 'FOO')
+    end
+    
+    it "should allow registering of new paths and use those before other static paths" do
+      Server.register_static_path '/foo'
+      path = '/foo/path/to/file.txt'
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      File.should_receive(:exist?).with(path).and_return(true)
+      File.should_receive(:read).with(path).and_return('FOO')
+      run('/path/to/file.txt', 200, 'FOO')
+    end
+
+    it "should not use registered path before docroot" do
+      Server.register_static_path '/foo'
+      path = '/foo/path/to/file.txt'
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(true)
+      File.should_receive(:read).with('/c/path/to/file.txt').and_return('FOO')
+      run('/c/path/to/file.txt', 200, 'FOO')
+    end
+    
+    it "should return 404 if not found" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.reverse.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run('/path/to/file.txt', 404)
+    end
+    
+    it "should return text/html for file with no extension" do
+      File.should_receive(:exist?).with('/c/file').and_return(true)
+      File.should_receive(:read).with('/c/file')
+      s, h, b = *run('/file')
+      h['Content-Type'].should == 'text/html'
+    end
+    
+    {
+      "js" => "text/javascript",
+      "css" => "text/css",
+      "png" => "image/png",
+      "gif" => "image/gif",
+      "htm" => "text/html",
+      "html" => "text/html",
+      "txt" => "text/plain",
+      "unknown" => "application/octet-stream"
+    }.each do |ext, mime|
+      it "should serve file.#{ext} as #{mime}" do
+        File.should_receive(:exist?).with('/c/file.' + ext).and_return(true)
+        File.should_receive(:read).with('/c/file.' + ext)
+        s, h, b = *run('/file.' + ext)
+        h['Content-Type'].should == mime
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/server/doc_server_serializer_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MyDocServerSerializerRouter
+  def docs_prefix; 'PREFIX' end
+end
+
+describe YARD::Server::DocServerSerializer do
+  describe '#serialized_path' do
+    before do
+      Registry.clear
+      @command = mock(:command)
+      @command.stub!(:single_library).and_return(false)
+      @command.stub!(:library).and_return(LibraryVersion.new('foo'))
+      @command.stub!(:adapter).and_return(mock_adapter(:router => MyDocServerSerializerRouter.new))
+      @serializer = Server::DocServerSerializer.new(@command)
+    end
+
+    after(:all) { Server::Adapter.shutdown }
+    
+    it "should return '/PREFIX/library/toplevel' for root" do
+      @serializer.serialized_path(Registry.root).should == "/PREFIX/foo/toplevel"
+    end
+    
+    it "should return /PREFIX/library/Object for Object in a library" do
+      @serializer.serialized_path(P('A::B::C')).should == '/PREFIX/foo/A/B/C'
+    end
+    
+    it "should link to instance method as Class:method" do
+      obj = CodeObjects::MethodObject.new(:root, :method)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel:method'
+    end
+
+    it "should link to class method as Class.method" do
+      obj = CodeObjects::MethodObject.new(:root, :method, :class)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel.method'
+    end
+    
+    it "should link to anchor for constant" do
+      obj = CodeObjects::ConstantObject.new(:root, :FOO)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#FOO-constant'
+    end
+    
+    it "should link to anchor for class variable" do
+      obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#@@foo-classvariable'
+    end
+    
+    it "should not link to /library/ if single_library = true" do
+      @command.stub!(:single_library).and_return(true)
+      @serializer.serialized_path(Registry.root).should == "/PREFIX/toplevel"
+    end
+    
+    it "should return /PREFIX/foo/version if foo has a version" do
+      @command.stub!(:library).and_return(LibraryVersion.new('foo', 'bar'))
+      @serializer.serialized_path(P('A')).should == '/PREFIX/foo/bar/A'
+    end
+  end
+end