nutshell-crm 0.0.1 → 0.0.2

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

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler" do
+  before(:all) { parse_file :mixin_handler_001, __FILE__ }
+  
+  it "should handle includes from classes or modules" do
+    Registry.at(:X).instance_mixins.should include(P(:A))
+    Registry.at(:Y).instance_mixins.should include(P(:A))
+  end
+
+  it "should handle includes in class << self" do
+    Registry.at(:Y).class_mixins.should include(P(:A))
+  end
+  
+  it "should handle includes for modules that don't yet exist" do
+    Registry.at(:X).instance_mixins.should include(P(nil, :NOTEXIST))
+  end
+  
+  it "should set the type of non-existing modules to :module" do
+    P(:NOTEXIST).type.should == :module
+  end
+  
+  it "should handle includes with multiple parameters" do
+    Registry.at(:X).should_not be_nil
+  end
+  
+  it "should handle complex include statements" do
+    P(:Y).instance_mixins.should include(P('B::C'))
+    P(:Y).instance_mixins.should include(P(:B))
+  end
+  
+  it "should treat a mixed in Constant by taking its value as the real object name" do
+    P(:Y).instance_mixins.should include(Registry.at('B::D'))
+  end
+  
+  it "should avoid including self for unresolved mixins of the same name" do
+    P("ABC::DEF::FOO").mixins.should == [P("ABC::FOO")]
+    P("ABC::DEF::BAR").mixins.should == [P("ABC::BAR")]
+  end
+  
+  it "should raise undocumentable error if argument is variable" do
+    undoc_error "module X; include invalid; end"
+    Registry.at('X').mixins.should == []
+  end
+  
+  it "should parse all other arguments before erroring out on undocumentable error" do
+    undoc_error "module X; include invalid, Y; end"
+    Registry.at('X').mixins.should == [P('Y')]
+  end
+end

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

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
+  before(:all) { parse_file :module_handler_001, __FILE__ }
+
+  it "should parse a module block" do
+    Registry.at(:ModName).should_not == nil
+    Registry.at("ModName::OtherModName").should_not == nil
+  end
+  
+  it "should attach docstring" do
+    Registry.at("ModName::OtherModName").docstring.should == "Docstring"
+  end
+  
+  it "should handle any formatting" do
+    Registry.at(:StressTest).should_not == nil
+  end
+  
+  it "should handle complex module names" do
+    Registry.at("A::B").should_not == nil
+  end
+  
+  it "should handle modules in the form ::ModName" do
+    Registry.at("Kernel").should_not be_nil
+  end
+  
+  it "should list mixins in proper order" do
+    Registry.at('D').mixins.should == [P(:C), P(:B), P(:A)]
+  end
+  
+  it "should create proper module when constant is in namespace" do
+    Registry.at('Q::FOO::A').should_not be_nil
+  end
+end

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

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
+  before(:all) { parse_file :private_constant_handler_001, __FILE__ }
+
+  it "should handle private_constant statement" do
+    Registry.at('A::Foo').visibility.should == :private
+    Registry.at('A::B').visibility.should == :private
+    Registry.at('A::C').visibility.should == :private
+  end
+  
+  it "should make all other constants public" do
+    Registry.at('A::D').visibility.should == :public
+  end
+  
+  it "should fail if parameter is not String, Symbol or Constant" do
+    undoc_error 'class Foo; private_constant x; end'
+    undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
+  end unless LEGACY_PARSER
+  
+  it "should fail if constant can't be recognized" do
+    undoc_error 'class Foo2; private_constant :X end'
+  end
+end

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

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Handlers::Processor do
+  before do
+    @proc = Handlers::Processor.new
+  end
+  
+  it "should start with public visibility" do
+    @proc.visibility.should == :public
+  end
+  
+  it "should start in instance scope" do
+    @proc.scope.should == :instance
+  end
+  
+  it "should start in root namespace" do
+    @proc.namespace.should == Registry.root
+  end
+  
+  it "should have a globals structure" do
+    @proc.globals.should be_a(OpenStruct)
+  end
+end

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

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
+  include YARD::Parser::Ruby; YARD::Parser::Ruby::AstNode
+
+  before do
+    Handlers::Ruby::Base.stub!(:inherited)
+    @processor = Handlers::Processor.new(nil, false, :ruby)
+  end
+  
+  def valid(handler, stmt)
+    @processor.find_handlers(stmt).should include(handler)
+  end
+  
+  def invalid(handler, stmt)
+    @processor.find_handlers(stmt).should_not include(handler)
+  end
+
+  it "should only handle Handlers inherited from Ruby::Base class" do
+    class IgnoredHandler < Handlers::Base
+      handles :list
+    end
+    class NotIgnoredHandler < Handlers::Ruby::Base
+      handles :list
+    end
+    Handlers::Base.stub!(:subclasses).and_return [IgnoredHandler, NotIgnoredHandler]
+    @processor.find_handlers(s()).should == [NotIgnoredHandler]
+  end
+
+  it "should handle string input (matches AstNode#source)" do
+    class StringHandler < Handlers::Ruby::Base
+      handles "x"
+    end
+    Handlers::Base.stub!(:subclasses).and_return [StringHandler]
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
+    valid StringHandler, ast[0][0][0]
+    invalid StringHandler, ast[0][1]
+  end
+  
+  it "should handle symbol input (matches AstNode#type)" do
+    class SymbolHandler < Handlers::Ruby::Base
+      handles :myNodeType
+    end
+    Handlers::Base.stub!(:subclasses).and_return [SymbolHandler]
+    valid SymbolHandler, s(:myNodeType, s(1, 2, 3))
+    invalid SymbolHandler, s(:NOTmyNodeType, s(1, 2, 3))
+  end
+
+  it "should handle regex input (matches AstNode#source)" do
+    class RegexHandler < Handlers::Ruby::Base
+      handles %r{^if x ==}
+    end
+    Handlers::Base.stub!(:subclasses).and_return [RegexHandler]
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
+    valid RegexHandler, ast
+    invalid RegexHandler, ast[0][1]
+  end
+
+  it "should handle AstNode input (matches AST literally)" do
+    class ASTHandler < Handlers::Ruby::Base
+      handles s(:vcall, s(:ident, "hello_world"))
+    end
+    Handlers::Base.stub!(:subclasses).and_return [ASTHandler]
+    valid ASTHandler, s(:vcall, s(:ident, "hello_world"))
+    invalid ASTHandler, s(:vcall, s(:ident, "NOTHELLOWORLD"))
+  end
+  
+  it "should handle #method_call(:methname) on a valid AST" do
+    class MethCallHandler < Handlers::Ruby::Base
+      handles method_call(:meth)
+    end
+    Handlers::Base.stub!(:subclasses).and_return [MethCallHandler]
+    ast = Parser::Ruby::RubyParser.parse(<<-"eof").ast
+      meth                   # 0
+      meth()                 # 1
+      meth(1,2,3)            # 2
+      meth 1,2,3             # 3
+      NotMeth.meth           # 4
+      NotMeth.meth { }       # 5
+      NotMeth.meth do end    # 6
+      NotMeth.meth 1, 2, 3   # 7
+      NotMeth.meth(1, 2, 3)  # 8
+      NotMeth                # 9
+    eof
+    (0..8).each do |i|
+      valid MethCallHandler, ast[i]
+    end
+    invalid MethCallHandler, ast[9]
+  end
+end if HAVE_RIPPER

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/ruby/legacy/base_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+include Parser::Ruby::Legacy
+
+describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
+  before do
+    Handlers::Ruby::Legacy::Base.stub!(:inherited)
+    Handlers::Ruby::Legacy::MixinHandler.stub!(:inherited) # fixes a Ruby1.9 issue
+    @processor = Handlers::Processor.new(nil, false, :ruby18)
+  end
+  
+  def stmt(string)
+    Statement.new(TokenList.new(string))
+  end
+  
+  it "should only handle Handlers inherited from Ruby::Legacy::Base class" do
+    class IgnoredHandler < Handlers::Base
+      handles "hello"
+    end
+    class NotIgnoredHandlerLegacy < Handlers::Ruby::Legacy::Base
+      handles "hello"
+    end
+    Handlers::Base.stub!(:subclasses).and_return [IgnoredHandler, NotIgnoredHandlerLegacy]
+    @processor.find_handlers(stmt("hello world")).should == [NotIgnoredHandlerLegacy]
+  end
+
+  it "should handle a string input" do
+    class TestStringHandler < Handlers::Ruby::Legacy::Base
+      handles "hello"
+    end
+
+    TestStringHandler.handles?(stmt("hello world")).should be_true
+    TestStringHandler.handles?(stmt("nothello world")).should be_false
+  end
+
+  it "should handle regex input" do
+    class TestRegexHandler < Handlers::Ruby::Legacy::Base
+      handles /^nothello$/
+    end
+
+    TestRegexHandler.handles?(stmt("nothello")).should be_true
+    TestRegexHandler.handles?(stmt("not hello hello")).should be_false
+  end
+
+  it "should handle token input" do
+    class TestTokenHandler < Handlers::Ruby::Legacy::Base
+      handles TkMODULE
+    end
+
+    TestTokenHandler.handles?(stmt("module")).should be_true
+    TestTokenHandler.handles?(stmt("if")).should be_false
+  end
+  
+  it "should parse a do/end or { } block with #parse_block" do
+    class MyBlockHandler < Handlers::Ruby::Legacy::Base
+      handles /\AmyMethod\b/
+      def process
+        parse_block(:owner => "test")
+      end
+    end
+    
+    class MyBlockInnerHandler < Handlers::Ruby::Legacy::Base
+      handles "inner"
+      def self.reset; @@reached = false end
+      def self.reached?; @@reached ||= false end
+      def process; @@reached = true end
+    end
+    
+    Handlers::Base.stub!(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
+    Parser::SourceParser.parser_type = :ruby18
+    Parser::SourceParser.parse_string "myMethod do inner end"
+    MyBlockInnerHandler.should be_reached
+    MyBlockInnerHandler.reset
+    Parser::SourceParser.parse_string "myMethod { inner }"
+    MyBlockInnerHandler.should be_reached
+    Parser::SourceParser.parser_type = :ruby
+  end
+end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+require 'stringio'
+
+include Handlers
+
+def undoc_error(code)
+  lambda { StubbedSourceParser.parse_string(code) }.should raise_error(Parser::UndocumentableError)
+end
+
+def with_parser(parser_type, &block)
+  tmp = StubbedSourceParser.parser_type
+  StubbedSourceParser.parser_type = parser_type
+  yield
+  StubbedSourceParser.parser_type = tmp
+end
+
+class StubbedProcessor < Processor
+  def process(statements)
+    statements.each_with_index do |stmt, index|
+      find_handlers(stmt).each do |handler| 
+        handler.new(self, stmt).process
+      end
+    end
+  end
+end
+
+class StubbedSourceParser < Parser::SourceParser
+  StubbedSourceParser.parser_type = :ruby
+  def post_process
+    post = StubbedProcessor.new(@file, @load_order_errors, @parser_type, @globals)
+    post.process(@parser.enumerator)
+  end
+end
+  

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

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
+  before(:all) { parse_file :visibility_handler_001, __FILE__ }
+  
+  it "should be able to set visibility to public" do
+    Registry.at("Testing#pub").visibility.should == :public
+    Registry.at("Testing#pub2").visibility.should == :public
+  end
+  
+  it "should be able to set visibility to private" do
+    Registry.at("Testing#priv").visibility.should == :private
+  end
+  
+  it "should be able to set visibility to protected" do
+    Registry.at("Testing#prot").visibility.should == :protected
+  end
+  
+  it "should support parameters and only set visibility on those methods" do
+    Registry['Testing#notpriv'].visibility.should == :protected
+    Registry['Testing#notpriv2'].visibility.should == :protected
+    Registry['Testing#notpriv?'].visibility.should == :protected
+  end
+  
+  it "should only accept strings and symbols" do
+    Registry.at('Testing#name').should be_nil
+    Registry.at('Testing#argument').should be_nil
+    Registry.at('Testing#method_call').should be_nil
+  end
+  
+  it "should handle constants passed in as symbols" do
+    Registry.at('Testing#Foo').visibility.should == :private
+  end
+end

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

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
+  before(:all) { parse_file :yield_handler_001, __FILE__ }
+  
+  it "should only parse yield blocks in methods" do
+    P(:Testing).tag(:yield).should be_nil
+    P(:Testing).tag(:yieldparam).should be_nil
+  end
+  
+  it "should handle an empty yield statement" do
+    P('Testing#mymethod').tag(:yield).should be_nil
+    P('Testing#mymethod').tag(:yieldparam).should be_nil
+  end
+  
+  it "should not document a yield statement in a method with either @yield or @yieldparam" do
+    P('Testing#mymethod2').tag(:yield).types.should == ['a', 'b']
+    P('Testing#mymethod2').tag(:yield).text.should == "Blah"
+    P('Testing#mymethod2').tags(:yieldparam).size.should == 2
+
+    P('Testing#mymethod3').tag(:yield).types.should == ['a', 'b']
+    P('Testing#mymethod3').tags(:yieldparam).size.should == 0
+
+    P('Testing#mymethod4').tag(:yieldparam).name.should == '_self'
+    P('Testing#mymethod4').tag(:yieldparam).text.should == 'BLAH'
+  end
+  
+  it "should handle any arbitrary yield statement" do
+    P('Testing#mymethod5').tag(:yield).types.should == [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
+  end
+  
+  it "should handle parentheses" do
+    P('Testing#mymethod6').tag(:yield).types.should == ['b', 'a']
+  end
+  
+  it "should only document the first yield statement in a method (limitation of yield handler)" do
+    P('Testing#mymethod7').tag(:yield).types.should == ['a']
+  end
+  
+  it "should handle `self` keyword and list object type as yieldparam for _self" do
+    P('Testing#mymethod8').tag(:yield).types.should == ['_self']
+    P('Testing#mymethod8').tag(:yieldparam).types.should == ['Testing']
+    P('Testing#mymethod8').tag(:yieldparam).text.should == "the object that the method was called on"
+  end
+  
+  it "should handle `super` keyword and document it under _super" do
+    P('Testing#mymethod9').tag(:yield).types.should == ['_super']
+    P('Testing#mymethod9').tag(:yieldparam).types.should be_nil
+    P('Testing#mymethod9').tag(:yieldparam).text.should == "the result of the method from the superclass"
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/logging_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe YARD::Logger do
+  describe '#show_backtraces' do
+    it "should be true if debug level is on" do
+      log.show_backtraces = true
+      log.enter_level(Logger::DEBUG) do
+        log.show_backtraces = false
+        log.show_backtraces.should == true
+      end
+      log.show_backtraces.should == false
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe YARD::Parser::Base do
+  describe '#initialize' do
+    class MyParser < Parser::Base; def initialize(a, b) end end
+    
+    it "should take 2 arguments" do
+      lambda { YARD::Parser::Base.new }.should raise_error(ArgumentError, 
+        /wrong (number|#) of arguments|given 0, expected 2/)
+    end
+    
+    it "should raise NotImplementedError on #initialize" do
+      lambda { YARD::Parser::Base.new('a', 'b') }.should raise_error(NotImplementedError)
+    end
+
+    it "should raise NotImplementedError on #parse" do
+      lambda { MyParser.new('a', 'b').parse }.should raise_error(NotImplementedError)
+    end
+
+    it "should raise NotImplementedError on #tokenize" do
+      lambda { MyParser.new('a', 'b').tokenize }.should raise_error(NotImplementedError)
+    end
+  end
+end