neo4j 1.0.0.beta.15 → 1.0.0.beta.16

data/lib/neo4j/database.rb

@@ -18,6 +18,12 @@ module Neo4j
 
     def shutdown
       if @running
+        # since we might keep a reference to indexes we must clear them so
+        # that we can start neo4j with a fresh new lucene indexes
+        Neo4j::Transaction.run do
+          Neo4j::Index::IndexerRegistry.clear_all_indexes
+        end
+
         @graph.unregister_transaction_event_handler(@event_handler)
         @event_handler.neo4j_shutdown(self)
         @graph.shutdown

data/lib/neo4j/event_handler.rb

@@ -54,7 +54,7 @@ module Neo4j
 
     def print
       puts "Listeners #{@listeners.size}"
-      @listeners.each_key {|li| puts "  Listener '#{li}'"}
+      @listeners.each {|li| puts "  Listener '#{li}'"}
     end
 
     def neo4j_started(db)

data/lib/neo4j/index/index_registry.rb

@@ -9,8 +9,9 @@ module Neo4j
 
         def create_for(this_clazz, using_other_clazz, type)
           @@indexers ||= {}
-          @@indexers[this_clazz.to_s] = @@indexers[using_other_clazz.to_s] || Indexer.new(this_clazz, type)
-          @@indexers[this_clazz.to_s]
+	  index = Indexer.new(this_clazz, type)
+	  index.inherit_fields_from(@@indexers[using_other_clazz.to_s])
+          @@indexers[this_clazz.to_s] = index
         end
 
         def find_by_class(classname)

data/lib/neo4j/index/indexer.rb

@@ -1,18 +1,29 @@
 module Neo4j
   module Index
     class Indexer #:nodoc:
-      attr_reader :indexer_for
+      attr_reader :indexer_for, :field_types, :via_relationships
 
       def initialize(clazz, type)
         # part of the unique name of the index
-        @indexer_for = clazz
+        @indexer_for       = clazz
 
         # do we want to index nodes or relationships ?
-        @type = type
+        @type              = type
 
-        @indexes = {} # key = type, value = java neo4j index
-        @field_types = {} # key = field, value = type (e.g. :exact or :fulltext)
+        @indexes           = {} # key = type, value = java neo4j index
+        @field_types       = {} # key = field, value = type (e.g. :exact or :fulltext)
         @via_relationships = {} # key = field, value = relationship
+
+        # to enable subclass indexing to work properly, store a list of parent indexers and
+        # whenever an operation is performed on this one, perform it on all
+        @parent_indexers   = []
+      end
+
+      def inherit_fields_from(parent_index)
+        return unless parent_index
+        @field_types.reverse_merge!(parent_index.field_types) if parent_index.respond_to?(:field_types)
+        @via_relationships.reverse_merge!(parent_index.via_relationships) if parent_index.respond_to?(:via_relationships)
+        @parent_indexers << parent_index
       end
 
       def to_s
@@ -87,12 +98,15 @@ module Neo4j
           dsl = @via_relationships[field]
           to_class = dsl.to_class
 
-          dsl.all_relationships(node).each do |rel|
+          dsl._all_relationships(node).each do |rel|
             other = rel._start_node
-            to_class._indexer.update_index_on(other, field, old_val, new_val)
+            to_class._indexer.update_single_index_on(other, field, old_val, new_val)
           end
         end
+        update_single_index_on(node, field, old_val, new_val)
+      end
 
+      def update_single_index_on(node, field, old_val, new_val)
         if @field_types.include?(field)
           rm_index(node, field, old_val) if old_val
           add_index(node, field, new_val) if new_val
@@ -113,11 +127,15 @@ module Neo4j
       end
 
       def add_index(entity, field, value)
+       	return false unless @field_types.has_key?(field)
         index_for_field(field.to_s).add(entity, field, value)
+      	@parent_indexers.each { |i| i.add_index(entity, field, value) }
       end
 
       def rm_index(entity, field, value)
+        return false unless @field_types.has_key?(field)
         index_for_field(field).remove(entity, field, value)
+        @parent_indexers.each { |i| i.rm_index(entity, field, value) }
       end
 
       def find(query, params = {})

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

@@ -33,10 +33,10 @@ module Neo4j::Mapping
         module_eval(%Q{
                 def #{rel_type}_rels
                     dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    dsl.all_relationships(self).wrapped
+                    dsl.all_relationships(self)
                 end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, false, params)
+        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, false, clazz, params)
       end
 
 
@@ -80,7 +80,7 @@ module Neo4j::Mapping
                   dsl.single_relationship(self)
     end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, params)
+        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, clazz, params)
       end
 
     end

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

@@ -18,13 +18,22 @@ module Neo4j::Mapping
           trigger = props[:trigger].nil? ? [] : props[:trigger]
           @triggers[clazz][field] = trigger.respond_to?(:each) ? trigger : [trigger]
         end
-
-        def trigger_other_rules(node, field)
-          clazz = node[:_classname]
-          rel_types = @triggers[clazz][field]
-          rel_types.each do |rel_type|
-            node.incoming(rel_type).each { |n| n.trigger_rules }
-          end
+	
+	def inherit(parent_class, subclass)
+	  # copy all the rules
+	  @rules[parent_class.to_s].each_pair do |field, filter|
+	    subclass.rule field, &filter
+	  end if @rules[parent_class.to_s]
+	end
+
+        def trigger_other_rules(node)
+	  clazz = node[:_classname]
+	  @rules[clazz].keys.each do |field|
+	    rel_types = @triggers[clazz][field]
+	    rel_types.each do |rel_type|
+	      node.incoming(rel_type).each { |n| n.trigger_rules }
+	    end
+	  end
         end
 
         def fields_for(clazz)
@@ -61,12 +70,17 @@ module Neo4j::Mapping
         end
 
         def rule_for(clazz)
-          Neo4j.ref_node._rel(:outgoing, clazz)._end_node
+	  if Neo4j.ref_node.rel?(clazz)
+	    Neo4j.ref_node._rel(:outgoing, clazz)._end_node
+	  else
+	    # this should be called if the rule node gets deleted
+	    create_rule_node_for(clazz)
+	  end
         end
 
 
         def on_relationship_created(rel, *)
-          trigger_start_node = trigger?(rel._start_node)
+	  trigger_start_node = trigger?(rel._start_node)
           trigger_end_node   = trigger?(rel._end_node)
           # end or start node must be triggered by this event
           return unless trigger_start_node || trigger_end_node
@@ -75,28 +89,52 @@ module Neo4j::Mapping
 
 
         def on_property_changed(node, *)
-          trigger_rules(node) if trigger?(node)
+	  trigger_rules(node) if trigger?(node)
         end
 
         def trigger_rules(node)
-          clazz = node[:_classname]
-          return if @rules[clazz].nil?
+          trigger_rules_for_class(node, node[:_classname])
+	  trigger_other_rules(node)
+        end
+	
+	def trigger_rules_for_class(node, clazz)
+	  return if @rules[clazz].nil?
 
-          agg_node = rule_for(node[:_classname])
+          agg_node = rule_for(clazz)
           @rules[clazz].each_pair do |field, rule|
             if run_rule(rule, node)
               # is this node already included ?
-              if !node.rel?(field)
+	      unless connected?(field, agg_node, node)
                 agg_node.outgoing(field) << node
-                trigger_other_rules(node, field)
               end
             else
               # remove old ?
-              node.rels(field).incoming.each { |x| x.del }
-              trigger_other_rules(node, field)
+	      break_connection(field, agg_node, node)
             end
           end
-        end
+	  
+	  # recursively add relationships for all the parent classes with rules that also pass for this node
+	  if clazz = eval("#{clazz}.superclass")
+	    trigger_rules_for_class(node, clazz.to_s)
+	  end
+	end
+	
+	# work out if two nodes are connected by a particular relationship
+	# uses the end_node to start with because it's more likely to have less relationships to go through
+	# (just the number of superclasses it has really)
+	def connected?(relationship, start_node, end_node)
+	  end_node.incoming(relationship).each do |n|
+	    return true if n == start_node
+	  end
+	  false
+	end
+	
+	# sever a direct one-to-one relationship if it exists
+	def break_connection(relationship, start_node, end_node)
+	  end_node.rels(relationship).incoming.each do |r|
+	    return r.del if r.start_node == start_node
+	  end
+	end
 
         def run_rule(rule, node)
           if rule.arity != 1
@@ -130,10 +168,10 @@ module Neo4j::Mapping
       #   p1.young?    # => true
       #
       def rule(name, props = {}, &block)
-        singelton = class << self;
+	singelton = class << self;
           self;
         end
-
+	
         # define class methods
         singelton.send(:define_method, name) do
           agg_node = Rules.rule_for(self)
@@ -145,16 +183,20 @@ module Neo4j::Mapping
             end
           end
           traversal
-        end
+        end unless respond_to?(name)
 
         # define instance methods
         self.send(:define_method, "#{name}?") do
           instance_eval &block
-        end
+	end
 
         Rules.add(self, name, props, &block)
       end
-
+      
+      def inherit_rules_from(clazz)
+	Rules.inherit(clazz, self)
+      end
+      
       # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
       # It also remove the given class method.
       def delete_rules

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -34,37 +34,25 @@ module Neo4j::Mapping
     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}
 
-    def initialize(rel_id, has_one, params)
+    def initialize(rel_id, has_one, to_class, params)
       @direction = :outgoing
       @rel_id = rel_id
       @to_type = rel_id
       @has_one = has_one
       @namespace_type = rel_id
-      @cascade_delete_prop_name = CASCADE_DELETE_PROP_NAMES[params[:cascade_delete]]
-      @counter = params[:counter] == true
+      @to_class = to_class
     end
 
     def has_one?
       @has_one
     end
 
-    # If a counter was specified in the dsl for counting number of nodes in this relationship.
-    #
-    def counter?
-      @counter
-    end
-
-    # If cascade delete was specified for this relationship
-    #
-    def cascade_delete?
-      !@cascade_delete_prop_name.nil?
-    end
-
     def class_and_type_from_args(args) # :nodoc:
       if (args.size > 1)
         return args[0], args[1]
+      elsif (Symbol === args[0])
+        return @to_class, args[0]
       else
         return args[0], @rel_id
       end
@@ -73,7 +61,7 @@ module Neo4j::Mapping
 
     # The actual relationship type that this DSL will use
     def namespace_type
-      @to_class.nil? ? @to_type.to_s : "#{@to_class.to_s}##{@to_type.to_s}"
+      @namespace_type
     end
 
     def each_node(node, direction, &block)
@@ -90,7 +78,7 @@ module Neo4j::Mapping
     end
 
     def incoming_dsl
-      dsl = to_class._decl_rels[to_type]
+      dsl = @to_class._decl_rels[to_type]
       raise "Unspecified outgoing relationship '#{to_type}' for incoming relationship '#{rel_id}' on class #{to_class}" if dsl.nil?
       dsl
     end
@@ -106,13 +94,18 @@ module Neo4j::Mapping
       node._java_node.rel(dir, dsl.namespace_type)
     end
 
-    def all_relationships(node)
+    def _all_relationships(node)
       dsl = incoming? ? incoming_dsl : self
       type = type_to_java(dsl.namespace_type)
       dir  = dir_to_java(direction)
       node._java_node.getRelationships(type, dir)
     end
 
+    def all_relationships(node)
+      dsl = incoming? ? incoming_dsl : self
+      Neo4j::RelationshipTraverser.new(node._java_node, [dsl.namespace_type], direction)
+    end
+
     def create_relationship_to(node, other)
       dsl = incoming? ? incoming_dsl : self
 
@@ -156,6 +149,7 @@ module Neo4j::Mapping
     def to(*args)
       @direction = :outgoing
       @to_class, @to_type = class_and_type_from_args(args)
+      @namespace_type = "#{@to_class.to_s}##{@to_type.to_s}"
       self
     end
 

data/lib/neo4j/mapping/has_n.rb

@@ -43,7 +43,7 @@ module Neo4j
 
       # Returns true if there are no node in this type of relationship
       def empty?
-        first != nil
+        first == nil
       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, :getSingleRelationship, :rels_raw, :rel
+                   :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel
 
 
     # --------------------------------------------------------------------------
@@ -59,8 +59,14 @@ module Neo4j::Mapping
       c.extend Neo4j::Index::ClassMethods
 
       def c.inherited(subclass)
-        subclass.node_indexer subclass
         subclass.root_class subclass
+
+        # inherit the index properties
+        subclass.node_indexer self
+
+        # inherit the rules too
+        subclass.inherit_rules_from self
+
         super
       end
 

data/lib/neo4j/mapping/relationship_mixin.rb

@@ -5,7 +5,7 @@ module Neo4j::Mapping
     include Neo4j::Index
 
     def_delegators :@_java_rel, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :to_param, :getId,
-                   :equal?, :eql?, :==, :delete, :getStartNode, :getEndNode, :getOtherNode
+                   :equal?, :eql?, :==, :delete, :getStartNode, :getEndNode, :getOtherNode, :exist?
 
 
 
@@ -59,7 +59,7 @@ module Neo4j::Mapping
     end
 
     def exist?
-      Neo4j::Relationship.load(neo_id) != nil
+      Neo4j::Relationship.exist?(self)
     end
 
     # A convenience operation that, given a node that is attached to this relationship, returns the other node.

data/lib/neo4j/node.rb

@@ -118,6 +118,7 @@ module Neo4j
       # Same as load but does not return the node as a wrapped Ruby object.
       #
       def _load(node_id, db)
+	return nil if node_id.nil?
         db.graph.get_node_by_id(node_id.to_i)
       rescue java.lang.IllegalStateException
         nil # the node has been deleted

data/lib/neo4j/node_relationship.rb

@@ -111,7 +111,7 @@ module Neo4j
     end
 
     # Returns the raw java neo4j relationship object.
-    def rels_raw(dir=:both, *types)
+    def _rels(dir=:both, *types)
       if types.size > 1
         java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
         get_relationships(java_types)

data/lib/neo4j/rails/model.rb

@@ -2,6 +2,7 @@ module Neo4j
   module Rails
     class Model
       include Neo4j::NodeMixin
+      include ActiveModel::Serializers::Xml
       include ActiveModel::Validations
       include ActiveModel::Dirty
       include ActiveModel::MassAssignmentSecurity
@@ -13,7 +14,8 @@ module Neo4j
 
       define_model_callbacks :create, :save, :update, :destroy
 
-
+      rule :all
+      
       UniquenessValidator = Neo4j::Validations::UniquenessValidator
 
       class RecordInvalidError < RuntimeError
@@ -35,7 +37,6 @@ module Neo4j
       def init_on_create(*args) # :nodoc:
         super()
         self.attributes=args[0] if args[0].respond_to?(:each_pair)
-        @_created_record = true
       end
 
       # --------------------------------------
@@ -119,7 +120,7 @@ module Neo4j
         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)
+          outgoing(rel_type) << clazz.new(attr) unless reject_if?(reject_if, attr) || (allow_destroy && attr[:_destroy] && attr[:_destroy] != '0')
         else
           # We have a node that was created with the #create method - has real Neo4j relationships
           # does it exist ?
@@ -167,36 +168,40 @@ module Neo4j
       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
+        _run_save_callbacks do
+          if create_or_update_node
+            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
         end
-        valid
       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
-
-        if  new_record?
-          _run_create_callbacks { clear_changes }
-        else
-          _run_update_callbacks { clear_changes }
+        if valid?(:save)
+          if new_record?
+            _run_create_callbacks do
+              if valid?(:create)
+                node = Neo4j::Node.new(props)
+                return false unless _java_node.save_nested(node)
+                init_on_load(node)
+                init_on_create
+                clear_changes
+                true
+              end
+            end
+          else
+            _run_update_callbacks do
+              if valid?(:update)
+                clear_changes
+                true
+              end
+            end
+          end
         end
-        valid
       end
 
       def clear_changes
@@ -204,6 +209,12 @@ module Neo4j
         @changed_attributes.clear
       end
 
+      def reload(options = nil)
+        clear_changes
+        attributes = self.class.load(self.id.to_s).attributes
+        self
+      end
+
       def save!
         raise RecordInvalidError.new(self) unless save
       end
@@ -217,15 +228,11 @@ module Neo4j
         self
       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 new?
         _java_node.kind_of?(Neo4j::Rails::Value)
       end
+      
+      alias :new_record? :new?
 
       def del
         @_deleted = true
@@ -258,12 +265,12 @@ module Neo4j
           wrapped
         end
 
-        # Handle Model.find(params[:id])
-        def find(*args)
-          if args.length == 1 && String === args[0] && args[0].to_i != 0
-            load(*args)
+	      # Behave like ActiveModel
+        def all_with_args(*args)
+          if args.empty?
+            all_without_args
           else
-            hits = super
+            hits                                     = find_without_checking_for_id(*args)
             # 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
@@ -271,6 +278,19 @@ module Neo4j
           end
         end
 
+        alias_method_chain :all, :args
+        
+        # Handle Model.find(params[:id])
+        def find_with_checking_for_id(*args)
+          if args.length == 1 && String === args[0] && args[0].to_i != 0
+            load(*args)
+          else
+            all_with_args(*args).first
+          end
+        end
+
+        alias_method_chain :find, :checking_for_id
+
         def load(*ids)
           result = ids.map { |id| Neo4j::Node.load(id) }
           if ids.length == 1
@@ -283,16 +303,12 @@ module Neo4j
 
         alias_method :_orig_create, :create
 
-        def create(*)
-          model = super
-          model.save
-          model
+        def create(*args)
+          new(*args).tap { |o| o.save }
         end
 
         def create!(*args)
-          model = _orig_create(*args)
-          model.save!
-          model
+          new(*args).tap { |o| o.save! }
         end
 
         tx_methods :create, :create!
@@ -338,4 +354,3 @@ module Neo4j
 
   end
 end
-

data/lib/neo4j/rails/transaction.rb

@@ -52,13 +52,14 @@ module Neo4j
         def run
           begin
             new
-            yield
+            ret = yield
           rescue
             fail
             raise
           ensure
             finish
           end
+	  ret
         end
       end
     end

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -5,16 +5,16 @@ module Neo4j
         super(options.reverse_merge(:case_sensitive => true))
       end
 
-      def validate_each(record, attribute, value)
-        clazz = record.class
-
-        # TODO is it possible to move this to setup instead so that we don't have to do this always ?
-        if clazz.index_type_for(attribute) != :exact
-          raise "Can't validate property #{attribute} on class #{clazz} since there is no :exact lucene index on that property"
+      def setup(klass)
+        @attributes.each do |attribute|
+          if klass.index_type_for(attribute) != :exact
+            raise "Can't validate property #{attribute} on class #{klass} since there is no :exact lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
+          end
         end
+      end
 
-        query = "#{attribute}: #{value}"
-        if !clazz.find(query).empty?
+      def validate_each(record, attribute, value)
+        if record.class.find("#{attribute}: #{value}")
           record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
         end
       end

data/lib/neo4j/rails/value.rb

@@ -75,6 +75,11 @@ module Neo4j::Rails
       end
       valid
     end
+    
+    # this node doesn't exist in the DB yet
+    def exist?
+      false
+    end
 
     class Relationship
       include org.neo4j.graphdb.Relationship

data/lib/neo4j/relationship.rb

@@ -36,6 +36,12 @@ module Neo4j
       self
     end
 
+
+    # Returns true if the relationship exists
+    def exist?
+      Neo4j::Relationship.exist?(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)
@@ -130,8 +136,24 @@ module Neo4j
       # create is the same as new
       alias_method :create, :new
 
+      # Loads a relationship or wrapped relationship given a native java relationship or an id.
+      # If there is a Ruby wrapper for the node then it will create a Ruby object that will
+      # wrap the java node (see Neo4j::RelationshipMixin).
+      #
+      # If the relationship does not exist it will return nil
+      #
       def load(rel_id, db = Neo4j.started_db)
-        wrapper(db.graph.get_relationship_by_id(rel_id.to_i))
+        rel = _load(rel_id, db)
+        return nil if rel.nil?
+        rel.wrapper
+      end
+
+      # Same as load but does not return the node as a wrapped Ruby object.
+      #
+      def _load(rel_id, db)
+        rel = db.graph.get_relationship_by_id(rel_id.to_i)
+        rel.hasProperty('_classname')  # since we want a IllegalStateException which is otherwise not triggered
+        rel
       rescue java.lang.IllegalStateException
         nil # the node has been deleted
       rescue org.neo4j.graphdb.NotFoundException

data/lib/neo4j/relationship_traverser.rb

@@ -4,59 +4,83 @@ module Neo4j
     include Enumerable
     include ToJava
 
-    def initialize(node, types, dir)
-      @node = node
+    def initialize(node, types, direction)
+      @node      = node
       if types.size > 1
         @types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
       elsif types.size == 1
         @type = type_to_java(types[0])
       end
-
-      @dir = dir_to_java(dir)
+      @direction = direction
     end
 
     def to_s
       if @type
-        "#{self.class} [type: #{@type} dir:#{@dir}]"
+        "#{self.class} [type: #{@type} dir:#{@direction}]"
       elsif @types
-        "#{self.class} [types: #{@types.join(',')} dir:#{@dir}]"
+        "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
       else
-        "#{self.class} [types: ANY dir:#{@dir}]"
+        "#{self.class} [types: ANY dir:#{@direction}]"
       end
     end
 
     def each
-      iterator.each {|i| yield i.wrapper}
+      iter = iterator
+      while (iter.hasNext())
+        rel = iter.next
+        yield rel.wrapper if match_to_other?(rel)
+      end
     end
 
     def iterator
       if @types
         @node.get_relationships(@types).iterator
       elsif @type
-        @node.get_relationships(@type, @dir).iterator
+        @node.get_relationships(@type, dir_to_java(@direction))
+      else
+        @node.get_relationships(dir_to_java(@direction))
+      end
+    end
+
+    def match_to_other?(rel)
+      if @to_other.nil?
+        true
+      elsif @direction == :outgoing
+        rel._end_node == @to_other
+      elsif @direction == :incoming
+        rel._start_node == @to_other
       else
-        @node.get_relationships(@dir).iterator
+        rel._start_node == @to_other || rel._end_node == @to_other
       end
     end
 
+    def to_other(to_other)
+      @to_other = to_other
+      self
+    end
+
+    def del
+      each { |rel| rel.del }
+    end
+
     def size
       [*self].size
     end
 
     def both
-      @dir = dir_to_java(:both)
+      @direction = :both
       self
     end
 
     def incoming
       raise "Not allowed calling incoming when finding several relationships types" if @types
-      @dir = dir_to_java(:incoming)
+      @direction = :incoming
       self
     end
 
     def outgoing
       raise "Not allowed calling outgoing when finding several relationships types" if @types
-      @dir = dir_to_java(:outgoing)
+      @direction = :outgoing
       self
     end
 

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.15"
-end
+  VERSION = "1.0.0.beta.16"
+end

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 15
-  version: 1.0.0.beta.15
+    - 16
+  version: 1.0.0.beta.16
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-26 00:00:00 +02:00
+date: 2010-10-28 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency