nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/cli/yri_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class YARD::CLI::YRI
+  public :optparse, :find_object, :cache_object
+end
+
+describe YARD::CLI::Yardoc do
+  before do
+    @yri = YARD::CLI::YRI.new
+    Registry.stub!(:load)
+  end
+  
+  describe '#find_object' do
+    it "should use cache if available" do
+      @yri.stub!(:cache_object)
+      File.should_receive(:exist?).with('.yardoc').and_return(false)
+      File.should_receive(:exist?).with('bar.yardoc').and_return(true)
+      Registry.should_receive(:load).with('bar.yardoc')
+      Registry.should_receive(:at).with('Foo').and_return('OBJ')
+      @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
+      @yri.find_object('Foo').should == 'OBJ'
+    end
+    
+    it "should never use cache ahead of current directory's .yardoc" do
+      @yri.stub!(:cache_object)
+      File.should_receive(:exist?).with('.yardoc').and_return(true)
+      Registry.should_receive(:load).with('.yardoc')
+      Registry.should_receive(:at).with('Foo').and_return('OBJ')
+      @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
+      @yri.find_object('Foo').should == 'OBJ'
+      @yri.instance_variable_get("@search_paths")[0].should == '.yardoc'
+    end
+  end
+  
+  describe '#cache_object' do
+    it "should skip caching for Registry.yardoc_file" do
+      File.should_not_receive(:open).with(CLI::YRI::CACHE_FILE, 'w')
+      @yri.cache_object('Foo', Registry.yardoc_file)
+    end
+  end
+  
+  describe '#initialize' do
+    it "should load search paths" do
+      path = %r{/\.yard/yri_search_paths$}
+      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      File.should_receive(:file?).with(path).and_return(true)
+      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      @yri = YARD::CLI::YRI.new
+      spaths = @yri.instance_variable_get("@search_paths")
+      spaths.should include('line1')
+      spaths.should include('line2')
+    end
+    
+    it "should use DEFAULT_SEARCH_PATHS prior to other paths" do
+      YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.push('foo', 'bar')
+      path = %r{/\.yard/yri_search_paths$}
+      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      File.should_receive(:file?).with(path).and_return(true)
+      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      @yri = YARD::CLI::YRI.new
+      spaths = @yri.instance_variable_get("@search_paths")
+      spaths[0,4].should == %w(foo bar line1 line2)
+      YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.replace([])
+    end
+  end
+  
+  describe '#run' do
+    it "should search for objects and print their documentation" do
+      obj = YARD::CodeObjects::ClassObject.new(:root, 'Foo')
+      @yri.should_receive(:print_object).with(obj)
+      @yri.run('Foo')
+      Registry.clear
+    end unless ENV['CI'] # FIXME make this work on Travis CI
+    
+    it "should print usage if no object is provided" do
+      @yri.should_receive(:print_usage)
+      @yri.should_receive(:exit).with(1)
+      @yri.run('')
+    end
+    
+    it "should print no documentation exists for object if object is not found" do
+      STDERR.should_receive(:puts).with("No documentation for `Foo'")
+      @yri.should_receive(:exit).with(1)
+      @yri.run('Foo')
+    end
+  end
+end

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

@@ -0,0 +1,334 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::Base do
+  before { Registry.clear }
+
+  # Fix this
+  # it "should not allow empty object name" do
+  #   lambda { Base.new(:root, '') }.should raise_error(ArgumentError)
+  # end
+  
+  it "should return a unique instance of any registered object" do
+    obj = ClassObject.new(:root, :Me)
+    obj2 = ClassObject.new(:root, :Me)
+    obj.object_id.should == obj2.object_id
+    
+    obj3 = ModuleObject.new(obj, :Too)
+    obj4 = CodeObjects::Base.new(obj3, :Hello)
+    obj4.parent = obj
+    
+    obj5 = CodeObjects::Base.new(obj3, :hello)
+    obj4.object_id.should_not == obj5.object_id
+  end
+
+  it "should create a new object if cached object is not of the same class" do
+    ConstantObject.new(:root, "MYMODULE").should be_instance_of(ConstantObject)
+    ModuleObject.new(:root, "MYMODULE").should be_instance_of(ModuleObject)
+    ClassObject.new(:root, "MYMODULE").should be_instance_of(ClassObject)
+    YARD::Registry.at("MYMODULE").should be_instance_of(ClassObject)
+  end
+  
+  it "should recall the block if #new is called on an existing object" do
+    o1 = ClassObject.new(:root, :Me) do |o|
+      o.docstring = "DOCSTRING"
+    end
+    
+    o2 = ClassObject.new(:root, :Me) do |o|
+      o.docstring = "NOT_DOCSTRING"
+    end
+    
+    o1.object_id.should == o2.object_id
+    o1.docstring.should == "NOT_DOCSTRING"
+    o2.docstring.should == "NOT_DOCSTRING"
+  end
+  
+  it "should allow complex name and convert that to namespace" do
+    obj = CodeObjects::Base.new(nil, "A::B")
+    obj.namespace.path.should == "A"
+    obj.name.should == :B
+  end
+  
+  it "should allow namespace to be nil and not register in the Registry" do
+    obj = CodeObjects::Base.new(nil, :Me)
+    obj.namespace.should == nil
+    Registry.at(:Me).should == nil
+  end
+  
+  it "should allow namespace to be a NamespaceObject" do
+    ns = ModuleObject.new(:root, :Name)
+    obj = CodeObjects::Base.new(ns, :Me)
+    obj.namespace.should == ns
+  end
+  
+  it "should allow :root to be the shorthand namespace of `Registry.root`" do
+    obj = CodeObjects::Base.new(:root, :Me)
+    obj.namespace.should == Registry.root
+  end
+  
+  it "should not allow any other types as namespace" do
+    lambda { CodeObjects::Base.new("ROOT!", :Me) }.should raise_error(ArgumentError)
+  end
+  
+  it "should register itself in the registry if namespace is supplied" do
+    obj = ModuleObject.new(:root, :Me)
+    Registry.at(:Me).should == obj
+    
+    obj2 = ModuleObject.new(obj, :Too)
+    Registry.at(:"Me::Too").should == obj2
+  end
+  
+  it "should set any attribute using #[]=" do
+    obj = ModuleObject.new(:root, :YARD)
+    obj[:some_attr] = "hello"
+    obj[:some_attr].should == "hello"
+  end
+  
+  it "#[]= should use the accessor method if available" do
+    obj = CodeObjects::Base.new(:root, :YARD)
+    obj[:source] = "hello"
+    obj.source.should == "hello"
+    obj.source = "unhello"
+    obj[:source].should == "unhello"
+  end
+  
+  it "should set attributes via attr= through method_missing" do
+    obj = CodeObjects::Base.new(:root, :YARD)
+    obj.something = 2
+    obj.something.should == 2
+    obj[:something].should == 2
+  end
+  
+  it "should exist in the parent's #children after creation" do
+    obj = ModuleObject.new(:root, :YARD)
+    obj2 = MethodObject.new(obj, :testing)
+    obj.children.should include(obj2)
+  end
+  
+  it "should properly re-indent source starting from 0 indentation" do
+    obj = CodeObjects::Base.new(nil, :test)
+    obj.source = <<-eof
+      def mymethod
+        if x == 2 &&
+            5 == 5
+          3 
+        else
+          1
+        end
+      end
+    eof
+    obj.source.should == "def mymethod\n  if x == 2 &&\n      5 == 5\n    3 \n  else\n    1\n  end\nend"
+    
+    Registry.clear
+    Parser::SourceParser.parse_string <<-eof
+      def key?(key)
+        super(key)
+      end
+    eof
+    Registry.at('#key?').source.should == "def key?(key)\n  super(key)\nend"
+
+    Registry.clear
+    Parser::SourceParser.parse_string <<-eof
+        def key?(key)
+          if x == 2
+            puts key
+          else
+            exit
+          end
+        end
+    eof
+    Registry.at('#key?').source.should == "def key?(key)\n  if x == 2\n    puts key\n  else\n    exit\n  end\nend"
+  end
+  
+  it "should not add newlines to source when parsing sub blocks" do
+    Parser::SourceParser.parse_string <<-eof
+      module XYZ
+        module ZYX
+          class ABC
+            def msg
+              hello_world
+            end
+          end
+        end
+      end
+    eof
+    Registry.at('XYZ::ZYX::ABC#msg').source.should == "def msg\n  hello_world\nend"    
+  end
+  
+  it "should handle source for 'def x; end'" do
+    Registry.clear
+    Parser::SourceParser.parse_string "def x; 2 end"
+    Registry.at('#x').source.should == "def x; 2 end"
+  end
+  
+  it "should set file and line information" do
+    Parser::SourceParser.parse_string <<-eof
+      class X; end
+    eof
+    Registry.at(:X).file.should == '(stdin)'
+    Registry.at(:X).line.should == 1
+  end
+  
+  it "should maintain all file associations when objects are defined multiple times in one file" do
+    Parser::SourceParser.parse_string <<-eof
+      class X; end
+      class X; end
+      class X; end
+    eof
+    
+    Registry.at(:X).file.should == '(stdin)'
+    Registry.at(:X).line.should == 1
+    Registry.at(:X).files.should == [['(stdin)', 1], ['(stdin)', 2], ['(stdin)', 3]]
+  end
+
+  it "should maintain all file associations when objects are defined multiple times in multiple files" do
+    3.times do |i|
+      File.stub!(:read_binary).and_return("class X; end")
+      Parser::SourceParser.new.parse("file#{i+1}.rb")
+    end
+    
+    Registry.at(:X).file.should == 'file1.rb'
+    Registry.at(:X).line.should == 1
+    Registry.at(:X).files.should == [['file1.rb', 1], ['file2.rb', 1], ['file3.rb', 1]]
+  end
+
+  it "should prioritize the definition with a docstring when returning #file" do
+    Parser::SourceParser.parse_string <<-eof
+      class X; end
+      class X; end
+      # docstring
+      class X; end
+    eof
+    
+    Registry.at(:X).file.should == '(stdin)'
+    Registry.at(:X).line.should == 4
+    Registry.at(:X).files.should == [['(stdin)', 4], ['(stdin)', 1], ['(stdin)', 2]]
+  end
+  
+  describe '#format' do
+    it "should send to Templates.render" do
+      object = MethodObject.new(:root, :method)
+      Templates::Engine.should_receive(:render).with(:x => 1, :object => object)
+      object.format :x => 1
+    end
+  end
+  
+  describe '#source_type' do
+    it "should default source_type to :ruby" do
+      object = MethodObject.new(:root, :method)
+      object.source_type.should == :ruby
+    end
+  end
+  
+  describe '#relative_path' do
+    it "should accept a string" do
+      YARD.parse_string "module A; class B; end; class C; end; end"
+      Registry.at('A::B').relative_path(Registry.at('A::C')).should == 
+        Registry.at('A::B').relative_path('A::C')
+    end
+    
+    it "should return full class name when objects share a common class prefix" do
+      YARD.parse_string "module User; end; module UserManager; end"
+      Registry.at('User').relative_path('UserManager').should == 'UserManager'
+      Registry.at('User').relative_path(Registry.at('UserManager')).should == 'UserManager'
+    end
+    
+    it "should return the relative path when they share a common namespace" do
+      YARD.parse_string "module A; class B; end; class C; end; end"
+      Registry.at('A::B').relative_path(Registry.at('A::C')).should == 'C'
+      YARD.parse_string "module Foo; module A; end; module B; def foo; end end end"
+      Registry.at('Foo::A').relative_path(Registry.at('Foo::B#foo')).should == 'B#foo'
+    end
+    
+    it "should return the full path if they don't have a common namespace" do
+      YARD.parse_string "module A; class B; end; end; module D; class C; end; end"
+      Registry.at('A::B').relative_path('D::C').should == 'D::C'
+      YARD.parse_string 'module C::B::C; module Apple; end; module Ant; end end'
+      Registry.at('C::B::C::Apple').relative_path('C::B::C::Ant').should == 'Ant'
+      YARD.parse_string 'module OMG::ABC; end; class Object; end'
+      Registry.at('OMG::ABC').relative_path('Object').should == "Object"
+      YARD.parse_string("class YARD::Config; MYCONST = 1; end")
+      Registry.at('YARD::Config').relative_path('YARD::Config::MYCONST').should == "MYCONST"
+    end
+    
+    it "should return a relative path for class methods" do
+      YARD.parse_string "module A; def self.b; end; def self.c; end; end"
+      Registry.at('A.b').relative_path('A.c').should == 'c'
+      Registry.at('A').relative_path('A.c').should == 'c'
+    end
+
+    it "should return a relative path for instance methods" do
+      YARD.parse_string "module A; def b; end; def c; end; end"
+      Registry.at('A#b').relative_path('A#c').should == '#c'
+      Registry.at('A').relative_path('A#c').should == '#c'
+    end
+    
+    it "should return full path if relative path is to parent namespace" do
+      YARD.parse_string "module A; module B; end end"
+      Registry.at('A::B').relative_path('A').should == 'A'
+    end
+    
+    it "should only return name for relative path to self" do
+      YARD.parse_string("class A::B::C; def foo; end end")
+      Registry.at('A::B::C').relative_path('A::B::C').should == 'C'
+      Registry.at('A::B::C#foo').relative_path('A::B::C#foo').should == '#foo'
+    end
+  end
+  
+  describe '#docstring=' do
+    it "should convert string into Docstring when #docstring= is set" do
+      o = ClassObject.new(:root, :Me) 
+      o.docstring = "DOCSTRING"
+      o.docstring.should be_instance_of(Docstring)
+    end
+    
+    it "should set docstring to docstring of other object if docstring is '(see Path)'" do
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == "FOO"
+    end
+
+    it "should not copy docstring mid-docstring" do
+      doc = "Hello.\n(see file.rb)\nmore documentation"
+      o = ClassObject.new(:root, :Me)
+      o.docstring = doc
+      o.docstring.should == doc
+    end
+    
+    it "should allow extra docstring after (see Path)" do
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o = ClassObject.new(:root, :Me)
+      o.docstring = "(see AnotherObject)\n\nEXTRA\n@api private"
+      o.docstring.should == "FOO\n\nEXTRA"
+      o.docstring.should have_tag(:api)
+    end
+  end
+  
+  describe '#docstring' do
+    it "should return empty string if docstring was '(see Path)' and Path is not resolved" do
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == ""
+    end
+    
+    it "should return docstring when object is resolved" do
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == ""
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o.docstring.should == "FOO"
+    end
+  end
+  
+  describe '#add_file' do
+    it "should only add a file/line combination once" do
+      o = ClassObject.new(:root, :Me)
+      o.add_file('filename', 12)
+      o.files.should == [['filename', 12]]
+      o.add_file('filename', 12)
+      o.files.should == [['filename', 12]]
+      o.add_file('filename', 40) # different line
+      o.files.should == [['filename', 12], ['filename', 40]]
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/code_objects/class_object_spec.rb

@@ -0,0 +1,225 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::ClassObject do
+  describe '#inheritance_tree' do
+    before(:all) do
+      Registry.clear
+      @mixin = ModuleObject.new(:root, :SomeMixin)
+      @mixin2 = ModuleObject.new(:root, :SomeMixin2)
+      @mixin2.instance_mixins << @mixin
+      @mixin3 = ModuleObject.new(:root, :SomeMixin3)
+      @mixin4 = ModuleObject.new(:root, :SomeMixin4)
+      @mixin2.instance_mixins << @mixin3
+      @superyard = ClassObject.new(:root, :SuperYard)
+      @superyard.superclass = P("String")
+      @superyard.instance_mixins << @mixin2
+      @superyard.class_mixins << @mixin4
+      @yard = ClassObject.new(:root, :YARD)
+      @yard.superclass = @superyard
+      @yard.instance_mixins << @mixin
+    end
+
+    it "should show the proper inheritance tree" do
+      @yard.inheritance_tree.should == [@yard, @superyard, P(:String)]
+    end
+
+    it "should show proper inheritance tree when mixins are included" do
+      @yard.inheritance_tree(true).should == [@yard, @mixin, @superyard, @mixin4, @mixin2, @mixin3, P(:String)]
+    end
+
+    it "should not modify the object's mixin list when mixins are included" do
+      @class1 = ClassObject.new(:root, :A)
+      @class2 = ClassObject.new(:root, :B)
+      @class2.superclass = @class1
+
+      @class2.inheritance_tree(true)
+      @class2.mixins.should == []
+    end
+    
+    it "should list class mixins in inheritance tree" do
+      mod = ModuleObject.new(:root, :ClassMethods)
+      klass = ClassObject.new(:root, :ReceivingClass)
+      klass.class_mixins << mod
+      klass.inheritance_tree(true).should == [klass, mod]
+    end
+  end
+
+  describe "#meths / #inherited_meths" do
+    before(:all) do
+      Registry.clear
+    
+      YARD.parse_string <<-eof
+        class SuperYard < String
+          def foo; end
+          def foo2; end
+          def bar; end
+          def middle; end
+          protected :foo2
+          private
+          def self.bar; end
+        end
+      
+        class MiddleYard < SuperYard
+          def middle; end
+        end
+      
+        class YARD < MiddleYard
+          def mymethod; end
+          def bar; end
+        end
+        
+        module IncludedYard
+          def foo; end
+        end
+        
+        class FinalYard < SuperYard
+          include IncludedYard
+        end
+      eof
+    end
+  
+    it "should show inherited methods by default" do
+      meths = P(:YARD).meths
+      meths.should include(P("YARD#mymethod"))
+      meths.should include(P("SuperYard#foo"))
+      meths.should include(P("SuperYard#foo2"))
+      meths.should include(P("SuperYard.bar"))
+    end
+  
+    it "should allow :inherited to be set to false" do
+      meths = P(:YARD).meths(:inherited => false)
+      meths.should include(P("YARD#mymethod"))
+      meths.should_not include(P("SuperYard#foo"))
+      meths.should_not include(P("SuperYard#foo2"))
+      meths.should_not include(P("SuperYard.bar"))
+    end
+  
+    it "should not show overridden methods" do 
+      meths = P(:YARD).meths
+      meths.should include(P("YARD#bar"))
+      meths.should_not include(P("SuperYard#bar"))
+    
+      meths = P(:YARD).inherited_meths
+      meths.should_not include(P("YARD#bar"))
+      meths.should_not include(P("YARD#mymethod"))
+      meths.should include(P("SuperYard#foo"))
+      meths.should include(P("SuperYard#foo2"))
+      meths.should include(P("SuperYard.bar"))
+    end
+  
+    it "should not show inherited methods overridden by other subclasses" do
+      meths = P(:YARD).inherited_meths
+      meths.should include(P('MiddleYard#middle'))
+      meths.should_not include(P('SuperYard#middle'))
+    end
+    
+    it "should show mixed in methods before superclass method" do
+      meths = P(:FinalYard).meths
+      meths.should include(P('IncludedYard#foo'))
+      meths.should_not include(P('SuperYard#foo'))
+    end
+  end
+
+  describe "#constants / #inherited_constants" do
+    before(:all) do 
+      Registry.clear 
+    
+      Parser::SourceParser.parse_string <<-eof
+        class YARD
+          CONST1 = 1
+          CONST2 = "hello"
+          CONST4 = 0
+        end
+      
+        class SUPERYARD < YARD
+          CONST4 = 5
+        end
+      
+        class SubYard < SUPERYARD
+          CONST2 = "hi"
+          CONST3 = "foo"
+        end
+      eof
+    end
+  
+    it "should list inherited constants by default" do
+      consts = P(:SubYard).constants
+      consts.should include(P("YARD::CONST1"))
+      consts.should include(P("SubYard::CONST3"))
+    
+      consts = P(:SubYard).inherited_constants
+      consts.should include(P("YARD::CONST1"))
+      consts.should_not include(P("YARD::CONST2"))
+      consts.should_not include(P("SubYard::CONST2"))
+      consts.should_not include(P("SubYard::CONST3"))
+    end
+  
+    it "should not list inherited constants if turned off" do
+      consts = P(:SubYard).constants(:inherited => false)
+      consts.should_not include(P("YARD::CONST1"))
+      consts.should include(P("SubYard::CONST3"))
+    end
+  
+    it "should not include an inherited constant if it is overridden by the object" do
+      consts = P(:SubYard).constants
+      consts.should include(P("SubYard::CONST2"))
+      consts.should_not include(P("YARD::CONST2"))
+    end
+  
+    it "should not include an inherited constant if it is overridden by another subclass" do
+      consts = P(:SubYard).inherited_constants
+      consts.should include(P("SUPERYARD::CONST4"))
+      consts.should_not include(P("YARD::CONST4"))
+    end
+  
+    it "should not set a superclass on BasicObject class" do
+      o = ClassObject.new(:root, :Object)
+      o.superclass.should == P(:BasicObject)
+    end
+    
+    it "should set superclass of Object to BasicObject" do
+      o = ClassObject.new(:root, :BasicObject)
+      o.superclass.should be_nil
+    end
+  
+    it "should raise ArgumentError if superclass == self" do
+      lambda do
+        o = ClassObject.new(:root, :Object) do |o|
+          o.superclass = :Object
+        end
+      end.should raise_error(ArgumentError)
+    end
+  
+    it "should tell the world if it is an exception class" do
+      o = ClassObject.new(:root, :MyClass) 
+      o2 = ClassObject.new(:root, :OtherClass)
+      o2.superclass = :SystemCallError
+      o3 = ClassObject.new(:root, :StandardError)
+      o3.superclass = :Object
+      o4 = ClassObject.new(:root, :Object)
+
+      o.superclass = :Object
+      o.is_exception?.should == false
+    
+      o.superclass = :Exception
+      o.is_exception?.should == true
+    
+      o.superclass = :NoMethodError
+      o.is_exception?.should == true
+    
+      o.superclass = o2
+      o.is_exception?.should == true
+    
+      o.superclass = o3
+      o.is_exception?.should == true
+    end
+  
+    it "should not raise ArgumentError if superclass is proxy in different namespace" do
+      lambda do
+        o = ClassObject.new(:root, :X) do |o|
+          o.superclass = P('OTHER::X')
+        end
+      end.should_not raise_error(ArgumentError)
+    end
+  end
+end