neo4j_legacy 7.2.0.1

data/lib/neo4j/active_node/persistence.rb

@@ -0,0 +1,175 @@
+module Neo4j::ActiveNode
+  module Persistence
+    class RecordInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(', '))
+      end
+    end
+
+    extend ActiveSupport::Concern
+    extend Forwardable
+    include Neo4j::Shared::Persistence
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise the existing record gets updated.
+    # If perform_validation is true validations run.
+    # If any of them fail the action is cancelled and save returns false.
+    # If the flag is false validations are bypassed altogether.
+    # See ActiveRecord::Validations for more information.
+    # There's a series of callbacks associated with save.
+    # If any of the before_* callbacks return false the action is cancelled and save returns false.
+    def save(*)
+      cascade_save do
+        association_proxy_cache.clear
+        create_or_update
+      end
+    end
+
+    # Increments concurrently a numeric attribute by a centain amount
+    # @param [Symbol, String] name of the attribute to increment
+    # @param [Integer, Float] amount to increment
+    def concurrent_increment!(attribute, by = 1)
+      query_node = Neo4j::Session.query.match_nodes(n: neo_id)
+      increment_by_query! query_node, attribute, by
+    end
+
+    # Persist the object to the database.  Validations and Callbacks are included
+    # by default but validation can be disabled by passing :validate => false
+    # to #save!  Creates a new transaction.
+    #
+    # @raise a RecordInvalidError if there is a problem during save.
+    # @param (see Neo4j::Rails::Validations#save)
+    # @return nil
+    # @see #save
+    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
+    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
+    def save!(*args)
+      save(*args) or fail(RecordInvalidError, self) # rubocop:disable Style/AndOr
+    end
+
+    # Creates a model with values matching those of the instance attributes and returns its id.
+    # @private
+    # @return true
+    def create_model
+      node = _create_node(props_for_create)
+      init_on_load(node, node.props)
+      @deferred_nodes = nil
+      true
+    end
+
+    # TODO: This does not seem like it should be the responsibility of the node.
+    # Creates an unwrapped node in the database.
+    # @param [Hash] node_props The type-converted properties to be added to the new node.
+    # @param [Array] labels The labels to use for creating the new node.
+    # @return [Neo4j::Node] A CypherNode or EmbeddedNode
+    def _create_node(node_props, labels = labels_for_create)
+      self.class.neo4j_session.create_node(node_props, labels)
+    end
+
+    # As the name suggests, this inserts the primary key (id property) into the properties hash.
+    # The method called here, `default_property_values`, is a holdover from an earlier version of the gem. It does NOT
+    # contain the default values of properties, it contains the Default Property, which we now refer to as the ID Property.
+    # It will be deprecated and renamed in a coming refactor.
+    # @param [Hash] converted_props A hash of properties post-typeconversion, ready for insertion into the DB.
+    def inject_primary_key!(converted_props)
+      self.class.default_property_values(self).tap do |destination_props|
+        destination_props.merge!(converted_props) if converted_props.is_a?(Hash)
+      end
+    end
+
+    # @return [Array] Labels to be set on the node during a create event
+    def labels_for_create
+      self.class.mapped_label_names
+    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
+      Neo4j::Transaction.run(pending_deferred_creations?) do
+        result = yield
+        process_unpersisted_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 = {})
+        new(props).tap do |obj|
+          yield obj if block_given?
+          obj.save
+        end
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(props = {})
+        new(props).tap do |o|
+          yield o if block_given?
+          o.save!
+        end
+      end
+
+      def merge(match_attributes, optional_attrs = {})
+        options = [:on_create, :on_match, :set]
+        optional_attrs.assert_valid_keys(*options)
+
+        optional_attrs.default = {}
+        on_create_attrs, on_match_attrs, set_attrs = optional_attrs.values_at(*options)
+
+        neo4j_session.query.merge(n: {self.mapped_label_names => match_attributes})
+          .on_create_set(on_create_clause(on_create_attrs))
+          .on_match_set(on_match_clause(on_match_attrs))
+          .break.set(n: set_attrs)
+          .pluck(:n).first
+      end
+
+      def find_or_create(find_attributes, set_attributes = {})
+        on_create_attributes = set_attributes.reverse_merge(find_attributes.merge(self.new(find_attributes).props_for_create))
+
+        neo4j_session.query.merge(n: {self.mapped_label_names => find_attributes})
+          .on_create_set(n: on_create_attributes)
+          .pluck(:n).first
+      end
+
+      # Finds the first node with the given attributes, or calls create if none found
+      def find_or_create_by(attributes, &block)
+        find_by(attributes) || create(attributes, &block)
+      end
+
+      # Same as #find_or_create_by, but calls #create! so it raises an error if there is a problem during save.
+      def find_or_create_by!(attributes, &block)
+        find_by(attributes) || create!(attributes, &block)
+      end
+
+      def load_entity(id)
+        Neo4j::Node.load(id)
+      end
+
+      private
+
+      def on_create_clause(clause)
+        if clause.is_a?(Hash)
+          {n: clause.merge(self.new(clause).props_for_create)}
+        else
+          clause
+        end
+      end
+
+      def on_match_clause(clause)
+        if clause.is_a?(Hash)
+          {n: clause.merge(attributes_nil_hash.key?('updated_at') ? {updated_at: Time.new.to_i} : {})}
+        else
+          clause
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/property.rb

@@ -0,0 +1,60 @@
+module Neo4j::ActiveNode
+  module Property
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Property
+
+    def initialize(attributes = nil)
+      super(attributes)
+      @attributes ||= Hash[self.class.attributes_nil_hash]
+    end
+
+    module ClassMethods
+      # Extracts keys from attributes hash which are associations 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 unless contains_association?(attributes)
+        attributes.each_with_object({}) do |(key, _), result|
+          result[key] = attributes.delete(key) if self.association_key?(key)
+        end
+      end
+
+      def association_key?(key)
+        association_method_keys.include?(key.to_sym)
+      end
+
+      private
+
+      def contains_association?(attributes)
+        return false unless attributes
+        attributes.each_key { |k| return true if association_key?(k) }
+        false
+      end
+
+      # All keys which could be association setter methods (including _id/_ids)
+      def association_method_keys
+        @association_method_keys ||=
+          associations_keys.map(&:to_sym) +
+          associations.values.map do |association|
+            if association.type == :has_one
+              "#{association.name}_id"
+            elsif association.type == :has_many
+              "#{association.name.to_s.singularize}_ids"
+            end.to_sym
+          end
+      end
+    end
+
+    private
+
+    def inspect_attributes
+      id_property_name = self.class.id_property_name.to_s
+
+      attribute_pairs = attributes.except(id_property_name).sort.map do |key, value|
+        [key, (value.is_a?(String) && value.size > 100) ? value.dup[0..100] : value]
+      end
+
+      attribute_pairs.unshift([id_property_name, self.send(id_property_name)])
+      attribute_pairs
+    end
+  end
+end

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

@@ -0,0 +1,361 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      class QueryProxy
+        include Neo4j::ActiveNode::Query::QueryProxyEnumerable
+        include Neo4j::ActiveNode::Query::QueryProxyMethods
+        include Neo4j::ActiveNode::Query::QueryProxyMethodsOfMassUpdating
+        include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
+        include Neo4j::ActiveNode::Query::QueryProxyEagerLoading
+        include Neo4j::ActiveNode::Dependent::QueryProxyMethods
+
+        # The most recent node to start a QueryProxy chain.
+        # Will be nil when using QueryProxy chains on class methods.
+        attr_reader :source_object, :association, :model, :starting_query
+
+        # QueryProxy is ActiveNode's Cypher DSL. While the name might imply that it creates queries in a general sense,
+        # it is actually referring to <tt>Neo4j::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
+        # QueryProxy provides ActiveRecord-like methods for common patterns. When it's not handling CRUD for relationships and queries, it
+        # provides ActiveNode's association chaining (`student.lessons.teachers.where(age: 30).hobbies`) and enjoys long walks on the
+        # beach.
+        #
+        # It should not ever be necessary to instantiate a new QueryProxy object directly, it always happens as a result of
+        # calling a method that makes use of it.
+        #
+        # @param [Constant] model The class which included ActiveNode (typically a model, hence the name) from which the query
+        # originated.
+        # @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:
+        # @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 = {})
+          @model = model
+          @association = association
+          @context = options.delete(:context)
+          @options = options
+          @associations_spec = []
+
+          instance_vars_from_options!(options)
+
+          @match_type = @optional ? :optional_match : :match
+
+          @rel_var = options[:rel] || _rel_chain_var
+
+          @chain = []
+          @params = @query_proxy ? @query_proxy.instance_variable_get('@params') : {}
+        end
+
+        def inspect
+          "#<QueryProxy #{@context} CYPHER: #{self.to_cypher.inspect}>"
+        end
+
+        attr_reader :start_object, :query_proxy
+
+        # The current node identifier on deck, so to speak. It is the object that will be returned by calling `each` and the last node link
+        # in the QueryProxy chain.
+        attr_reader :node_var
+        def identity
+          @node_var || _result_string
+        end
+        alias_method :node_identity, :identity
+
+        # The relationship identifier most recently used by the QueryProxy chain.
+        attr_reader :rel_var
+        def rel_identity
+          ActiveSupport::Deprecation.warn 'rel_identity is deprecated and may be removed from future releases, use rel_var instead.', caller
+
+          @rel_var
+        end
+
+        def params(params)
+          new_link.tap { |new_query| new_query._add_params(params) }
+        end
+
+        # Like calling #query_as, but for when you don't care about the variable name
+        def query
+          query_as(identity)
+        end
+
+        # 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|
+            args = link.args(var, rel_var)
+
+            args.is_a?(Array) ? query.send(link.clause, *args) : query.send(link.clause, args)
+          end
+
+          result_query.tap { |query| query.proxy_chain_level = _chain_level }
+        end
+
+        def base_query(var, with_labels = true)
+          if @association
+            chain_var = _association_chain_var
+            (_association_query_start(chain_var) & _query).break.send(@match_type,
+                                                                      "(#{chain_var})#{_association_arrow}(#{var}#{_model_label_string})")
+          else
+            starting_query ? starting_query : _query_model_as(var, with_labels)
+          end
+        end
+
+        # param [TrueClass, FalseClass] with_labels This param is used by certain QueryProxy methods that already have the neo_id and
+        # therefore do not need labels.
+        # The @association_labels instance var is set during init and used during association chaining to keep labels out of Cypher queries.
+        def _model_label_string(with_labels = true)
+          return if !@model || (!with_labels || @association_labels == false)
+          @model.mapped_label_names.map { |label_name| ":`#{label_name}`" }.join
+        end
+
+        # Scope all queries to the current scope.
+        #
+        # .. code-block:: ruby
+        #
+        #   Comment.where(post_id: 1).scoping do
+        #     Comment.first
+        #   end
+        #
+        # TODO: unscoped
+        # Please check unscoped if you want to remove all previous scopes (including
+        # the default_scope) during the execution of a block.
+        def scoping
+          previous = @model.current_scope
+          @model.current_scope = self
+          yield
+        ensure
+          @model.current_scope = previous
+        end
+
+        METHODS = %w(where where_not rel_where rel_order order skip limit)
+
+        METHODS.each do |method|
+          define_method(method) { |*args| build_deeper_query_proxy(method.to_sym, args) }
+        end
+        # Since there are rel_where and rel_order methods, it seems only natural for there to be node_where and node_order
+        alias_method :node_where, :where
+        alias_method :node_order, :order
+        alias_method :offset, :skip
+        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>.
+        delegate :to_cypher, to: :query
+
+        delegate :print_cypher, to: :query
+
+        # Returns a string of the cypher query with return objects and params
+        # @param [Array] columns array containing symbols of identifiers used in the query
+        # @return [String]
+        def to_cypher_with_params(columns = [self.identity])
+          final_query = query.return_query(columns)
+          "#{final_query.to_cypher} | params: #{final_query.send(:merge_params)}"
+        end
+
+        # To add a relationship for the node for the association on this QueryProxy
+        def <<(other_node)
+          if @start_object._persisted_obj
+            create(other_node, {})
+          elsif @association
+            @start_object.defer_create(@association.name, other_node)
+          else
+            fail 'Another crazy error!'
+          end
+          self
+        end
+
+        # Executes the relation chain specified in the block, while keeping the current scope
+        #
+        # @example Load all people that have friends
+        #   Person.all.branch { friends }.to_a # => Returns a list of `Person`
+        #
+        # @example Load all people that has old friends
+        #   Person.all.branch { friends.where('age > 70') }.to_a # => Returns a list of `Person`
+        #
+        # @yield the block that will be evaluated starting from the current scope
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def branch(&block)
+          if block
+            instance_eval(&block).query.proxy_as(self.model, identity)
+          else
+            fail LocalJumpError, 'no block given'
+          end
+        end
+
+        def [](index)
+          # TODO: Maybe for this and other methods, use array if already loaded, otherwise
+          # use OFFSET and LIMIT 1?
+          self.to_a[index]
+        end
+
+        def create(other_nodes, properties = {})
+          fail 'Can only create relationships on associations' if !@association
+          other_nodes = _nodeify!(*other_nodes)
+
+          Neo4j::Transaction.run do
+            other_nodes.each do |other_node|
+              other_node.save unless other_node.neo_id
+
+              return false if @association.perform_callback(@start_object, other_node, :before) == false
+
+              @start_object.association_proxy_cache.clear
+
+              _create_relationship(other_node, properties)
+
+              @association.perform_callback(@start_object, other_node, :after)
+            end
+          end
+        end
+
+        def _nodeify!(*args)
+          other_nodes = [args].flatten!.map! do |arg|
+            (arg.is_a?(Integer) || arg.is_a?(String)) ? @model.find_by(id: arg) : arg
+          end.compact
+
+          if @model && other_nodes.any? { |other_node| !other_node.class.mapped_label_names.include?(@model.mapped_label_name) }
+            fail ArgumentError, "Node must be of the association's class when model is specified"
+          end
+
+          other_nodes
+        end
+
+        def _create_relationship(other_node_or_nodes, properties)
+          association._create_relationship(@start_object, other_node_or_nodes, properties)
+        end
+
+        def read_attribute_for_serialization(*args)
+          to_a.map { |o| o.read_attribute_for_serialization(*args) }
+        end
+
+        delegate :to_ary, to: :to_a
+
+        # QueryProxy objects act as a representation of a model at the class level so we pass through calls
+        # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
+        def method_missing(method_name, *args, &block)
+          if @model && @model.respond_to?(method_name)
+            scoping { @model.public_send(method_name, *args, &block) }
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_all = false)
+          (@model && @model.respond_to?(method_name, include_all)) || super
+        end
+
+        def optional?
+          @optional == true
+        end
+
+        attr_reader :context
+
+        def new_link(node_var = nil)
+          self.clone.tap do |new_query_proxy|
+            new_query_proxy.instance_variable_set('@result_cache', nil)
+            new_query_proxy.instance_variable_set('@node_var', node_var) if node_var
+          end
+        end
+
+        protected
+
+        # Methods are underscored to prevent conflict with user class methods
+        def _add_params(params)
+          @params = @params.merge(params)
+        end
+
+        def _add_links(links)
+          @chain += links
+        end
+
+        def _query_model_as(var, with_labels = true)
+          _query.break.send(@match_type, _match_arg(var, with_labels))
+        end
+
+        # @param [String, Symbol] var The Cypher identifier to use within the match string
+        # @param [Boolean] with_labels Send "true" to include model labels where possible.
+        def _match_arg(var, with_labels)
+          if @model && with_labels != false
+            labels = @model.respond_to?(:mapped_label_names) ? _model_label_string : @model
+            {var.to_sym => labels}
+          else
+            var.to_sym
+          end
+        end
+
+        def _query
+          _session.query(context: @context)
+        end
+
+        # TODO: Refactor this. Too much happening here.
+        def _result_string
+          s = (self.association && self.association.name) || (self.model && self.model.name) || ''
+
+          s ? "result_#{s}".downcase.tr(':', '').to_sym : :result
+        end
+
+        def _session
+          (@session || (@model && @model.neo4j_session)).tap do |session|
+            fail 'No session found!' if session.nil?
+          end
+        end
+
+        def _association_arrow(properties = {}, create = false)
+          @association && @association.arrow_cypher(@rel_var, properties, create, false, @rel_length)
+        end
+
+        def _chain_level
+          (@query_proxy ? @query_proxy._chain_level : (@chain_level || 0)) + 1
+        end
+
+        def _association_chain_var
+          fail 'Crazy error' if !(start_object || @query_proxy)
+
+          if start_object
+            :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id}"
+          else
+            @query_proxy.node_var || :"node#{_chain_level}"
+          end
+        end
+
+        def _association_query_start(var)
+          # TODO: Better error
+          fail 'Crazy error' if !(object = (start_object || @query_proxy))
+
+          object.query_as(var)
+        end
+
+        def _rel_chain_var
+          :"rel#{_chain_level - 1}"
+        end
+
+        attr_writer :context
+
+        private
+
+        def instance_vars_from_options!(options)
+          @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)
+          new_link.tap do |new_query_proxy|
+            Link.for_args(@model, method, args, association).each { |link| new_query_proxy._add_links(link) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyEagerLoading
+        def each(node = true, rel = nil, &block)
+          return super if with_associations_spec.size.zero?
+
+          query_from_association_spec.pluck(identity, "[#{with_associations_return_clause}]").map do |record, eager_data|
+            eager_data.each_with_index do |eager_records, index|
+              record.association_proxy(with_associations_spec[index]).cache_result(eager_records)
+            end
+
+            block.call(record)
+          end
+        end
+
+        def with_associations_spec
+          @with_associations_spec ||= []
+        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)
+          end
+        end
+
+        private
+
+        def with_associations_return_clause(variables = with_associations_spec)
+          variables.map { |n| "#{n}_collection" }.join(',')
+        end
+
+        def query_from_association_spec
+          previous_with_variables = []
+          with_associations_spec.inject(query_as(identity).with(identity)) do |query, association_name|
+            with_association_query_part(query, association_name, previous_with_variables).tap do
+              previous_with_variables << association_name
+            end
+          end.return(identity)
+        end
+
+        def with_association_query_part(base_query, association_name, previous_with_variables)
+          association = model.associations[association_name]
+
+          base_query.optional_match("(#{identity})#{association.arrow_cypher}(#{association_name})")
+            .where(association.target_where_clause)
+            .with(identity, "collect(#{association_name}) AS #{association_name}_collection", *with_associations_return_clause(previous_with_variables))
+        end
+      end
+    end
+  end
+end