nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/macro_handler_001.rb.txt

@@ -0,0 +1,83 @@
+class Foo
+  attr_accessor :ignoreme
+
+  # IMPLICIT METHOD!
+  # @return [String]
+  just_a_method_for :implicit0
+  
+  # Not recognized
+  just_a_method_for :implicit_invalid
+  
+  #
+  ## IS NOT RECOGNIZED!
+  just_a_method_for :implicit_invalid2
+
+  ##
+  # IS RECOGNIZED!
+  just_a_method_for 'implicit_valid'
+
+  # @attribute [r]
+  # @return [Numeric] a number
+  a_readable_attribute :attr1
+  
+  # @attribute [w]
+  a_writable_attribute :attr2, 'bar'
+
+  # @attribute
+  default_attribute :attr3
+  
+  # @attribute custom
+  default_attribute :attr4
+  
+  # @method xyz(a, b, c)
+  # The foo method
+  # @param [String] a
+  # @visibility protected
+  # @scope class
+  foo_bar
+
+  # @macro property
+  # @method $1(${3-})
+  # A $0 that is awesome.
+  # @param $3 first parameter
+  # @return [$2] the property $1
+  property :name, String, :a, :b, :c
+  
+  # @macro property
+  property :age, Fixnum, :value
+  
+  # This is just for x
+  # @macro [attach] parser
+  #   @method $1(opts = {})
+  #   @return NOTHING!
+  parser :x
+  
+  parser :c_parser
+  
+  # @macro [attach] none
+  # @method none(foo, bar)
+  none
+  
+  # @macro something
+  # @overload $1(a, b, c)
+  something :qux
+  
+  # @overload qux2(a, b, c)
+  something
+end
+
+class Bar
+  parser :x_parser
+end
+
+class Baz < Foo
+  parser :y_parser
+  none { }
+end
+
+# @method my_other_method
+# Docstring for method
+method_that_makes_a_method
+
+# @macro something
+foobarbaz :beep

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/method_condition_handler_001.rb.txt

@@ -0,0 +1,10 @@
+def a
+  if 1
+    # ignore this
+    def b; end
+  end
+  
+  # don't ignore these even though we know they're not executed
+  def c; end if false
+  def d; end unless true
+end 

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/method_handler_001.rb.txt

@@ -0,0 +1,122 @@
+class Foo
+  class << self
+    def inherited; end
+    def included; end
+    # docstring
+    def extended; end
+    def method_added; end
+    def method_removed; end
+    def method_undefined; end
+  end
+
+  # A docstring but no return type
+  def initialize; end
+
+  def ==(other)
+    'hello' 
+  end
+  def /(other) 'hi' end
+
+  attr_reader :method1
+
+  def method1
+    def dynamic; end
+  end
+ 
+  def self.method2; end
+
+  # Docstring
+  def String :: hello; "" end
+  
+  def self.new() end
+
+  def [](key = 'default') puts key end
+  def []=(key, value) end
+  def 
+allowed?
+end
+
+  def ` param; end
+  def /(x = File.new('x', 'w'), y = 2) end
+  def |; end; def =~ ()
+  def -@; end; 
+end
+  def *(o) def +@; end
+    def ~@
+    end end
+  def &(o) end
+  def %(o) end
+  def ^(o) end
+  
+  def optsmeth(x, opts = {}) end
+  def blockmeth(x, &block) end
+
+  # @param a [Fixnum]
+  # @overload def bar(a, b = 1)
+  #   @param a [String]
+  #   @return [String]
+  # @overload def baz(b, c)
+  #   @return [Fixnum]
+  # @overload bang(d, e)
+  def foo(*args); end
+
+  # No return tag
+  def boolean?; end
+
+  # @return without type
+  def boolean2?; end
+
+  # @return [NotBoolean, nil]
+  def boolean3?; end
+
+  attr_writer :attr_name
+  def attr_name; end
+
+  attr_reader :attr_name2
+  def attr_name2=; end
+
+  # @option opts :bar [String] It's bar!
+  def auto_opts(opts)
+  end
+end
+
+CONST = Foo
+def CONST.meth_on_const; end
+CONST2 = CONST
+def CONST2.meth2_on_const; end
+
+class D
+  alias b a
+  
+  # foo bar
+  def a; end
+end
+
+class E
+  # @macro prop
+  #   @method $1(value)
+  #   $3
+  #   @return [$2]
+  def self.property(name, ret_type, docstring)
+  end
+  
+  property :foo, String, "create a foo"
+  
+  # @macro xyz
+  #   @method $1
+  def xyz; end
+  
+  xyz :a
+end
+
+module F
+  class A
+    def foo; end
+    
+    def end
+    end
+    
+    # PASS
+    def bar; end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/mixin_handler_001.rb.txt

@@ -0,0 +1,33 @@
+module A; end
+module B; 
+  module C; end 
+  module D; end
+end
+
+QQQ = B::D
+
+class X
+  include A
+  include B, B::C, NOTEXIST
+end
+
+module Y
+  include B::C, B if X == 2
+  include A
+  include QQQ
+
+  class << self; include A; end
+end
+
+module ABC
+  module FOO; end
+  module DEF
+    module FOO
+      include ABC::FOO
+    end
+    
+    module BAR
+      include ABC::BAR
+    end
+  end
+end  

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/module_handler_001.rb.txt

@@ -0,0 +1,29 @@
+module ModName
+  private
+
+  # Docstring
+  module OtherModName
+  end
+end
+
+module            StressTest; end
+
+module A; end
+
+module Q
+	module A::B
+	end
+	module FOO; end
+end
+
+module ::Kernel
+  def x; end
+end
+
+module A; end
+module B; end
+module C; end
+class D; include A; include B; include C; end
+
+Z = Q
+module Z::FOO::A; end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/private_constant_handler_001.rb.txt

@@ -0,0 +1,8 @@
+module A
+  Foo = 1
+  class B; end
+  module C; end
+  module D; end
+  
+  private_constant :Foo, 'B', C
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/process_handler_001.rb.txt

@@ -0,0 +1,11 @@
+class A < NotHandler
+  process { hello }
+end
+
+class B < YARD::Handlers::Ruby::Base
+  process { test }
+end
+
+class C < YARD::Handlers::Ruby::Legacy::Base
+  process do test end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -0,0 +1,27 @@
+class Testing
+  def pub; end
+  
+  private
+
+  def priv; end
+  def notpriv; end
+  def notpriv2; end
+  def notpriv?; end
+
+  protected
+
+  def prot; end
+
+  public
+
+  def pub2; end
+
+  protected :notpriv, 'notpriv2', :notpriv?
+  
+  private name
+  private *argument
+  private *(method_call)
+  
+  def Foo; end
+  private :Foo
+end

data/vendor/bundle/gems/yard-0.7.4/spec/handlers/examples/yield_handler_001.rb.txt

@@ -0,0 +1,55 @@
+class Testing
+  # Ignore yields outside methods
+  yield x, y, z 
+  
+  # Should document this
+  def mymethod
+    yield
+  end
+  
+  # Has yield and yieldparam documentation
+  # @yield [a, b] Blah
+  # @yieldparam a Blah
+  # @yieldparam b Blah
+  def mymethod2
+    yield(b, a) # Yield something else
+  end
+  
+  # Has yield documentation only
+  # @yield [a, b]
+  def mymethod3 
+    yield self # Should not be changed
+  end
+  
+  # Has yieldparam documentation only
+  # @yieldparam _self BLAH
+  def mymethod4
+    yield self
+  end
+  
+  # Some weird possibilities..
+  # Document it all.
+  
+  
+  def mymethod5
+    yield :a, b, self, File.read('file', 'w'), CONSTANT if x == 2
+  end
+  
+  def mymethod6
+    yield(b, a)
+  end
+  
+  def mymethod7
+    yield a
+    yield b
+  end
+  
+  def mymethod8
+    yield self
+  end
+  
+  def mymethod9
+    yield super
+  end
+end
+  

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

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
+  before(:all) { parse_file :exception_handler_001, __FILE__ }
+  
+  it "should not document an exception outside of a method" do
+    P('Testing').has_tag?(:raise).should == false
+  end
+  
+  it "should document a valid raise" do
+    P('Testing#mymethod').tag(:raise).types.should == ['ArgumentError']
+  end
+  
+  it "should only document non-dynamic raises" do
+    P('Testing#mymethod2').tag(:raise).should be_nil
+    P('Testing#mymethod6').tag(:raise).should be_nil
+    P('Testing#mymethod7').tag(:raise).should be_nil
+  end
+  
+  it "should treat ConstantName.new as a valid exception class" do
+    P('Testing#mymethod8').tag(:raise).types.should == ['ExceptionClass']
+  end
+  
+  it "should not document a method with an existing @raise tag" do
+    P('Testing#mymethod3').tag(:raise).types.should == ['A']
+  end
+
+  it "should only document the first raise message of a method (limitation of exception handler)" do
+    P('Testing#mymethod4').tag(:raise).types.should == ['A']
+  end
+  
+  it "should handle complex class names" do
+    P('Testing#mymethod5').tag(:raise).types.should == ['YARD::Parser::UndocumentableError']
+  end
+  
+  it "should ignore any raise calls on a receiver" do
+    P('Testing#mymethod9').tag(:raise).should be_nil
+  end
+  
+  it "should handle raise expressions that are method calls" do
+    P('Testing#mymethod10').tag(:raise).should be_nil
+    P('Testing#mymethod11').tag(:raise).should be_nil
+  end
+  
+  it "should ignore empty raise call" do
+    P('Testing#mymethod12').tag(:raise).should be_nil
+  end
+end

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

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
+  before(:all) { parse_file :extend_handler_001, __FILE__ }
+
+  it "should include modules at class scope" do
+    Registry.at(:B).class_mixins.should == [P(:A)]
+    Registry.at(:B).instance_mixins.should be_empty
+  end
+
+  it "should handle a module extending itself" do
+    Registry.at(:C).class_mixins.should == [P(:C)]
+    Registry.at(:C).instance_mixins.should be_empty
+  end
+  
+  it "should extend module with correct namespace" do
+    Registry.at('Q::R::S').class_mixins.first.path.should == 'A'
+  end
+  
+  it "should not allow extending self if object is a class" do
+    undoc_error "class Foo; extend self; end"
+  end
+end