neo4j 1.0.0.beta.21-java

data/lib/neo4j/config.rb

@@ -0,0 +1,153 @@
+
+module Neo4j
+
+
+  # == Keeps configuration for neo4j
+  #
+  # The most important configuration is <tt>Neo4j::Config[:storage_path]</tt> which is used to
+  # locate where the neo4j database is stored on the filesystem.
+  # If this directory is empty then a new database will be created, otherwise it will use the
+  # database from that directory.
+  #
+  # ==== Default Configurations
+  # <tt>:storage_path</tt>::   default <tt>tmp/neo4j</tt> where the database is stored
+  # <tt>:timestamps</tt>::     default <tt>true</tt> for Rails Neo4j::Model - if timestamps should be used when saving the model
+  # <tt>:lucene</tt>::         default hash keys: <tt>:fulltext</tt>, <tt>:exact</tt> configuration how the lucene index is stored
+  # <tt>:converters</tt>::     defines which converters should be used before writing and reading to neo4j, see Neo4j::TypeConverters
+  #
+  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',
+          :timestamps => true,
+          
+          # TODO: Just pickup all converter classes that are in the Neo4j::TypeConverters module?
+          :converters => { 	Date 			=> Neo4j::TypeConverters::DateConverter, 
+                            DateTime 	=> Neo4j::TypeConverters::DateTimeConverter,
+                            Time 			=> Neo4j::TypeConverters::TimeConverter
+          								},
+          								
+          :lucene => {
+                  :fulltext =>  {"provider" => "lucene", "type" => "fulltext" },
+                  :exact    =>  {"provider" => "lucene", "type" => "exact" }}
+        }
+      end
+
+     
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c :: The configuration parameters, a hash.
+      #
+      # ==== 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 :: The key to set the parameter for.
+      # val :: The value of the parameter.
+      #
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
+      end
+
+
+      # Gets the the value of a config entry
+      #
+      # ==== Parameters
+      # key:: 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
+      # 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:: The key to retrieve the parameter for.
+      # default::The default value to return if the parameter is not set.
+      #
+      # ==== Returns
+      # 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
+      # The config as a hash.
+      #
+      def to_hash
+        @configuration
+      end
+
+      # Returns the config as YAML.
+      #
+      # ==== Returns
+      # The config as YAML.
+      #
+      def to_yaml
+        require "yaml"
+        @configuration.to_yaml
+      end
+    end
+  end
+
+end

data/lib/neo4j/database.rb

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

data/lib/neo4j/equal.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,116 @@
+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>
+  #
+  # === Usage
+  #
+  #   class MyListener
+  #     def on_node_deleted(node, old_props, tx_data)
+  #     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)
+    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), data)}
+      data.created_relationships.each {|rel| relationship_created(rel, data)}
+      data.deleted_relationships.each {|rel| relationship_deleted(rel, deleted_rel_properties_for(rel, data), data)}
+      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 data.deleted_relationships.include?(tx_data.entity) }
+    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 deleted_rel_properties_for(rel, data)
+      data.removed_relationship_properties.find_all{|tx_data| tx_data.entity == rel}.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 {|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, data)
+      @listeners.each {|li| li.on_node_deleted(node,old_properties, data) if li.respond_to?(:on_node_deleted)}
+    end
+
+    def relationship_created(relationship, tx_data)
+      @listeners.each {|li| li.on_relationship_created(relationship, tx_data) if li.respond_to?(:on_relationship_created)}
+    end
+
+    def relationship_deleted(relationship, old_props, data)
+      @listeners.each {|li| li.on_relationship_deleted(relationship, old_props, data) 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
+  end
+end

data/lib/neo4j/index/class_methods.rb

@@ -0,0 +1,62 @@
+module Neo4j
+  module Index
+    module ClassMethods
+      attr_reader :_indexer
+
+      extend Forwardable
+
+      ##
+      # See Neo4j::Index::Indexer#index
+      # Forwards to the indexer that should be used.
+      # It is possible to share the same index for several different classes, see #node_indexer.
+      # :singleton-method: index
+
+      ##
+      # See Neo4j::Index::Indexer#find
+      # Forwards to the indexer that should be used.
+      # It is possible to share the same index for several different classes, see #node_indexer.
+      # :singleton-method: find
+
+
+      def_delegators :@_indexer, :index, :find, :index?, :index_type?, :delete_index_type, :rm_field_type, :add_index, :rm_index, :index_type_for, :index_name
+
+
+      # Sets which indexer should be used for the given node class.
+      # You can share an indexer between several different classes.
+      #
+      # ==== Example
+      #   class Contact
+      #      include Neo4j::NodeMixin
+      #      index :name
+      #      has_one :phone
+      #   end
+      #
+      #   class Phone
+      #      include Neo4j::NodeMixin
+      #      property :phone
+      #      node_indexer Contact  # put index on the Contact class instead
+      #      index :phone
+      #   end
+      #
+      #   # Find an contact with a phone number, this works since they share the same index
+      #   Contact.find('phone: 12345').first #=> a phone object !
+      #
+      # ==== Returns
+      # The indexer that should be used to index the given class
+      def node_indexer(clazz)
+        indexer(clazz, :node)
+      end
+
+      # Sets which indexer should be used for the given relationship class
+      # Same as #node_indexer except that it indexes relationships instead of nodes.
+      #
+      def rel_indexer(clazz)
+        indexer(clazz, :rel)
+      end
+
+      def indexer(clazz, type) #:nodoc:
+        @_indexer = IndexerRegistry.create_for(self, clazz, type)
+      end
+    end
+  end
+end

data/lib/neo4j/index/index.rb

@@ -0,0 +1,33 @@
+module Neo4j
+
+  module Index
+
+    # Adds an index on the given property
+    # Notice that you normally don't have to do that since you simply can declare
+    # that the property and index should be updated automatically by using the class method #index.
+    #
+    # The index operation will take place immediately unlike when using the Neo4j::Index::ClassMethods::index
+    # method which instead will guarantee that the neo4j database and the lucene database will be consistent.
+    # It uses a two phase commit when the transaction is about to be committed.
+    #
+    # ==== See also
+    # Neo4j::Index::ClassMethods::index
+    #
+    def add_index(field, value=self[field])
+      self.class.add_index(wrapped_entity, field.to_s, value)
+    end
+
+    # Removes an index on the given property.
+    # Just like #add_index this is normally not needed since you instead can declare it with the
+    # #index class method instead.
+    #
+    # ==== See also
+    # Neo4j::Index::ClassMethods::index
+    # Neo4j::Index#add_index
+    #
+    def rm_index(field, value=self[field])
+      self.class.rm_index(wrapped_entity, field.to_s, value)
+    end
+
+  end
+end