neo4j 7.2.3 → 8.0.0.alpha.1

data/lib/neo4j/active_node/enum.rb

@@ -6,12 +6,9 @@ module Neo4j::ActiveNode
     module ClassMethods
       protected
 
-      def build_property_options(enum_keys, options = {})
-        if options[:_index]
-          super.merge!(index: :exact)
-        else
-          super
-        end
+      def define_property(property_name, *args)
+        super
+        Neo4j::ModelSchema.add_required_index(self, property_name)
       end
 
       def define_enum_methods(property_name, enum_keys, options)

data/lib/neo4j/active_node/has_n.rb

@@ -23,11 +23,8 @@ module Neo4j::ActiveNode
       # States:
       # Default
       def inspect
-        if @cached_result
-          result_nodes.inspect
-        else
-          "#<AssociationProxy @query_proxy=#{@query_proxy.inspect}>"
-        end
+        formatted_nodes = ::Neo4j::ActiveNode::NodeListFormatter.new(result_nodes)
+        "#<AssociationProxy #{@query_proxy.context} #{formatted_nodes.inspect}>"
       end
 
       extend Forwardable
@@ -212,7 +209,9 @@ module Neo4j::ActiveNode
       end
     end
 
+    # rubocop:disable Metrics/ModuleLength
     module ClassMethods
+      # rubocop:enable Style/PredicateName
       # rubocop:disable Style/PredicateName
 
       # :nocov:
@@ -229,21 +228,18 @@ module Neo4j::ActiveNode
         !!associations[name.to_sym]
       end
 
+      def parent_associations
+        superclass == Object ? {} : superclass.associations
+      end
+
       def associations
-        @associations ||= {}
+        (@associations ||= parent_associations.dup)
       end
 
       def associations_keys
         @associations_keys ||= associations.keys
       end
 
-      # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
-      def inherited(klass)
-        klass.instance_variable_set(:@associations, associations.clone)
-        @associations_keys = klass.associations_keys.clone
-        super
-      end
-
       # For defining an "has many" association on a model.  This defines a set of methods on
       # your model instances.  For instance, if you define the association on a Person model:
       #
@@ -379,7 +375,7 @@ module Neo4j::ActiveNode
 
           clear_deferred_nodes_for_association(name)
 
-          Neo4j::Transaction.run { association_proxy(name).replace_with(other_nodes) }
+          self.class.run_transaction { association_proxy(name).replace_with(other_nodes) }
         end
       end
 
@@ -455,7 +451,7 @@ module Neo4j::ActiveNode
           if persisted?
             other_node.save if other_node.respond_to?(:persisted?) && !other_node.persisted?
             association_proxy_cache.clear # TODO: Should probably just clear for this association...
-            Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
+            self.class.run_transaction { association_proxy(name).replace_with(other_node) }
             # handle_non_persisted_node(other_node)
           else
             defer_create(name, other_node, clear: true)
@@ -509,24 +505,33 @@ module Neo4j::ActiveNode
 
       def default_association_query_proxy
         Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize, nil,
-                                                 session: neo4j_session, query_proxy: nil, context: "#{self.name}")
+                                                 session: neo4j_session, query_proxy: nil, context: self.name.to_s)
       end
 
       def build_association(macro, direction, name, options)
         options[:model_class] = options[:model_class].name if options[:model_class] == self
         Neo4j::ActiveNode::HasN::Association.new(macro, direction, name, options).tap do |association|
-          @associations ||= {}
-          @associations[name] = association
+          add_association(name, association)
           create_reflection(macro, name, association, self)
         end
 
-        associations_keys << name
+        @associations_keys = nil
 
       # Re-raise any exception with added class name and association name to
       # make sure error message is helpful
       rescue StandardError => e
         raise e.class, "#{e.message} (#{self.class}##{name})"
       end
+
+      def add_association(name, association_object)
+        fail "Association `#{name}` defined for a second time. "\
+             'Associations can only be defined once' if duplicate_association?(name)
+        associations[name] = association_object
+      end
+
+      def duplicate_association?(name)
+        associations.key?(name) && parent_associations[name] != associations[name]
+      end
     end
   end
 end

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

@@ -67,6 +67,10 @@ module Neo4j
                                   end
         end
 
+        def inverse_of?(other)
+          origin_association == other
+        end
+
         def target_classes
           ClassArguments.constantize_argument(target_class_names)
         end
@@ -151,7 +155,7 @@ module Neo4j
         def relationship_class?
           !!relationship_class
         end
-        alias_method :rel_class?, :relationship_class?
+        alias rel_class? relationship_class?
 
         private
 
@@ -216,7 +220,7 @@ module Neo4j
           message = case
                     when (message = type_keys_error_message(options.keys))
                       message
-                    when (unknown_keys = options.keys - VALID_ASSOCIATION_OPTION_KEYS).size > 0
+                    when !(unknown_keys = options.keys - VALID_ASSOCIATION_OPTION_KEYS).empty?
                       "Unknown option(s) specified: #{unknown_keys.join(', ')}"
                     end
 

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

@@ -44,7 +44,7 @@ module Neo4j::ActiveNode::HasN
 
       def _match_query(other_node, wrapper)
         nodes = _nodes_for_create(other_node, wrapper.from_node_identifier, wrapper.to_node_identifier)
-        Neo4j::Session.current.query.match_nodes(nodes)
+        Neo4j::ActiveBase.new_query.match_nodes(nodes)
       end
 
       def _nodes_for_create(other_node, from_node_id, to_node_id)

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

@@ -7,7 +7,7 @@ class Neo4j::ActiveNode::HasN::Association
     attr_reader :type, :association
     attr_accessor :properties
     private :association
-    alias_method :props_for_create, :properties
+    alias props_for_create properties
 
     def initialize(association, properties = {})
       @association = association

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

@@ -39,7 +39,7 @@ module Neo4j
           p = properties.map do |key, value|
             "#{key}: #{value.inspect}"
           end.join(', ')
-          p.size == 0 ? '' : " {#{p}}"
+          p.empty? ? '' : " {#{p}}"
         end
 
         VALID_REL_LENGTH_SYMBOLS = {

data/lib/neo4j/active_node/id_property.rb

@@ -40,6 +40,8 @@ module Neo4j::ActiveNode
       def define_id_methods(clazz, name, conf)
         validate_conf!(conf)
 
+        return if name == :neo_id
+
         if conf[:on]
           define_custom_method(clazz, name, conf[:on])
         elsif conf[:auto]
@@ -125,7 +127,7 @@ module Neo4j::ActiveNode
       attr_accessor :manual_id_property
 
       def find_by_neo_id(id)
-        Neo4j::Node.load(id)
+        find_by(neo_id: id)
       end
 
       def find_by_id(id)
@@ -136,13 +138,11 @@ module Neo4j::ActiveNode
         all.where(id_property_name => ids).to_a
       end
 
-      def id_property(name, conf = {})
+      def id_property(name, conf = {}, inherited = false)
         self.manual_id_property = true
-        Neo4j::Session.on_next_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
-        end
+
+        @id_property_info = {name: name, type: conf, inherited: inherited}
+        TypeMethods.define_id_methods(self, name, conf)
       end
 
       # rubocop:disable Style/PredicateName
@@ -158,6 +158,8 @@ module Neo4j::ActiveNode
       end
 
       def id_property_info
+        ensure_id_property_info!
+
         @id_property_info ||= {}
       end
 
@@ -169,18 +171,53 @@ module Neo4j::ActiveNode
         !!manual_id_property
       end
 
-      alias_method :primary_key, :id_property_name
+      alias primary_key id_property_name
+
+      # Since there's no way to know when a class is done being described, we wait until the id_property
+      # information is requested and use that as the opportunity to set up the defaults if no others are specified
+      def ensure_id_property_info!
+        if !manual_id_property? && !@id_property_info
+          name, type, value = id_property_name_type_value
+          id_property(name, type => value)
+        end
+
+        handle_model_schema!
+      end
 
       private
 
-      def id_property_constraint(name)
-        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) if constraint?(mapped_label_name, id_property_name)
-          end
+      def handle_model_schema!
+        id_property_name = @id_property_info[:name]
+        if @id_property_info[:type][:constraint] == false &&
+           !@id_property_info[:inherited] &&
+           !@id_property_info[:warned_of_constraint]
+          @id_property_info[:warned_of_constraint] = true
+          warn_constraint_option_false!(id_property_name)
+          return
         end
-      rescue Neo4j::Server::CypherResponse::ResponseError, Java::OrgNeo4jCypher::CypherExecutionException
+
+        return if id_property_name == :neo_id || @id_property_info[:inherited]
+
+        Neo4j::ModelSchema.add_defined_constraint(self, id_property_name)
+      end
+
+      def warn_constraint_option_false!(id_property_name)
+        Neo4j::ActiveBase.logger.warn <<MSG
+        WARNING: The constraint option for id_property is no longer supported (Used on #{self.name}.#{id_property_name}).
+        Since you specified `constraint: false` this option can simply be removed.
+MSG
+      end
+
+      def id_property_name_type_value
+        name, type, value = Neo4j::Config.to_hash.values_at(*%w(id_property id_property_type id_property_type_value))
+
+        if !(name && type && value)
+          name = :uuid
+          type = :auto
+          value = :uuid
+        end
+
+        [name, type, value]
       end
     end
   end

data/lib/neo4j/active_node/labels.rb

@@ -1,3 +1,5 @@
+require 'neo4j/core/label'
+
 module Neo4j
   module ActiveNode
     # Provides a mapping between neo4j labels and Ruby classes
@@ -11,7 +13,11 @@ module Neo4j
       MODELS_FOR_LABELS_CACHE.clear
 
       included do |model|
-        Neo4j::ActiveNode::Labels.clear_wrapped_models
+        def self.inherited(model)
+          add_wrapped_class(model)
+
+          super
+        end
 
         Neo4j::ActiveNode::Labels.add_wrapped_class(model) unless Neo4j::ActiveNode::Labels._wrapped_classes.include?(model)
       end
@@ -31,15 +37,32 @@ module Neo4j
 
       # adds one or more labels
       # @see Neo4j-core
-      def add_label(*label)
-        @_persisted_obj.add_label(*label)
+      def add_labels(*labels)
+        labels.inject(query_as(:n)) do |query, label|
+          query.set("n:`#{label}`")
+        end.exec
+        @_persisted_obj.labels.concat(labels)
+        @_persisted_obj.labels.uniq!
+      end
+
+      # Remove this method in 9.0.0
+      def add_label(*_labels)
+        fail 'add_label has been removed in favor of `add_labels`'
       end
 
       # Removes one or more labels
       # Be careful, don't remove the label representing the Ruby class.
       # @see Neo4j-core
-      def remove_label(*label)
-        @_persisted_obj.remove_label(*label)
+      def remove_labels(*labels)
+        labels.inject(query_as(:n)) do |query, label|
+          query.remove("n:`#{label}`")
+        end.exec
+        labels.each(&@_persisted_obj.labels.method(:delete))
+      end
+
+      # Remove this method in 9.0.0
+      def remove_label(*_labels)
+        fail 'remove_label has been removed in favor of `remove_labels`'
       end
 
       def self._wrapped_classes
@@ -56,7 +79,7 @@ module Neo4j
         return MODELS_FOR_LABELS_CACHE[labels] if MODELS_FOR_LABELS_CACHE[labels]
 
         models = WRAPPED_CLASSES.select do |model|
-          (model.mapped_label_names - labels).size == 0
+          (model.mapped_label_names - labels).empty?
         end
 
         MODELS_FOR_LABELS_CACHE[labels] = models.max_by do |model|
@@ -66,7 +89,7 @@ module Neo4j
 
       def self.clear_wrapped_models
         MODELS_FOR_LABELS_CACHE.clear
-        Neo4j::Node::Wrapper::CONSTANTS_FOR_LABELS_CACHE.clear
+        Neo4j::NodeWrapping::CONSTANTS_FOR_LABELS_CACHE.clear
       end
 
       module ClassMethods
@@ -100,8 +123,7 @@ module Neo4j
 
         # Deletes all nodes and connected relationships from Cypher.
         def delete_all
-          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
-          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
+          neo4j_query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
         end
 
         # Returns each node to Ruby and calls `destroy`. Be careful, as this can be a very slow operation if you have many nodes. It will generate at least
@@ -122,7 +144,7 @@ module Neo4j
 
         # @return [Neo4j::Label] the label for this class
         def mapped_label
-          Neo4j::Label.create(mapped_label_name)
+          Neo4j::Core::Label.new(mapped_label_name, neo4j_session)
         end
 
         def base_class

data/lib/neo4j/active_node/labels/index.rb

@@ -20,67 +20,17 @@ module Neo4j::ActiveNode::Labels
       #      index :name
       #    end
       def index(property)
-        Neo4j::Session.on_next_session_available do |_|
-          declared_properties.index_or_fail!(property, id_property_name)
-          schema_create_operation(:index, property)
-        end
+        return if Neo4j::ModelSchema.defined_constraint?(self, property)
+
+        Neo4j::ModelSchema.add_defined_index(self, property)
       end
 
       # Creates a neo4j constraint on this class for given property
       #
       # @example
       #   Person.constraint :name, type: :unique
-      def constraint(property, constraints = {type: :unique})
-        Neo4j::Session.on_next_session_available do
-          declared_properties.constraint_or_fail!(property, id_property_name)
-          schema_create_operation(:constraint, property, constraints)
-        end
-      end
-
-      # @param [Symbol] property The name of the property index to be dropped
-      def drop_index(property, options = {})
-        Neo4j::Session.on_next_session_available do
-          declared_properties[property].unindex! if declared_properties[property]
-          schema_drop_operation(:index, property, options)
-        end
-      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_next_session_available do
-          declared_properties[property].unconstraint! if declared_properties[property]
-          schema_drop_operation(:constraint, property, constraint)
-        end
-      end
-
-      def index?(property)
-        mapped_label.indexes[:property_keys].include?([property])
-      end
-
-      def constraint?(property)
-        mapped_label.unique_constraints[:property_keys].include?([property])
-      end
-
-      private
-
-      def schema_create_operation(type, property, options = {})
-        new_schema_class(type, property, options).create!
-      end
-
-      def schema_drop_operation(type, property, options = {})
-        new_schema_class(type, property, options).drop!
-      end
-
-      def new_schema_class(type, property, options)
-        case type
-        when :index
-          Neo4j::Schema::ExactIndexOperation
-        when :constraint
-          Neo4j::Schema::UniqueConstraintOperation
-        else
-          fail "Unknown Schema Operation class #{type}"
-        end.new(mapped_label_name, property, options)
+      def constraint(property, _constraints = {type: :unique})
+        Neo4j::ModelSchema.add_defined_constraint(self, property)
       end
     end
   end

data/lib/neo4j/active_node/node_list_formatter.rb

@@ -0,0 +1,13 @@
+module Neo4j::ActiveNode
+  class NodeListFormatter
+    def initialize(list, max_elements = 5)
+      @list = list
+      @max_elements = max_elements
+    end
+
+    def inspect
+      return @list.inspect if !@max_elements || @list.length <= @max_elements
+      "[#{@list.take(5).map!(&:inspect).join(', ')}, ...]"
+    end
+  end
+end