neo4j 1.0.0-java → 1.1.0.beta.1-java

data/lib/neo4j/rails/relationships/node_dsl.rb

@@ -0,0 +1,91 @@
+module Neo4j
+  module Rails
+    module Relationships
+
+      class NodesDSL #:nodoc:
+        include Enumerable
+
+        def initialize(storage, dir)
+          @storage = storage
+          @dir = dir
+        end
+
+        def build(attrs)
+          self << (node = @storage.build(attrs))
+          node
+        end
+
+        def create(attrs)
+          self << (node = @storage.create(attrs))
+          node
+        end
+
+        def <<(other)
+          @storage.create_relationship_to(other, @dir)
+          self
+        end
+
+        def depth(d)
+          adapt_to_traverser.depth(d)
+        end
+
+        def adapt_to_traverser
+          Neo4j::Traversal::Traverser.new(@storage.node, @storage.rel_type, @dir)
+        end
+
+        def [](index)
+          i = 0
+          each{|x| return x if i == index; i += 1}
+          nil # out of index
+        end
+
+        def is_a?(type)
+          # ActionView requires this for nested attributes to work
+          return true if Array == type
+          super
+        end
+
+        def find(*args, &block)
+          return super(*args, &block) if block
+          node = args.first
+          enum = Enumerator.new(@storage, :each_rel, @dir)
+          if @dir == :incoming
+            enum.find{|r| r.start_node == node}
+          else
+            enum.find{|r| r.end_node == node}
+          end
+        end
+
+        def destroy_all
+          each {|n| n.destroy}
+        end
+
+        def delete_all
+          each {|n| n.delete}
+        end
+
+        def size
+          @storage.size(@dir)
+        end
+
+        alias :length :size
+
+        def each(&block)
+          @storage.each_node(@dir, &block)
+        end
+
+        def delete(*nodes)
+          @storage.destroy_rels(@dir, *nodes)
+        end
+
+        def empty?
+          size == 0 # TODO, performance: there are probably faster way of doing this
+        end
+
+        def to_s
+          "Node dir: #{@dir}, #{@storage}"
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/relationships/relationships.rb

@@ -2,65 +2,72 @@ module Neo4j
   module Rails
     module Relationships
 
-      # TODO, reuse for incoming relationships ?
-      class OutgoingRelationship #:nodoc:
-        include Enumerable
 
-        def initialize(from_node, mapper)
-          @from_node = from_node
-          @mapper    = mapper
+      def write_changed_relationships #:nodoc:
+        @relationships.each_value do |storage|
+          storage.persist
         end
+      end
 
-        def <<(other)
-          @mapper.create_relationship_to(@from_node, other)
-          self
-        end
+      def clear_relationships #:nodoc:
+        @relationships = {}
+      end
 
-        def size
-          @mapper.dsl.all_relationships(@from_node).size
-        end
 
-        def each(&block)
-          @mapper.each_node(@from_node, :outgoing, &block)
-        end
+      def _create_or_get_storage(rel_type) #:nodoc:
+        dsl = _decl_rels_for(rel_type.to_sym)
+        @relationships[rel_type.to_sym] ||= Storage.new(self, rel_type, dsl)
       end
 
+      def _create_or_get_storage_for_decl_rels(decl_rels) #:nodoc:
+        @relationships[decl_rels.rel_type.to_sym] ||= Storage.new(self, decl_rels.rel_type, decl_rels)
+      end
 
-      def write_changed_relationships #:nodoc:
-        @relationships.each_value do |mapper|
-          mapper.persist
-        end
+
+      # If the node is persisted and it does not have any unsaved relationship it returns a Neo4j::NodeTraverser.
+      # Otherwise it will return a NodesDSL which behaves like the Neo4j::NodeTraverser except that it does not
+      # allow to traverse both persisted and not persisted (not saved yet) relationship more then depth one.
+      #
+      # See, Neo4j::NodeRelationship#outgoing (when node is persisted) which returns a Neo4j::NodeTraverser
+      #
+      def outgoing(rel_type)
+        storage = _create_or_get_storage(rel_type)
+        NodesDSL.new(storage, :outgoing)
       end
 
-      def valid_relationships? #:nodoc:
-        !@relationships.values.find {|mapper| !mapper.valid?}
+
+      # Traverse or update an incoming relationship
+      # See #outgoing
+      # See, Neo4j::NodeRelationship#outgoing (when node is persisted) which returns a Neo4j::NodeTraverser
+      def incoming(rel_type)
+        storage = _create_or_get_storage(rel_type)
+        NodesDSL.new(storage, :incoming)
       end
 
-      def _decl_rels_for(type) #:nodoc:
-        dsl = super
-        @relationships[type] ||= Mapper.new(type, dsl, self)
+      # See Neo4j::Rels#rels.
+      # Will also allow to access unsaved relationships - like the #outgoing and #incoming method.
+      #
+      def rels(*rel_types)
+        storage = _create_or_get_storage(rel_types.first)
+        RelsDSL.new(storage)
       end
 
+      def add_outgoing_rel(rel_type, rel) #:nodoc:
+        _create_or_get_storage(rel_type).add_outgoing_rel(rel)
+      end
 
-      def clear_relationships #:nodoc:
-        @relationships = {}
+      def add_incoming_rel(rel_type, rel) #:nodoc:
+        _create_or_get_storage(rel_type).add_incoming_rel(rel)
       end
 
+      def rm_incoming_rel(rel_type, rel) #:nodoc:
+        _create_or_get_storage(rel_type).rm_incoming_rel(rel)
+      end
 
-      # If the node is persisted it returns a Neo4j::NodeTraverser
-      # otherwise create a new object which will handle creating new relationships in memory.
-      # If not persisted the traversal method like prune, expand, filter etc. will not be available
-      #
-      # See, Neo4j::NodeRelationship#outgoing (when node is persisted) which returns a Neo4j::NodeTraverser
-      #
-      def outgoing(rel_type)
-        if persisted?
-          super
-        else
-          dsl = _decl_rels_for(rel_type)
-          OutgoingRelationship.new(self, dsl)
-        end
+      def rm_outgoing_rel(rel_type, rel) #:nodoc:
+        _create_or_get_storage(rel_type).rm_outgoing_rel(rel)
       end
+
     end
   end
 end

data/lib/neo4j/rails/relationships/rels_dsl.rb

@@ -0,0 +1,82 @@
+module Neo4j
+  module Rails
+    module Relationships
+      class RelsDSL
+        include Enumerable
+
+        def initialize(storage, dir=:both)
+          @storage = storage
+          @dir = dir
+        end
+
+
+        def build(attrs)
+          node = @storage.build(attrs)
+          @storage.create_relationship_to(node, @dir)
+        end
+
+        def create(attrs)
+          node = @storage.create(attrs)
+          @storage.create_relationship_to(node, @dir)
+        end
+
+        def outgoing
+          @dir = :outgoing
+          self
+        end
+
+        def incoming
+          @dir = :incoming
+          self
+        end
+
+        def each(&block)
+          @storage.each_rel(@dir, &block)
+        end
+
+        def size
+          @storage.size(@dir)
+        end
+
+        def empty?
+          size == 0
+        end
+
+        def destroy_all
+          each {|n| n.destroy}
+        end
+
+        def delete_all
+          each {|n| n.delete}
+        end
+
+        def find(*args, &block)
+          return super(*args, &block) if block
+          node = args.first
+          if @dir == :incoming
+            find{|r| r.start_node == node}
+          else
+            find{|r| r.end_node == node}
+          end
+        end
+
+        def [](index)
+          i = 0
+          each{|x| return x if i == index; i += 1}
+          nil # out of index
+        end
+
+        def is_a?(type)
+          # ActionView requires this for nested attributes to work
+          return true if Array == type
+          super
+        end
+
+        def to_s
+          "Rels dir: #{@dir}, #{@storage}"
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/rails/relationships/storage.rb

@@ -0,0 +1,161 @@
+module Neo4j
+  module Rails
+    module Relationships
+
+      # Holds the relationships in memory but also allows read access to persisted relationships
+      class Storage #:nodoc:
+        include Neo4j::ToJava
+        attr_reader :dsl, :node, :rel_type
+
+        def initialize(node, rel_type, dsl)
+          @rel_type = rel_type.to_sym
+          @node = node
+          @rel_class = (dsl && dsl.relationship_class) || Neo4j::Rails::Relationship
+          @target_class = (dsl && dsl.target_class) || Neo4j::Rails::Model
+          @outgoing_rels = []
+          @incoming_rels = []
+        end
+
+        def to_s #:nodoc:
+          "Storage #{object_id} node: #{@node.id} rel_type: #{@rel_type} outgoing #{@outgoing_rels.size} incoming #{@incoming_rels.size}"
+        end
+
+
+        def size(dir)
+          counter = 0
+          # count persisted relationship
+          @node._java_node && @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each { |*| counter += 1 }
+          # count relationship which has not yet been persisted
+          counter += relationships(dir).size
+          counter
+        end
+
+
+        def build(attrs)
+          @target_class.new(attrs)
+        end
+
+        def create(attrs)
+          @target_class.create(attrs)
+        end
+
+        def relationships(dir)
+          case dir
+            when :outgoing
+              @outgoing_rels
+            when :incoming
+              @incoming_rels
+            when :both
+              @incoming_rels + @outgoing_rels
+          end
+        end
+
+        def java_rel_type
+          type_to_java(rel_type)
+        end
+
+        def each_rel(dir, &block) #:nodoc:
+          relationships(dir).each { |rel| block.call rel }
+
+          if @node.persisted?
+            node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+              block.call rel.wrapper
+            end
+          end
+        end
+
+        def each_node(dir, &block)
+          relationships(dir).each do |rel|
+            if rel.start_node == @node
+              block.call rel.end_node
+            else
+              block.call rel.start_node
+            end
+          end
+
+          if @node.persisted?
+            @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+              block.call rel.getOtherNode(@node._java_node).wrapper
+            end
+          end
+        end
+
+        def single_relationship(dir)
+          rel = relationships(dir).first
+          if rel.nil? && @node.persisted?
+            java_rel = @node._java_node.getSingleRelationship(java_rel_type, dir_to_java(dir))
+            java_rel && java_rel.wrapper
+          else
+            rel
+          end
+        end
+
+        def all_relationships(dir)
+          Enumerator.new(self, :each_rel, dir)
+        end
+
+        def single_node(dir)
+          rel = single_relationship(dir)
+          return nil if rel.nil?
+          other = rel.other_node(@node)
+          other && other.wrapper
+        end
+
+        def destroy_rels(dir, *nodes)
+          all_relationships(dir).each do |rel|
+            node = dir == :outgoing ? rel.end_node : rel.start_node
+            dir == :incoming ? rm_incoming_rel(rel) : rm_outgoing_rel(rel)
+            rel.destroy if nodes.include?(node)
+          end
+        end
+
+        def create_relationship_to(to, dir)
+          if dir == :outgoing
+            @rel_class.new(@rel_type, @node, to, self)
+          else
+            @rel_class.new(@rel_type, to, @node, self)
+          end
+        end
+
+        def add_incoming_rel(rel)
+          @incoming_rels << rel
+        end
+
+        def add_outgoing_rel(rel)
+          @outgoing_rels << rel
+        end
+
+        def rm_incoming_rel(rel)
+          @incoming_rels.delete(rel)
+        end
+
+        def rm_outgoing_rel(rel)
+          @outgoing_rels.delete(rel)
+        end
+
+        def persist
+          out_rels = @outgoing_rels.clone
+          in_rels = @incoming_rels.clone
+
+          @outgoing_rels.clear
+          @incoming_rels.clear
+
+          out_rels.each do |rel|
+            rel.end_node.rm_incoming_rel(@rel_type.to_sym, rel)
+            success = rel.persisted? || rel.save
+            # don't think this can happen - just in case, TODO
+            raise "Can't save outgoing #{rel}, validation errors ? #{rel.errors.inspect}" unless success
+          end
+
+          in_rels.each do |rel|
+            rel.start_node.rm_outgoing_rel(@rel_type.to_sym, rel)
+            success = rel.persisted? || rel.save
+            # don't think this can happen - just in case, TODO
+            raise "Can't save incoming #{rel}, validation errors ? #{rel.errors.inspect}" unless success
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/rails/serialization.rb

@@ -5,7 +5,7 @@ module Neo4j
 			
 			included do
 				include ActiveModel::Serializers::Xml
-				
+        include ActiveModel::Serializers::JSON
 				# Patch for ActiveModel's XML serializer.  There is a bug in the original where
 				# raw_value is used in the initializer and so demands always that the object being 
 				# serialized is sent the attribute's name as a method call.  This causes a problem

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

@@ -0,0 +1,53 @@
+module Neo4j
+  module Rails
+    module Validations
+      class AssociatedValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          return if (value.is_a?(Enumerable) ? value : [value]).collect { |r| r.nil? || r.valid? }.all?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
+      end
+
+      module ClassMethods
+        # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
+        #
+        #   class Book < Neo4j::Rails::Model
+        #     has_n :pages
+        #     belongs_to :library
+        #
+        #     validates_associated :pages, :library
+        #   end
+        #
+        # Warning: If, after the above definition, you then wrote:
+        #
+        #   class Page < Neo4j::Rails::Model
+        #     has_n(:book).from(:pages)
+        #
+        #     validates_associated :book
+        #   end
+        #
+        # this would specify a circular dependency and cause infinite recursion.
+        #
+        # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
+        # ensure that the association is both present and guaranteed to be valid, you also need to
+        # use +validates_presence_of+.
+        #
+        # Configuration options:
+        # * <tt>:message</tt> - A custom error message (default is: "is invalid")
+        # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+        # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+        #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+        #   method, proc or string should return or evaluate to a true or false value.
+        # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+        #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+        #   method, proc or string should return or evaluate to a true or false value.
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+          rel_attr_names = attr_names.collect{|a| a.is_a?(Symbol) && _decl_rels[a].has_one? ? "#{a}_rel" : a}
+          rel_attr_names = rel_attr_names.collect{|a| a.is_a?(Symbol) && _decl_rels[a].has_n? ? "#{a}_rels" : a}
+          validates_with AssociatedValidator, _merge_attributes(rel_attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/validations.rb

@@ -15,9 +15,8 @@ module Neo4j
 
       def valid?(context = nil)
         context     ||= (new_record? ? :create : :update)
-        output      = super(context)
-        output_rels = valid_relationships?
-        errors.empty? && output && output_rels
+        super(context)
+        errors.empty?
       end
 
       private

data/lib/neo4j/relationship.rb

@@ -140,9 +140,9 @@ module Neo4j
       #
       #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
       #
-      def new(type, from_node, to_node, props=nil)
+      def new(type, start_node, end_node, props=nil)
         java_type = type_to_java(type)
-        rel = from_node._java_node.create_relationship_to(to_node._java_node, java_type)
+        rel = start_node._java_node.create_relationship_to(end_node._java_node, java_type)
         props.each_pair {|k,v| rel[k] = v} if props
         rel
       end
@@ -164,7 +164,7 @@ module Neo4j
 
       # Same as load but does not return the node as a wrapped Ruby object.
       #
-      def _load(rel_id, db)
+      def _load(rel_id, db = Neo4j.started_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

data/lib/neo4j/relationship_mixin/relationship_mixin.rb

@@ -59,6 +59,10 @@ module Neo4j
       @_java_rel
     end
 
+    def _java_entity
+      @_java_rel
+    end
+
     # Returns the end node of this relationship
     def end_node
       id = getEndNode.getId
@@ -127,7 +131,7 @@ module Neo4j
         c.extend Neo4j::Index::ClassMethods
 
         def c.inherited(subclass)
-          subclass.rel_indexer subclass
+          subclass.rel_indexer self
           super
         end
 

data/lib/neo4j/rels/traverser.rb

@@ -12,23 +12,23 @@ module Neo4j
       include Enumerable
       include ToJava
 
-      def initialize(node, types, direction)
+      def initialize(node, types, dir)
         @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
-        @direction = direction
+        @dir = dir
       end
 
       def to_s
         if @type
-          "#{self.class} [type: #{@type} dir:#{@direction}]"
+          "#{self.class} [type: #{@type} dir:#{@dir}]"
         elsif @types
-          "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
+          "#{self.class} [types: #{@types.join(',')} dir:#{@dir}]"
         else
-          "#{self.class} [types: ANY dir:#{@direction}]"
+          "#{self.class} [types: ANY dir:#{@dir}]"
         end
       end
 
@@ -48,18 +48,18 @@ module Neo4j
         if @types
           @node.get_relationships(@types).iterator
         elsif @type
-          @node.get_relationships(@type, dir_to_java(@direction))
+          @node.get_relationships(@type, dir_to_java(@dir))
         else
-          @node.get_relationships(dir_to_java(@direction))
+          @node.get_relationships(dir_to_java(@dir))
         end
       end
 
       def match_to_other?(rel)
         if @to_other.nil?
           true
-        elsif @direction == :outgoing
+        elsif @dir == :outgoing
           rel._end_node == @to_other
-        elsif @direction == :incoming
+        elsif @dir == :incoming
           rel._start_node == @to_other
         else
           rel._start_node == @to_other || rel._end_node == @to_other
@@ -80,19 +80,19 @@ module Neo4j
       end
 
       def both
-        @direction = :both
+        @dir = :both
         self
       end
 
       def incoming
         raise "Not allowed calling incoming when finding several relationships types" if @types
-        @direction = :incoming
+        @dir = :incoming
         self
       end
 
       def outgoing
         raise "Not allowed calling outgoing when finding several relationships types" if @types
-        @direction = :outgoing
+        @dir = :outgoing
         self
       end
 

data/lib/neo4j/rule/rule_node.rb

@@ -7,6 +7,7 @@ module Neo4j
     # The RuleNode can also be used to hold properties for functions, like sum and count.
     #
     class RuleNode
+      include ToJava
       attr_reader :rules
 
       def initialize(clazz)
@@ -26,7 +27,7 @@ module Neo4j
       def create_node
         Neo4j::Transaction.run do
           node = Neo4j::Node.new
-          Neo4j.ref_node.outgoing(@clazz) << node
+          Neo4j.ref_node.create_relationship_to(node, type_to_java(@clazz))
           node
         end
       end

data/lib/neo4j/to_java.rb

@@ -5,10 +5,6 @@ module Neo4j
       org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
     end
 
-    def type_from_java(type)
-      type.get_type
-    end
-
     def dir_from_java(dir)
       case dir
         when org.neo4j.graphdb.Direction::OUTGOING then :outgoing