neo4j 1.0.0.beta.1

data/lib/neo4j/config.rb

@@ -0,0 +1,137 @@
+
+module Neo4j
+
+
+  # Keeps configuration for neo4j.
+  #
+  # Neo4j::Config[:storage_path]:: is used for locating the neo4j database on the filesystem.
+  #
+  class Config
+    # This code is copied from merb-core/config.rb.
+    class << self
+      # Returns the hash of default config values for neo4j
+      #
+      # ==== Returns
+      # Hash:: The defaults for the config.
+      def defaults
+        @defaults ||= {
+          :storage_path => 'tmp/neo4j',
+          :lucene => {
+                  :fulltext => org.neo4j.index.impl.lucene.LuceneIndexProvider::FULLTEXT_CONFIG,
+                  :exact => org.neo4j.index.impl.lucene.LuceneIndexProvider::EXACT_CONFIG}
+        }
+      end
+
+     
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c<Hash>:: The configuration parameters.
+      #
+      # ==== Examples
+      # Neo4j::Config.use do |config|
+      # config[:storage_path] = '/var/neo4j'
+      # end
+      #
+      # ==== Returns
+      # nil
+      def use
+        @configuration ||= {}
+        yield @configuration
+        nil
+      end
+      
+      
+      # Set the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key to set the parameter for.
+      # val<Object>:: The value of the parameter.
+      #
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
+      end
+
+
+      # Gets the the value of a config entry
+      #
+      # ==== Parameters
+      # key<Object>:: The key of the config entry value we want
+      #
+      def [](key)
+        (@configuration ||= setup)[key]
+      end
+
+
+      # Remove the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key of the parameter to delete.
+      #
+      # ==== Returns
+      # Object:: The value of the removed entry.
+      #
+      def delete(key)
+        @configuration.delete(key)
+      end
+
+
+      # Remove all configuration. This can be useful for testing purpose.
+      #
+      #
+      # ==== Returns
+      # nil
+      #
+      def delete_all
+        @configuration = nil
+      end
+
+
+      # Retrieve the value of a config entry, returning the provided default if the key is not present
+      #
+      # ==== Parameters
+      # key<Object>:: The key to retrieve the parameter for.
+      # default<Object>::
+      # The default value to return if the parameter is not set.
+      #
+      # ==== Returns
+      # Object:: The value of the configuration parameter or the default.
+      #
+      def fetch(key, default)
+        @configuration.fetch(key, default)
+      end
+
+      # Sets up the configuration
+      #
+      # ==== Returns
+      # The configuration as a hash.
+      #
+      def setup()
+        @configuration = {}
+        @configuration.merge!(defaults)
+        @configuration
+      end
+
+
+      # Returns the configuration as a hash.
+      #
+      # ==== Returns
+      # Hash:: The config as a hash.
+      #
+      def to_hash
+        @configuration
+      end
+
+      # Returns the config as YAML.
+      #
+      # ==== Returns
+      # String:: The config as YAML.
+      #
+      def to_yaml
+        require "yaml"
+        @configuration.to_yaml
+      end
+    end
+  end
+
+end

data/lib/neo4j/database.rb

@@ -0,0 +1,43 @@
+module Neo4j
+  class Database
+    attr_reader :graph, :lucene, :event_handler
+
+    def initialize()
+      @event_handler = EventHandler.new
+    end
+
+
+    def start
+      @running = true
+      @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(Config[:storage_path])
+      @lucene = org.neo4j.index.impl.lucene.LuceneIndexProvider.new(@graph)
+      @graph.register_transaction_event_handler(@event_handler)
+      @event_handler.neo4j_started(self)
+    end
+
+    def shutdown
+      @running = false
+      @graph.unregister_transaction_event_handler(@event_handler)
+      @event_handler.neo4j_shutdown(self)
+      @graph.shutdown
+    end
+
+    def running?
+      @running
+    end
+
+    def begin_tx
+      @graph.begin_tx
+    end
+
+
+    def each_node
+      iter = @graph.all_nodes.iterator
+      while (iter.hasNext)
+        yield Node.load_wrapper(iter.next)
+      end
+    end
+
+  end
+
+end

data/lib/neo4j/equal.rb

@@ -0,0 +1,22 @@
+module Neo4j
+  module Equal
+    def neo_id
+      getId
+    end
+
+    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

@@ -0,0 +1,91 @@
+module Neo4j
+
+  # Handles events like a new node is created or deleted
+  class EventHandler
+    include org.neo4j.graphdb.event.TransactionEventHandler
+
+    def initialize
+      @listeners = []
+    end
+
+
+    def after_commit(data, state)
+    end
+
+    def after_rollback(data, state)
+    end
+
+    def before_commit(data)
+      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.removed_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless data.deleted_nodes.include?(tx_data.entity) }
+      data.deleted_nodes.each { |node| node_deleted(node, deleted_properties_for(node,data))}
+      # TODO Add relationship properties callbacks
+    end
+
+    def deleted_properties_for(node, data)
+      data.removed_node_properties.find_all{|tx_data| tx_data.entity == node}.inject({}) do |memo, tx_data|
+        memo[tx_data.key] = tx_data.previously_commited_value
+        memo
+      end
+    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_key {|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)
+      @listeners.each {|li| li.on_node_deleted(node,old_properties) if li.respond_to?(:on_node_deleted)}
+    end
+
+    def relationship_created(relationship)
+      @listeners.each {|li| li.on_relationship_created(relationship) if li.respond_to?(:on_relationship_created)}
+    end
+
+    def relationship_deleted(relationship)
+      @listeners.each {|li| li.on_relationship_deleted(relationship) 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
+
+    # TODO
+    def tx_finished(tx)
+      @listeners.each {|li| li.on_tx_finished(tx) if li.respond_to?(:on_tx_finished)}
+    end
+
+    def neo_started(neo_instance)
+      @listeners.each {|li|  li.on_neo_started(neo_instance)  if li.respond_to?(:on_neo_started)}
+    end
+
+    def neo_stopped(neo_instance)
+      @listeners.each {|li| li.on_neo_stopped(neo_instance) if li.respond_to?(:on_neo_stopped)}
+    end
+  end
+end

data/lib/neo4j/index.rb

@@ -0,0 +1,157 @@
+module Neo4j
+
+  module Index
+    def add_index(field, value=self[field])
+      self.class.add_index(wrapped_entity, field.to_s, value)
+    end
+
+    def rm_index(field, value=self[field])
+      self.class.rm_index(wrapped_entity, field.to_s, value)
+    end
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :@indexer, :index, :find, :index?, :index_type?, :clear_index_type, :rm_index_type, :add_index, :rm_index
+
+      # Sets which indexer should be used for the given class.
+      # Returns the old one if there was an old indexer.
+      def indexer(clazz)
+        old = @indexer
+        @@indexers ||= {}
+        if @@indexers.include?(clazz)
+          # we want to reuse an existing index
+          @indexer = @@indexers[clazz]
+          @indexer.include_trigger(self)
+        else
+          @indexer = Indexer.new(clazz)
+          @@indexers[clazz] = @indexer
+        end
+        old
+      end
+    end
+
+    class Indexer
+      attr_reader :index_name
+
+      def initialize(clazz)
+        @index_name = clazz.to_s
+
+        @indexes = {}  # key = type, value = java neo4j index
+        @field_types = {}  # key = field, value = type (e.g. :exact or :fulltext)
+        @triggered_by = clazz.to_s
+      end
+
+      #  add an index on a field that will be automatically updated by events.
+      def index(field, conf = {})
+        type = conf[:type] || :exact
+        @field_types[field.to_s] = type
+        Neo4j.default_db.event_handler.add(self)
+      end
+
+      def index?(field)
+        @field_types.include?(field.to_s)
+      end
+
+      def index_type?(type)
+        @field_types.values.include?(type)
+      end
+
+      def add_index(entity, field, value)
+        index_for_field(field.to_s).add(entity, field, value)
+      end
+
+      def rm_index(entity, field, value)
+        index_for_field(field).remove(entity, field, value)
+      end
+
+      def find(query, type = :exact)
+        index = index_for_type(type)
+        hits = index.query(query)
+        if block_given?
+          begin
+            ret = yield hits
+          ensure
+            hits.close if hits
+          end
+          ret
+        else
+          hits
+        end
+      end
+
+      # clears the index, if no type is provided clear all types of indexes
+      def clear_index_type(type=nil)
+        if type
+          #raise "can't clear index of type '#{type}' since it does not exist ([#{@field_types.values.join(',')}] exists)" unless index_type?(type)
+          @indexes[type] && @indexes[type].clear
+        else
+          @indexes.each_value{|index| index.clear}
+        end
+      end
+
+      def rm_index_type(type=nil)
+        if type
+          #raise "can't remove index of type '#{type}' since it does not exist ([#{@field_types.values.join(',')}] exists)" unless index_type?(type)
+          @field_types.delete_if {|k,v| v == type}
+        else
+          @field_types.clear
+        end
+      end
+
+      def index_for_field(field)
+        type = @field_types[field]
+        @indexes[type] ||= create_index_with(type)
+      end
+
+      def index_for_type(type)
+        @indexes[type] ||= create_index_with(type)
+      end
+
+      def lucene_config(type)
+        conf = Neo4j::Config[:lucene][type.to_sym]
+        raise "unknown lucene type #{type}" unless conf
+        conf
+      end
+
+      def create_index_with(type)
+        db=Neo4j.started_db
+        index_config = lucene_config(type)
+        db.lucene.node_index("#{@index_name}-#{type}", index_config)
+      end
+
+
+      # ------------------------------------------------------------------
+      # Event Handling
+
+      def include_trigger(clazz)
+         @triggered_by << clazz.to_s  unless @triggered_by.include?(clazz.to_s)
+      end
+
+      def trigger?(classname)
+        @triggered_by.include?(classname || 'Neo4j::Node')
+      end
+
+      def on_node_created(node)
+        return unless trigger?(node['_classname'])
+        @field_types.keys.each {|field| add_index(node, field, node[field]) if node.property?(field)}
+      end
+
+      def on_node_deleted(node, old_props)
+        return unless @triggered_by.include?(old_props['_classname'] || 'Neo4j::Node')
+        @field_types.keys.each {|field| rm_index(node, field, old_props[field]) if old_props[field]}
+      end
+
+      def on_property_changed(node, field, old_val, new_val)
+        return unless trigger?(node[:_classname]) && @field_types.include?(field)
+
+        rm_index(node, field, old_val) if old_val
+
+        # add index
+        add_index(node, field, new_val) if new_val
+      end
+    end
+
+  end
+
+end