nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/tags/default_tag_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::DefaultTag do
+  it "should create a tag with defaults" do
+    o = YARD::Tags::DefaultTag.new('tagname', 'desc', ['types'], 'name', ['defaults'])
+    o.defaults.should == ['defaults']
+    o.tag_name.should == 'tagname'
+    o.name.should == 'name'
+    o.types.should == ['types']
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/tags/library_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::Library do
+  def tag(docstring)
+    Docstring.new(docstring).tags.first
+  end
+  
+  describe '#see_tag' do
+    it "should take a URL" do
+      tag("@see http://example.com").name.should == "http://example.com"
+    end
+    
+    it "should take an object path" do
+      tag("@see String#reverse").name.should == "String#reverse"
+    end
+    
+    it "should take a description after the url/object" do
+      tag = tag("@see http://example.com An Example Site")
+      tag.name.should == "http://example.com"
+      tag.text.should == "An Example Site"
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/tags/overload_tag_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::OverloadTag do
+  before do
+    @tag = Tags::OverloadTag.new(:overload, <<-'eof')
+      def bar(a, b = 1, &block)
+        Hello world
+        @param a [String]
+        @return [String]
+    eof
+  end
+  
+  it "should parse the first line as a method signature" do
+    @tag.signature.should == "def bar(a, b = 1, &block)"
+    @tag.parameters.should == [[:a, nil], [:b, "1"], [:"&block", nil]]
+  end
+  
+  it "should parse the rest of the text as a new Docstring" do
+    @tag.docstring.should be_instance_of(Docstring)
+    @tag.docstring.should == "Hello world"
+  end
+  
+  it "should set Docstring's object after #object= is called" do
+    m = mock(:object)
+    @tag.object = m
+    @tag.docstring.object.should == m
+  end
+  
+  it "should respond to #tag, #tags and #has_tag?" do
+    @tag.object = mock(:object)
+    @tag.tags.size.should == 2
+    @tag.tag(:param).name.should == "a"
+    @tag.has_tag?(:return).should == true
+  end
+  
+  it "should not be a CodeObjects::Base when not hooked up to an object" do
+    @tag.object = nil
+    @tag.is_a?(CodeObjects::Base).should == false
+  end
+  
+  it "should be a CodeObjects::Base when hooked up to an object" do
+    @tag.object = mock(:object)
+    @tag.object.should_receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
+    @tag.is_a?(CodeObjects::Base).should == true
+    @tag.kind_of?(CodeObjects::Base).should == true
+    (CodeObjects::Base === @tag).should == true
+  end
+
+  it "should not parse 'def' out of method name" do
+    tag = Tags::OverloadTag.new(:overload, "default")
+    tag.signature.should == "default"
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/tags/ref_tag_list_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::RefTagList do
+  before { YARD::Registry.clear }
+  
+  it "should accept symbol or string as owner's path and convert it into a proxy" do
+    t = Tags::RefTagList.new('author', :String)
+    t.owner.should == P(:String)
+  end
+  
+  it "should accept proxy object as owner" do
+    t = Tags::RefTagList.new('author', P(:String))
+    t.owner.should == P(:String)
+  end
+  
+  it "should return tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    t = Tags::Tag.new(:author, 'foo')
+    o.docstring.add_tag(t)
+  
+    ref = Tags::RefTagList.new('author', :String)
+    ref.tags.should == [t]
+    ref.tags.first.text.should == 'foo'
+  end
+  
+  it "should return named tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+  
+    ref = Tags::RefTagList.new('param', :String, 'foo')
+    ref.tags.should == [p1, p2]
+    ref.tags.first.text.should == 'bar1'
+  end
+  
+  it "all tags should respond to #owner and be a RefTag" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+  
+    ref = Tags::RefTagList.new('param', :String)
+    ref.tags.each do |t|
+      t.should be_kind_of(Tags::RefTag)
+      t.owner.should == o
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/templates/class_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :docstring) do
+  before do
+    YARD.parse_string <<-'eof'
+      private
+      # Comments
+      # @abstract override this class
+      # @author Test
+      # @version 1.0
+      # @see A
+      # @see http://example.com Example
+      class A < B
+        # HI
+        def method_missing(*args) end
+        # @deprecated
+        def a; end
+        
+        # constructor method!
+        def initialize(test) end
+      end
+      
+      class C < A; end
+      
+      class D
+        # @private
+        def initialize; end
+      end
+    eof
+  end
+  
+  it "should render html format correctly" do
+    html_equals(Registry.at('A').format(:format => :html, :no_highlight => true), :class001)
+  end
+  
+  it "should render text format correctly" do
+    text_equals(Registry.at('A').format, :class001)
+  end
+
+  it "should hide private constructors" do
+    html_equals(Registry.at('D').format(:format => :html, :no_highlight => true, :verifier => Verifier.new("!@private")), :class002)
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/templates/constant_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Templates::Engine.template(:default, :constant) do
+  describe 'fully dressed constant' do
+    it "should render text format correctly" do
+      YARD.parse_string <<-'eof'
+        class YARD::CLI::YRI
+          # Default search paths that should be loaded dynamically into YRI. These paths
+          # take precedence over all other paths ({SEARCH_PATHS_FILE} and RubyGems
+          # paths). To add a path, call: 
+          # 
+          #   DEFAULT_SEARCH_PATHS.push("/path/to/.yardoc")
+          # 
+          # @return [Array<String>] a list of extra search paths
+          # @since 0.6.0
+          DEFAULT_SEARCH_PATHS = []
+        end
+      eof
+      text_equals(Registry.at('YARD::CLI::YRI::DEFAULT_SEARCH_PATHS').format, :constant001)
+    end
+  end
+  
+  describe 'simple constant with no documentation' do
+    it "should render text format correctly" do
+      # Short constant should show on single line
+      YARD.parse_string <<-'eof'
+        MYCONST = 'foo'
+      eof
+      text_equals(Registry.at('MYCONST').format, :constant002)
+
+      # Long constant should show on multiple lines, indented
+      YARD.parse_string <<-'eof'
+        MYCONST = [A, B, C, D, E, F, G, H, I, J, K, L,
+          M, N, O, P, Q, R, S, T, U, V, W,
+          X, Y, Z]
+      eof
+      text_equals(Registry.at('MYCONST').format, :constant003)
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/templates/engine_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine do
+  describe '.register_template_path' do
+    it "should register a String path" do
+      Engine.register_template_path('.')
+      Engine.template_paths.pop.should == '.'
+    end
+  end
+  
+  describe '.template!' do
+    it "should create a module including Template" do
+      mod = Engine.template!('path/to/template')
+      mod.should include(Template)
+      mod.full_path.to_s.should == 'path/to/template'
+    end
+    
+    it "should create a module including Template with full_path" do
+      mod = Engine.template!('path/to/template2', '/full/path/to/template2')
+      mod.should include(Template)
+      mod.full_path.to_s.should == '/full/path/to/template2'
+    end
+  end
+  
+  describe '.template' do
+    it "should raise an error if the template is not found" do
+      lambda { Engine.template(:a, :b, :c) }.should raise_error(ArgumentError)
+    end
+    
+    it "should create a module including Template" do
+      mock = mock(:template)
+      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(['/full/path/template/name'])
+      Engine.should_receive(:template!).with('template/name', ['/full/path/template/name']).and_return(mock)
+      Engine.template('template/name').should == mock
+    end
+    
+    it "should create a Template from a relative Template path" do
+      Engine.should_receive(:template_paths).and_return([])
+      File.should_receive(:directory?).with("/full/path/template/notname").and_return(true)
+      start_template = mock(:start_template)
+      start_template.stub!(:full_path).and_return('/full/path/template/name')
+      start_template.stub!(:full_paths).and_return(['/full/path/template/name'])
+      start_template.should_receive(:is_a?).with(Template).and_return(true)
+      mod = Engine.template(start_template, '..', 'notname')
+      mod.should include(Template)
+      mod.full_path.to_s.should == "/full/path/template/notname"
+    end
+
+    it "should create a Template including other matching templates in path" do
+      paths = ['/full/path/template/name', '/full/path2/template/name']
+      Engine.should_receive(:find_template_paths).with(nil, 'template').at_least(1).times.and_return([])
+      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
+      ancestors = Engine.template('template/name').ancestors.map {|m| m.class_name }
+      ancestors.should include("Template__full_path2_template_name")
+    end
+    
+    it "should include parent directories before other template paths" do
+      paths = ['/full/path/template/name', '/full/path2/template/name']
+      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
+      ancestors = Engine.template('template/name').ancestors.map {|m| m.class_name }
+      ancestors[0, 4].should == ["Template__full_path_template_name", "Template__full_path_template", 
+        "Template__full_path2_template_name", "Template__full_path2_template"]
+    end
+  end
+  
+  describe '.generate' do
+    it "should generate with fulldoc template" do
+      mod = mock(:template)
+      mod.should_receive(:run).with(:__globals => OpenStruct.new, :format => :text, :template => :default, :objects => [:a, :b, :c])
+      Engine.should_receive(:template).with(:default, :fulldoc, :text).and_return(mod)
+      Engine.generate([:a, :b, :c])
+    end
+  end
+  
+  describe '.render' do
+    def loads_template(*args)
+      Engine.should_receive(:template).with(*args).and_return(@template)
+    end
+  
+    before(:all) do 
+      @object = CodeObjects::MethodObject.new(:root, :method)
+    end
+    
+    before do
+      @template = mock(:template)
+      @template.stub!(:include)
+    end
+  
+    it "should accept method call with no parameters" do
+      loads_template(:default, :method, :text)
+      @template.should_receive(:run).with :__globals => OpenStruct.new,
+                                          :type => :method,
+                                          :template => :default,
+                                          :format => :text,
+                                          :object => @object
+      @object.format
+    end
+  
+    it "should allow template key to be changed" do
+      loads_template(:javadoc, :method, :text)
+      @template.should_receive(:run).with :__globals => OpenStruct.new,
+                                          :type => :method,
+                                          :template => :javadoc,
+                                          :format => :text,
+                                          :object => @object
+      @object.format(:template => :javadoc)
+    end
+
+    it "should allow type key to be changed" do
+      loads_template(:default, :fulldoc, :text)
+      @template.should_receive(:run).with :__globals => OpenStruct.new,
+                                          :type => :fulldoc,
+                                          :template => :default,
+                                          :format => :text,
+                                          :object => @object
+      @object.format(:type => :fulldoc)
+    end
+  
+    it "should allow format key to be changed" do
+      loads_template(:default, :method, :html)
+      @template.should_receive(:run).with :__globals => OpenStruct.new,
+                                          :type => :method,
+                                          :template => :default,
+                                          :format => :html,
+                                          :object => @object
+      @object.format(:format => :html)
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/templates/examples/class001.html

@@ -0,0 +1,280 @@
+<h1>Class: A 
+  <span class="abstract note title">Abstract</span>
+  
+</h1>
+
+<dl class="box">
+  
+    <dt class="r1">Inherits:</dt>
+    <dd class="r1">
+      <span class="inheritName">B</span>
+      
+        <ul class="fullTree">
+          <li>Object</li>
+          
+            <li class="next">B</li>
+          
+            <li class="next">A</li>
+          
+        </ul>
+        <a href="#" class="inheritanceTree">show all</a>
+      
+      </dd>
+    
+  
+  
+    
+  
+    
+  
+  
+    <dt class="r2 last">Defined in:</dt>
+    <dd class="r2 last">(stdin)</dd>
+  
+</dl>
+<div class="clear"></div>
+
+<h2>Overview</h2><div class="docstring">
+  <div class="discussion">
+    <div class="note abstract">
+  <strong>This class is abstract.</strong> 
+  <div class='inline'>override this class</div>
+</div>
+Comments
+
+  </div>
+</div>
+<div class="tags">
+  
+  <h3>See Also:</h3>
+  <ul class="see">
+    
+      <li>A</li>
+    
+      <li><a href="http://example.com" target="_parent" title="Example">Example</a></li>
+    
+  </ul>
+<h3>Author:</h3>
+<ul class="author">
+  
+    <li>
+      
+      
+      
+      
+        
+        <div class='inline'>Test</div>
+      
+    </li>
+  
+</ul>
+<h3>Version:</h3>
+<ul class="version">
+  
+    <li>
+      
+      
+      
+      
+        
+        <div class='inline'>1.0</div>
+      
+    </li>
+  
+</ul>
+
+</div><div id="subclasses">
+  <h2>Direct Known Subclasses</h2>
+  <p class="children">C</p>
+</div>
+
+
+  
+
+  
+    <h2>Instance Method Summary <small>(<a href="#" class="summary_toggle">collapse</a>)</small></h2>
+
+    <ul class="summary">
+      
+        <li class="public deprecated">
+  <span class="summary_signature">
+    
+      <a  title="#a (instance method)">- <strong>a</strong> </a>
+    
+
+    
+  </span>
+  
+  
+  
+  
+  <span class="deprecated note title">Deprecated</span>
+
+  
+    <span class="summary_desc"><strong>Deprecated.</strong> <div class='inline'></div></span>
+  
+</li>
+
+      
+        <li class="public ">
+  <span class="summary_signature">
+    
+      <a  title="#initialize (instance method)">- (A) <strong>initialize</strong>(test) </a>
+    
+
+    
+  </span>
+  
+    <span class="note title constructor">constructor</span>
+  
+  
+  
+  
+  
+
+  
+    <span class="summary_desc"><div class='inline'>constructor method!.</div></span>
+  
+</li>
+
+      
+        <li class="public ">
+  <span class="summary_signature">
+    
+      <a  title="#method_missing (instance method)">- <strong>method_missing</strong>(*args) </a>
+    
+
+    
+  </span>
+  
+  
+  
+  
+  
+
+  
+    <span class="summary_desc"><div class='inline'>HI.</div></span>
+  
+</li>
+
+      
+    </ul>
+  
+
+
+  <div id="constructor_details" class="method_details_list">
+  <h2>Constructor Details</h2>
+  
+    <div class="method_details first">
+  <p class="signature first" id="initialize-instance_method">
+  
+    - (<tt>A</tt>) <strong>initialize</strong>(test) 
+  
+
+  
+</p><div class="docstring">
+  <div class="discussion">
+    constructor method!
+
+  </div>
+</div>
+<div class="tags">
+  
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+15</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 15</span>
+
+def initialize(test) end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+  
+</div>
+<div id="method_missing_details" class="method_details_list">
+  <h2>Dynamic Method Handling</h2>
+  <p class="notice this">
+    This class handles dynamic methods through the <tt>method_missing</tt> method
+    
+  </p>
+  
+    <div class="method_details first">
+  <p class="signature first" id="method_missing-instance_method">
+  
+    - <strong>method_missing</strong>(*args) 
+  
+
+  
+</p><div class="docstring">
+  <div class="discussion">
+    HI
+
+  </div>
+</div>
+<div class="tags">
+  
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+10</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 10</span>
+
+def method_missing(*args) end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+  
+</div>
+
+
+  <div id="instance_method_details" class="method_details_list">
+    <h2>Instance Method Details</h2>
+    
+    
+      <div class="method_details first">
+  <p class="signature first" id="a-instance_method">
+  
+    - <strong>a</strong> 
+  
+
+  
+</p><div class="docstring">
+  <div class="discussion">
+    <div class="note deprecated"><strong>Deprecated.</strong> <div class='inline'></div></div>
+
+
+  </div>
+</div>
+<div class="tags">
+  
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+12</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 12</span>
+
+def a; end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+    
+  </div>