activegraph 11.0.0.beta.1-java

data/lib/active_graph/node/query/query_proxy_methods_of_mass_updating.rb

@@ -0,0 +1,99 @@
+module ActiveGraph
+  module Node
+    module Query
+      module QueryProxyMethodsOfMassUpdating
+        # Updates some attributes of a group of nodes within a QP chain.
+        # The optional argument makes sense only of `updates` is a string.
+        # @param [Hash,String] updates An hash or a string of parameters to be updated.
+        # @param [Hash] params An hash of parameters for the update string. It's ignored if `updates` is an Hash.
+        def update_all(updates, params = {})
+          # Move this to Node module?
+          update_all_with_query(identity, updates, params)
+        end
+
+        # Updates some attributes of a group of relationships within a QP chain.
+        # The optional argument makes sense only of `updates` is a string.
+        # @param [Hash,String] updates An hash or a string of parameters to be updated.
+        # @param [Hash] params An hash of parameters for the update string. It's ignored if `updates` is an Hash.
+        def update_all_rels(updates, params = {})
+          fail 'Cannot update rels without a relationship variable.' unless @rel_var
+          update_all_with_query(@rel_var, updates, params)
+        end
+
+        # Deletes a group of nodes and relationships within a QP chain. When identifier is omitted, it will remove the last link in the chain.
+        # The optional argument must be a node identifier. A relationship identifier will result in a Cypher Error
+        # @param identifier [String,Symbol] the optional identifier of the link in the chain to delete.
+        def delete_all(identifier = nil)
+          query_with_target(identifier) do |target|
+            begin
+              self.query.with(target).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
+            rescue Neo4j::Driver::Exceptions::ClientException # <=- Seems hacky
+              self.query.delete(target).exec
+            end
+            clear_source_object_cache
+          end
+        end
+
+        # Deletes the relationship between a node and its last link in the QueryProxy chain. Executed in the database, callbacks will not run.
+        def delete(node)
+          self.match_to(node).query.delete(rel_var).exec
+          clear_source_object_cache
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain.  Executed in the database, callbacks will not be run.
+        def delete_all_rels
+          return unless start_object && start_object._persisted_obj
+          self.query.delete(rel_var).exec
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain and replaces them with relationships to the given nodes.
+        # Executed in the database, callbacks will not be run.
+        def replace_with(node_or_nodes)
+          node_or_nodes = Array(node_or_nodes).map { |arg| arg.is_a?(ActiveGraph::Node) ? arg : @model.find(arg) }
+          original_ids = self.pluck(:id)
+          delete_rels_for_nodes(original_ids, node_or_nodes.collect(&:id))
+          add_rels(node_or_nodes, original_ids)
+        end
+
+        def add_rels(node_or_nodes, original_ids)
+          node_or_nodes.map do |obj|
+            obj if original_ids.include?(obj.id) || _create_relation_or_defer(obj)
+          end.compact
+        end
+
+        def delete_rels_for_nodes(original_ids, new_ids)
+          ids = original_ids.select { |id| !new_ids.include?(id) }
+          return unless ids.present?
+          if association.dependent
+            start_object.public_send("dependent_#{association.dependent}_callback", association, ids)
+          else
+            self.where(id: ids).delete_all_rels
+          end
+        end
+
+        # Returns all relationships between a node and its last link in the QueryProxy chain, destroys them in Ruby. Callbacks will be run.
+        def destroy(node)
+          self.rels_to(node).map!(&:destroy)
+          clear_source_object_cache
+        end
+
+        private
+
+        def update_all_with_query(var_name, updates, params)
+          query = all.query
+
+          case updates
+          when Hash then query.set(var_name => updates).pluck("count(#{var_name})").first
+          when String then query.set(updates).params(params).pluck("count(#{var_name})").first
+          else
+            fail ArgumentError, "Invalid parameter type #{updates.class} for `updates`."
+          end
+        end
+
+        def clear_source_object_cache
+          self.source_object.clear_association_cache if self.source_object.respond_to?(:clear_association_cache)
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/node/query_methods.rb

@@ -0,0 +1,68 @@
+module ActiveGraph
+  module Node
+    module QueryMethods
+      def exists?(node_condition = nil)
+        unless [Integer, String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
+          fail(ActiveGraph::InvalidParameterError, ':exists? only accepts ids or conditions')
+        end
+        query_start = exists_query_start(node_condition)
+        start_q = query_start.respond_to?(:query_as) ? query_start.query_as(:n) : query_start
+        result = start_q.return('ID(n) AS proof_of_life LIMIT 1').first
+        !!result
+      end
+
+      # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def first
+        self.query_as(:n).limit(1).order(n: primary_key).pluck(:n).first
+      end
+
+      # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def last
+        self.query_as(:n).limit(1).order(n: {primary_key => :desc}).pluck(:n).first
+      end
+
+      # @return [Integer] number of nodes of this class
+      def count(distinct = nil)
+        fail(ActiveGraph::InvalidParameterError, ':count accepts the `:distinct` symbol or nil as a parameter') unless distinct.nil? || distinct == :distinct
+        q = distinct.nil? ? 'n' : 'DISTINCT n'
+        self.query_as(:n).return("count(#{q}) AS count").first[:count]
+      end
+
+      alias size count
+      alias length count
+
+      def empty?
+        !self.all.exists?
+      end
+
+      alias blank? empty?
+
+      def find_in_batches(options = {})
+        self.query_as(:n).return(:n).find_in_batches(:n, primary_key, options) do |batch|
+          yield batch.map { |record| record[:n] }
+        end
+      end
+
+      def find_each(options = {})
+        self.query_as(:n).return(:n).find_each(:n, primary_key, options) do |batch|
+          yield batch[:n]
+        end
+      end
+
+      private
+
+      def exists_query_start(node_condition)
+        case node_condition
+        when Integer
+          self.query_as(:n).where('ID(n)' => node_condition)
+        when String
+          self.query_as(:n).where(n: {primary_key => node_condition})
+        when Hash
+          self.where(node_condition.keys.first => node_condition.values.first)
+        else
+          self.query_as(:n)
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/node/reflection.rb

@@ -0,0 +1,86 @@
+module ActiveGraph::Node
+  # A reflection contains information about an association.
+  # They are often used in connection with form builders to determine associated classes.
+  # This module contains methods related to the creation and retrieval of reflections.
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Adds methods to the class related to creating and retrieving reflections.
+    module ClassMethods
+      # @param macro [Symbol] the association type, :has_many or :has_one
+      # @param name [Symbol] the association name
+      # @param association_object [ActiveGraph::Node::HasN::Association] the association object created in the course of creating this reflection
+      def create_reflection(macro, name, association_object, model)
+        self.reflections = self.reflections.merge(name => AssociationReflection.new(macro, name, association_object))
+        association_object.add_destroy_callbacks(model)
+      end
+
+      private :create_reflection
+      # @param association [Symbol] an association declared on the model
+      # @return [ActiveGraph::Node::Reflection::AssociationReflection] of the given association
+      def reflect_on_association(association)
+        reflections[association.to_sym]
+      end
+
+      # Returns an array containing one reflection for each association declared in the model.
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+    end
+
+    # The actual reflection object that contains information about the given association.
+    # These should never need to be created manually, they will always be created by declaring a :has_many or :has_one association on a model.
+    class AssociationReflection
+      # The name of the association
+      attr_reader :name
+
+      # The type of association
+      attr_reader :macro
+
+      # The association object referenced by this reflection
+      attr_reader :association
+
+      def initialize(macro, name, association)
+        @macro        = macro
+        @name         = name
+        @association  = association
+      end
+
+      # Returns the target model
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the name of the target model
+      def class_name
+        @class_name ||= association.target_class.name
+      end
+
+      def rel_klass
+        @rel_klass ||= rel_class_name.constantize
+      end
+
+      def rel_class_name
+        @rel_class_name ||= association.relationship_class.name.to_s
+      end
+
+      def type
+        @type ||= association.relationship_type
+      end
+
+      def collection?
+        macro == :has_many
+      end
+
+      def validate?
+        true
+      end
+    end
+  end
+end

data/lib/active_graph/node/rels.rb

@@ -0,0 +1,11 @@
+module ActiveGraph::Node
+  module Rels
+    extend Forwardable
+    def_delegators :_rels_delegator, :rel?, :rel, :rels, :node, :nodes, :create_rel
+
+    def _rels_delegator
+      fail "Can't access relationship on a non persisted node" unless _persisted_obj
+      _persisted_obj
+    end
+  end
+end

data/lib/active_graph/node/scope.rb

@@ -0,0 +1,166 @@
+require 'active_support/per_thread_registry'
+
+module ActiveGraph::Node
+  module Scope
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Similar to ActiveRecord scope
+      #
+      # @example without argument
+      #   class Person
+      #     include ActiveGraph::Node
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, type: :has_friend, model_class: self
+      #     scope :top_students, -> { where(score: 42)}") }
+      #   end
+      #   Person.top_students.to_a
+      #   a_person.friends.top_students.to_a
+      #   a_person.friends.friends.top_students.to_a
+      #   a_person.friends.top_students.friends.to_a
+      #
+      # @example Argument for scopes
+      #   Person.scope :level, ->(num) { where(level_num: num)}
+      #
+      # @example Argument as a cypher identifier
+      #   class Person
+      #     include ActiveGraph::Node
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, type: :has_friend, model_class: self
+      #     scope :great_students, ->(identifier) { where("#{identifier}.score > 41") }
+      #   end
+      #   Person.as(:all_people).great_students(:all_people).to_a
+      #
+      # @see http://guides.rubyonrails.org/active_record_querying.html#scopes
+      def scope(name, proc)
+        scopes[name.to_sym] = proc
+
+        klass = class << self; self; end
+        klass.instance_eval do
+          define_method(name) do |*query_params|
+            eval_context = ScopeEvalContext.new(self, current_scope || self.query_proxy)
+            proc = full_scopes[name.to_sym]
+            _call_scope_context(eval_context, query_params, proc)
+          end
+        end
+
+        define_method(name) do |*query_params|
+          as(:n).public_send(name, *query_params)
+        end
+      end
+
+      # rubocop:disable Naming/PredicateName
+      def has_scope?(name)
+        ActiveSupport::Deprecation.warn 'has_scope? is deprecated and may be removed from future releases, use scope? instead.', caller
+
+        scope?(name)
+      end
+      # rubocop:enable Naming/PredicateName
+
+      # @return [Boolean] true if model has access to scope with this name
+      def scope?(name)
+        full_scopes.key?(name.to_sym)
+      end
+
+      # @return [Hash] of scopes assigned to this model. Keys are scope name, value is scope callable.
+      def scopes
+        @scopes ||= {}
+      end
+
+      # @return [Hash] of scopes available to this model. Keys are scope name, value is scope callable.
+      def full_scopes
+        self.ancestors.find_all { |a| a.respond_to?(:scopes) }.reverse.inject({}) do |scopes, a|
+          scopes.merge(a.scopes)
+        end
+      end
+
+      def _call_scope_context(eval_context, query_params, proc)
+        eval_context.instance_exec(*query_params.fill(nil, query_params.length..proc.arity - 1), &proc)
+      end
+
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      end
+
+      def all(new_var = nil)
+        var = new_var || (current_scope ? current_scope.node_identity : :n)
+        if current_scope
+          current_scope.new_link(var)
+        else
+          self.as(var)
+        end
+      end
+    end
+
+    class ScopeEvalContext
+      def initialize(target, query_proxy)
+        @query_proxy = query_proxy
+        @target = target
+      end
+
+      def identity
+        query_proxy_or_target.identity
+      end
+
+      ActiveGraph::Node::Query::QueryProxy::METHODS.each do |method|
+        define_method(method) do |*args|
+          @target.all.scoping do
+            query_proxy_or_target.public_send(method, *args)
+          end
+        end
+      end
+
+      # method_missing is not delegated to super class but to aggregated class
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(name, *params, &block)
+        query_proxy_or_target.public_send(name, *params, &block)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      private
+
+      def query_proxy_or_target
+        @query_proxy_or_target ||= @query_proxy || @target
+      end
+    end
+
+
+    # Stolen from ActiveRecord
+    # https://github.com/rails/rails/blob/08754f12e65a9ec79633a605e986d0f1ffa4b251/activerecord/lib/active_record/scoping.rb#L57
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        return if VALID_SCOPE_TYPES.include?(scope_type)
+
+        fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+      end
+    end
+  end
+end

data/lib/active_graph/node/unpersisted.rb

@@ -0,0 +1,48 @@
+module ActiveGraph
+  module Node
+    module Unpersisted
+      # The values in this Hash are returned and used outside by reference
+      # so any modifications to the Array should be in-place
+      def deferred_create_cache
+        @deferred_create_cache ||= {}
+      end
+
+      def defer_create(association_name, object, options = {})
+        clear_deferred_nodes_for_association(association_name) if options[:clear]
+
+        deferred_nodes_for_association(association_name).concat(Array(object))
+      end
+
+      def deferred_nodes_for_association(association_name)
+        deferred_create_cache[association_name.to_sym] ||= []
+      end
+
+      def pending_deferred_creations?
+        !deferred_create_cache.values.all?(&:empty?)
+      end
+
+      def clear_deferred_nodes_for_association(association_name)
+        deferred_nodes_for_association(association_name.to_sym).clear
+      end
+
+      private
+
+      def process_unpersisted_nodes!
+        deferred_create_cache.dup.each do |association_name, nodes|
+          association_proxy = association_proxy(association_name)
+
+          nodes.each do |node|
+            if node.respond_to?(:changed?)
+              node.save if node.changed? || !node.persisted?
+              fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
+            end
+
+            association_proxy << node
+          end
+        end
+
+        @deferred_create_cache = {}
+      end
+    end
+  end
+end