neo4j 1.0.0.beta.8 → 1.0.0.beta.9

data/lib/neo4j/database.rb

@@ -37,7 +37,7 @@ module Neo4j
     def each_node
       iter = @graph.all_nodes.iterator
       while (iter.hasNext)
-        yield Node.load_wrapper(iter.next)
+        yield Node.wrapper(iter.next)
       end
     end
 

data/lib/neo4j/event_handler.rb

@@ -21,8 +21,9 @@ module Neo4j
       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.created_relationships.each {|rel| relationship_created(rel)}
-      data.deleted_relationships.each {|rel| relationship_deleted(rel)}
-      # TODO Add relationship properties callbacks
+      data.deleted_relationships.each {|rel| relationship_deleted(rel, deleted_rel_properties_for(rel, 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)
@@ -32,6 +33,13 @@ module Neo4j
       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
@@ -69,15 +77,19 @@ module Neo4j
       @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)}
+    def relationship_deleted(relationship, old_props)
+      @listeners.each {|li| li.on_relationship_deleted(relationship, old_props) 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 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
+
+    # TODO ?
     def tx_finished(tx)
       @listeners.each {|li| li.on_tx_finished(tx) if li.respond_to?(:on_tx_finished)}
     end

data/lib/neo4j/index.rb

@@ -14,9 +14,20 @@ module Neo4j
 
       def_delegators :@indexer, :index, :find, :index?, :index_type?, :clear_index_type, :rm_index_type, :add_index, :rm_index, :index_type_for, :index_name
 
-      # Sets which indexer should be used for the given class.
+
+      # Sets which indexer should be used for the given node class
+      # Returns the old one if there was an old indexer.
+      def node_indexer(clazz)
+        indexer(clazz, :node)
+      end
+
+      # Sets which indexer should be used for the given relationship class
       # Returns the old one if there was an old indexer.
-      def indexer(clazz)
+      def rel_indexer(clazz)
+        indexer(clazz, :rel)
+      end
+
+      def indexer(clazz, type)  #:nodoc:
         old = @indexer
         @@indexers ||= {}
         if @@indexers.include?(clazz)
@@ -24,7 +35,7 @@ module Neo4j
           @indexer = @@indexers[clazz]
           @indexer.include_trigger(self)
         else
-          @indexer = Indexer.new(clazz)
+          @indexer = Indexer.new(clazz, type)
           @@indexers[clazz] = @indexer
         end
         old
@@ -84,9 +95,12 @@ module Neo4j
     class Indexer
       attr_reader :index_name
 
-      def initialize(clazz)
+      def initialize(clazz, type)
         @index_name = clazz.to_s
 
+        # do we want to index nodes or relationships ?
+        @type = type
+
         @indexes = {}  # key = type, value = java neo4j index
         @field_types = {}  # key = field, value = type (e.g. :exact or :fulltext)
         @triggered_by = clazz.to_s
@@ -174,7 +188,11 @@ module Neo4j
       def create_index_with(type)
         db=Neo4j.started_db
         index_config = lucene_config(type)
-        db.lucene.node_index("#{@index_name}-#{type}", index_config)
+        if @type == :node
+          db.lucene.node_index("#{@index_name}-#{type}", index_config)
+        else
+          db.lucene.relationship_index("#{@index_name}-#{type}", index_config)
+        end
       end
 
 
@@ -186,7 +204,7 @@ module Neo4j
       end
 
       def trigger?(classname)
-        @triggered_by.include?(classname || 'Neo4j::Node')
+        @triggered_by.include?(classname || (@type==:node ? 'Neo4j::Node' : 'Neo4j::Relationship'))
       end
 
       def on_node_created(node)
@@ -195,7 +213,7 @@ module Neo4j
       end
 
       def on_node_deleted(node, old_props)
-        return unless @triggered_by.include?(old_props['_classname'] || 'Neo4j::Node')
+        return unless trigger?(old_props['_classname'])
         @field_types.keys.each {|field| rm_index(node, field, old_props[field]) if old_props[field]}
       end
 
@@ -207,6 +225,22 @@ module Neo4j
         # add index
         add_index(node, field, new_val) if new_val
       end
+
+      def on_rel_property_changed(rel, field, old_val, new_val)
+        # works exactly like for nodes
+        on_property_changed(rel, field, old_val, new_val)
+      end
+
+      def on_relationship_created(rel)
+        # works exactly like for nodes
+        on_node_created(rel)
+      end
+
+      def on_relationship_deleted(rel, old_props)
+        # works exactly like for nodes
+        on_node_deleted(rel, old_props)
+      end
+
     end
 
   end

data/lib/neo4j/load.rb

@@ -0,0 +1,17 @@
+module Neo4j
+  module Load
+    def wrapper(node)
+      return node unless node.property?(:_classname)
+      to_class(node[:_classname]).load_wrapper(node)
+    end
+
+    def to_class(class_name)
+      class_name.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
+    end
+
+    def exist?(node_or_node_id, db = Neo4j.started_db)
+      id = node_or_node_id.kind_of?(Fixnum) ?  node_or_node_id : node_or_node_id.id
+      load(id, db) != nil
+    end
+  end
+end

data/lib/neo4j/mapping/class_methods/init_node.rb

@@ -0,0 +1,50 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module InitNode
+
+      def load_wrapper(node)
+        wrapped_node = self.orig_new
+        wrapped_node.init_on_load(node)
+        wrapped_node
+      end
+
+
+      # Creates a new node or loads an already existing Neo4j node.
+      #
+      # You can use two callback method to initialize the node
+      # init_on_load:: this method is called when the node is loaded from the database
+      # init_on_create:: called when the node is created, will be provided with the same argument as the new method
+      #
+      #
+      # Does
+      # * sets the neo4j property '_classname' to self.class.to_s
+      # * creates a neo4j node java object (in @_java_node)
+      #
+      # If you want to provide your own initialize method you should instead implement the
+      # method init_on_create method.
+      #
+      # === Example
+      #
+      #   class MyNode
+      #     include Neo4j::NodeMixin
+      #
+      #     def init_on_create(name, age)
+      #        self[:name] = name
+      #        self[:age] = age
+      #     end
+      #   end
+      #
+      #   node = MyNode.new('jimmy', 23)
+      #
+      def new(*args)
+        node = Neo4j::Node.create
+        wrapped_node = super()
+        wrapped_node.init_on_load(node)
+        wrapped_node.init_on_create(*args)
+        wrapped_node
+      end
+
+      alias_method :create, :new
+    end
+  end
+end

data/lib/neo4j/mapping/class_methods/init_rel.rb

@@ -0,0 +1,35 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module InitRel
+      def load_wrapper(rel)
+        wrapped_rel = self.orig_new
+        wrapped_rel.init_on_load(rel)
+        wrapped_rel
+      end
+
+
+      # Creates a relationship between given nodes.
+      #
+      # You can use two callback method to initialize the relationship
+      # init_on_load:: this method is called when the relationship is loaded from the database
+      # init_on_create:: called when the relationship is created, will be provided with the same argument as the new method
+      #
+      # ==== Parameters (when creating a new relationship in db)
+      # type:: the key and value to be set
+      # from_node:: create relationship from this node
+      # to_node:: create relationship to this node
+      # props:: optional hash of properties to initialize the create relationship with
+      #
+      def new(*args)
+        type, from_node, to_node, props = args
+        rel = Neo4j::Relationship.create(type, from_node, to_node)
+        wrapped_rel = super()
+        wrapped_rel.init_on_load(rel)
+        wrapped_rel.init_on_create(*args)
+        wrapped_rel
+      end
+
+      alias_method :create, :new
+    end
+  end
+end

data/lib/neo4j/mapping/class_methods/property.rb

@@ -61,61 +61,6 @@ module Neo4j::Mapping
         _decl_props[prop_name.to_sym][:defined] == true
       end
 
-
-      def load
-        # TODO
-        node = db.graph.get_node_by_id(node_id.to_i)
-        clazz = Neo4j::Node.to_class(node[:_classname])
-        raise "Expected classname #{self} got #{clazz}" if clazz != self
-      end
-
-      def load_wrapper(node, db = Neo4j.started_db)
-        wrapped_node = self.orig_new # avo
-        #id creating a new node, only a Ruby Object
-        wrapped_node.init_on_load(node)
-        wrapped_node
-      end
-
-
-      # Creates a new node or loads an already existing Neo4j node.
-      #
-      # Does
-      # * sets the neo4j property '_classname' to self.class.to_s
-      # * creates a neo4j node java object (in @_java_node)
-      # * calls init_node if that is defined in the current class.
-      #
-      # If you want to provide your own initialize method you should instead implement the
-      # method init_node method.
-      #
-      # === Example
-      #
-      #   class MyNode
-      #     include Neo4j::NodeMixin
-      #
-      #     def init_node(name, age)
-      #        self[:name] = name
-      #        self[:age] = age
-      #     end
-      #   end
-      #
-      #   node = MyNode.new('jimmy', 23)
-      #   # notice the following is still possible:
-      #   node = MyNode :name => 'jimmy', :age => 12
-      #
-      # The init_node is only called when the node is created in the database.
-      # The initialize method is used both for to purposes:
-      # loading an already existing node from the Neo4j database and creating a new node in the database.
-      #
-      def new(*args)
-        node = Neo4j::Node.create
-        wrapped_node = super()
-        wrapped_node.init_on_load(node)
-        wrapped_node.init_on_create(*args)
-        wrapped_node
-      end
-
-      alias_method :create, :new
-
     end
   end
-end
+end

data/lib/neo4j/mapping/class_methods/rule.rb

@@ -100,7 +100,7 @@ module Neo4j::Mapping
 
         def run_rule(rule, node)
           if rule.arity != 1
-            wrapper = Neo4j::Node.load_wrapper(node)
+            wrapper = Neo4j::Node.wrapper(node)
             wrapper.instance_eval(&rule)
           else
             rule.call(node)

data/lib/neo4j/mapping/has_n.rb

@@ -6,6 +6,7 @@ module Neo4j
     #
     class HasN
       include Enumerable
+      include ToJava
 
       def initialize(node, dsl) # :nodoc:
         @node = node
@@ -64,6 +65,7 @@ module Neo4j
 
 
       # Creates a relationship instance between this and the other node.
+      # Returns the relationship object
       def new(other)
         create_rel(@node, other)
       end
@@ -79,11 +81,6 @@ module Neo4j
       #
       #   n1 << n2 << n3
       #
-      # This is the same as:
-      #
-      #   n1.add_rel(:friends, n2)
-      #   n1.add_rel(:friends, n3)
-      #
       # ==== Returns
       # self
       #
@@ -101,14 +98,16 @@ module Neo4j
           from, to = other, node
         end
 
-        rel = from.outgoing(@dsl.namespace_type) << to
-        # rel[_classname] =  @dsl.relationship_class # TODO
+        java_type = type_to_java(@dsl.namespace_type)
+        rel = from._java_node.create_relationship_to(to._java_node, java_type)
+        rel[:_classname] =  @dsl.relationship_class.to_s if @dsl.relationship_class
 
+        # TODO - not implemented yet
         # the from.neo_id is only used for cascade_delete_incoming since that node will be deleted when all the list items has been deleted.
         # if cascade_delete_outgoing all nodes will be deleted when the root node is deleted
         # if cascade_delete_incoming then the root node will be deleted when all root nodes' outgoing nodes are deleted
-        rel[@dsl.cascade_delete_prop_name] = node.neo_id if @dsl.cascade_delete?
-        rel
+        #rel[@dsl.cascade_delete_prop_name] = node.neo_id if @dsl.cascade_delete?
+        rel.wrapper
       end
 
     end

data/lib/neo4j/mapping/node_mixin.rb

@@ -26,7 +26,7 @@ module Neo4j::Mapping
     def init_on_create(*args) # :nodoc:
       self[:_classname] = self.class.to_s
       if args[0].respond_to?(:each_pair)
-         args[0].each_pair { |k, v| @_java_node.set_property(k.to_s, v) }
+        args[0].each_pair { |k, v| @_java_node.set_property(k.to_s, v) }
       end
     end
 
@@ -46,17 +46,21 @@ module Neo4j::Mapping
           alias_method :orig_new, :new
         end
       end
+
       c.extend ClassMethods::Root
       c.extend ClassMethods::Property
+      c.extend ClassMethods::InitNode
       c.extend ClassMethods::Relationship
       c.extend ClassMethods::Rule
       c.extend Neo4j::Index::ClassMethods
+
       def c.inherited(subclass)
-        subclass.indexer subclass
+        subclass.node_indexer subclass
         subclass.root_class subclass
         super
       end
-      c.indexer c
+
+      c.node_indexer c
       c.root_class c
     end
   end

data/lib/neo4j/mapping/relationship_mixin.rb

@@ -0,0 +1,117 @@
+module Neo4j::Mapping
+
+  module RelationshipMixin
+    extend Forwardable
+    include Neo4j::Index
+
+    def_delegators :@_java_rel, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :to_param, :getId,
+                   :equal?, :eql?, :==, :delete, :getStartNode, :getEndNode, :getOtherNode
+
+
+
+    # --------------------------------------------------------------------------
+    # Initialization methods
+    #
+
+
+    # Init this node with the specified java neo4j relationship.
+    #
+    def init_on_load(java_rel) # :nodoc:
+      @_java_rel = java_rel
+    end
+
+
+    # Creates a new node and initialize with given properties.
+    #
+    def init_on_create(*args) # :nodoc:
+      type, from_node, to_node, props = args
+      self[:_classname] = self.class.to_s
+      if props.respond_to?(:each_pair)
+        props.each_pair { |k, v| @_java_rel.set_property(k.to_s, v) }
+      end
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Instance Methods
+    #
+
+    # Returns the org.neo4j.graphdb.Relationship wrapped object
+    def _java_rel
+      @_java_rel
+    end
+
+    # Returns the end node of this relationship
+    def end_node
+      id = getEndNode.getId
+      Neo4j::Node.load(id)
+    end
+
+    # Returns the start node of this relationship
+    def start_node
+      id = getStartNode.getId
+      Neo4j::Node.load(id)
+    end
+
+    # Deletes this relationship
+    def del
+      delete
+    end
+
+    def exist?
+      Neo4j::Relationship.load(neo_id) != nil
+    end
+
+    # A convenience operation that, given a node that is attached to this relationship, returns the other node.
+    # For example if node is a start node, the end node will be returned, and vice versa.
+    # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels operations on node.
+    #
+    # This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
+    #
+    # ==== Example
+    # For example, to get the node "at the other end" of a relationship, use the following:
+    #   Node endNode = node.rel(:some_rel_type).other_node(node)
+    #
+    def other_node(node)
+      neo_node = node.respond_to?(:_java_node)? node._java_node : node
+      id = getOtherNode(neo_node).getId
+      Neo4j::Node.load(id)
+    end
+
+
+    # Returns the neo relationship type that this relationship is used in.
+    # (see java API org.neo4j.graphdb.Relationship#getType  and org.neo4j.graphdb.RelationshipType)
+    #
+    # ==== Returns
+    # the relationship type (of type Symbol)
+    #
+    def relationship_type
+      get_type.name.to_sym
+    end
+
+    # --------------------------------------------------------------------------
+    # Class Methods
+    #
+
+    class << self
+      def included(c) # :nodoc:
+        c.instance_eval do
+          class << self
+            alias_method :orig_new, :new
+          end
+        end
+        c.extend ClassMethods::Root
+        c.extend ClassMethods::Property
+        c.extend ClassMethods::InitRel
+        c.extend Neo4j::Index::ClassMethods
+
+        def c.inherited(subclass)
+          subclass.rel_indexer subclass
+          super
+        end
+
+        c.rel_indexer c
+      end
+    end
+  end
+end

data/lib/neo4j/node.rb

@@ -19,16 +19,21 @@ module Neo4j
       Neo4j::Node.exist?(self)
     end
 
-    # provide a hook for ruby class mapping
+    # same as _java_node
+    # Used so that we have same method for both relationship and nodes
     def wrapped_entity
       self
     end
     
     # Loads the Ruby wrapper for this node 
     # If there is no _classname property for this node then it will simply return itself.
-    # Same as Neo4j::Node.load_wrapper(node)
+    # Same as Neo4j::Node.wrapper(node)
     def wrapper
-      self.class.load_wrapper(self)
+      self.class.wrapper(self)
+    end
+
+    def _java_node
+      self
     end
 
     def class
@@ -40,10 +45,10 @@ module Neo4j
   class Node
     extend Neo4j::Index::ClassMethods
 
-    self.indexer self
+    self.node_indexer self
 
     class << self
-
+      include Neo4j::Load
 
       # Creates a new node using the default db instance when given no args
       # Same as Neo4j::Node#create
@@ -63,26 +68,13 @@ module Neo4j
       alias_method :create, :new
 
       def load(node_id, db = Neo4j.started_db)
-        load_wrapper(db.graph.get_node_by_id(node_id.to_i))
+        wrapper(db.graph.get_node_by_id(node_id.to_i))
       rescue java.lang.IllegalStateException
         nil # the node has been deleted
       rescue org.neo4j.graphdb.NotFoundException
         nil
       end
 
-      def load_wrapper(node)
-        return node unless node.property?(:_classname)
-        to_class(node[:_classname]).load_wrapper(node)
-      end
-
-      def to_class(class_name)
-        class_name.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
-      end
-
-      def exist?(node_or_node_id, db = Neo4j.started_db)
-        id = node_or_node_id.kind_of?(Fixnum) ?  node_or_node_id : node_or_node_id.id
-        load(id, db) != nil
-      end
 
     end
   end

data/lib/neo4j/node_traverser.rb

@@ -121,7 +121,7 @@ module Neo4j
     def each
       iter = iterator
       while (iter.hasNext) do
-        yield Neo4j::Node.load_wrapper(iter.next)
+        yield Neo4j::Node.wrapper(iter.next)
       end
     end
 

data/lib/neo4j/relationship.rb

@@ -9,18 +9,40 @@ module Neo4j
     end
 
     def end_node # :nodoc:
-      Neo4j::Node.load_wrapper(getEndNode)
+      getEndNode.wrapper
     end
 
     def start_node # :nodoc:
-      Neo4j::Node.load_wrapper(getStartNode)
+      getStartNode.wrapper
     end
 
     def other_node(node) # :nodoc:
-      java_node  = node.respond_to?(:_java_node)? node._java_node : node
-      other_node = getOtherNode(java_node)
-      Neo4j::Node.load_wrapper(other_node)
+      getOtherNode(node._java_node).wrapper
     end
+
+
+    # same as _java_rel
+    # Used so that we have same method for both relationship and nodes
+    def wrapped_entity
+      self
+    end
+
+    def _java_rel
+      self
+    end
+
+    # Loads the Ruby wrapper for this node
+    # If there is no _classname property for this node then it will simply return itself.
+    # Same as Neo4j::Node.load_wrapper(node)
+    def wrapper
+      self.class.wrapper(self)
+    end
+
+
+    def class
+      Neo4j::Relationship
+    end
+
   end
 
   #
@@ -57,7 +79,15 @@ module Neo4j
   # (Those mixin are actually not included in the Neo4j::Relationship but instead directly included in the java class org.neo4j.kernel.impl.core.RelationshipProxy)
   #
   class Relationship
+    extend Neo4j::Index::ClassMethods
+
+    self.rel_indexer self
+
     class << self
+      include Neo4j::Load
+      include Neo4j::ToJava
+
+
       # Returns a org.neo4j.graphdb.Relationship java object (!)
       # Will trigger a event that the relationship was created.
       #
@@ -74,11 +104,24 @@ module Neo4j
       #
       #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
       #
-      def new(type, from_node, to_node, props={})
-        rel = from_node.outgoing(type).new(to_node)
-        props.each_pair {|k,v| rel[k] = v}
+      def new(type, from_node, to_node, props=nil)
+        java_type = type_to_java(type)
+        rel = from_node._java_node.create_relationship_to(to_node._java_node, java_type)
+        props.each_pair {|k,v| rel[k] = v} if props
         rel
       end
+
+      # create is the same as new
+      alias_method :create, :new
+
+      def load(rel_id, db = Neo4j.started_db)
+        wrapper(db.graph.get_relationship_by_id(rel_id.to_i))
+      rescue java.lang.IllegalStateException
+        nil # the node has been deleted
+      rescue org.neo4j.graphdb.NotFoundException
+        nil
+      end
+
     end
 
   end

data/lib/neo4j/relationship_mixin.rb

@@ -0,0 +1,4 @@
+module Neo4j
+  # make an alias so that we don't have to write the long name Neo4j::Mapping::Relationship
+  RelationshipMixin = Neo4j::Mapping::RelationshipMixin
+end

data/lib/neo4j/relationship_traverser.rb

@@ -18,7 +18,7 @@ module Neo4j
     def each
       iter = iterator
       while (iter.hasNext) do
-        yield iter.next
+        yield iter.next.wrapper
       end
     end
 

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.8"
+  VERSION = "1.0.0.beta.9"
 end

data/lib/neo4j.rb

@@ -20,10 +20,13 @@ require 'neo4j/node_traverser'
 require 'neo4j/property'
 require 'neo4j/transaction'
 require 'neo4j/node_relationship'
+require 'neo4j/load'
 require 'neo4j/relationship'
 require 'neo4j/node'
 require 'neo4j/config'
 require 'neo4j/neo4j'
+require 'neo4j/mapping/class_methods/init_node'
+require 'neo4j/mapping/class_methods/init_rel'
 require 'neo4j/mapping/class_methods/root'
 require 'neo4j/mapping/class_methods/property'
 require 'neo4j/mapping/class_methods/index'
@@ -31,7 +34,9 @@ require 'neo4j/mapping/class_methods/relationship'
 require 'neo4j/mapping/decl_relationship_dsl'
 require 'neo4j/mapping/has_n'
 require 'neo4j/mapping/node_mixin'
+require 'neo4j/mapping/relationship_mixin'
 require 'neo4j/node_mixin'
+require 'neo4j/relationship_mixin'
 require 'neo4j/mapping/class_methods/rule'
 
 # rails

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 8
-  version: 1.0.0.beta.8
+    - 9
+  version: 1.0.0.beta.9
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-04 00:00:00 +02:00
+date: 2010-10-05 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -166,6 +166,8 @@ files:
   - lib/neo4j/node.rb
   - lib/neo4j/node_mixin.rb
   - lib/neo4j/property.rb
+  - lib/neo4j/relationship_mixin.rb
+  - lib/neo4j/load.rb
   - lib/neo4j/database.rb
   - lib/neo4j/index.rb
   - lib/neo4j/version.rb
@@ -186,10 +188,13 @@ files:
   - lib/neo4j/mapping/decl_relationship_dsl.rb
   - lib/neo4j/mapping/node_mixin.rb
   - lib/neo4j/mapping/has_n.rb
+  - lib/neo4j/mapping/relationship_mixin.rb
   - lib/neo4j/mapping/class_methods/rule.rb
+  - lib/neo4j/mapping/class_methods/init_node.rb
   - lib/neo4j/mapping/class_methods/property.rb
   - lib/neo4j/mapping/class_methods/index.rb
   - lib/neo4j/mapping/class_methods/root.rb
+  - lib/neo4j/mapping/class_methods/init_rel.rb
   - lib/neo4j/mapping/class_methods/relationship.rb
   - README.rdoc
   - CHANGELOG