nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/legacy_base_spec.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+include Parser::Ruby::Legacy
+
+describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do 
+  
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) } 
+  
+  def tokval(code, *types)
+    @handler.send(:tokval, TokenList.new(code).first, *types)
+  end
+  
+  it "should return the String's value without quotes" do
+    tokval('"hello"').should == "hello"
+  end
+  
+  it "should not allow interpolated strings with TkSTRING" do
+    tokval('"#{c}"', RubyToken::TkSTRING).should be_nil
+  end
+  
+  it "should return a Symbol's value as a String (as if it was done via :name.to_sym)" do
+    tokval(':sym').should == :sym
+  end
+  
+  it "should return nil for any non accepted type" do
+    tokval('identifier').should be_nil
+    tokval(':sym', RubyToken::TkId).should be_nil
+  end
+  
+  it "should accept TkVal tokens by default" do
+    tokval('2.5').should == 2.5
+    tokval(':sym').should == :sym
+  end
+  
+  it "should accept any ID type if TkId is set" do
+    tokval('variable', RubyToken::TkId).should == "variable"
+    tokval('CONSTANT', RubyToken::TkId).should == "CONSTANT"
+  end
+  
+  it "should allow extra token types to be accepted" do 
+    tokval('2.5', RubyToken::TkFLOAT).should == 2.5
+    tokval('2', RubyToken::TkFLOAT).should be_nil
+    tokval(':symbol', RubyToken::TkFLOAT).should be_nil
+  end
+  
+  it "should allow :string for any string type" do
+    tokval('"hello"', :string).should == "hello"
+    tokval('"#{c}"', :string).should == '#{c}'
+  end
+  
+  it "should not include interpolated strings when using :attr" do
+    tokval('"#{c}"', :attr).should be_nil
+  end
+  
+  it "should allow any number type with :number" do
+    tokval('2.5', :number).should == 2.5
+    tokval('2', :number).should == 2
+  end
+  
+  it "should should allow method names with :identifier" do
+    tokval('methodname?', :identifier).should == "methodname?"
+  end
+  
+  #it "should obey documentation expectations" do docspec end
+end
+
+describe YARD::Handlers::Base, "#tokval_list" do 
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) } 
+  
+  def tokval_list(code, *types)
+    @handler.send(:tokval_list, TokenList.new(code), *types)
+  end
+  
+  it "should return the list of tokvalues" do
+    tokval_list(":a, :b, \"\#{c}\", 'd'", :attr).should == [:a, :b, 'd']
+    tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d", 
+      RubyToken::Token).should  == [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
+  end
+  
+  it "should try to skip any invalid tokens" do
+    tokval_list(":a, :b, \"\#{c}\", :d", :attr).should  == [:a, :b, :d]
+    tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr).should  == [:a, :b, :d]
+    tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2", 
+      RubyToken::TkId).should  == ['CONST1', 'identifier', 'CONST2']
+  end
+  
+  it "should ignore a token if another invalid token is read before a comma" do
+    tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL).should == [:a, :c]
+  end
+  
+  it "should stop on most keywords" do
+    tokval_list(':a rescue :x == 5', RubyToken::Token).should == [:a]
+  end
+  
+  it "should handle ignore parentheses that begin the token list" do
+    tokval_list('(:a, :b, :c)', :attr).should == [:a, :b, :c]
+  end
+  
+  it "should end when a closing parenthesis was found" do
+    tokval_list(':a, :b, :c), :d', :attr).should == [:a, :b, :c]
+  end
+  
+  it "should ignore parentheses around items in a list" do
+    tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr).should == [:a, :b, :c, :e, :g]
+    tokval_list(':a, (((:f)))', :attr).should == [:a, :f]
+    tokval_list(':a, ([:f]), :c)', RubyToken::Token).should == [:a, '[:f]', :c]
+  end
+  
+  it "should not stop on a true/false/self keyword (cannot handle nil)" do
+    tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ', 
+      RubyToken::Token).should == [:a, true, :b, 'self', false, :c, 'File', 'super']
+  end
+  
+  it "should ignore invalid commas" do
+    tokval_list(":a, :b, , :d").should == [:a, :b, :d]
+  end
+  
+  it "should return an empty list if no matches were found" do
+    tokval_list('attr_accessor :x').should == []
+  end
+  
+  it "should treat {} as a valid value" do
+    # FIXME: tokval_list destroys extra spaces surrounding the '=' in
+    #        this situation. This is technically a design flaw of the
+    #        tokval parser, but this is now the expected behaviour.
+    tokval_list("opts = {}", :all).should == ["opts={}"]
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/macro_handler_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'ostruct'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MacroHandler" do
+  before(:all) { parse_file :macro_handler_001, __FILE__ }
+  
+  it "should create a readable attribute when @attribute r is found" do
+    obj = Registry.at('Foo#attr1')
+    obj.should_not be_nil
+    obj.should be_reader
+    obj.tag(:return).types.should == ['Numeric']
+    Registry.at('Foo#attr1=').should be_nil
+  end
+
+  it "should create a writable attribute when @attribute w is found" do
+    obj = Registry.at('Foo#attr2=')
+    obj.should_not be_nil
+    obj.should be_writer
+    Registry.at('Foo#attr2').should be_nil
+  end
+  
+  it "should default to readwrite @attribute" do
+    obj = Registry.at('Foo#attr3')
+    obj.should_not be_nil
+    obj.should be_reader
+    obj = Registry.at('Foo#attr3=')
+    obj.should_not be_nil
+    obj.should be_writer
+  end
+  
+  it "should allow @attribute to define alternate method name" do
+    Registry.at('Foo#attr4').should be_nil
+    Registry.at('Foo#custom').should_not be_nil
+  end
+
+  it "should default to creating an instance method for any DSL method with tags" do
+    obj = Registry.at('Foo#implicit0')
+    obj.should_not be_nil
+    obj.docstring.should == "IMPLICIT METHOD!"
+    obj.tag(:return).types.should == ['String']
+  end
+  
+  it "should set the method name when using @method" do
+    obj = Registry.at('Foo.xyz')
+    obj.should_not be_nil
+    obj.signature.should == 'def xyz(a, b, c)'
+    obj.source.should == 'foo_bar'
+    obj.docstring.should == 'The foo method'
+  end
+  
+  it "should create hidden overlaod tag when @method has signature" do
+    obj = Registry.at('Foo.xyz')
+    obj.docstring.tag(:overload).signature.should == 'xyz(a, b, c)'
+    obj.docstring.tag(:overload).object.should == obj
+  end
+  
+  it "should set the method name when using @overload" do
+    obj = Registry.at('Foo#qux2')
+    obj.should_not be_nil
+    obj.signature.should == 'def qux2(a, b, c)'
+    obj.source.should == 'something'
+    obj.docstring.tag(:overload).name.should == :qux2
+    obj.docstring.tag(:overload).object.should == obj
+  end
+
+  it "should set the method object when using @overload" do
+    obj = Registry.at('Foo#qux')
+    obj.should_not be_nil
+    obj.signature.should == 'def qux(a, b, c)'
+    obj.source.should == 'something :qux'
+    obj.docstring.tag(:overload).name.should == :qux
+    obj.docstring.tag(:overload).object.should == obj
+  end
+  
+  it "should allow setting of @scope" do
+    Registry.at('Foo.xyz').scope.should == :class
+  end
+  
+  it "should allow setting of @visibility" do
+    Registry.at('Foo.xyz').visibility.should == :protected
+  end
+  
+  it "should ignore DSL methods without tags" do
+    Registry.at('Foo#implicit_invalid').should be_nil
+  end
+
+  it "should accept a DSL method without tags if it has hash_flag (##)" do
+    Registry.at('Foo#implicit_valid').should_not be_nil
+    Registry.at('Foo#implicit_invalid2').should be_nil
+  end
+ 
+  it "should allow creation of macros" do
+    macro = CodeObjects::MacroObject.find('property')
+    macro.should_not be_nil
+    macro.should_not be_attached
+    macro.method_object.should be_nil
+  end
+  
+  it "should handle macros with no parameters to expand" do
+    Registry.at('Foo#none').should_not be_nil
+    Registry.at('Baz#none').signature.should == 'def none(foo, bar)'
+  end
+  
+  it "should apply new macro docstrings on new objects" do
+    obj = Registry.at('Foo#name')
+    obj.should_not be_nil
+    obj.source.should == 'property :name, String, :a, :b, :c'
+    obj.signature.should == 'def name(a, b, c)'
+    obj.docstring.should == 'A property that is awesome.'
+    obj.tag(:param).name.should == 'a'
+    obj.tag(:param).text.should == 'first parameter'
+    obj.tag(:return).types.should == ['String']
+    obj.tag(:return).text.should == 'the property name'
+  end
+  
+  it "should allow reuse of named macros" do
+    obj = Registry.at('Foo#age')
+    obj.should_not be_nil
+    obj.source.should == 'property :age, Fixnum, :value'
+    obj.signature.should == 'def age(value)'
+    obj.docstring.should == 'A property that is awesome.'
+    obj.tag(:param).name.should == 'value'
+    obj.tag(:param).text.should == 'first parameter'
+    obj.tag(:return).types.should == ['Fixnum']
+    obj.tag(:return).text.should == 'the property age'
+  end
+  
+  it "should use implicitly named macros" do
+    macro = CodeObjects::MacroObject.find('parser')
+    macro.macro_data.should == "@method $1(opts = {})\n@return NOTHING!"
+    macro.should_not be_nil
+    macro.should be_attached
+    macro.method_object.should == P('Foo.parser')
+    obj = Registry.at('Foo#c_parser')
+    obj.should_not be_nil
+    obj.docstring.should == ""
+    obj.signature.should == "def c_parser(opts = {})"
+    obj.docstring.tag(:return).text.should == "NOTHING!"
+  end
+  
+  it "should only use implicit macros on methods defined in inherited hierarchy" do
+    Registry.at('Bar#x_parser').should be_nil
+    Registry.at('Baz#y_parser').should_not be_nil
+  end
+  
+  it "should handle top-level DSL methods" do
+    obj = Registry.at('#my_other_method')
+    obj.should_not be_nil
+    obj.docstring.should == "Docstring for method"
+  end
+  
+  it "should handle Constant.foo syntax" do
+    obj = Registry.at('#beep')
+    obj.should_not be_nil
+    obj.signature.should == 'def beep(a, b, c)'
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/method_condition_handler_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodConditionHandler" do
+  before(:all) { parse_file :method_condition_handler_001, __FILE__ }
+  
+  it "should not parse regular if blocks in methods" do
+    Registry.at('#b').should be_nil
+  end
+  
+  it "should parse if/unless blocks in the form X if COND" do
+    Registry.at('#c').should_not be_nil
+    Registry.at('#d').should_not be_nil
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/method_handler_spec.rb

@@ -0,0 +1,177 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler" do
+  before(:all) do
+    log.enter_level(Logger::ERROR) do
+      parse_file :method_handler_001, __FILE__ 
+    end
+  end
+  
+  it "should add methods to parent's #meths list" do
+    P(:Foo).meths.should include(P("Foo#method1"))
+  end
+  
+  it "should parse/add class methods (self.method2)" do
+    P(:Foo).meths.should include(P("Foo.method2"))
+  end
+  
+  it "should parse/add class methods from other namespaces (String.hello)" do
+    P("String.hello").should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  [:[], :[]=, :allowed?, :/, :=~, :==, :`, :|, :*, :&, :%, :'^', :-@, :+@, :'~@'].each do |name|
+    it "should allow valid method #{name}" do
+      Registry.at("Foo##{name}").should_not be_nil
+    end
+  end
+  
+  it "should allow self.methname" do
+    Registry.at("Foo.new").should_not be_nil
+  end
+  
+  it "should mark dynamic methods as such" do
+    P('Foo#dynamic').dynamic?.should == true
+  end
+  
+  it "should show that a method is explicitly defined (if it was originally defined implicitly by attribute)" do
+    P('Foo#method1').is_explicit?.should == true
+  end
+  
+  it "should handle parameters" do
+    P('Foo#[]').parameters.should == [['key', "'default'"]]
+    P('Foo#/').parameters.should == [['x', "File.new('x', 'w')"], ['y', '2']]
+  end
+  
+  it "should handle opts = {} as parameter" do
+    P('Foo#optsmeth').parameters.should == [['x', nil], ['opts', '{}']]
+  end
+
+  it "should handle &block as parameter" do
+    P('Foo#blockmeth').parameters.should == [['x', nil], ['&block', nil]]
+  end
+
+  it "should handle overloads" do
+    meth = P('Foo#foo')
+
+    o1 = meth.tags(:overload).first
+    o1.name.should == :bar
+    o1.parameters.should == [[:a, nil], [:b, "1"]]
+    o1.tag(:return).type.should == "String"
+
+    o2 = meth.tags(:overload)[1]
+    o2.name.should == :baz
+    o2.parameters.should == [[:b, nil], [:c, nil]]
+    o2.tag(:return).type.should == "Fixnum"
+
+    o3 = meth.tags(:overload)[2]
+    o3.name.should == :bang
+    o3.parameters.should == [[:d, nil], [:e, nil]]
+    o3.docstring.should be_empty
+    o3.docstring.should be_blank
+  end
+  
+  it "should set a return tag if not set on #initialize" do
+    meth = P('Foo#initialize')
+    
+    meth.should have_tag(:return)
+    meth.tag(:return).types.should == ["Foo"]
+    meth.tag(:return).text.should == "a new instance of Foo"
+  end
+  
+  %w(inherited included method_added method_removed method_undefined).each do |meth|
+    it "should set @private tag on #{meth} callback method if no docstring is set" do
+      P('Foo.' + meth).should have_tag(:private)
+    end
+  end
+  
+  it "should not set @private tag on extended callback method since docstring is set" do
+    P('Foo.extended').should_not have_tag(:private)
+  end
+  
+  it "should add @return [Boolean] tag to methods ending in ? without return types" do
+    meth = P('Foo#boolean?')
+    meth.should have_tag(:return)
+    meth.tag(:return).types.should == ['Boolean']
+  end
+  
+  it "should add Boolean type to return tag without types" do
+    meth = P('Foo#boolean2?')
+    meth.should have_tag(:return)
+    meth.tag(:return).types.should == ['Boolean']
+  end
+  
+  it "should not change return type for method ending in ? with return types set" do
+    meth = P('Foo#boolean3?')
+    meth.should have_tag(:return)
+    meth.tag(:return).types.should == ['NotBoolean', 'nil']
+  end
+  
+  it "should add method writer to existing attribute" do
+    Registry.at('Foo#attr_name').should be_reader
+    Registry.at('Foo#attr_name=').should be_writer
+  end
+  
+  it "should add method reader to existing attribute" do
+    Registry.at('Foo#attr_name2').should be_reader
+    Registry.at('Foo#attr_name2=').should be_writer
+  end
+  
+  it "should generate an options parameter if @option refers to an undocumented parameter" do
+    meth = P('Foo#auto_opts')
+    meth.should have_tag(:param)
+    meth.tag(:param).name.should == "opts"
+    meth.tag(:param).types.should == ["Hash"]
+  end
+  
+  it "should raise an undocumentable error when a method is defined on an object instance" do
+    undoc_error "error = Foo; def error.at(foo) end"
+    Registry.at('error').should be_nil
+  end
+  
+  it "should allow class method to be defined on constant reference object" do
+    Registry.at('Foo.meth_on_const').should_not be_nil
+    Registry.at('Foo.meth2_on_const').should_not be_nil
+  end
+  
+  it "should copy alias information on method (re-)definition to new method" do
+    Registry.at('D').aliases.should be_empty
+    Registry.at('D#b').is_alias?.should == false
+    Registry.at('D#a').is_alias?.should == false
+  end
+  
+  it "should add macros for class methods" do
+    macro = CodeObjects::MacroObject.find('prop')
+    macro.should_not be_nil
+    macro.macro_data.should == "@method $1(value)\n$3\n@return [$2]"
+    macro.method_object.should == Registry.at('E.property')
+    macro.should be_attached
+    obj = Registry.at('E#foo')
+    obj.should_not be_nil
+    obj.docstring.should == 'create a foo'
+    obj.signature.should == 'def foo(value)'
+    obj.tag(:return).types.should == ['String']
+  end
+  
+  it "should handle macros on any object" do
+    macro = CodeObjects::MacroObject.find('xyz')
+    macro.should_not be_nil
+    macro.macro_data.should == '@method $1'
+  end
+  
+  it "should skip macros on instance methods" do
+    Registry.at('E#a').should be_nil
+  end
+  
+  it "should warn if the macro name is invalid" do
+    log.should_receive(:warn).with(/Invalid.+macro name.+Foo\.foo/)
+    YARD.parse_string "class Foo\n# @macro\ndef self.foo; end\nend"
+  end
+  
+  it "should handle 'def end' methods" do
+    obj = Registry.at('F::A#foo')
+    obj.should_not be_nil
+    obj = Registry.at('F::A#bar')
+    obj.should_not be_nil
+    obj.docstring.should == 'PASS'
+  end
+end