neo4j 4.0.0 → 4.1.0

data/lib/neo4j/shared.rb

@@ -8,13 +8,17 @@ module Neo4j
     include ActiveModel::Serializers::JSON
 
     module ClassMethods
-      def neo4j_session_name (name)
+      attr_writer :neo4j_session_name
+
+      def neo4j_session_name(name)
+        ActiveSupport::Deprecation.warn 'neo4j_session_name is deprecated and may be removed from future releases, use neo4j_session_name= instead.', caller
+
         @neo4j_session_name = name
       end
 
       def neo4j_session
         if @neo4j_session_name
-          Neo4j::Session.named(@neo4j_session_name) || raise("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
+          Neo4j::Session.named(@neo4j_session_name) || fail("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
         else
           Neo4j::Session.current!
         end
@@ -29,4 +33,4 @@ module Neo4j
       end
     end
   end
-end
+end

data/lib/neo4j/shared/callbacks.rb

@@ -9,12 +9,20 @@ module Neo4j
 
       included do
         include ActiveModel::Validations::Callbacks
-        define_model_callbacks :initialize, :find, :only => :after
+        define_model_callbacks :initialize, :find, only: :after
         define_model_callbacks :save, :create, :update, :destroy
       end
 
       def destroy #:nodoc:
+        tx = Neo4j::Transaction.new
         run_callbacks(:destroy) { super }
+      rescue
+        @_deleted = false
+        @attributes = @attributes.dup
+        tx.mark_failed
+        raise
+      ensure
+        tx.close if tx
       end
 
       def touch(*) #:nodoc:
@@ -28,13 +36,16 @@ module Neo4j
       end
 
       def create_model #:nodoc:
-        run_callbacks(:create) { super }
+        Neo4j::Transaction.run do
+          run_callbacks(:create) { super }
+        end
       end
 
       def update_model(*) #:nodoc:
-        run_callbacks(:update) { super }
+        Neo4j::Transaction.run do
+          run_callbacks(:update) { super }
+        end
       end
     end
-
   end
 end

data/lib/neo4j/shared/identity.rb

@@ -1,7 +1,7 @@
 module Neo4j::Shared
   module Identity
-    def ==(o)
-      o.class == self.class && o.id == id
+    def ==(other)
+      other.class == self.class && other.id == id
     end
     alias_method :eql?, :==
 

data/lib/neo4j/shared/persistence.rb

@@ -1,6 +1,5 @@
 module Neo4j::Shared
   module Persistence
-
     extend ActiveSupport::Concern
     include Neo4j::Shared::TypeConverters
 
@@ -8,7 +7,7 @@ module Neo4j::Shared
 
     def update_model
       if changed_attributes && !changed_attributes.empty?
-        changed_props = attributes.select{|k,v| changed_attributes.include?(k)}
+        changed_props = attributes.select { |k, _| changed_attributes.include?(k) }
         changed_props = convert_properties_to :db, changed_props
         _persisted_obj.update_props(changed_props)
         changed_attributes.clear
@@ -34,21 +33,21 @@ module Neo4j::Shared
     def create_or_update
       # since the same model can be created or updated twice from a relationship we have to have this guard
       @_create_or_updating = true
-      result = persisted? ? update_model : create_model
-      unless result != false
-        Neo4j::Transaction.current.fail if Neo4j::Transaction.current
+      result = _persisted_obj ? update_model : create_model
+      if result == false
+        Neo4j::Transaction.current.failure if Neo4j::Transaction.current
         false
       else
         true
       end
     rescue => e
-      Neo4j::Transaction.current.fail if Neo4j::Transaction.current
+      Neo4j::Transaction.current.failure if Neo4j::Transaction.current
       raise e
     ensure
       @_create_or_updating = nil
     end
 
-    # Returns +true+ if the record is persisted, i.e. it’s not a new record and it was not destroyed
+    # 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?
     end
@@ -58,9 +57,10 @@ module Neo4j::Shared
       !_persisted_obj
     end
 
-    alias :new? :new_record?
+    alias_method :new?, :new_record?
 
     def destroy
+      freeze
       _persisted_obj && _persisted_obj.del
       @_deleted = true
     end
@@ -77,12 +77,11 @@ module Neo4j::Shared
 
     # @return [Hash] all defined and none nil properties
     def props
-      attributes.reject{|k,v| v.nil?}.symbolize_keys
+      attributes.reject { |_, v| v.nil? }.symbolize_keys
     end
 
     # @return true if the attributes hash has been frozen
     def frozen?
-      freeze_if_deleted
       @attributes.frozen?
     end
 
@@ -91,16 +90,6 @@ module Neo4j::Shared
       self
     end
 
-    def freeze_if_deleted
-      unless new_record?
-        # TODO - Neo4j::IdentityMap.remove_node_by_id(neo_id)
-        unless self.class.load_entity(neo_id)
-          @_deleted = true
-          freeze
-        end
-      end
-    end
-
     def reload
       return self if new_record?
       clear_association_cache
@@ -113,7 +102,7 @@ module Neo4j::Shared
     end
 
     def reload_from_database
-      # TODO - Neo4j::IdentityMap.remove_node_by_id(neo_id)
+      # TODO: - Neo4j::IdentityMap.remove_node_by_id(neo_id)
       if reloaded = self.class.load_entity(neo_id)
         send(:attributes=, reloaded.attributes)
       end

data/lib/neo4j/shared/property.rb

@@ -13,11 +13,11 @@ module Neo4j::Shared
     class MultiparameterAssignmentError < StandardError; end
     class IllegalPropertyError < StandardError; end
 
-    ILLEGAL_PROPS = %w[from_node to_node start_node end_node]
+    ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
 
     attr_reader :_persisted_obj
 
-    def initialize(attributes={}, options={})
+    def initialize(attributes = {}, options = {})
       attributes = process_attributes(attributes)
       @relationship_props = self.class.extract_association_attributes!(attributes)
       writer_method_props = extract_writer_methods!(attributes)
@@ -39,7 +39,7 @@ module Neo4j::Shared
 
     def default_properties=(properties)
       keys = self.class.default_properties.keys
-      @default_properties = properties.select {|key| keys.include?(key) }
+      @default_properties = properties.select { |key| keys.include?(key) }
     end
 
     def default_property(key)
@@ -64,14 +64,12 @@ module Neo4j::Shared
     # Raises an error if there are any keys left which haven't been defined as properties on the model
     def validate_attributes!(attributes)
       invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
-      raise UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
+      fail UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
     end
 
     def extract_writer_methods!(attributes)
-      attributes.keys.inject({}) do |writer_method_props, key|
+      attributes.keys.each_with_object({}) do |key, writer_method_props|
         writer_method_props[key] = attributes.delete(key) if self.respond_to?("#{key}=")
-
-        writer_method_props
       end
     end
 
@@ -97,7 +95,7 @@ module Neo4j::Shared
           values = (values.keys.min..values.keys.max).map { |i| values[i] }
           field = self.class.attributes[key.to_sym]
           new_attributes[key] = instantiate_object(field, values)
-        rescue => e
+        rescue
           raise MultiparameterAssignmentError, "error on assignment #{values.inspect} to #{key}"
         end
       end
@@ -105,14 +103,13 @@ module Neo4j::Shared
     end
 
     def instantiate_object(field, values_with_empty_parameters)
-      return nil if values_with_empty_parameters.all? { |v| v.nil? }
+      return nil if values_with_empty_parameters.all?(&:nil?)
       values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
       klass = field[:type]
       klass ? klass.new(*values) : values
     end
 
     module ClassMethods
-
       # Defines a property on the class
       #
       # See active_attr gem for allowed options, e.g which type
@@ -141,7 +138,7 @@ module Neo4j::Shared
       #      # declare a property which can have any value
       #      property :name, constraint: :unique
       #    end
-      def property(name, options={})
+      def property(name, options = {})
         check_illegal_prop(name)
         magic_properties(name, options)
         attribute(name, options)
@@ -149,7 +146,7 @@ module Neo4j::Shared
       end
 
       def undef_property(name)
-        raise ArgumentError, "Argument `#{name}` not an attribute" if not attribute_names.include?(name.to_s)
+        fail ArgumentError, "Argument `#{name}` not an attribute" if not attribute_names.include?(name.to_s)
 
         attribute_methods(name).each do |method|
           undef_method(method)
@@ -176,12 +173,12 @@ module Neo4j::Shared
       end
 
       def default_property_values(instance)
-        default_properties.each_with_object({}) do |(key, block),result|
+        default_properties.each_with_object({}) do |(key, block), result|
           result[key] = block.call(instance)
         end
       end
 
-      def attribute!(name, options={})
+      def attribute!(name, options = {})
         super(name, options)
         define_method("#{name}=") do |value|
           typecast_value = typecast_attribute(_attribute_typecaster(name), value)
@@ -195,38 +192,28 @@ module Neo4j::Shared
       def constraint_or_index(name, options)
         # either constraint or index, do not set both
         if options[:constraint]
-          raise "unknown constraint type #{options[:constraint]}, only :unique supported" if options[:constraint] != :unique
+          fail "unknown constraint type #{options[:constraint]}, only :unique supported" if options[:constraint] != :unique
           constraint(name, type: :unique)
         elsif options[:index]
-          raise "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
+          fail "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
           index(name, options) if options[:index] == :exact
         end
       end
 
       def check_illegal_prop(name)
         if ILLEGAL_PROPS.include?(name.to_s)
-          raise IllegalPropertyError, "#{name} is an illegal property"
+          fail IllegalPropertyError, "#{name} is an illegal property"
         end
       end
 
       # Tweaks properties
       def magic_properties(name, options)
-        set_stamp_type(name, options)
-        set_time_as_datetime(options)
-      end
-
-      def set_stamp_type(name, options)
-        options[:type] ||= DateTime if (name.to_sym == :created_at || name.to_sym == :updated_at)
-      end
+        options[:type] ||= DateTime if name.to_sym == :created_at || name.to_sym == :updated_at
 
-      # ActiveAttr does not handle "Time", Rails and Neo4j.rb 2.3 did
-      # Convert it to DateTime in the interest of consistency
-      def set_time_as_datetime(options)
+        # ActiveAttr does not handle "Time", Rails and Neo4j.rb 2.3 did
+        # Convert it to DateTime in the interest of consistency
         options[:type] = DateTime if options[:type] == Time
       end
-
     end
-
   end
-
 end

data/lib/neo4j/shared/rel_type_converters.rb

@@ -1,10 +1,8 @@
 module Neo4j::Shared
-
   # This module controls changes to relationship type based on Neo4j::Config.transform_rel_type.
   # It's used whenever a rel type is automatically determined based on ActiveRel model name or
   # association type.
   module RelTypeConverters
-
     def decorated_rel_type(type)
       @decorated_rel_type ||= Neo4j::Shared::RelTypeConverters.decorated_rel_type(type)
     end
@@ -41,4 +39,4 @@ module Neo4j::Shared
       end
     end
   end
-end
+end

data/lib/neo4j/shared/type_converters.rb

@@ -1,10 +1,8 @@
 module Neo4j::Shared
   module TypeConverters
-
     # Converts Date objects to Java long types. Must be timezone UTC.
     class DateConverter
       class << self
-
         def convert_type
           Date
         end
@@ -18,14 +16,12 @@ module Neo4j::Shared
           return nil if value.nil?
           Time.at(value).utc.to_date
         end
-
       end
     end
 
     # Converts DateTime objects to and from Java long types. Must be timezone UTC.
     class DateTimeConverter
       class << self
-
         def convert_type
           DateTime
         end
@@ -50,18 +46,16 @@ module Neo4j::Shared
               when String
                 DateTime.strptime(value, '%Y-%m-%d %H:%M:%S %z')
               else
-                raise ArgumentError, "Invalid value type for DateType property: #{value.inspect}"
+                fail ArgumentError, "Invalid value type for DateType property: #{value.inspect}"
               end
 
           DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
         end
-
       end
     end
 
     class TimeConverter
       class << self
-
         def convert_type
           Time
         end
@@ -81,14 +75,12 @@ module Neo4j::Shared
           return nil if value.nil?
           Time.at(value).utc
         end
-
       end
     end
 
     # Converts hash to/from YAML
     class YAMLConverter
       class << self
-
         def convert_type
           Hash
         end
@@ -108,7 +100,6 @@ module Neo4j::Shared
     # Converts hash to/from JSON
     class JSONConverter
       class << self
-
         def convert_type
           JSON
         end
@@ -130,24 +121,23 @@ module Neo4j::Shared
     def convert_properties_to(medium, properties)
       # Perform type conversion
       serialize = self.respond_to?(:serialized_properties) ? self.serialized_properties : {}
-      properties = properties.inject({}) do |new_attributes, key_value_pair|
+
+      properties.each_with_object({}) do |key_value_pair, new_attributes|
         attr, value = key_value_pair
 
         # skip "secret" undeclared attributes such as uuid
         next new_attributes unless self.class.attributes[attr]
 
-        type = serialize.has_key?(attr.to_sym) ? serialize[attr.to_sym] : self.class._attribute_type(attr)
+        type = serialize.key?(attr.to_sym) ? serialize[attr.to_sym] : self.class._attribute_type(attr)
         new_attributes[attr] = if TypeConverters.converters[type].nil?
-                                  value
-                                else
-                                  TypeConverters.send "to_#{medium}", value, type
-                                end
-        new_attributes
+                                 value
+                               else
+                                 TypeConverters.send "to_#{medium}", value, type
+                               end
       end
     end
 
     class << self
-
       # Converts the value to ruby from a Neo4j database value if there is a converter for given type
       def to_ruby(value, type = nil)
         found_converter = converters[type]
@@ -162,13 +152,11 @@ module Neo4j::Shared
 
       def converters
         @converters ||= begin
-          Neo4j::Shared::TypeConverters.constants.find_all do |c|
-            Neo4j::Shared::TypeConverters.const_get(c).respond_to?(:convert_type)
-          end.map do  |c|
-            Neo4j::Shared::TypeConverters.const_get(c)
-          end.inject({}) do |ack, t|
-            ack[t.convert_type] = t
-            ack
+          Neo4j::Shared::TypeConverters.constants.each_with_object({}) do |constant_name, result|
+            constant = Neo4j::Shared::TypeConverters.const_get(constant_name)
+            if constant.respond_to?(:convert_type)
+              result[constant.convert_type] = constant
+            end
           end
         end
       end

data/lib/neo4j/shared/validations.rb

@@ -14,7 +14,7 @@ module Neo4j
       # @param [Hash] options the options to create a message with.
       # @option options [true, false] :validate if false no validation will take place
       # @return [Boolean] true if it saved it successfully
-      def save(options={})
+      def save(options = {})
         result = perform_validations(options) ? super : false
         if !result
           Neo4j::Transaction.current.failure if Neo4j::Transaction.current
@@ -31,7 +31,7 @@ module Neo4j
 
       private
 
-      def perform_validations(options={})
+      def perform_validations(options = {})
         perform_validation = case options
                              when Hash
                                options[:validate] != false
@@ -45,4 +45,4 @@ module Neo4j
       end
     end
   end
-end
+end