nutshell-crm 0.0.1 → 0.0.2

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

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
+  before(:all) { parse_file :class_variable_handler_001, __FILE__ }
+  
+  it "should not parse class variables inside methods" do
+    obj = Registry.at("A::B::@@somevar")
+    obj.source.should == "@@somevar = \"hello\""
+    obj.value.should == '"hello"'
+  end
+end

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

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
+  before(:all) { parse_file :constant_handler_001, __FILE__ }
+  
+  it "should not parse constants inside methods" do
+    Registry.at("A::B::SOMECONSTANT").source.should == "SOMECONSTANT= \"hello\""
+  end
+  
+  it "should only parse valid constants" do
+    Registry.at("A::B::notaconstant").should be_nil
+  end
+  
+  it "should maintain newlines" do
+    Registry.at("A::B::MYCONSTANT").value.gsub("\r", "").should == "A +\nB +\nC +\nD"
+  end
+  
+  it "should turn Const = Struct.new(:sym) into class Const with attr :sym" do
+    obj = Registry.at("MyClass")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+  end
+
+  it "should turn Const = Struct.new('Name', :sym) into class Const with attr :sym" do
+    obj = Registry.at("NotMyClass")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+
+    Registry.at("NotMyClass2").should be_nil
+  end
+  
+  it "should turn Const = Struct.new into empty struct" do
+    obj = Registry.at("MyEmptyStruct")
+    obj.should_not be_nil
+    obj.attributes[:instance].should be_empty
+  end
+  
+  it "should maintain docstrings on structs defined via constants" do
+    obj = Registry.at("DocstringStruct")
+    obj.should_not be_nil
+    obj.docstring.should == "A crazy struct."
+    obj.attributes[:instance].should_not be_empty
+    a1 = Registry.at("DocstringStruct#bar")
+    a2 = Registry.at("DocstringStruct#baz")
+    a1.docstring.should == "An attr"
+    a1.tag(:return).types.should == ["String"]
+    a2.docstring.should == "Another attr"
+    a2.tag(:return).types.should == ["Number"]
+  end
+  
+  it "should raise undocumentable error in 1.9 parser for Struct.new assignment to non-const" do
+    undoc_error "nonconst = Struct.new"
+  end unless LEGACY_PARSER
+end

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

@@ -0,0 +1,44 @@
+module A
+  def a; end
+  alias_method :b, :a
+  
+  # Handle keyword syntax too
+  alias :c :a
+  alias d? a
+  alias [] a
+  alias []= a
+  alias -@ a
+  alias % a
+  alias * a
+  alias for a
+  alias ConstantName a
+  
+  # Handle quoted symbols
+  alias :'foo' :'a'
+end
+
+class C
+  def x; end
+end
+
+class B < C
+  alias_method(:q, :x)
+  alias_method :r?, :x
+  alias_method :s, :to_s 
+  alias_method :t, :inspect if 500 == 3 * CONSTANT
+  alias_method :<<, :a
+  alias_method :for, :a
+  alias do x
+  alias x2 do
+end
+
+class D
+  # Foo bar
+  def a; "FOO" end
+  
+  # @return [String]
+  alias b a
+  
+  # @return [Numeric]
+  def a; 0 end
+end

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

@@ -0,0 +1,32 @@
+module A
+  attr_writer :x
+end
+
+class B
+  class << self
+    attr_accessor :z
+  end
+
+  attr :a, true
+  attr :a2, false
+  attr :a3
+  # Docstring
+  attr_reader :b, :c, :d
+  attr_writer :e
+  attr_accessor 'f'
+
+  attr_accessor :z
+end
+
+class C
+  def foo; end
+  attr_writer :foo
+
+  def bar=(value); end
+  attr_reader :bar
+end
+
+class D
+protected
+attr_reader :parser
+end

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

@@ -0,0 +1,61 @@
+class A
+  if some_condition
+    def a; end
+  elsif 1 == 1
+    def b; end
+  else
+    def c; end
+  end
+  
+  def d; end if 50 * 2 == 101
+  
+  unless false
+    def e; end
+  else
+    def enot; end
+  end
+  
+  def g; end unless 5 * 2 == 101
+
+  def h
+    if 1
+      def hnot; end
+    end
+  end
+  
+  if defined? A
+    def j; end
+  else
+    def jnot; end
+  end
+  
+  if defined? RUBY_VERSION
+    def k; end
+  else
+    def knot; end
+  end
+  
+  if 0
+    def nnot; end
+  else
+    def n; end
+  end
+  
+  if 256
+    def o; end
+  else
+    def onot; end
+  end
+  
+  if true
+    def p; end
+  else
+    def pnot; end
+  end
+  
+  if false
+    def qnot; end
+  else
+    def q; end
+  end
+end

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

@@ -0,0 +1,120 @@
+# Docstring
+class A
+  module B; end
+  private
+  class B::C < String; 
+    def method1; end
+    def method2; end
+  end
+  class X<B::C
+  end
+  class<<self
+    def classmethod1; end
+  end
+
+  class << A::B::C; def Hello; end end
+end
+
+module B
+  class A < A
+  end
+end
+
+class RT < XX::RT; end
+
+class Test1 < R "something"
+end
+
+class Test2 < R(/something/)
+end
+
+class Test3 < Struct.new(:foo, :bar)
+end
+
+class Test4 < OStruct.new
+end
+
+class Test5 < DelegateClass(Array)
+end
+
+class Test6 < NotDelegateClass(Array)
+end
+
+class ::MyRootClass
+end
+
+module Holder
+  module SomeMod
+    class Importer
+      def parse; end
+    end
+  end
+end
+
+module Holder
+  class Importer < Holder::SomeMod::Importer
+    def a; end
+  end
+end
+
+class String; end
+CONST = String
+class << CONST
+  def classmethod; end
+end
+
+module Q
+  class Logger < ::Logger; end
+  class Foo < ::Logger; end
+end
+
+class << Symbol
+  alias toString to_s
+end
+
+# Docstring
+class Zebra
+end
+
+# Docstring 2
+
+class Zebra
+end
+
+class Zebra
+end
+
+# A simple struct
+class RegularStruct < Struct; end
+class RegularStruct2 < ::Struct; end
+
+class Point < Struct.new(:x, :y, :z)
+end
+
+class AnotherPoint < Struct.new('XPoint', :a, :b, :c, :description)
+end
+
+# @attr [IO] input the input stream
+# @attr mode the mode to read
+# @attr [Proc, #call] someproc the proc to run
+class DoccedStruct < Struct.new(:input, :mode, :someproc)
+end
+
+# @attr [String] first the first entry
+# @attr_reader [Fixnum] second this only has a reader
+# @attr_writer [Array] third this only has a writer
+# @attr_reader [#read] fourth returns a proc that reads
+# @attr_writer [IO] fourth sets the proc that writes stuff
+class SemiDoccedStruct < Struct.new(:first, :second, :third, :fourth)
+end
+
+# @attr [String] first the first entry
+# @attr_reader [Fixnum] second this only has a reader
+# @attr_writer [Array] third this only has a writer
+# @attr_reader [#read] fourth returns a proc that reads
+# @attr_writer [IO] fourth sets the proc that writes stuff
+class NotAStruct; end
+
+class Outer1
+  class Inner1 < self; end
+end

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

@@ -0,0 +1,10 @@
+module A
+  class B
+    @@somevar = "hello"
+	@@somevar.value = "H"
+
+    def method
+      @@somevar = "don't document this"
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module A
+  class B
+	notaconstant = 2
+    SOMECONSTANT= "hello"
+
+    def method
+      SOMECONSTANT = "don't document this"
+    end
+
+    MYCONSTANT = A +
+      B +
+      C +
+      D
+  end
+end
+
+MyClass = Struct.new(:a, :b, :c)
+NotMyClass = Struct.new("NotMyClass2", :b, :c)
+MyEmptyStruct = Struct.new
+
+# A crazy struct.
+#
+# @attr [String] bar An attr
+# @attr [Number] baz Another attr
+DocstringStruct = Struct.new(:bar, :baz)

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

@@ -0,0 +1,59 @@
+class Testing
+  # Ignore yields outside methods
+  raise NoMethodError, "reason"
+  
+  # Should document this
+  def mymethod
+    raise ArgumentError, "Argument is missing"
+  end
+  
+  # Don't document this
+  def mymethod2
+    raise(a) 
+  end
+  
+  # Don't document this (docstring takes precedence)
+  # @raise [A]
+  def mymethod3 
+    raise SomethingElse
+  end
+  
+  # Only document the first one (limitation of exc handler)
+  def mymethod4 
+    raise(A)
+    raise B, "Argument", somethingelse
+  end
+  
+  def mymethod5
+    raise YARD::Parser::UndocumentableError
+  end
+  
+  def mymethod6
+    raise YARD::Handlers.constants("test")
+  end
+  
+  def mymethod7
+    raise MethodCall('argument')
+  end
+  
+  def mymethod8
+    raise ExceptionClass.new('blah')
+  end
+
+  def mymethod9
+    obj.raise IgnoreMe
+	obj.raise(IgnoreMe)
+  end
+  
+  def mymethod10
+    raise ArgumentError 'Message' # actually a method call
+  end
+  
+  def mymethod11
+    raise foo('bar')
+  end
+  
+  def mymethod12
+    raise
+  end
+end

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

@@ -0,0 +1,16 @@
+module A; end
+module B
+  extend A
+end
+
+module C
+  extend self
+end
+
+module Q
+  module R
+    module S
+      extend A
+    end
+  end
+end