nutshell-crm 0.0.1 → 0.0.2

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

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::CodeObjectList do
+  before { Registry.clear }
+  
+  it "pushing a value should only allow CodeObjects::Base, String or Symbol" do
+    list = CodeObjectList.new(nil)
+    lambda { list.push(:hash => 1) }.should raise_error(ArgumentError)
+    list << "Test"
+    list << :Test2
+    list << ModuleObject.new(nil, :YARD)
+    list.size.should == 3
+  end
+  
+  it "added value should be a proxy if parameter was String or Symbol" do
+    list = CodeObjectList.new(nil)
+    list << "Test"
+    list.first.class.should == Proxy
+  end
+  
+  it "should contain a unique list of objects" do
+    obj = ModuleObject.new(nil, :YARD)
+    list = CodeObjectList.new(nil)
+    
+    list << P(:YARD)
+    list << obj
+    list.size.should == 1
+    
+    list << :Test
+    list << "Test"
+    list.size.should == 2
+  end
+end

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

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects, "CONSTANTMATCH" do
+  it "should match a constant" do
+    "Constant"[CodeObjects::CONSTANTMATCH].should == "Constant"
+    "identifier"[CodeObjects::CONSTANTMATCH].should be_nil
+    "File.new"[CodeObjects::CONSTANTMATCH].should == "File"
+  end
+end
+
+describe YARD::CodeObjects, "NAMESPACEMATCH" do
+  it "should match a namespace (multiple constants with ::)" do
+    "Constant"[CodeObjects::NAMESPACEMATCH].should == "Constant"
+    "A::B::C.new"[CodeObjects::NAMESPACEMATCH].should == "A::B::C"
+  end
+end
+
+describe YARD::CodeObjects, "METHODNAMEMATCH" do
+  it "should match a method name" do
+    "method"[CodeObjects::METHODNAMEMATCH].should == "method"
+    "[]()"[CodeObjects::METHODNAMEMATCH].should == "[]"
+    "-@"[CodeObjects::METHODNAMEMATCH].should == "-@"
+    "method?"[CodeObjects::METHODNAMEMATCH].should == "method?"
+    "method!!"[CodeObjects::METHODNAMEMATCH].should == "method!"
+  end
+end
+
+describe YARD::CodeObjects, "METHODMATCH" do
+  it "should match a full class method path" do
+    "method"[CodeObjects::METHODMATCH].should == "method"
+    "A::B::C.method?"[CodeObjects::METHODMATCH].should == "A::B::C.method?"
+    "A::B::C :: method"[CodeObjects::METHODMATCH].should == "A::B::C :: method"
+    "SomeClass . method"[CodeObjects::METHODMATCH].should == "SomeClass . method"
+  end
+  
+  it "should match self.method" do
+    "self :: method!"[CodeObjects::METHODMATCH].should == "self :: method!"
+    "self.is_a?"[CodeObjects::METHODMATCH].should == "self.is_a?"
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_EXCEPTIONS" do
+  it "should include all base exceptions" do
+    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+      eval(name).should <= Exception
+    end
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_CLASSES" do
+  it "should include all base classes" do
+    YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
+      next if name == "MatchingData" && !defined?(::MatchingData)
+      eval(name).should be_instance_of(Class)
+    end
+  end
+  
+  it "should include all exceptions" do
+    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+      YARD::CodeObjects::BUILTIN_CLASSES.should include(name)
+    end
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_ALL" do
+  it "should include classes modules and exceptions" do
+    a = YARD::CodeObjects::BUILTIN_ALL 
+    b = YARD::CodeObjects::BUILTIN_CLASSES
+    c = YARD::CodeObjects::BUILTIN_MODULES
+    a.should == b+c
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_MODULES" do
+  it "should include all base modules" do
+    YARD::CodeObjects::BUILTIN_MODULES.each do |name|
+      next if RUBY19 && ["Precision"].include?(name)
+      eval(name).should be_instance_of(Module)
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::ExtraFileObject do
+  describe '#initialize' do
+    it "should attempt to read contents from filesystem if contents=nil" do
+      File.should_receive(:read).with('file.txt').and_return('')
+      ExtraFileObject.new('file.txt')
+    end
+    
+    it "should raise Errno::ENOENT if contents=nil and file does not exist" do
+      lambda { ExtraFileObject.new('file.txt') }.should raise_error(Errno::ENOENT)
+    end
+    
+    it "should not attempt to read from disk if contents are provided" do
+      ExtraFileObject.new('file.txt', 'CONTENTS')
+    end
+    
+    it "should set filename to filename" do
+      file = ExtraFileObject.new('a/b/c/file.txt', 'CONTENTS')
+      file.filename.should == "a/b/c/file.txt"
+    end
+    
+    it "should parse out attributes at top of the file" do
+      file = ExtraFileObject.new('file.txt', "# @title X\n# @some_attribute Y\nFOO BAR")
+      file.attributes[:title].should == "X"
+      file.attributes[:some_attribute].should == "Y"
+      file.contents.should == "FOO BAR"
+    end
+    
+    it "should allow whitespace prior to '#' marker when parsing attributes" do
+      file = ExtraFileObject.new('file.txt', " \t # @title X\nFOO BAR")
+      file.attributes[:title].should == "X"
+      file.contents.should == "FOO BAR"
+    end
+    
+    it "should parse out old-style #!markup shebang format" do
+      file = ExtraFileObject.new('file.txt', "#!foobar\nHello")
+      file.attributes[:markup].should == "foobar"
+    end
+    
+    it "should not parse old-style #!markup if any whitespace is found" do
+      file = ExtraFileObject.new('file.txt', " #!foobar\nHello")
+      file.attributes[:markup].should be_nil
+      file.contents.should == " #!foobar\nHello"
+    end
+    
+    it "should not parse out attributes if there are newlines prior to attributes" do
+      file = ExtraFileObject.new('file.txt', "\n# @title\nFOO BAR")
+      file.attributes.should be_empty
+      file.contents.should == "\n# @title\nFOO BAR"
+    end
+    
+    it "should set contents to data after attributes" do
+      file = ExtraFileObject.new('file.txt', "# @title\nFOO BAR")
+      file.contents.should == "FOO BAR"
+    end
+    
+    it "should preserve newlines" do
+      file = ExtraFileObject.new('file.txt', "FOO\r\nBAR\nBAZ")
+      file.contents.should == "FOO\r\nBAR\nBAZ"
+    end
+    
+    it "should not include newlines in attribute data" do
+      file = ExtraFileObject.new('file.txt', "# @title FooBar\r\nHello world")
+      file.attributes[:title].should == "FooBar"
+    end
+    
+    it "should force encoding to @encoding attribute if present" do
+      log.should_not_receive(:warn)
+      data = "# @encoding sjis\nFOO"
+      data.force_encoding('binary')
+      file = ExtraFileObject.new('file.txt', data)
+      ['Shift_JIS', 'Windows-31J'].should include(file.contents.encoding.to_s)
+    end if RUBY19
+
+    it "should warn if @encoding is invalid" do
+      log.should_receive(:warn).with("Invalid encoding `INVALID' in file.txt")
+      data = "# @encoding INVALID\nFOO"
+      encoding = data.encoding
+      file = ExtraFileObject.new('file.txt', data)
+      file.contents.encoding.should == encoding
+    end if RUBY19
+    
+    it "should ignore encoding in 1.8.x (or encoding-unaware platforms)" do
+      log.should_not_receive(:warn)
+      file = ExtraFileObject.new('file.txt', "# @encoding INVALID\nFOO")
+    end if RUBY18
+    
+    it "should attempt to re-parse data as 8bit ascii if parsing fails" do
+      log.should_not_receive(:warn)
+      str = "\xB0"
+      str.force_encoding('utf-8') if str.respond_to?(:force_encoding)
+      file = ExtraFileObject.new('file.txt', str)
+      file.contents.should == "\xB0"
+    end
+  end
+  
+  describe '#name' do
+    it "should be set to basename (not extension) of filename" do
+      file = ExtraFileObject.new('file.txt', '')
+      file.name.should == 'file'
+    end
+  end
+  
+  describe '#title' do
+    it "should return @title attribute if present" do
+      file = ExtraFileObject.new('file.txt', '# @title FOO')
+      file.title.should == 'FOO'
+    end
+    
+    it "should return #name if no @title attribute exists" do
+      file = ExtraFileObject.new('file.txt', '')
+      file.title.should == 'file'
+    end
+  end
+  
+  describe '#==' do
+    it "should define equality on filename alone" do
+      file1 = ExtraFileObject.new('file.txt', 'A')
+      file2 = ExtraFileObject.new('file.txt', 'B')
+      file1.should == file2
+      file1.should be_eql(file2)
+      file1.should be_equal(file2)
+
+      # Another way to test the equality interface
+      a = [file1]
+      a |= [file2]
+      a.size.should == 1
+    end
+    
+  end
+end

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

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::MacroObject do
+  before do 
+    Registry.clear 
+  end
+  
+  describe '.create' do
+    def create(*args) MacroObject.create(*args) end
+
+    it "should create an object" do
+      create('foo', '')
+      obj = Registry.at('.macro.foo')
+      obj.should_not be_nil
+    end
+    
+    it "should use identity map" do
+      obj1 = create('foo', '')
+      obj2 = create('foo', '')
+      obj1.object_id.should == obj2.object_id
+    end
+    
+    it "should allow specifying of macro data" do
+      obj = create('foo', 'MACRODATA')
+      obj.macro_data.should == 'MACRODATA'
+    end
+    
+    it "should attach if a method object is provided" do
+      obj = create('foo', 'MACRODATA', P('Foo.property'))
+      obj.method_object.should == P('Foo.property')
+      obj.should be_attached
+    end
+  end
+  
+  describe '.find' do
+    before { MacroObject.create('foo', 'DATA') }
+    
+    it "should search for an object by name" do
+      MacroObject.find('foo').macro_data.should == 'DATA'
+    end
+    
+    it "should accept Symbol" do
+      MacroObject.find(:foo).macro_data.should == 'DATA'
+    end
+  end
+  
+  describe '.find_or_create' do
+    it "should look up name if @macro is present and find object" do
+      macro1 = MacroObject.create('foo', 'FOO')
+      macro2 = MacroObject.find_or_create("@macro foo\na b c")
+      macro1.should == macro2
+    end
+    
+    it "should create new macro if macro by that name does not exist" do
+      MacroObject.find_or_create("@macro foo\n  @method $1\nEXTRA")
+      MacroObject.find('foo').macro_data.should == "@method $1"
+    end
+    
+    it "should use full docstring if no text block is present in @macro" do
+      MacroObject.find_or_create("@macro foo\n@method $1\nEXTRA")
+      MacroObject.find('foo').macro_data.should == "EXTRA\n@method $1"
+    end
+  end
+  
+  describe '.apply' do
+    before do
+      @args = %w(foo a b c)
+    end
+    
+    def apply(comments)
+      MacroObject.apply(comments, @args)
+    end
+
+    it "should only expand macros if @macro is present" do
+      apply("$1$2$3").should == "$1$2$3"
+    end
+
+    it "should handle macro text inside block" do
+      apply("@macro name\n  foo$1$2$3\nfoobaz").should == "fooabc\nfoobaz"
+    end
+    
+    it "should append docstring to existing macro" do
+      macro = MacroObject.create('name', '$3$2$1')
+      result = MacroObject.apply("@macro name\nfoobar", @args)
+      result.should == "cba\nfoobar"
+    end
+    
+    it "should use only non macro data if docstring is an existing macro" do
+      data = "@macro name\n  $3$2$1\nEXTRA"
+      MacroObject.find_or_create(data)
+      result = MacroObject.apply(data, @args)
+      result.should == "cba\nEXTRA"
+      MacroObject.apply("@macro name\nFOO", @args).should == "cba\nFOO"
+    end
+    
+    it "should create macros if they don't exist" do
+      result = MacroObject.apply("@macro name\n  foo!$1", @args)
+      result.should == "foo!a"
+      MacroObject.find('name').macro_data.should == 'foo!$1'
+    end
+    
+    it "should keep other tags" do
+      apply("@macro name\n  foo$1$2$3\n@param name foo\nfoo").should == 
+        "fooabc\nfoo\n@param name\n  foo"
+    end
+  end
+
+  describe '.expand' do
+    def expand(comments)
+      args = %w(foo a b c)
+      full_line = 'foo :bar, :baz'
+      MacroObject.expand(comments, args, full_line)
+    end
+
+    it "should allow escaping of macro syntax" do
+      expand("$1\\$2$3").should == "a$2c"
+    end
+
+    it "should replace $* with the whole statement" do
+      expand("$* ${*}").should == "foo :bar, :baz foo :bar, :baz"
+    end
+
+    it "should replace $0 with method name" do
+      expand("$0 ${0}").should == "foo foo"
+    end
+
+    it "should replace all $N values with the Nth argument in the method call" do
+      expand("$1$2$3${3}\nfoobar").should == "abcc\nfoobar"
+    end
+
+    it "should replace ${N-M} ranges with N-M arguments (incl. commas)" do
+      expand("${1-2}x").should == "a, bx"
+    end
+
+    it "should handle open ended ranges (${N-})" do
+      expand("${2-}").should == "b, c"
+    end
+
+    it "should handle negative indexes ($-N)" do
+      expand("$-1 ${-2-} ${-2--2}").should == "c b, c b"
+    end
+    
+    it "should accept Docstring objects" do
+      expand(Docstring.new("$1\n@param name foo")).should == "a\n@param name foo"
+    end
+  end
+  
+  describe '#expand' do
+    it "should expand macro given its data" do
+      macro = MacroObject.create_docstring("@macro foo\n  $1 $2 THREE!")
+      macro.expand(['NAME', 'ONE', 'TWO']).should == "ONE TWO THREE!"
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::MethodObject do
+  before do 
+    Registry.clear 
+    @yard = ModuleObject.new(:root, :YARD)
+  end
+  
+  it "should have a path of testing for an instance method in the root" do
+    meth = MethodObject.new(:root, :testing)
+    meth.path.should == "#testing"
+  end
+  
+  it "should have a path of YARD#testing for an instance method in YARD" do
+    meth = MethodObject.new(@yard, :testing)
+    meth.path.should == "YARD#testing"
+  end
+  
+  it "should have a path of YARD.testing for a class method in YARD" do
+    meth = MethodObject.new(@yard, :testing, :class)
+    meth.path.should == "YARD.testing"
+  end
+  
+  it "should have a path of ::testing (note the ::) for a class method added to root namespace" do
+    meth = MethodObject.new(:root, :testing, :class)
+    meth.path.should == "::testing"
+  end
+  
+  it "should exist in the registry after successful creation" do
+    obj = MethodObject.new(@yard, :something, :class)
+    Registry.at("YARD.something").should_not be_nil
+    Registry.at("YARD#something").should be_nil
+    Registry.at("YARD::something").should be_nil
+    obj = MethodObject.new(@yard, :somethingelse)
+    Registry.at("YARD#somethingelse").should_not be_nil
+  end
+  
+  it "should allow #scope to be changed after creation" do
+    obj = MethodObject.new(@yard, :something, :class)
+    Registry.at("YARD.something").should_not be_nil
+    obj.scope = :instance
+    Registry.at("YARD.something").should be_nil
+    Registry.at("YARD#something").should_not be_nil
+  end
+  
+  describe '#name' do
+    it "should show a prefix for an instance method when prefix=true" do
+      obj = MethodObject.new(nil, :something)
+      obj.name(true).should == "#something"
+    end
+    
+    it "should never show a prefix for a class method" do
+      obj = MethodObject.new(nil, :something, :class)
+      obj.name.should == :"something"
+      obj.name(true).should == "something"
+    end
+  end
+  
+  describe '#is_attribute?' do
+    it "should only return true if attribute is set in namespace for read/write" do
+      obj = MethodObject.new(@yard, :foo)
+      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
+      obj.is_attribute?.should be_true
+      MethodObject.new(@yard, :foo=).is_attribute?.should be_false
+    end
+  end
+  
+  describe '#attr_info' do
+    it "should return attribute info if namespace is available" do
+      obj = MethodObject.new(@yard, :foo)
+      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
+      obj.attr_info.should == @yard.attributes[:instance][:foo]
+    end
+    
+    it "should return nil if namespace is proxy" do
+      obj = MethodObject.new(P(:ProxyClass), :foo)
+      MethodObject.new(@yard, :foo).attr_info.should == nil
+    end
+    
+    it "should return nil if meth is not an attribute" do
+      MethodObject.new(@yard, :notanattribute).attr_info.should == nil
+    end
+  end
+  
+  describe '#writer?' do
+    it "should return true if method is a writer attribute" do
+      obj = MethodObject.new(@yard, :foo=)
+      @yard.attributes[:instance][:foo] = {:read => nil, :write => obj}
+      obj.writer?.should == true
+      MethodObject.new(@yard, :NOTfoo=).writer?.should == false
+    end
+  end
+
+  describe '#reader?' do
+    it "should return true if method is a reader attribute" do
+      obj = MethodObject.new(@yard, :foo)
+      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
+      obj.reader?.should == true
+      MethodObject.new(@yard, :NOTfoo).reader?.should == false
+    end
+  end
+  
+  describe '#constructor?' do
+    before { @class = ClassObject.new(:root, :MyClass) }
+
+    it "should mark the #initialize method as constructor" do
+      MethodObject.new(@class, :initialize)
+    end
+    
+    it "should not mark Klass.initialize as constructor" do
+      MethodObject.new(@class, :initialize, :class).constructor?.should be_false
+    end
+    
+    it "should not mark module method #initialize as constructor" do
+      MethodObject.new(@yard, :initialize).constructor?.should be_false
+    end
+  end
+  
+  describe '#overridden_method' do
+    before { Registry.clear }
+    
+    it "should return overridden method from mixin first" do
+      YARD.parse_string(<<-eof)
+        module C; def foo; end end
+        class A; def foo; end end
+        class B < A; include C; def foo; end end
+      eof
+      Registry.at('B#foo').overridden_method.should == Registry.at('C#foo')
+    end
+    
+    it "should return overridden method from superclass" do
+      YARD.parse_string(<<-eof)
+        class A; def foo; end end
+        class B < A; def foo; end end
+      eof
+      Registry.at('B#foo').overridden_method.should == Registry.at('A#foo')
+    end
+    
+    it "should return nil if none is found" do
+      YARD.parse_string(<<-eof)
+        class A; end
+        class B < A; def foo; end end
+      eof
+      Registry.at('B#foo').overridden_method.should be_nil
+    end
+    
+    it "should return nil if namespace is a proxy" do
+      YARD.parse_string "def ARGV.foo; end"
+      Registry.at('ARGV.foo').overridden_method.should be_nil
+    end
+  end
+end