neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/rails/finders.rb

@@ -6,11 +6,26 @@ module Neo4j
     module Finders
       extend ActiveSupport::Concern
 
+
+      def reachable_from_ref_node?
+        # All relationships are reachable
+        respond_to?(:_java_rel) || Neo4j::Algo.all_path(self.class.ref_node_for_class, self).outgoing(self.class).outgoing(:_all).first != nil
+      end
+
       included do
-        rule(:_all, :functions => Neo4j::Rule::Functions::Count.new)
+        rule(:_all, :functions => Neo4j::Wrapper::Rule::Functions::Size.new) if respond_to?(:rule)
       end
 
       module ClassMethods
+
+        def index_prefix
+          return "" unless Neo4j.running?
+          return "" unless respond_to?(:ref_node_for_class)
+          ref_node = ref_node_for_class.wrapper
+          prefix = ref_node.respond_to?(:index_prefix) ? ref_node.send(:index_prefix) : ref_node[:name]
+          prefix ? prefix + "_" : ""
+        end
+
         # overwrite the index method to add find_by_xxx class methods
         def index(*args)
           field = args.first
@@ -40,7 +55,7 @@ module Neo4j
 
         # load an id or array of ids from the database
         def load(*ids)
-          result = ids.map { |id| entity_load(id) }
+          result = ids.map { |id| load_entity(id) }
           if ids.length == 1
             result.first
           else
@@ -48,6 +63,8 @@ module Neo4j
           end
         end
 
+        Neo4j::Wrapper::Find.send(:alias_method, :_wrapper_find, :find)
+
         # Behave like the ActiveRecord query interface
         #
         # === Example
@@ -68,18 +85,18 @@ module Neo4j
         #   Model.find(:all, :conditions => "name: test")
         #   Model.find(:all, :conditions => { :name => "test" })
         #
-        def find(*args)
+        def find(*args, &block)
           case args.first
             when :all, :first
               kind = args.shift
-              send(kind, *args)
+              send(kind, *args, &block)
             when "0", 0, nil
               nil
             else
               if convertable_to_id?(args.first)
                 find_with_ids(*args)
               else
-                first(*args)
+                first(*args, &block)
               end
           end
         end
@@ -124,7 +141,7 @@ module Neo4j
           find_or(:new, attrs, &block)
         end
 
-        def all(*args)
+        def all(*args, &block)
           if !conditions_in?(*args)
             # use the _all rule to recover all the stored instances of this node
             _all
@@ -134,18 +151,18 @@ module Neo4j
             if ids
               [find_with_ids(ids)].flatten
             else
-              find_with_indexer(*args)
+              find_with_indexer(*args, &block)
             end
           end
         end
 
-        def first(*args)
-          all(*args).first
+        def first(*args, &block)
+          all(*args, &block).first
         end
 
         def last(*args)
           a = all(*args)
-          a.empty? ? nil : a[a.size - 1]
+          a.empty? ? nil : a[all.size - 1]
         end
 
         def count
@@ -201,14 +218,23 @@ module Neo4j
         end
 
         def findable?(entity)
-          entity.is_a? self
+          entity.is_a?(self) and entity.reachable_from_ref_node?
         end
 
-        def find_with_indexer(*args)
-          hits                                     = _indexer.find(*args)
+        def find_with_indexer(*args, &block)
+          hits = if args.first.is_a?(Hash) && args.first.include?(:conditions)
+                   params = args.first.clone
+                   params.delete(:conditions)
+                   raise "ARGS #{args.inspect}" if args.size > 1
+                   _wrapper_find(args.first[:conditions], params, &block)
+                 else
+                   _wrapper_find(*args, &block)
+                 end
+
+
           # We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
           Thread.current[:neo4j_lucene_connection] ||= []
-          Thread.current[:neo4j_lucene_connection] << hits
+          Thread.current[:neo4j_lucene_connection] << hits if hits.respond_to?(:close)
           hits
         end
 
@@ -222,7 +248,7 @@ module Neo4j
         #
         # @return [ Node ] The first or new node.
         def find_or(method, attrs = {}, &block)
-          first(:conditions => attrs) || send(method, attrs, &block)
+          first(attrs) || send(method, attrs, &block)
         end
       end
     end

data/lib/neo4j/rails/has_n.rb

@@ -0,0 +1,203 @@
+module Neo4j
+  module Rails
+    module HasN
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Create a number of methods similar to active record has_many.
+        # The first one returns an Neo4j::Rails::Relationships::NodesDSL
+        # the second generate method (with the _rels postfix) returns a
+        # Neo4j::Rails::Relationships::RelsDSL
+        #
+        # See also Neo4j::NodeMixin#has_n which only work with persisted relationships.
+        #
+        # @example
+        #   class Thing
+        #     has_n(:things)
+        #   end
+        #
+        #   t = Thing.new
+        #   t.things << Thing.new << OtherClass.new
+        #   t.save # saves all nodes and relationships
+        #
+        # @example declare a to relationship
+        #  class Company
+        #    has_n(:employees).to(Person)
+        #  end
+        #
+        #  c = Company.new
+        #  c.employees << Person.new << Person.new(:name => 'kalle')
+        #
+        # @example creates a new person and relationship
+        #  c.employees.build(:name => 'sune')
+        #
+        # @example creates a new person and relationship and persist it
+        #  c.employees.create(:name => 'sune')
+        #
+        # @example delete all nodes and relationships
+        #  c.employees.destroy_all
+        #
+        # @example access the relationships and destroy them
+        #  c.employees_rels.destroy_all
+        #
+        # @example advanced traversal, using Neo4j::Core::Traversal
+        #  c._outgoing(Company.employees).outgoing(:friends).depth.each{ }
+        #
+        # @see Neo4j::Rails::Relationships::NodesDSL
+        def has_n(*args)
+          options = args.extract_options!
+          define_has_n_methods_for(args.first, options)
+        end
+
+        # Declares ONE incoming or outgoing relationship
+        #
+        # @example
+        #  class Person
+        #    has_one(:friend).to(OtherClass)
+        #  end
+        #
+        # @example
+        #  person.best_friend = my_friend
+        #
+        # @example
+        #  person.best_friend # => my_friend
+        #
+        # @example
+        #  person.build_best_friend(:name => 'foo')
+        #
+        # @example
+        #  person.create_best_friend(:name => 'foo')
+        #
+        # @example
+        #  person.create_best_friend!(:name => 'foo')
+        #
+        # @notice when using the <tt>build_</tt> and <tt>create_</tt> methods you <b>must</b> specify a <tt>to</to> relationship as done above in the Person example
+        def has_one(*args)
+          options = args.extract_options!
+          define_has_one_methods_for(args.first, options)
+        end
+
+        protected
+
+        def define_has_one_methods_for(rel_type, options)
+          unless method_defined?(rel_type)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    storage.single_node(dsl.dir)
+                end
+            RUBY
+          end
+
+          unless method_defined?("#{rel_type}_rel")
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}_rel
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    storage.single_relationship(dsl.dir)
+                end
+            RUBY
+          end
+
+          unless method_defined?("#{rel_type}=".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}=(other)
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    storage.destroy_single_relationship(dsl.dir)
+                    storage.create_relationship_to(other, dsl.dir) if other
+                end
+            RUBY
+          end
+
+          unless method_defined?("build_#{rel_type}".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def build_#{rel_type}(attr)
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    NodesDSL.new(storage, dsl.dir).build(attr)
+                end
+            RUBY
+          end
+
+          unless method_defined?("create_#{rel_type}".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def create_#{rel_type}(attr)
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    NodesDSL.new(storage, dsl.dir).create(attr)
+                end
+            RUBY
+          end
+
+          unless method_defined?("create_#{rel_type}!".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def create_#{rel_type}!(attr)
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    NodesDSL.new(storage, dsl.dir).create!(attr)
+                end
+            RUBY
+          end
+
+          _decl_rels[rel_type.to_sym] = Neo4j::Wrapper::HasN::DeclRel.new(rel_type, true, self)
+        end
+
+        def define_has_n_methods_for(rel_type, options) #:nodoc:
+          unless method_defined?(rel_type)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    NodesDSL.new(storage, dsl.dir)
+                end
+            RUBY
+          end
+
+          unless method_defined?("#{rel_type}=".to_sym)
+
+            # TODO: This is a temporary fix for allowing running neo4j with Formtastic, issue 109
+            # A better solution might be to implement accept_ids for has_n relationship and
+            # make sure (somehow) that Formtastic uses the _ids methods.
+
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}=(nodes)
+                    if nodes.is_a?(Array) && nodes.first.is_a?(String)
+                      if nodes.first.blank?
+                        self.#{rel_type}_rels.destroy_all
+                        nodes.shift
+                      end
+                    else
+                      self.#{rel_type}_rels.destroy_all
+                    end
+                    association = self.#{rel_type}
+                    nodes.each { |node| association << node }
+                end
+            RUBY
+          end
+
+          unless method_defined?("#{rel_type}_rels".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}_rels
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                  RelsDSL.new(storage, dsl.dir)
+                end
+            RUBY
+          end
+
+          instance_eval <<-RUBY, __FILE__, __LINE__
+              def #{rel_type}
+                _decl_rels[:'#{rel_type}'].rel_type.to_s
+              end
+          RUBY
+
+          _decl_rels[rel_type.to_sym] = Neo4j::Wrapper::HasN::DeclRel.new(rel_type, false, self)
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/rails/identity.rb

@@ -0,0 +1,25 @@
+module Neo4j
+  module Rails
+    module Identity
+
+      def id
+        _java_entity ? _java_entity.neo_id.to_s : nil
+      end
+
+      def neo_id
+        _java_entity ? _java_entity.neo_id : nil
+      end
+
+      def getId
+        new_record? ? nil : neo_id
+      end
+
+      def ==(other)
+        new? ? self.__id__ == other.__id__ : _java_entity == (other)
+      end
+
+
+    end
+  end
+end
+

data/lib/neo4j/rails/model.rb

@@ -1,285 +1,108 @@
 module Neo4j
   module Rails
-
-    # Includes the Neo4j::NodeMixin and adds ActiveRecord/Model like behaviour.
+    # Makes Neo4j nodes and relationships behave like active record objects.
     # That means for example that you don't have to care about transactions since they will be
-    # automatically be created when needed.
+    # automatically be created when needed. Validation, Callbacks etc. are also supported.
     #
-    # ==== Included Mixins
+    # @example Traverse
+    #   class Person < Neo4j::Rails::Model
+    #   end
     #
-    # * Neo4j::Rails::Persistence :: handles how to save, create and update the model
-    # * Neo4j::Rails::Attributes :: handles how to save and retrieve attributes
-    # * Neo4j::Rails::Mapping::Property :: allows some additional options on the #property class method
-    # * Neo4j::Rails::Serialization :: enable to_xml and to_json
-    # * Neo4j::Rails::Timestamps :: handle created_at, updated_at timestamp properties
-    # * Neo4j::Rails::Validations :: enable validations
-    # * Neo4j::Rails::Callbacks :: enable callbacks
-    # * Neo4j::Rails::Finders :: ActiveRecord style find
-    # * Neo4j::Rails::Relationships :: handles persisted and none persisted relationships.
-    # * Neo4j::Rails::Compositions :: see Neo4j::Rails::Compositions::ClassMethods, similar to http://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html
-    # * ActiveModel::Observing # enable observers, see Rails documentation.
-    # * ActiveModel::Translation - class mixin
+    #   person = Person.find(...)
+    #   person.outgoing(:foo) << Person.create
+    #   person.save!
+    #   person.outgoing(:foo).depth(:all)...
+    #   person.outgoing(:friends).map{|f| f.outgoing(:knows).to_a}.flatten
     #
-    # ==== Traversals
-    # This class only expose a limited set of traversals.
-    # If you want to access the raw java node to do traversals use the _java_node.
+    # @example Declared Relationships: has_n and has_one
     #
     #   class Person < Neo4j::Rails::Model
     #   end
     #
-    #   person = Person.find(...)
-    #   person._java_node.outgoing(:foo).depth(:all)...
+    #   class Person
+    #      has_n(:friends).to(Person)
+    #      has_n(:employed_by)
+    #   end
+    #
+    #   Person.new.foo << other_node
+    #   Person.friends.build(:name => 'kalle')
     #
-    # ==== has_n and has_one
+    # @example Declared Properties and Index
     #
-    # The has_n and has_one relationship accessors returns objects of type Neo4j::Rails::Relationships::RelsDSL
-    # and Neo4j::Rails::Relationships::NodesDSL which behaves more like the Active Record relationships.
-    # Notice that unlike Neo4j::NodeMixin new relationships are kept in memory until @save@ is called.
+    #   class Person < Neo4j::Rails::Model
+    #     property :name
+    #     property :age, :type => Fixnum, :index => :exact
+    #   end
     #
-    # ==== Callbacks
+    #   Person.create(:name => 'kalle', :age => 42, :undeclared_prop => 3.14)
+    #   Person.find_by_age(42)
     #
-    # The following callbacks are supported :validation, :create, :destroy, :save, :update.
-    # It works with before, after and around callbacks, see the Rails documentation.
-    # Notice you can also do callbacks using the Neo4j::Rails::Callbacks module (check the Rails documentation)
+    # @example Callbacks
+    #
+    #   class Person < Neo4j::Rails::Model
+    #     before_save :do_something
+    #     def do_something
+    #     end
+    #   end
+    #
+    # = Class Method Modules
+    # * {Neo4j::Rails::Persistence::ClassMethods} defines methods like: <tt>create</tt> and <tt>destroy_all</tt>
+    # * {Neo4j::Rails::Attributes::ClassMethods} defines the <tt>property</tt> and <tt>columns</tt> methods.
+    # * {Neo4j::Rails::NestedAttributes::ClassMethods} defines <tt>accepts_nested_attributes_for</tt>
+    # * {Neo4j::Rails::HasN::ClassMethods} defines <tt>has_n</tt> and <tt>has_one</tt>
+    # * {Neo4j::Rails::Finders::ClassMethods} defines <tt>find</tt>
+    # * {Neo4j::Rails::Compositions::ClassMethods} defines <tt>composed_of</tt> method
+    # * {Neo4j::Rails::AcceptId::ClassMethods} defines <tt>accepts_id_for</tt> method.
     #
     class Model
-      include Neo4j::NodeMixin
-
-
-      # Initialize a Node with a set of properties (or empty if nothing is passed)
-      def initialize(attributes = {})
-        @properties_before_type_cast=java.util.HashMap.new
-        reset_attributes
-        clear_relationships
-        self.attributes = attributes if attributes.is_a?(Hash)
-        yield self if block_given?
-      end
-
-      def id
-        neo_id.nil? ? nil : neo_id.to_s
-      end
-
-      def hash
-        persisted? ? _java_entity.neo_id.hash : super
-      end
-
-      def to_param
-        persisted? ? neo_id.to_s : nil
-      end
-
-
-      # Returns an Enumerable of all (primary) key attributes
-      # or nil if model.persisted? is false
-      def to_key
-        persisted? ? [id] : nil
-      end
-
-      def reject_if?(proc_or_symbol, attr)
-        return false if proc_or_symbol.nil?
-        if proc_or_symbol.is_a?(Symbol)
-          meth = method(proc_or_symbol)
-          meth.arity == 0 ? meth.call : meth.call(attr)
-        else
-          proc_or_symbol.call(attr)
-        end
-      end
-
-      def to_model
-        self
-      end
-
-      def ==(other)
-        new? ? self.__id__ == other.__id__ : @_java_node == (other)
-      end
-
-      def reachable_from_ref_node?
-        Neo4j::Algo.all_path(self.class.ref_node_for_class, self).outgoing(self.class).outgoing(:_all).count > 0
-      end
-
-      def attribute_missing(method_id, *args, &block)
-        method_name = method_id.method_name
-        if property?(method_name)
-          self[method_name]
-        else
-          super
-        end
-      end
-
-      ##
-      # :method: outgoing
-      #
-      # Similar to Neo4j::Traversal#outgoing but returns depth one only outgoing relationship
-      # which may not all be persisted.
-      # For only traversing persisted outgoing relationship of any depth or more advanced traversals, use
-      # the wrapped Java node instead.
-      #
-      # ==== Examples
-      #
-      #   person.outgoing(:friends) << other_person
-      #   person.save!
-      #
-      #   person.outgoing(:friends).map{|f| f.outgoing(:knows).to_a}.flatten
-      #
-      # ==== Examples
-      #
-      #   Neo4j::Transaction.run do
-      #     person._java_node.outgoing(:friends) << other_person
-      #   end
-      #
-      #   person._java_node.outgoing(:friends).outgoing(:knows).depth(4)
-      #
-      # Notice you can also declare outgoing relationships with the #has_n and #has_one class method.
-      #
-      # See Neo4j::Rails::Relationships#outgoing
-      # See Neo4j::Traversal#outgoing (when using it from the _java_node)
-
-
-      ##
-      # :method: incoming
-      #
-      # Returns incoming relationship of depth one which may not all be persisted.
-      # See #outgoing
-
-
-      ##
-      # :method: rels
-      #
-      # Returns both incoming and outgoing relationships which may not all be persisted.
-      # If you only want to find persisted relationships: @node._java_node.rels@
-      #
-      # See Neo4j::Rails::Relationships#rels
-      # See Neo4j::Rels#rels or Neo4j::Rels
-      #
-
-      ##
-      # :method: []
-      #
-      # Returns a property of this node, which may or may not have been declared with the class property method.
-      # Similar to Neo4j::Property#[] but can return not persisted properties as well.
-
-      ##
-      # :method: []=
-      #
-      # Sets any property on the node.
-      # Similar to Neo4j::Property#[]= but you must call the #save method to persist the property.
-
-      ##
-      # :singleton-method: property
-      #
-      # See Neo4j::Rails::Mapping::Property::ClassMethods#property
-
-      ##
-      # :singleton-method: has_one
-      #
-      # Generates a has_one methods which returns an object of type Neo4j::Rails::Relationships::NodesDSL
-      # and a has_one method postfixed @_rel@ which return a Neo4j::Rails::Relationships::RelsDSL
-      #
-      # See also Neo4j::Rails::Mapping::Property::ClassMethods#has_one
-      #
-
-      ##
-      # :singleton-method: columns
-      #
-      # Returns all defined properties as an array
-
-      ##
-      # :singleton-method: has_n
-      #
-      # Generates a has_n method which returns an object of type Neo4j::Rails::Relationships::NodesDSL
-      # and a has_n method postfixed @_rel@ which return a Neo4j::Rails::Relationships::RelsDSL
-      #
-      # See also Neo4j::Rails::Mapping::Property::ClassMethods#has_n
-      #
+      extend ActiveModel::Translation
 
+      include Neo4j::NodeMixin
+      include ActiveModel::Dirty # track changes to attributes
+      include ActiveModel::MassAssignmentSecurity # handle attribute hash assignment
+      include ActiveModel::Observing # enable observers
+      include Neo4j::Rails::Identity
+      include Neo4j::Rails::Persistence # handles how to save, create and update the model
+      include Neo4j::Rails::NodePersistence # handles how to save, create and update the model
+      include Neo4j::Rails::Attributes # handles how to save and retrieve attributes and override the property class method
+      include Neo4j::Rails::NestedAttributes
+      include Neo4j::Rails::HasN # allows some additional options on the #property class method
+      include Neo4j::Rails::Serialization # enable to_xml and to_json
+      include Neo4j::Rails::Validations # enable validations
+      include Neo4j::Rails::Callbacks # enable callbacks
+      include Neo4j::Rails::Timestamps # handle created_at, updated_at timestamp properties
+      include Neo4j::Rails::Finders # ActiveRecord style find
+      include Neo4j::Rails::Relationships # for none persisted relationships
+      include Neo4j::Rails::Compositions
+      include Neo4j::Rails::AcceptId
+      include Neo4j::Rails::Relationships
 
       # --------------------------------------
       # Public Class Methods
       # --------------------------------------
       class << self
-        # NodeMixin overwrites the #new class method but it saves it as orig_new
-        # Here, we just get it back to normal
-        alias :new :orig_new
-
-        def transaction(&block)
-          Neo4j::Rails::Transaction.run do |tx|
-            block.call(tx)
-          end
-        end
-
-        def entity_load(id)
-          Neo4j::Node.load(id)
-        end
 
         ##
         # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling
         # dates and times from the database. This is set to :local by default.
+        # @api public
         def default_timezone
           @default_timezone || :local
         end
 
+        # @api public
         def default_timezone=(zone)
           @default_timezone = zone
         end
 
-        def accepts_nested_attributes_for(*attr_names)
-          options = attr_names.pop if attr_names[-1].is_a?(Hash)
-
-          attr_names.each do |association_name|
-            # Do some validation that we have defined the relationships we want to nest
-            rel = self._decl_rels[association_name.to_sym]
-            raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
-            raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless rel.target_class
-
-            if rel.has_one?
-              send(:define_method, "#{association_name}_attributes=") do |attributes|
-                update_nested_attributes(association_name.to_sym, attributes, options)
-              end
-            else
-              send(:define_method, "#{association_name}_attributes=") do |attributes|
-                if attributes.is_a?(Array)
-                  attributes.each do |attr|
-                    update_nested_attributes(association_name.to_sym, attr, options)
-                  end
-                else
-                  attributes.each_value do |attr|
-                    update_nested_attributes(association_name.to_sym, attr, options)
-                  end
-                end
-              end
-            end
-
-          end
-        end
-
-        # When multitenancy is used, node should be findable only from current ref node.
-        def findable?(entity)
-          entity.is_a? self and entity.reachable_from_ref_node?
-        end
-
         # Set the i18n scope to overwrite ActiveModel.
         #
         # @return [ Symbol ] :neo4j
+        # @api public
         def i18n_scope
           :neo4j
         end
       end
     end
-
-    Model.class_eval do
-      extend ActiveModel::Translation
-
-      include Persistence # handles how to save, create and update the model
-      include Attributes # handles how to save and retrieve attributes
-      include Mapping::Property # allows some additional options on the #property class method
-      include Serialization # enable to_xml and to_json
-      include Validations # enable validations
-      include Callbacks # enable callbacks
-      include Timestamps # handle created_at, updated_at timestamp properties
-      include ActiveModel::Observing # enable observers
-      include Finders # ActiveRecord style find
-      include Relationships # for none persisted relationships
-      include Compositions
-      include AcceptId
-    end
   end
-end
+end