neo4j 4.0.0 → 4.1.0

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

@@ -5,16 +5,16 @@ module Neo4j
     module HasN
       class Association
         include Neo4j::Shared::RelTypeConverters
-        attr_reader :type, :name, :relationship, :direction
+        include Neo4j::ActiveNode::Dependent::AssociationMethods
+        attr_reader :type, :name, :relationship, :direction, :dependent
 
         def initialize(type, direction, name, options = {})
-          check_valid_type_and_dir(type, direction)
+          validate_init_arguments(type, direction, options)
           @type = type.to_sym
           @name = name
           @direction = direction.to_sym
           @target_class_name_from_name = name.to_s.classify
-
-          set_vars_from_options(options)
+          apply_vars_from_options(options)
         end
 
         def target_class_option(options)
@@ -42,7 +42,11 @@ module Neo4j
         end
 
         def target_class_name
-          @target_class_option.to_s if @target_class_option
+          @target_class_name ||= @target_class_option.to_s if @target_class_option
+        end
+
+        def target_class_name_or_nil
+          @target_class_name_or_nil ||= target_class_name || 'nil'
         end
 
         def target_class
@@ -75,9 +79,7 @@ module Neo4j
           end
         end
 
-        def relationship_class
-          @relationship_class
-        end
+        attr_reader :relationship_class
 
         def relationship_class_type
           @relationship_class = @relationship_class.constantize if @relationship_class.class == String || @relationship_class == Symbol
@@ -104,6 +106,10 @@ module Neo4j
           properties
         end
 
+        def unique?
+          @origin ? origin_association.unique? : !!@unique
+        end
+
         private
 
         def get_direction(relationship_cypher, create)
@@ -129,19 +135,24 @@ module Neo4j
           p.size == 0 ? '' : " {#{p}}"
         end
 
+        def origin_association
+          target_class.associations[@origin]
+        end
+
         def origin_type
-          target_class.associations[@origin].relationship_type
+          origin_association.relationship_type
         end
 
         private
 
-        def set_vars_from_options(options)
-          validate_option_combinations(options)
+        def apply_vars_from_options(options)
           @target_class_option = target_class_option(options)
           @callbacks = {before: options[:before], after: options[:after]}
           @origin = options[:origin] && options[:origin].to_sym
           @relationship_class = options[:rel_class]
           @relationship_type  = options[:type] && options[:type].to_sym
+          @dependent = options[:dependent]
+          @unique = options[:unique]
         end
 
         # Return basic details about association as declared in the model
@@ -151,15 +162,25 @@ module Neo4j
           "#{type} #{direction.inspect}, #{name.inspect}"
         end
 
+        def validate_init_arguments(type, direction, options)
+          validate_option_combinations(options)
+          check_valid_type_and_dir(type, direction)
+        end
+
         def check_valid_type_and_dir(type, direction)
-          raise ArgumentError, "Invalid association type: #{type.inspect} (valid value: :has_many and :has_one)" if not [:has_many, :has_one].include?(type.to_sym)
-          raise ArgumentError, "Invalid direction: #{direction.inspect} (valid value: :out, :in, and :both)" if not [:out, :in, :both].include?(direction.to_sym)
+          fail ArgumentError, "Invalid association type: #{type.inspect} (valid value: :has_many and :has_one)" if not [:has_many, :has_one].include?(type.to_sym)
+          fail ArgumentError, "Invalid direction: #{direction.inspect} (valid value: :out, :in, and :both)" if not [:out, :in, :both].include?(direction.to_sym)
         end
 
         def validate_option_combinations(options)
-          raise ArgumentError, "Cannot specify both :type and :origin (#{base_declaration})" if options[:type] && options[:origin]
-          raise ArgumentError, "Cannot specify both :type and :rel_class (#{base_declaration})" if options[:type] && options[:rel_class]
-          raise ArgumentError, "Cannot specify both :origin and :rel_class (#{base_declaration}" if options[:origin] && options[:rel_class]
+          fail ArgumentError, "Cannot specify both :type and :origin (#{base_declaration})" if options[:type] && options[:origin]
+          fail ArgumentError, "Cannot specify both :type and :rel_class (#{base_declaration})" if options[:type] && options[:rel_class]
+          fail ArgumentError, "Cannot specify both :origin and :rel_class (#{base_declaration}" if options[:origin] && options[:rel_class]
+        end
+
+        VALID_DEPENDENT_TYPES = [:delete, :delete_orphans, :destroy_orphans, :destroy, nil]
+        def validate_dependent(value)
+          fail ArgumentError, "Invalid dependent value: #{value.inspect}" if not VALID_DEPENDENT_TYPES.include?(value)
         end
 
         # Determine if model class as derived from the association name would be different than the one specified via the model_class key
@@ -174,22 +195,16 @@ module Neo4j
         end
 
         def validate_origin!
-          if @origin
-            if target_class
-              if association = target_class.associations[@origin]
-                if @direction == association.direction
-                  raise ArgumentError, "Origin `#{@origin.inspect}` (specified in #{base_declaration}) has same direction `#{@direction}`)"
-                end
-              else
-                raise ArgumentError, "Origin `#{@origin.inspect}` association not found for #{target_class} (specified in #{base_declaration})"
-              end
-            else
-              raise ArgumentError, "Cannot use :origin without a model_class (implied or explicit)"
-            end
-          end
+          return if not @origin
+
+          fail ArgumentError, 'Cannot use :origin without a model_class (implied or explicit)' if not target_class
+
+          association = origin_association
+          fail ArgumentError, "Origin `#{@origin.inspect}` association not found for #{target_class} (specified in #{base_declaration})" if not association
+
+          fail ArgumentError, "Origin `#{@origin.inspect}` (specified in #{base_declaration}) has same direction `#{@direction}`)" if @direction == association.direction
         end
       end
     end
   end
 end
-

data/lib/neo4j/active_node/id_property.rb

@@ -1,5 +1,4 @@
 module Neo4j::ActiveNode
-
   # This module makes it possible to use other IDs than the build it neo4j id (neo_id)
   #
   # @example using generated UUIDs
@@ -27,16 +26,16 @@ module Neo4j::ActiveNode
 
     module TypeMethods
       def define_id_methods(clazz, name, conf)
-        raise "Expected a Hash, got #{conf.class} (#{conf.to_s}) for id_property" unless conf.is_a?(Hash)
+        fail "Expected a Hash, got #{conf.class} (#{conf}) for id_property" unless conf.is_a?(Hash)
         if conf[:on]
           define_custom_method(clazz, name, conf[:on])
         elsif conf[:auto]
-          raise "only :uuid auto id_property allowed, got #{conf[:auto]}" unless conf[:auto] == :uuid
+          fail "only :uuid auto id_property allowed, got #{conf[:auto]}" unless conf[:auto] == :uuid
           define_uuid_method(clazz, name)
         elsif conf.empty?
           define_property_method(clazz, name)
         else
-          raise "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
+          fail "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
         end
       end
 
@@ -45,23 +44,22 @@ module Neo4j::ActiveNode
       def define_property_method(clazz, name)
         clear_methods(clazz, name)
 
-        clazz.module_eval(%Q{
+        clazz.module_eval(%(
           def id
-            persisted? ? #{name.to_sym == :id ? 'attribute(\'id\')' : name} : nil
+            _persisted_obj ? #{name.to_sym == :id ? 'attribute(\'id\')' : name} : nil
           end
 
           validates_uniqueness_of :#{name}
 
           property :#{name}
-        }, __FILE__, __LINE__)
-
+                ), __FILE__, __LINE__)
       end
 
 
       def define_uuid_method(clazz, name)
         clear_methods(clazz, name)
 
-        clazz.module_eval(%Q{
+        clazz.module_eval(%(
           default_property :#{name} do
              ::SecureRandom.uuid
           end
@@ -71,13 +69,13 @@ module Neo4j::ActiveNode
           end
 
           alias_method :id, :#{name}
-        }, __FILE__, __LINE__)
+                ), __FILE__, __LINE__)
       end
 
       def define_custom_method(clazz, name, on)
         clear_methods(clazz, name)
 
-        clazz.module_eval(%Q{
+        clazz.module_eval(%{
           default_property :#{name} do |instance|
              raise "Specifying custom id_property #{name} on none existing method #{on}" unless instance.respond_to?(:#{on})
              instance.#{on}
@@ -93,15 +91,15 @@ module Neo4j::ActiveNode
 
       def clear_methods(clazz, name)
         if clazz.method_defined?(name)
-          clazz.module_eval(%Q{
+          clazz.module_eval(%(
             undef_method :#{name}
-          }, __FILE__, __LINE__)
+                    ), __FILE__, __LINE__)
         end
 
         if clazz.attribute_names.include?(name.to_s)
-          clazz.module_eval(%Q{
+          clazz.module_eval(%(
             undef_property :#{name}
-          }, __FILE__, __LINE__)
+                    ), __FILE__, __LINE__)
         end
       end
 
@@ -110,7 +108,6 @@ module Neo4j::ActiveNode
 
 
     module ClassMethods
-
       def find_by_neo_id(id)
         Neo4j::Node.load(id)
       end
@@ -125,7 +122,7 @@ module Neo4j::ActiveNode
 
       def id_property(name, conf = {})
         begin
-          if has_id_property?
+          if id_property?
             unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
               drop_constraint(id_property_name, type: :unique)
             end
@@ -142,7 +139,15 @@ module Neo4j::ActiveNode
         end
       end
 
+      # rubocop:disable Style/PredicateName
       def has_id_property?
+        ActiveSupport::Deprecation.warn 'has_id_property? is deprecated and may be removed from future releases, use id_property? instead.', caller
+
+        id_property?
+      end
+      # rubocop:enable Style/PredicateName
+
+      def id_property?
         id_property_info && !id_property_info.empty?
       end
 
@@ -155,8 +160,6 @@ module Neo4j::ActiveNode
       end
 
       alias_method :primary_key, :id_property_name
-
     end
   end
-
 end

data/lib/neo4j/active_node/initialize.rb

@@ -1,6 +1,7 @@
 module Neo4j::ActiveNode::Initialize
   extend ActiveSupport::Concern
   include Neo4j::Shared::TypeConverters
+  attr_reader :called_by
 
   # called when loading the node from the database
   # @param [Neo4j::Node] persisted_node the node this class wraps
@@ -11,7 +12,7 @@ module Neo4j::ActiveNode::Initialize
     @association_cache = {}
     changed_attributes && changed_attributes.clear
     @attributes = attributes.merge(properties.stringify_keys)
-    self.default_properties=properties
+    self.default_properties = properties
     @attributes = convert_properties_to :ruby, @attributes
   end
 
@@ -21,7 +22,4 @@ module Neo4j::ActiveNode::Initialize
   def wrapper
     self
   end
-
 end
-
-

data/lib/neo4j/active_node/labels.rb

@@ -1,7 +1,5 @@
 module Neo4j
   module ActiveNode
-
-
     # Provides a mapping between neo4j labels and Ruby classes
     module Labels
       extend ActiveSupport::Concern
@@ -52,7 +50,7 @@ module Neo4j
       # Only for testing purpose
       # @private
       def self._wrapped_labels=(wl)
-        @_wrapped_labels=(wl)
+        @_wrapped_labels = (wl)
       end
 
       def self._wrapped_labels
@@ -74,25 +72,24 @@ module Neo4j
         # Returns the object with the specified neo4j id.
         # @param [String,Fixnum] id of node to find
         def find(id)
-          map_id = Proc.new {|object| object.respond_to?(:id) ? object.send(:id) : object }
+          map_id = proc { |object| object.respond_to?(:id) ? object.send(:id) : object }
 
           if id.is_a?(Array)
-            find_by_ids(id.map {|o| map_id.call(o) })
+            find_by_ids(id.map { |o| map_id.call(o) })
           else
             find_by_id(map_id.call(id))
           end
         end
 
         # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
-        # @param [Hash] args of arguments to find
-        def find_by(*args)
-          self.query_as(:n).where(n: eval(args.join)).limit(1).pluck(:n).first
+        # @param Hash args of arguments to find
+        def find_by(values)
+          self.query_as(:n).where(n: values).limit(1).pluck(:n).first
         end
 
         # Like find_by, except that if no record is found, raises a RecordNotFound error.
-        def find_by!(*args)
-          a = eval(args.join)
-          find_by(args) or raise RecordNotFound, "#{self.query_as(:n).where(n: a).limit(1).to_cypher} returned no results"
+        def find_by!(values)
+          find_by(values) || fail(RecordNotFound, "#{self.query_as(:n).where(n: values).limit(1).to_cypher} returned no results")
         end
 
         # Deletes all nodes and connected relationships from Cypher.
@@ -104,7 +101,7 @@ module Neo4j
         # 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
         # one database query per node in the database, more if callbacks require them.
         def destroy_all
-          self.all.each { |n| n.destroy }
+          self.all.each(&:destroy)
         end
 
         # Creates a Neo4j index on given property
@@ -141,14 +138,14 @@ module Neo4j
         # @example
         #   Person.constraint :name, type: :unique
         #
-        def constraint(property, constraints, session = Neo4j::Session.current)
+        def constraint(property, constraints)
           Neo4j::Session.on_session_available do |session|
             label = Neo4j::Label.create(mapped_label_name)
             label.create_constraint(property, constraints, session)
           end
         end
 
-        def drop_constraint(property, constraint, session = Neo4j::Session.current)
+        def drop_constraint(property, constraint)
           Neo4j::Session.on_session_available do |session|
             label = Neo4j::Label.create(mapped_label_name)
             label.drop_constraint(property, constraint, session)
@@ -166,7 +163,7 @@ module Neo4j
 
         # @return [Symbol] the label that this class has which corresponds to a Ruby class
         def mapped_label_name
-          @_label_name || (self.name.nil? ? object_id.to_s.to_sym : self.name.to_sym)
+          @mapped_label_name || (self.name.nil? ? object_id.to_s.to_sym : self.name.to_sym)
         end
 
         # @return [Neo4j::Label] the label for this class
@@ -180,7 +177,7 @@ module Neo4j
 
         def base_class
           unless self < Neo4j::ActiveNode
-            raise "#{name} doesn't belong in a hierarchy descending from ActiveNode"
+            fail "#{name} doesn't belong in a hierarchy descending from ActiveNode"
           end
 
           if superclass == Object
@@ -204,21 +201,25 @@ module Neo4j
             else
               label.create_index(property) unless existing.flatten.include?(property)
             end
-
           end
         end
 
         def mapped_labels
-          mapped_label_names.map{|label_name| Neo4j::Label.create(label_name)}
+          mapped_label_names.map { |label_name| Neo4j::Label.create(label_name) }
         end
 
-        def set_mapped_label_name(name)
-          @_label_name = name.to_sym
+        def mapped_label_name=(name)
+          @mapped_label_name = name.to_sym
         end
 
-      end
+        # rubocop:disable Style/AccessorMethodName
+        def set_mapped_label_name(name)
+          ActiveSupport::Deprecation.warn 'set_mapped_label_name is deprecated and may be removed from future releases, use self.mapped_label_name= instead.', caller
 
+          self.mapped_label_name = name
+        end
+        # rubocop:enable Style/AccessorMethodName
+      end
     end
-
   end
 end

data/lib/neo4j/active_node/node_wrapper.rb

@@ -1,7 +1,6 @@
 class Neo4j::Node
   # The wrapping process is what transforms a raw CypherNode or EmbeddedNode from Neo4j::Core into a healthy ActiveNode (or ActiveRel) object.
   module Wrapper
-
     # this is a plugin in the neo4j-core so that the Ruby wrapper will be wrapped around the Neo4j::Node objects
     def wrapper
       self.props.symbolize_keys!
@@ -26,22 +25,20 @@ class Neo4j::Node
 
     # Makes the determination of whether to use <tt>_classname</tt> (or whatever is defined by config) or the node's labels.
     def sorted_wrapper_classes
-      if self.props.is_a?(Hash) && self.props.has_key?(Neo4j::Config.class_name_property)
+      if self.props.is_a?(Hash) && self.props.key?(Neo4j::Config.class_name_property)
         self.props[Neo4j::Config.class_name_property].constantize
       else
         wrappers = _class_wrappers
         return self if wrappers.nil?
-        wrapper_classes = wrappers.map{|w| Neo4j::ActiveNode::Labels._wrapped_labels[w]}
+        wrapper_classes = wrappers.map { |w| Neo4j::ActiveNode::Labels._wrapped_labels[w] }
         wrapper_classes.sort.first
       end
     end
 
     def load_class_from_label(label_name)
-      begin
-        label_name.to_s.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
-      rescue NameError
-        nil
-      end
+      label_name.to_s.split('::').inject(Kernel) { |container, name| container.const_get(name.to_s) }
+    rescue NameError
+      nil
     end
 
     def _class_wrappers