neo4j-cypher 1.0.0.rc1

data/lib/neo4j-cypher/result.rb

@@ -0,0 +1,43 @@
+module Neo4j
+  module Cypher
+
+    # Generates a Cypher string from a Ruby DSL
+    # The result returned by #to_s and the last Cypher return columns can be found #return_names.
+    # The cypher query will only be generated once - in the constructor.
+    class Result
+
+      def initialize(*args, &dsl_block)
+        @root = Neo4j::Cypher::RootClause.new
+        eval_context = @root.eval_context
+        to_dsl_args = args.map do |a|
+          case
+            when a.is_a?(Array) && a.first.respond_to?(:_java_node)
+              eval_context.node(*a)
+            when a.is_a?(Array) && a.first.respond_to?(:_java_rel)
+              eval_context.rel(*a)
+            when a.respond_to?(:_java_node)
+              eval_context.node(a)
+            when a.respond_to?(:_java_rel)
+              eval_context.rel(a)
+            else
+              raise "Illegal argument #{a.class}"
+          end
+
+        end
+        @root.execute(to_dsl_args, &dsl_block)
+        @result = @root.return_value
+      end
+
+      def return_names
+        @root.return_names
+      end
+
+      # Converts the DSL query to a cypher String which can be executed by cypher query engine.
+      def to_s
+        @result
+      end
+
+    end
+
+  end
+end

data/lib/neo4j-cypher/result_wrapper.rb

@@ -0,0 +1,47 @@
+module Neo4j
+  module Cypher
+    # Wraps the Cypher query result.
+    # Loads the node and relationships wrapper if possible and use symbol as column keys.
+    # This is typically used in the native neo4j bindings since result does is not a Ruby enumerable with symbols as keys.
+    # @notice The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
+    #
+    # @example
+    #   result = Neo4j.query(@a, @b){|a,b| node(a,b).as(:n)}
+    #   r = @query_result.to_a # can only loop once
+    #   r.size.should == 2
+    #   r.first.should include(:n)
+    #   r[0][:n].neo_id.should == @a.neo_id
+    #   r[1][:n].neo_id.should == @b.neo_id
+    class ResultWrapper
+      include Enumerable
+
+      # @return the original result from the Neo4j Cypher Engine, once forward read only !
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      # @return [Array<Symbol>] the columns in the query result
+      def columns
+        @source.columns.map { |x| x.to_sym }
+      end
+
+      # for the Enumerable contract
+      def each
+        @source.each { |row| yield map(row) }
+      end
+
+      # Maps each row so that we can use symbols for column names.
+      # @private
+      def map(row)
+        out = {} # move to a real hash!
+        row.each do |key, value|
+          out[key.to_sym] = value.respond_to?(:wrapper) ? value.wrapper : value
+        end
+        out
+      end
+
+    end
+  end
+end

data/lib/neo4j-cypher/return.rb

@@ -0,0 +1,124 @@
+module Neo4j
+  module Cypher
+
+
+    # Can be used to skip result from a return clause
+    class Skip
+      include Clause
+
+      def initialize(clause_list, value, context)
+        super(clause_list, :skip, context)
+        @value = value
+      end
+
+      def to_cypher
+        @value
+      end
+    end
+
+    # Can be used to limit result from a return clause
+    class Limit
+      include Clause
+
+      def initialize(clause_list, value, context)
+        super(clause_list, :limit, context)
+        @value = value
+      end
+
+      def to_cypher
+        @value
+      end
+    end
+
+    class OrderBy
+      include Clause
+
+      def initialize(clause_list, context)
+        super(clause_list, :order_by, context)
+        @orders = []
+      end
+
+      def asc(props)
+        @orders << [:asc, props.map(&:clause)]
+      end
+
+      def desc(props)
+        @orders << [:desc, props.map(&:clause)]
+      end
+
+      def to_cypher
+        @orders.map do |pair|
+          if pair[0] == :asc
+            pair[1].map(&:return_value).join(', ')
+          else
+            pair[1].map(&:return_value).join(', ') + " DESC"
+          end
+        end.join(', ')
+      end
+    end
+
+    # Used for returning several values, e.g. RETURN x,y,z
+    class Return
+      include Clause
+
+      attr_reader :return_items
+
+      def initialize(clause_list, return_items, opts = {})
+        super(clause_list, :return, EvalContext)
+        @return_items = return_items.map { |ri| ri.is_a?(ReturnItem::EvalContext) ? ri.clause : ReturnItem.new(clause_list, ri) }
+        opts.each_pair { |k, v| self.eval_context.send(k, v) }
+      end
+
+      def to_cypher
+        @return_items.map(&:return_value_with_alias).join(',')
+      end
+
+
+      class EvalContext
+        include Context
+        include ReturnOrder
+      end
+
+    end
+
+    # The return statement in the cypher query
+    class ReturnItem
+      include Clause
+      include Referenceable
+
+      def initialize(clause_list, name_or_ref)
+        super(clause_list, :return_item, EvalContext)
+        if name_or_ref.respond_to?(:clause)
+          @delegated_clause = name_or_ref.clause
+          @delegated_clause.referenced!
+          as_alias(@delegated_clause.var_name) if @delegated_clause.as_alias?
+        else
+          @return_value = name_or_ref.to_s
+        end
+      end
+
+      def var_name
+        @var_name || (@delegated_clause && @delegated_clause.var_name) || @return_value.to_sym
+      end
+
+      def return_value_with_alias
+        as_alias? ? "#{return_value} as #{var_name}" : return_value
+      end
+
+      def return_value
+        @delegated_clause ? @delegated_clause.return_value : @return_value
+      end
+
+      class EvalContext
+        include Context
+        include Alias
+        include ReturnOrder
+        include Aggregate
+        include Comparable
+      end
+
+
+    end
+  end
+
+end

data/lib/neo4j-cypher/root.rb

@@ -0,0 +1,182 @@
+module Neo4j
+  module Cypher
+    class RootClause
+      include Clause
+
+      def initialize
+        super(ClauseList.new, :root, EvalContext)
+      end
+
+      def execute(args, &cypher_dsl)
+        result = eval_context.instance_exec(*args, &cypher_dsl)
+
+        if ![Array, Symbol].include?(result.class)
+          return if clause_list.include?(:return)
+          return if clause_list.include?(:with)
+          return if clause_list.include?(:delete)
+        end
+        create_returns(result)
+      end
+
+      def create_returns(last_result)
+        if last_result.is_a?(Array)
+          eval_context.ret(*last_result)
+        elsif last_result.nil?
+          eval_context.ret(clause_list.last.eval_context) unless clause_list.empty?
+        else
+          eval_context.ret(last_result)
+        end
+      end
+
+      def return_value
+        clause_list.to_cypher
+      end
+
+      def return_names
+        ret = clause_list.last
+        ret.respond_to?(:return_items) ? ret.return_items.map { |ri| ri.var_name.to_sym } : []
+      end
+
+      class EvalContext
+        include Context
+        include MathFunctions
+        include Returnable
+
+        # Does nothing, just for making the DSL easier to read (maybe).
+        # @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)
+        # @return self
+        def start(*)
+          self
+        end
+
+        def where(w=nil)
+          Where.new(clause_list, w) if w.is_a?(String)
+          self
+        end
+
+        # Specifies a start node by performing a lucene query.
+        # @param [Class] index_class a class responsible for an index
+        # @param [String] q the lucene query
+        # @param [Symbol] index_type the type of index
+        # @return [NodeQuery]
+        def query(index_class, q, index_type = :exact)
+          NodeQuery.new(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 [String, Symbol] key the key we ask for
+        # @param [String, Symbol] value the value of the key we ask for
+        # @return [NodeLookup]
+        def lookup(index_class, key, value)
+          NodeLookup.new(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)
+        # * Symbol - it will create an unbound node variable with the same name as the symbol (NodeVar#as)
+        # * empty array - it will create an unbound node variable (NodeVar)
+        #
+        # @param [Fixnum,Symbol,String] nodes the id of the nodes we want to start from
+        # @return [StartNode, NodeVar]
+        def node(*nodes)
+          if nodes.first.is_a?(Symbol)
+            NodeVar.new(clause_list).eval_context.as(nodes.first)
+          elsif !nodes.empty?
+            StartNode.new(clause_list, nodes).eval_context
+          else
+            NodeVar.new(clause_list).eval_context
+          end
+        end
+
+        # Similar to #node
+        # @return [StartRel, RelVar]
+        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}"
+          end
+        end
+
+        def rel?(*rels)
+          rel(*rels).clause.optionally!.eval_context
+        end
+
+
+        def shortest_path(&block)
+          match = instance_eval(&block)
+          match.shortest_path
+        end
+
+        def shortest_paths(&block)
+          match = instance_eval(&block)
+          match.shortest_paths
+        end
+
+        # @param [Symbol,nil] variable the entity we want to count or wildcard (*)
+        # @return [ReturnItem] a counter return clause
+        def count(variable='*')
+          operand = variable.respond_to?(:clause) ? variable.clause.var_name : variable
+          ReturnItem.new(clause_list, "count(#{operand})").eval_context
+        end
+
+        def coalesce(*args)
+          s = args.map { |x| x.clause.return_value }.join(", ")
+          ReturnItem.new(clause_list, "coalesce(#{s})").eval_context
+        end
+
+        def nodes(*args)
+          s = args.map { |x| x.clause.referenced!; x.clause.var_name }.join(", ")
+          ReturnItem.new(clause_list, "nodes(#{s})").eval_context
+        end
+
+        def rels(*args)
+          s = args.map { |x| x.clause.referenced!; x.clause.var_name }.join(", ")
+          ReturnItem.new(clause_list, "relationships(#{s})").eval_context
+        end
+
+        def create_path(*args, &block)
+          CreatePath.new(clause_list, *args, &block).eval_context
+        end
+
+        def create_unique_path(*args, &block)
+          CreatePath.new(clause_list, *args, &block).unique!.eval_context
+        end
+
+        def with(*args, &block)
+          With.new(clause_list, :where, *args, &block).eval_context
+        end
+
+        def with_match(*args, &block)
+          With.new(clause_list, :match, *args, &block).eval_context
+        end
+
+        def distinct(node_or_name)
+          operand = node_or_name.respond_to?(:clause) ? node_or_name.clause.var_name : node_or_name
+          ReturnItem.new(clause_list, "distinct(#{operand})").eval_context
+        end
+
+      end
+    end
+
+  end
+end

data/lib/neo4j-cypher/start.rb

@@ -0,0 +1,88 @@
+module Neo4j
+  module Cypher
+    class Start
+      include Clause
+      include Referenceable
+
+      attr_accessor :entities # TODO CHECK  if needed
+
+      def initialize(clause_list)
+        super(clause_list, :start, EvalContext)
+      end
+
+      def initialize_entities(entities)
+        @entities = entities.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
+      end
+
+      class EvalContext
+        include Context
+        include Variable
+        include Matchable
+        include Returnable
+        include Sortable
+        include Aggregate
+        include Alias
+      end
+
+    end
+
+    # Can be created from a <tt>node</tt> dsl method.
+    class StartNode < Start
+
+      def initialize(clause_list, nodes)
+        super(clause_list)
+        initialize_entities(nodes)
+      end
+
+      def to_cypher
+        "#{var_name}=node(#{entities.join(',')})"
+      end
+
+    end
+
+
+    # Can be created from a <tt>rel</tt> dsl method.
+    class StartRel < Start
+      def initialize(clause_list, rels)
+        super(clause_list)
+        initialize_entities(rels)
+      end
+
+      def to_cypher
+        "#{var_name}=relationship(#{entities.join(',')})"
+      end
+    end
+
+    class NodeQuery < Start
+      attr_reader :index_name, :query
+
+      def initialize(clause_list, index_class, query, index_type)
+        super(clause_list)
+        @index_name = index_class.index_name_for_type(index_type)
+        @query = query
+      end
+
+      def to_cypher
+        "#{var_name}=node:#{index_name}(#{query})"
+      end
+    end
+
+    class NodeLookup < Start
+      attr_reader :index_name, :query
+
+      def initialize(clause_list, index_class, key, value)
+        super(clause_list)
+        index_type = index_class.index_type(key.to_s)
+        raise "No index on #{index_class} property #{key}" unless index_type
+        @index_name = index_class.index_name_for_type(index_type)
+        @query = %Q[#{key}="#{value}"]
+      end
+
+      def to_cypher
+        %Q[#{var_name}=node:#{index_name}(#{query})]
+      end
+
+    end
+
+  end
+end