neo4j 5.0.15 → 5.1.0.rc.1

data/lib/neo4j/active_node/has_n/association.rb

@@ -6,6 +6,7 @@ module Neo4j
       class Association
         include Neo4j::Shared::RelTypeConverters
         include Neo4j::ActiveNode::Dependent::AssociationMethods
+        include Neo4j::ActiveNode::HasN::AssociationCypherMethods
 
         attr_reader :type, :name, :relationship, :direction, :dependent, :model_class
 
@@ -29,7 +30,9 @@ module Neo4j
 
         def refresh_model_class!
           @pending_model_refresh = @target_classes_or_nil = nil
-          @model_class = @model_class.name.constantize if @model_class
+
+          # Using #to_s on purpose here to take care of classes/strings/symbols
+          @model_class = @model_class.to_s.constantize if @model_class
         end
 
         def queue_model_refresh!
@@ -49,12 +52,6 @@ module Neo4j
           end
         end
 
-        # Return cypher partial query string for the relationship part of a MATCH (arrow / relationship definition)
-        def arrow_cypher(var = nil, properties = {}, create = false, reverse = false)
-          validate_origin!
-          direction_cypher(get_relationship_cypher(var, properties, create), create, reverse)
-        end
-
         def pending_model_refresh?
           !!@pending_model_refresh
         end
@@ -110,9 +107,12 @@ module Neo4j
 
         def relationship_type(create = false)
           case
-          when relationship_class then relationship_class_type
-          when @relationship_type then @relationship_type
-          when @origin then origin_type
+          when relationship_class
+            relationship_class_type
+          when @relationship_type
+            @relationship_type
+          when @origin
+            origin_type
           else
             (create || exceptional_target_class?) && decorated_rel_type(@name)
           end
@@ -148,14 +148,6 @@ module Neo4j
           Neo4j::Config.association_model_namespace_string
         end
 
-        def direction_cypher(relationship_cypher, create, reverse = false)
-          case get_direction(create, reverse)
-          when :out then "-#{relationship_cypher}->"
-          when :in then "<-#{relationship_cypher}-"
-          when :both then "-#{relationship_cypher}-"
-          end
-        end
-
         def get_direction(create, reverse = false)
           dir = (create && @direction == :both) ? :out : @direction
           if reverse
@@ -169,21 +161,6 @@ module Neo4j
           end
         end
 
-        def get_relationship_cypher(var, properties, create)
-          relationship_type = relationship_type(create)
-          relationship_name_cypher = ":`#{relationship_type}`" if relationship_type
-          properties_string = get_properties_string(properties)
-
-          "[#{var}#{relationship_name_cypher}#{properties_string}]"
-        end
-
-        def get_properties_string(properties)
-          p = properties.map do |key, value|
-            "#{key}: #{value.inspect}"
-          end.join(', ')
-          p.size == 0 ? '' : " {#{p}}"
-        end
-
         def origin_association
           target_class.associations[@origin]
         end

data/lib/neo4j/active_node/has_n/association_cypher_methods.rb

@@ -0,0 +1,108 @@
+module Neo4j
+  module ActiveNode
+    module HasN
+      module AssociationCypherMethods
+        # Return cypher partial query string for the relationship part of a MATCH (arrow / relationship definition)
+        def arrow_cypher(var = nil, properties = {}, create = false, reverse = false, length = nil)
+          validate_origin!
+
+          if create && length.present?
+            fail(ArgumentError, 'rel_length option cannot be specified when creating a relationship')
+          end
+
+          direction_cypher(get_relationship_cypher(var, properties, create, length), create, reverse)
+        end
+
+        private
+
+        def direction_cypher(relationship_cypher, create, reverse = false)
+          case get_direction(create, reverse)
+          when :out
+            "-#{relationship_cypher}->"
+          when :in
+            "<-#{relationship_cypher}-"
+          when :both
+            "-#{relationship_cypher}-"
+          end
+        end
+
+        def get_relationship_cypher(var, properties, create, length)
+          relationship_type = relationship_type(create)
+          relationship_name_cypher = ":`#{relationship_type}`" if relationship_type
+          rel_length_cypher = cypher_for_rel_length(length)
+          properties_string = get_properties_string(properties)
+
+          "[#{var}#{relationship_name_cypher}#{rel_length_cypher}#{properties_string}]"
+        end
+
+        def get_properties_string(properties)
+          p = properties.map do |key, value|
+            "#{key}: #{value.inspect}"
+          end.join(', ')
+          p.size == 0 ? '' : " {#{p}}"
+        end
+
+        VALID_REL_LENGTH_SYMBOLS = {
+          any: '*'
+        }
+
+        def cypher_for_rel_length(length)
+          return nil if length.blank?
+
+          validate_rel_length!(length)
+
+          case length
+          when Symbol then VALID_REL_LENGTH_SYMBOLS[length]
+          when Fixnum then "*#{length}"
+          when Range then cypher_for_range_rel_length(length)
+          when Hash then cypher_for_hash_rel_length(length)
+          end
+        end
+
+        def cypher_for_range_rel_length(length)
+          range_end = length.end
+          range_end = nil if range_end == Float::INFINITY
+          "*#{length.begin}..#{range_end}"
+        end
+
+        def cypher_for_hash_rel_length(length)
+          range_end = length[:max]
+          range_end = nil if range_end == Float::INFINITY
+          "*#{length[:min]}..#{range_end}"
+        end
+
+        def validate_rel_length!(length)
+          message = rel_length_error_message(length)
+          fail(ArgumentError, "Invalid value for rel_length (#{length.inspect}): #{message}") if message
+          true
+        end
+
+        def rel_length_error_message(length)
+          case length
+          when Fixnum then 'cannot be negative' if length < 0
+          when Symbol then rel_length_symbol_error_message(length)
+          when Range then rel_length_range_error_message(length)
+          when Hash then rel_length_hash_error_message(length)
+          else 'should be a Symbol, Fixnum, Range or Hash'
+          end
+        end
+
+        def rel_length_symbol_error_message(length)
+          "expecting one of #{VALID_REL_LENGTH_SYMBOLS.keys.inspect}" if !VALID_REL_LENGTH_SYMBOLS.key?(length)
+        end
+
+        def rel_length_range_error_message(length)
+          if length.begin > length.end
+            'cannot be a decreasing Range'
+          elsif length.begin < 0
+            'cannot include negative values'
+          end
+        end
+
+        def rel_length_hash_error_message(length)
+          'Hash keys should be a subset of [:min, :max]' if (length.keys & [:min, :max]) != length.keys
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/id_property.rb

@@ -34,7 +34,7 @@ module Neo4j::ActiveNode
   #
   module IdProperty
     extend ActiveSupport::Concern
-
+    include Accessor
 
     module TypeMethods
       def define_id_methods(clazz, name, conf)
@@ -90,7 +90,7 @@ module Neo4j::ActiveNode
           end
 
           def #{name}
-             default_property :#{name}
+             default_property_value
           end
 
           alias_method :id, :#{name}
@@ -102,12 +102,12 @@ module Neo4j::ActiveNode
 
         clazz.module_eval(%{
           default_property :#{name} do |instance|
-             raise "Specifying custom id_property #{name} on none existing method #{on}" unless instance.respond_to?(:#{on})
-             instance.#{on}
+            raise "Specifying custom id_property #{name} on non-existent method #{on}" unless instance.respond_to?(:#{on})
+            instance.#{on}
           end
 
           def #{name}
-             default_property :#{name}
+            default_property_value
           end
 
           alias_method :id, :#{name}
@@ -124,6 +124,8 @@ module Neo4j::ActiveNode
 
 
     module ClassMethods
+      attr_accessor :manual_id_property
+
       def find_by_neo_id(id)
         Neo4j::Node.load(id)
       end
@@ -137,12 +139,14 @@ module Neo4j::ActiveNode
       end
 
       def id_property(name, conf = {})
-        id_property_constraint(name)
-        @id_property_info = {name: name, type: conf}
-        TypeMethods.define_id_methods(self, name, conf)
-        constraint name, type: :unique unless conf[:constraint] == false
+        self.manual_id_property = true
+        Neo4j::Session.on_session_available do |_|
+          @id_property_info = {name: name, type: conf}
+          TypeMethods.define_id_methods(self, name, conf)
+          constraint(name, type: :unique) unless conf[:constraint] == false
 
-        self.define_singleton_method(:find_by_id) { |key| self.where(name => key).first }
+          self.define_singleton_method(:find_by_id) { |key| self.where(name => key).first }
+        end
       end
 
       # rubocop:disable Style/PredicateName
@@ -165,6 +169,10 @@ module Neo4j::ActiveNode
         id_property_info[:name]
       end
 
+      def manual_id_property?
+        !!manual_id_property
+      end
+
       alias_method :primary_key, :id_property_name
 
       private
@@ -173,7 +181,7 @@ module Neo4j::ActiveNode
         if id_property?
           unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
             # Neo4j Embedded throws a crazy error when a constraint can't be dropped
-            drop_constraint(id_property_name, type: :unique)
+            drop_constraint(id_property_name, type: :unique) if constraint?(mapped_label_name, id_property_name)
           end
         end
       rescue Neo4j::Server::CypherResponse::ResponseError, Java::OrgNeo4jCypher::CypherExecutionException

data/lib/neo4j/active_node/id_property/accessor.rb

@@ -0,0 +1,62 @@
+module Neo4j::ActiveNode::IdProperty
+  # Provides get/set of the Id Property values.
+  # Some methods
+  module Accessor
+    extend ActiveSupport::Concern
+
+    attr_reader :default_property_value
+
+    def default_properties=(properties)
+      @default_property_value = properties[default_property_key]
+    end
+
+    def default_property(key)
+      return nil unless key == default_property_key
+      default_property_value
+    end
+
+    def default_property_key
+      self.class.default_property_key
+    end
+
+    def default_properties
+      @default_properties ||= Hash.new(nil)
+    end
+
+    module ClassMethods
+      def default_property_key
+        @default_property_key ||= default_properties_keys.first
+      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
+    end
+  end
+end

data/lib/neo4j/active_node/labels.rb

@@ -103,7 +103,7 @@ module Neo4j
         # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
         # @param Hash args of arguments to find
         def find_by(values)
-          all.query_as(:n).where(n: values).limit(1).pluck(:n).first
+          all.where(values).limit(1).query_as(:n).pluck(:n).first
         end
 
         # Like find_by, except that if no record is found, raises a RecordNotFound error.
@@ -147,6 +147,7 @@ module Neo4j
         #    end
         def index(property, conf = {})
           Neo4j::Session.on_session_available do |_|
+            drop_constraint(property, type: :unique) if Neo4j::Label.constraint?(mapped_label_name, property)
             _index(property, conf)
           end
           indexed_properties.push property unless indexed_properties.include? property
@@ -161,12 +162,22 @@ module Neo4j
           Neo4j::Session.on_session_available do |session|
             unless Neo4j::Label.constraint?(mapped_label_name, property)
               label = Neo4j::Label.create(mapped_label_name)
+              drop_index(property, label) if index?(property)
               label.create_constraint(property, constraints, session)
             end
           end
         end
 
-        def drop_constraint(property, constraint)
+        # @param [Symbol] property The name of the property index to be dropped
+        # @param [Neo4j::Label] label An instance of label from Neo4j::Core
+        def drop_index(property, label = nil)
+          label_obj = label || Neo4j::Label.create(mapped_label_name)
+          label_obj.drop_index(property)
+        end
+
+        # @param [Symbol] property The name of the property constraint to be dropped
+        # @param [Hash] constraint The constraint type to be dropped.
+        def drop_constraint(property, constraint = {type: :unique})
           Neo4j::Session.on_session_available do |session|
             label = Neo4j::Label.create(mapped_label_name)
             label.drop_constraint(property, constraint, session)

data/lib/neo4j/active_node/persistence.rb

@@ -24,8 +24,10 @@ module Neo4j::ActiveNode
     # If any of the before_* callbacks return false the action is cancelled and save returns false.
     def save(*)
       update_magic_properties
-      association_proxy_cache.clear
-      create_or_update
+      cascade_save do
+        association_proxy_cache.clear
+        create_or_update
+      end
     end
 
     # Persist the object to the database.  Validations and Callbacks are included
@@ -53,7 +55,7 @@ module Neo4j::ActiveNode
       node = _create_node(properties)
       init_on_load(node, node.props)
       send_props(@relationship_props) if @relationship_props
-      @relationship_props = nil
+      @relationship_props = @deferred_nodes = nil
       true
     end
 
@@ -66,12 +68,25 @@ module Neo4j::ActiveNode
       session.create_node(props, labels)
     end
 
+    private
+
+    # The pending associations are cleared during the save process, so it's necessary to
+    # build the processable hash before it begins. If there are nodes and associations that
+    # need to be created after the node is saved, a new transaction is started.
+    def cascade_save
+      deferred_nodes = pending_associations_with_nodes
+      Neo4j::Transaction.run(!deferred_nodes.blank?) do
+        result = yield
+        process_unpersisted_nodes!(deferred_nodes) if deferred_nodes
+        result
+      end
+    end
+
     module ClassMethods
       # Creates and saves a new node
       # @param [Hash] props the properties the new node should have
       def create(props = {})
         association_props = extract_association_attributes!(props) || {}
-
         new(props).tap do |obj|
           yield obj if block_given?
           obj.save

data/lib/neo4j/active_node/property.rb

@@ -3,9 +3,9 @@ module Neo4j::ActiveNode
     extend ActiveSupport::Concern
     include Neo4j::Shared::Property
 
-    def initialize(attributes = {}, options = {})
-      super(attributes, options)
-      @attributes ||= self.class.attributes_nil_hash.dup
+    def initialize(attributes = nil)
+      super(attributes)
+      @attributes ||= Hash[self.class.attributes_nil_hash]
       send_props(@relationship_props) if _persisted_obj && !@relationship_props.nil?
     end
 
@@ -22,6 +22,7 @@ module Neo4j::ActiveNode
       private
 
       def contains_association?(attributes)
+        return false unless attributes
         attributes.each_key { |key| return true if associations_keys.include?(key) }
         false
       end

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

@@ -6,6 +6,7 @@ module Neo4j
         include Neo4j::ActiveNode::Query::QueryProxyMethods
         include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
         include Neo4j::ActiveNode::Query::QueryProxyEagerLoading
+        include Neo4j::ActiveNode::Query::QueryProxyUnpersisted
         include Neo4j::ActiveNode::Dependent::QueryProxyMethods
 
         # The most recent node to start a QueryProxy chain.
@@ -26,11 +27,13 @@ module Neo4j
         # @param [Neo4j::ActiveNode::HasN::Association] association The ActiveNode association (an object created by a <tt>has_one</tt> or
         # <tt>has_many</tt>) that created this object.
         # @param [Hash] options Additional options pertaining to the QueryProxy object. These may include:
-        # * node_var: A string or symbol to be used by Cypher within its query string as an identifier
-        # * rel_var:  Same as above but pertaining to a relationship identifier
-        # * session: The session to be used for this query
-        # * source_object:  The node instance at the start of the QueryProxy chain
-        # * query_proxy: An existing QueryProxy chain upon which this new object should be built
+        # @option options [String, Symbol] :node_var A string or symbol to be used by Cypher within its query string as an identifier
+        # @option options [String, Symbol] :rel_var Same as above but pertaining to a relationship identifier
+        # @option options [Range, Fixnum, Symbol, Hash] :rel_length A Range, a Fixnum, a Hash or a Symbol to indicate the variable-length/fixed-length
+        #   qualifier of the relationship. See http://neo4jrb.readthedocs.org/en/latest/Querying.html#variable-length-relationships.
+        # @option options [Neo4j::Session] :session The session to be used for this query
+        # @option options [Neo4j::ActiveNode] :source_object The node instance at the start of the QueryProxy chain
+        # @option options [QueryProxy] :query_proxy An existing QueryProxy chain upon which this new object should be built
         #
         # QueryProxy objects are evaluated lazily.
         def initialize(model, association = nil, options = {})
@@ -51,7 +54,7 @@ module Neo4j
         end
 
         def inspect
-          "<QueryProxy #{ANSI::CYAN}#{@context}#{ANSI::CLEAR} CYPHER: #{ANSI::YELLOW}#{self.to_cypher.inspect}#{ANSI::CLEAR}>"
+          "#<QueryProxy #{@context} CYPHER: #{self.to_cypher.inspect}>"
         end
 
         attr_reader :start_object, :query_proxy
@@ -84,6 +87,9 @@ module Neo4j
         # Build a Neo4j::Core::Query object for the QueryProxy. This is necessary when you want to take an existing QueryProxy chain
         # and work with it from the more powerful (but less friendly) Neo4j::Core::Query.
         # @param [String,Symbol] var The identifier to use for node at this link of the QueryProxy chain.
+        #
+        # .. code-block:: ruby
+        #
         #   student.lessons.query_as(:l).with('your cypher here...')
         def query_as(var, with_labels = true)
           result_query = @chain.inject(base_query(var, with_labels).params(@params)) do |query, link|
@@ -115,6 +121,8 @@ module Neo4j
 
         # Scope all queries to the current scope.
         #
+        # .. code-block:: ruby
+        #
         #   Comment.where(post_id: 1).scoping do
         #     Comment.first
         #   end
@@ -141,8 +149,12 @@ module Neo4j
         alias_method :order_by, :order
 
         # Cypher string for the QueryProxy's query. This will not include params. For the full output, see <tt>to_cypher_with_params</tt>.
-        def to_cypher
-          query.to_cypher
+        def to_cypher(*args)
+          query.to_cypher(*args)
+        end
+
+        def print_cypher
+          query.print_cypher
         end
 
         # Returns a string of the cypher query with return objects and params
@@ -155,8 +167,7 @@ module Neo4j
 
         # To add a relationship for the node for the association on this QueryProxy
         def <<(other_node)
-          create(other_node, {})
-
+          @start_object._persisted_obj ? create(other_node, {}) : defer_create(other_node, {}, :<<)
           self
         end
 
@@ -278,7 +289,7 @@ module Neo4j
         end
 
         def _association_arrow(properties = {}, create = false)
-          @association && @association.arrow_cypher(@rel_var, properties, create)
+          @association && @association.arrow_cypher(@rel_var, properties, create, false, @rel_length)
         end
 
         def _chain_level
@@ -312,8 +323,13 @@ module Neo4j
         private
 
         def instance_vars_from_options!(options)
-          @node_var, @session, @source_object, @starting_query, @optional, @start_object, @query_proxy, @chain_level, @association_labels =
-              options.values_at(:node, :session, :source_object, :starting_query, :optional, :start_object, :query_proxy, :chain_level, :association_labels)
+          @node_var, @session, @source_object, @starting_query, @optional,
+              @start_object, @query_proxy, @chain_level, @association_labels,
+              @rel_length = options.values_at(:node, :session, :source_object,
+                                              :starting_query, :optional,
+                                              :start_object, :query_proxy,
+                                              :chain_level, :association_labels,
+                                              :rel_length)
         end
 
         def build_deeper_query_proxy(method, args)