nutshell-crm 0.0.1 → 0.0.2

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

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/shared_signature_examples"
+
+describe YARD::Templates::Helpers::TextHelper do
+  include YARD::Templates::Helpers::TextHelper
+  include YARD::Templates::Helpers::MethodHelper
+  
+  describe '#signature' do
+    before do
+      @results = {
+        :regular => "root.foo -> Object",
+        :default_return => "root.foo -> Hello",
+        :no_default_return => "root.foo",
+        :private_class => "A.foo -> Object (private)",
+        :single => "root.foo -> String",
+        :two_types => "root.foo -> (String, Symbol)",
+        :two_types_multitag => "root.foo -> (String, Symbol)",
+        :type_nil => "root.foo -> Type?",
+        :type_array => "root.foo -> Type+",
+        :multitype => "root.foo -> (Type, ...)",
+        :void => "root.foo -> void",
+        :hide_void => "root.foo",
+        :block => "root.foo {|a, b, c| ... } -> Object",
+        :empty_overload => 'root.foobar -> String'
+      }
+    end
+    
+    def signature(obj) super(obj).strip end
+    
+    it_should_behave_like "signature"
+  end
+
+  describe '#align_right' do
+    it "should align text right" do
+      text = "Method: #some_method (SomeClass)"
+      align_right(text).should == ' ' * 40 + text
+    end
+
+    it "should truncate text that is longer than allowed width" do
+      text = "(Defined in: /home/user/.rip/.packages/some_gem-2460672e333ac07b9190ade88ec9a91c/long/path.rb)"
+      align_right(text).should == ' ' + text[0,68] + '...'
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# $COPY = :method001
+# $COPYT = :html
+
+describe YARD::Templates::Engine.template(:default, :method) do
+  before { Registry.clear }
+  
+  shared_examples_for "all formats" do
+    it "should render html format correctly" do
+      html_equals(Registry.at('#m').format(:format => :html, :no_highlight => true), @template)
+    end
+    
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format, @template)
+    end
+  end
+  
+  describe 'regular (deprecated) method' do
+    before do
+      @template = :method001
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @param [Hash] x the x argument
+        # @option x [String] :key1 (default) first key
+        # @option x [Symbol] :key2 second key
+        # @return [String] the result
+        # @raise [Exception] hi!
+        # @deprecated for great justice
+        def m(x) end
+        alias x m
+      eof
+    end
+    
+    it_should_behave_like "all formats"
+  end
+  
+  describe 'method with 1 overload' do
+    before do
+      @template = :method002
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @overload m(x, y)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        def m(x) end
+      eof
+    end
+    
+    it_should_behave_like "all formats"
+  end
+  
+  describe 'method with 2 overloads' do
+    before do
+      @template = :method003
+      YARD.parse_string <<-'eof'
+        private
+        # Method comments
+        # @overload m(x, y)
+        #   Overload docstring
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        # @overload m(x, y, z)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        #   @param [Boolean] z parameter z
+        def m(*args) end
+      eof
+    end
+    
+    it_should_behave_like "all formats"
+  end
+  
+  describe 'method void return' do
+    before do
+      @template = :method004
+      YARD.parse_string <<-'eof'
+        # @return [void]
+        def m(*args) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+  
+  describe 'method void return in an overload' do
+    before do
+      @template = :method005
+      YARD.parse_string <<-'eof'
+        # @overload m(a)
+        #   @return [void]
+        # @overload m(b)
+        #   @param [String] b hi
+        def m(*args) end
+      eof
+    end
+    
+    it_should_behave_like "all formats"
+  end
+end

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

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :module) do
+  before do 
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        def c; end
+        def d; end
+        private
+        def e; end
+      end
+
+      module BaseMod
+        attr_reader :base_attr1
+        attr_writer :base_attr2
+        attr_accessor :base_attr3
+      end
+
+      # Comments
+      module A
+        include BaseMod
+        attr_accessor :attr1
+        attr_reader :attr2
+        
+        # @overload attr3
+        #   @return [String] a string
+        # @overload attr3=(value)
+        #   @param [String] value sets the string
+        #   @return [void]
+        attr_accessor :attr3
+        
+        attr_writer :attr4
+        
+        def self.a; end
+        def a; end
+        alias b a
+
+        # @overload test_overload(a)
+        #   hello2
+        #   @param [String] a hi
+        def test_overload(*args) end
+          
+        # @overload test_multi_overload(a)
+        # @overload test_multi_overload(a, b)
+        def test_multi_overload(*args) end
+          
+        # @return [void]
+        def void_meth; end
+        
+        include B
+        
+        class Y; end
+        class Q; end
+        class X; end
+        module Z; end
+        # A long docstring for the constant. With extra text
+        # and newlines.
+        CONSTANT = 'value'
+        @@cvar = 'value' # @deprecated
+      end
+      
+      module TMP; include A end
+      class TMP2; extend A end
+    eof
+  end
+
+  it "should render html format correctly" do
+    html_equals(Registry.at('A').format(
+          :format => :html, :no_highlight => true, :hide_void_return => true,
+          :verifier => Verifier.new('object.type != :method || object.visibility == :public')),
+        :module001)
+  end
+
+  it "should render text format correctly" do
+    YARD.parse_string <<-'eof'
+      module A
+        include D, E, F, A::B::C
+      end
+    eof
+
+    text_equals(Registry.at('A').format, :module001)
+  end
+  
+  it "should render dot format correctly" do
+    Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example_contents(:module001, 'dot')
+  end
+  
+  it "should render groups correctly in html" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module A
+        # @group Foo
+        attr_accessor :foo_attr
+        def foo; end
+        def self.bar; end
+        
+        # @group Bar
+        def baz; end
+        
+        # @endgroup
+         
+        def self.baz; end
+      end
+    eof
+    
+    html_equals(Registry.at('A').format(:format => :html, :no_highlight => true), :module002)
+  end
+end

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

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class StringSerializer < YARD::Serializers::Base
+  attr_accessor :files, :string
+  def initialize(files, string)
+    @files = files
+    @string = string
+  end
+  
+  def serialize(object, data)
+    files << object
+    string << data
+  end
+end
+
+describe YARD::Templates::Engine.template(:default, :onefile) do
+  before { Registry.clear }
+
+  it "should render html" do
+    files = []
+    string = ''
+    YARD.parse_string <<-eof
+      class A
+        # Foo method
+        # @return [String]
+        def foo; end
+        
+        # Bar method
+        # @return [Numeric]
+        def bar; end
+      end
+    eof
+    readme = CodeObjects::ExtraFileObject.new('README', 
+      "# This is a code comment\n\n# Top of file\n\n\nclass C; end")
+    Templates::Engine.generate Registry.all(:class), 
+      :serializer => StringSerializer.new(files, string),
+      :onefile => true, :format => :html, :readme => readme, :files => [readme,
+        CodeObjects::ExtraFileObject.new('LICENSE', 'This is a license!')
+      ]
+    files.should == ['index.html']
+    string.should include("This is a code comment")
+    string.should include("This is a license!")
+    string.should include("Class: A")
+    string.should include("Foo method")
+    string.should include("Bar method")
+  end
+end

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

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Section do
+  include YARD::Templates
+  
+  describe '#initialize' do
+    it "should convert first argument to splat if it is array" do
+      s = Section.new(:name, [:foo, :bar])
+      s.name.should == :name
+      s[0].name.should == :foo
+      s[1].name.should == :bar
+    end
+    
+    it "should allow initialization with Section objects" do
+      s = Section.new(:name, [:foo, Section.new(:bar)])
+      s.name.should == :name
+      s[0].should == Section.new(:foo)
+      s[1].should == Section.new(:bar)
+    end
+
+    it "should make a list of sections" do
+      s = Section.new(:name, [:foo, [:bar]])
+      s.should == Section.new(:name, Section.new(:foo, Section.new(:bar)))
+    end
+  end
+  
+  describe '#[]' do
+    it "should use Array#[] if argument is integer" do
+      Section.new(:name, [:foo, :bar])[0].name.should == :foo
+    end
+    
+    it "should return new Section object if more than one argument" do
+      Section.new(:name, :foo, :bar, :baz)[1, 2].should ==
+        Section.new(:name, :bar, :baz)
+    end
+    
+    it "should return new Section object if arg is Range" do
+      Section.new(:name, :foo, :bar, :baz)[1..2].should ==
+        Section.new(:name, :bar, :baz)
+    end
+    
+    it "should look for section by name if arg is object" do
+      Section.new(:name, :foo, :bar, [:baz])[:bar][:baz].should ==
+        Section.new(:baz)
+    end
+  end
+  
+  describe '#eql?' do
+    it "should check for equality of two equal sections" do
+      Section.new(:foo, [:a, :b]).should be_eql(Section.new(:foo, :a, :b))
+      Section.new(:foo, [:a, :b]).should == Section.new(:foo, :a, :b)
+    end
+    
+    it "should not be equal if section names are different" do
+      Section.new(:foo, [:a, :b]).should_not be_eql(Section.new(:bar, :a, :b))
+      Section.new(:foo, [:a, :b]).should_not == Section.new(:bar, :a, :b)
+    end
+  end
+  
+  describe '#==' do
+    it "should allow comparison to Symbol" do
+      Section.new(:foo, 2, 3).should == :foo
+    end
+    
+    it "should allow comparison to String" do
+      Section.new("foo", 2, 3).should == "foo"
+    end
+    
+    it "should allow comparison to Template" do
+      t = YARD::Templates::Engine.template!(:xyzzy, '/full/path/xyzzy')
+      Section.new(t, 2, 3).should == t
+    end
+    
+    it "should allow comparison to Section" do
+      Section.new(1, [2, 3]).should == Section.new(1, 2, 3)
+    end
+    
+    it "should allow comparison to Object" do
+      Section.new(1, [2, 3]).should == 1
+    end
+    
+    it "should allow comparison to Array" do
+      Section.new(1, 2, [3]).should == [1, [2, [3]]]
+    end
+  end
+  
+  describe '#to_a' do
+    it "should convert Section to regular Array list" do
+      arr = Section.new(1, 2, [3, [4]]).to_a
+      arr.class.should == Array
+      arr.should == [1, [2, [3, [4]]]]
+    end
+  end
+  
+  describe '#place' do
+    it "should place objects as Sections" do
+      Section.new(1, 2, 3).place(4).before(3).should == [1, [2, 4, 3]]
+    end
+    
+    it "should place objects anywhere inside Section with before/after_any" do
+      Section.new(1, 2, [3, [4]]).place(5).after_any(4).should == [1, [2, [3, [4, 5]]]]
+      Section.new(1, 2, [3, [4]]).place(5).before_any(4).should == [1, [2, [3, [5, 4]]]]
+    end
+    
+    it "should allow multiple sections to be placed" do
+      Section.new(1, 2, 3).place(4, 5).after(3).to_a.should == [1, [2, 3, 4, 5]]
+      Section.new(1, 2, 3).place(4, [5]).after(3).to_a.should == [1, [2, 3, 4, [5]]]
+    end
+  end
+  
+  describe '#push' do
+    it "should push objects as Sections" do
+      s = Section.new(:foo)
+      s.push :bar
+      s[0].should == Section.new(:bar)
+    end
+    
+    it "should alias to #<<" do
+      s = Section.new(1)
+      s << :index
+      s[:index].should be_a(Section)
+    end
+  end
+  
+  describe '#unshift' do
+    it "should unshift objects as Sections" do
+      s = Section.new(:foo)
+      s.unshift :bar
+      s[0].should == Section.new(:bar)
+    end
+  end
+  
+  describe '#any' do
+    it "should find item inside sections" do
+      s = Section.new(:foo, Section.new(:bar, Section.new(:bar)))
+      s.any(:bar).push(:baz)
+      s.to_a.should == [:foo, [:bar, [:bar, :baz]]]
+    end
+    
+    it "should find item in any deeply nested set of sections" do
+      s = Section.new(:foo, Section.new(:bar, Section.new(:baz)))
+      s.any(:baz).push(:qux)
+      s.to_a.should == [:foo, [:bar, [:baz, [:qux]]]]
+    end
+  end
+end