neo4j 5.2.15 → 6.0.0.alpha.1

data/lib/neo4j/errors.rb

@@ -7,4 +7,6 @@ module Neo4j
   # Raised when Neo4j.rb cannot find record by given id.
   class RecordNotFound < Neo4jrbError
   end
+
+  class InvalidPropertyOptionsError < Neo4jrbError; end
 end

data/lib/neo4j/schema/operation.rb

@@ -0,0 +1,91 @@
+module Neo4j
+  module Schema
+    class Operation
+      attr_reader :label_name, :property, :options
+
+      def initialize(label_name, property, options = default_options)
+        @label_name = label_name.to_sym
+        @property = property.to_sym
+        @options = options
+      end
+
+      def self.incompatible_operation_classes
+        []
+      end
+
+      def create!
+        drop_incompatible!
+        return if exist?
+        label_object.send(:"create_#{type}", property, options)
+      end
+
+      def label_object
+        @label_object ||= Neo4j::Label.create(label_name)
+      end
+
+      def incompatible_operation_classes
+        self.class.incompatible_operation_classes
+      end
+
+      def drop!
+        label_object.send(:"drop_#{type}", property, options)
+      end
+
+      def drop_incompatible!
+        incompatible_operation_classes.each do |clazz|
+          operation = clazz.new(label_name, property)
+          operation.drop! if operation.exist?
+        end
+      end
+
+      def exist?
+        fail 'Abstract class, not implemented'
+      end
+
+      def default_options
+        {}
+      end
+
+      def type
+        fail 'Abstract class, not implemented'
+      end
+    end
+
+    class ExactIndexOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [UniqueConstraintOperation]
+      end
+
+      def type
+        'index'
+      end
+
+      def exist?
+        label_object.indexes[:property_keys].include?([property])
+      end
+    end
+
+    class UniqueConstraintOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [ExactIndexOperation]
+      end
+
+      def type
+        'constraint'
+      end
+
+      def create!
+        return if exist?
+        super
+      end
+
+      def exist?
+        Neo4j::Label.constraint?(label_name, property)
+      end
+
+      def default_options
+        {type: :unique}
+      end
+    end
+  end
+end

data/lib/neo4j/shared.rb

@@ -28,15 +28,15 @@ module Neo4j
 
     included do
       self.include_root_in_json = Neo4j::Config.include_root_in_json
-      @_declared_property_manager ||= Neo4j::Shared::DeclaredPropertyManager.new(self)
+      @_declared_properties ||= Neo4j::Shared::DeclaredProperties.new(self)
 
       def self.i18n_scope
         :neo4j
       end
     end
 
-    def declared_property_manager
-      self.class.declared_property_manager
+    def declared_properties
+      self.class.declared_properties
     end
   end
 end

data/lib/neo4j/shared/callbacks.rb

@@ -9,13 +9,8 @@ module Neo4j
 
       included do
         include ActiveModel::Validations::Callbacks
-        # after_find is triggered by the `find` method defined in lib/neo4j/active_node/id_property.rb
         define_model_callbacks :initialize, :find, only: :after
-        define_model_callbacks :save, :create, :update, :destroy, :touch
-      end
-
-      def initialize(args = nil)
-        run_callbacks(:initialize) { super }
+        define_model_callbacks :save, :create, :update, :destroy
       end
 
       def destroy #:nodoc:
@@ -30,7 +25,7 @@ module Neo4j
         tx.close if tx
       end
 
-      def touch #:nodoc:
+      def touch(*) #:nodoc:
         run_callbacks(:touch) { super }
       end
 

data/lib/neo4j/shared/{declared_property_manager.rb → declared_properties.rb}

@@ -5,17 +5,26 @@ module Neo4j::Shared
   # a way of separating behavior from the general Active{obj} modules.
   #
   # See Neo4j::Shared::DeclaredProperty for definitions of the property objects themselves.
-  class DeclaredPropertyManager
+  class DeclaredProperties
     include Neo4j::Shared::TypeConverters
 
     attr_reader :klass
+    delegate :each, :each_pair, :each_key, :each_value, to: :registered_properties
 
     # Each class that includes Neo4j::ActiveNode or Neo4j::ActiveRel gets one instance of this class.
-    # @param [#declared_property_manager] klass An object that has the #declared_property_manager method.
+    # @param [#declared_properties] klass An object that has the #declared_properties method.
     def initialize(klass)
       @klass = klass
     end
 
+    def [](key)
+      registered_properties[key.to_sym]
+    end
+
+    def property?(key)
+      registered_properties.key?(key.to_sym)
+    end
+
     # @param [Neo4j::Shared::DeclaredProperty] property An instance of DeclaredProperty, created as the result of calling
     # #property on an ActiveNode or ActiveRel class. The DeclaredProperty has specifics about the property, but registration
     # makes the management object aware of it. This is necessary for type conversion, defaults, and inclusion in the nil and string hashes.
@@ -27,6 +36,18 @@ module Neo4j::Shared
       declared_property_defaults[property.name] = property.default_value if !property.default_value.nil?
     end
 
+    def index_or_fail!(key, id_property_name, type = :exact)
+      return if key == id_property_name
+      fail "Cannot index undeclared property #{key}" unless property?(key)
+      registered_properties[key].index!(type)
+    end
+
+    def constraint_or_fail!(key, id_property_name, type = :unique)
+      return if key == id_property_name
+      fail "Cannot constraint undeclared property #{property}" unless property?(key)
+      registered_properties[key].constraint!(type)
+    end
+
     # The :default option in Neo4j::ActiveNode#property class method allows for setting a default value instead of
     # nil on declared properties. This holds those values.
     def declared_property_defaults
@@ -37,6 +58,10 @@ module Neo4j::Shared
       @_registered_properties ||= {}
     end
 
+    def indexed_properties
+      registered_properties.select { |_, p| p.index_or_constraint? }
+    end
+
     # During object wrap, a hash is needed that contains each declared property with a nil value.
     # The active_attr dependency is capable of providing this but it is expensive and calculated on the fly
     # each time it is called. Rather than rely on that, we build this progressively as properties are registered.
@@ -113,6 +138,13 @@ module Neo4j::Shared
       @upstream_primitives ||= {}
     end
 
+    EXCLUDED_TYPES = [Array, Range, Regexp]
+    def value_for_where(key, value)
+      return value unless prop = registered_properties[key]
+      return value_for_db(key, value) if prop.typecaster && prop.typecaster.convert_type == value.class
+      EXCLUDED_TYPES.include?(value.class) ? value : value_for_db(key, value)
+    end
+
     def value_for_db(key, value)
       return value unless registered_properties[key]
       convert_property(key, value, :to_db)

data/lib/neo4j/shared/declared_property.rb

@@ -2,6 +2,7 @@ module Neo4j::Shared
   # Contains methods related to the management
   class DeclaredProperty
     class IllegalPropertyError < StandardError; end
+    include Neo4j::Shared::DeclaredProperty::Index
 
     ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
     attr_reader :name, :name_string, :name_sym, :options, :magic_typecaster
@@ -11,6 +12,7 @@ module Neo4j::Shared
       @name = @name_sym = name
       @name_string = name.to_s
       @options = options
+      fail_invalid_options!
     end
 
     def register
@@ -29,8 +31,25 @@ module Neo4j::Shared
       options[:default]
     end
 
+    def fail_invalid_options!
+      case
+      when index?(:exact) && constraint?(:unique)
+        fail Neo4j::InvalidPropertyOptionsError,
+             "#Uniqueness constraints also provide exact indexes, cannot set both options on property #{name}"
+      end
+    end
+
     private
 
+    def option_with_value!(key, value)
+      options[key] = value
+      fail_invalid_options!
+    end
+
+    def option_with_value?(key, value)
+      options[key] == value
+    end
+
     # Tweaks properties
     def register_magic_properties
       options[:type] ||= Neo4j::Config.timestamp_type if timestamp_prop?

data/lib/neo4j/shared/declared_property/index.rb

@@ -0,0 +1,37 @@
+module Neo4j::Shared
+  class DeclaredProperty
+    # None of these methods interact with the database. They only keep track of property settings in models.
+    # It could (should?) handle the actual indexing/constraining, but that's TBD.
+    module Index
+      def index_or_constraint?
+        index?(:exact) || constraint?(:unique)
+      end
+
+      def index?(type = :exact)
+        options.key?(:index) && options[:index] == type
+      end
+
+      def constraint?(type = :unique)
+        options.key?(:constraint) && options[:constraint] == type
+      end
+
+      def index!(type = :exact)
+        fail Neo4j::InvalidPropertyOptionsError, "Unable to set index on constrainted property #{name}" if constraint?(:unique)
+        options[:index] = type
+      end
+
+      def constraint!(type = :unique)
+        fail Neo4j::InvalidPropertyOptionsError, "Unable to set constraint on indexed property #{name}" if index?(:exact)
+        options[:constraint] = type
+      end
+
+      def unindex!(type = :exact)
+        options.delete(:index) if index?(type)
+      end
+
+      def unconstraint!(type = :unique)
+        options.delete(:constraint) if constraint?(type)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/initialize.rb

@@ -15,12 +15,12 @@ module Neo4j::Shared
       @attributes ||= Hash[self.class.attributes_nil_hash]
       stringify_attributes!(@attributes, properties)
       self.default_properties = properties if respond_to?(:default_properties=)
-      self.class.declared_property_manager.convert_properties_to(self, :ruby, @attributes)
+      self.class.declared_properties.convert_properties_to(self, :ruby, @attributes)
     end
 
     def stringify_attributes!(attr, properties)
       properties.each_pair do |k, v|
-        key = self.class.declared_property_manager.string_key(k)
+        key = self.class.declared_properties.string_key(k)
         attr[key.freeze] = v
       end
     end

data/lib/neo4j/shared/persistence.rb

@@ -82,11 +82,6 @@ module Neo4j::Shared
       end
     end
 
-    def touch
-      fail 'Cannot touch on a new record object' unless persisted?
-      update_attribute!(:updated_at, Time.now) if respond_to?(:updated_at=)
-    end
-
     # Returns +true+ if the record is persisted, i.e. it's not a new record and it was not destroyed
     def persisted?
       !new_record? && !destroyed?
@@ -111,26 +106,9 @@ module Neo4j::Shared
 
     # Returns +true+ if the object was destroyed.
     def destroyed?
-      @_deleted || _destroyed_double_check?
+      @_deleted
     end
 
-    # These two methods should be removed in 6.0.0
-    def _destroyed_double_check?
-      if _active_record_destroyed_behavior?
-        false
-      else
-        (!new_record? && !exist?)
-      end
-    end
-
-    def _active_record_destroyed_behavior?
-      fail 'Remove this workaround in 6.0.0' if Neo4j::VERSION >= '6.0.0'
-
-      !!Neo4j::Config[:_active_record_destroyed_behavior]
-    end
-    # End of two methods which should be removed in 6.0.0
-
-
     # @return [Hash] all defined and none nil properties
     def props
       attributes.reject { |_, v| v.nil? }.symbolize_keys
@@ -193,7 +171,7 @@ module Neo4j::Shared
     private
 
     def props_for_db(props_hash)
-      self.class.declared_property_manager.convert_properties_to(self, :db, props_hash)
+      self.class.declared_properties.convert_properties_to(self, :db, props_hash)
     end
 
     def model_cache_key
@@ -222,7 +200,7 @@ module Neo4j::Shared
     end
 
     def inject_defaults!(properties)
-      self.class.declared_property_manager.declared_property_defaults.each_pair do |k, v|
+      self.class.declared_properties.declared_property_defaults.each_pair do |k, v|
         properties[k.to_sym] = v if send(k).nil?
       end
       properties

data/lib/neo4j/shared/property.rb

@@ -108,10 +108,10 @@ module Neo4j::Shared
     module ClassMethods
       extend Forwardable
 
-      def_delegators :declared_property_manager, :serialized_properties, :serialized_properties=, :serialize, :declared_property_defaults
+      def_delegators :declared_properties, :serialized_properties, :serialized_properties=, :serialize, :declared_property_defaults
 
       def inherited(other)
-        self.declared_property_manager.registered_properties.each_pair do |prop_key, prop_def|
+        self.declared_properties.registered_properties.each_pair do |prop_key, prop_def|
           other.property(prop_key, prop_def.options)
         end
         super
@@ -146,22 +146,36 @@ module Neo4j::Shared
       #      property :name, constraint: :unique
       #    end
       def property(name, options = {})
+        build_property(name, options) do |prop|
+          attribute(name, prop.options)
+        end
+      end
+
+      # @param [Symbol] name The property name
+      # @param [ActiveAttr::AttributeDefinition] active_attr A cloned AttributeDefinition to reuse
+      # @param [Hash] options An options hash to use in the new property definition
+      def inherit_property(name, active_attr, options = {})
+        build_property(name, options) do |prop|
+          attributes[prop.name.to_s] = active_attr
+        end
+      end
+
+      def build_property(name, options)
         prop = DeclaredProperty.new(name, options)
         prop.register
-        declared_property_manager.register(prop)
-
-        attribute(name, prop.options)
+        declared_properties.register(prop)
+        yield prop
         constraint_or_index(name, options)
       end
 
       def undef_property(name)
-        declared_property_manager.unregister(name)
+        declared_properties.unregister(name)
         attribute_methods(name).each { |method| undef_method(method) }
         undef_constraint_or_index(name)
       end
 
-      def declared_property_manager
-        @_declared_property_manager ||= DeclaredPropertyManager.new(self)
+      def declared_properties
+        @_declared_properties ||= DeclaredProperties.new(self)
       end
 
       def attribute!(name, options = {})
@@ -176,7 +190,7 @@ module Neo4j::Shared
       # @return [Hash] A frozen hash of all model properties with nil values. It is used during node loading and prevents
       # an extra call to a slow dependency method.
       def attributes_nil_hash
-        declared_property_manager.attributes_nil_hash
+        declared_properties.attributes_nil_hash
       end
 
       private
@@ -188,7 +202,7 @@ module Neo4j::Shared
           constraint(name, type: :unique)
         elsif options[:index]
           fail "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
-          index(name, options) if options[:index] == :exact
+          index(name) if options[:index] == :exact
         end
       end
     end

data/lib/neo4j/shared/type_converters.rb

@@ -1,9 +1,128 @@
 require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'active_support/core_ext/big_decimal/conversions'
 
 module Neo4j::Shared
   module TypeConverters
+    class BaseConverter
+      class << self
+        def converted?(value)
+          value.is_a?(db_type)
+        end
+      end
+    end
+
+    class IntegerConverter < BaseConverter
+      class << self
+        def convert_type
+          Integer
+        end
+
+        def db_type
+          Integer
+        end
+
+        def to_db(value)
+          value.to_i
+        end
+
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class FloatConverter < BaseConverter
+      class << self
+        def convert_type
+          Float
+        end
+
+        def db_type
+          Float
+        end
+
+        def to_db(value)
+          value.to_f
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class BigDecimalConverter < BaseConverter
+      class << self
+        def convert_type
+          BigDecimal
+        end
+
+        def db_type
+          BigDecimal
+        end
+
+        def to_db(value)
+          case value
+          when Rational
+            value.to_f.to_d
+          when respond_to?(:to_d)
+            value.to_d
+          else
+            BigDecimal.new(value.to_s)
+          end
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class StringConverter < BaseConverter
+      class << self
+        def convert_type
+          String
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          value.to_s
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class BooleanConverter < BaseConverter
+      FALSE_VALUES = %w(n N no No NO false False FALSE off Off OFF f F)
+
+      class << self
+        def converted?(value)
+          convert_type.include?(value)
+        end
+
+        def convert_type
+          [true, false]
+        end
+
+        def db_type
+          ActiveAttr::Typecasting::Boolean
+        end
+
+        def to_db(value)
+          return false if FALSE_VALUES.include?(value)
+          case value
+          when TrueClass, FalseClass
+            value
+          when Numeric, /^\-?[0-9]/
+            !value.to_f.zero?
+          else
+            value.present?
+          end
+        end
+
+        alias_method :to_ruby, :to_db
+      end
+    end
+
     # Converts Date objects to Java long types. Must be timezone UTC.
-    class DateConverter
+    class DateConverter < BaseConverter
       class << self
         def convert_type
           Date
@@ -24,7 +143,7 @@ module Neo4j::Shared
     end
 
     # Converts DateTime objects to and from Java long types. Must be timezone UTC.
-    class DateTimeConverter
+    class DateTimeConverter < BaseConverter
       class << self
         def convert_type
           DateTime
@@ -61,7 +180,7 @@ module Neo4j::Shared
       end
     end
 
-    class TimeConverter
+    class TimeConverter < BaseConverter
       class << self
         def convert_type
           Time
@@ -95,7 +214,7 @@ module Neo4j::Shared
     end
 
     # Converts hash to/from YAML
-    class YAMLConverter
+    class YAMLConverter < BaseConverter
       class << self
         def convert_type
           Hash
@@ -116,7 +235,7 @@ module Neo4j::Shared
     end
 
     # Converts hash to/from JSON
-    class JSONConverter
+    class JSONConverter < BaseConverter
       class << self
         def convert_type
           JSON
@@ -159,6 +278,7 @@ module Neo4j::Shared
     private
 
     def converted_property(type, value, converter)
+      return nil if value.nil?
       TypeConverters.converters[type].nil? ? value : TypeConverters.to_other(converter, value, type)
     end
 
@@ -209,7 +329,12 @@ module Neo4j::Shared
       # @param [#convert_type] found_converter An object that responds to #convert_type, hinting that it is a type converter.
       # @param value The value for conversion.
       def formatted_for_db?(found_converter, value)
-        found_converter.respond_to?(:db_type) && value.is_a?(found_converter.db_type)
+        return false unless found_converter.respond_to?(:db_type)
+        if found_converter.respond_to?(:converted)
+          found_converter.converted?(value)
+        else
+          value.is_a?(found_converter.db_type)
+        end
       end
 
       def register_converter(converter)