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

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

@@ -1,51 +1,128 @@
 module Neo4j
-	module Rails
-		module Mapping
-			module Property
-				extend ActiveSupport::Concern
-					
-				module ClassMethods
-					# Handles options for the property
-					#
-					# Set the property type 				:type => Time
-					# Set a default  								:default => "default"
-					# Property must be there  			:null => false
-					# Property has a length limit  	:limit => 128
-					def property(*args)
-						options = args.extract_options!
-						args.each do |property_sym|
-							property_setup(property_sym, options)
-						end
-					end
-					
-					protected
-					def property_setup(property, options)
-						_decl_props[property] = options
-						handle_property_options_for(property, options)
-						define_property_methods_for(property, options)
-					end
-					
-					def handle_property_options_for(property, options)
-						attribute_defaults[property.to_s] = options[:default] if options.has_key?(:default)
-						
+  module Rails
+    module Mapping
+      module Property
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def has_n(*args)
+            options = args.extract_options!
+            define_has_n_methods_for(args.first, options)
+          end
+
+          def has_one(*args)
+            options = args.extract_options!
+            define_has_one_methods_for(args.first, options)
+          end
+
+
+          def define_has_one_methods_for(rel_type, options)
+            unless method_defined?(rel_type)
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    storage.single_node(dsl.dir)
+                end
+              RUBY
+            end
+
+            unless method_defined?("#{rel_type}_rel")
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}_rel
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    storage.single_relationship(dsl.dir)
+                end
+              RUBY
+            end
+
+            unless method_defined?("#{rel_type}=".to_sym)
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}=(other)
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    rel = storage.single_relationship(dsl.dir)
+                    rel && rel.destroy
+                    storage.create_relationship_to(other, dsl.dir)
+                end
+              RUBY
+            end
+            _decl_rels[rel_type.to_sym] = Neo4j::HasN::DeclRelationshipDsl.new(rel_type, true, self)
+          end
+
+          def define_has_n_methods_for(rel_type, options)
+            unless method_defined?(rel_type)
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                    NodesDSL.new(storage, dsl.dir)
+                end
+              RUBY
+            end
+
+            unless method_defined?("#{rel_type}_rels".to_sym)
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}_rels
+                    dsl = _decl_rels_for(:'#{rel_type}')
+                    storage = _create_or_get_storage_for_decl_rels(dsl)
+                  RelsDSL.new(storage, dsl.dir)
+                end
+              RUBY
+            end
+
+            instance_eval <<-RUBY, __FILE__, __LINE__
+              def #{rel_type}
+                _decl_rels[:'#{rel_type}'].rel_type.to_s
+              end
+            RUBY
+
+            _decl_rels[rel_type.to_sym] = Neo4j::HasN::DeclRelationshipDsl.new(rel_type, false, self)
+          end
+
+          # Handles options for the property
+          #
+          # Set the property type 				:type => Time
+          # Set a default  								:default => "default"
+          # Property must be there  			:null => false
+          # Property has a length limit  	:limit => 128
+          def property(*args)
+            options = args.extract_options!
+            args.each do |property_sym|
+              property_setup(property_sym, options)
+            end
+          end
+
+          protected
+          def property_setup(property, options)
+            _decl_props[property] = options
+            handle_property_options_for(property, options)
+            define_property_methods_for(property, options)
+          end
+
+          def handle_property_options_for(property, options)
+            attribute_defaults[property.to_s] = options[:default] if options.has_key?(:default)
+
             if options.has_key?(:null) && options[:null] === false
               validates(property, :non_nil => true, :on => :create)
               validates(property, :non_nil => true, :on => :update)
             end
 						validates(property, :length => { :maximum => options[:limit] }) if options[:limit]
 					end
-					
+
 					def define_property_methods_for(property, options)
 						unless method_defined?(property)
 							class_eval <<-RUBY, __FILE__, __LINE__
 								def #{property}
 									send(:[], "#{property}")
 								end
-							RUBY
-						end
-						
-						unless method_defined?("#{property}=".to_sym)
-							class_eval <<-RUBY, __FILE__, __LINE__
+              RUBY
+            end
+
+            unless method_defined?("#{property}=".to_sym)
+              class_eval <<-RUBY, __FILE__, __LINE__
 								def #{property}=(value)
 									send(:[]=, "#{property}", value)
 								end

data/lib/neo4j/rails/model.rb

@@ -3,6 +3,7 @@ module Neo4j
     class Model
       include Neo4j::NodeMixin
 
+
       # Initialize a Node with a set of properties (or empty if nothing is passed)
       def initialize(attributes = {})
         reset_attributes
@@ -14,10 +15,15 @@ module Neo4j
         neo_id.nil? ? nil : neo_id.to_s
       end
 
+      def hash
+        persisted? ? _java_entity.neo_id.hash : super
+      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
@@ -57,6 +63,10 @@ module Neo4j
           end
         end
 
+        def entity_load(id)
+          Neo4j::Node.load(id)
+        end
+        
         ##
         # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling
         # dates and times from the database. This is set to :local by default.

data/lib/neo4j/rails/persistence.rb

@@ -5,7 +5,7 @@ module Neo4j
 			
 			included do
 				extend TxMethods
-				tx_methods :destroy, :create, :update, :update_nested_attributes
+				tx_methods :destroy, :create, :update, :update_nested_attributes, :delete
 			end
 
 			# Persist the object to the database.  Validations and Callbacks are included
@@ -53,7 +53,7 @@ module Neo4j
 			
 			# Returns true if the object was destroyed.
 			def destroyed?()
-        @_deleted
+        @_deleted || Neo4j::Node._load(id).nil?
       end
 			
 			# Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
@@ -108,13 +108,19 @@ module Neo4j
         # Initialize a model and set a bunch of attributes at the same time.  Returns
         # the object whether saved successfully or not.
         def create(*args)
-          new(*args).tap { |o| o.save }
+          new(*args).tap do |o|
+            yield o if block_given?
+            o.save
+          end
         end
 
         # Same as #create, but raises an error if there is a problem during save.
         # Returns the object whether saved successfully or not.
         def create!(*args)
-          new(*args).tap { |o| o.save! }
+          new(*args).tap do |o|
+            yield o if block_given?
+            o.save!
+          end
         end
 
         # Destroy each node in turn.  Runs the destroy callbacks for each node.

data/lib/neo4j/rails/rails.rb

@@ -4,6 +4,7 @@ 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'
@@ -12,8 +13,11 @@ require 'neo4j/rails/timestamps'
 require 'neo4j/rails/serialization'
 require 'neo4j/rails/attributes'
 require 'neo4j/rails/persistence'
-require 'neo4j/rails/relationships/mapper'
-require 'neo4j/rails/relationships/relationship'
+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/lucene_connection_closer'
+require 'neo4j/rails/rel_persistence'
+require 'neo4j/rails/relationship'

data/lib/neo4j/rails/rel_persistence.rb

@@ -0,0 +1,231 @@
+module Neo4j
+	module Rails
+		module RelPersistence
+			extend ActiveSupport::Concern
+
+      included do
+        extend TxMethods
+        tx_methods :destroy, :create, :update, :delete
+      end
+
+
+			# Persist the object to the database.  Validations and Callbacks are included
+			# by default but validation can be disabled by passing :validate => false
+			# to #save.
+      def save(*)
+      	create_or_update
+      end
+
+      # Persist the object to the database.  Validations and Callbacks are included
+			# by default but validation can be disabled by passing :validate => false
+			# to #save!.
+			#
+			# Raises a RecordInvalidError if there is a problem during save.
+      def save!(*args)
+				unless save(*args)
+					raise RecordInvalidError.new(self)
+				end
+			end
+
+			# Updates a single attribute and saves the record.
+			# This is especially useful for boolean flags on existing records. Also note that
+			#
+			# * Validation is skipped.
+			# * Callbacks are invoked.
+			# * Updates all the attributes that are dirty in this object.
+			#
+			def update_attribute(name, value)
+				respond_to?("#{name}=") ? send("#{name}=", value) : self[name] = value
+				save(:validate => false)
+			end
+
+			# Removes the node from Neo4j and freezes the object.
+			def destroy
+				delete
+				freeze
+			end
+
+			# Same as #destroy but doesn't run destroy callbacks and doesn't freeze
+			# the object
+			def delete
+				del unless new_record?
+				set_deleted_properties
+			end
+
+			# Returns true if the object was destroyed.
+			def destroyed?()
+        @_deleted || Neo4j::Relationship._load(id).nil?
+      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
+
+      # Same as #update_attributes, but raises an exception if saving fails.
+      def update_attributes!(attributes)
+        self.attributes = attributes
+        save!
+      end
+
+      # Reload the object from the DB.
+      def reload(options = nil)
+        clear_changes
+        reset_attributes
+        unless reload_from_database
+          set_deleted_properties
+          freeze
+        end
+        self
+      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
+
+      # Returns true if the record hasn't been saved to Neo4j yet.
+      def new_record?
+        _java_rel.nil?
+      end
+
+      alias :new? :new_record?
+
+      # Freeze the properties hash.
+			def freeze
+				@properties.freeze; self
+			end
+
+      # Returns +true+ if the properties hash has been frozen.
+      def frozen?
+        reload
+        @properties.frozen?
+      end
+
+      module ClassMethods
+        # Initialize a model and set a bunch of attributes at the same time.  Returns
+        # the object whether saved successfully or not.
+        def create(*args)
+          new(*args).tap do |o|
+            yield o if block_given?
+            o.save
+          end
+        end
+
+        # Same as #create, but raises an error if there is a problem during save.
+        # Returns the object whether saved successfully or not.
+        def create!(*args)
+          new(*args).tap do |o|
+            yield o if block_given?
+            o.save!
+          end
+        end
+
+        # Destroy each node in turn.  Runs the destroy callbacks for each node.
+        def destroy_all
+          all.each do |n|
+            n.destroy
+          end
+        end
+      end
+
+      protected
+      def create_or_update
+        result = persisted? ? update : create
+        unless result != false
+          Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running?
+          false
+        else
+          true
+        end
+      end
+
+      def update
+        write_changed_attributes
+        clear_changes
+        true
+      end
+
+      def create()
+        # prevent calling create twice
+        @start_node.rm_outgoing_rel(type, self)
+        @end_node.rm_incoming_rel(type, self)
+
+        _persist_start_node
+        _persist_end_node
+
+        @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
+        init_on_create
+        clear_changes
+        true
+      end
+
+      def _load(id)
+        Neo4j::Relationship.load(id)
+      end
+
+      def _persist_start_node
+        unless @start_node.persisted? || @start_node.save
+          # not sure if this can happen - probably a bug
+          raise "Can't save start_node #{@start_node} id #{@start_node.id}"
+        end
+      end
+
+      def _persist_end_node
+        unless @end_node.persisted? || @end_node.save
+          raise "Can't save end_node #{@end_node} id #{@end_node.id}"
+        end
+      end
+
+      def init_on_create(*)
+        #self["_classname"] = self.class.to_s
+        write_default_attributes
+        write_changed_attributes
+        @_java_rel[:_classname] = self.class.to_s
+      end
+
+      def reset_attributes
+        @properties = {}
+      end
+
+      def reload_from_database
+        if reloaded = self.class.load(id)
+          send(:attributes=, reloaded.attributes, false)
+        end
+        reloaded
+      end
+
+      def set_deleted_properties
+        @_deleted   = true
+        @_persisted = false
+      end
+
+      # Ensure any defaults are stored in the DB
+      def write_default_attributes
+        attribute_defaults.each do |attribute, value|
+          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class)) unless changed_attributes.has_key?(attribute) || _java_rel.has_property?(attribute)
+        end
+      end
+
+      # Write attributes to the Neo4j DB only if they're altered
+      def write_changed_attributes
+        @properties.each do |attribute, value|
+          write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
+        end
+      end
+
+      class RecordInvalidError < RuntimeError
+        attr_reader :record
+
+        def initialize(record)
+          @record = record
+          super(@record.errors.full_messages.join(", "))
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/neo4j/rails/relationship.rb

@@ -0,0 +1,126 @@
+module Neo4j
+  module Rails
+    class Relationship
+      include Neo4j::RelationshipMixin
+
+      attr_reader :type
+
+      index :_classname
+
+      # Initialize a Node with a set of properties (or empty if nothing is passed)
+      def initialize(*args)
+        @type = args[0]
+        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
+      
+      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
+
+      # --------------------------------------
+      # 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 Timestamps # handle created_at, updated_at timestamp properties
+      include Validations # enable validations
+      include Callbacks # enable callbacks
+      include Finders # ActiveRecord style find
+    end
+
+  end
+end