neo4j-cypher 1.0.0.rc1

data/lib/neo4j-cypher/node_var.rb

@@ -0,0 +1,65 @@
+module Neo4j
+  module Cypher
+
+    # Represents an unbound node variable used in match statements
+    class NodeVar
+      include Clause
+      include Referenceable
+
+      def initialize(clause_list, var_name = nil)
+        super(clause_list, :node_var, EvalContext)
+        @var_name = var_name
+      end
+
+      def self.as_var(clause_list, something)
+        if something.is_a?(Symbol) || something.is_a?(String)
+          NodeVar.new(clause_list, something)
+        elsif something.respond_to?(:clause)
+          something.clause
+        else
+          something
+        end
+      end
+
+      def expr
+        var_name
+      end
+
+      # @return [String] a cypher string for this node variable
+      def to_cypher
+        var_name
+      end
+
+      def return_value
+        to_cypher
+      end
+
+      class EvalContext
+        include Context
+        include Variable
+        include Matchable
+        include Returnable
+        include Aggregate
+        include Alias
+
+
+        def initialize(clause)
+          super
+        end
+
+        def new(props = nil)
+          clause.clause_list.delete(clause)
+          Create.new(clause_list, props).eval_context
+        end
+
+        def [](p)
+          property = Property.new(clause, p)
+          property.match_value = clause.var_name
+          property.eval_context
+        end
+
+      end
+    end
+
+  end
+end

data/lib/neo4j-cypher/operator.rb

@@ -0,0 +1,130 @@
+module Neo4j
+  module Cypher
+
+    class Operand
+      attr_reader :obj
+
+      def initialize(obj)
+        @obj = obj.respond_to?(:clause) ? obj.clause : obj
+      end
+
+      def regexp?
+        @obj.kind_of?(Regexp)
+      end
+
+      def to_s
+        if @obj.is_a?(String)
+          %Q["#{@obj}"]
+        elsif @obj.is_a?(Operator)
+          "(#{@obj.to_s})"
+        elsif @obj.is_a?(MatchStart)
+          "(#{@obj.to_cypher})"
+        elsif @obj.respond_to?(:expr) && @obj.expr
+          @obj.expr
+        elsif @obj.respond_to?(:source)
+          "'#{@obj.source}'"
+        elsif @obj.respond_to?(:return_value)
+          @obj.return_value.to_s
+        else
+          @obj.to_s
+        end
+
+      end
+    end
+
+    class Operator
+      attr_reader :left_operand, :right_operand, :op, :neg, :eval_context
+      include Clause
+      include Referenceable
+
+      def initialize(clause_list, left_operand, right_operand, op, clause_type = :where, post_fix = nil, &dsl)
+        super(clause_list, clause_type, EvalContext)
+        right_operand = Regexp.new(right_operand) if op == '=~' && right_operand.is_a?(String)
+        @left_operand = Operand.new(left_operand)
+        raise "No Leftoperatnd #{left_operand.class}" unless @left_operand.obj
+        @right_operand = Operand.new(right_operand) if right_operand
+        @op = (@right_operand && @right_operand.regexp?) ? '=~' : op
+        @post_fix = post_fix
+        @valid = true
+
+        # since we handle it our self in to_cypher method
+        clause_list.delete(left_operand) if left_operand.kind_of?(Clause)
+        clause_list.delete(right_operand) if right_operand.kind_of?(Clause)
+
+        @neg = nil
+      end
+
+      def separator
+        " and "
+      end
+
+      def match_value
+        @left_operand.obj.match_value || expr
+      end
+
+
+      def var_name
+        @left_operand.obj.var_name
+      end
+
+      def return_value
+        (@right_operand || @unary) ? @left_operand.obj.var_name : to_cypher
+      end
+
+      def not
+        @neg = "not"
+      end
+
+      def unary!
+        @unary = true # TODO needed ?
+        eval_context
+      end
+
+      def to_s
+        to_cypher
+      end
+
+      def to_cypher
+        if @right_operand
+          neg ? "#{neg}(#{@left_operand.to_s} #{op} #{@right_operand.to_s})" : "#{@left_operand.to_s} #{op} #{@right_operand.to_s}"
+        else
+          left_p, right_p = @left_operand.to_s[0..0] == '(' ? ['', ''] : ['(', ')']
+          # binary operator
+          neg ? "#{neg}#{op}(#{@left_operand.to_s}#{@post_fix})" : "#{op}#{left_p}#{@left_operand.to_s}#{@post_fix}#{right_p}"
+        end
+      end
+
+
+      class EvalContext
+        include Context
+        include MathFunctions
+
+        def &(other)
+          Operator.new(clause.clause_list, clause, other.clause, "and").eval_context
+        end
+
+        def |(other)
+          Operator.new(clause.clause_list, clause, other.clause, "or").eval_context
+        end
+
+        def not
+          clause.not
+          self
+        end
+
+        # Only in 1.9
+        if RUBY_VERSION > "1.9.0"
+          eval %{
+             def !
+               clause.not
+               self
+             end
+             }
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/neo4j-cypher/predicate.rb

@@ -0,0 +1,64 @@
+module Neo4j
+  module Cypher
+    class Predicate
+      include Clause
+      include Referenceable
+      attr_accessor :params
+
+      def initialize(clause_list, params)
+        super(clause_list, params[:clause])
+        @identifier = :x
+        @separator = params[:separator] || ','
+        params[:input].referenced! if params[:input].respond_to?(:referenced!)
+
+        clause_list.push
+
+        var = NodeVar.as_var(clause_list, @identifier)
+
+        input = params[:input]
+
+        # TODO refactor please
+        if input.kind_of?(Property)
+          eval_prop = Property.new(var)
+          eval_prop.expr = @identifier
+          yield_param = eval_prop.eval_context
+          args = ""
+        else
+          yield_param = var.eval_context
+          args = "(#{input.var_name})"
+        end
+
+        result = RootClause::EvalContext.new(self).instance_exec(yield_param, &params[:predicate_block])
+
+        result = case params[:clause]
+          when :return_item
+            block_result = result.clause.to_cypher
+            "#{params[:op]}(#@identifier in #{params[:iterable]}#{args} : #{block_result})"
+          when :foreach
+            block_result = clause_list.to_cypher
+            "#{params[:op]}(#@identifier in #{params[:iterable]}#{args} : #{block_result})"
+          else
+            block_result = clause_list.to_cypher
+            "#{params[:op]}(#@identifier in #{params[:iterable]}#{args} WHERE #{block_result})"
+        end
+
+        clause_list.pop
+        @result = result
+      end
+
+      def return_value
+        to_cypher
+      end
+
+
+      def separator
+        @separator
+      end
+
+      def to_cypher
+        @result
+      end
+    end
+
+  end
+end

data/lib/neo4j-cypher/property.rb

@@ -0,0 +1,106 @@
+module Neo4j
+  module Cypher
+
+    # A property is returned from a Variable by using the [] operator.
+    #
+    # It has a number of useful method like
+    # <tt>count</tt>, <tt>sum</tt>, <tt>avg</tt>, <tt>min</tt>, <tt>max</tt>, <tt>collect</tt>, <tt>head</tt>, <tt>last</tt>, <tt>tail</tt>,
+    #
+    # @example
+    #  n=node(2, 3, 4); n[:name].collect
+    #  # same as START n0=node(2,3,4) RETURN collect(n0.property)
+    class Property
+      include Referenceable
+      include Clause
+
+      def initialize(var, prop_name = nil)
+        super(var.clause_list, :property, EvalContext)
+        @var = var
+        self.var_name = var.var_name
+        @prop_name = prop_name
+        @expr = prop_name ? "#{var.var_name}.#{prop_name}" : var.var_name.to_s
+      end
+
+
+      # @private
+      def to_function!(prop_name = nil)
+        @expr = "#{prop_name || @prop_name}(#{var_name})"
+        eval_context
+      end
+
+      def return_value
+        to_cypher
+      end
+
+
+      def match_value
+        @var.match_value
+      end
+
+      def unary_operator(op, clause_type = :where, post_fix = nil)
+        # TODO DELETE THIS ?
+        Operator.new(clause_list, self, nil, op, clause_type, post_fix).unary!
+      end
+
+
+      def to_cypher
+        @expr
+      end
+
+      class EvalContext
+        include Context
+        include Alias
+        include Comparable
+        include MathOperator
+        include MathFunctions
+        include PredicateMethods
+        include Aggregate
+
+        def asc
+          ReturnItem.new(clause_list, self).eval_context.asc
+        end
+
+        def desc
+          ReturnItem.new(clause_list, self).eval_context.desc
+        end
+
+        def where(&block)
+          x = block.call(self)
+          clause_list.delete(x)
+          Operator.new(clause_list, x.clause, nil, "").unary!
+          self
+        end
+
+        def where_not(&block)
+          x = block.call(self)
+          clause_list.delete(x)
+          Operator.new(clause_list, x.clause, nil, "not").unary!
+          self
+        end
+
+        # required by the Predicate Methods Module
+        # @see PredicateMethods
+        # @private
+        def iterable
+          clause.return_value
+        end
+
+        def input
+          clause
+        end
+
+        # @private
+        def in?(values)
+          clause.unary_operator("", :where, " IN [#{values.map { |x| %Q["#{x}"] }.join(',')}]")
+        end
+
+        def length
+          clause.to_function!('length')
+          self
+        end
+      end
+
+    end
+
+  end
+end

data/lib/neo4j-cypher/rel_var.rb

@@ -0,0 +1,128 @@
+module Neo4j
+  module Cypher
+
+    class RelVar
+      include Clause
+      include ToPropString
+      include Referenceable
+
+      def initialize(clause_list, expr, props = nil)
+        super(clause_list, :rel_var, EvalContext)
+
+        case expr
+          when String
+            @match_value = expr.empty? ? '?' : expr.to_s
+            guess = expr.is_a?(String) && /([[:alpha:]_]*)/.match(expr)[1]
+            self.var_name = guess.to_sym if guess && !guess.empty?
+          when Symbol
+            @match_value = ":`#{expr}`"
+          else
+            raise "Illegal arg for rel #{expr.class}"
+        end
+
+        @match_value = "#@match_value #{to_prop_string(props)}" if props
+      end
+
+      def rel_type
+        @match_value.include?(':') ? @match_value.split(':').last : @match_value.sub('?', '')
+      end
+
+      def self.join(clause_list, rel_types)
+        rel_string = rel_types.map { |r| _rel_to_string(clause_list, r) }.join('|')
+
+        if rel_string.empty?
+          RelVar.new(clause_list, "")
+        else
+          RelVar.new(clause_list, ":#{rel_string}")
+        end
+      end
+
+      def self._rel_to_string(clause_list, rel_or_symbol)
+        case rel_or_symbol
+          when String, Symbol
+            RelVar.new(clause_list, rel_or_symbol).rel_type
+          when Neo4j::Cypher::RelVar::EvalContext
+            rel_or_symbol.clause.rel_type
+          else
+            raise "Unknown type of relationship, got #{rel_or_symbol.class}"
+        end
+      end
+
+      def referenced!
+        eval_context.as(var_name) unless referenced?
+        super
+      end
+
+      def return_value
+        var_name
+      end
+
+      def optionally!
+        if @match_value.include?('?')
+          # We are done
+        elsif @match_value.include?(':')
+          @match_value.sub!(/:/, "?:")
+        else
+          @match_value += '?'
+        end
+        self
+      end
+
+      class EvalContext
+        include Context
+        include Variable
+        include Returnable
+        include Aggregate
+        include Alias
+
+        def rel_type
+          Property.new(clause, 'type').to_function!
+        end
+
+
+        def where(&block)
+          x = block.call(self)
+          clause_list.delete(x)
+          Operator.new(clause_list, x.clause, nil, "").unary!
+          self
+        end
+
+        def where_not(&block)
+          x = block.call(self)
+          clause_list.delete(x)
+          Operator.new(clause_list, x.clause, nil, "not").unary!
+          self
+        end
+
+        # generates a <tt>is null</tt> cypher fragment.
+        def null
+          clause.referenced!
+          Operator.new(clause_list, self, nil, '', :where, " is null").unary!
+        end
+
+
+        def [](p)
+          # TODO
+          clause.referenced!
+          property = super
+          property.clause.match_value = clause.expr
+          property
+        end
+
+        def as(name) # TODO DRY
+          super
+          super.tap do
+            if clause.match_value == '?'
+              clause.match_value = "#{clause.var_name}?"
+            elsif clause.match_value.include?(':') || clause.match_value.include?('?')
+              clause.match_value = clause.match_value.sub(/[^:\?]*/, clause.var_name.to_s)
+            else
+              clause.match_value = clause.var_name.to_s
+            end
+          end
+        end
+      end
+    end
+
+  end
+end