neo4j-core 4.0.7 → 5.0.0.rc.1

data/lib/neo4j-core/query_clauses.rb

@@ -12,8 +12,11 @@ module Neo4j
 
       class Clause
         include CypherTranslator
+        UNDERSCORE = '_'
+        COMMA_SPACE = ', '
+        AND = ' AND '
 
-        attr_reader :params
+        attr_accessor :params, :arg
 
         def initialize(arg, options = {})
           @arg = arg
@@ -54,19 +57,23 @@ module Neo4j
           label = label_from_key_and_value(key, value, options[:prefer] || :var)
           attributes = attributes_from_key_and_value(key, value)
 
-          "(#{var}#{format_label(label)}#{attributes_string(attributes)})"
+          prefix_value = value
+          if value.is_a?(Hash)
+            prefix_value = if value.values.any? { |v| v.is_a?(Hash) }
+                             value.keys.join(UNDERSCORE)
+                           end
+          end
+
+          prefix_array = [key, prefix_value].tap(&:compact!).join(UNDERSCORE)
+          formatted_attributes = attributes_string(attributes, "#{prefix_array}#{UNDERSCORE}")
+          "(#{var}#{format_label(label)}#{formatted_attributes})"
         end
 
         def var_from_key_and_value(key, value, prefer = :var)
           case value
-          when String, Symbol, Class, Module
-            key
+          when String, Symbol, Class, Module, NilClass, Array then key
           when Hash
-            if value.values.none? { |v| v.is_a?(Hash) }
-              key if prefer == :var
-            else
-              key
-            end
+            key if _use_key_for_var?(value, prefer)
           else
             fail ArgError, value
           end
@@ -74,22 +81,29 @@ module Neo4j
 
         def label_from_key_and_value(key, value, prefer = :var)
           case value
-          when String, Symbol
-            value
-          when Class, Module
-            defined?(value::CYPHER_LABEL) ? value::CYPHER_LABEL : value.name
+          when String, Symbol, Array, NilClass then value
+          when Class, Module then value.name
           when Hash
             if value.values.map(&:class) == [Hash]
               value.first.first
             else
-              key if value.values.none? { |v| v.is_a?(Hash) } && prefer == :label
+              key if !_use_key_for_var?(value, prefer)
             end
           else
             fail ArgError, value
           end
         end
 
-        def attributes_from_key_and_value(key, value)
+        def _use_key_for_var?(value, prefer)
+          _nested_value_hash?(value) || prefer == :var
+        end
+
+        def _nested_value_hash?(value)
+          value.values.any? { |v| v.is_a?(Hash) }
+        end
+
+
+        def attributes_from_key_and_value(_key, value)
           return nil unless value.is_a?(Hash)
 
           if value.values.map(&:class) == [Hash]
@@ -100,28 +114,41 @@ module Neo4j
         end
 
         class << self
-          attr_reader :keyword
+          def keyword
+            self::KEYWORD
+          end
+
+          def keyword_downcase
+            keyword.downcase
+          end
 
           def from_args(args, options = {})
-            args.flatten.map do |arg|
-              new(arg, options) if !arg.respond_to?(:empty?) || !arg.empty?
-            end.compact
+            args.flatten!
+            args.map { |arg| from_arg(arg, options) }.tap(&:compact!)
+          end
+
+          def from_arg(arg, options = {})
+            new(arg, options) if !arg.respond_to?(:empty?) || !arg.empty?
           end
 
           def to_cypher(clauses)
+            @question_mark_param_index = 1
+
             string = clause_string(clauses)
             string.strip!
 
-            "#{@keyword} #{string}" if string.size > 0
+            "#{keyword} #{string}" if string.size > 0
           end
         end
 
         private
 
         def key_value_string(key, value, previous_keys = [], force_equals = false)
-          param = (previous_keys << key).join('_')
-          param.gsub!(/[^a-z0-9]+/i, '_')
+          param = (previous_keys << key).join(UNDERSCORE)
+          param.tr_s!('^a-zA-Z0-9', UNDERSCORE)
           param.gsub!(/^_+|_+$/, '')
+
+          value = value.first if value.is_a?(Array) && value.size == 1
           @params[param.to_sym] = value
 
           if !value.is_a?(Array) || force_equals
@@ -131,34 +158,39 @@ module Neo4j
           end
         end
 
-        def format_label(label_string)
-          label_string = label_string.to_s
-          label_string.strip!
-          if !label_string.empty? && label_string[0] != ':'
-            label_string = "`#{label_string}`" unless label_string.match(' ')
-            label_string = ":#{label_string}"
+        def format_label(label_arg)
+          if label_arg.is_a?(Array)
+            return label_arg.map { |arg| format_label(arg) }.join
           end
-          label_string
+
+          label_arg = label_arg.to_s
+          label_arg.strip!
+          if !label_arg.empty? && label_arg[0] != ':'
+            label_arg = "`#{label_arg}`" unless label_arg.match(' ')
+            label_arg = ":#{label_arg}"
+          end
+          label_arg
         end
 
-        def attributes_string(attributes)
+        def attributes_string(attributes, prefix = '')
           return '' if not attributes
 
           attributes_string = attributes.map do |key, value|
-            v = if value.nil?
-                  'null'
-                else
-                  value.to_s.match(/^{.+}$/) ? value : value.inspect
-                end
-            "#{key}: #{v}"
-          end.join(', ')
+            if value.to_s.match(/^{.+}$/)
+              "#{key}: #{value}"
+            else
+              param_key = "#{prefix}#{key}".gsub('::', '_')
+              @params[param_key.to_sym] = value
+              "#{key}: {#{param_key}}"
+            end
+          end.join(Clause::COMMA_SPACE)
 
           " {#{attributes_string}}"
         end
       end
 
       class StartClause < Clause
-        @keyword = 'START'
+        KEYWORD = 'START'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -175,33 +207,20 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class WhereClause < Clause
-        @keyword = 'WHERE'
+        KEYWORD = 'WHERE'
 
         def from_key_and_value(key, value, previous_keys = [])
           case value
-          when Hash
-            value.map do |k, v|
-              if k.to_sym == :neo_id
-                clause_id = "neo_id_#{v}"
-                @params[clause_id] = v.to_i
-                "ID(#{key}) = {#{clause_id}}"
-              else
-                "#{key}.#{from_key_and_value(k, v, previous_keys + [key])}"
-              end
-            end.join(' AND ')
-          when NilClass
-            "#{key} IS NULL"
-          when Regexp
-            pattern = (value.casefold? ? '(?i)' : '') + value.source
-            "#{key} =~ #{escape_value(pattern.gsub(/\\/, '\\\\\\'))}"
-          when Array
-            key_value_string(key, value, previous_keys)
+          when Hash then hash_key_value_string(key, value, previous_keys)
+          when NilClass then "#{key} IS NULL"
+          when Regexp then regexp_key_value_string(key, value)
+          when Array then key_value_string(key, value, previous_keys)
           else
             key_value_string(key, value, previous_keys)
           end
@@ -209,14 +228,62 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map(&:value).flatten.map {|value| "(#{value})" }.join(' AND ')
+            clauses.map!(&:value).tap(&:flatten!).map! { |value| "(#{value})" }.join(Clause::AND)
+          end
+        end
+
+        private
+
+        def hash_key_value_string(key, value, previous_keys)
+          value.map do |k, v|
+            if k.to_sym == :neo_id
+              v = Array(v).map { |item| (item.respond_to?(:neo_id) ? item.neo_id : item).to_i }
+              key_value_string("ID(#{key})", v)
+            else
+              "#{key}.#{from_key_and_value(k, v, previous_keys + [key])}"
+            end
+          end.join(AND)
+        end
+
+        def regexp_key_value_string(key, value)
+          pattern = (value.casefold? ? '(?i)' : '') + value.source
+          "#{key} =~ #{escape_value(pattern.gsub(/\\/, '\\\\\\'))}"
+        end
+
+        class << self
+          ARG_HAS_QUESTION_MARK_REGEX = /(^|\s)\?(\s|$)/
+
+          def from_args(args, options = {})
+            query_string, params = args
+
+            if query_string.is_a?(String) && (query_string.match(ARG_HAS_QUESTION_MARK_REGEX) || params.is_a?(Hash))
+              if !params.is_a?(Hash)
+                question_mark_params_param = self.question_mark_params_param
+                query_string.gsub!(ARG_HAS_QUESTION_MARK_REGEX, "\\1{#{question_mark_params_param}}\\2")
+                params = {question_mark_params_param.to_sym => params}
+              end
+
+              clause = from_arg(query_string, options).tap do |clause|
+                clause.params.merge!(params)
+              end
+
+              [clause]
+            else
+              super
+            end
+          end
+
+          def question_mark_params_param
+            result = "question_mark_param#{@question_mark_param_index}"
+            @question_mark_param_index += 1
+            result
           end
         end
       end
 
 
       class MatchClause < Clause
-        @keyword = 'MATCH'
+        KEYWORD = 'MATCH'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -228,17 +295,17 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class OptionalMatchClause < MatchClause
-        @keyword = 'OPTIONAL MATCH'
+        KEYWORD = 'OPTIONAL MATCH'
       end
 
       class WithClause < Clause
-        @keyword = 'WITH'
+        KEYWORD = 'WITH'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -250,23 +317,23 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class UsingClause < Clause
-        @keyword = 'USING'
+        KEYWORD = 'USING'
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(" #{@keyword} ")
+            clauses.map!(&:value).join(" #{keyword} ")
           end
         end
       end
 
       class CreateClause < Clause
-        @keyword = 'CREATE'
+        KEYWORD = 'CREATE'
 
         def from_string(value)
           value
@@ -298,15 +365,15 @@ module Neo4j
       end
 
       class CreateUniqueClause < CreateClause
-        @keyword = 'CREATE UNIQUE'
+        KEYWORD = 'CREATE UNIQUE'
       end
 
       class MergeClause < CreateClause
-        @keyword = 'MERGE'
+        KEYWORD = 'MERGE'
       end
 
       class DeleteClause < Clause
-        @keyword = 'DELETE'
+        KEYWORD = 'DELETE'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -314,13 +381,13 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class OrderClause < Clause
-        @keyword = 'ORDER BY'
+        KEYWORD = 'ORDER BY'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -332,38 +399,32 @@ module Neo4j
             "#{key}.#{value}"
           when Array
             value.map do |v|
-              if v.is_a?(Hash)
-                from_key_and_value(key, v)
-              else
-                "#{key}.#{v}"
-              end
+              v.is_a?(Hash) ?  from_key_and_value(key, v) : "#{key}.#{v}"
             end
           when Hash
-            value.map do |k, v|
-              "#{key}.#{k} #{v.upcase}"
-            end
+            value.map { |k, v| "#{key}.#{k} #{v.upcase}" }
           end
         end
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class LimitClause < Clause
-        @keyword = 'LIMIT'
+        KEYWORD = 'LIMIT'
 
         def from_string(value)
-          clause_id = "#{self.class.keyword.downcase}_#{value}"
-          @params[clause_id] = value.to_i
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          @params[clause_id.to_sym] = value.to_i
           "{#{clause_id}}"
         end
 
         def from_integer(value)
-          clause_id = "#{self.class.keyword.downcase}_#{value}"
-          @params[clause_id] = value
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          @params[clause_id.to_sym] = value
           "{#{clause_id}}"
         end
 
@@ -375,17 +436,17 @@ module Neo4j
       end
 
       class SkipClause < Clause
-        @keyword = 'SKIP'
+        KEYWORD = 'SKIP'
 
         def from_string(value)
-          clause_id = "#{self.class.keyword.downcase}_#{value}"
-          @params[clause_id] = value.to_i
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          @params[clause_id.to_sym] = value.to_i
           "{#{clause_id}}"
         end
 
         def from_integer(value)
-          clause_id = "#{self.class.keyword.downcase}_#{value}"
-          @params[clause_id] = value
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          @params[clause_id.to_sym] = value
           "{#{clause_id}}"
         end
 
@@ -397,21 +458,20 @@ module Neo4j
       end
 
       class SetClause < Clause
-        @keyword = 'SET'
+        KEYWORD = 'SET'
 
         def from_key_and_value(key, value)
           case value
-          when String, Symbol
-            "#{key} = #{value}"
+          when String, Symbol then "#{key}:`#{value}`"
           when Hash
             if @options[:set_props]
-              attribute_string = value.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+              attribute_string = value.map { |k, v| "#{k}: #{v.inspect}" }.join(Clause::COMMA_SPACE)
               "#{key} = {#{attribute_string}}"
             else
-              value.map do |k, v|
-                key_value_string("#{key}.`#{k}`", v, ['setter'], true)
-              end
+              value.map { |k, v| key_value_string("#{key}.`#{k}`", v, ['setter'], true) }
             end
+          when Array then value.map { |v| from_key_and_value(key, v) }
+          when NilClass then []
           else
             fail ArgError, value
           end
@@ -419,13 +479,13 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class OnCreateSetClause < SetClause
-        @keyword = 'ON CREATE SET'
+        KEYWORD = 'ON CREATE SET'
 
         def initialize(*args)
           super
@@ -434,20 +494,24 @@ module Neo4j
       end
 
       class OnMatchSetClause < OnCreateSetClause
-        @keyword = 'ON MATCH SET'
+        KEYWORD = 'ON MATCH SET'
       end
 
       class RemoveClause < Clause
-        @keyword = 'REMOVE'
+        KEYWORD = 'REMOVE'
 
         def from_key_and_value(key, value)
           case value
           when /^:/
-            "#{key}:#{value[1..-1]}"
+            "#{key}:`#{value[1..-1]}`"
           when String
             "#{key}.#{value}"
           when Symbol
-            "#{key}:#{value}"
+            "#{key}:`#{value}`"
+          when Array
+            value.map do |v|
+              from_key_and_value(key, v)
+            end
           else
             fail ArgError, value
           end
@@ -455,13 +519,13 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end
 
       class UnwindClause < Clause
-        @keyword = 'UNWIND'
+        KEYWORD = 'UNWIND'
 
         def from_key_and_value(key, value)
           case value
@@ -482,7 +546,7 @@ module Neo4j
       end
 
       class ReturnClause < Clause
-        @keyword = 'RETURN'
+        KEYWORD = 'RETURN'
 
         def from_symbol(value)
           from_string(value.to_s)
@@ -493,9 +557,13 @@ module Neo4j
           when Array
             value.map do |v|
               from_key_and_value(key, v)
-            end.join(', ')
+            end.join(Clause::COMMA_SPACE)
           when String, Symbol
-            "#{key}.#{value}"
+            if value.to_sym == :neo_id
+              "ID(#{key})"
+            else
+              "#{key}.#{value}"
+            end
           else
             fail ArgError, value
           end
@@ -503,7 +571,7 @@ module Neo4j
 
         class << self
           def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+            clauses.map!(&:value).join(Clause::COMMA_SPACE)
           end
         end
       end

data/lib/neo4j-core/query_find_in_batches.rb

@@ -2,8 +2,7 @@ module Neo4j
   module Core
     module QueryFindInBatches
       def find_in_batches(node_var, prop_var, options = {})
-        invalid_keys = options.keys.map(&:to_sym) - [:batch_size]
-        fail ArgumentError, "Invalid keys: #{invalid_keys.join(', ')}" if not invalid_keys.empty?
+        validate_find_in_batches_options!(options)
 
         batch_size = options.delete(:batch_size) || 1000
 
@@ -13,15 +12,7 @@ module Neo4j
 
         while records.any?
           records_size = records.size
-          primary_key_offset = begin
-                                 records.last.send(node_var).send(prop_var)
-                               rescue NoMethodError
-                                 begin
-                                   records.last.send(node_var)[prop_var.to_sym]
-                                 rescue NoMethodError
-                                   records.last.send("#{node_var}.#{prop_var}") # In case we're explicitly returning it
-                                 end
-                               end
+          primary_key_offset = primary_key_offset(records.last, node_var, prop_var)
 
           yield records
 
@@ -36,6 +27,23 @@ module Neo4j
           batch.each { |result| yield result }
         end
       end
+
+      private
+
+      def validate_find_in_batches_options!(options)
+        invalid_keys = options.keys.map(&:to_sym) - [:batch_size]
+        fail ArgumentError, "Invalid keys: #{invalid_keys.join(', ')}" if not invalid_keys.empty?
+      end
+
+      def primary_key_offset(last_record, node_var, prop_var)
+        last_record.send(node_var).send(prop_var)
+      rescue NoMethodError
+        begin
+          last_record.send(node_var)[prop_var.to_sym]
+        rescue NoMethodError
+          last_record.send("#{node_var}.#{prop_var}") # In case we're explicitly returning it
+        end
+      end
     end
   end
 end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = '4.0.7'
+    VERSION = '5.0.0.rc.1'
   end
 end

data/lib/neo4j-core.rb

@@ -1,3 +1,6 @@
+require 'ext/kernel'
+
+require 'ostruct'
 require 'forwardable'
 require 'fileutils'
 

data/lib/neo4j-embedded/cypher_response.rb

@@ -12,26 +12,31 @@ module Neo4j
       include Enumerable
 
       # @return the original result from the Neo4j Cypher Engine, once forward read only !
-      attr_reader :source
+      attr_reader :source, :unwrapped
 
-      def initialize(source, query)
+      def initialize(source, query, unwrapped = nil)
         @source = source
-        @struct = Struct.new(*source.columns.to_a.map(&:to_sym))
+        @struct = Struct.new(*source.columns.to_a.map!(&:to_sym)) unless source.columns.empty?
         @unread = true
         @query = query
+        @unwrapped = unwrapped
       end
 
       def to_s
         @query
       end
 
+      def unwrapped?
+        !!unwrapped
+      end
+
       def inspect
         "Enumerable query: '#{@query}'"
       end
 
       # @return [Array<Symbol>] the columns in the query result
       def columns
-        @source.columns.map(&:to_sym)
+        @source.columns.map!(&:to_sym)
       end
 
       def each
@@ -40,13 +45,23 @@ module Neo4j
         if block_given?
           @source.each do |row|
             yield(row.each_with_object(@struct.new) do |(column, value), result|
-              result[column.to_sym] = (value.respond_to?(:wrapper) ? value.wrapper : value)
+              result[column.to_sym] = unwrap(value)
             end)
           end
         else
           Enumerator.new(self)
         end
       end
+
+      private
+
+      def unwrap(value)
+        if !value.nil? && value.respond_to?(:to_a)
+          value.map { |v| unwrap(v) }
+        else
+          (!value.respond_to?(:wrapper) || unwrapped?) ? value : value.wrapper
+        end
+      end
     end
   end
 end