neo4j 6.1.12 → 7.0.0.rc.1

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

@@ -0,0 +1,83 @@
+module Neo4j
+  module ActiveNode
+    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 ActiveNode 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::Session::CypherError
+              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)
+          nodes = Array(node_or_nodes)
+
+          self.delete_all_rels
+          nodes.each { |node| self << node }
+        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/neo4j/active_node/query_methods.rb

@@ -1,11 +1,9 @@
 module Neo4j
   module ActiveNode
     module QueryMethods
-      class InvalidParameterError < StandardError; end
-
       def exists?(node_condition = nil)
         unless node_condition.is_a?(Integer) || node_condition.is_a?(Hash) || node_condition.nil?
-          fail(InvalidParameterError, ':exists? only accepts ids or conditions')
+          fail(Neo4j::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
@@ -24,7 +22,7 @@ module Neo4j
 
       # @return [Integer] number of nodes of this class
       def count(distinct = nil)
-        fail(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+        fail(Neo4j::InvalidParameterError, ':count accepts `distinct` 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

data/lib/neo4j/active_node/scope.rb

@@ -35,13 +35,13 @@ module Neo4j::ActiveNode
       #
       # @see http://guides.rubyonrails.org/active_record_querying.html#scopes
       def scope(name, proc)
-        scopes[name.to_sym] = proc
+        _scope[name.to_sym] = proc
 
         klass = class << self; self; end
         klass.instance_eval do
           define_method(name) do |query_params = nil, _ = nil|
             eval_context = ScopeEvalContext.new(self, current_scope || self.query_proxy)
-            proc = full_scopes[name.to_sym]
+            proc = _scope[name.to_sym]
             _call_scope_context(eval_context, query_params, proc)
           end
         end
@@ -56,15 +56,11 @@ module Neo4j::ActiveNode
       # rubocop:enable Style/PredicateName
 
       def scope?(name)
-        full_scopes.key?(name.to_sym)
+        _scope.key?(name.to_sym)
       end
 
-      def scopes
-        @scopes ||= {}
-      end
-
-      def full_scopes
-        scopes.merge(self.superclass.respond_to?(:scopes) ? self.superclass.scopes : {})
+      def _scope
+        @_scope ||= {}
       end
 
       def _call_scope_context(eval_context, query_params, proc)

data/lib/neo4j/active_rel.rb

@@ -17,8 +17,9 @@ module Neo4j
     include Neo4j::ActiveRel::Callbacks
     include Neo4j::ActiveRel::Query
     include Neo4j::ActiveRel::Types
+    include Neo4j::Shared::Enum
 
-    class FrozenRelError < StandardError; end
+    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))

data/lib/neo4j/active_rel/related_node.rb

@@ -3,8 +3,7 @@ module Neo4j::ActiveRel
   # It's important (or maybe not really IMPORTANT, but at least worth mentioning) that calling method_missing
   # will result in a query to load the node if the node is not already loaded.
   class RelatedNode
-    class InvalidParameterError < StandardError; end
-    class UnsetRelatedNodeError < StandardError; end
+    class UnsetRelatedNodeError < Neo4j::Error; end
 
     # ActiveRel's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
     #
@@ -13,7 +12,7 @@ module Neo4j::ActiveRel
     # Initialization with an integer happens when a relationship is loaded from the database. It loads using the ID
     # because that is provided by the Cypher response and does not require an extra query.
     def initialize(node = nil)
-      @node = valid_node_param?(node) ? node : (fail InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
+      @node = valid_node_param?(node) ? node : (fail Neo4j::InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
     end
 
     # Loads the node if needed, then conducts comparison.

data/lib/neo4j/errors.rb

@@ -1,12 +1,28 @@
 module Neo4j
   # Neo4j.rb Errors
   # Generic Neo4j.rb exception class.
-  class Neo4jrbError < StandardError
+  class Error < StandardError
   end
 
   # Raised when Neo4j.rb cannot find record by given id.
-  class RecordNotFound < Neo4jrbError
+  class RecordNotFound < Error
+    attr_reader :model, :primary_key, :id
+
+    def initialize(message = nil, model = nil, primary_key = nil, id = nil)
+      @primary_key = primary_key
+      @model = model
+      @id = id
+
+      super(message)
+    end
   end
 
-  class InvalidPropertyOptionsError < Neo4jrbError; end
+  class InvalidPropertyOptionsError < Error; end
+
+  class InvalidParameterError < Error; end
+
+  class UnknownTypeConverterError < Error; end
+
+  class DangerousAttributeError < ScriptError; end
+  class UnknownAttributeError < NoMethodError; end
 end

data/lib/neo4j/railtie.rb

@@ -1,5 +1,7 @@
 require 'active_support/notifications'
 require 'rails/railtie'
+# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
+require 'action_dispatch/railtie'
 
 module Neo4j
   class Railtie < ::Rails::Railtie
@@ -11,6 +13,17 @@ module Neo4j
       end
     end
 
+    # Rescue responses similar to ActiveRecord.
+    # For rails 3.2 and 4.0
+    if config.action_dispatch.respond_to?(:rescue_responses)
+      config.action_dispatch.rescue_responses.merge!(
+        'Neo4j::RecordNotFound' => :not_found
+      )
+    else
+      # For rails 3.0 and 3.1
+      ActionDispatch::ShowExceptions.rescue_responses['Neo4j::RecordNotFound'] = :not_found
+    end
+
     # Add ActiveModel translations to the I18n load_path
     initializer 'i18n' do
       config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]

data/lib/neo4j/shared/attributes.rb

@@ -0,0 +1,207 @@
+module Neo4j::Shared
+  # Attributes provides a set of class methods for defining an attributes
+  # schema and instance methods for reading and writing attributes.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::Attributes
+  #     attribute :name
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Ben Poweski"
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    # Methods deprecated on the Object class which can be safely overridden
+    DEPRECATED_OBJECT_METHODS = %w(id type)
+
+    included do
+      attribute_method_suffix '' if attribute_method_matchers.none? { |matcher| matcher.prefix == '' && matcher.suffix == '' }
+      attribute_method_suffix '='
+    end
+
+    # Performs equality checking on the result of attributes and its type.
+    #
+    # @example Compare for equality.
+    #   model == other
+    #
+    # @param [ActiveAttr::Attributes, Object] other The other model to compare
+    #
+    # @return [true, false] True if attributes are equal and other is instance
+    #   of the same Class, false if not.
+    def ==(other)
+      return false unless other.instance_of? self.class
+      attributes == other.attributes
+    end
+
+    # Returns a Hash of all attributes
+    #
+    # @example Get attributes
+    #   person.attributes # => {"name"=>"Ben Poweski"}
+    #
+    # @return [Hash{String => Object}] The Hash of all attributes
+    def attributes
+      attributes_map { |name| send name }
+    end
+
+    # Write a single attribute to the model's attribute hash.
+    #
+    # @example Write the attribute with write_attribute
+    #   person.write_attribute(:name, "Benjamin")
+    # @example Write an attribute with bracket syntax
+    #   person[:name] = "Benjamin"
+    #
+    # @param [String, Symbol, #to_s] name The name of the attribute to update.
+    # @param [Object] value The value to set for the attribute.
+    #
+    # @raise [UnknownAttributeError] if the attribute is unknown
+    def write_attribute(name, value)
+      if respond_to? "#{name}="
+        send "#{name}=", value
+      else
+        fail Neo4j::UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+    alias_method :[]=, :write_attribute
+
+    private
+
+    # Read an attribute from the attributes hash
+    def attribute(name)
+      @attributes ||= {}
+      @attributes[name]
+    end
+
+    # Write an attribute to the attributes hash
+    def attribute=(name, value)
+      @attributes ||= {}
+      @attributes[name] = value
+    end
+
+    # Maps all attributes using the given block
+    #
+    # @example Stringify attributes
+    #   person.attributes_map { |name| send(name).to_s }
+    #
+    # @yield [name] block called to return hash value
+    # @yieldparam [String] name The name of the attribute to map.
+    #
+    # @return [Hash{String => Object}] The Hash of mapped attributes
+    def attributes_map
+      Hash[self.class.attribute_names.map { |name| [name, yield(name)] }]
+    end
+
+    module ClassMethods
+      # Defines an attribute
+      #
+      # For each attribute that is defined, a getter and setter will be
+      # added as an instance method to the model. An
+      # {AttributeDefinition} instance will be added to result of the
+      # attributes class method.
+      #
+      # @example Define an attribute.
+      #   attribute :name
+      #
+      # @param (see AttributeDefinition#initialize)
+      #
+      # @raise [DangerousAttributeError] if the attribute name conflicts with
+      #   existing methods
+      #
+      # @return [AttributeDefinition] Attribute's definition
+      def attribute(name)
+        if dangerous_attribute?(name)
+          fail Neo4j::DangerousAttributeError, %(an attribute method named "#{name}" would conflict with an existing method)
+        else
+          attribute!(name)
+        end
+      end
+
+      # Returns an Array of attribute names as Strings
+      #
+      # @example Get attribute names
+      #   Person.attribute_names
+      #
+      # @return [Array<String>] The attribute names
+      def attribute_names
+        attributes.keys
+      end
+
+      # Returns a Hash of AttributeDefinition instances
+      #
+      # @example Get attribute definitions
+      #   Person.attributes
+      #
+      # @return [ActiveSupport::HashWithIndifferentAccess{String => Neo4j::Shared::AttributeDefinition}]
+      #   The Hash of AttributeDefinition instances
+      def attributes
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      # Determine if a given attribute name is dangerous
+      #
+      # Some attribute names can cause conflicts with existing methods
+      # on an object. For example, an attribute named "timeout" would
+      # conflict with the timeout method that Ruby's Timeout library
+      # mixes into Object.
+      #
+      # @example Testing a harmless attribute
+      #   Person.dangerous_attribute? :name #=> false
+      #
+      # @example Testing a dangerous attribute
+      #   Person.dangerous_attribute? :nil #=> "nil?"
+      #
+      # @param name Attribute name
+      #
+      # @return [false, String] False or the conflicting method name
+      def dangerous_attribute?(name)
+        attribute_methods(name).detect do |method_name|
+          !DEPRECATED_OBJECT_METHODS.include?(method_name.to_s) && allocate.respond_to?(method_name, true)
+        end unless attribute_names.include? name.to_s
+      end
+
+      # Returns the class name plus its attribute names
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      def inspect
+        inspected_attributes = attribute_names.sort
+        attributes_list = "(#{inspected_attributes.join(', ')})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+      protected
+
+      # Assign a set of attribute definitions, used when subclassing models
+      #
+      # @param [Array<Neo4j::Shared::DeclaredProperties>] The Array of
+      #   AttributeDefinition instances
+      def attributes=(attributes)
+        @attributes = attributes
+      end
+
+      # Overrides ActiveModel::AttributeMethods to backport 3.2 fix
+      def instance_method_already_implemented?(method_name)
+        generated_attribute_methods.method_defined?(method_name)
+      end
+
+      private
+
+      # Expand an attribute name into its generated methods names
+      def attribute_methods(name)
+        attribute_method_matchers.map { |matcher| matcher.method_name name }
+      end
+
+      # Ruby inherited hook to assign superclass attributes to subclasses
+      def inherited(subclass)
+        super
+        subclass.attributes = attributes.dup
+      end
+    end
+  end
+end

data/lib/neo4j/shared/declared_properties.rb

@@ -101,8 +101,7 @@ module Neo4j::Shared
     def unregister(name)
       # might need to be include?(name.to_s)
       fail ArgumentError, "Argument `#{name}` not an attribute" if not registered_properties[name]
-      declared_prop = registered_properties[name]
-      registered_properties.delete(declared_prop)
+      registered_properties.delete(name)
       unregister_magic_typecaster(name)
       unregister_property_default(name)
     end
@@ -133,11 +132,6 @@ module Neo4j::Shared
       @magic_typecast_properties ||= {}
     end
 
-    # The known mappings of declared properties and their primitive types.
-    def upstream_primitives
-      @upstream_primitives ||= {}
-    end
-
     EXCLUDED_TYPES = [Array, Range, Regexp]
     def value_for_where(key, value)
       return value unless prop = registered_properties[key]
@@ -166,7 +160,7 @@ module Neo4j::Shared
 
     # Prevents repeated calls to :_attribute_type, which isn't free and never changes.
     def fetch_upstream_primitive(attr)
-      upstream_primitives[attr] || upstream_primitives[attr] = klass._attribute_type(attr)
+      registered_properties[attr].type
     end
 
     private