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

data/lib/neo4j/core_ext/class/inheritable_attributes.rb

@@ -1,12 +0,0 @@
-# This is copied from Rails Active Support since it has been depricated and I still need it
-
-# Taken from: https://raw.github.com/lifo/docrails/dd6c3676af3fa6019c53a59f62c4fd14966be728/activesupport/lib/active_support/core_ext/class/inheritable_attributes.rb
-
-# Changes made:
-# - Remove deprecation warnings
-# - Ignore if already available from ActiveSupport
-#
-# Can't use class_attribute because we want to use the same value for all subclasses
-
-
-require 'neo4j/core_ext/class/rewrite_inheritable_attributes.rb'

data/lib/neo4j/core_ext/class/rewrite_inheritable_attributes.rb

@@ -1,170 +0,0 @@
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/array/extract_options'
-
-# Retained for backward compatibility. Methods are now included in Class.
-module ClassInheritableAttributes # :nodoc:
-end
-
-# It is recommended to use <tt>class_attribute</tt> over methods defined in this file. Please
-# refer to documentation for <tt>class_attribute</tt> for more information. Officially it is not
-#
-# Allows attributes to be shared within an inheritance hierarchy. Each descendant gets a copy of
-# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
-# to, for example, an array without those additions being shared with either their parent, siblings, or
-# children. This is unlike the regular class-level attributes that are shared across the entire hierarchy.
-#
-# The copies of inheritable parent attributes are added to subclasses when they are created, via the
-# +inherited+ hook.
-#
-#  class Person
-#    class_inheritable_accessor :hair_colors
-#  end
-#
-#  Person.hair_colors = [:brown, :black, :blonde, :red]
-#  Person.hair_colors     # => [:brown, :black, :blonde, :red]
-#  Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-#
-# To opt out of the instance writer method, pass :instance_writer => false.
-# To opt out of the instance reader method, pass :instance_reader => false.
-#
-#   class Person
-#     class_inheritable_accessor :hair_colors :instance_writer => false, :instance_reader => false
-#   end
-#
-#   Person.new.hair_colors = [:brown]  # => NoMethodError
-#   Person.new.hair_colors             # => NoMethodError
-class Class # :nodoc:
-  def class_inheritable_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}                                # def self.after_add
-          read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}                                     # def after_add
-          self.class.#{sym}                            #   self.class.after_add
-        end                                            # end
-        " unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.color=(obj)
-          write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def color=(obj)
-          self.class.#{sym} = obj                      #   self.class.color = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_array_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.levels=(obj)
-          write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def levels=(obj)
-          self.class.#{sym} = obj                      #   self.class.levels = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_hash_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.nicknames=(obj)
-          write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def nicknames=(obj)
-          self.class.#{sym} = obj                      #   self.class.nicknames = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-
-  def class_inheritable_array(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_array_writer(*syms)
-  end
-
-  def class_inheritable_hash(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_hash_writer(*syms)
-  end
-
-  def inheritable_attributes
-    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  def write_inheritable_attribute(key, value)
-    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-      @inheritable_attributes = {}
-    end
-    inheritable_attributes[key] = value
-  end
-
-  def write_inheritable_array(key, elements)
-    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
-  end
-
-  def write_inheritable_hash(key, hash)
-    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
-  def read_inheritable_attribute(key)
-    inheritable_attributes[key]
-  end
-
-  def reset_inheritable_attributes
-    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  private
-    # Prevent this constant from being created multiple times
-    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze
-
-    def inherited_with_inheritable_attributes(child)
-      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-
-      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-      else
-        new_inheritable_attributes = Hash[inheritable_attributes.map do |(key, value)|
-          [key, value.duplicable? ? value.dup : value]
-        end]
-      end
-
-      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-    end
-
-    alias inherited_without_inheritable_attributes inherited
-    alias inherited inherited_with_inheritable_attributes
-end

data/lib/neo4j/database.rb

@@ -1,158 +0,0 @@
-require 'neo4j/config'
-require 'neo4j/event_handler'
-require 'neo4j/transaction'
-
-module Neo4j
-  # Wraps both Java Neo4j GraphDatabaseService and Lucene.
-  # You can access the raw java neo4j and lucene db's with the <tt>graph</tt> and <tt>lucene</tt>
-  # properties.
-  #
-  # This class is also responsible for checking if there is already a running neo4j database.
-  # If one tries to start an already started database then a read only instance to neo4j will be used.
-  #
-  class Database
-    attr_reader :graph, :lucene, :event_handler, :storage_path
-
-    alias_method :index, :lucene # needed by cypher
-
-    def initialize()
-      @event_handler = EventHandler.new
-    end
-
-    def start #:nodoc:
-      return if running?
-      @running = true
-      @storage_path = Config.storage_path
-
-      begin
-        if self.class.locked?
-          start_readonly_graph_db
-        elsif Neo4j::Config['ha.db']
-          start_ha_graph_db
-          Neo4j.migrate!
-        else
-          start_local_graph_db
-          Neo4j.migrate!
-        end
-      rescue
-        @running = false
-        raise
-      end
-
-      at_exit { shutdown }
-    end
-
-    def start_readonly_graph_db #:nodoc:
-      Neo4j.logger.info "Starting Neo4j in readonly mode since the #{@storage_path} is locked"
-      @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}"
-      @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.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)
-      @graph = org.neo4j.kernel.HighlyAvailableGraphDatabase.new(@storage_path, Neo4j.config.to_java_map)
-      @graph.register_transaction_event_handler(@event_handler)
-      @lucene = @graph.index
-      @event_handler.neo4j_started(self)
-    end
-
-    def start_external_db(external_graph_db)
-      begin
-        @running = true
-        @graph = external_graph_db
-        Neo4j.migrate!
-        @graph.register_transaction_event_handler(@event_handler)
-        @lucene = @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
-        @event_handler.neo4j_started(self)
-        Neo4j.logger.info("Started with external db")
-      rescue
-        @running = false
-        raise
-      end
-    end
-
-    def running? #:nodoc:
-      @running
-    end
-
-    # 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.java_class == org.neo4j.kernel.EmbeddedGraphDatabase
-    end
-
-    # check if the database is locked. A neo4j database is locked when the database is running.
-    def self.locked?
-      lock_file = File.join(Neo4j.config.storage_path, 'neostore')
-      return false unless File.exist?(lock_file)
-      rfile = java.io.RandomAccessFile.new(lock_file, 'rw')
-      begin
-        lock = rfile.getChannel.tryLock
-        lock.release if lock
-        return lock == nil # we got the lock, so that means it is not locked.
-      rescue Exception => e
-        return false
-      end
-    end
-
-    def shutdown #:nodoc:
-      if @running
-        @graph.unregister_transaction_event_handler(@event_handler) unless read_only?
-        @event_handler.neo4j_shutdown(self)
-        @graph.shutdown
-        @graph = nil
-        @lucene = nil
-        @running = false
-        @neo4j_manager = nil
-      end
-
-    end
-
-
-    def management(jmx_clazz) #:nodoc:
-      @neo4j_manager ||= org.neo4j.management.Neo4jManager.new(@graph.get_management_bean(org.neo4j.jmx.Kernel.java_class))
-      @neo4j_manager.getBean(jmx_clazz.java_class)
-    end
-
-    def begin_tx #:nodoc:
-      @graph.begin_tx
-    end
-
-
-    def each_node #:nodoc:
-      iter = @graph.all_nodes.iterator
-      while (iter.hasNext)
-        yield iter.next.wrapper
-      end
-    end
-
-    def _each_node #:nodoc:
-      iter = @graph.all_nodes.iterator
-      while (iter.hasNext)
-        yield iter.next
-      end
-    end
-
-  end
-
-end

data/lib/neo4j/equal.rb

@@ -1,21 +0,0 @@
-module Neo4j
-
-  # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
-  #
-  module Equal
-    def equal?(o)
-      eql?(o)
-    end
-
-    def eql?(o)
-      return false unless o.respond_to?(:getId)
-      o.getId == getId
-    end
-
-    def ==(o)
-      eql?(o)
-    end
-
-  end
-
-end

data/lib/neo4j/event_handler.rb

@@ -1,263 +0,0 @@
-module Neo4j
-
-  # == Handles Transactional Events
-  #
-  # You can use this to receive event before the transaction commits.
-  # The following events are supported:
-  # * <tt>on_neo4j_started</tt>
-  # * <tt>on_neo4j_shutdown</tt>
-  # * <tt>on_node_created</tt>
-  # * <tt>on_node_deleted</tt>
-  # * <tt>on_relationship_created</tt>
-  # * <tt>on_relationship_deleted</tt>
-  # * <tt>on_property_changed</tt>
-  # * <tt>on_rel_property_changed</tt>
-  # * <tt>on_after_commit</tt>
-  #
-  # ==== on_neo4j_started(db)
-  #
-  # Called when the neo4j engine starts.
-  # Notice that the neo4j will be started automatically when the first neo4j operation is performed.
-  # You can also start Neo4j: <tt>Neo4j.start</tt>
-  #
-  # * <tt>db</tt> :: the Neo4j::Database instance
-  #
-  # ==== on_neo4j_shutdown(db)
-  #
-  # Called when the neo4j engine shutdown. You don't need to call <tt>Neo4j.shutdown</tt> since
-  # the it will automatically be shutdown when the application exits (using the at_exit ruby hook).
-  #
-  # * <tt>db</tt> :: the Neo4j::Database instance
-  #
-  # ==== on_after_commit(data, state)
-  #
-  # Called after the transaction has successfully committed.
-  # See http://api.neo4j.org/1.4/org/neo4j/graphdb/event/TransactionEventHandler.html for the data and state parameter.
-  #
-  # ==== on_node_created(node)
-  #
-  # * <tt>node</tt> :: the node that was created
-  #
-  # ==== on_node_deleted(node, old_props, deleted_relationship_set, deleted_node_identity_map)
-  #
-  # * <tt>node</tt> :: the node that was deleted
-  # * <tt>old_props</tt> :: a hash of the old properties this node had
-  # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::RelationshipSet
-  # * <tt>deleted_node_identity_map</tt> :: the identity map of deleted nodes. The key is the node id, and the value is the node
-  #
-  # ==== on_relationship_created(rel, created_node_identity_map)
-  #
-  # * <tt>rel</tt> :: the relationship that was created
-  # * <tt>created_node_identity_map</tt> :: the identity map of created nodes. The key is the node id, and the value is the node
-  #
-  # ==== on_relationship_deleted(rel, old_props, deleted_relationship_set, deleted_node_identity_map)
-  #
-  # * <tt>rel</tt> :: the relationship that was created
-  # * <tt>old_props</tt> :: a hash of the old properties this relationship had
-  # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::RelationshipSet
-  # * <tt>deleted_node_identity_map</tt> :: the identity map of deleted nodes. The key is the node id, and the value is the node
-  #
-  # ==== on_property_changed(node, key, old_value, new_value)
-  #
-  # * <tt>node</tt> :: the node
-  # * <tt>key</tt> :: the name of the property that was changed (String)
-  # * <tt>old_value</tt> :: old value of the property
-  # * <tt>new_value</tt> :: new value of the property
-  #
-  # ==== on_rel_property_changed(rel, key, old_value, new_value)
-  #
-  # * <tt>rel</tt> :: the node that was created
-  # * <tt>key</tt> :: the name of the property that was changed (String)
-  # * <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
-  #     def on_node_deleted(node, old_props, deleted_relationship_set, deleted_node_identity_map)
-  #     end
-  #   end
-  #
-  #   # to add an listener without starting neo4j:
-  #   Neo4j.unstarted_db.event_handler.add(MyListener.new)
-  #
-  # You only need to implement the methods that you need.
-  #
-  class EventHandler
-    include org.neo4j.graphdb.event.TransactionEventHandler
-
-    def initialize
-      @listeners = []
-    end
-
-
-    def after_commit(data, state)
-      @listeners.each {|li|  li.on_after_commit(data, state) if li.respond_to?(:on_after_commit)}
-    end
-
-    def after_rollback(data, state)
-    end
-
-    def before_commit(data)
-      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.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 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)
-      relationships.each{|rel| relationship_set.add(rel)}
-      relationship_set
-    end
-
-    def property_map(properties)
-      map = java.util.HashMap.new
-      properties.each do |property|
-        map(property.entity.getId, map).put(property.key, property.previously_commited_value)
-      end
-      map
-    end
-
-    def map(key,map)
-      map.get(key) || add_map(key,map)
-    end
-
-    def add_map(key,map)
-      map.put(key, java.util.HashMap.new)
-      map.get(key)
-    end
-
-    def add(listener)
-      @listeners << listener unless @listeners.include?(listener)
-    end
-
-    def remove(listener)
-      @listeners.delete(listener)
-    end
-
-    def remove_all
-      @listeners = []
-    end
-
-    def print
-      puts "Listeners #{@listeners.size}"
-      @listeners.each {|li| puts "  Listener '#{li}'"}
-    end
-
-    def neo4j_started(db)
-      @listeners.each { |li| li.on_neo4j_started(db) if li.respond_to?(:on_neo4j_started) }
-    end
-
-    def neo4j_shutdown(db)
-      @listeners.each { |li| li.on_neo4j_shutdown(db) if li.respond_to?(:on_neo4j_shutdown) }
-    end
-
-    def node_created(node)
-      @listeners.each {|li| li.on_node_created(node) if li.respond_to?(:on_node_created)}
-    end
-
-    def node_deleted(node,old_properties, deleted_relationship_set, deleted_node_identity_map)
-      @listeners.each {|li| li.on_node_deleted(node,old_properties, deleted_relationship_set, deleted_node_identity_map) if li.respond_to?(:on_node_deleted)}
-    end
-
-    def relationship_created(relationship, created_node_identity_map)
-      @listeners.each {|li| li.on_relationship_created(relationship, created_node_identity_map) if li.respond_to?(:on_relationship_created)}
-    end
-
-    def relationship_deleted(relationship, old_props, deleted_relationship_set, deleted_node_identity_map)
-      @listeners.each {|li| li.on_relationship_deleted(relationship, old_props, deleted_relationship_set, deleted_node_identity_map) if li.respond_to?(:on_relationship_deleted)}
-    end
-
-    def property_changed(node, key, old_value, new_value)
-      @listeners.each {|li| li.on_property_changed(node, key, old_value, new_value) if li.respond_to?(:on_property_changed)}
-    end
-
-    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