neo4j 1.2.6-java → 2.0.0.alpha.3-java

data/CHANGELOG

@@ -1,3 +1,33 @@
+ == 1.3.1 / 2011-12-14
+* Make all relationships visible in Rails callback (rspecs #87, Dmytrii Nagirniak) [#211]
+* Enable travis to build JRuby 1.9 (pull #87, Dmytrii Nagirniak) [#214]
+* Support for composite lucene queries with OR and NOT (pull #89, Deepak N)
+* Enforce the correct converter on a property type when the type is given (pull #86, Dmytrii Nagirniak)
+* Development: make it easier to run RSpecs and guard (pull #85, Dmytrii Nagirniak)
+* Added ability to disable observer (pull #84, Dmytrii Nagirniak)
+* Fixing multiple assignment of has_one assocaition (pull #83 Deepak N)
+* Accept association_id for has_one assocations (pull #82, Deepak N)
+* Upgrade to 1.6.M01 Neo4j java jars [#209]
+* Defer warning message 'Unknown outgoing relationship' (pull #81, Vivek Prahlad)
+* Added string converter, e.g. property :name, :type => String  (pull #80, Dmytrii Nagirniak)
+* Added symbol converter e.g. property :status, :type => Symbol (pull #79, Dmytrii Nagirniak) [#205]
+
+ == 1.3.0 / 2011-12-06
+* Added neo4j-upgrade script to rename lucene index files and upgrade to 1.5 [#197]
+* Expose Neo4j::NodeMixin#index_types returning available indices (useful for Cypher queries) [#194]
+* The to_other method is now available also in the Neo4j::Rails API [#193]
+* Expose rel_type method for Neo4j::Rails::Relationship [#196]
+* Support for breadth and depth first traversals [#198]
+* Support for cypher query [#197]
+* Fix for rule node concurrency issue (pull #78, Vivek Prahlad)
+* Bugfix for the uniqueness validation for properties with quotes (pull #76, Vivek Prahlad)
+* More performance tweaks (pull #75, #77, Vivek Prahlad)
+* Fixing add_index for properties other than type string (pull #74, Deepak N)
+* Significant performance boost for creating large numbers of models in a transaction (pull #73, Vivek Prahlad)
+* Upgrade to neo4j 1.5 jars (pull #72, Vivek Prahlad)
+* Fix for assigning nil values to incoming has_one relation (pull #70, Deepak N)
+* Support for revert and fixes for Neo4j::Rails::Versioning (pull #71, Vivek Prahlad)
+
  == 1.2.6 / 2011-11-02
 * Generators can now generate relationships as well [#195]
 * Better will_paginate support for Neo4j::Rails::Model [#194]

data/CONTRIBUTORS

@@ -2,6 +2,7 @@ Maintainer:
   Andreas Ronge <andreas dot ronge at gmail dot com>
 
 Contributors:
+* Dmytrii Nagirniak
 * Marcio Toshio
 * Kalyan Akella
 * Vivek Prahlad

data/Gemfile

@@ -5,14 +5,26 @@ gemspec
 group 'test' do
   gem "rake", ">= 0.8.7"
   gem "rdoc", ">= 2.5.10"
-  gem "horo", ">= 1.0.2"
-  gem "rspec", "= 2.6.0"
+  gem "horo", ">= 1.0.2" # TODO: Why horo, YARD seems to be much better option?
+  gem "rspec", "~> 2.8"
+  gem "its" # its(:with, :arguments) { should be_possible }
 
-  # use this version for rspec-rails-matchers which work with latest RSpec (Rspec => RSpec)
-  gem "rspec-rails-matchers", :git => 'git://github.com/afcapel/rspec-rails-matchers.git'
+  gem 'guard'
+  gem 'ruby_gntp', :require => false # GrowlNotify for Mac
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+  gem "guard-rspec"
+
+  gem 'shoulda-matchers', '~> 1.0'
 
   gem "test-unit"
   gem 'rcov'
+
+  gem 'pry'
+
+  gem 'neo4j-advanced', "1.6.0.alpha.5",  :require => false
+  gem 'neo4j-enterprise', "1.6.0.alpha.5", :require => false
 end
 
 #gem 'ruby-debug-base19' if RUBY_VERSION.include? "1.9"

data/README.rdoc

@@ -12,7 +12,9 @@ It uses two powerful and mature Java libraries:
 === Documentation
 
 * {Guides and API}[http://neo4j.rubyforge.org/guides/index.html]
+* {RDoc}[http://neo4j.rubyforge.org]
 * {Blog: Neo4j and Rails 3}[http://blog.jayway.com/2011/03/02/neo4j-rb-1-0-0-and-rails-3/]
+* {Kvitter Example Application}[https://github.com/andreasronge/kvitter/]
 
 === Why Neo4j.rb or a Graph Database ?
 
@@ -107,6 +109,15 @@ To run it with Tomcat instead of WEBrick
   gem install trinidad
   trinidad
 
+=== Architecture
+
+As you seen above, neo4j.rb consists of a three layers API:
+
+* Layer 1. For interacting with the basic building blocks of the graph database (node, properties and relationship), see Neo4j::Node and Neo4j::Relationship classes.
+* Layer 2. A binding API to Ruby objects, see Neo4j::NodeMixin and Neo4j::RelationshipMixin modules.
+* Layer 3. An implementation of the Rails Active Model and a subset of the Active Record API, see Neo4j::Rails::Model class.
+
+Notice that you can always access the lower layers if you want to do some more advanced. You can even access the Java API directly.
 
 === Presentation Materials and other URLs
 * {Presentation: RailsConf 2011}[http://andreasronge.github.com/neo4j-railsconf.pdf]
@@ -115,17 +126,28 @@ To run it with Tomcat instead of WEBrick
 
 === Project information
 * {GitHub}[http://github.com/andreasronge/neo4j/tree/master]
-* {Lighthouse Issue Tracking}[http://neo4j.lighthouseapp.com]
+* {Issue Tracking}[https://github.com/andreasronge/neo4j/issues]
 * {Twitter}[http://twitter.com/ronge]
-* IRC -  #neo4j @ irc.freenode.net
 * {Mailing list, neo4jrb@googlegroups.com}[http://groups.google.com/group/neo4jrb]
+* {Read only, old lighthouse issues}[http://neo4j.lighthouseapp.com]
+
+=== Configuration
+
+{Development configuration}[http://neo4j.rubyforge.org/guides/index.html#development-and-testing-configuration] - You can configure Neo4j through the {Neo4j::Config}[http://neo4j.rubyforge.org/Neo4j/Config.html] object.
+
+    Neo4j::Config[:storage_path] = "/var/neo4j"
+
+{Configuring Neo4j from Rails}[http://neo4j.rubyforge.org/guides/configuration.html#config-neo4j-from-rails] - When using Neo4j.rb from rails you can use the normal rails configuration to set Neo4j configuration.
+    
+    config.neo4j.storage_path = "#{config.root}/db/neo4j"
 
 === Contributing
 
+{<img src="https://secure.travis-ci.org/andreasronge/neo4j.png" />}[http://travis-ci.org/andreasronge/neo4j]
+
 Have you found a bug, need help or have a patch ?
 Just clone neo4j.rb and send me a pull request or email me.
 Do you need help - send me an email (andreas.ronge at gmail dot com).
-Please also check/add issues at lighthouse, http://neo4j.lighthouseapp.com
 
 === License
 * Neo4j.rb - MIT, see the LICENSE file http://github.com/andreasronge/neo4j/tree/master/LICENSE.

data/bin/neo4j-jars

@@ -5,22 +5,29 @@ require 'neo4j'
 if ARGV.length == 0
   puts <<TEXT
 A tool for copying jar files needed by the application server, like trinidad
-It copies the jar files to the lib folder of the current directory
-Usage: neo4j-jars [-ha|-backup]
-  -ha      copies the High Available cluster Jars
-  -backup  copies the online backup jars
-  -local   copies only the jars for running a local neo4j db
+It copies all jar files which has been required (neo4j-community, neo4j-advanced or neo4j-enterprise) to the lib folder of the current directory
+
+  Usage: neo4j-jars <community|advanced|enterprise>
+
 TEXT
 exit
 end
 
-Neo4j.load_online_backup if ARGV.include?('-backup')
-Neo4j.load_ha_jars if ARGV.include?('-ha')
+if ARGV.include?('community')
+  require 'neo4j-community' # not really needed
+elsif ARGV.include?('advanced')
+  require 'neo4j-advanced' # not really needed
+elsif ARGV.include?('enterprise')
+  require 'neo4j-enterprise' # not really needed
+else
+  puts "Expected community, advanced, enterprise"
+  exit -1
+end
 
 lib_dir = File.join(Dir.pwd, 'lib')
 raise "Expected a lib folder where to copy the jars file, mkdir #{lib_dir}? " unless File.exist?(lib_dir)
 
-files = $CLASSPATH.find_all{|x| x =~ /neo4j\/jars/}.collect{|y| y.sub('file:', '')}
+files = $CLASSPATH.find_all{|x| x =~ /\.jar$/}.collect{|y| y.sub('file:', '')}
 files.each {|file| FileUtils.cp(file, lib_dir)}
 
 puts "copied #{files.size} files to #{lib_dir}"

data/bin/neo4j-shell

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
 
 require 'neo4j'
-Neo4j.load_shell_jars
 org.neo4j.shell.StartClient.main(ARGV)

data/bin/neo4j-upgrade

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'neo4j'
+
+if ARGV.length == 0
+  puts <<TEXT
+A tool for upgrading the neo4j database to #{Neo4j::VERSION}.
+Make sure you shutdown the database cleanly before running this script.
+More info:  http://neo4j.rubyforge.org/guides/configuration.html#upgrade-to-a-new-neo4j-version
+
+Usage   : neo4j-upgrade <location of database>
+Example : neo4j-upgrade db/neo4j-development
+
+TEXT
+exit
+end
+
+def error(msg)
+  puts msg
+  exit
+end
+
+def rename_index(folder, file)
+  new_file = File.join(folder, file.gsub(/-/, '_'))
+  old_file = File.join(folder, file)
+  puts "moved index '#{old_file}' to '#{new_file}'"
+  FileUtils.move(old_file, new_file)
+end
+
+def upgrade(path)
+  Dir.entries(path).each do |file|
+    rename_index(path, file) if file =~ /(-exact)|(-fulltext)$/
+  end
+end
+
+root = ARGV[0]
+error("Can't find database at location #{root}") unless File.exist?(root)
+error("Expected location #{root} to be a folder") unless File.directory?(root)
+
+# Upgrade
+puts "upgrade database to Neo4j.rb version #{Neo4j::VERSION}, this might take a while ...."
+Neo4j::Config[:storage_path] = root
+Neo4j::Config[:allow_store_upgrade] = 'true'
+Neo4j.start
+puts "Neo4j database at #{root} upgraded to #{Neo4j::VERSION}, now shutdown"
+Neo4j.shutdown
+puts "Rename lucene index files"
+
+nodes_path = File.join(root, "index", "lucene", "node")
+if File.exist?(nodes_path)
+  upgrade(nodes_path)
+else
+  puts("Can't find lucene index at location #{nodes_path}")
+end
+
+
+nodes_path = File.join(root, "index", "lucene", "node")
+if File.exist?(nodes_path)
+  upgrade(nodes_path)
+else
+  puts("No lucene index for nodes found at location #{nodes_path}, continue")
+end
+
+nodes_path = File.join(root, "index", "lucene", "relationship")
+if File.exist?(nodes_path)
+  upgrade(nodes_path)
+else
+  puts("No lucene index for relationship found at location #{nodes_path}")
+end
+
+puts "Upgraded database done at '#{root}'"

data/config/neo4j/config.yml

@@ -28,17 +28,18 @@ lucene: { fulltext: { provider: lucene,
 # If set to true it you can use the database while it is migrating.
 migration_thread: false
 
-# If online backup should be available, if it is the Online JAR file will be loaded.
-online_backup_enabled: false
+# If online backup should be available, if it is the Online JAR file will be loaded,
+# Notice it must be either 'true' or 'false' as string
+enable_online_backup: 'false'
 
 #use the clustered Neo4j GraphDatabase (org.neo4j.kernel.HighlyAvailableGraphDatabase)
 ha.db: false
 
 # Example of HA Configuration, see http://wiki.neo4j.org/content/High_Availability_Cluster
 # This is only used when ha.db is set to true
-ha.machine_id: 2
+ha.server_id: 2
 ha.server: 'localhost:6002'
-ha.zoo_keeper_servers: 'localhost:2181,localhost:2182,localhost:2183'
+ha.coordinators: 'localhost:2181,localhost:2182,localhost:2183'
 
 # if enabled you can use the bin/neo4j-shell command to access the database
 enable_remote_shell: "port=9332"

data/lib/neo4j/algo/algo.rb

@@ -1,6 +1,5 @@
 # external neo4j dependencies
 require 'neo4j/to_java'
-require 'neo4j/jars/core/neo4j-graph-algo-1.4.1.jar'
 
 module Neo4j
 

data/lib/neo4j/batch/inserter.rb

@@ -48,6 +48,8 @@ module Neo4j
         props = {} if clazz != Neo4j::Node && props.nil?
         props['_classname'] = clazz.to_s if clazz != Neo4j::Node
 
+        props = ensure_valid_props(props)
+
         node = @batch_inserter.create_node(props)
         props && _index(node, props, clazz)
         @rule_inserter.node_added(node, props)
@@ -68,6 +70,9 @@ module Neo4j
       def create_rel(rel_type, from_node, to_node, props=nil, clazz=Neo4j::Relationship)
         props = {} if clazz != Neo4j::Relationship && props.nil?
         props['_classname'] = clazz.to_s if clazz != Neo4j::Relationship
+
+        props = ensure_valid_props(props)
+
         rel = @batch_inserter.create_relationship(from_node, to_node, type_to_java(rel_type), props)
 
         props && _index(rel, props, clazz)

data/lib/neo4j/database.rb

@@ -13,6 +13,8 @@ module Neo4j
   class Database
     attr_reader :graph, :lucene, :event_handler, :storage_path
 
+    alias_method :index, :lucene # needed by cypher
+
     def initialize()
       @event_handler = EventHandler.new
     end
@@ -22,12 +24,6 @@ module Neo4j
       @running = true
       @storage_path = Config.storage_path
 
-
-      if Config[:enable_remote_shell]
-        Neo4j.logger.info("Enable remote shell at port #{Config[:enable_remote_shell]}")
-        Neo4j.load_shell_jars
-      end
-
       begin
         if self.class.locked?
           start_readonly_graph_db
@@ -48,24 +44,34 @@ module Neo4j
 
     def start_readonly_graph_db #:nodoc:
       Neo4j.logger.info "Starting Neo4j in readonly mode since the #{@storage_path} is locked"
-      Neo4j.load_local_jars
       @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(@storage_path, Config.to_java_map)
       @lucene = @graph.index
     end
 
     def start_local_graph_db #:nodoc:
       Neo4j.logger.info "Starting local Neo4j using db #{@storage_path}"
-      Neo4j.load_local_jars
       @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(@storage_path, Config.to_java_map)
       @graph.register_transaction_event_handler(@event_handler)
       @lucene = @graph.index
       @event_handler.neo4j_started(self)
     end
 
+    # needed by cypher
+    def getNodeById(id) #:nodoc:
+      Neo4j::Node.load(id)
+    end
+
+    # needed by cypher
+    def getRelationshipById(id) #:nodoc:
+      Neo4j::Relationship.load(id)
+    end
+
     def start_ha_graph_db
-      Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.machine_id']} at #{Neo4j.config['ha.server']} db #{@storage_path}"
-      Neo4j.load_ha_jars # those jars are only needed for the HighlyAvailableGraphDatabase
-      Neo4j.load_online_backup if Neo4j.config[:online_backup_enabled]
+      Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.server_id']} at #{Neo4j.config['ha.server']} db #{@storage_path}"
+      # Modify the public base classes for the HA Node and Relationships
+      # (instead of private org.neo4j.kernel.HighlyAvailableGraphDatabase::LookupNode)
+      Neo4j::Node.extend_java_class(org.neo4j.tooling.wrap.WrappedNode)
+      Neo4j::Relationship.extend_java_class(org.neo4j.tooling.wrap.WrappedRelationship)
       @graph = org.neo4j.kernel.HighlyAvailableGraphDatabase.new(@storage_path, Neo4j.config.to_java_map)
       @graph.register_transaction_event_handler(@event_handler)
       @lucene = @graph.index
@@ -94,7 +100,7 @@ module Neo4j
     # Returns true if the neo4j db was started in read only mode.
     # This can occur if the database was locked (it was already one instance running).
     def read_only?
-      @graph.isReadOnly
+      @graph.java_class == org.neo4j.kernel.EmbeddedGraphDatabase
     end
 
     # check if the database is locked. A neo4j database is locked when the database is running.

data/lib/neo4j/event_handler.rb

@@ -71,6 +71,9 @@ module Neo4j
   # * <tt>old_value</tt> :: old value of the property
   # * <tt>new_value</tt> :: new value of the property
   #
+  # ==== classes_changed(class_change_map)
+  # * <tt>class_change_map</tt> :: a hash with class names as keys, and class changes as values. See Neo4j::ClassChanges
+  #
   # == Usage
   #
   #   class MyListener
@@ -99,30 +102,47 @@ module Neo4j
     end
 
     def before_commit(data)
-      created_node_identity_map = node_identity_map(data.created_nodes)
-      deleted_node_identity_map = node_identity_map(data.deleted_nodes)
+      class_change_map = java.util.HashMap.new
+      created_node_identity_map = iterate_created_nodes(data.created_nodes, class_change_map)
+      deleted_node_identity_map = deleted_node_identity_map(data.deleted_nodes)
       deleted_relationship_set = relationship_set(data.deleted_relationships)
       removed_node_properties_map = property_map(data.removed_node_properties)
       removed_relationship_properties_map = property_map(data.removed_relationship_properties)
+      add_deleted_nodes(data, class_change_map, removed_node_properties_map)
       empty_map = java.util.HashMap.new
-      data.created_nodes.each{|node| node_created(node)}
-      data.assigned_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
+      data.assigned_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) unless tx_data.key == '_classname'}
       data.removed_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless deleted_node_identity_map.containsKey(tx_data.entity.getId) }
       data.deleted_nodes.each { |node| node_deleted(node, removed_node_properties_map.get(node.getId)||empty_map, deleted_relationship_set, deleted_node_identity_map)}
       data.created_relationships.each {|rel| relationship_created(rel, created_node_identity_map)}
       data.deleted_relationships.each {|rel| relationship_deleted(rel, removed_relationship_properties_map.get(rel.getId)||empty_map, deleted_relationship_set, deleted_node_identity_map)}
       data.assigned_relationship_properties.each { |tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
       data.removed_relationship_properties.each {|tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless deleted_relationship_set.contains_rel?(tx_data.entity) }
+      classes_changed(class_change_map)
+    rescue Exception => e
+      # since these exceptions gets swallowed
+      puts "ERROR in before commit hook #{e}"
+      puts e.backtrace.join("\n")
     end
 
-    def node_identity_map(nodes)
-      identity_map = java.util.HashMap.new(nodes.size)
-      nodes.each{|node| identity_map.put(node.neo_id,node)}#using put due to a performance regression in JRuby 1.6.4
+
+    def iterate_created_nodes(nodes, class_change_map)
+      identity_map = java.util.HashMap.new
+      nodes.each do |node|
+        identity_map.put(node.neo_id,node) #using put due to a performance regression in JRuby 1.6.4
+        instance_created(node, class_change_map)
+        node_created(node)
+      end
+      identity_map
+    end
+
+    def deleted_node_identity_map(nodes)
+      identity_map = java.util.HashMap.new
+      nodes.each{|node| identity_map.put(node.neo_id,node)} #using put due to a performance regression in JRuby 1.6.4
       identity_map
     end
 
     def relationship_set(relationships)
-      relationship_set = Neo4j::RelationshipSet.new(relationships.size)
+      relationship_set = Neo4j::RelationshipSet.new#(relationships.size)
       relationships.each{|rel| relationship_set.add(rel)}
       relationship_set
     end
@@ -192,5 +212,52 @@ module Neo4j
     def rel_property_changed(rel, key, old_value, new_value)
       @listeners.each {|li| li.on_rel_property_changed(rel, key, old_value, new_value) if li.respond_to?(:on_rel_property_changed)}
     end
+
+    def add_deleted_nodes(data, class_change_map, removed_node_properties_map)
+      data.deleted_nodes.each{|node| instance_deleted(node, removed_node_properties_map, class_change_map)}
+    end
+
+    def instance_created(node, class_change_map)
+      classname = node[:_classname]
+      class_change(classname, class_change_map).add(node) if classname
+    end
+
+    def instance_deleted(node, removed_node_properties_map, class_change_map)
+      properties = removed_node_properties_map.get(node.getId)
+      if properties
+        classname = properties.get("_classname")
+        class_change(classname, class_change_map).delete(node) if classname
+      end
+    end
+
+    def class_change(classname, class_change_map)
+      class_change_map.put(classname, ClassChanges.new) if class_change_map.get(classname).nil?
+      class_change_map.get(classname)
+    end
+
+    def classes_changed(changed_class_map)
+      @listeners.each {|li| li.classes_changed(changed_class_map) if li.respond_to?(:classes_changed)}
+    end
+  end
+
+  class ClassChanges
+    attr_accessor :added, :deleted
+
+    def initialize
+      self.added = []
+      self.deleted = []
+    end
+
+    def add(node)
+      self.added << node
+    end
+
+    def delete(node)
+      self.deleted << node
+    end
+
+    def net_change
+      self.added.size - self.deleted.size
+    end
   end
-end
+end

data/lib/neo4j/has_list/class_methods.rb

@@ -3,7 +3,7 @@ module Neo4j::HasList
       def has_list(name, params = {})
         module_eval(%Q{
                 def #{name}
-                  Neo4j::HasList::Mapping.new(self, '#{name}')
+                  Neo4j::HasList::Mapping.new(self.class, self, '#{name}')
                 end}, __FILE__, __LINE__)
       end
   end

data/lib/neo4j/has_list/mapping.rb

@@ -34,11 +34,11 @@ module Neo4j
     class Mapping
       include Enumerable
       include ToJava
-      include WillPaginate::Finders::Base
-      
 
-      def initialize(node, name)
-        @time_line = org.neo4j.index.timeline.Timeline.new(name, node._java_node, true, Neo4j.started_db.graph)
+
+      def initialize(indexer_for, node, name)
+        @index = Neo4j.started_db.lucene.for_nodes("#{indexer_for.to_s.gsub('::', '_')}_#{name}-timeline", Neo4j::Config[:lucene][:exact])
+        @time_line = org.neo4j.index.lucene.LuceneTimeline.new(Neo4j.started_db.graph, @index)
         @node      = node
         @name      = name
         self.size = 0 unless size
@@ -57,38 +57,38 @@ module Neo4j
 
       # returns the first node with index n
       def [](n)
-        @time_line.getAllNodesBetween(n-1, n+1).first
+        @time_line.getBetween(n, n).first
       end
 
       # returns all nodes with the given index n
       def all(n)
-        @time_line.getAllNodesBetween(n-1, n+1)
+        @time_line.getBetween(n, n)
       end
 
       # returns the first node in the list or nil
       def first
-        @time_line.first_node
+        @time_line.getFirst()
       end
 
       # returns the last node in the list or nil
       def last
-        @time_line.last_node
+        @time_line.getLast
       end
 
       # adds a node to the list with the given index n
       def []=(n, other_node)
-        @time_line.add_node(other_node, n)
+        @time_line.add(other_node, n)
         self.size = self.size + 1
       end
 
       # returns all the nodes between the given Range
       def between(range)
-        @time_line.getAllNodesBetween(range.first-1, range.end+1)
+        @time_line.getBetween(range.first, range.end)
       end
 
       # removes one node from the list and decrases the size of the list,
       def remove(node)
-        @time_line.remove_node(node)
+        @index.remove(node, "timestamp")
         self.size = self.size - 1
       end
 
@@ -104,7 +104,7 @@ module Neo4j
       #  person.feeds.each {|node| node}
       #
       def each
-        @time_line.all_nodes.iterator.each do |node|
+        @time_line.getBetween(java.lang.Long::MIN_VALUE,java.lang.Long::MAX_VALUE).iterator.each do |node|
           if @raw then
             yield node
           else
@@ -113,41 +113,21 @@ module Neo4j
         end
       end
 
-      def wp_query(options, pager, args, &block) #:nodoc:
-        @raw = true
-        page = pager.current_page || 1
-        to   = pager.per_page * page
-        from = to - pager.per_page
-        i    = 0
-        res  = []
-        each do |node|
-          res << node.wrapper if i >= from
-          i += 1
-          break if i >= to
-        end
-        pager.replace res
-        pager.total_entries ||= size
-      end
-
       # If called then it will only return the raw java nodes and not the Ruby wrappers using the Neo4j::NodeMixin
       def raw
         @raw = true
       end
 
       def <<(other)
-        @time_line.add_node(other, size)
+        @time_line.add(other._java_node, size)
         self.size = self.size + 1
         self
       end
 
-
       private
       def size=(size)
         @node["_list_size_#{@name}"] = size
       end
-
-
     end
-
   end
 end