neo4j 1.0.0.beta.1

data/lib/neo4j.old/batch_inserter.rb

@@ -0,0 +1,144 @@
+module Neo4j
+
+  class BatchItem  # :nodoc:
+    attr_accessor :_wrapper, :neo_id
+
+    include Neo4j::JavaPropertyMixin
+
+    def initialize(neo_id, inserter)
+      @neo_id = neo_id
+      @inserter = inserter
+    end
+
+    def getId(); neo_id end
+
+    def has_property?(key)
+      props.include?(key.to_s)
+    end
+
+    def get_property(key)
+      props[key]
+    end
+    
+    def props
+      # not sure why I have to do it like this, Strange why I can't use the Java Hash ?
+      # gets java.lang.UnsupportedOperationException: null, in java/util/AbstractMap.java:186:in `put'
+      java_props = @inserter.getNodeProperties(neo_id)
+      ruby_props = {}
+      java_props.keySet().each{|k| ruby_props[k] = java_props[k]}
+      ruby_props
+    end
+
+
+    def setProperty(key, value)
+      ruby_props = props
+      ruby_props[key.to_s] = value
+      @inserter.setNodeProperties(neo_id, ruby_props)
+
+      if (wrapper_class and key[0, 1] != '_') # do not want events on internal properties
+        wrapper_class.indexer.on_property_changed(wrapper, key)
+      end
+    end
+  end
+
+  # Neo4j has a batch insert mode that drops support for transactions and concurrency in favor of insertion speed.
+  # This is useful when you have a big dataset that needs to be loaded once. In our experience, the batch inserter will
+  # typically inject data around five times faster than running in normal transactional mode.
+  #
+  # === Usage
+  #
+  # The initialize method takes a code block that will use the BatchInserter.
+  #
+  #  Neo4j::BatchInserter.new do |b|
+  #    a = Neo4j::Node.new :name => 'a'
+  #    b = Neo4j::Node.new :name => 'b'
+  #    c = Foo.new :key1 => 'val1', :key2 => 'val2'
+  #    c[:name] = "c"
+  #    Neo4j::Relationship.new(:friend, a, b, :since => '2001-01-01')
+  #    Neo4j::Relationship.new(:friend, Neo4j.ref_node, c, :since => '2001-01-01')
+  #  end
+  #
+  # After the code block the normal creation for nodes and relationship will be used.
+  # Traversals inside the batch inserter block is not possible.
+  # The BatchInserter can be used together with Neo4j Migrations (see Neo4j#migration)
+  #
+  class BatchInserter
+
+    # See class description for usage.
+    #
+    # === Parameters
+    # storage_path:: optional, the location of the neo4j dabase on file system, default Neo4j::Config[:storage_path]
+    # db_version:: optional, sets version number on reference node, default nil -> do not set this property
+    def initialize(storage_path = Neo4j::Config[:storage_path], db_version=nil)  # :yields: batch_inserter
+      # create the batch inserter
+      inserter = org.neo4j.kernel.impl.batchinsert.BatchInserterImpl.new(storage_path)
+
+      # save original methods
+      create_node_meth = Neo4j.method(:create_node)
+      create_rel_meth  = Neo4j.method(:create_rel)
+      ref_node_meth    = Neo4j.method(:ref_node)
+      instance_meth    = Neo4j.method(:instance)
+      
+      # replace methods
+      neo4j_meta = (class << Neo4j; self; end)
+      neo4j_meta.instance_eval do
+        define_method(:create_node) do |props|
+          props ||= {}
+          id = inserter.createNode(props.keys.inject({}) {|hash, key| hash[key.to_s] = props[key]; hash})
+          BatchItem.new(id, inserter)
+        end
+        define_method(:create_rel) do |type, from_node, to_node, props|
+          props = Hash[*props.map{|k, v| [k.to_s, v]}.flatten] if props
+          java_type = org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+          id = inserter.createRelationship(from_node.neo_id, to_node.neo_id, java_type, props)
+          BatchItem.new(id, inserter)
+        end
+        define_method(:ref_node) do 
+          BatchItem.new(inserter.getReferenceNode, inserter)
+        end
+        define_method(:instance) do
+          Neo4j::BatchInstance.new
+        end
+      end
+
+      begin                     
+        yield inserter         
+        Neo4j.ref_node[:db_version] = db_version if db_version
+      ensure
+        inserter.shutdown
+        # restore old methods
+        neo4j_meta.instance_eval do
+          define_method(:create_node, create_node_meth)
+          define_method(:create_rel, create_rel_meth)
+          define_method(:ref_node, ref_node_meth)
+          define_method(:instance, instance_meth)
+        end
+      end
+    end
+
+    # This method is used if the batch inserter is used from the Migration API.
+    #
+    # === Parameters
+    # context:: the context on which the batch inserter code block is evaluated in, not used.
+    # version:: optional, if given then will set the property db_version on the context
+    def self.execute(context, version=nil, &block)
+      # Neo4j must not be running while using batch inserter, stop it just in case ...
+      Neo4j::Transaction.finish
+      Neo4j.stop
+
+      BatchInserter.new(Neo4j::Config[:storage_path], version, &block)
+
+      Neo4j.start
+    end
+  end
+
+  # Used instead of Neo4j.instance object - will happily accept any methods - like transaction methods.
+  class BatchInstance # :nodoc:
+    def method_missing(m, *args, &block)
+      return BatchInstance.new
+    end
+  end
+end
+
+
+

data/lib/neo4j.old/config.rb

@@ -0,0 +1,138 @@
+
+module Neo4j
+
+
+  # Keeps configuration for neo4j.
+  #
+  # Neo4j::Config[:storage_path]:: is used for locating the neo4j database on the filesystem.
+  # Neo4j::Config[:rest_port]:: used by the REST extension for starting a web server on a port
+  #
+  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',
+          :rest_port => 9123
+        }
+      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.
+      #
+      # :api: public
+      def to_hash
+        @configuration
+      end
+
+      # Returns the config as YAML.
+      #
+      # ==== Returns
+      # String:: The config as YAML.
+      #
+      # :api: public
+      def to_yaml
+        require "yaml"
+        @configuration.to_yaml
+      end
+    end
+  end
+
+end

data/lib/neo4j.old/event_handler.rb

@@ -0,0 +1,73 @@
+module Neo4j
+
+  # Handles events like a new node is created or deleted
+  class EventHandler
+    def initialize
+      @listeners = []
+      @filter_classes = []
+    end
+
+    def add(listener)
+      @listeners << listener unless @listeners.include?(listener)
+      add_filter(listener) # the listener do not want to get events on it self
+    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 add_filter(filter_class)
+      @filter_classes << filter_class  unless @filter_classes.include?(filter_class)
+    end
+
+    def remove_filter(filter_class)
+      @filter_classes.delete filter_class
+    end
+
+    def node_created(node)
+      return if @filter_classes.include?(node.class)
+      @listeners.each {|li| li.on_node_created(node) if li.respond_to?(:on_node_created)}
+    end
+
+    def node_deleted(node)
+      return if @filter_classes.include?(node.class)
+      @listeners.each {|li| li.on_node_deleted(node) if li.respond_to?(:on_node_deleted)}
+    end
+
+    def relationship_created(relationship)
+      return if @filter_classes.include?(relationship.class)
+      @listeners.each {|li| li.on_relationship_created(relationship) if li.respond_to?(:on_relationship_created)}
+    end
+
+    def relationship_deleted(relationship)
+      return if @filter_classes.include?(relationship.class)
+      @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)
+      return if @filter_classes.include?(node.class)
+      @listeners.each {|li| li.on_property_changed(node, key, old_value, new_value) if li.respond_to?(:on_property_changed)}
+    end
+
+    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.old/extensions/activemodel.rb

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'singleton'
+require 'neo4j'
+require 'active_model'
+
+
+module Neo4j::NodeMixin
+  def to_model
+    Neo4j::ActiveModel::ActiveModelFactory.instance.to_model(self)
+  end
+
+  def attributes
+    attr = props
+    attr.keys.each {|k| attr.delete k if k[0] == ?_}
+    attr
+  end
+
+end
+
+module Neo4j::ActiveModel
+
+  def self.on_property_changed(node, key, old_value, new_value)
+    # make model dirty since it is changed
+    ActiveModelFactory.instance.dirty_node!(node.neo_id)
+  end
+
+  def self.on_tx_finished(tx)
+    # make all models clean again
+    ActiveModelFactory.instance.clean!
+  end
+
+  class ActiveModelFactory
+    private
+    def initialize
+      @classes = {}
+      @node_models = {}
+      Thread.current[:neo4j_active_model_factory] = self
+      Neo4j.event_handler.add(self)
+    end
+
+    public
+    def self.instance
+      # create one Neo4jActiveModelFactory for each thread
+      # since a transaction belongs to a thread and we don't want
+      # side effect of one transaction making model object dirty or clean for a different transaction
+      # in a different thread.
+      Thread.current[:neo4j_active_model_factory] || ActiveModelFactory.new
+    end
+
+    def dirty_node!(neo_id)
+      @node_models[neo_id] && @node_models[neo_id].dirty!
+    end
+
+    def clean!
+      @node_models.clear
+    end
+
+    def to_model(obj)
+      @node_models[obj.neo_id] || create_model_for(obj)
+    end
+
+    def create_model_for(obj)
+      clazz = @classes[obj.class] || create_wrapped_class_for(obj)
+      @node_models[obj.neo_id] = clazz.new(obj)
+    end
+
+    def create_wrapped_class_for(obj)
+      clazz = Class.new do
+        def initialize(wrapped)
+          @dirty = false
+          @wrapped = wrapped
+        end
+
+        def dirty!
+          @dirty = true
+        end
+
+        def persisted?
+          ! @dirty
+        end
+
+        def to_key
+          persisted? ? @wrapped.neo_id : nil
+        end
+
+        def to_param
+          to_key
+        end
+
+        if obj.respond_to?(:errors)
+          def errors;
+            @wrapped.errors;
+          end
+        else
+          def errors
+            object = Object.new
+
+            def object.[](key)
+              []
+            end
+
+            def object.full_messages()
+              []
+            end
+
+            object
+          end
+        end
+
+        if obj.respond_to?(:valid?)
+          def valid?;
+            @wrapped.valid?;
+          end
+        else
+          def valid?
+            true
+          end
+        end
+      end
+
+      singleton = class << clazz;
+        self;
+      end
+      singleton.class_eval do
+        # class methods
+        define_method :model_name do
+          @_model_name ||= ActiveModel::Name.new(obj.class)
+        end
+      end
+
+      @classes[obj.class] = clazz
+      clazz
+    end
+
+  end
+
+  Neo4j.event_handler.add(self)
+end
+
+
+
+#class LintTest < ActiveModel::TestCase
+#  include ActiveModel::Lint::Tests
+#
+#  class MyModel
+#    include Neo4j::NodeMixin
+#  end
+#
+#  def setup
+#    @model = MyModel.new
+#  end
+#
+#end
+#
+#require 'test/unit/ui/console/testrunner'
+#Neo4j::Transaction.run do
+#  Test::Unit::UI::Console::TestRunner.run(LintTest)
+#end