nutshell-crm 0.0.1 → 0.0.2

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

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AliasHandler" do
+  before(:all) { parse_file :alias_handler_001, __FILE__ }
+
+  it "should throw alias into namespace object list" do
+    P(:A).aliases[P("A#b")].should == :a
+  end
+  
+  ['c', 'd?', '[]', '[]=', '-@', '%', '*'].each do |a|
+    it "should handle the Ruby 'alias' keyword syntax for method ##{a}" do
+      P('A#' + a).should be_instance_of(CodeObjects::MethodObject)
+    end
+  end
+  
+  it "should handle keywords as the alias name" do
+    P('A#for').should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should allow ConstantNames to be specified as aliases" do
+    P('A#ConstantName').should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should create a new method object for the alias" do
+    P("A#b").should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should pull the method into the current class if it's from another one" do
+    P(:B).aliases[P("B#q")].should == :x
+    P(:B).aliases[P("B#r?")].should == :x
+  end
+  
+  it "should gracefully fail to pull a method in if the original method cannot be found" do
+    P(:B).aliases[P("B#s")].should == :to_s
+  end
+  
+  it "should allow complex Ruby expressions after the alias parameters" do
+    P(:B).aliases[P("B#t")].should == :inspect
+  end
+  
+  it "should show up in #is_alias? for method" do
+    P("B#t").is_alias?.should == true 
+    P('B#r?').is_alias?.should == true
+  end
+
+  it "should allow operators and keywords to be specified as symbols" do
+    P('B#<<').should be_instance_of(CodeObjects::MethodObject)
+    P('B#for').should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should handle keywords in alias names" do
+    P('B#do').is_alias?.should == true
+    P('B#x2').is_alias?.should == true
+    P(:B).aliases[P('B#do')].should == :x
+    P(:B).aliases[P('B#x2')].should == :do
+  end
+  
+  it "should handle quoted symbols" do
+    foo = Registry.at('A#foo')
+    foo.should_not be_nil
+    foo.should be_is_alias
+    Registry.at('A').aliases[foo].should == :a
+  end
+  
+  it "should prepend aliases object's docstring to comments" do
+    Registry.at('D#a').tag(:return).types.should == ['Numeric']
+    Registry.at('D#b').tag(:return).types.should == ['String']
+    Registry.at('D#b').docstring.should == "Foo bar"
+  end
+  
+  it "should raise an UndocumentableError if only one parameter is passed" do
+    undoc_error "alias_method :q"
+  end
+  
+  it "should raise an UndocumentableError if the parameter is not a Symbol or String" do
+    undoc_error "alias_method CONST, Something"
+    undoc_error "alias_method variable, ClassName"
+    undoc_error "alias_method variable, other_variable"
+  end
+end

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

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandler" do
+  before(:all) { parse_file :attribute_handler_001, __FILE__ }
+  
+  def read_write(namespace, name, read, write, scope = :instance)
+    rname, wname = namespace.to_s+"#"+name.to_s, namespace.to_s+"#"+name.to_s+"="
+    if read
+      Registry.at(rname).should be_instance_of(CodeObjects::MethodObject) 
+    else
+      Registry.at(rname).should == nil
+    end
+    
+    if write
+      Registry.at(wname).should be_kind_of(CodeObjects::MethodObject) 
+    else
+      Registry.at(wname).should == nil
+    end     
+    
+    attrs = Registry.at(namespace).attributes[scope][name]
+    attrs[:read].should == (read ? Registry.at(rname) : nil)
+    attrs[:write].should == (write ? Registry.at(wname) : nil)
+  end
+  
+  it "should parse attributes inside modules too" do
+    Registry.at("A#x=").should_not == nil
+  end
+  
+  it "should parse 'attr'" do
+    read_write(:B, :a, true, true)
+    read_write(:B, :a2, true, false)
+    read_write(:B, "a3", true, false)
+  end
+  
+  it "should parse 'attr_reader'" do
+    read_write(:B, :b, true, false)
+  end
+  
+  it "should parse 'attr_writer'" do
+    read_write(:B, :e, false, true)
+  end
+  
+  it "should parse 'attr_accessor'" do
+    read_write(:B, :f, true, true)
+  end
+  
+  it "should parse a list of attributes" do
+    read_write(:B, :b, true, false)
+    read_write(:B, :c, true, false)
+    read_write(:B, :d, true, false)
+  end
+  
+  it "should have a default docstring if one is not supplied" do
+    Registry.at("B#f=").docstring.should_not be_empty
+  end
+  
+  it "should set the correct docstring if one is supplied" do
+    Registry.at("B#b").docstring.should == "Docstring"
+    Registry.at("B#c").docstring.should == "Docstring"
+    Registry.at("B#d").docstring.should == "Docstring"
+  end
+  
+  it "should be able to differentiate between class and instance attributes" do
+    P('B').class_attributes[:z][:read].scope.should == :class
+    P('B').instance_attributes[:z][:read].scope.should == :instance
+  end
+  
+  it "should respond true in method's #is_attribute?" do
+    P('B#a').is_attribute?.should == true
+    P('B#a=').is_attribute?.should == true
+  end
+  
+  it "should not return true for #is_explicit? in created methods" do
+    Registry.at(:B).meths.each do |meth|
+      meth.is_explicit?.should == false
+    end
+  end
+  
+  it "should handle attr call with no arguments" do
+    lambda { StubbedSourceParser.parse_string "attr" }.should_not raise_error
+  end
+  
+  it "should add existing reader method as part of attr_writer combo" do
+    Registry.at('C#foo=').attr_info[:read].should == Registry.at('C#foo')
+  end
+
+  it "should add existing writer method as part of attr_reader combo" do
+    Registry.at('C#foo').attr_info[:write].should == Registry.at('C#foo=')
+  end
+  
+  it "should maintain visibility for attr_reader" do
+    Registry.at('D#parser').visibility.should == :protected
+  end
+end

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

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'ostruct'
+
+include Parser
+
+describe YARD::Handlers::Base do
+  describe "#handles and inheritance" do
+    before do
+      Handlers::Base.stub!(:inherited)
+    end
+  
+    it "should keep track of subclasses" do
+      Handlers::Base.should_receive(:inherited).once
+      class TestHandler < Handlers::Base; end
+    end
+  
+    it "should raise NotImplementedError if process is called on a class with no #process" do
+      class TestNotImplementedHandler < Handlers::Base
+      end
+    
+      lambda { TestNotImplementedHandler.new(0, 0).process }.should raise_error(NotImplementedError)
+    end
+  
+    it "should allow multiple handles arguments" do
+      Handlers::Base.should_receive(:inherited).once
+      class TestHandler1 < Handlers::Base
+        handles :a, :b, :c
+      end
+      TestHandler1.handlers.should == [:a, :b, :c]
+    end
+
+    it "should allow multiple handles calls" do
+      Handlers::Base.should_receive(:inherited).once
+      class TestHandler2 < Handlers::Base
+        handles :a
+        handles :b
+        handles :c
+      end
+      TestHandler2.handlers.should == [:a, :b, :c]
+    end
+  end
+  
+  describe 'transitive tags' do
+    it "should add transitive tags to children" do
+      Registry.clear
+      YARD.parse_string <<-eof
+        # @since 1.0
+        # @author Foo
+        class A
+          def foo; end
+          # @since 1.1
+          def bar; end
+        end
+      eof
+      Registry.at('A').tag(:since).text.should == "1.0"
+      Registry.at('A#foo').tag(:since).text.should == "1.0"
+      Registry.at('A#bar').tag(:since).text.should == "1.1"
+      Registry.at('A#bar').tag(:author).should be_nil
+    end
+  end
+  
+  describe 'sharing global state' do
+    it "should allow globals to share global state among handlers" do
+      class GlobalStateHandler1 < Handlers::Ruby::Base
+        class << self; attr_accessor :state end
+        handles :class
+        process { self.class.state = globals.foo; globals.foo = :bar }
+      end
+
+      class GlobalStateHandler2 < Handlers::Ruby::Base
+        class << self; attr_accessor :state end
+        handles :def
+        process { self.class.state = globals.foo }
+      end
+
+      2.times do
+        YARD.parse_string 'class Foo; end; def foo; end'
+        GlobalStateHandler1.state.should == nil
+        GlobalStateHandler2.state.should == :bar
+      end
+    end
+  end if HAVE_RIPPER
+  
+  describe '#push_state' do
+    def process(klass)
+      state = OpenStruct.new(:namespace => "ROOT", :scope => :instance, :owner => "ROOT")
+      klass.new(state, nil).process
+    end
+    
+    it "should push and return all old state info after block" do
+      class PushStateHandler1 < Handlers::Base
+        def process
+          push_state(:namespace => "FOO", :scope => :class, :owner => "BAR") do
+            namespace.should == "FOO"
+            scope.should == :class
+            owner.should == "BAR"
+          end
+          namespace.should == "ROOT"
+          owner.should == "ROOT"
+          scope.should == :instance
+        end
+      end
+      process PushStateHandler1
+    end
+    
+    it "should allow owner to be pushed individually" do
+      class PushStateHandler2 < Handlers::Base
+        def process
+          push_state(:owner => "BAR") do
+            namespace.should == "ROOT"
+            scope.should == :instance
+            owner.should == "BAR"
+          end
+          owner.should == "ROOT"
+        end
+      end
+      process PushStateHandler2
+    end
+    
+    it "should allow scope to be pushed individually" do
+      class PushStateHandler3 < Handlers::Base
+        def process
+          push_state(:scope => :foo) do
+            namespace.should == "ROOT"
+            scope.should == :foo
+            owner.should == "ROOT"
+          end
+          scope.should == :instance
+        end
+      end
+      process PushStateHandler3
+    end
+  end
+  
+  describe '.in_file' do
+    def parse(filename, parser_type, src = "class A; end")
+      parser = Parser::SourceParser.new(parser_type)
+      parser.instance_variable_set("@file", filename)
+      parser.parse(StringIO.new(src))
+    end
+    
+    def create_handler(stmts, parser_type)
+      $handler_counter ||= 0
+      sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
+      instance_eval(<<-eof)
+        class ::InFileHandler#{$handler_counter += 1} < Handlers::Ruby::#{sklass}
+          handles /^class/
+          #{stmts}
+          def process; MethodObject.new(:root, :FOO) end
+        end
+      eof
+    end
+    
+    def test_handler(file, stmts, creates = true, parser_type = :ruby)
+      Registry.clear
+      Registry.at('#FOO').should be_nil
+      create_handler(stmts, parser_type)
+      parse(file, parser_type)
+      Registry.at('#FOO').send(creates ? :should_not : :should, be_nil)
+      Handlers::Base.subclasses.delete_if {|k,v| k.to_s =~ /^InFileHandler/ }
+    end
+    
+    [:ruby, :ruby18].each do |parser_type|
+      next if parser_type == :ruby && LEGACY_PARSER
+      describe "Parser type = #{parser_type.inspect}" do
+        it "should allow handler to be specific to a file" do
+          test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
+        end
+    
+        it "should ignore handler if filename does not match" do
+          test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
+        end
+
+        it "should only test filename part when given a String" do
+          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
+        end
+    
+        it "should test exact match for entire String" do
+          test_handler 'file_a.rb', 'in_file "file"', false, parser_type
+        end
+
+        it "should allow a Regexp as argument and test against full path" do
+          test_handler 'file_a.rbx', 'in_file /\.rbx$/', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true, parser_type
+        end
+
+        it "should allow multiple in_file declarations" do
+          stmts = 'in_file "x"; in_file /y/; in_file "foo.rb"'
+          test_handler 'foo.rb', stmts, true, parser_type
+          test_handler 'xyzzy.rb', stmts, true, parser_type
+          test_handler 'x', stmts, true, parser_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
+  before(:all) { parse_file :class_condition_handler_001, __FILE__ }
+  
+  def verify_method(*names)
+    names.each {|name| Registry.at("A##{name}").should_not be_nil }
+    names.each {|name| Registry.at("A##{name}not").should be_nil }
+  end
+  
+  def no_undoc_error(code)
+    lambda { StubbedSourceParser.parse_string(code) }.should_not raise_error
+  end
+  
+  it "should parse all unless blocks for complex conditions" do
+    verify_method :g
+  end
+  
+  it "should not parse conditionals inside methods" do
+    verify_method :h
+  end
+  
+  it "should only parse then block if condition is literal value `true`" do
+    verify_method :p
+  end
+  
+  it "should only parse then block if condition is literal integer != 0" do
+    verify_method :o
+  end
+  
+  it "should invert block to parse for literal condition if it's an unless block" do
+    verify_method :e
+  end
+  
+  it "should handle conditions such as 'defined? VALUE'" do
+    verify_method :j, :k
+  end
+  
+  it "should parse all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
+
+  it "should only parse else block if condition is literal value `false`" do
+    verify_method :q
+  end
+
+  it "should only parse else block if condition is literal integer == 0" do
+    verify_method :n
+  end
+  
+  it "should not fail on complex conditions" do
+    log.should_not_receive(:warn)
+    log.should_not_receive(:error)
+    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
+    no_undoc_error(<<-eof)
+      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
+        'String'
+      TEST
+    eof
+    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
+  end
+end

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

@@ -0,0 +1,246 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
+  before(:all) { parse_file :class_handler_001, __FILE__ }
+  
+  it "should parse a class block with docstring" do
+    P("A").docstring.should == "Docstring"
+  end
+  
+  it "should handle complex class names" do
+    P("A::B::C").should_not == nil
+  end
+  
+  it "should handle the subclassing syntax" do
+    P("A::B::C").superclass.should == P(:String)
+    P("A::X").superclass.should == Registry.at("A::B::C")
+  end
+  
+  it "should interpret class << self as a class level block" do
+    P("A.classmethod1").should_not == nil
+  end
+  
+  it "should interpret class << ClassName as a class level block in ClassName's namespace" do
+    P("A::B::C.Hello").should be_instance_of(CodeObjects::MethodObject)
+  end
+  
+  it "should make visibility public when parsing a block" do
+    P("A::B::C#method1").visibility.should == :public
+  end
+  
+  it "should set superclass type to :class if it is a Proxy" do
+    P("A::B::C").superclass.type.should == :class
+  end
+  
+  it "should look for a superclass before creating the class if it shares the same name" do
+    P('B::A').superclass.should == P('A')
+  end
+
+  it "should handle class definitions in the form ::ClassName" do
+    Registry.at("MyRootClass").should_not be_nil
+  end
+  
+  it "should handle superclass as a constant-style method (camping style < R /path/)" do
+    P('Test1').superclass.should == P(:R)
+    P('Test2').superclass.should == P(:R)
+    P('Test6').superclass.should == P(:NotDelegateClass)
+  end
+  
+  it "should handle superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
+    P('Test3').superclass.should == P(:Struct)
+    P('Test4').superclass.should == P(:OStruct)
+  end
+  
+  it "should handle DelegateClass(CLASSNAME) superclass syntax" do
+    P('Test5').superclass.should == P(:Array)
+  end
+  
+  it "should handle a superclass of the same name in the form ::ClassName" do
+    P('Q::Logger').superclass.should == P(:Logger)
+    P('Q::Foo').superclass.should_not == P('Q::Logger')
+  end
+  
+  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
+    it "should raise an UndocumentableError for invalid class '#{klass}'" do
+      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
+    end
+  end
+  
+  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
+    it "should raise an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
+      YARD::CodeObjects::ClassObject.should_receive(:new).with(Registry.root, 'A')
+      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
+      Registry.at('A').superclass.should == P(:Object)
+    end
+  end
+  
+  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
+    it "should raise an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
+      with_parser(:ruby18) do
+        undoc_error <<-eof
+          CONST = #{klass}
+          class << CONST; end
+        eof
+      end
+      Registry.at(klass).should be_nil
+    end
+  end
+
+  it "should document 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
+    Registry.at('String.classmethod').should_not be_nil
+  end
+  
+  it "should allow class << SomeRubyClass to create the class if it does not exist" do
+    Registry.at('Symbol.toString').should_not be_nil
+  end
+  
+  it "should document 'class Exception' without running into superclass issues" do
+    Parser::SourceParser.parse_string <<-eof
+      class Exception
+      end
+    eof
+    Registry.at(:Exception).should_not be_nil
+  end
+  
+  it "should document 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
+    Registry.at(:RT).should_not be_nil
+    Registry.at(:RT).superclass.should == P('XX::RT')
+  end
+  
+  it "should not overwrite docstring with an empty one" do
+    Registry.at(:Zebra).docstring.should == "Docstring 2"
+  end
+  
+  it "should turn 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
+    obj = Registry.at("Point")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:x, :y, :z].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 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
+    obj = Registry.at("AnotherPoint")
+    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
+
+    Registry.at("XPoint").should be_nil
+  end
+  
+  it "should create a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
+    obj = Registry.at("Struct::XPoint")
+    obj.should_not be_nil
+  end
+  
+  it "should attach attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
+    obj = Registry.at("Struct::XPoint")
+    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 use @attr to set attribute descriptions on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#input")
+    obj.docstring.should == "the input stream"
+  end
+  
+  it "should use @attr to set attribute types on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#someproc")
+    obj.should_not be_nil
+    obj.tag(:return).should_not be_nil
+    obj.tag(:return).types.should == ["Proc", "#call"]
+  end
+  
+  it "should default types unspecified by @attr to Object on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#mode")
+    obj.should_not be_nil
+    obj.tag(:return).should_not be_nil
+    obj.tag(:return).types.should == ["Object"]
+  end
+  
+  it "should create parameters for writers of Struct subclass's attributes" do
+    obj = Registry.at("DoccedStruct#input=")
+    obj.tags(:param).size.should == 1
+    obj.tag(:param).types.should == ["IO"]
+  end
+  
+  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
+    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
+      it "defines both readers and writers when @attr is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:first][:read].should_not be_nil
+        attrs[:first][:write].should_not be_nil
+      end
+  
+      it "defines only a reader when only @attr_reader is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:second][:read].should_not be_nil
+        attrs[:second][:write].should be_nil
+      end
+  
+      it "defines only a writer when only @attr_writer is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:third][:read].should be_nil
+        attrs[:third][:write].should_not be_nil
+      end
+  
+      it "defines a reader with correct return types when @attr_reader is used on Structs" do
+        obj = Registry.at("#{struct}#second")
+        obj.tag(:return).types.should == ["Fixnum"]
+      end
+  
+      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
+        obj = Registry.at("#{struct}#third=")
+        obj.tag(:param).types.should == ["Array"]
+      end
+  
+      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:fourth][:read].should_not be_nil
+        attrs[:fourth][:write].should_not be_nil
+      end
+  
+      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth")
+        obj.tag(:return).types.should == ["#read"]
+      end
+  
+      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth=")
+        obj.tag(:param).types.should == ["IO"]
+      end
+  
+      it "extracts text from @attr_reader" do
+        Registry.at("#{struct}#fourth").docstring.should == "returns a proc that reads"
+      end
+  
+      it "extracts text from @attr_writer" do
+        Registry.at("#{struct}#fourth=").docstring.should == "sets the proc that writes stuff"
+      end
+    end
+  end
+    
+  it "should inherit from a regular struct" do
+    Registry.at('RegularStruct').superclass.should == P(:Struct)
+    Registry.at('RegularStruct2').superclass.should == P(:Struct)
+  end
+  
+  it "should handle inheritance from 'self'" do
+    Registry.at('Outer1::Inner1').superclass.should == Registry.at('Outer1')
+  end
+end