neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/rails/rails.rb

@@ -1,27 +1,30 @@
 # rails
 require 'neo4j/rails/tx_methods'
+require 'neo4j/rails/identity'
 require 'neo4j/rails/transaction'
 require 'neo4j/rails/railtie'
 require 'neo4j/rails/validations/uniqueness'
 require 'neo4j/rails/validations/non_nil'
 require 'neo4j/rails/validations/associated'
 require 'neo4j/rails/finders'
-require 'neo4j/rails/mapping/property'
 require 'neo4j/rails/validations'
 require 'neo4j/rails/callbacks'
 require 'neo4j/rails/observer'
 require 'neo4j/rails/compositions'
 require 'neo4j/rails/accept_id'
 require 'neo4j/rails/timestamps'
-require 'neo4j/rails/serialization'
 require 'neo4j/rails/attributes'
+require 'neo4j/rails/nested_attributes'
+require 'neo4j/rails/serialization'
 require 'neo4j/rails/persistence'
+require 'neo4j/rails/node_persistance'
+require 'neo4j/rails/relationship_persistence'
 require 'neo4j/rails/relationships/storage'
 require 'neo4j/rails/relationships/node_dsl'
 require 'neo4j/rails/relationships/rels_dsl'
 require 'neo4j/rails/relationships/relationships'
-require 'neo4j/rails/model'
+require 'neo4j/rails/has_n'
 require 'neo4j/rails/rack_middleware'
-require 'neo4j/rails/rel_persistence'
-require 'neo4j/rails/relationship'
-require 'neo4j/rails/versioning/versioning'
+require 'neo4j/rails/versioning/versioning'
+require 'neo4j/rails/model'
+require 'neo4j/rails/relationship'

data/lib/neo4j/rails/railtie.rb

@@ -3,8 +3,7 @@ module Neo4j
     config.neo4j = ActiveSupport::OrderedOptions.new
 
     initializer "neo4j.tx" do |app|
-      app.config.middleware.use Neo4j::Rails::RackMiddleware
-      app.config.middleware.use Neo4j::IdentityMap::Middleware
+      app.config.middleware.use Neo4j::Rails::Middleware
     end
 
     # Add ActiveModel translations to the I18n load_path

data/lib/neo4j/rails/relationship.rb

@@ -1,6 +1,5 @@
 module Neo4j
   module Rails
-
     # Includes the Neo4j::RelationshipMixin and adds ActiveRecord/Model like behaviour.
     # That means for example that you don't have to care about transactions since they will be
     # automatically be created when needed.
@@ -12,146 +11,40 @@ module Neo4j
     # It also implement timestamps (like active record), just add a updated_at or created_at attribute.
     #
     class Relationship
-      include Neo4j::RelationshipMixin
-
-      # The relationship type
-      attr_reader :type
-
-      index :_classname
-
-      # Initialize a Node with a set of properties (or empty if nothing is passed)
-      def initialize(*args)
-        @properties_before_type_cast=java.util.HashMap.new
-        @type = args[0].to_s
-        self.start_node = args[1]
-        self.end_node = args[2]
-        attributes = args[3]
-        reset_attributes
-        self.attributes = attributes if attributes.is_a?(Hash)
-      end
-
-      def other_node(node)
-        if persisted?
-          _java_rel.getOtherNode(node._java_node)
-        else
-          @start_node == (node._java_node || node) ? @end_node : @start_node
-        end
-      end
-
-
-      alias_method :get_other_node, :other_node # so it looks like the java version
+      extend ActiveModel::Translation
 
-      def attribute_missing(method_id, *args, &block)
-        method_name = method_id.method_name
-        if property?(method_name)
-          self[method_name]
-        else
-          super
-        end
-      end
+      include Neo4j::RelationshipMixin
+      include ActiveModel::Dirty # track changes to attributes
+      include ActiveModel::MassAssignmentSecurity # handle attribute hash assignment
+      include ActiveModel::Observing # enable observers
+      include Neo4j::Rails::Identity
+      include Neo4j::Rails::Persistence # handles how to save, create and update the model
+      include Neo4j::Rails::RelationshipPersistence # handles how to save, create and update the model
+      include Neo4j::Rails::Attributes # handles how to save and retrieve attributes
+      include Neo4j::Rails::Serialization # enable to_xml and to_json
+      include Neo4j::Rails::Validations # enable validations
+      include Neo4j::Rails::Callbacks # enable callbacks
+      include Neo4j::Rails::Timestamps # handle created_at, updated_at timestamp properties
+      include Neo4j::Rails::Finders # ActiveRecord style find
+      include Neo4j::Rails::Compositions
+
+      index :_classname # since there are no rule we have to use lucene to find all instance of a class
 
-      def rel_type
-        persisted? ?  _java_entity.rel_type : @type
-      end
 
       def to_s
         "id: #{self.object_id}  start_node: #{start_node.id} end_node: #{end_node.id} type:#{@type}"
       end
 
-      def id
-        _java_rel.nil? || neo_id.nil? ? nil : neo_id.to_s
-      end
-
-      def hash
-        persisted? ? _java_entity.neo_id.hash : super
-      end
-
-      def start_node
-        @start_node ||= _java_rel && _java_rel.start_node
-      end
-
-      def start_node=(node)
-        old = @start_node
-        @start_node = node
-        # TODO should raise exception if not persisted and changed
-        if old != @start_node
-          old && old.rm_outgoing_rel(type, self)
-          @start_node.class != Neo4j::Node && @start_node.add_outgoing_rel(type, self)
-        end
-      end
-
-      def end_node
-        @end_node ||= _java_rel && _java_rel.end_node
-      end
-
-      def end_node=(node)
-        old = @end_node
-        @end_node = node
-        # TODO should raise exception if not persisted and changed
-        if old != @end_node
-          old && old.rm_incoming_rel(type, self)
-          @end_node.class != Neo4j::Node && @end_node.add_incoming_rel(type, self)
-        end
-      end
-
-      def del
-        _java_rel.del
-      end
-
-      def reset_attributes
-        @properties = {}
-      end
-
-      def wrapper
-        self
-      end
-
       # --------------------------------------
       # Public Class Methods
       # --------------------------------------
       class << self
-        # NodeMixin overwrites the #new class method but it saves it as orig_new
-        # Here, we just get it back to normal
-        alias :new :orig_new
-
-        def entity_load(id)
-          Neo4j::Relationship.load(id)
-        end
-
-
-        def rule(*)
-        end
-
         def _all
           _indexer.find(:_classname => self)
         end
-
-        def load(*ids) # TODO Copied from finders.rb
-          result = ids.map { |id| entity_load(id) }
-          if ids.length == 1
-            result.first
-          else
-            result
-          end
-        end
-
       end
 
     end
 
-
-    Relationship.class_eval do
-      extend ActiveModel::Translation
-      include RelPersistence # handles how to save, create and update the model
-      include Attributes # handles how to save and retrieve attributes
-      include Mapping::Property # allows some additional options on the #property class method
-      include Serialization # enable to_xml and to_json
-      include Validations # enable validations
-      include Callbacks # enable callbacks
-      include Timestamps # handle created_at, updated_at timestamp properties
-      include Finders # ActiveRecord style find
-      include Compositions
-    end
-
   end
-end
+end

data/lib/neo4j/rails/relationship_persistence.rb

@@ -0,0 +1,107 @@
+module Neo4j
+  module Rails
+    module RelationshipPersistence
+      extend TxMethods
+
+      # Initialize a Node with a set of properties (or empty if nothing is passed)
+      def initialize(*args)
+        return initialize_attributes(nil) if args.size < 3 # then we have been loaded
+        type, start_node, end_node, attributes = args
+        @_rel_type = type.to_sym
+        raise "Unknown type" unless type
+        raise "Unknown start_node" unless start_node
+        raise "Unknown end_node" unless end_node
+        self.start_node = start_node
+        self.end_node = end_node
+        initialize_attributes(attributes)
+      end
+
+
+      def create
+        # prevent calling create twice
+        @_start_node.add_unpersisted_outgoing_rel(rel_type, self)
+        @_end_node.add_unpersisted_incoming_rel(rel_type, self)
+
+        return unless _persist_node(@_start_node) && _persist_node(@_end_node)
+
+        java_rel = Neo4j::Relationship.new(rel_type, start_node, end_node)
+        init_on_load(java_rel)
+        Neo4j::IdentityMap.add(java_rel, self)
+        init_on_create
+
+        @_start_node.rm_unpersisted_outgoing_rel(rel_type, self)
+        @_end_node.rm_unpersisted_incoming_rel(rel_type, self)
+        true
+      end
+
+      def rel_type
+        new_record? ? @_rel_type : _java_entity.rel_type.to_sym
+      end
+
+      def other_node(node)
+        if persisted?
+          _java_rel._other_node(node._java_node)
+        else
+          @_start_node == (node._java_node || node) ? @_end_node : @_start_node
+        end
+      end
+
+
+      def start_node
+        @_start_node ||= _java_rel && _java_rel.start_node.wrapper
+      end
+
+      def start_node=(node)
+        old = @_start_node
+        @_start_node = node
+        # TODO should raise exception if not persisted and changed
+        if old != @_start_node
+          old && old.rm_outgoing_rel(rel_type, self)
+          @_start_node.class != Neo4j::Node && @_start_node.add_outgoing_rel(rel_type, self)
+        end
+      end
+
+      def end_node
+        @_end_node ||= _java_rel && _java_rel.end_node.wrapper
+      end
+
+      def end_node=(node)
+        old = @_end_node
+        @_end_node = node
+        # TODO should raise exception if not persisted and changed
+        if old != @_end_node
+          old && old.rm_incoming_rel(rel_type, self)
+          @_end_node.class != Neo4j::Node && @_end_node.add_incoming_rel(rel_type, self)
+        end
+      end
+
+
+      def _persist_node(start_or_end_node)
+        (start_or_end_node.new_record? || start_or_end_node.relationships_changed?) ? start_or_end_node.save : true
+      end
+
+      # Reload the object from the DB
+      def reload(options = nil)
+        raise "Can't reload a none persisted node" if new_record?
+        clear_changes
+        reset_attributes
+        unless reload_from_database
+          set_deleted_properties
+          freeze
+        end
+        self
+      end
+
+
+      def reload_from_database
+        Neo4j::IdentityMap.remove_rel_by_id(id) if persisted?
+        if reloaded = self.class.load_entity(id)
+          send(:attributes=, reloaded.attributes, false)
+        end
+        reloaded
+      end
+    end
+
+  end
+end
+

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

@@ -5,7 +5,7 @@ module Neo4j
       # Instances of this class is returned from the #outgoing, #incoming and generated accessor methods:
       # has_n and has_one.
       # Notice that this class includes the Ruby Enumerable mixin.
-      # If you want to full traversal api use the wrapped java node instead (some_node._java_node.outgoing(...)).
+      # If you want to full traversal api use the core version of these methods (some_node._outgoing(...)).
       #
       class NodesDSL
         include Enumerable
@@ -19,8 +19,7 @@ module Neo4j
         # The new node and relationship will not be saved.
         # Both the relationship class and the node class can be specified with the has_n and has_one.
         #
-        # ==== Example
-        #
+        # @example
         #   class Person < Neo4j::Rails::Model
         #      has_n(:friends).to(Person).relationship(Friend)
         #      has_n(:knows)
@@ -28,13 +27,16 @@ module Neo4j
         #
         #   Person.friends.build(:name => 'kalle')  # creates a Person and Friends class.
         #   Person.knows.build(:name => 'kalle') # creates a Neo4j::Rails::Model and Neo4j::Rails::Relationship class
-        #
-        def build(attrs =  {})
+        # @param [Hash] attrs the attributes for the created node
+        # @return [Neo4j::Rails::Model]
+        def build(attrs = {})
           self << (node = @storage.build(attrs))
           node
         end
 
         # Same as #build except that the relationship and node are saved.
+        # @param (see #build)
+        # @return [Neo4j::Rails::Model]
         def create(attrs = {})
           self << (node = @storage.create(attrs))
           node.save
@@ -42,13 +44,24 @@ module Neo4j
         end
 
         # Same as #create but will raise an exception if an error (like validation) occurs.
+        # @param (see #build)
+        # @return [Neo4j::Rails::Model]
         def create!(attrs)
           self << (node = @storage.create(attrs))
           node.save!
           node
         end
 
-        # Adds a new node to the relationship
+        # Adds a new node to the relationship, no transaction is needed.
+        #
+        # @example create a relationship between two nodes
+        #   node.friends << other
+        #
+        # @example using existing nodes
+        #   node.friends = ['42', '32']
+        #
+        # @param [String, Neo4j::Rails::Model] other
+        # @return self
         def <<(other)
           if other.is_a?(String)
             # this is typically called in an assignment operator, person.friends = ['42', '32']
@@ -69,20 +82,11 @@ module Neo4j
           all.to_a
         end
 
-        # Specifies the depth of the traversal
-        def depth(d)
-          adapt_to_traverser.depth(d)
-        end
-
-        def adapt_to_traverser # :nodoc:
-          Neo4j::Traversal::Traverser.new(@storage.node, @storage.rel_type, @dir)
-        end
-
         # Returns the n:th item in the relationship.
         # This method simply traverse all relationship and returns the n:th one.
         def [](index)
           i = 0
-          each{|x| return x if i == index; i += 1}
+          each { |x| return x if i == index; i += 1 }
           nil # out of index
         end
 
@@ -94,32 +98,33 @@ module Neo4j
 
         # Find one node in the relationship.
         #
-        # ==== Example
+        # @example Declaration of the relationship used in the examples below
         #
         #   class Actor < Neo4j::Rails::Model
         #     has_n(:acted_in)
         #   end
         #
-        #    # find all child nodes
-        #    actor.acted_in.find(:all)
+        # @example find all child nodes
+        #   actor.acted_in.find(:all)
         #
-        #    # find first child node
-        #    actor.acted_in.find(:first)
+        # @example find first child node
+        #   actor.acted_in.find(:first)
         #
-        #    # find a child node by node
-        #    actor.acted_in.find(some_movie)
+        # @example find a child node by node
+        #   actor.acted_in.find(some_movie)
         #
-        #    # find a child node by id" do
-        #    actor.acted_in.find(some_movie.id)
+        # @example find a child node by id" do
+        #   actor.acted_in.find(some_movie.id)
         #
-        #    #find a child node by delegate to Enumerable#find
-        #    actor.acted_in.find{|n| n.title == 'movie_1'}
+        # @example find a child node by delegate to Enumerable#find
+        #   actor.acted_in.find{|n| n.title == 'movie_1'}
         #
+        # @return [Neo4j::Rails::Model]
         def find(*args, &block)
           return super(*args, &block) if block
-          
+
           case args.first
-            when :all, :first          
+            when :all, :first
               kind = args.shift
               send(kind, *args)
             when "0", 0
@@ -130,14 +135,14 @@ module Neo4j
               else
                 first(*args)
               end
-          end          
+          end
         end
 
         # Same as #find except that it returns an Enumerator of all nodes found.
         #
         def all(*args)
           unless args.empty?
-            enum = Enumerator.new(@storage, :each_node, @dir).find{|n| n == args.first}
+            enum = Enumerator.new(@storage, :each_node, @dir).find { |n| n == args.first }
           else
             enum = Enumerator.new(@storage, :each_node, @dir)
           end
@@ -148,7 +153,7 @@ module Neo4j
           if result = all(*args)
             if result.respond_to?(:collect) #if it's enumerable, get the first result
               result.first
-            else 
+            else
               result
             end
           else
@@ -156,36 +161,40 @@ module Neo4j
           end
         end
 
-        # Destroys all nodes (!!!) and relationship in this relatationship.
-        # Notice, if you only want to destroy the relationship use the
+        # Destroys all nodes (!) and relationship.
+        # Notice, if you only want to destroy the relationship use the #rels(:friends).destroy_all method instead.
         def destroy_all
-          each {|n| n.destroy}
+          each { |n| n.destroy }
         end
 
+        # Deletes all nodes and relationships, similar to #destroy_all
         def delete_all
-          each {|n| n.delete}
+          each { |n| n.delete }
         end
 
-        def size
-          @storage.size(@dir)
+        # Counts all relationships
+        def count
+          @storage.count(@dir)
         end
 
-        alias :length :size
+        alias :length :count
 
         def each
-          @storage.each_node(@dir) {|n| yield n} # Why passing the &block through doesn't work on JRuby 1.9?
+          @storage.each_node(@dir) { |n| yield n } # Why passing the &block through doesn't work on JRuby 1.9?
         end
 
+        # Delete relationships to the given nodes
+        # @param [Neo4j::Rails::Model] nodes a list of nodes we want to delete relationships to
         def delete(*nodes)
           @storage.destroy_rels(@dir, *nodes)
         end
 
         def empty?
-          size == 0 # TODO, performance: there are probably faster way of doing this
+          !@storage.relationships?(@dir)
         end
 
         def blank?
-          false unless size == 0
+          false unless empty?
         end
 
         def to_s
@@ -196,13 +205,32 @@ module Neo4j
           @storage.persisted?
         end
 
+
+        # These methods are using the Neo4j::Core::Traversal::Traverser which means that only persisted relationship will be seen
+        # but more advanced traversal can be performed.
+        CORE_TRAVERSAL_METHODS = [:depth, :outgoing, :incoming, :both, :expand, :depth_first, :breadth_first, :eval_paths, :unique, :expander, :prune, :filter, :include_start_node, :rels, :eval_paths]
+
+
         protected
 
+        def self.define_traversal_method(method_name)
+          class_eval <<-RUBY, __FILE__, __LINE__
+						def #{method_name}(*args, &block)
+              if block
+							  Neo4j::Core::Traversal::Traverser.new(@storage.node, @dir, @storage.rel_type).send(:"#{method_name}", *args, &block)
+              else
+              	Neo4j::Core::Traversal::Traverser.new(@storage.node, @dir, @storage.rel_type).send(:"#{method_name}", *args)
+              end
+						end
+          RUBY
+        end
+
+        CORE_TRAVERSAL_METHODS.each { |meth| define_traversal_method(meth)}
 
         def find_by_id(*args)
-          result = Enumerator.new(@storage, :each_node, @dir).find{|n| n.id.to_i == args.first.to_i}        
+          result = Enumerator.new(@storage, :each_node, @dir).find { |n| n.id.to_i == args.first.to_i }
         end
-   
+
       end
     end
   end