neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-core/query_clauses.rb

@@ -1,496 +1,512 @@
-module Neo4j::Core
-  module QueryClauses
-
-    class ArgError < StandardError
-      attr_reader :arg_part
-      def initialize(arg_part = nil)
-        super
-        @arg_part = arg_part
+module Neo4j
+  module Core
+    module QueryClauses
+      class ArgError < StandardError
+        attr_reader :arg_part
+        def initialize(arg_part = nil)
+          super
+          @arg_part = arg_part
+        end
       end
-    end
 
 
-    class Clause
-      include CypherTranslator
+      class Clause
+        include CypherTranslator
 
-      attr_reader :params
+        attr_reader :params
 
-      def initialize(arg, options = {})
-        @arg = arg
-        @options = options
-        @params = {}
-      end
+        def initialize(arg, options = {})
+          @arg = arg
+          @options = options
+          @params = {}
+        end
 
-      def value
-        if @arg.is_a?(String)
-          self.from_string @arg
+        def value
+          [String, Symbol, Integer, Hash].each do |arg_class|
+            from_method = "from_#{arg_class.name.downcase}"
+            return send(from_method, @arg) if @arg.is_a?(arg_class) && self.respond_to?(from_method)
+          end
 
-        elsif @arg.is_a?(Symbol) && self.respond_to?(:from_symbol)
-          self.from_symbol @arg
+          fail ArgError
+        rescue ArgError => arg_error
+          message = "Invalid argument for #{self.class.keyword}.  Full arguments: #{@arg.inspect}"
+          message += " | Invalid part: #{arg_error.arg_part.inspect}" if arg_error.arg_part
 
-        elsif @arg.is_a?(Integer) && self.respond_to?(:from_integer)
-          self.from_integer @arg
+          raise ArgumentError, message
+        end
 
-        elsif @arg.is_a?(Hash)
-          if self.respond_to?(:from_hash)
-            self.from_hash @arg
-          elsif self.respond_to?(:from_key_and_value)
-            @arg.map do |key, value|
-              self.from_key_and_value key, value
+        def from_hash(value)
+          if self.respond_to?(:from_key_and_value)
+            value.map do |k, v|
+              from_key_and_value k, v
             end
           else
-            raise ArgError.new
+            fail ArgError
           end
-
-        else
-          raise ArgError.new
         end
 
-      rescue ArgError => arg_error
-        message = "Invalid argument for #{self.class.keyword}.  Full arguments: #{@arg.inspect}"
-        message += " | Invalid part: #{arg_error.arg_part.inspect}" if arg_error.arg_part
+        def from_string(value)
+          value
+        end
 
-        raise ArgumentError, message
-      end
+        def node_from_key_and_value(key, value, options = {})
+          var = var_from_key_and_value(key, value, options[:prefer] || :var)
+          label = label_from_key_and_value(key, value, options[:prefer] || :var)
+          attributes = attributes_from_key_and_value(key, value)
 
-      def from_string(value)
-        value
-      end
+          "(#{var}#{format_label(label)}#{attributes_string(attributes)})"
+        end
 
-      def node_from_key_and_value(key, value, options = {})
-        prefer = options[:prefer] || :var
-
-        var, label_string, attributes_string = nil
-
-        case value
-        when String, Symbol
-          var = key
-          label_string = value
-        when Hash
-          if !value.values.any? {|v| v.is_a?(Hash) }
-            case prefer
-            when :var
-              var = key
-            when :label
-              label_string = key
+        def var_from_key_and_value(key, value, prefer = :var)
+          case value
+          when String, Symbol, Class, Module
+            key
+          when Hash
+            if value.values.none? { |v| v.is_a?(Hash) }
+              key if prefer == :var
+            else
+              key
             end
           else
-            var = key
+            fail ArgError, value
           end
+        end
 
-          if value.size == 1 && value.values.first.is_a?(Hash)
-            label_string, attributes = value.first
-            attributes_string = attributes_string(attributes)
+        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 Hash
+            if value.values.map(&:class) == [Hash]
+              value.first.first
+            else
+              key if value.values.none? { |v| v.is_a?(Hash) } && prefer == :label
+            end
           else
-            attributes_string = attributes_string(value)
+            fail ArgError, value
           end
-        when Class, Module
-          var = key
-          label_string = defined?(value::CYPHER_LABEL) ? value::CYPHER_LABEL : value.name
-        else
-          raise ArgError.new(value)
         end
 
-        "(#{var}#{format_label(label_string)}#{attributes_string})"
-      end
-
-      class << self
-        attr_reader :keyword
+        def attributes_from_key_and_value(key, value)
+          return nil unless value.is_a?(Hash)
 
-        def from_args(args, options = {})
-          args.flatten.map do |arg|
-            if !arg.respond_to?(:empty?) || !arg.empty?
-              self.new(arg, options)
-            end
-          end.compact
+          if value.values.map(&:class) == [Hash]
+            value.first[1]
+          else
+            value
+          end
         end
 
-        def to_cypher(clauses)
-          string = clause_string(clauses)
+        class << self
+          attr_reader :keyword
+
+          def from_args(args, options = {})
+            args.flatten.map do |arg|
+              new(arg, options) if !arg.respond_to?(:empty?) || !arg.empty?
+            end.compact
+          end
+
+          def to_cypher(clauses)
+            string = clause_string(clauses)
+            string.strip!
 
-          "#{@keyword} #{string}" if string.to_s.strip.size > 0
+            "#{@keyword} #{string}" if string.size > 0
+          end
         end
-      end
 
-      private
+        private
 
-      def key_value_string(key, value, previous_keys = [], force_equals = false)
-        param = (previous_keys + [key]).join('_').gsub(/[^a-z0-9]+/i, '_').gsub(/^_+|_+$/, '')
-        @params[param.to_sym] = value
+        def key_value_string(key, value, previous_keys = [], force_equals = false)
+          param = (previous_keys << key).join('_')
+          param.gsub!(/[^a-z0-9]+/i, '_')
+          param.gsub!(/^_+|_+$/, '')
+          @params[param.to_sym] = value
 
-        if !value.is_a?(Array) || force_equals
-          "#{key} = {#{param}}"
-        else
-          "#{key} IN {#{param}}"
+          if !value.is_a?(Array) || force_equals
+            "#{key} = {#{param}}"
+          else
+            "#{key} IN {#{param}}"
+          end
         end
-      end
 
-      def format_label(label_string)
-        label_string = label_string.to_s.strip
-        if !label_string.empty? && label_string[0] != ':'
-          label_string = "`#{label_string}`" unless label_string.match(' ')
-          label_string = ":#{label_string}"
+        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}"
+          end
+          label_string
         end
-        label_string
-      end
 
-      def attributes_string(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(', ')
+        def attributes_string(attributes)
+          return '' if not attributes
 
-        " {#{attributes_string}}"
+          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(', ')
+
+          " {#{attributes_string}}"
+        end
       end
-    end
 
-    class StartClause < Clause
-      @keyword = 'START'
+      class StartClause < Clause
+        @keyword = 'START'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      def from_key_and_value(key, value)
-        case value
-        when String, Symbol
-          "#{key} = #{value}"
-        else
-          raise ArgError.new(value)
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{key} = #{value}"
+          else
+            fail ArgError, value
+          end
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class WhereClause < Clause
-      @keyword = 'WHERE'
+      class WhereClause < Clause
+        @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
-              "ID(#{key}) = #{v.to_i}"
-            else
-              key.to_s + '.' + 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)
-        else
-          key_value_string(key, value, previous_keys)
+        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)
+          else
+            key_value_string(key, value, previous_keys)
+          end
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(' AND ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(' AND ')
+          end
         end
       end
-    end
 
 
-    class MatchClause < Clause
-      @keyword = 'MATCH'
+      class MatchClause < Clause
+        @keyword = 'MATCH'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      def from_key_and_value(key, value)
-        self.node_from_key_and_value(key, value)
-      end
+        def from_key_and_value(key, value)
+          node_from_key_and_value(key, value)
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class OptionalMatchClause < MatchClause
-      @keyword = 'OPTIONAL MATCH'
-    end
+      class OptionalMatchClause < MatchClause
+        @keyword = 'OPTIONAL MATCH'
+      end
 
-    class WithClause < Clause
-      @keyword = 'WITH'
+      class WithClause < Clause
+        @keyword = 'WITH'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      def from_key_and_value(key, value)
-        "#{value} AS #{key}"
-      end
+        def from_key_and_value(key, value)
+          "#{value} AS #{key}"
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class UsingClause < Clause
-      @keyword = 'USING'
+      class UsingClause < Clause
+        @keyword = 'USING'
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(" #{@keyword} ")
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(" #{@keyword} ")
+          end
         end
       end
-    end
 
-    class CreateClause < Clause
-      @keyword = 'CREATE'
+      class CreateClause < Clause
+        @keyword = 'CREATE'
 
-      def from_string(value)
-        value
-      end
+        def from_string(value)
+          value
+        end
 
-      def from_symbol(value)
-        "(:#{value})"
-      end
+        def from_symbol(value)
+          "(:#{value})"
+        end
 
-      def from_hash(hash)
-        if hash.values.any? {|value| value.is_a?(Hash) }
-          hash.map do |key, value|
-            from_key_and_value(key, value)
+        def from_hash(hash)
+          if hash.values.any? { |value| value.is_a?(Hash) }
+            hash.map do |key, value|
+              from_key_and_value(key, value)
+            end
+          else
+            "(#{attributes_string(hash)})"
           end
-        else
-          "(#{attributes_string(hash)})"
         end
-      end
 
-      def from_key_and_value(key, value)
-        self.node_from_key_and_value(key, value, prefer: :label)
-      end
+        def from_key_and_value(key, value)
+          node_from_key_and_value(key, value, prefer: :label)
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class CreateUniqueClause < CreateClause
-      @keyword = 'CREATE UNIQUE'
-    end
+      class CreateUniqueClause < CreateClause
+        @keyword = 'CREATE UNIQUE'
+      end
 
-    class MergeClause < CreateClause
-      @keyword = 'MERGE'
-    end
+      class MergeClause < CreateClause
+        @keyword = 'MERGE'
+      end
 
-    class DeleteClause < Clause
-      @keyword = 'DELETE'
+      class DeleteClause < Clause
+        @keyword = 'DELETE'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class OrderClause < Clause
-      @keyword = 'ORDER BY'
+      class OrderClause < Clause
+        @keyword = 'ORDER BY'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      def from_key_and_value(key, value)
-        case value
-        when String, Symbol
-          "#{key}.#{value}"
-        when Array
-          value.map do |v|
-            if v.is_a?(Hash)
-              from_key_and_value(key, v)
-            else
-              "#{key}.#{v}"
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{key}.#{value}"
+          when Array
+            value.map do |v|
+              if v.is_a?(Hash)
+                from_key_and_value(key, v)
+              else
+                "#{key}.#{v}"
+              end
+            end
+          when Hash
+            value.map do |k, v|
+              "#{key}.#{k} #{v.upcase}"
             end
-          end
-        when Hash
-          value.map do |k, v|
-            "#{key}.#{k} #{v.upcase}"
           end
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class LimitClause < Clause
-      @keyword = 'LIMIT'
+      class LimitClause < Clause
+        @keyword = 'LIMIT'
 
-      def from_string(value)
-        value.to_i
-      end
+        def from_string(value)
+          clause_id = "#{self.class.keyword.downcase}_#{value}"
+          @params[clause_id] = value.to_i
+          "{#{clause_id}}"
+        end
 
-      def from_integer(value)
-        value
-      end
+        def from_integer(value)
+          clause_id = "#{self.class.keyword.downcase}_#{value}"
+          @params[clause_id] = value
+          "{#{clause_id}}"
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.last.value
+        class << self
+          def clause_string(clauses)
+            clauses.last.value
+          end
         end
       end
-    end
 
-    class SkipClause < Clause
-      @keyword = 'SKIP'
+      class SkipClause < Clause
+        @keyword = 'SKIP'
 
-      def from_string(value)
-        value.to_i
-      end
+        def from_string(value)
+          clause_id = "#{self.class.keyword.downcase}_#{value}"
+          @params[clause_id] = value.to_i
+          "{#{clause_id}}"
+        end
 
-      def from_integer(value)
-        value
-      end
+        def from_integer(value)
+          clause_id = "#{self.class.keyword.downcase}_#{value}"
+          @params[clause_id] = value
+          "{#{clause_id}}"
+        end
 
-      class << self
-        def clause_string(clauses)
-          clauses.last.value
+        class << self
+          def clause_string(clauses)
+            clauses.last.value
+          end
         end
       end
-    end
 
-    class SetClause < Clause
-      @keyword = 'SET'
-
-      def from_key_and_value(key, value)
-        case value
-        when String, Symbol
-          "#{key} = #{value}"
-        when Hash
-          if @options[:set_props]
-            attribute_string = value.map {|k, v| "#{k}: #{v.inspect}" }.join(', ')
-            "#{key} = {#{attribute_string}}"
-          else
-            value.map do |k, v|
-              key_value_string("#{key}.`#{k}`", v, ['setter'], true)
+      class SetClause < Clause
+        @keyword = 'SET'
+
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{key} = #{value}"
+          when Hash
+            if @options[:set_props]
+              attribute_string = value.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+              "#{key} = {#{attribute_string}}"
+            else
+              value.map do |k, v|
+                key_value_string("#{key}.`#{k}`", v, ['setter'], true)
+              end
             end
+          else
+            fail ArgError, value
           end
-        else
-          raise ArgError.new(value)
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class OnCreateSetClause < SetClause
-      @keyword = 'ON CREATE SET'
+      class OnCreateSetClause < SetClause
+        @keyword = 'ON CREATE SET'
 
-      def initialize(*args)
-        super
-        @options[:set_props] = false
+        def initialize(*args)
+          super
+          @options[:set_props] = false
+        end
       end
-    end
 
-    class OnMatchSetClause < OnCreateSetClause
-      @keyword = 'ON MATCH SET'
-    end
+      class OnMatchSetClause < OnCreateSetClause
+        @keyword = 'ON MATCH SET'
+      end
 
-    class RemoveClause < Clause
-      @keyword = 'REMOVE'
+      class RemoveClause < Clause
+        @keyword = 'REMOVE'
 
-      def from_key_and_value(key, value)
-        case value
-        when /^:/
-          "#{key}:#{value[1..-1]}"
-        when String
-          "#{key}.#{value}"
-        when Symbol
-          "#{key}:#{value}"
-        else
-          raise ArgError.new(value)
+        def from_key_and_value(key, value)
+          case value
+          when /^:/
+            "#{key}:#{value[1..-1]}"
+          when String
+            "#{key}.#{value}"
+          when Symbol
+            "#{key}:#{value}"
+          else
+            fail ArgError, value
+          end
         end
 
-      end
-
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
-    end
 
-    class UnwindClause < Clause
-      @keyword = 'UNWIND'
+      class UnwindClause < Clause
+        @keyword = 'UNWIND'
 
-      def from_key_and_value(key, value)
-        case value
-        when String, Symbol
-          "#{value} AS #{key}"
-        when Array
-          "#{value.inspect} AS #{key}"
-        else
-          raise ArgError.new(value)
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{value} AS #{key}"
+          when Array
+            "#{value.inspect} AS #{key}"
+          else
+            fail ArgError, value
+          end
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(' UNWIND ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(' UNWIND ')
+          end
         end
       end
-    end
 
-    class ReturnClause < Clause
-      @keyword = 'RETURN'
+      class ReturnClause < Clause
+        @keyword = 'RETURN'
 
-      def from_symbol(value)
-        from_string(value.to_s)
-      end
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
 
-      def from_key_and_value(key, value)
-        case value
-        when Array
-          value.map do |v|
-            from_key_and_value(key, v)
-          end.join(', ')
-        when String, Symbol
-          "#{key}.#{value}"
-        else
-          raise ArgError.new(value)
+        def from_key_and_value(key, value)
+          case value
+          when Array
+            value.map do |v|
+              from_key_and_value(key, v)
+            end.join(', ')
+          when String, Symbol
+            "#{key}.#{value}"
+          else
+            fail ArgError, value
+          end
         end
-      end
 
-      class << self
-        def clause_string(clauses)
-          clauses.map(&:value).join(', ')
+        class << self
+          def clause_string(clauses)
+            clauses.map!(&:value).join(', ')
+          end
         end
       end
     end
-
-
   end
 end
-