neo4j 1.2.6-java → 2.0.0.alpha.3-java

data/lib/neo4j/rails/compositions.rb

@@ -206,6 +206,14 @@ module Neo4j
         #               :constructor => Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
         #               :converter => Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
         #
+        def is_composed_property?(property)
+          composed_properties.contains(property)
+        end
+
+        def composed_properties
+          @composed_properties ||= java.util.HashSet.new
+        end
+
         def composed_of(part_id, options = {})
           options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
 
@@ -216,7 +224,7 @@ module Neo4j
           allow_nil   = options[:allow_nil]   || false
           constructor = options[:constructor] || :new
           converter   = options[:converter]
-
+          composed_properties.add(name.to_sym)
           reader_method(name, class_name, mapping, allow_nil, constructor)
           writer_method(name, class_name, mapping, allow_nil, converter)
         end

data/lib/neo4j/rails/finders.rb

@@ -76,7 +76,7 @@ module Neo4j
             when "0", 0, nil
               nil
             else
-              if ((args.first.is_a?(Integer) || args.first.is_a?(String)) && args.first.to_i > 0)
+              if convertable_to_id?(args.first)
                 find_with_ids(*args)
               else
                 first(*args)
@@ -167,6 +167,10 @@ module Neo4j
           condition.is_a?(Hash) && condition[:id]
         end
 
+        def convertable_to_id?(value)
+          return false unless value
+          value.is_a?(Integer) || (value.is_a?(String) && value =~ /^[+-]?\d+$/)
+        end
 
         def conditions_in?(*args)
           return false if args.empty?

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

@@ -55,8 +55,7 @@ module Neo4j
                 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.destroy_single_relationship(dsl.dir)
                     storage.create_relationship_to(other, dsl.dir)
                 end
               RUBY
@@ -76,9 +75,21 @@ module Neo4j
             end
 
             unless method_defined?("#{rel_type}=".to_sym)
+
+              # TODO: This is a temporary fix for allowing running neo4j with Formtastic, issue 109
+              # A better solution might be to implement accept_ids for has_n relationship and
+              # make sure (somehow) that Formtastic uses the _ids methods.
+
               class_eval <<-RUBY, __FILE__, __LINE__
                 def #{rel_type}=(nodes)
-                    self.#{rel_type}_rels.destroy_all
+                    if nodes.is_a?(Array) && nodes.first.is_a?(String)
+                      if nodes.first.blank?
+                        self.#{rel_type}_rels.destroy_all
+                        nodes.shift
+                      end
+                    else
+                      self.#{rel_type}_rels.destroy_all
+                    end
                     association = self.#{rel_type}
                     nodes.each { |node| association << node }
                 end
@@ -106,10 +117,10 @@ module Neo4j
 
           # 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
+          # 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|
@@ -132,39 +143,41 @@ module Neo4j
               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
+            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__
-								def #{property}=(value)
-									send(:[]=, "#{property}", value)
-								end
-							RUBY
-						end
-					end
+                def #{property}=(value)
+                  send(:[]=, "#{property}", value)
+                end
+              RUBY
+            end
+          end
 
           def define_property_before_type_cast_methods_for(property, options)
             property_before_type_cast = "#{property}_before_type_cast"
             class_eval <<-RUBY, __FILE__, __LINE__
-              attr_writer :#{property_before_type_cast}
+              def #{property_before_type_cast}=(value)
+                @properties_before_type_cast[:#{property}]=value
+              end
 
               def #{property_before_type_cast}
-                instance_variable_defined?(:@#{property_before_type_cast}) ? @#{property_before_type_cast} : self.#{property}
+                @properties_before_type_cast.has_key?(:#{property}) ? @properties_before_type_cast[:#{property}] : self.#{property}
               end
             RUBY
           end
-				end
-			end
-		end
-	end
+        end
+      end
+    end
+  end
 end

data/lib/neo4j/rails/model.rb

@@ -48,6 +48,7 @@ module Neo4j
 
       # Initialize a Node with a set of properties (or empty if nothing is passed)
       def initialize(attributes = {})
+        @properties_before_type_cast=java.util.HashMap.new
         reset_attributes
         clear_relationships
         self.attributes = attributes if attributes.is_a?(Hash)
@@ -269,6 +270,7 @@ module Neo4j
       include Finders # ActiveRecord style find
       include Relationships # for none persisted relationships
       include Compositions
+      include AcceptId
     end
   end
 end

data/lib/neo4j/rails/observer.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/class/attribute_accessors'
+
 module Neo4j
   module Rails
     # Observer classes respond to life cycle callbacks to implement trigger-like
@@ -86,11 +88,26 @@ module Neo4j
     # In order to activate an observer, list it in the +config.neo4j.observers+
     # configuration setting in your +config/application.rb+ file.
     #
-    #   config.neo4j.observers = :comment_observer, :signup_observer
+    #   config.neo4j.observers = [:comment_observer, :signup_observer]
     #
     # Observers will not be invoked unless you define them in your
     # application configuration.
     #
+    # During testing you may want (and probably should) to disable all the observers.
+    # Most of the time you don't want any kind of emails to be sent when creating objects.
+    # This should improve the speed of your tests and isolate the models and observer logic.
+    #
+    # For example, the following will disable the observers in RSpec:
+    #
+    #   config.before(:each) { Neo4j::Rails::Observer.disable_observers }
+    #
+    # But if you do want to run a particular observer(s) as part of the test,
+    # you can temporarily enable it:
+    #
+    #   Neo4j::Rails::Observer.with_observers(:user_recorder, :account_observer) do
+    #     # Any code here will work with observers enabled
+    #   end
+    #
     # == Loading
     #
     # Observers register themselves with the model class that they observe,
@@ -113,6 +130,48 @@ module Neo4j
         super and observed_descendants.each { |klass| add_observer!(klass) }
       end
 
+      cattr_accessor :default_observers_enabled, :observers_enabled
+
+      # TODO: Add docs
+      class << self
+        # Enables all observers (default behavior)
+        def enable_observers
+          self.default_observers_enabled = true
+        end
+
+        # Disables all observers
+        def disable_observers
+          self.default_observers_enabled = false
+        end
+
+        # Run a block with a specific set of observers enabled
+        def with_observers(*observer_syms)
+          self.observers_enabled = Array(observer_syms).map do |o|
+            o.respond_to?(:instance) ? o.instance : o.to_s.classify.constantize.instance
+          end
+          yield
+        ensure
+          self.observers_enabled = []
+        end
+
+        # Determines whether an observer is enabled.  Either:
+        # - All observers are enabled OR
+        # - The observer is in the whitelist
+        def observer_enabled?(observer)
+          default_observers_enabled or self.observers_enabled.include?(observer)
+        end
+      end
+
+
+      # Determines whether this observer should be run
+      def observer_enabled?
+        self.class.observer_enabled?(self)
+      end
+
+      # By default, enable all observers
+      enable_observers
+      self.observers_enabled = []
+
       protected
 
       # Get all the child observers.
@@ -149,7 +208,7 @@ module Neo4j
             callback_meth = :"_notify_#{observer_name}_for_#{callback}"
             unless klass.respond_to?(callback_meth)
               klass.send(:define_method, callback_meth) do |&block|
-                observer.send(callback, self, &block)
+                observer.send(callback, self, &block) if observer.observer_enabled?
               end
               klass.send(callback, callback_meth)
             end

data/lib/neo4j/rails/persistence.rb

@@ -1,62 +1,62 @@
 module Neo4j
-	module Rails
-		module Persistence
-			extend ActiveSupport::Concern
-
-			included do
-				extend TxMethods
-				tx_methods :destroy, :create, :update, :update_nested_attributes, :delete, :update_attributes, :update_attributes!
-			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.
+  module Rails
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        extend TxMethods
+        tx_methods :destroy, :create, :update, :update_nested_attributes, :delete, :update_attributes, :update_attributes!
+      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
+        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.
+      # 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?()
+        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::Node._load(id).nil?
       end
 
-			# Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
+      # 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
@@ -95,9 +95,9 @@ module Neo4j
       alias :new? :new_record?
 
       # Freeze the properties hash.
-			def freeze
-				@properties.freeze; self
-			end
+      def freeze
+        @properties.freeze; self
+      end
 
       # Returns +true+ if the properties hash has been frozen.
       def frozen?
@@ -162,7 +162,7 @@ module Neo4j
       end
 
       def init_on_create(*)
-        self["_classname"] = self.class.to_s
+        self._classname = self.class.to_s
         write_default_attributes
         write_changed_attributes
         write_changed_relationships
@@ -190,7 +190,7 @@ module Neo4j
       # 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_node.has_property?(attribute)
+          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class, false)) unless changed_attributes.has_key?(attribute) || _java_node.has_property?(attribute)
         end
       end
 
@@ -262,7 +262,7 @@ module Neo4j
           super(@record.errors.full_messages.join(", "))
         end
       end
-		end
-	end
+    end
+  end
 end
 

data/lib/neo4j/rails/rails.rb

@@ -11,6 +11,7 @@ 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'

data/lib/neo4j/rails/railtie.rb

@@ -15,7 +15,10 @@ module Neo4j
     # Starting Neo after :load_config_initializers allows apps to
     # register migrations in config/initializers
     initializer "neo4j.start", :after => :load_config_initializers do |app|
-      Neo4j::Config.setup.merge!(app.config.neo4j.to_hash)
+      cfg = app.config.neo4j
+      # Set Rails specific defaults
+      cfg.storage_path = "#{app.config.root}/db/neo4j-#{::Rails.env}" unless cfg.storage_path
+      Neo4j::Config.setup.merge!(cfg.to_hash)
     end
 
     # Instantitate any registered observers after Rails initialization and

data/lib/neo4j/rails/rel_persistence.rb

@@ -151,17 +151,20 @@ module Neo4j
       def create()
         begin
           # prevent calling create twice
-          @start_node.rm_outgoing_rel(type, self)
-          @end_node.rm_incoming_rel(type, self)
+          @start_node.add_unpersisted_outgoing_rel(type, self)
+          @end_node.add_unpersisted_incoming_rel(type, self)
 
-          _persist_start_node
-          _persist_end_node
+          return unless _persist_start_node && _persist_end_node
 
           @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
           Neo4j::IdentityMap.add(@_java_rel, self)
           init_on_create
           clear_changes
-        end unless @end_node.nil?
+
+          @start_node.rm_unpersisted_outgoing_rel(type, self)
+          @end_node.rm_unpersisted_incoming_rel(type, self)
+
+        end unless @end_node.nil? or @start_node.nil?
         true
       end
 
@@ -170,18 +173,14 @@ module Neo4j
       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
+        (!@start_node.persisted? || @start_node.relationships_changed?) ? @start_node.save : true
       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_node.persisted? || @end_node.relationships_changed?) ? @end_node.save : true
       end
 
+
       def init_on_create(*)
         #self["_classname"] = self.class.to_s
         write_default_attributes

data/lib/neo4j/rails/relationship.rb

@@ -21,7 +21,8 @@ module Neo4j
 
       # Initialize a Node with a set of properties (or empty if nothing is passed)
       def initialize(*args)
-        @type = args[0]
+        @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]
@@ -39,11 +40,15 @@ module Neo4j
 
 
       alias_method :get_other_node, :other_node # so it looks like the java version
-      
+
+      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
@@ -111,7 +116,7 @@ module Neo4j
         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

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

@@ -9,7 +9,6 @@ module Neo4j
       #
       class NodesDSL
         include Enumerable
-        include Neo4j::Paginate
 
         def initialize(storage, dir)
           @storage = storage
@@ -51,7 +50,14 @@ module Neo4j
 
         # Adds a new node to the relationship
         def <<(other)
-          @storage.create_relationship_to(other, @dir)
+          if other.is_a?(String)
+            # this is typically called in an assignment operator, person.friends = ['42', '32']
+            node = Neo4j::Node.load(other)
+            @storage.create_relationship_to(node, @dir) unless all.include?(node)
+          else
+            # allow multiple relationships to the same node
+            @storage.create_relationship_to(other, @dir)
+          end
           self
         end
 
@@ -166,8 +172,8 @@ module Neo4j
 
         alias :length :size
 
-        def each(&block)
-          @storage.each_node(@dir, &block)
+        def each
+          @storage.each_node(@dir) {|n| yield n} # Why passing the &block through doesn't work on JRuby 1.9?
         end
 
         def delete(*nodes)
@@ -185,7 +191,11 @@ module Neo4j
         def to_s
           "Node dir: #{@dir}, #{@storage}"
         end
-        
+
+        def rel_changed?
+          @storage.persisted?
+        end
+
         protected
 
 

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

@@ -30,6 +30,9 @@ module Neo4j
         @_relationships[decl_rels.rel_type.to_sym] ||= Storage.new(self, decl_rels.rel_type, decl_rels)
       end
 
+      def _storage_for(rel_type) #:nodoc:
+        @_relationships[rel_type.to_sym]
+      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
@@ -66,8 +69,12 @@ module Neo4j
       #   node.rels(:foo) #=> [node2] - incoming and outgoing
       #
       def rels(*rel_types)
-        storage = _create_or_get_storage(rel_types.first)
-        RelsDSL.new(storage)
+        if rel_types.empty?
+          AllRelsDsl.new(@_relationships, _java_node)
+        else
+          storage = _create_or_get_storage(rel_types.first)
+          RelsDSL.new(storage)
+        end
       end
 
       def add_outgoing_rel(rel_type, rel) #:nodoc:
@@ -86,6 +93,39 @@ module Neo4j
         _create_or_get_storage(rel_type).rm_outgoing_rel(rel)
       end
 
+      def rm_outgoing_rel(rel_type, rel) #:nodoc:
+        _create_or_get_storage(rel_type).rm_outgoing_rel(rel)
+      end
+
+      def add_unpersisted_incoming_rel(rel_type, rel) #:nodoc
+        if (storage = _create_or_get_storage(rel_type))
+          # move the relationship since we are now about to store the relationship
+          storage.add_unpersisted_incoming_rel(rel)
+          storage.rm_incoming_rel(rel)
+        end
+      end
+
+      def add_unpersisted_outgoing_rel(rel_type, rel) #:nodoc
+        if (storage = _create_or_get_storage(rel_type))
+          # move the relationship since we are now about to store the relationship
+          storage.add_unpersisted_outgoing_rel(rel)
+          storage.rm_outgoing_rel(rel)
+        end
+      end
+
+      def rm_unpersisted_outgoing_rel(rel_type, rel)  #:nodoc
+        if (storage = _storage_for(rel_type))
+          storage.rm_unpersisted_outgoing_rel(rel)
+        end
+      end
+
+      def rm_unpersisted_incoming_rel(rel_type, rel)  #:nodoc
+        if (storage = _storage_for(rel_type))
+          storage.rm_unpersisted_incoming_rel(rel)
+        end
+      end
+
+
     end
   end
 end