neo4j-core 2.0.0.alpha.1-java → 2.0.0-java

data/lib/neo4j/neo4j.rb

@@ -5,10 +5,17 @@
 # The Neo4j modules is used to interact with an Neo4j Database instance.
 # You can for example start and stop an instance and list all the nodes that exist in the database.
 #
-# === Starting and Stopping Neo4j
+# @example
+#   require 'neo4j'
+#   Neo4j::Transaction.run { Neo4j.ref_node.outgoing(:friends) << Neo4j::Node.new(:name => 'andreas')}
+#   Neo4j.ref_node.node(:outgoing, :friends)[:name] #=> 'andreas'
+#   Neo4j.query(Neo4j.ref_node){|ref| ref > ':friends' > :x; :x}
+#
+# ==== Notice - Starting and Stopping Neo4j
 # You don't normally need to start the Neo4j database since it will be automatically started when needed.
 # Before the database is started you should configure where the database is stored, see {Neo4j::Config]}.
 #
+#
 module Neo4j
 
   # @return [String] The version of the Neo4j jar files
@@ -51,9 +58,10 @@ module Neo4j
     end
 
     # Checks read only mode of the database. Only one process can have write access to the database.
+    # It will always return false if the database is not started yet.
     # @return [true, false] if the database has started up in read only mode
     def read_only?
-      (@db && @db.graph && @db.read_only?)
+      !!(@db && @db.graph && @db.read_only?)
     end
 
     # Returns a started db instance. Starts it's not running.
@@ -64,14 +72,10 @@ module Neo4j
       db
     end
 
-    # Runs all user defined migrations.
-    def migrate!
-
-    end
-
-    # @return [String, nil] the current storage path of a running neo4j database. If the database is not running it returns nil.
+    # If the database is not running it returns Neo4j::Config.storage_path otherwise it asks the database
+    # @return [String] the current storage path of the database
     def storage_path
-      return nil unless db.running?
+      return Neo4j::Config.storage_path unless db.running?
       db.storage_path
     end
 
@@ -85,18 +89,42 @@ module Neo4j
     # Check the neo4j 
     # Returns an enumerable of hash values.
     #
-    # @example
+    # @example Using the Cypher DSL
+    #  q = Neo4j.query{ match node(3) <=> node(:x); ret :x}
+    #  q.first[:n] #=> the @node
+    #  q.columns.first => :n
+    #
+    # @example Using the Cypher DSL and one parameter (n=Neo4j.ref_node)
+    #  q = Neo4j.query(Neo4j.ref_node){|n| n <=> node(:x); :x}
+    #  q.first[:n] #=> the @node
+    #  q.columns.first => :n
+    #
+    # @example Using an array of nodes
+    #  # same as - two_nodes=node(Neo4j.ref_node.neo_id, node_b.neo_id), b = node(b.neo_id)
+    #  q = Neo4j.query([Neo4j.ref_node, node_b], node_c){|two_nodes, b| two_nodes <=> b; b}
     #
-    #  q = Neo4j.query("START n=node({node}) RETURN n", 'node' => @node.neo_id)
-    #  q.first['n'] #=> the @node
-    #  q.columns.first => 'n'
+    # @example With an string
+    #  q = Neo4j._query("START n=node(42) RETURN n")
+    #  q.first(:n) #=> the @node
+    #  q.columns.first => :n
     #
-    # @see {http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation}
+    # @see Cypher
+    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
     # @note Returns a read-once only forward iterable.
-    # @return [Enumerable] a forward read once only Enumerable, containing hash values.
-    def query(query, params = {})
-      engine = org.neo4j.cypher.javacompat.ExecutionEngine.new(db)
-      engine.execute(query, params)
+    # @param params parameter for the query_dsl block
+    # @return [Neo4j::Core::Cypher::ResultWrapper] a forward read once only Enumerable, containing hash values.
+    def query(*params, &query_dsl)
+      q = Cypher.new(*params, &query_dsl).to_s
+      _query(q)
+    end
+
+    # Performs a cypher query with given string
+    # @param [String] q the cypher query as a String
+    # @return (see #query)
+    def _query(q)
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(db)
+      result = engine.execute(q)
+      Neo4j::Core::Cypher::ResultWrapper.new(result)
     end
 
 
@@ -165,9 +193,8 @@ module Neo4j
 
     # Usually, a client attaches relationships to this node that leads into various parts of the node space.
     # ®return the reference node, which is a "starting point" in the node space.
-    # @note In case the ref_node has been assigned via the threadlocal_ref_node method, 
+    # @note In case the ref_node has been assigned via the threadlocal_ref_node method,
     #       then that node will be returned instead.
-    # @see the design guide at http://wiki.neo4j.org/content/Design_Guide
     def ref_node(this_db = self.started_db)
       return Thread.current[:local_ref_node] if Thread.current[:local_ref_node]
       default_ref_node(this_db)
@@ -199,15 +226,16 @@ module Neo4j
     # Neo4j.management(org.neo4j.management.HighAvailability).isMaster
     #
     # @param jmx_clazz the JMX class http://api.neo4j.org/current/org/neo4j/management/package-summary.html
-    # @param this_db default currently runnig instance or a newly started neo4j db instance
+    # @param this_db default currently running instance or a newly started neo4j db instance
     # @see for the jmx_clazz p
-    def management(jmx_clazz = org.neo4j.jmx.Primitives, this_db = self.started_db)
+    # @node this
+    def management(jmx_clazz = Java::OrgNeo4jJmx::Primitives, this_db = self.started_db)
       this_db.management(jmx_clazz)
     end
 
     # @return [Enumerable] all nodes in the database
     def all_nodes(this_db = self.started_db)
-      Enumerable::Enumerator.new(this_db, :each_node)
+      Enumerator.new(this_db, :each_node)
     end
 
     # @return [Enumerable] all nodes in the database but not wrapped in ruby classes.

data/lib/neo4j/node.rb

@@ -9,14 +9,39 @@ module Neo4j
   # *org.neo4j.kernel.impl.core.NodeProxy* object. This java object includes the same mixin as this class. The #class method on the java object
   # returns Neo4j::Node in order to make it feel like an ordinary Ruby object.
   #
+  # @example Create a node with one property (see {Neo4j::Core::Node::ClassMethods})
+  #   Neo4j::Node.new(:name => 'andreas')
+  #
+  # @example Create a relationship (see {Neo4j::Core::Traversal})
+  #   Neo4j::Node.new.outgoing(:friends) << Neo4j::Node.new
+  #
+  # @example Finding relationships (see {Neo4j::Core::Rels})
+  #   node.rels(:outgoing, :friends)
+  #
+  # @example Lucene index (see {Neo4j::Core::Index})
+  #   Neo4j::Node.trigger_on(:typex => 'MyTypeX')
+  #   Neo4j::Node.index(:name)
+  #   a = Neo4j::Node.new(:name => 'andreas', :typex => 'MyTypeX')
+  #   # finish_tx
+  #   Neo4j::Node.find(:name => 'andreas').first.should == a
+  #
   class Node
     extend Neo4j::Core::Node::ClassMethods
+    extend Neo4j::Core::Wrapper::ClassMethods
+    extend Neo4j::Core::Index::ClassMethods
 
     include Neo4j::Core::Property
     include Neo4j::Core::Rels
     include Neo4j::Core::Traversal
     include Neo4j::Core::Equal
     include Neo4j::Core::Node
+    include Neo4j::Core::Wrapper
+    include Neo4j::Core::Property::Java # for documentation purpose only
+    include Neo4j::Core::Index
+
+    node_indexer do
+      index_names :exact => 'default_node_index_exact', :fulltext => 'default_node_index_fulltext'
+    end
 
     class << self
 
@@ -29,6 +54,8 @@ module Neo4j
           include Neo4j::Core::Traversal
           include Neo4j::Core::Equal
           include Neo4j::Core::Node
+          include Neo4j::Core::Wrapper
+          include Neo4j::Core::Index
         end
       end
     end

data/lib/neo4j/relationship.rb

@@ -29,13 +29,36 @@ module Neo4j
   #
   #   node.outgoing(:friends) << other_node << yet_another_node
   #
+  # @example lucene index
+  #  Neo4j::Relationship.trigger_on(:typey => 123)
+  #  Neo4j::Relationship.index(:name)
+  #  a = Neo4j::Relationship.new(:friends, Neo4j::Node.new, Neo4j::Node.new, :typey => 123, :name => 'kalle')
+  #  # Finish tx
+  #  Neo4j::Relationship.find(:name => 'kalle').first.should be_nil
+  #
   # @see http://api.neo4j.org/current/org/neo4j/graphdb/Relationship.html
   #
   class Relationship
     extend Neo4j::Core::Relationship::ClassMethods
+    extend Neo4j::Core::Wrapper::ClassMethods
+    extend Neo4j::Core::Index::ClassMethods
+
     include Neo4j::Core::Property
     include Neo4j::Core::Equal
     include Neo4j::Core::Relationship
+    include Neo4j::Core::Wrapper
+    include Neo4j::Core::Property::Java # for documentation purpose only
+    include Neo4j::Core::Index
+
+
+    # (see Neo4j::Core::Relationship::ClassMethods#new)
+    def initialize(rel_type, start_node, end_node, props={})
+    end
+
+
+    rel_indexer do
+      index_names :exact => 'default_rel_index_exact', :fulltext => 'default_rel_index_fulltext'
+    end
 
     class << self
       def extend_java_class(java_clazz) #:nodoc:
@@ -43,6 +66,8 @@ module Neo4j
           include Neo4j::Core::Property
           include Neo4j::Core::Equal
           include Neo4j::Core::Relationship
+          include Neo4j::Core::Wrapper
+          include Neo4j::Core::Index
         end
       end
 

data/lib/test.rb~

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'neo4j-core'
+
+
+def connect(d)
+  d.each{|i| Neo4j::Relationship.new(:flies_to, i[:from], i[:to])}
+end
+
+puts "Using #{Neo4j::Core::VERSION}"
+
+tx = Neo4j::Transaction.new
+@a, @b, @c, @z = (1..4).map{Neo4j::Node.new}
+connect([ {:from=>@a, :to=>@b}, {:from=>@a, :to=>@c},  {:from=>@b, :to=>@c},
+          {:from=>@b, :to=>@z}, {:from=>@c, :to=>@b},  {:from=>@c, :to=>@z}])
+tx.success
+tx.finish
+
+
+traversal = @a.outgoing(:flies_to).depth(:all).eval_paths { |path|  :include_and_continue }
+
+# This prints out
+#Path (1)--[flies_to,0]-->(2)
+#Path (1)--[flies_to,1]-->(3)
+#Path (1)--[flies_to,0]-->(2)--[flies_to,3]-->(4)
+traversal.paths.each do |path|
+  puts "Path #{path.to_s}"
+end

data/neo4j-core.gemspec

@@ -25,7 +25,7 @@ It comes included with the Apache Lucene document database.
   s.files = Dir.glob("{bin,lib,config}/**/*") + %w(README.rdoc Gemfile neo4j-core.gemspec)
   s.has_rdoc = true
   s.extra_rdoc_files = %w( README.rdoc )
-  s.rdoc_options = ["--quiet", "--title", "Neo4j.rb", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+  s.rdoc_options = ["--quiet", "--title", "Neo4j::Core", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
 
-  s.add_dependency("neo4j-community", "1.6.1.alpha.1")
+  s.add_dependency("neo4j-community", ">= 1.7.0")
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: neo4j-core
 version: !ruby/object:Gem::Version 
-  prerelease: 6
-  version: 2.0.0.alpha.1
+  prerelease: 
+  version: 2.0.0
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-11 00:00:00 Z
+date: 2012-05-07 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -18,9 +18,9 @@ dependencies:
     requirement: &id001 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
-        - - "="
+        - - ">="
           - !ruby/object:Gem::Version 
-            version: 1.6.1.alpha.1
+            version: 1.7.0
     type: :runtime
     version_requirements: *id001
 description: |
@@ -37,9 +37,11 @@ extensions: []
 extra_rdoc_files: 
   - README.rdoc
 files: 
-  - lib/test.rb
   - lib/neo4j-core.rb
+  - lib/test.rb~
   - lib/neo4j/config.rb
+  - lib/neo4j/algo.rb
+  - lib/neo4j/cypher.rb
   - lib/neo4j/transaction.rb
   - lib/neo4j/neo4j.rb
   - lib/neo4j/neo4j.rb~
@@ -47,13 +49,14 @@ files:
   - lib/neo4j/relationship.rb
   - lib/neo4j-core/event_handler.rb
   - lib/neo4j-core/lazy_map.rb
-  - lib/neo4j-core/version.rb~
+  - lib/neo4j-core/hash_with_indifferent_access.rb
   - lib/neo4j-core/database.rb
   - lib/neo4j-core/relationship_set.rb
   - lib/neo4j-core/version.rb
   - lib/neo4j-core/to_java.rb
   - lib/neo4j-core/node/node.rb
   - lib/neo4j-core/node/class_methods.rb
+  - lib/neo4j-core/property/java.rb
   - lib/neo4j-core/property/property.rb
   - lib/neo4j-core/equal/equal.rb
   - lib/neo4j-core/traversal/rel_expander.rb
@@ -62,17 +65,47 @@ files:
   - lib/neo4j-core/traversal/traversal.rb
   - lib/neo4j-core/traversal/traverser.rb
   - lib/neo4j-core/traversal/evaluator.rb
-  - lib/neo4j-core/type_converters/type_converters.rb
   - lib/neo4j-core/rels/traverser.rb
   - lib/neo4j-core/rels/rels.rb
+  - lib/neo4j-core/wrapper/wrapper.rb
+  - lib/neo4j-core/wrapper/class_methods.rb
   - lib/neo4j-core/index/index_config.rb
   - lib/neo4j-core/index/indexer.rb
   - lib/neo4j-core/index/lucene_query.rb
   - lib/neo4j-core/index/indexer_registry.rb
+  - lib/neo4j-core/index/unique_factory.rb
   - lib/neo4j-core/index/class_methods.rb
   - lib/neo4j-core/index/index.rb
   - lib/neo4j-core/relationship/class_methods.rb
   - lib/neo4j-core/relationship/relationship.rb
+  - lib/neo4j-core/cypher/cypher.rb
+  - lib/neo4j-core/cypher/result_wrapper.rb
+  - lib/db/neostore.relationshiptypestore.db.names
+  - lib/db/neostore.id
+  - lib/db/neostore.relationshiptypestore.db.names.id
+  - lib/db/neostore.nodestore.db.id
+  - lib/db/neostore.propertystore.db.index
+  - lib/db/neostore.propertystore.db.strings.id
+  - lib/db/nioneo_logical.log.active
+  - lib/db/neostore.propertystore.db.strings
+  - lib/db/neostore.relationshiptypestore.db.id
+  - lib/db/neostore
+  - lib/db/neostore.nodestore.db
+  - lib/db/neostore.propertystore.db.index.keys.id
+  - lib/db/neostore.propertystore.db.arrays.id
+  - lib/db/messages.log
+  - lib/db/neostore.relationshipstore.db.id
+  - lib/db/neostore.propertystore.db.arrays
+  - lib/db/neostore.relationshipstore.db
+  - lib/db/neostore.propertystore.db.index.id
+  - lib/db/neostore.propertystore.db.id
+  - lib/db/neostore.propertystore.db
+  - lib/db/tm_tx_log.1
+  - lib/db/neostore.relationshiptypestore.db
+  - lib/db/active_tx_log
+  - lib/db/neostore.propertystore.db.index.keys
+  - lib/db/index/lucene-store.db
+  - lib/db/index/lucene.log.active
   - config/neo4j/config.yml
   - README.rdoc
   - Gemfile
@@ -84,7 +117,7 @@ post_install_message:
 rdoc_options: 
   - --quiet
   - --title
-  - Neo4j.rb
+  - Neo4j::Core
   - --line-numbers
   - --main
   - README.rdoc
@@ -100,9 +133,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.1
+        version: "0"
 requirements: []
 
 rubyforge_project: neo4j-core

data/lib/neo4j-core/type_converters/type_converters.rb

@@ -1,287 +0,0 @@
-module Neo4j
-
-  # Responsible for converting values from and to Java Neo4j and Lucene.
-  # You can implement your own converter by implementing the method <tt>convert?</tt>
-  # <tt>to_java</tt> and <tt>to_ruby</tt> in this module.
-  #
-  # There are currently three default converters that are triggered when a Time, Date or a DateTime is read or written
-  # if there is a type declared for the property.
-  #
-  # ==== Example
-  #
-  # Example of writing your own marshalling converter:
-  #
-  #  class Foo
-  #     include Neo4j::NodeMixin
-  #     property :thing, :type => MyType
-  #  end
-  #
-  #  module Neo4j::TypeConverters
-  #    class MyTypeConverter
-  #      class << self
-  #        def convert?(type)
-  #          type == MyType
-  #        end
-  #
-  #        def to_java(val)
-  #          "silly:#{val}"
-  #        end
-  #
-  #        def to_ruby(val)
-  #          val.sub(/silly:/, '')
-  #        end
-  #      end
-  #    end
-  #  end
-  #
-  module TypeConverters
-
-    # The default converter to use if there isn't a specific converter for the type
-    class DefaultConverter
-      class << self
-
-        def to_java(value)
-          value
-        end
-
-        def to_ruby(value)
-          value
-        end
-      end
-    end
-
-
-    class BooleanConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          :boolean == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          !!value && value != '0'
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          !!value && value != '0'
-        end
-      end
-    end
-
-    class SymbolConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          :symbol == class_or_symbol || Symbol == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_s
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_sym
-        end
-      end
-    end
-
-
-    class StringConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          [String, :string, :text].include? class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_s
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_s
-        end
-      end
-    end
-
-
-
-    class FixnumConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          Fixnum == class_or_symbol || :fixnum == class_or_symbol || :numeric == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_i
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_i
-        end
-      end
-    end
-
-    class FloatConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Float == clazz_or_symbol || :float == clazz_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_f
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_f
-        end
-      end
-    end
-
-    # Converts Date objects to Java long types. Must be timezone UTC.
-    class DateConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Date == clazz_or_symbol || :date == clazz_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          Time.utc(value.year, value.month, value.day).to_i
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc.to_date
-        end
-      end
-    end
-
-    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
-    class DateTimeConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          DateTime == clazz_or_symbol || :datetime == clazz_or_symbol
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
-          end
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          t = Time.at(value).utc
-          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
-        end
-      end
-    end
-
-    class TimeConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Time == clazz_or_symbol || :time == clazz_or_symbol
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            value.utc.to_i
-          end
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc
-        end
-      end
-    end
-
-    class << self
-
-      # Mostly for testing purpose, You can use this method in order to
-      # add a converter while the neo4j has already started.
-      def converters=(converters)
-        @converters = converters
-      end
-      
-      # Always returns a converter that handles to_ruby or to_java
-      # if +enforce_type+ is set to false then it will raise in case of unknown type
-      # otherwise it will return the DefaultConverter.
-      def converter(type = nil, enforce_type = true)
-        return DefaultConverter unless type
-        @converters ||= begin
-          Neo4j::TypeConverters.constants.find_all do |c|
-            Neo4j::TypeConverters.const_get(c).respond_to?(:convert?)
-          end.map do  |c|
-            Neo4j::TypeConverters.const_get(c)
-          end
-        end
-        found = @converters.find {|c| c.convert?(type) }
-        raise "The type #{type.inspect} is unknown. Use one of #{@converters.map{|c| c.name }.join(", ")} or create a custom type converter." if !found && enforce_type
-        found or DefaultConverter
-      end
-
-      # Converts the given value to a Java type by using the registered converters.
-      # It just looks at the class of the given value unless an attribute name is given.
-      def convert(value, attribute = nil, klass = nil, enforce_type = true)
-        converter(attribute_type(value, attribute, klass), enforce_type).to_java(value)
-      end
-
-      # Converts the given property (key, value) to Java if there is a type converter for given type.
-      # The type must also be declared using Neo4j::NodeMixin#property property_name, :type => clazz
-      # If no Converter is defined for this value then it simply returns the given value.
-      def to_java(clazz, key, value)
-        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
-        converter(type).to_java(value)
-      end
-
-      # Converts the given property (key, value) to Ruby if there is a type converter for given type.
-      # If no Converter is defined for this value then it simply returns the given value.
-      def to_ruby(clazz, key, value)
-        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
-        converter(type).to_ruby(value)
-      end
-
-      private
-      def attribute_type(value, attribute = nil, klass = nil)
-        type = (attribute && klass) ? attribute_type_from_attribute_and_klass(value, attribute, klass) : nil
-        type || attribute_type_from_value(value)
-      end
-
-      def attribute_type_from_attribute_and_klass(value, attribute, klass)
-        if klass.respond_to?(:_decl_props)
-          (klass._decl_props.has_key?(attribute) && klass._decl_props[attribute][:type]) ? klass._decl_props[attribute][:type] : nil
-        end
-      end
-
-      def attribute_type_from_value(value)
-        value.class
-      end
-    end
-  end
-end