neo4j 1.0.0.beta.11 → 1.0.0.beta.12

data/lib/neo4j.rb

@@ -50,6 +50,8 @@ require 'neo4j/rails/model'
 require 'neo4j/rails/value'
 require 'neo4j/rails/lucene_connection_closer'
 
+require 'neo4j/model'
+
 
 
 # hmm, looks like Enumerator have been moved in some ruby versions

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

@@ -2,6 +2,7 @@ module Neo4j::Mapping
   module ClassMethods
 
     module Relationship
+      include Neo4j::ToJava
 
       # Specifies a relationship between two node classes.
       # Generates assignment and accessor methods for the given relationship.
@@ -24,9 +25,9 @@ module Neo4j::Mapping
       def has_n(rel_type, params = {})
         clazz = self
         module_eval(%Q{
-                def #{rel_type}(&block)
+                def #{rel_type}
                     dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    Neo4j::Mapping::HasN.new(self, dsl, &block)
+                    Neo4j::Mapping::HasN.new(self, dsl)
                 end}, __FILE__, __LINE__)
 
         module_eval(%Q{
@@ -61,28 +62,25 @@ module Neo4j::Mapping
       #
       def has_one(rel_type, params = {})
         clazz = self
-
-
         module_eval(%Q{def #{rel_type}=(value)
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    r = Neo4j::Mapping::HasN.new(self, dsl)
-                    r.rels.each {|n| n.del} # delete previous relationships, only one can exist
-                    r << value
-                    r
-                end}, __FILE__, __LINE__)
+                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
+                  rel = dsl.single_relationship(self)
+                  rel.del unless rel.nil?
+                  dsl.create_relationship_to(self, value)
+              end}, __FILE__, __LINE__)
 
         module_eval(%Q{def #{rel_type}
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    r = Neo4j::Mapping::HasN.new(self, dsl)
-                    [*r][0]
-                end}, __FILE__, __LINE__)
+                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
+                  dsl.single_relationship(self)
+              end}, __FILE__, __LINE__)
 
+        # TODO
         module_eval(%Q{
-                def #{rel_type}_rel
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    r = Neo4j::Mapping::HasN.new(self, dsl).rels
-                    [*r][0]
-      end}, __FILE__, __LINE__)
+              def #{rel_type}_rel
+                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
+                  r = Neo4j::Mapping::HasN.new(self, dsl).rels
+                  [*r][0]
+    end}, __FILE__, __LINE__)
 
         _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, params)
       end

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -31,6 +31,7 @@ module Neo4j::Mapping
   # <b>File#folder</b> ::       for accessing nodes from relationship 'files' from the outgoing Folder node
   #
   class DeclRelationshipDsl
+    include Neo4j::ToJava
 
     attr_reader :to_type, :to_class, :cascade_delete_prop_name, :counter, :rel_id, :direction
     CASCADE_DELETE_PROP_NAMES = {:outgoing => :_cascade_delete_outgoing, :incoming => :_cascade_delete_incoming}
@@ -75,6 +76,41 @@ module Neo4j::Mapping
       @to_class.nil? ? @to_type.to_s : "#{@to_class.to_s}##{@to_type.to_s}"
     end
 
+    def each_node(node, direction, &block)
+      type = type_to_java(namespace_type)
+      dir  = dir_to_java(direction)
+      node._java_node.getRelationships(type, dir).each do |rel|
+        other = rel.getOtherNode(node).wrapper
+        block.call other
+      end
+    end
+
+    def single_relationship(node)
+      type = type_to_java(namespace_type)
+      dir  = dir_to_java(@direction)
+      rel = node._java_node.getSingleRelationship(type, dir)
+      rel.nil? ? nil : rel.end_node.wrapper
+    end
+
+    def create_relationship_to(node, other)
+      # If the are creating an incoming relationship we need to swap incoming and outgoing nodes
+      if @direction == :outgoing
+        from, to = node, other
+      else
+        from, to = other, node
+      end
+
+      java_type = type_to_java(namespace_type)
+      rel = from._java_node.create_relationship_to(to._java_node, java_type)
+      rel[:_classname] =  relationship_class.to_s if 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.wrapper
+    end
 
     # Specifies an outgoing relationship.
     # The name of the outgoing class will be used as a prefix for the relationship used.

data/lib/neo4j/mapping/has_n.rb

@@ -11,7 +11,7 @@ module Neo4j
       def initialize(node, dsl) # :nodoc:
         @node = node
         @direction = dsl.direction
-        # returns the other DSL if it exists otherwise use this DSL for specifing incoming relationships
+        # returns the other DSL if it exists otherwise use this DSL for specifying incoming relationships
         if @direction == :outgoing
           @dsl = dsl
         else
@@ -20,8 +20,10 @@ module Neo4j
           @dsl = clazz._decl_rels[dsl.to_type]
           raise "Unspecified outgoing relationship '#{dsl.to_type}' for incoming relationship '#{dsl.rel_id}' on class #{clazz}" if @dsl.nil?
         end
+      end
 
-        @traverser = Neo4j::NodeTraverser.new(node._java_node, @dsl.namespace_type, @direction)
+      def to_s
+        "HasN [#@direction, #{@node.neo_id} #{@dsl.namespace_type}]"
       end
 
       def size
@@ -41,6 +43,12 @@ module Neo4j
         super
       end
 
+      # Required by the Enumerable mixin.
+      def each(&block)
+        @dsl.each_node(@node, @direction, &block)
+      end
+
+
       # Returns the relationships instead of the nodes.
       #
       # ==== Example
@@ -51,39 +59,16 @@ module Neo4j
         Neo4j::RelationshipTraverser.new(@node._java_node, [@dsl.namespace_type], @direction)
       end
 
-      # Sets the depth of the traversal.
-      # Default is 1 if not specified.
-      #
-      # ==== Example
-      #  morpheus.friends.depth(:all).each { ... }
-      #  morpheus.friends.depth(3).each { ... }
-      #  
-      # ==== Arguments
-      # d:: the depth or :all if traversing to the end of the network (symbol or fixnum)
-      # ==== Return
-      # self
-      # 
-      def depth(d)
-        @traverser.depth(d)
-        self
-      end
-
-      # Required by the Enumerable mixin.
-      def each(&block)
-        @traverser.each(&block)
-      end
-
-
       # Returns true if there are no node in this type of relationship
       def empty?
-        @traverser.empty?
+        first != nil
       end
 
 
       # Creates a relationship instance between this and the other node.
       # Returns the relationship object
       def new(other)
-        create_rel(@node, other)
+        @dsl.create_relationship_to(@node, other)
       end
 
 
@@ -101,31 +86,9 @@ module Neo4j
       # self
       #
       def <<(other)
-        create_rel(@node, other)
+        @dsl.create_relationship_to(@node, other)
         self
       end
-
-
-      def create_rel(node, other) # :nodoc:
-        # If the are creating an incoming relationship we need to swap incoming and outgoing nodes
-        if @direction == :outgoing
-          from, to = node, other
-        else
-          from, to = other, node
-        end
-
-        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.wrapper
-      end
-
     end
 
   end

data/lib/neo4j/mapping/node_mixin.rb

@@ -6,7 +6,7 @@ module Neo4j::Mapping
 
     def_delegators :@_java_node, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
                    :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both,
-                   :equal?, :eql?, :==, :exist?, :getRelationships
+                   :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship
 
 
     # --------------------------------------------------------------------------
@@ -40,6 +40,10 @@ module Neo4j::Mapping
     end
 
 
+    def wrapper
+      self
+    end
+
     def self.included(c) # :nodoc:
       c.instance_eval do
         class << self

data/lib/neo4j/model.rb

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

data/lib/neo4j/node_traverser.rb

@@ -132,10 +132,7 @@ module Neo4j
     end
 
     def each
-      iter = iterator
-      while (iter.hasNext) do
-        yield iter.next.wrapper
-      end
+      iterator.each {|i| yield i.wrapper}
     end
 
     def iterator
@@ -147,7 +144,7 @@ module Neo4j
         end
       end
       @td = @td.prune(org.neo4j.kernel.Traversal.pruneAfterDepth( @depth ) ) unless @depth == :all
-      @td.traverse(@from).nodes.iterator
+      @td.traverse(@from).nodes
     end
   end
 

data/lib/neo4j/rails/model.rb

@@ -1,358 +1,343 @@
-class Neo4j::Model
-  include Neo4j::NodeMixin
-  include ActiveModel::Validations
-  include ActiveModel::Dirty
-  include ActiveModel::MassAssignmentSecurity
+module Neo4j
+  module Rails
+    class Model
+      include Neo4j::NodeMixin
+      include ActiveModel::Validations
+      include ActiveModel::Dirty
+      include ActiveModel::MassAssignmentSecurity
 
-  extend ActiveModel::Naming
-  extend ActiveModel::Callbacks
-  extend Neo4j::Validations::ClassMethods
-  extend Neo4j::TxMethods
+      extend ActiveModel::Naming
+      extend ActiveModel::Callbacks
+      extend Neo4j::Validations::ClassMethods
+      extend TxMethods
+#      extend ClassMethods::Relationship
 
-  define_model_callbacks :create, :save, :update, :destroy
+      define_model_callbacks :create, :save, :update, :destroy
 
 
-  UniquenessValidator = Neo4j::Validations::UniquenessValidator
+      UniquenessValidator = Neo4j::Validations::UniquenessValidator
 
-  class RecordInvalidError < RuntimeError
-    attr_reader :record
+      class RecordInvalidError < RuntimeError
+        attr_reader :record
 
-    def initialize(record)
-      @record = record
-      super(@record.errors.full_messages.join(", "))
-    end
-  end
+        def initialize(record)
+          @record = record
+          super(@record.errors.full_messages.join(", "))
+        end
+      end
 
-  # --------------------------------------
-  # Initialize
-  # --------------------------------------
+      # --------------------------------------
+      # Initialize
+      # --------------------------------------
 
-  def initialize(*)
-  end
+      def initialize(*)
+      end
 
-  def init_on_create(*args) # :nodoc:
-    super()
-    self.attributes=args[0] if args[0].respond_to?(:each_pair)
-    @_created_record = true
-  end
+      def init_on_create(*args) # :nodoc:
+        super()
+        self.attributes=args[0] if args[0].respond_to?(:each_pair)
+        @_created_record = true
+      end
 
-  # --------------------------------------
-  # Identity
-  # --------------------------------------
+      # --------------------------------------
+      # Identity
+      # --------------------------------------
 
-  def id
-    neo_id.nil? ? nil : neo_id.to_s
-  end
+      def id
+        neo_id.nil? ? nil : neo_id.to_s
+      end
 
-  def to_param
-    persisted? ? neo_id.to_s : nil
-  end
+      def to_param
+        persisted? ? neo_id.to_s : nil
+      end
 
-  # Returns an Enumerable of all (primary) key attributes
-  # or nil if model.persisted? is false
-  def to_key
-    persisted? ? [:id] : nil
-  end
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if model.persisted? is false
+      def to_key
+        persisted? ? [:id] : nil
+      end
 
 
-  # enables ActiveModel::Dirty and Validation
-  def method_missing(method_id, *args, &block)
-    if !self.class.attribute_methods_generated?
-      self.class.define_attribute_methods(self.class._decl_props.keys)
-      # try again
-      send(method_id, *args, &block)
-    end
-  end
-
-  # redefine this methods so that ActiveModel::Dirty will work
-  def []=(key, new_value)
-    key = key.to_s
-    unless key[0] == ?_
-      old_value = self.send(:[], key)
-      attribute_will_change!(key) unless old_value == new_value
-    end
-    Neo4j::Rails::Transaction.running? ? super : Neo4j::Rails::Transaction.run { super }
-  end
+      # enables ActiveModel::Dirty and Validation
+      def method_missing(method_id, *args, &block)
+        if !self.class.attribute_methods_generated?
+          self.class.define_attribute_methods(self.class._decl_props.keys)
+          # try again
+          send(method_id, *args, &block)
+        end
+      end
 
-  def attribute_will_change!(attr)
-    begin
-      value = __send__(:[], attr)
-      value = value.duplicable? ? value.clone : value
-    rescue TypeError, NoMethodError
-    end
-    changed_attributes[attr] = value
-  end
+      # redefine this methods so that ActiveModel::Dirty will work
+      def []=(key, new_value)
+        key = key.to_s
+        unless key[0] == ?_
+          old_value = self.send(:[], key)
+          attribute_will_change!(key) unless old_value == new_value
+        end
+        Neo4j::Rails::Transaction.running? ? super : Neo4j::Rails::Transaction.run { super }
+      end
 
+      def attribute_will_change!(attr)
+        begin
+          value = __send__(:[], attr)
+          value = value.duplicable? ? value.clone : value
+        rescue TypeError, NoMethodError
+        end
+        changed_attributes[attr] = value
+      end
 
-  def read_attribute_for_validation(key)
-    respond_to?(key) ? send(key) : self[key]
-  end
 
-  def attributes=(values)
-    sanitize_for_mass_assignment(values).each do |k, v|
-      if respond_to?("#{k}=")
-        send("#{k}=", v)
-      else
-        self[k] = v
+      def read_attribute_for_validation(key)
+        respond_to?(key) ? send(key) : self[key]
       end
-    end
-  end
 
+      def attributes=(values)
+        sanitize_for_mass_assignment(values).each do |k, v|
+          if respond_to?("#{k}=")
+            send("#{k}=", v)
+          else
+            self[k] = v
+          end
+        end
+      end
 
-  # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
-  # If saving fails because the resource is invalid then false will be returned.
-  def update_attributes(attributes)
-    self.attributes=attributes
-    save
-  end
 
-  def update_attributes!(attributes)
-    self.attributes=attributes
-    save!
-  end
+      # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
+      # If saving fails because the resource is invalid then false will be returned.
+      def update_attributes(attributes)
+        self.attributes=attributes
+        save
+      end
 
-  def update_nested_attributes(rel_type, clazz, has_one, attr, options)
-    allow_destroy,reject_if = [options[:allow_destroy], options[:reject_if]] if options
-
-    if new?
-      # We are updating a node that was created with the 'new' method.
-      # The relationship will only be kept in the Value object.
-      outgoing(rel_type)<<clazz.new(attr) unless reject_if?(reject_if,attr)
-    else
-      # We have a node that was created with the #create method - has real Neo4j relationships
-      # does it exist ?
-      found = if has_one
-                # id == nil that means we have a has_one relationship
-                outgoing(rel_type).first
-              else
-                # do we have an ID ?
-                id = attr[:id]
-                # this is a has_n relationship, find which one we want to update
-                id && outgoing(rel_type).find { |n| n.id == id }
-              end
+      def update_attributes!(attributes)
+        self.attributes=attributes
+        save!
+      end
 
-      # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
-      destroy = attr[:_destroy] && attr[:_destroy] != '0'
+      def update_nested_attributes(rel_type, clazz, has_one, attr, options)
+        allow_destroy, reject_if = [options[:allow_destroy], options[:reject_if]] if options
 
-      if found
-        if destroy
-          found.destroy if allow_destroy
+        if new?
+          # We are updating a node that was created with the 'new' method.
+          # The relationship will only be kept in the Value object.
+          outgoing(rel_type)<<clazz.new(attr) unless reject_if?(reject_if, attr)
         else
-          found.update_attributes_in_tx(attr) # it already exist, so update that one
+          # We have a node that was created with the #create method - has real Neo4j relationships
+          # does it exist ?
+          found = if has_one
+            # id == nil that means we have a has_one relationship
+                    outgoing(rel_type).first
+                  else
+                    # do we have an ID ?
+                    id = attr[:id]
+                    # this is a has_n relationship, find which one we want to update
+                    id && outgoing(rel_type).find { |n| n.id == id }
+                  end
+
+          # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
+          destroy = attr[:_destroy] && attr[:_destroy] != '0'
+
+          puts "FOUND #{found}"
+          if found
+            if destroy
+              found.destroy if allow_destroy
+            else
+              found.update_attributes_in_tx(attr) # it already exist, so update that one
+            end
+          elsif !destroy && !reject_if?(reject_if, attr)
+            new_node = clazz.new(attr)
+            saved = new_node.save
+            outgoing(rel_type) << new_node if saved
+          end
         end
-      elsif !destroy && !reject_if?(reject_if,attr)
-        new_node = clazz.new(attr)
-        saved = new_node.save
-        outgoing(rel_type) << new_node if saved
       end
-    end
-  end
-
-  def reject_if?(proc_or_symbol, attr)
-    return false if proc_or_symbol.nil?
-    if proc_or_symbol.is_a?(Symbol)
-      meth = method(proc_or_symbol)
-      meth.arity == 0 ? meth.call : meth.call(attr)
-    else
-      proc_or_symbol.call(attr)
-    end
-  end
-
-  def delete
-    super
-    @_deleted = true
-    @_persisted = false
-  end
 
-  def save
-    valid = valid?
-    if valid
-      # if we are trying to save a value then we should create a real node
-      valid = _run_save_callbacks { create_or_update_node }
-      @_created_record = false
-      true
-    else
-      # if not valid we should rollback the transaction so that the changes does not take place.
-      # no point failing the transaction if we have created a model with 'new'
-      Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running? && !_java_node.kind_of?(Neo4j::Value)
-      false
-    end
-    valid
-  end
+      def reject_if?(proc_or_symbol, attr)
+        return false if proc_or_symbol.nil?
+        if proc_or_symbol.is_a?(Symbol)
+          meth = method(proc_or_symbol)
+          meth.arity == 0 ? meth.call : meth.call(attr)
+        else
+          proc_or_symbol.call(attr)
+        end
+      end
 
-  def create_or_update_node
-    valid = true
-    if _java_node.kind_of?(Neo4j::Value)
-      node = Neo4j::Node.new(props)
-      valid = _java_node.save_nested(node)
-      init_on_load(node)
-      init_on_create
-    end
+      def delete
+        super
+        @_deleted = true
+        @_persisted = false
+      end
 
-    if  new_record?
-      _run_create_callbacks { clear_changes }
-    else
-      _run_update_callbacks { clear_changes }
-    end
-    valid
-  end
+      def save
+        valid = valid?
+        if valid
+          # if we are trying to save a value then we should create a real node
+          valid = _run_save_callbacks { create_or_update_node }
+          @_created_record = false
+          true
+        else
+          # if not valid we should rollback the transaction so that the changes does not take place.
+          # no point failing the transaction if we have created a model with 'new'
+          Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running? && !_java_node.kind_of?(Neo4j::Rails::Value)
+          false
+        end
+        valid
+      end
 
-  def clear_changes
-    @previously_changed = changes
-    @changed_attributes.clear
-  end
+      def create_or_update_node
+        valid = true
+        if _java_node.kind_of?(Neo4j::Rails::Value)
+          node = Neo4j::Node.new(props)
+          valid = _java_node.save_nested(node)
+          init_on_load(node)
+          init_on_create
+        end
 
-  def save!
-    raise RecordInvalidError.new(self) unless save
-  end
+        if  new_record?
+          _run_create_callbacks { clear_changes }
+        else
+          _run_update_callbacks { clear_changes }
+        end
+        valid
+      end
 
-  # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
-  def persisted?
-    !new_record? && !destroyed?
-  end
+      def clear_changes
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
 
-  def to_model
-    self
-  end
+      def save!
+        raise RecordInvalidError.new(self) unless save
+      end
 
-  # Returns true if this object hasn’t been saved yet — that is, a record for the object doesn’t exist yet; otherwise, returns false.
-  def new_record?()
-    # it is new if the model has been created with either the new or create method
-    new? || @_created_record == true
-  end
+      # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
+      def persisted?
+        !new_record? && !destroyed?
+      end
 
-  def new?
-    _java_node.kind_of?(Neo4j::Value)
-  end
+      def to_model
+        self
+      end
 
-  def del
-    @_deleted = true
-    super
-  end
+      # Returns true if this object hasn’t been saved yet — that is, a record for the object doesn’t exist yet; otherwise, returns false.
+      def new_record?()
+        # it is new if the model has been created with either the new or create method
+        new? || @_created_record == true
+      end
 
-  def destroy
-    _run_update_callbacks { del }
-  end
+      def new?
+        _java_node.kind_of?(Neo4j::Rails::Value)
+      end
 
-  def destroyed?()
-    @_deleted
-  end
+      def del
+        @_deleted = true
+        super
+      end
 
-  tx_methods :destroy, :create_or_update_node, :update_attributes, :update_attributes!
+      def destroy
+        _run_update_callbacks { del }
+      end
 
-  # --------------------------------------
-  # Class Methods
-  # --------------------------------------
+      def destroyed?()
+        @_deleted
+      end
 
-  class << self
-    extend Neo4j::TxMethods
+      tx_methods :destroy, :create_or_update_node, :update_attributes, :update_attributes!
 
-    # returns a value object instead of creating a new node
-    def new(*args)
-      value = Neo4j::Value.new
-      wrapped = self.orig_new
-      wrapped.init_on_load(value)
-      wrapped.attributes=args[0] if args[0].respond_to?(:each_pair)
+      # --------------------------------------
+      # Class Methods
+      # --------------------------------------
 
-      wrapped.class._decl_rels.each_pair do |field, dsl|
+      class << self
+        extend TxMethods
 
-        meta = class << wrapped;
-          self;
+        # returns a value object instead of creating a new node
+        def new(*args)
+          wrapped = self.orig_new
+          value = Neo4j::Rails::Value.new(wrapped)
+          wrapped.init_on_load(value)
+          wrapped.attributes=args[0] if args[0].respond_to?(:each_pair)
+          wrapped
         end
 
-        wrapped.class._decl_rels.each_pair do |field, dsl|
-          meta.send(:define_method, field) do
-            if new?
-              value.outgoing(dsl.namespace_type)
-            else
-              self.outgoing(dsl.namespace_type)
-            end
-          end if dsl.direction == :outgoing
-
-          meta.send(:define_method, field) do
-            raise "NOT IMPLEMENTED #{field} (incoming relationship) FOR #new method, please create a new model with the create method instead"
-          end if dsl.direction == :incoming
+        # Handle Model.find(params[:id])
+        def find(*args)
+          if args.length == 1 && String === args[0] && args[0].to_i != 0
+            load(*args)
+          else
+            hits = super
+            # We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
+            Thread.current[:neo4j_lucene_connection] ||= []
+            Thread.current[:neo4j_lucene_connection] << hits
+            hits
+          end
         end
-      end
-
-      wrapped
-    end
 
-    # Handle Model.find(params[:id])
-    def find(*args)
-      if args.length == 1 && String === args[0] && args[0].to_i != 0
-        load(*args)
-      else
-        hits = super
-        # We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
-        Thread.current[:neo4j_lucene_connection] ||= []
-        Thread.current[:neo4j_lucene_connection] << hits
-        hits
-      end
-    end
-
-    def load(*ids)
-      result = ids.map { |id| Neo4j::Node.load(id) }
-      if ids.length == 1
-        result.first
-      else
-        result
-      end
-    end
+        def load(*ids)
+          result = ids.map { |id| Neo4j::Node.load(id) }
+          if ids.length == 1
+            result.first
+          else
+            result
+          end
+        end
 
 
-    alias_method :_orig_create, :create
+        alias_method :_orig_create, :create
 
-    def create(*)
-      model = super
-      model.save
-      model
-    end
+        def create(*)
+          model = super
+          model.save
+          model
+        end
 
-    def create!(*args)
-      model = _orig_create(*args)
-      model.save!
-      model
-    end
+        def create!(*args)
+          model = _orig_create(*args)
+          model.save!
+          model
+        end
 
-    tx_methods :create, :create!
+        tx_methods :create, :create!
 
 
-    def transaction(&block)
-      Neo4j::Rails::Transaction.run &block
-    end
+        def transaction(&block)
+          Neo4j::Rails::Transaction.run &block
+        end
 
-    def accepts_nested_attributes_for(*attr_names)
-      options = attr_names.pop if attr_names[-1].is_a?(Hash)
+        def accepts_nested_attributes_for(*attr_names)
+          options = attr_names.pop if attr_names[-1].is_a?(Hash)
 
-      attr_names.each do |association_name|
-        rel = self._decl_rels[association_name.to_sym]
-        raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
-        to_class = rel.to_class
-        raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless to_class
-        type = rel.namespace_type
-        has_one = rel.has_one?
+          attr_names.each do |association_name|
+            rel = self._decl_rels[association_name.to_sym]
+            raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
+            to_class = rel.to_class
+            raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless to_class
+            type = rel.namespace_type
+            has_one = rel.has_one?
 
-        send(:define_method, "#{association_name}_attributes=") do |attributes|
-          if has_one
-            update_nested_attributes(type, to_class, true, attributes, options)
-          else
-            if attributes.is_a?(Array)
-              attributes.each do |attr|
-                update_nested_attributes(type, to_class, false, attr, options)
-              end
-            else
-              attributes.each_value do |attr|
-                update_nested_attributes(type, to_class, false, attr, options)
+            send(:define_method, "#{association_name}_attributes=") do |attributes|
+              if has_one
+                update_nested_attributes(type, to_class, true, attributes, options)
+              else
+                if attributes.is_a?(Array)
+                  attributes.each do |attr|
+                    update_nested_attributes(type, to_class, false, attr, options)
+                  end
+                else
+                  attributes.each_value do |attr|
+                    update_nested_attributes(type, to_class, false, attr, options)
+                  end
+                end
               end
             end
+            tx_methods("#{association_name}_attributes=")
           end
         end
-        tx_methods("#{association_name}_attributes=")
+
       end
+
     end
 
   end
-
 end
 

data/lib/neo4j/rails/tx_methods.rb

@@ -1,11 +1,15 @@
-module Neo4j::TxMethods
-  def tx_methods(*methods)
-    methods.each do |method|
-      tx_method = "#{method}_in_tx"
-      send(:alias_method, tx_method, method)
-      send(:define_method, method) do |*args|
-        Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
+module Neo4j
+  module Rails
+    module TxMethods
+      def tx_methods(*methods)
+        methods.each do |method|
+          tx_method = "#{method}_in_tx"
+          send(:alias_method, tx_method, method)
+          send(:define_method, method) do |*args|
+            Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
+          end
+        end
       end
     end
   end
-end
+end

data/lib/neo4j/rails/value.rb

@@ -1,16 +1,13 @@
-module Neo4j
+module Neo4j::Rails
 
   class Value
     include Neo4j::Property
     include org.neo4j.graphdb.Node
 
-    def initialize(*args)
-      # the first argument can be an hash of properties to set
+    def initialize(wrapper)
+      @wrapper = wrapper
       @props = {}
-      if args[0].respond_to?(:each_pair)
-        args[0].each_pair { |k, v| set_property(k.to_s, v) }
-      end
-      @rels = {}  # a hash of all relationship with key type
+      @outgoing_rels = {}  # a hash of all relationship with key type
     end
 
     # override Neo4j::Property#props
@@ -22,6 +19,23 @@ module Neo4j
       nil
     end
 
+
+    def create_relationship_to(other_java_node, java_type)
+      outgoing(java_type.name).new(other_java_node)
+    end
+
+    def getSingleRelationship(type, dir)
+      # TODO incoming not implemented, needed ?
+      @outgoing_rels[type.name] && @outgoing_rels[type.name].rels.first
+    end
+
+    def getRelationships(*args)
+      type = args[0].name
+      outgoing = @outgoing_rels[type]
+      return [] unless outgoing
+      outgoing.rels
+    end
+
     # Pretend this object is a Java Node
     def has_property?(key)
       !@props[key].nil?
@@ -39,16 +53,22 @@ module Neo4j
       @props.delete(key)
     end
 
+    def wrapper
+      @wrapper
+    end
+
     def outgoing(type)
-      @rels[type.to_sym] ||= OutgoingRels.new
+      @outgoing_rels[type.to_s] ||= OutgoingRels.new(self)
     end
 
     def save_nested(root_node)
       valid = true
-      @rels.each_pair do |type, rel|
+      @outgoing_rels.each_pair do |type, rel|
         rel.each do |new_node|
-          if new_node.save
-            root_node.outgoing(type) << new_node
+          wrapper = new_node.respond_to?(:wrapper) ? new_node.wrapper : new_node
+          if wrapper.save
+            puts "NEW RELATIONSHIP OF TYPE #{type} from #{root_node} to #{new_node}"
+            root_node.outgoing(type) << wrapper
           else
             valid = false
           end
@@ -57,22 +77,55 @@ module Neo4j
       valid
     end
 
+    class Relationship
+      include org.neo4j.graphdb.Relationship
+      attr_reader :end_node, :start_node
+
+      def initialize(from, to)
+        @end_node = to
+        @start_node = from
+      end
+
+      def wrapper
+        self
+      end
+
+      def getOtherNode(other)
+        other == @end_node ? @start_node : @end_node
+      end
+    end
+
+
     class OutgoingRels
       include Enumerable
-      def initialize
-        @nodes = []
+      attr_reader :rels
+
+      def initialize(start_node)
+        @rels = []
+        @start_node = start_node
       end
 
       def <<(other)
-        @nodes << other
+        new(other)
+        self
+      end
+
+      def new(other)
+        new_rel = Relationship.new(@start_node, other)
+        @rels << new_rel
+        new_rel
       end
 
       def each
-        @nodes.each {|n| yield n}
+        @rels.each {|n| yield n.end_node}
+      end
+
+      def clear
+        @rels.clear
       end
 
       def empty?
-        @nodes.empty?
+        @rels.empty?
       end
 
       def is_a?(type)

data/lib/neo4j/relationship_traverser.rb

@@ -16,10 +16,7 @@ module Neo4j
     end
 
     def each
-      iter = iterator
-      while (iter.hasNext) do
-        yield iter.next.wrapper
-      end
+      iterator.each {|i| yield i.wrapper}
     end
 
     def iterator

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.11"
+  VERSION = "1.0.0.beta.12"
 end

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 11
-  version: 1.0.0.beta.11
+    - 12
+  version: 1.0.0.beta.12
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-08 00:00:00 +02:00
+date: 2010-10-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -102,6 +102,7 @@ extra_rdoc_files:
 files: 
   - lib/neo4j.rb
   - lib/neo4j/event_handler.rb
+  - lib/neo4j/model.rb
   - lib/neo4j/node_traverser.rb
   - lib/neo4j/relationship_traverser.rb
   - lib/neo4j/config.rb