neo4j 5.0.15 → 5.1.0.rc.1

data/lib/neo4j/active_node/query/query_proxy_eager_loading.rb

@@ -23,6 +23,14 @@ module Neo4j
         end
 
         def with_associations(*spec)
+          invalid_association_names = spec.reject do |association_name|
+            model.associations[association_name]
+          end
+
+          if invalid_association_names.size > 0
+            fail "Invalid associations: #{invalid_association_names.join(', ')}"
+          end
+
           new_link.tap do |new_query_proxy|
             new_spec = new_query_proxy.with_associations_spec + spec
             new_query_proxy.with_associations_spec.replace(new_spec)

data/lib/neo4j/active_node/query/query_proxy_enumerable.rb

@@ -37,7 +37,11 @@ module Neo4j
 
         # When called at the end of a QueryProxy chain, it will return the resultant relationship objects intead of nodes.
         # For example, to return the relationship between a given student and their lessons:
+        #
+        # .. code-block:: ruby
+        #
         #   student.lessons.each_rel do |rel|
+        #
         # @return [Enumerable] An enumerable containing any number of applicable relationship objects.
         def each_rel(&block)
           block_given? ? each(false, true, &block) : to_enum(:each, false, true)
@@ -45,6 +49,9 @@ module Neo4j
 
         # When called at the end of a QueryProxy chain, it will return the nodes and relationships of the last link.
         # For example, to return a lesson and each relationship to a given student:
+        #
+        # .. code-block:: ruby
+        #
         #   student.lessons.each_with_rel do |lesson, rel|
         def each_with_rel(&block)
           block_given? ? each(true, true, &block) : to_enum(:each, true, true)

data/lib/neo4j/active_node/query/query_proxy_link.rb

@@ -29,10 +29,9 @@ module Neo4j
                 arg.each do |key, value|
                   if model && model.association?(key)
                     result += for_association(key, value, "n#{node_num}", model)
-
                     node_num += 1
                   else
-                    result << new(:where, ->(v, _) { {v => {key => value}} })
+                    result << new_for_key_and_value(model, key, value)
                   end
                 end
               elsif arg.is_a?(String)
@@ -42,15 +41,26 @@ module Neo4j
             end
             alias_method :for_node_where_clause, :for_where_clause
 
+            def new_for_key_and_value(model, key, value)
+              key = (key.to_sym == :id ? model.id_property_name : key)
+
+              val = if !model
+                      value
+                    elsif key == model.id_property_name && value.is_a?(Neo4j::ActiveNode)
+                      value.id
+                    else
+                      model.declared_property_manager.value_for_db(key, value)
+                    end
+
+              new(:where, ->(v, _) { {v => {key => val}} })
+            end
+
             def for_association(name, value, n_string, model)
               neo_id = value.try(:neo_id) || value
               fail ArgumentError, "Invalid value for '#{name}' condition" if not neo_id.is_a?(Integer)
 
-              dir = model.associations[name].direction
-
-              arrow = dir == :out ? '-->' : '<--'
               [
-                new(:match, ->(v, _) { "#{v}#{arrow}(#{n_string})" }),
+                new(:match, ->(v, _) { "#{v}#{model.associations[name].arrow_cypher}(#{n_string})" }),
                 new(:where, ->(_, _) { {"ID(#{n_string})" => neo_id.to_i} })
               ]
             end

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -135,6 +135,7 @@ module Neo4j
                         # support for null object pattern
                         '1 = 2'
                       end
+
           self.where(where_arg)
         end
 
@@ -203,6 +204,9 @@ module Neo4j
         # So for a `Teacher` model inheriting from a `Person` model and an `Article` model
         # if you called .as_models([Teacher, Article])
         # The where clause would look something like:
+        #
+        # .. code-block:: cypher
+        #
         #   WHERE (node_var:Teacher:Person OR node_var:Article)
         def as_models(models)
           where_clause = models.map do |model|

data/lib/neo4j/active_node/query/query_proxy_unpersisted.rb

@@ -0,0 +1,17 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyUnpersisted
+        def defer_create(other_nodes, _properties, operator)
+          key = [@association.name, [nil, nil, nil]].hash
+          @start_object.pending_associations[key] = [@association.name, operator]
+          if @start_object.association_proxy_cache[key]
+            @start_object.association_proxy_cache[key] << other_nodes
+          else
+            @start_object.association_proxy_cache[key] = [other_nodes]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/unpersisted.rb

@@ -0,0 +1,49 @@
+module Neo4j
+  module ActiveNode
+    module Unpersisted
+      def pending_associations
+        @pending_associations ||= {}
+      end
+
+      def pending_associations?
+        !@pending_associations.blank?
+      end
+
+      private
+
+      # TODO: Change this method's name.
+      # Takes the pending_associations hash, which is in the format { cache_key => [:association_name, :association_operator]},
+      # and returns them as { association_name => [[nodes_for_persistence], :operator] }
+      def pending_associations_with_nodes
+        return unless pending_associations?
+        {}.tap do |deferred_nodes|
+          pending_associations.each_pair do |cache_key, (association_name, operator)|
+            nodes_for_creation = self.persisted? ? association_proxy_cache[cache_key].select { |n| !n.persisted? } : association_proxy_cache[cache_key]
+            deferred_nodes[association_name] = [nodes_for_creation, operator]
+          end
+        end
+      end
+
+      # @param [Hash] deferred_nodes A hash created by :pending_associations_with_nodes
+      def process_unpersisted_nodes!(deferred_nodes)
+        deferred_nodes.each_pair do |k, (v, o)|
+          save_and_associate_queue(k, v, o)
+        end
+      end
+
+
+      def save_and_associate_queue(association_name, node_queue, operator)
+        association_proc = proc { |node| save_and_associate_node(association_name, node, operator) }
+        node_queue.each do |element|
+          element.is_a?(Array) ? element.each { |node| association_proc.call(node) } : association_proc.call(element)
+        end
+      end
+
+      def save_and_associate_node(association_name, node, operator)
+        node.save if node.changed? || !node.persisted?
+        fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
+        operator == :<< ? send(association_name).send(operator, node) : send(:"#{association_name}=", node)
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/validations.rb

@@ -8,7 +8,7 @@ module Neo4j
 
       # @return [Boolean] true if valid
       def valid?(context = nil)
-        context     ||= (new_record? ? :create : :update)
+        context ||= (new_record? ? :create : :update)
         super(context)
         errors.empty?
       end

data/lib/neo4j/active_rel.rb

@@ -22,6 +22,23 @@ module Neo4j
       super
     end
 
+    def inspect
+      attribute_pairs = attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }
+      attribute_descriptions = attribute_pairs.join(', ')
+      separator = ' ' unless attribute_descriptions.empty?
+
+      cypher_representation = "#{node_cypher_representation(from_node)}-[:#{type}]->#{node_cypher_representation(to_node)}"
+      "#<#{self.class.name} #{cypher_representation}#{separator}#{attribute_descriptions}>"
+    end
+
+    def node_cypher_representation(node)
+      node_class = node.class
+      id_name = node_class.id_property_name
+      labels = ':' + node_class.mapped_label_names.join(':')
+
+      "(#{labels} {#{id_name}: #{node.id.inspect}})"
+    end
+
     def neo4j_obj
       _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
     end

data/lib/neo4j/active_rel/persistence.rb

@@ -47,7 +47,14 @@ module Neo4j::ActiveRel
 
       # Same as #create, but raises an error if there is a problem during save.
       def create!(*args)
-        fail RelInvalidError, self unless create(*args)
+        props = args[0] || {}
+        relationship_props = extract_association_attributes!(props) || {}
+        new(props).tap do |obj|
+          relationship_props.each do |prop, value|
+            obj.send("#{prop}=", value)
+          end
+          obj.save!
+        end
       end
     end
 
@@ -70,9 +77,7 @@ module Neo4j::ActiveRel
       "Node class was #{node.class} (#{node.class.object_id}), expected #{type_class} (#{type_class.object_id})"
     end
 
-    def _create_rel(from_node, to_node, *args)
-      props = self.class.default_property_values(self)
-      props.merge!(args[0]) if args[0].is_a?(Hash)
+    def _create_rel(from_node, to_node, props = {})
       set_classname(props, true)
 
       if from_node.id.nil? || to_node.id.nil?
@@ -91,7 +96,7 @@ module Neo4j::ActiveRel
     end
 
     def create_method
-      self.class.unique? ? :create_unique : :create
+      self.class.creates_unique? ? :create_unique : :create
     end
   end
 end

data/lib/neo4j/active_rel/property.rb

@@ -19,8 +19,8 @@ module Neo4j::ActiveRel
       self.class._type
     end
 
-    def initialize(attributes = {}, options = {})
-      super(attributes, options)
+    def initialize(attributes = nil)
+      super(attributes)
       send_props(@relationship_props) unless @relationship_props.nil?
     end
 
@@ -28,6 +28,7 @@ module Neo4j::ActiveRel
       # Extracts keys from attributes hash which are relationships of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
+        return if attributes.blank?
         {}.tap do |relationship_props|
           attributes.each_key do |key|
             relationship_props[key] = attributes.delete(key) if [:from_node, :to_node].include?(key)
@@ -55,12 +56,23 @@ module Neo4j::ActiveRel
         Neo4j::Node.load(id)
       end
 
+      def creates_unique
+        @creates_unique = true
+      end
+
       def creates_unique_rel
-        @unique = true
+        warning = <<-WARNING
+creates_unique_rel() is deprecated and will be removed from future releases,
+use creates_unique() instead.
+WARNING
+
+        ActiveSupport::Deprecation.warn(warning, caller)
+
+        creates_unique
       end
 
-      def unique?
-        !!@unique
+      def creates_unique?
+        !!@creates_unique
       end
     end
 

data/lib/neo4j/railtie.rb

@@ -11,7 +11,6 @@ module Neo4j
     end
 
     rake_tasks do
-      load 'neo4j/tasks/neo4j_server.rake'
       load 'neo4j/tasks/migration.rake'
     end
 
@@ -71,6 +70,8 @@ module Neo4j
     def register_neo4j_cypher_logging
       return if @neo4j_cypher_logging_registered
 
+      Neo4j::Core::Query.pretty_cypher = Neo4j::Config[:pretty_logged_cypher_queries]
+
       Neo4j::Server::CypherSession.log_with do |message|
         (Neo4j::Config[:logger] || Rails.logger).info message
       end

data/lib/neo4j/shared/declared_property_manager.rb

@@ -113,6 +113,16 @@ module Neo4j::Shared
       @upstream_primitives ||= {}
     end
 
+    def value_for_db(key, value)
+      return value unless registered_properties[key]
+      convert_property(key, value, :to_db)
+    end
+
+    def value_for_ruby(key, value)
+      return unless registered_properties[key]
+      convert_property(key, value, :to_ruby)
+    end
+
     protected
 
     # Prevents repeated calls to :_attribute_type, which isn't free and never changes.

data/lib/neo4j/shared/initialize.rb

@@ -12,16 +12,16 @@ module Neo4j::Shared
     private
 
     def convert_and_assign_attributes(properties)
-      @attributes ||= self.class.attributes_nil_hash.dup
+      @attributes ||= Hash[self.class.attributes_nil_hash]
       stringify_attributes!(@attributes, properties)
-      self.default_properties = properties
+      self.default_properties = properties if respond_to?(:default_properties=)
       self.class.declared_property_manager.convert_properties_to(self, :ruby, @attributes)
     end
 
     def stringify_attributes!(attr, properties)
       properties.each_pair do |k, v|
         key = self.class.declared_property_manager.string_key(k)
-        attr[key] = v
+        attr[key.freeze] = v
       end
     end
   end

data/lib/neo4j/shared/property.rb

@@ -17,15 +17,14 @@ module Neo4j::Shared
 
     # TODO: Remove the commented :super entirely once this code is part of a release.
     # It calls an init method in active_attr that has a very negative impact on performance.
-    def initialize(attributes = {}, _options = nil)
-      attributes = process_attributes(attributes) unless attributes.empty?
+    def initialize(attributes = nil)
+      attributes = process_attributes(attributes)
       @relationship_props = self.class.extract_association_attributes!(attributes)
       writer_method_props = extract_writer_methods!(attributes)
       validate_attributes!(attributes)
-      send_props(writer_method_props) unless writer_method_props.empty?
+      send_props(writer_method_props)
 
       @_persisted_obj = nil
-      # super(attributes, options)
     end
 
     # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
@@ -36,22 +35,8 @@ module Neo4j::Shared
     end
     alias_method :[], :read_attribute
 
-    def default_properties=(properties)
-      default_property_keys = self.class.default_properties_keys
-      @default_properties = properties.select { |key| default_property_keys.include?(key) }
-    end
-
-    def default_property(key)
-      default_properties[key.to_sym]
-    end
-
-    def default_properties
-      @default_properties ||= Hash.new(nil)
-      # keys = self.class.default_properties.keys
-      # _persisted_obj.props.reject{|key| !keys.include?(key)}
-    end
-
     def send_props(hash)
+      return hash if hash.blank?
       hash.each { |key, value| self.send("#{key}=", value) }
     end
 
@@ -70,13 +55,13 @@ module Neo4j::Shared
     # Changes attributes hash to remove relationship keys
     # Raises an error if there are any keys left which haven't been defined as properties on the model
     def validate_attributes!(attributes)
-      return attributes if attributes.empty?
+      return attributes if attributes.blank?
       invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
       fail UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
     end
 
     def extract_writer_methods!(attributes)
-      return attributes if attributes.empty?
+      return attributes if attributes.blank?
       {}.tap do |writer_method_props|
         attributes.each_key do |key|
           writer_method_props[key] = attributes.delete(key) if self.respond_to?("#{key}=")
@@ -86,6 +71,7 @@ module Neo4j::Shared
 
     # Gives support for Rails date_select, datetime_select, time_select helpers.
     def process_attributes(attributes = nil)
+      return attributes if attributes.blank?
       multi_parameter_attributes = {}
       new_attributes = {}
       attributes.each_pair do |key, value|
@@ -179,36 +165,6 @@ module Neo4j::Shared
         @_declared_property_manager ||= DeclaredPropertyManager.new(self)
       end
 
-      # TODO: Move this to the DeclaredPropertyManager
-      def default_property(name, &block)
-        reset_default_properties(name) if default_properties.respond_to?(:size)
-        default_properties[name] = block
-      end
-
-      # @return [Hash<Symbol,Proc>]
-      def default_properties
-        @default_property ||= {}
-      end
-
-      def default_properties_keys
-        @default_properties_keys ||= default_properties.keys
-      end
-
-      def reset_default_properties(name_to_keep)
-        default_properties.each_key do |property|
-          @default_properties_keys = nil
-          undef_method(property) unless property == name_to_keep
-        end
-        @default_properties_keys = nil
-        @default_property = {}
-      end
-
-      def default_property_values(instance)
-        default_properties.each_with_object({}) do |(key, block), result|
-          result[key] = block.call(instance)
-        end
-      end
-
       def attribute!(name, options = {})
         super(name, options)
         define_method("#{name}=") do |value|