neo4j 4.1.5 → 5.0.0.rc.1

data/lib/neo4j/active_rel/property.rb

@@ -29,8 +29,10 @@ module Neo4j::ActiveRel
       # Extracts keys from attributes hash which are relationships 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)
-        attributes.keys.each_with_object({}) do |key, relationship_props|
-          relationship_props[key] = attributes.delete(key) if [:from_node, :to_node].include?(key)
+        {}.tap do |relationship_props|
+          attributes.each_key do |key|
+            relationship_props[key] = attributes.delete(key) if [:from_node, :to_node].include?(key)
+          end
         end
       end
 

data/lib/neo4j/active_rel/types.rb

@@ -21,25 +21,37 @@ module Neo4j
       WRAPPED_CLASSES = {}
 
       included do
-        type self.name, true
+        type self.namespaced_model_name, true
       end
 
       module ClassMethods
         include Neo4j::Shared::RelTypeConverters
 
-        def inherited(other)
-          other.type other.name, true
+        def inherited(subclass)
+          subclass.type subclass.namespaced_model_name, true
         end
 
         # @param type [String] sets the relationship type when creating relationships via this class
-        def type(given_type = self.name, auto = false)
-          use_type = auto ? decorated_rel_type(given_type) : given_type
-          add_wrapped_class use_type
-          @rel_type = use_type
+        def type(given_type = namespaced_model_name, auto = false)
+          @rel_type = (auto ? decorated_rel_type(given_type) : given_type).tap do |type|
+            add_wrapped_class type unless uses_classname?
+          end
+        end
+
+        def namespaced_model_name
+          case Neo4j::Config[:module_handling]
+          when :demodulize
+            self.name.demodulize
+          when Proc
+            Neo4j::Config[:module_handling].call(self.name)
+          else
+            self.name
+          end
         end
 
-        # @return [String] a string representing the relationship type that will be created
         attr_reader :rel_type
+        # @return [String] a string representing the relationship type that will be created
+        # attr_reader :rel_type
         alias_method :_type, :rel_type # Should be deprecated
 
         def add_wrapped_class(type)

data/lib/neo4j/config.rb

@@ -5,6 +5,7 @@ module Neo4j
   #
   class Config
     DEFAULT_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', 'config.yml'))
+    CLASS_NAME_PROPERTY_KEY = 'class_name_property'
 
     class << self
       # @return [Fixnum] The location of the default configuration file.
@@ -53,7 +54,6 @@ module Neo4j
         nil
       end
 
-
       # Sets the value of a config entry.
       #
       # @param [Symbol] key the key to set the parameter for
@@ -62,14 +62,12 @@ module Neo4j
         configuration[key.to_s] = val
       end
 
-
       # @param [Symbol] key The key of the config entry value we want
       # @return the the value of a config entry
       def [](key)
         configuration[key.to_s]
       end
 
-
       # Remove the value of a config entry.
       #
       # @param [Symbol] key the key of the configuration entry to delete
@@ -78,7 +76,6 @@ module Neo4j
         configuration.delete(key)
       end
 
-
       # Remove all configuration. This can be useful for testing purpose.
       #
       # @return nil
@@ -86,7 +83,6 @@ module Neo4j
         @configuration = nil
       end
 
-
       # @return [Hash] The config as a hash.
       def to_hash
         configuration.to_hash
@@ -98,13 +94,27 @@ module Neo4j
       end
 
       def class_name_property
-        Neo4j::Config[:class_name_property] || :_classname
+        @_class_name_property = Neo4j::Config[CLASS_NAME_PROPERTY_KEY] || :_classname
       end
 
       def include_root_in_json
         # we use ternary because a simple || will always evaluate true
         Neo4j::Config[:include_root_in_json].nil? ? true : Neo4j::Config[:include_root_in_json]
       end
+
+      def module_handling
+        Neo4j::Config[:module_handling] || :none
+      end
+
+      def association_model_namespace
+        Neo4j::Config[:association_model_namespace] || nil
+      end
+
+      def association_model_namespace_string
+        namespace = Neo4j::Config[:association_model_namespace]
+        return nil if namespace.nil?
+        "::#{namespace}"
+      end
     end
   end
 end

data/lib/neo4j/core/query.rb

@@ -8,14 +8,14 @@ module Neo4j::Core
     # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object.
     def proxy_as(model, var, optional = false)
       # TODO: Discuss whether it's necessary to call `break` on the query or if this should be left to the user.
-      Neo4j::ActiveNode::Query::QueryProxy.new(model, nil,  starting_query: self, node: var, optional: optional, chain_level: @proxy_chain_level)
+      Neo4j::ActiveNode::Query::QueryProxy.new(model, nil, node: var, optional: optional, starting_query: self, chain_level: @proxy_chain_level)
     end
 
     # Calls proxy_as with `optional` set true. This doesn't offer anything different from calling `proxy_as` directly but it may be more readable.
     def proxy_as_optional(model, var)
       proxy_as(model, var, true)
     end
-    #
+
     # For instances where you turn a QueryProxy into a Query and then back to a QueryProxy with `#proxy_as`
     attr_accessor :proxy_chain_level
   end

data/lib/neo4j/errors.rb

@@ -0,0 +1,10 @@
+module Neo4j
+  # Neo4j.rb Errors
+  # Generic Neo4j.rb exception class.
+  class Neo4jrbError < StandardError
+  end
+
+  # Raised when Neo4j.rb cannot find record by given id.
+  class RecordNotFound < Neo4jrbError
+  end
+end

data/lib/neo4j/migration.rb

@@ -1,3 +1,5 @@
+require 'benchmark'
+
 module Neo4j
   class Migration
     def migrate
@@ -17,7 +19,7 @@ module Neo4j
     end
 
     def joined_path(path)
-      File.join(path, 'db', 'neo4j-migrate')
+      File.join(path.to_s, 'db', 'neo4j-migrate')
     end
 
     class AddIdProperty < Neo4j::Migration
@@ -41,64 +43,72 @@ module Neo4j
 
       def setup
         FileUtils.mkdir_p('db/neo4j-migrate')
-        unless File.file?(models_filename)
-          File.open(models_filename, 'w') do |file|
-            file.write("# Provide models to which IDs should be added.\n# It will only modify nodes that do not have IDs. There is no danger of overwriting data.\n# models: [Student,Lesson,Teacher,Exam]\nmodels: []")
-          end
+
+        return if File.file?(models_filename)
+
+        File.open(models_filename, 'w') do |file|
+          message = <<MESSAGE
+# Provide models to which IDs should be added.
+# # It will only modify nodes that do not have IDs. There is no danger of overwriting data.
+# # models: [Student,Lesson,Teacher,Exam]\nmodels: []
+MESSAGE
+          file.write(message)
         end
       end
 
       private
 
       def add_ids_to(model)
-        require 'benchmark'
-
         max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
 
         label = model.mapped_label_name
-        property = model.primary_key
-        nodes_left = 1
         last_time_taken = nil
 
-        until nodes_left == 0
-          nodes_left = Neo4j::Session.query.match(n: label).where("NOT has(n.#{property})").return('COUNT(n) AS ids').first.ids
+        until (nodes_left = idless_count(label, model.primary_key)) == 0
+          print_status(last_time_taken, max_per_batch, nodes_left)
 
-          time_per_node = last_time_taken / max_per_batch if last_time_taken
-          print_output "Running first batch...\r"
-          if time_per_node
-            eta_seconds = (nodes_left * time_per_node).round
-            print_output "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
+          count = [nodes_left, max_per_batch].min
+          last_time_taken = Benchmark.realtime do
+            max_per_batch = id_batch_set(label, model.primary_key, count.times.map { new_id_for(model) }, count)
           end
+        end
+      end
 
-          return if nodes_left == 0
-          to_set = [nodes_left, max_per_batch].min
+      def idless_count(label, id_property)
+        Neo4j::Session.query.match(n: label).where("NOT has(n.#{id_property})").pluck('COUNT(n) AS ids').first
+      end
 
-          new_ids = to_set.times.map { new_id_for(model) }
-          begin
-            last_time_taken = id_batch_set(label, property, new_ids, to_set)
-          rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
-            new_max_per_batch = (max_per_batch * 0.8).round
-            output "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
-            max_per_batch = new_max_per_batch
-          end
-        end
+      def print_status(last_time_taken, max_per_batch, nodes_left)
+        time_per_node = last_time_taken / max_per_batch if last_time_taken
+        message = if time_per_node
+                    eta_seconds = (nodes_left * time_per_node).round
+                    "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
+                  else
+                    "Running first batch...\r"
+                  end
+
+        print_output message
       end
 
-      def id_batch_set(label, property, new_ids, to_set)
-        Benchmark.realtime do
-          begin
-            tx = Neo4j::Transaction.new
-            Neo4j::Session.query("MATCH (n:`#{label}`) WHERE NOT has(n.#{property})
-              with COLLECT(n) as nodes, #{new_ids} as ids
-              FOREACH(i in range(0,#{to_set - 1})|
-                FOREACH(node in [nodes[i]]|
-                  SET node.#{property} = ids[i]))
-              RETURN distinct(true)
-              LIMIT #{to_set}")
-          ensure
-            tx.close
-          end
-        end
+
+      def id_batch_set(label, id_property, new_ids, count)
+        tx = Neo4j::Transaction.new
+
+        Neo4j::Session.query("MATCH (n:`#{label}`) WHERE NOT has(n.#{id_property})
+          with COLLECT(n) as nodes, #{new_ids} as ids
+          FOREACH(i in range(0,#{count - 1})|
+            FOREACH(node in [nodes[i]]|
+              SET node.#{id_property} = ids[i]))
+          RETURN distinct(true)
+          LIMIT #{count}")
+
+        count
+      rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
+        new_max_per_batch = (max_per_batch * 0.8).round
+        output "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
+        new_max_per_batch
+      ensure
+        tx.close
       end
 
       def default_max_per_batch
@@ -133,10 +143,11 @@ module Neo4j
       def setup
         output "Creating file #{classnames_filepath}. Please use this as the migration guide."
         FileUtils.mkdir_p('db/neo4j-migrate')
-        unless File.file?(classnames_filepath)
-          source = File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', classnames_filename)
-          FileUtils.copy_file(source, classnames_filepath)
-        end
+
+        return if File.file?(classnames_filepath)
+
+        source = File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', classnames_filename)
+        FileUtils.copy_file(source, classnames_filepath)
       end
 
       private

data/lib/neo4j/paginated.rb

@@ -4,7 +4,9 @@ module Neo4j
     attr_reader :items, :total, :current_page
 
     def initialize(items, total, current_page)
-      @items, @total, @current_page = items, total, current_page
+      @items = items
+      @total = total
+      @current_page = current_page
     end
 
     def self.create_from(source, page, per_page, order = nil)

data/lib/neo4j/railtie.rb

@@ -21,19 +21,24 @@ module Neo4j
       end
 
       def setup_default_session(cfg)
+        setup_config_defaults!(cfg)
+
+        return if !cfg.sessions.empty?
+
+        cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options}
+      end
+
+      def setup_config_defaults!(cfg)
         cfg.session_type ||= :server_db
         cfg.session_path ||= 'http://localhost:7474'
         cfg.session_options ||= {}
         cfg.sessions ||= []
 
-        unless (uri = URI(cfg.session_path)).user.blank?
-          cfg.session_options.reverse_merge!(basic_auth: {username: uri.user, password: uri.password})
-          cfg.session_path = cfg.session_path.gsub("#{uri.user}:#{uri.password}@", '')
-        end
+        uri = URI(cfg.session_path)
+        return if uri.user.blank?
 
-        if cfg.sessions.empty?
-          cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options}
-        end
+        cfg.session_options.reverse_merge!(basic_auth: {username: uri.user, password: uri.password})
+        cfg.session_path = cfg.session_path.gsub("#{uri.user}:#{uri.password}@", '')
       end
 
 
@@ -63,6 +68,16 @@ module Neo4j
       end
     end
 
+    def register_neo4j_cypher_logging
+      return if @neo4j_cypher_logging_registered
+
+      Neo4j::Server::CypherSession.log_with do |message|
+        Rails.logger.info message
+      end
+
+      @neo4j_cypher_logging_registered = true
+    end
+
     # Starting Neo after :load_config_initializers allows apps to
     # register migrations in config/initializers
     initializer 'neo4j.start', after: :load_config_initializers do |app|
@@ -75,14 +90,11 @@ module Neo4j
       end
       Neo4j::Config.configuration.merge!(cfg.to_hash)
 
-      clear = "\e[0m"
-      yellow = "\e[33m"
-      cyan = "\e[36m"
+      register_neo4j_cypher_logging
+    end
 
-      ActiveSupport::Notifications.subscribe('neo4j.cypher_query') do |_, start, finish, _id, payload|
-        ms = (finish - start) * 1000
-        Rails.logger.info " #{cyan}#{payload[:context]}#{clear} #{yellow}#{ms.round}ms#{clear} #{payload[:cypher]}" + (payload[:params].size > 0 ? ' | ' + payload[:params].inspect : '')
-      end
+    console do
+      register_neo4j_cypher_logging
     end
   end
 end

data/lib/neo4j/shared.rb

@@ -18,7 +18,8 @@ module Neo4j
 
       def neo4j_session
         if @neo4j_session_name
-          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")
+          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
@@ -27,10 +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)
 
       def self.i18n_scope
         :neo4j
       end
     end
+
+    def declared_property_manager
+      self.class.declared_property_manager
+    end
   end
 end

data/lib/neo4j/shared/declared_property.rb

@@ -0,0 +1,62 @@
+module Neo4j::Shared
+  # Contains methods related to the management
+  class DeclaredProperty
+    class IllegalPropertyError < StandardError; end
+
+    ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
+    attr_reader :name, :name_string, :name_sym, :options, :magic_typecaster
+
+    def initialize(name, options = {})
+      fail IllegalPropertyError, "#{name} is an illegal property" if ILLEGAL_PROPS.include?(name.to_s)
+      @name = @name_sym = name
+      @name_string = name.to_s
+      @options = options
+    end
+
+    def register
+      register_magic_properties
+    end
+
+    def type
+      options[:type]
+    end
+
+    def typecaster
+      options[:typecaster]
+    end
+
+    def default_value
+      options[:default]
+    end
+
+    private
+
+    # Tweaks properties
+    def register_magic_properties
+      options[:type] ||= DateTime if name.to_sym == :created_at || name.to_sym == :updated_at
+      # TODO: Custom typecaster to fix the stuff below
+      # 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
+
+      register_magic_typecaster
+      register_type_converter
+    end
+
+    def register_magic_typecaster
+      found_typecaster = Neo4j::Shared::TypeConverters.typecaster_for(options[:type])
+      return unless found_typecaster && found_typecaster.respond_to?(:primitive_type)
+      options[:typecaster] = found_typecaster
+      @magic_typecaster = options[:type]
+      options[:type] = found_typecaster.primitive_type
+    end
+
+    def register_type_converter
+      converter = options[:serializer]
+      return unless converter
+      options[:type]        = converter.convert_type
+      options[:typecaster]  = ActiveAttr::Typecasting::ObjectTypecaster.new
+      Neo4j::Shared::TypeConverters.register_converter(converter)
+    end
+  end
+end