neo4j-cypher 1.0.0.rc2 → 1.0.0

data/lib/neo4j-cypher/create.rb

@@ -17,9 +17,7 @@ module Neo4j
 
 
     class Create
-      include ToPropString
       include Clause
-      include Referenceable
 
       def initialize(clause_list, props)
         super(clause_list, :create, EvalContext)
@@ -59,7 +57,6 @@ module Neo4j
 
     class CreatePath
       include Clause
-      include Referenceable
 
       attr_reader :arg_list
 

data/lib/neo4j-cypher/foreach.rb

@@ -0,0 +1,16 @@
+module Neo4j
+  module Cypher
+    class Foreach < AbstractFilter
+
+      def initialize(clause_list, input_context, &block)
+        super(clause_list, :foreach, input_context)
+        # Input can either be a property array or a node/relationship collection
+        input = input_context.clause
+        clause_list.delete(input)
+        filter_initialize(input_context, '', " : ", &block)
+      end
+
+    end
+  end
+
+end

data/lib/neo4j-cypher/match.rb

@@ -3,7 +3,6 @@ module Neo4j
 
     class MatchStart
       include Clause
-      include Referenceable
 
       attr_reader :match_list
       attr_accessor :algorithm
@@ -196,7 +195,7 @@ module Neo4j
             set_rel(rels.first)
           else
             # wrap and maybe join several relationship strings
-            @rel_var = RelVar.join(clause_list, rels)
+            @rel_var = RelVar.new(clause_list, rels)
           end
           self
         end
@@ -215,16 +214,11 @@ module Neo4j
           elsif rel.respond_to?(:clause) && rel.clause.match_value
             @rel_var = rel.clause
           else
-            @rel_var = RelVar.new(clause_list, rel)
+            @rel_var = RelVar.new(clause_list, [rel])
           end
           self
         end
 
-        def self.new_first(match_start, from, rel)
-          from_var = NodeVar.as_var(match_start.clause_list, from)
-          RelLeftMatchContext.new(match_start, from_var).set_rel(rel)
-        end
-
         def -(to)
           @match_start.match_list.delete(self) # since it is complete now
           RelRightMatchContext.new(@match_start, self, @rel_var, to, :both)
@@ -308,32 +302,41 @@ module Neo4j
         end
 
         def to_cypher_no_join
-          "(#{@from.var_name})#{DIR_OPERATORS[@dir]}(#{@to.var_name})"
+          x = @to.match_value
+          "(#{@from.match_value})#{DIR_OPERATORS[@dir]}(#{x})"
         end
 
         def to_cypher_join
-          "#{DIR_OPERATORS[@dir]}(#{@to.var_name})"
+          "#{DIR_OPERATORS[@dir]}(#{@to.match_value})"
         end
       end
 
       class Entities
         include Clause
+        attr_reader :input
 
         def initialize(clause_list, iterable, input)
           super(clause_list, :entities, EvalContext)
-          eval_context.iterable = iterable
-          eval_context.input = input.clause
+          @iterable = iterable
+          @input = input.clause
+        end
+
+        def referenced!
+          @input.referenced!
+        end
+
+        def return_value
+          "#{@iterable}(#{@input.var_name})"
         end
 
         class EvalContext
           include Context
           include PredicateMethods
-          attr_accessor :input, :iterable
-          #
-          #def each(&cypher_dsl)
-          #  Predicate.new(clause_list, :clause => clause, :input => input, :predicate_block => cypher_dsl)
-          #  #RootClause::EvalContext.new(self).instance_exec(*arg_exec, &cypher_dsl)
-          #end
+          include Returnable
+
+          include Variable
+          include Matchable
+          include Aggregate
         end
       end
 

data/lib/neo4j-cypher/neography.rb

@@ -0,0 +1,22 @@
+module Neography
+
+  # Monkey patch so it works better with neo4-cypher gem and becomes more similar to neo4j-core
+  class Relationship
+    def _java_rel
+      self
+    end
+  end
+
+  class Node
+    def _java_node
+      self
+    end
+  end
+
+  class Rest
+    def execute_cypher(params, &dsl)
+      q = Neo4j::Cypher.query(params, &dsl).to_s
+      execute_query(q)
+    end
+  end
+end

data/lib/neo4j-cypher/node_var.rb

@@ -4,7 +4,6 @@ module Neo4j
     # 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)

data/lib/neo4j-cypher/operator.rb

@@ -35,7 +35,6 @@ module Neo4j
     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)
@@ -48,19 +47,14 @@ module Neo4j
         @valid = true
 
         # since we handle it ourself in to_cypher method unless it needs to be declared (as a cypher start node/relationship)
-        clause_list.delete(left_operand) unless declare_operand?(left_operand)
-        clause_list.delete(right_operand) unless declare_operand?(right_operand)
-
+        clause_list.delete(left_operand) if remove_operand?(left_operand)
+        clause_list.delete(right_operand) if remove_operand?(right_operand)
         @neg = nil
       end
 
-      def declare_operand?(operand)
+      def remove_operand?(operand)
         clause = operand.respond_to?(:clause) ? operand.clause : operand
-        clause.kind_of?(Clause) && clause.clause_type == :start
-      end
-
-      def separator
-        " and "
+        clause.kind_of?(Clause) && clause.clause_type == :where
       end
 
       def match_value

data/lib/neo4j-cypher/predicate.rb

@@ -1,62 +1,11 @@
 module Neo4j
   module Cypher
-    class Predicate
-      include Clause
-      include Referenceable
-      attr_accessor :params
+    class Predicate < AbstractFilter
 
-      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
+      def initialize(clause_list, method_name, input_context, &block)
+        super(clause_list, :where, input_context)
+        # Input can either be a property array or a node/relationship collection
+        filter_initialize(input_context, method_name, " WHERE ", &block)
       end
     end
 

data/lib/neo4j-cypher/property.rb

@@ -10,15 +10,17 @@ module Neo4j
     #  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
 
+      attr_accessor :prop_name
+
       def initialize(var, prop_name = nil)
         super(var.clause_list, :property, EvalContext)
         @var = var
         @prop_name = prop_name
       end
 
+      # TODO check why needed
       def var_name
         @var.var_name
       end
@@ -65,6 +67,7 @@ module Neo4j
         include MathFunctions
         include PredicateMethods
         include Aggregate
+        include Returnable
 
         def asc
           ReturnItem.new(clause_list, self).eval_context.asc
@@ -88,17 +91,6 @@ module Neo4j
           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(',')}]")

data/lib/neo4j-cypher/rel_var.rb

@@ -3,49 +3,43 @@ module Neo4j
 
     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
+        self.var_name = guess_var_name_from_string(expr.first) if expr.first.is_a?(String)
 
-        @match_value = "#@match_value #{to_prop_string(props)}" if props
+        if props
+          @match_value = "#{match_value_from_args(expr)} #{to_prop_string(props)}"
+        else
+          @match_value = match_value_from_args(expr)
+        end
       end
 
-      def rel_type
-        @match_value.include?(':') ? @match_value.split(':').last : @match_value.sub('?', '')
+      def match_value_from_args(expr)
+        if expr.first.is_a?(String)
+          expr.first
+        elsif expr.first.is_a?(Symbol)
+          ":#{expr.map { |e| match_value_from_symbol(e) }.join('|')}"
+        elsif expr.empty?
+          '?'
+        else
+          # try to join several RelVars to one rel var
+          ":#{expr.map { |e| e.clause.rel_type }.join('|')}"
+        end
       end
 
-      def self.join(clause_list, rel_types)
-        rel_string = rel_types.map { |r| _rel_to_string(clause_list, r) }.join('|')
+      def guess_var_name_from_string(expr)
+        guess = /([[:alpha:]_]*)/.match(expr)[1]
+        guess && !guess.empty? && guess
+      end
 
-        if rel_string.empty?
-          RelVar.new(clause_list, "")
-        else
-          RelVar.new(clause_list, ":#{rel_string}")
-        end
+      def match_value_from_symbol(expr)
+        "`#{expr}`"
       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
+      def rel_type
+        @match_value.include?(':') ? @match_value.split(':').last : @match_value.sub('?', '')
       end
 
       def referenced!

data/lib/neo4j-cypher/return.rb

@@ -84,7 +84,6 @@ module Neo4j
     # The return statement in the cypher query
     class ReturnItem
       include Clause
-      include Referenceable
       attr_accessor :order_by
 
       def initialize(clause_list, name_or_ref)

data/lib/neo4j-cypher/root.rb

@@ -33,7 +33,7 @@ module Neo4j
       end
 
       def return_names
-        ret = clause_list.clause_list.find{|r| r.respond_to?(:return_items)}
+        ret = clause_list.return_clause
         ret ? ret.return_items.map { |ri| (ri.alias_name || ri.return_value).to_sym } : []
       end
 
@@ -46,12 +46,10 @@ module Neo4j
         # @return self
         def match(*, &match_dsl)
           instance_eval(&match_dsl) if match_dsl
-          self
         end
 
         def match_not(&match_dsl)
           instance_eval(&match_dsl).not
-          self
         end
 
         # Does nothing, just for making the DSL easier to read (maybe)
@@ -60,29 +58,55 @@ module Neo4j
           self
         end
 
-        def where(w=nil)
-          Where.new(clause_list, w) if w.is_a?(String)
+        def where(w=nil, &block)
+          Where.new(clause_list, self, w, &block)
+          self
+        end
+
+        def where_not(w=nil, &block)
+          Where.new(clause_list, self, w, &block).neg!
           self
         end
 
         # Specifies a start node by performing a lucene query.
-        # @param [Class] index_class a class responsible for an index
+        # @param [Class, String] index_class a class responsible for an index or the string value of the index
         # @param [String] q the lucene query
         # @param [Symbol] index_type the type of index
-        # @return [NodeQuery]
+        # @return [LuceneQuery]
         def query(index_class, q, index_type = :exact)
-          NodeQuery.new(clause_list, index_class, q, index_type).eval_context
+          LuceneQuery.query_node_by_class(clause_list, index_class, q, index_type).eval_context
+        end
+
+        # Specifies a start relationship by performing a lucene query.
+        # @param [Class, String] index_class a class responsible for an index or the string value of the index
+        # @param [String] q the lucene query
+        # @param [Symbol] index_type the type of index
+        # @return [LuceneQuery]
+        def query_rel(index_class, q, index_type = :exact)
+          LuceneQuery.query_rel_by_class(clause_list, index_class, q, index_type).eval_context
         end
 
+
         # Specifies a start node by performing a lucene query.
-        # @param [Class] index_class a class responsible for an index
+        # @param [Class, String] index_class a class responsible for an index or the string value of the index
         # @param [String, Symbol] key the key we ask for
         # @param [String, Symbol] value the value of the key we ask for
-        # @return [NodeLookup]
+        # @return [LuceneQuery]
         def lookup(index_class, key, value)
-          NodeLookup.new(clause_list, index_class, key, value).eval_context
+          LuceneQuery.lookup_node_by_class(clause_list, index_class, key, value).eval_context
         end
 
+
+        # Specifies a start relationship by performing a lucene query.
+        # @param [Class, String] index_class a class responsible for an index or the string value of the index
+        # @param [String, Symbol] key the key we ask for
+        # @param [String, Symbol] value the value of the key we ask for
+        # @return [LuceneQuery]
+        def lookup_rel(index_class, key, value)
+          LuceneQuery.lookup_rel_by_class(clause_list, index_class, key, value).eval_context
+        end
+
+
         # Creates a node variable.
         # It will create different variables depending on the type of the first element in the nodes argument.
         # * Fixnum - it will be be used as neo_id  for start node(s) (StartNode)
@@ -106,14 +130,9 @@ module Neo4j
         def rel(*rels)
           if rels.first.is_a?(Fixnum) || rels.first.respond_to?(:neo_id)
             StartRel.new(clause_list, rels).eval_context
-          elsif rels.first.is_a?(Symbol)
-            RelVar.new(clause_list, ":`#{rels.first}`", rels[1]).eval_context
-          elsif rels.first.is_a?(String)
-            RelVar.new(clause_list, rels.first, rels[1]).eval_context
-          elsif rels.empty?
-            RelVar.new(clause_list, '?').eval_context
           else
-            raise "Unknown arg #{rels.inspect}"
+            props = rels.pop if rels.last.is_a?(Hash)
+            RelVar.new(clause_list, rels, props).eval_context
           end
         end
 
@@ -145,13 +164,16 @@ module Neo4j
         end
 
         def nodes(*args)
-          s = args.map { |x| x.clause.referenced!; x.clause.var_name }.join(", ")
-          ReturnItem.new(clause_list, "nodes(#{s})").eval_context
+          _entities(args, 'nodes')
         end
 
         def rels(*args)
-          s = args.map { |x| x.clause.referenced!; x.clause.var_name }.join(", ")
-          ReturnItem.new(clause_list, "relationships(#{s})").eval_context
+          _entities(args, 'relationships')
+        end
+
+        def _entities(arg_list, entity_type)
+          s = arg_list.map { |x| x.clause.referenced!; x.clause.var_name }.join(", ")
+          ReturnItem.new(clause_list, "#{entity_type}(#{s})").eval_context
         end
 
         def create_path(*args, &block)