nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/code_objects/module_object_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::ModuleObject do
+  describe "#meths" do
+    before do 
+      Registry.clear 
+    
+      # setup the object space:
+      # 
+      #   YARD:module
+      #   YARD#foo:method
+      #   YARD#foo2:method
+      #   YARD#xyz:method
+      #   YARD.bar:method
+      #   SomeMod#mixmethod
+      #   SomeMod#xyz:method
+      # 
+      @yard = ModuleObject.new(:root, :YARD)
+      MethodObject.new(@yard, :foo)
+      MethodObject.new(@yard, :xyz)
+      MethodObject.new(@yard, :foo2) do |o|
+        o.visibility = :protected
+      end
+      MethodObject.new(@yard, :bar, :class) do |o|
+        o.visibility = :private
+      end
+      @other = ModuleObject.new(:root, :SomeMod)
+      MethodObject.new(@other, :mixmethod)
+      MethodObject.new(@other, :xyz)
+      MethodObject.new(@other, :baz, :class)
+      @another = ModuleObject.new(:root, :AnotherMod)
+      MethodObject.new(@another, :fizz)
+      MethodObject.new(@another, :bar)
+      MethodObject.new(@another, :fazz, :class)
+    
+      @yard.instance_mixins << @other
+      @yard.class_mixins << @another
+    end
+  
+    it "should list all methods (including mixin methods) via #meths" do
+      meths = @yard.meths
+      meths.should include(P("YARD#foo"))
+      meths.should include(P("YARD#foo2"))
+      meths.should include(P("YARD.bar"))
+      meths.should include(P("SomeMod#mixmethod"))
+      meths.should include(P("AnotherMod#fizz"))
+    end
+  
+    it "should allow :visibility to be set" do
+      meths = @yard.meths(:visibility => :public)
+      meths.should_not include(P("YARD.bar"))
+      meths = @yard.meths(:visibility => [:public, :private])
+      meths.should include(P("YARD#foo"))
+      meths.should include(P("YARD.bar"))
+      meths.should_not include(P("YARD#foo2"))
+    end
+  
+    it "should only display class methods for :scope => :class" do
+      meths = @yard.meths(:scope => :class)
+      meths.should_not include(P("YARD#foo"))
+      meths.should_not include(P("YARD#foo2"))
+      meths.should_not include(P("SomeMod#mixmethod"))
+      meths.should_not include(P("SomeMod.baz"))
+      meths.should_not include(P("AnotherMod#fazz"))
+      meths.should include(P("YARD.bar"))
+      meths.should include(P("AnotherMod#fizz"))
+    end
+  
+    it "should only display instance methods for :scope => :class" do
+      meths = @yard.meths(:scope => :instance)
+      meths.should include(P("YARD#foo"))
+      meths.should include(P("YARD#foo2"))
+      meths.should include(P("SomeMod#mixmethod"))
+      meths.should_not include(P("YARD.bar"))
+      meths.should_not include(P("AnotherMod#fizz"))
+    end
+  
+    it "should allow :included to be set" do
+      meths = @yard.meths(:included => false)
+      meths.should_not include(P("SomeMod#mixmethod"))
+      meths.should_not include(P("AnotherMod#fizz"))
+      meths.should include(P("YARD#foo"))
+      meths.should include(P("YARD#foo2"))
+      meths.should include(P("YARD.bar"))
+    end
+  
+    it "should choose the method defined in the class over an included module" do
+      meths = @yard.meths
+      meths.should_not include(P("SomeMod#xyz"))
+      meths.should include(P("YARD#xyz"))
+      meths.should_not include(P("AnotherMod#bar"))
+      meths.should include(P("YARD.bar"))
+    
+      meths = @other.meths
+      meths.should include(P("SomeMod#xyz"))
+
+      meths = @another.meths
+      meths.should include(P("AnotherMod#bar"))
+    end
+  end
+
+  describe "#inheritance_tree" do
+    before do
+      Registry.clear
+
+      @mod1 = ModuleObject.new(:root, :Mod1)
+      @mod2 = ModuleObject.new(:root, :Mod2)
+      @mod3 = ModuleObject.new(:root, :Mod3)
+      @mod4 = ModuleObject.new(:root, :Mod4)
+      @mod5 = ModuleObject.new(:root, :Mod5)
+
+      @mod1.instance_mixins << @mod2
+      @mod2.instance_mixins << @mod3
+      @mod3.instance_mixins << @mod4
+      @mod1.instance_mixins << @mod4
+    
+      @proxy = P(:SomeProxyClass)
+      @mod5.instance_mixins << @proxy
+    end
+
+    it "should show only itself for an inheritance tree without included modules" do
+      @mod1.inheritance_tree.should == [@mod1]
+    end
+
+    it "should show proper inheritance three when modules are included" do
+      @mod1.inheritance_tree(true).should == [@mod1, @mod2, @mod3, @mod4]
+    end
+  
+    it "should not list inheritance tree of proxy objects in inheritance tree" do
+      @proxy.should_not_receive(:inheritance_tree)
+      @mod5.instance_mixins.should == [@proxy]
+    end
+    
+    it "should list class mixins in inheritance tree" do
+      mod = ModuleObject.new(:root, :ClassMethods)
+      recvmod = ModuleObject.new(:root, :ReceivingModule)
+      recvmod.class_mixins << mod
+      recvmod.inheritance_tree(true).should == [recvmod, mod]
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/code_objects/namespace_object_spec.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::NamespaceObject do
+  before { Registry.clear }
+  
+  describe '#child' do
+    it "should return the object matching the name passed in if argument is a Symbol" do
+      obj = NamespaceObject.new(nil, :YARD)
+      other = NamespaceObject.new(obj, :Other)
+      obj.child(:Other).should == other
+      obj.child('Other').should == other
+    end
+
+    it "should look for attributes matching the object if the argument is a Hash" do
+      obj = NamespaceObject.new(nil, :YARD)
+      NamespaceObject.new(obj, :NotOther)
+      other = NamespaceObject.new(obj, :Other)
+      other.somevalue = 2
+      obj.child(:somevalue => 2).should == other
+    end
+  end
+  
+  describe '#meths' do
+    it "should return #meths even if parent is a Proxy" do
+      obj = NamespaceObject.new(P(:String), :YARD)
+      obj.meths.should be_empty
+    end
+
+    it "should not list included methods that are already defined in the namespace using #meths" do
+      a = ModuleObject.new(nil, :Mod1)
+      ameth = MethodObject.new(a, :testing)
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :foo)
+      c = NamespaceObject.new(nil, :YARD)
+      cmeth = MethodObject.new(c, :testing)
+      cmeth2 = MethodObject.new(c, :foo)
+      c.instance_mixins << a
+      c.class_mixins << b
+
+      meths = c.meths
+      meths.should include(bmeth)
+      meths.should include(cmeth)
+      meths.should include(cmeth2)
+      meths.should_not include(ameth)
+
+      meths = c.included_meths
+      meths.should include(bmeth)
+      meths.should_not include(ameth)
+      meths.should_not include(cmeth)
+      meths.should_not include(cmeth2)
+    end
+  end
+
+  describe '#included_meths' do
+    it "should list methods mixed into the class scope as class methods" do
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :foo)
+      bmeth2 = MethodObject.new(b, :foo2)
+      c = NamespaceObject.new(nil, :YARD)
+      c.class_mixins << b
+
+      [bmeth, bmeth2].each {|o| o.scope.should == :instance }
+      meths = c.included_meths(:scope => :class)
+      meths.each {|o| o.scope.should == :class }
+    end
+
+    it "should not list methods overridden by another included module" do
+      a = ModuleObject.new(nil, :Mod)
+      ameth = MethodObject.new(a, :testing)
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :testing)
+      c = NamespaceObject.new(nil, :YARD)
+      c.instance_mixins.unshift a
+      c.instance_mixins.unshift b
+      c.class_mixins.unshift b
+      c.class_mixins.unshift a
+
+      meths = c.included_meths(:scope => :instance)
+      meths.should_not include(ameth)
+      meths.should include(bmeth)
+
+      meths = c.included_meths(:scope => :class)
+      meths.should include(ameth)
+      meths.should_not include(bmeth)
+    end
+  end
+  
+  describe '#class_attributes' do
+    it "should list class attributes" do
+      a = NamespaceObject.new(nil, :Mod)
+      a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
+      a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
+      a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
+      a.class_attributes.keys.should include(:a)
+      a.class_attributes.keys.should_not include(:b)
+    end
+  end
+  
+  describe '#instance_attributes' do
+    it "should list instance attributes" do
+      a = NamespaceObject.new(nil, :Mod)
+      a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
+      a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
+      a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
+      a.instance_attributes.keys.should include(:a)
+      a.instance_attributes.keys.should include(:b)
+    end
+  end
+  
+  describe '#constants/#included_constants' do
+    before do
+      Registry.clear
+
+      YARD.parse_string <<-eof
+        module A
+          CONST1 = 1
+          CONST2 = 2
+        end
+
+        module B
+          CONST2 = -2
+          CONST3 = -3
+        end
+
+        class C
+          CONST3 = 3
+          CONST4 = 4
+
+          include A
+          include B
+        end
+      eof
+    end
+
+    it "should list all included constants by default" do
+      consts = P(:C).constants
+      consts.should include(P('A::CONST1'))
+      consts.should include(P('C::CONST4'))
+    end
+
+    it "should allow :included to be set to false to ignore included constants" do
+      consts = P(:C).constants(:included => false)
+      consts.should_not include(P('A::CONST1'))
+      consts.should include(P('C::CONST4'))
+    end
+
+    it "should not list an included constant if it is defined in the object" do
+      consts = P(:C).constants
+      consts.should include(P('C::CONST3'))
+      consts.should_not include(P('B::CONST3'))
+    end
+
+    it "should not list an included constant if it is shadowed by another included constant" do
+      consts = P(:C).included_constants
+      consts.should include(P('B::CONST2'))
+      consts.should_not include(P('A::CONST2'))
+    end
+  end
+  
+  describe '#included_meths' do
+    it "should return all included methods with :all = true" do
+      YARD.parse_string <<-eof
+        module B; def foo; end end
+        module C; def bar; end end
+        class A; include B; include C; def foo; end; def bar; end end
+      eof
+      Registry.at('A').included_meths(:all => true).should == [P('C#bar'), P('B#foo')]
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/code_objects/proxy_spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::Proxy do
+  before { Registry.clear }
+  
+  it "should return the object if it's in the Registry" do
+    pathobj = ModuleObject.new(:root, :YARD)
+    proxyobj = P(:root, :YARD)
+    proxyobj.type.should == :module
+    Proxy.should_not === proxyobj
+  end
+  
+  it "should handle complex string namespaces" do
+    ModuleObject.new(:root, :A)
+    pathobj = ModuleObject.new(P(nil, :A), :B)
+    P(:root, "A::B").should be_instance_of(ModuleObject)
+  end
+  
+  it "should not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
+    Proxy.should === P(:root, 'a')
+    Proxy.should_not === P(:root)
+    MethodObject.new(:root, 'a')
+    Proxy.should_not === P(:root, 'a')
+    x = Proxy.new(:root, 'a')
+    Proxy.should_not === x
+  end
+  
+  it "should return the object if it's an included Module" do
+    yardobj = ModuleObject.new(:root, :YARD)
+    pathobj = ClassObject.new(:root, :TestClass)
+    pathobj.instance_mixins << yardobj
+    P(P(nil, :TestClass), :YARD).should be_instance_of(ModuleObject)
+  end
+  
+  it "should respond_to respond_to?" do
+    obj = ClassObject.new(:root, :Object)
+    yardobj = ModuleObject.new(:root, :YARD)
+    P(:YARD).respond_to?(:children).should == true
+    P(:NOTYARD).respond_to?(:children).should == false
+
+    P(:YARD).respond_to?(:initialize).should == false
+    P(:YARD).respond_to?(:initialize, true).should == true
+    P(:NOTYARD).respond_to?(:initialize).should == false
+    P(:NOTYARD).respond_to?(:initialize, true).should == true
+  end
+  
+  it "should make itself obvious that it's a proxy" do
+    pathobj = P(:root, :YARD)
+    pathobj.class.should == Proxy
+    (Proxy === pathobj).should == true
+  end    
+
+  it "should pretend it's the object's type if it can resolve" do
+    pathobj = ModuleObject.new(:root, :YARD)
+    proxyobj = P(:root, :YARD)
+    proxyobj.should be_instance_of(ModuleObject)
+  end
+  
+  it "should handle instance method names" do
+    obj = P(nil, '#test')
+    obj.name.should == :test
+    obj.path.should == "#test"
+    obj.namespace.should == Registry.root
+  end
+  
+  it "should handle instance method names under a namespace" do
+    pathobj = ModuleObject.new(:root, :YARD)
+    obj = P(pathobj, "A::B#test")
+    obj.name.should == :test
+    obj.path.should == "A::B#test"
+  end
+  
+  it "should allow type to be changed" do
+    obj = P("InvalidClass")
+    obj.type.should == :proxy
+    Proxy.should === obj
+    obj.type = :class
+    obj.type.should == :class
+  end
+  
+  it "should retain a type change between Proxy objects" do
+    P("InvalidClass").type = :class
+    P("InvalidClass").type.should == :class
+  end
+  
+  it "should never equal Registry.root" do
+    P("MYPROXY").should_not == Registry.root
+    P("X::A").should_not == Registry.root
+  end
+  
+  it "should reset namespace and name when object is resolved" do
+    obj1 = ModuleObject.new(:root, :YARD)
+    obj2 = ModuleObject.new(:root, :NOTYARD)
+    resolved = Proxy.new(obj2, :YARD)
+    resolved.should == obj1
+    resolved.namespace.should == Registry.root
+    resolved.name.should == :YARD
+  end
+  
+  it "should ensure that the correct object was resolved" do
+    foo = ModuleObject.new(:root, :Foo)
+    foobar = ModuleObject.new(foo, :Bar)
+    foobaz = ClassObject.new(foo, :Baz)
+    
+    # Remember, we're looking for Qux::Bar, not just 'Bar'
+    proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
+    proxy.type.should == :proxy
+    
+    qux = ModuleObject.new(foo, :Qux)
+    quxbar = ModuleObject.new(qux, :Bar)
+    
+    # Now it should resolve
+    proxy.type.should == :module
+  end
+  
+  
+  it "should handle constant names in namespaces" do
+    YARD.parse_string <<-eof
+      module A; end; B = A
+      module B::C; def foo; end end
+    eof
+    Proxy.new(:root, 'B::C').should == Registry.at('A::C')
+  end
+end

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

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+include CodeObjects

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

@@ -0,0 +1,167 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'yaml'
+
+describe YARD::Config do
+  describe '.load' do
+    before do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+    end
+
+    it "should use default options if no ~/.yard/config is found" do
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      YARD::Config.load
+      YARD::Config.options.should == YARD::Config::DEFAULT_CONFIG_OPTIONS
+    end
+    
+    it "should overwrite options with data in ~/.yard/config" do
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      YAML.should_receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return({'test' => true})
+      YARD::Config.load
+      YARD::Config.options[:test].should be_true
+    end
+    
+    it "should ignore any plugins specified in '~/.yard/ignored_plugins'" do
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      File.should_receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
+      YARD::Config.load
+      YARD::Config.options[:ignored_plugins].should == ['yard-plugin', 'yard-plugin2']
+      YARD::Config.should_not_receive(:require).with('yard-plugin2')
+      YARD::Config.load_plugin('yard-plugin2').should == false
+    end
+  end
+  
+  describe '.save' do
+    it "should save options to config file" do
+      YARD::Config.stub!(:options).and_return(:a => 1, :b => %w(a b c))
+      file = mock(:file)
+      File.should_receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
+      file.should_receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
+      YARD::Config.save
+    end
+  end
+  
+  describe '.load_plugin' do
+    it "should load a plugin by 'name' as 'yard-name'" do
+      YARD::Config.should_receive(:require).with('yard-foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('foo').should == true
+    end
+    
+    it "should not load plugins like 'doc-*'" do
+      YARD::Config.should_not_receive(:require).with('yard-doc-core')
+      YARD::Config.load_plugin('doc-core')
+      YARD::Config.load_plugin('yard-doc-core')
+    end
+    
+    it "should load plugin by 'yard-name' as 'yard-name'" do
+      YARD::Config.should_receive(:require).with('yard-foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('yard-foo').should == true
+    end
+    
+    it "should load plugin by 'yard_name' as 'yard_name'" do
+      YARD::Config.should_receive(:require).with('yard_foo')
+      log.should_receive(:debug).with(/Loading plugin 'yard_foo'/).once
+      log.show_backtraces = false
+      YARD::Config.load_plugin('yard_foo').should == true
+    end
+    
+    it "should log error if plugin is not found" do
+      YARD::Config.should_receive(:require).with('yard-foo').and_raise(LoadError)
+      log.should_receive(:warn).with(/Error loading plugin 'yard-foo'/).once
+      YARD::Config.load_plugin('yard-foo').should == false
+    end
+    
+    it "should sanitize plugin name (remove /'s)" do
+      YARD::Config.should_receive(:require).with('yard-foofoo')
+      YARD::Config.load_plugin('foo/foo').should == true
+    end
+    
+    it "should ignore plugins in :ignore_plugins" do
+      YARD::Config.stub!(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
+      YARD::Config.load_plugin('foo').should == false
+      YARD::Config.load_plugin('bar').should == false
+    end
+  end
+  
+  describe '.load_plugins' do
+    it "should load gem plugins if :load_plugins is true" do
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      YARD::Config.stub!(:load_plugin)
+      YARD::Config.should_receive(:require).with('rubygems')
+      YARD::Config.load_plugins
+    end
+    
+    it "should ignore gem loading if RubyGems cannot load" do
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      YARD::Config.should_receive(:require).with('rubygems').and_raise(LoadError)
+      YARD::Config.load_plugins.should == false
+    end
+    
+    it "should load certain plugins automatically when specified in :autoload_plugins" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      YARD::Config.stub!(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
+      YARD::Config.should_receive(:require).with('yard-plugin').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should parse --plugin from command line arguments" do
+      YARD::Config.should_receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
+      YARD::Config.should_receive(:load_plugin).with('foo').and_return(true)
+      YARD::Config.should_receive(:load_plugin).with('bar').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should load --plugin arguments from .yardopts" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).once.and_return(true)
+      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      File.should_receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).once.and_return('--plugin foo')
+      YARD::Config.should_receive(:load_plugin).with('foo')
+      YARD::Config.load
+    end
+    
+    it "should load any gem plugins starting with 'yard_' or 'yard-'" do
+      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
+      plugins = {
+        'yard' => mock('yard'), 
+        'yard_plugin' => mock('yard_plugin'), 
+        'yard-plugin' => mock('yard-plugin'),
+        'my-yard-plugin' => mock('yard-plugin'),
+        'rspec' => mock('rspec'),
+      }
+      plugins.each do |k, v|
+        v.should_receive(:name).at_least(1).times.and_return(k)
+      end
+      
+      source_mock = mock(:source_index)
+      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
+      Gem.should_receive(:source_index).and_return(source_mock)
+      YARD::Config.should_receive(:load_plugin).with('yard_plugin').and_return(false)
+      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_return(true)
+      YARD::Config.load_plugins.should == true
+    end
+    
+    it "should log an error if a gem raises an error" do
+      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      plugins = {
+        'yard-plugin' => mock('yard-plugin')
+      }
+      plugins.each do |k, v|
+        v.should_receive(:name).at_least(1).times.and_return(k)
+      end
+      
+      source_mock = mock(:source_index)
+      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
+      Gem.should_receive(:source_index).and_return(source_mock)
+      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
+      log.should_receive(:warn).with(/Error loading plugin 'yard-plugin'/)
+      YARD::Config.load_plugins.should == false
+    end
+  end
+end