neo4j 7.2.3 → 8.0.0.alpha.1

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

@@ -27,7 +27,7 @@ module Neo4j
           query_with_target(identifier) do |target|
             begin
               self.query.with(target).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
-            rescue Neo4j::Session::CypherError
+            rescue Neo4j::Core::CypherSession::CypherError # <=- Seems hacky
               self.query.delete(target).exec
             end
             clear_source_object_cache

data/lib/neo4j/active_node/query_methods.rb

@@ -27,14 +27,14 @@ module Neo4j
         self.query_as(:n).return("count(#{q}) AS count").first.count
       end
 
-      alias_method :size, :count
-      alias_method :length, :count
+      alias size count
+      alias length count
 
       def empty?
         !self.all.exists?
       end
 
-      alias_method :blank?, :empty?
+      alias blank? empty?
 
       def find_in_batches(options = {})
         self.query_as(:n).return(:n).find_in_batches(:n, primary_key, options) do |batch|

data/lib/neo4j/active_node/scope.rb

@@ -64,7 +64,7 @@ module Neo4j::ActiveNode
       end
 
       def full_scopes
-        scopes.merge(self.superclass.respond_to?(:scopes) ? self.superclass.scopes : {})
+        self.superclass.respond_to?(:scopes) ? self.superclass.scopes.merge(scopes) : scopes
       end
 
       def _call_scope_context(eval_context, query_params, proc)
@@ -100,13 +100,30 @@ module Neo4j::ActiveNode
         @target = target
       end
 
+      def identity
+        query_proxy_or_target.identity
+      end
+
       Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
-        module_eval(%{
-            def #{method}(params={})
-              @target.all.scoping do
-                (@query_proxy || @target).#{method}(params)
-              end
-            end}, __FILE__, __LINE__)
+        define_method(method) do |*args|
+          @target.all.scoping do
+            query_proxy_or_target.public_send(method, *args)
+          end
+        end
+      end
+
+      def method_missing(name, *params, &block)
+        if query_proxy_or_target.respond_to?(name)
+          query_proxy_or_target.public_send(name, *params, &block)
+        else
+          super
+        end
+      end
+
+      private
+
+      def query_proxy_or_target
+        @query_proxy_or_target ||= @query_proxy || @target
       end
     end
 

data/lib/neo4j/active_rel.rb

@@ -18,14 +18,13 @@ module Neo4j
     include Neo4j::ActiveRel::Query
     include Neo4j::ActiveRel::Types
     include Neo4j::Shared::Enum
-    include Neo4j::Shared::PermittedAttributes
 
     class FrozenRelError < Neo4j::Error; end
 
     def initialize(from_node = nil, to_node = nil, args = nil)
       load_nodes(node_or_nil(from_node), node_or_nil(to_node))
       resolved_args = hash_or_nil(from_node, args)
-      symbol_args = sanitize_input_parameters(resolved_args)
+      symbol_args = resolved_args.is_a?(Hash) ? resolved_args.symbolize_keys : resolved_args
       super(symbol_args)
     end
 
@@ -61,7 +60,26 @@ module Neo4j
     end
 
     def hash_or_nil(node_or_hash, hash_or_nil)
-      hash_or_parameter?(node_or_hash) ? node_or_hash : hash_or_nil
+      node_or_hash.is_a?(Hash) ? node_or_hash : hash_or_nil
+    end
+
+    module ClassMethods
+      [:create, :create!].each do |meth|
+        define_method(meth) do |from_node_or_args = nil, to_node = nil, args = nil|
+          return super(from_node_or_args) if from_node_or_args.is_a?(Hash)
+          args_hash = args || {}
+          args_with_node!(:from_node, from_node_or_args, args_hash)
+          args_with_node!(:to_node, to_node, args_hash)
+          super(args_hash)
+        end
+      end
+
+      private
+
+      def args_with_node!(key, node, args)
+        args[key] = node if node.is_a?(Neo4j::ActiveNode)
+        args
+      end
     end
   end
 end

data/lib/neo4j/active_rel/initialize.rb

@@ -19,8 +19,8 @@ module Neo4j::ActiveRel
     def init_on_reload(unwrapped_reloaded)
       @attributes = nil
       init_on_load(unwrapped_reloaded,
-                   unwrapped_reloaded._start_node_id,
-                   unwrapped_reloaded._end_node_id,
+                   unwrapped_reloaded.start_node_id,
+                   unwrapped_reloaded.end_node_id,
                    unwrapped_reloaded.rel_type)
       self
     end

data/lib/neo4j/active_rel/persistence.rb

@@ -40,8 +40,7 @@ module Neo4j::ActiveRel
     # @param [Symbol, String] name of the attribute to increment
     # @param [Integer, Float] amount to increment
     def concurrent_increment!(attribute, by = 1)
-      query_rel = Neo4j::Session.query.match('()-[n]-()').where(n: {neo_id: neo_id})
-      increment_by_query! query_rel, attribute, by
+      increment_by_query! query_as(:n), attribute, by
     end
 
     def create_model
@@ -52,16 +51,35 @@ module Neo4j::ActiveRel
       true
     end
 
+    def query_as(var)
+      # This should query based on the nodes, not the rel neo_id, I think
+      # Also, picky point: Should the var be `n`?
+      self.class.query_as(neo_id, var)
+    end
+
     module ClassMethods
       # Creates a new relationship between objects
       # @param [Hash] props the properties the new relationship should have
-      def create(*args)
-        new(*args).tap(&:save)
+      def create(props = {})
+        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
 
       # Same as #create, but raises an error if there is a problem during save.
       def create!(*args)
-        new(*args).tap(&:save!)
+        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
 
       def create_method
@@ -69,7 +87,11 @@ module Neo4j::ActiveRel
       end
 
       def load_entity(id)
-        Neo4j::Relationship.load(id)
+        query_as(id).pluck(:r).first
+      end
+
+      def query_as(neo_id, var = :r)
+        Neo4j::ActiveBase.new_query.match("()-[#{var}]-()").where(var => {neo_id: neo_id})
       end
     end
 
@@ -79,6 +101,10 @@ module Neo4j::ActiveRel
 
     private
 
+    def destroy_query
+      query_as(:r).delete(:r)
+    end
+
     def validate_node_classes!
       [from_node, to_node].each do |node|
         type = from_node == node ? :_from_class : :_to_class

data/lib/neo4j/active_rel/persistence/query_factory.rb

@@ -15,9 +15,9 @@ module Neo4j::ActiveRel::Persistence
     # TODO: This feels like it should also wrap the rel, but that is handled in Neo4j::ActiveRel::Persistence at the moment.
     # Builds and executes the query using the objects giving during init.
     # It holds the process:
-    #   * Execute node callbacks if needed
-    #   * Create and execute the query
-    #   * Mix the query response into the unpersisted objects given during init
+    # * Execute node callbacks if needed
+    # * Create and execute the query
+    # * Mix the query response into the unpersisted objects given during init
     def build!
       node_before_callbacks! do
         res = query_factory(rel, rel_id, iterative_query).query.unwrapped.return(*unpersisted_return_ids).first

data/lib/neo4j/active_rel/property.rb

@@ -6,27 +6,27 @@ module Neo4j::ActiveRel
     include Neo4j::Shared::Property
 
     %w(to_node from_node).each do |direction|
-      define_method("#{direction}") { instance_variable_get("@#{direction}") }
+      define_method(direction.to_s) { instance_variable_get("@#{direction}") }
       define_method("#{direction}=") do |argument|
         fail FrozenRelError, 'Relationship start/end nodes cannot be changed once persisted' if _persisted_obj
         instance_variable_set("@#{direction}", argument)
       end
     end
 
-    alias_method :start_node, :from_node
-    alias_method :end_node,   :to_node
+    alias start_node from_node
+    alias end_node to_node
 
     %w(start_node end_node).each do |direction|
       define_method("#{direction}_neo_id") { send(direction).neo_id if direction }
     end
-    alias_method :from_node_neo_id, :start_node_neo_id
-    alias_method :to_node_neo_id,   :end_node_neo_id
+    alias from_node_neo_id start_node_neo_id
+    alias to_node_neo_id end_node_neo_id
 
     # @return [String] a string representing the relationship type that will be created
     def type
       self.class.type
     end
-    alias_method :rel_type, :type
+    alias rel_type type
 
     def initialize(attributes = nil)
       super(attributes)
@@ -55,7 +55,7 @@ module Neo4j::ActiveRel
       end
 
       %w(to_class from_class).each do |direction|
-        define_method("#{direction}") do |argument = nil|
+        define_method(direction.to_s) do |argument = nil|
           if !argument.nil?
             Neo4j::ClassArguments.validate_argument!(argument, direction)
 
@@ -73,8 +73,8 @@ module Neo4j::ActiveRel
           (class_argument.is_a?(Array) && class_argument.all? { |c| [String, Symbol].include?(c.class) })
       end
 
-      alias_method :start_class,  :from_class
-      alias_method :end_class,    :to_class
+      alias start_class from_class
+      alias end_class to_class
 
       def load_entity(id)
         Neo4j::Node.load(id)

data/lib/neo4j/active_rel/query.rb

@@ -12,8 +12,10 @@ module Neo4j::ActiveRel
       end
 
       # Loads the relationship using its neo_id.
-      def find_by_id(key, session = Neo4j::Session.current!)
-        session.query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first.r
+      def find_by_id(key, session = nil)
+        options = session ? {session: session} : {}
+        query ||= Neo4j::ActiveBase.new_query(options)
+        query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first.r
       end
 
       # Performs a very basic match on the relationship.
@@ -47,12 +49,12 @@ module Neo4j::ActiveRel
 
       def where_query
         deprecation_warning!
-        Neo4j::Session.query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
+        Neo4j::ActiveBase.new_query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
       end
 
       def all_query
         deprecation_warning!
-        Neo4j::Session.query.match("#{cypher_string}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
+        Neo4j::ActiveBase.new_query.match("#{cypher_string}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
       end
 
       def cypher_string(dir = :outbound)

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -1,22 +1,30 @@
-class Neo4j::Relationship
-  module Wrapper
-    def wrapper
-      props.symbolize_keys!
-      begin
-        most_concrete_class = class_from_type
-        wrapped_rel = most_concrete_class.constantize.new
-      rescue NameError
-        return self
-      end
+require 'neo4j/core/relationship'
 
-      wrapped_rel.init_on_load(self, self._start_node_id, self._end_node_id, self.rel_type)
-      wrapped_rel
-    end
+wrapping_proc = proc do |relationship|
+  Neo4j::RelWrapping.wrapper(relationship)
+end
+Neo4j::Core::Relationship.wrapper_callback(wrapping_proc)
 
-    private
+module Neo4j
+  module RelWrapping
+    class << self
+      def wrapper(rel)
+        rel.props.symbolize_keys!
+        begin
+          most_concrete_class = class_from_type(rel.rel_type)
+          most_concrete_class.constantize.new
+        rescue NameError => e
+          raise e unless e.message =~ /(uninitialized|wrong) constant/
 
-    def class_from_type
-      Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] || Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] = rel_type.camelize
+          return rel
+        end.tap do |wrapped_rel|
+          wrapped_rel.init_on_load(rel, rel.start_node_id, rel.end_node_id, rel.type)
+        end
+      end
+
+      def class_from_type(rel_type)
+        Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] || Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] = rel_type.to_s.camelize
+      end
     end
   end
 end

data/lib/neo4j/active_rel/related_node.rb

@@ -29,7 +29,11 @@ module Neo4j::ActiveRel
     # Loads a node from the database or returns the node if already laoded
     def loaded
       fail UnsetRelatedNodeError, 'Node not set, cannot load' if @node.nil?
-      @node = @node.respond_to?(:neo_id) ? @node : Neo4j::Node.load(@node)
+      @node = if @node.respond_to?(:neo_id)
+                @node
+              else
+                Neo4j::ActiveBase.new_query.match(:n).where(n: {neo_id: @node}).pluck(:n).first
+              end
     end
 
     # @param [String, Symbol, Array] clazz An alternate label to use in the event the node is not present or loaded

data/lib/neo4j/active_rel/types.rb

@@ -42,8 +42,8 @@ module Neo4j
             assign_type!(namespaced_model_name, true)
           end
         end
-        alias_method :rel_type, :type
-        alias_method :_type, :type # should be deprecated
+        alias rel_type type
+        alias _type type # should be deprecated
 
         def namespaced_model_name
           case Neo4j::Config[:module_handling]

data/lib/neo4j/config.rb

@@ -4,7 +4,6 @@ module Neo4j
   # == Configurations keys
   class Config
     DEFAULT_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', 'config.yml'))
-    CLASS_NAME_PROPERTY_KEY = 'class_name_property'
 
     class << self
       # In keeping with the Rails convention, this class writer lets you globally configure

data/lib/neo4j/errors.rb

@@ -25,4 +25,7 @@ module Neo4j
 
   class DangerousAttributeError < ScriptError; end
   class UnknownAttributeError < NoMethodError; end
+  class MigrationError < Error; end
+  class IrreversibleMigration < MigrationError; end
+  class UnknownMigrationVersionError < MigrationError; end
 end

data/lib/neo4j/migration.rb

@@ -1,4 +1,5 @@
 require 'benchmark'
+require 'neo4j/migrations/helpers/id_property'
 
 module Neo4j
   class Migration
@@ -7,11 +8,11 @@ module Neo4j
     end
 
     def output(string = '')
-      puts string unless !!ENV['silenced']
+      puts string unless !!ENV['MIGRATIONS_SILENCED']
     end
 
     def print_output(string)
-      print string unless !!ENV['silenced']
+      print string unless !!ENV['MIGRATIONS_SILENCED']
     end
 
     def default_path
@@ -22,7 +23,15 @@ module Neo4j
       File.join(path.to_s, 'db', 'neo4j-migrate')
     end
 
+    def setup
+      FileUtils.mkdir_p('db/neo4j-migrate')
+    end
+
+    delegate :query, to: Neo4j::Session
+
     class AddIdProperty < Neo4j::Migration
+      include Neo4j::Migrations::Helpers::IdProperty
+
       attr_reader :models_filename
 
       def initialize(path = default_path)
@@ -30,6 +39,8 @@ module Neo4j
       end
 
       def migrate
+        ActiveSupport::Deprecation.warn '`AddIdProperty` task is deprecated and may be removed from future releases. '\
+                                        'Create a new migration and use the `populate_id_property` helper.', caller
         models = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(models_filename))[:models]
         output 'This task will add an ID Property every node in the given file.'
         output 'It may take a significant amount of time, please be patient.'
@@ -37,13 +48,20 @@ module Neo4j
           output
           output
           output "Adding IDs to #{model}"
-          add_ids_to model.constantize
+          populate_id_property model
         end
       end
 
-      def setup
-        FileUtils.mkdir_p('db/neo4j-migrate')
+      def query(*args)
+        ActiveBase.magic_query(*args)
+      end
+
+      def execute(*args)
+        ActiveBase.query(*args)
+      end
 
+      def setup
+        super
         return if File.file?(models_filename)
 
         File.open(models_filename, 'w') do |file|
@@ -56,72 +74,73 @@ MESSAGE
         end
       end
 
-      private
-
-      def add_ids_to(model)
-        max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
-
-        label = model.mapped_label_name
-        last_time_taken = nil
-
-        until (nodes_left = idless_count(label, model.primary_key)) == 0
-          print_status(last_time_taken, max_per_batch, nodes_left)
-
-          count = [nodes_left, max_per_batch].min
-          last_time_taken = Benchmark.realtime do
-            max_per_batch = id_batch_set(label, model.primary_key, count.times.map { new_id_for(model) }, count)
-          end
-        end
-      end
-
-      def idless_count(label, id_property)
-        Neo4j::Session.query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
-      end
-
-      def print_status(last_time_taken, max_per_batch, nodes_left)
-        time_per_node = last_time_taken / max_per_batch if last_time_taken
-        message = if time_per_node
-                    eta_seconds = (nodes_left * time_per_node).round
-                    "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
-                  else
-                    "Running first batch...\r"
-                  end
-
-        print_output message
-      end
-
-
-      def id_batch_set(label, id_property, new_ids, count)
-        tx = Neo4j::Transaction.new
-
-        Neo4j::Session.query("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
-          with COLLECT(n) as nodes, #{new_ids} as ids
-          FOREACH(i in range(0,#{count - 1})|
-            FOREACH(node in [nodes[i]]|
-              SET node.#{id_property} = ids[i]))
-          RETURN distinct(true)
-          LIMIT #{count}")
-
-        count
-      rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
-        new_max_per_batch = (max_per_batch * 0.8).round
-        output "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
-        new_max_per_batch
-      ensure
-        tx.close
-      end
-
-      def default_max_per_batch
-        900
-      end
-
-      def new_id_for(model)
-        if model.id_property_info[:type][:auto]
-          SecureRandom.uuid
-        else
-          model.new.send(model.id_property_info[:type][:on])
-        end
-      end
+      # Might need some of this...
+      # private
+
+      # def add_ids_to(model)
+      #  max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
+
+      #  label = model.mapped_label_name
+      #  last_time_taken = nil
+
+      #  until (nodes_left = idless_count(label, model.primary_key)) == 0
+      #    print_status(last_time_taken, max_per_batch, nodes_left)
+
+      #    count = [nodes_left, max_per_batch].min
+      #    last_time_taken = Benchmark.realtime do
+      #      max_per_batch = id_batch_set(label, model.primary_key, Array.new(count) { new_id_for(model) }, count)
+      #    end
+      #  end
+      # end
+
+      # def idless_count(label, id_property)
+      #  Neo4j::ActiveBase.new_query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
+      # end
+
+      # def print_status(last_time_taken, max_per_batch, nodes_left)
+      #  time_per_node = last_time_taken / max_per_batch if last_time_taken
+      #  message = if time_per_node
+      #              eta_seconds = (nodes_left * time_per_node).round
+      #              "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
+      #            else
+      #              "Running first batch...\r"
+      #            end
+
+      #  print_output message
+      # end
+
+
+      # def id_batch_set(label, id_property, new_ids, count)
+      #  tx = Neo4j::ActiveBase.new_transaction
+
+      #  Neo4j::ActiveBase.current_session.query("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
+      #    with COLLECT(n) as nodes, #{new_ids} as ids
+      #    FOREACH(i in range(0,#{count - 1})|
+      #      FOREACH(node in [nodes[i]]|
+      #        SET node.#{id_property} = ids[i]))
+      #    RETURN distinct(true)
+      #    LIMIT #{count}")
+
+      #  count
+      # rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
+      #  new_max_per_batch = (max_per_batch * 0.8).round
+      #  output "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
+      #  new_max_per_batch
+      # ensure
+      #  tx.close
+      # end
+
+      # def default_max_per_batch
+      #  900
+      # end
+
+      # def new_id_for(model)
+      #  if model.id_property_info[:type][:auto]
+      #    SecureRandom.uuid
+      #  else
+      #    model.new.send(model.id_property_info[:type][:on])
+      #  end
+      # end
     end
   end
 end