neo4j-cypher 1.0.0.rc2 → 1.0.0

data/Gemfile

@@ -5,6 +5,10 @@ gemspec
 group 'development' do
   gem 'pry'
   gem 'simplecov'
+  # gem "term-ansicolor"
+  gem 'flog'
+  gem 'flay'
+  gem 'reek'
 end
 
 group 'test' do

data/README.rdoc

@@ -1,98 +1,49 @@
-== neo4j-cypher {<img src="https://secure.travis-ci.org/andreasronge/neo4j-cypher.png" />}[http://travis-ci.org/andreasronge/neo4j-cypher]
+= neo4j-cypher {<img src="https://secure.travis-ci.org/andreasronge/neo4j-cypher.png" />}[http://travis-ci.org/andreasronge/neo4j-cypher] {<img src="https://codeclimate.com/badge.png"/>}[https://codeclimate.com/github/andreasronge/neo4j-cypher]
 
 A Ruby DSL for the Neo4j Cypher query language for both MRI and JRuby.
 The JRuby neo4j-core gem's cypher dsl has been moved to this gem.
 
-=== Docs
+== Docs
 
-See {Neo4j Wiki Cypher}[https://github.com/andreasronge/neo4j/wiki/Neo4j::Core-Cypher]
+* {Neo4j Wiki Cypher}[https://github.com/andreasronge/neo4j/wiki/Neo4j%3A%3ACypher]
+* {Neo4j Cypher Docs}[http://docs.neo4j.org/chunked/stable/]
+* RSpecs (100% test coverage)
 
-See the rspecs ! (> 99% test coverage)
+== Why ?
 
+Why should I write my queries using the neo4j-cypher DSL instead of using original cypher syntax ?
 
-=== Random Examples
+Let's look at a simple example using the cypher query language without the DSL.
+For example: Find my friends I got 1994
 
-Notice the last value returned is the return value (if possible).
-Matching relationships can be done with operators: <,>, -, and <=> or with the both, incoming and outgoing methods.
+  START me=node(1) 
+  MATCH (me)-[friend_rel:`friends`]->(friends) 
+  WHERE (friend_rel.since = 1994) 
+  RETURN friends
 
-"START v1=node(3) MATCH v2 = (v1)-[:`r`]->(x) RETURN v2"
+Instead of relying on a strict order of the clauses (+START+, +MATCH+, +WHERE+ ...)
+and having to use variables (me and friends) you can write the same query using the DSL like this:
 
-  Neo4j::Cypher.query do
-    node(3) > :r > :x
-  end
+  node(1).outgoing(rel(:friends).where{|r| r[:since] == 1994})
 
+This is more or less plain english (for me), navigate from node(1) outgoing relationships friends where friends since property is equal 1994.
+Remember just like ruby, the last value evaluated is the return value which means it will return your friend.
 
-"START v2=node(1) MATCH (v2)-[v1:`knows`]->(other) WHERE v1.since > 1994 and other.name = "foo" RETURN other"
+Another example: Return the age property of all the nodes between node 1 and node 3. 
 
-  Neo4j::Cypher.query do
-    node(1) > (rel(:knows)[:since] > 1994) > (node(:other)[:name] == 'foo'); :other
-  end
+  (node(1) >> node >> node(3)).nodes.extract(&:age)
 
+Notice the cypher extract function works like the standard ruby map method.
+The query above will generate the following cypher string:
 
-"START v2=node(1) MATCH (v2)-[v1:`friends`]->(v3) WHERE (v1.since = 1994) RETURN v3"
+  START v2=node(3),v3=node(1) 
+  MATCH v1 = (v2)-->(v4)-->(v3) 
+  RETURN extract(x in nodes(v1) : x.age)
 
-  Neo4j::Cypher.query do
-    node(1).outgoing(rel(:friends).where{|r| r[:since] == 1994})
-  end
-
-
-"START v1=node(2,3,4,1) RETURN count(v1.property?"
-
-  Neo4j::Cypher.query do
-    node(2, 3, 4, 1)[:property?].count
-  end
-
-"START v1=node(42) MATCH (v1)-[:`favorite`]->(stuff)<-[:`favorite`]-(person) WHERE not((v1)-[:`friend`]-(person)) RETURN person.name,count(stuff) ORDER BY count(stuff) DESC"
-
-  Neo4j::Cypher.query do
-    node(42).where_not { |m| m - :friend - :person } > :favorite > :stuff < :favorite < :person
-    ret(node(:person)[:name], count(:stuff).desc)
-  end
-
-
-== Complex Example
-
-"START n=node(42) MATCH (n)-[r]->(m) WITH n,collect(type(r)) as out_types,collect(m) as outgoing MATCH (n)<-[r]-(m) RETURN n,outgoing,out_types,collect(m) as incoming,collect(type(r)) as in_types"
-
-  Neo4j::Cypher.query do
-    n = node(42).as(:n)
-    r = rel('r')
-    m = node(:m)
-    rel_types = r.rel_type.collect
-    end_nodes = m.collect
-
-    n.with_match(rel_types.as(:out_types), end_nodes.as(:outgoing)) { |n, _, _| n < r < m } > r > m
-
-    ret([n,
-         :outgoing,
-         :out_types,
-         end_nodes.as(:incoming),
-         rel_types.as(:in_types)])
- end
-
-
-=== Co-Tagged Places - Places Related through Tags
-
-Find places that are tagged with the same tags: Determine the tags for place x. What else is tagged the same as x that is not x."
-
-"START place=node:node_auto_index(name = "CoffeeShop1") MATCH place-[:tagged]->tag<-[:tagged]-otherPlace RETURN otherPlace.name, collect(tag.name) ORDER By otherPlace.name desc"
-
-Can be written like this:
-
-  Neo4j::Cypher.query do
-    other_place = node(:otherPlace)
-    place = lookup('node_auto_index', 'name', 'CoffeeShop1').as(:place)
-    place > rel(':tagged') > node(:tag) < rel(':tagged') < other_place
-    ret other_place[:name].desc, node(:tag)[:name].collect
-  end
-
-
-Or in one line:
-
-  Neo4j::Cypher.query do
-    lookup('node_auto_index', 'name', 'CoffeeShop1') > rel(':tagged') > node(:tag).ret { |t| t[:name].collect } < rel(':tagged') < node(:otherPlace).ret { |n| n[:name].desc }
-  end
+So, the answer why you should use it is simply that it might improve the readability of the code for (ruby) programmers and
+make it more fun to write queries.
 
+Please read the {Neo4j Cypher Docs}[http://docs.neo4j.org/chunked/stable/] for more examples.
 
 == License
 

data/lib/neo4j-cypher.rb

@@ -1,9 +1,11 @@
 require 'neo4j-cypher/version'
 
 require 'neo4j-cypher/context'
-require 'neo4j-cypher/mixins'
 require 'neo4j-cypher/clause'
 require 'neo4j-cypher/clause_list'
+require 'neo4j-cypher/abstract_filter'
+require 'neo4j-cypher/collection'
+require 'neo4j-cypher/foreach'
 require 'neo4j-cypher/argument'
 require 'neo4j-cypher/root'
 require 'neo4j-cypher/start'

data/lib/neo4j-cypher/abstract_filter.rb

@@ -0,0 +1,78 @@
+module Neo4j
+  module Cypher
+    class AbstractFilter
+      include Clause
+
+      def filter_initialize(input_context, method_name, selector_token, &block)
+        input = input_context.clause
+        fe = filter_expr(input, selector_token, &block)
+        @cypher = "#{method_name}#{fe}"
+      end
+
+      def return_value
+        @cypher
+      end
+
+      def to_cypher
+        @cypher
+      end
+
+      def filter_arg(input)
+        var = NodeVar.as_var(clause_list, 'x')
+
+        if input.is_a?(Neo4j::Cypher::Property)
+          filter_input = Property.new(var)
+          filter_input.expr = 'x'
+          filter_input.eval_context
+        else
+          input.referenced!
+          var.eval_context
+        end
+      end
+
+      def filter_value(input)
+        input.is_a?(Neo4j::Cypher::Property) ? input.expr : input.return_value
+      end
+
+      # Used for the Ruby &: method shortcut
+      class FilterProp
+        def initialize(obj)
+          @obj = obj
+        end
+
+        def method_missing(m)
+          @obj[m.to_sym]
+        end
+      end
+
+      def filter_exec(arg, &block)
+        clause_list.push
+        begin
+          ret = RootClause::EvalContext.new(self).instance_exec(arg, &block)
+        rescue NoMethodError
+          if arg.kind_of?(Neo4j::Cypher::Context::Variable)
+          # Try again, maybe we are using the Ruby &: method shortcut
+            ret = FilterProp.new(arg).instance_eval(&block)
+          else
+            raise
+          end
+        end
+
+        filter = clause_list.empty? ? ret.clause.to_cypher : clause_list.to_cypher
+        clause_list.pop
+        filter
+      end
+
+      def filter_expr(input, selector_token, &block)
+        expr = "(x in #{filter_value(input)}"
+        arg = filter_arg(input)
+        filter = filter_exec(arg, &block)
+        expr << "#{selector_token}#{filter})"
+        # WHERE all(x in nodes(v1) WHERE x.age > 30)
+        expr
+      end
+
+    end
+  end
+
+end

data/lib/neo4j-cypher/argument.rb

@@ -2,7 +2,6 @@ module Neo4j
   module Cypher
 
     class Argument
-      include Referenceable
       include Clause
 
       def initialize(clause_list, expr, var_name)

data/lib/neo4j-cypher/clause.rb

@@ -38,7 +38,7 @@ module Neo4j
       end
 
       def separator
-        ','
+        clause_type == :where ? ' and ' : ','
       end
 
       def match_value=(mv)
@@ -58,6 +58,44 @@ module Neo4j
         NAME[clause_type]
       end
 
+      def var_name
+        @var_name ||= @clause_list.create_variable(self)
+      end
+
+      def var_name=(new_name)
+        @var_name = new_name.to_sym if new_name
+      end
+
+      def referenced?
+        !!@referenced
+      end
+
+      def referenced!
+        @referenced = true
+      end
+
+      def as_alias(new_name)
+        @alias = new_name
+        self.var_name = new_name
+      end
+
+      def alias_name
+        @alias
+      end
+
+      def as_alias?
+        !!@alias && var_name != return_value
+      end
+
+      def to_prop_string(props)
+        key_values = props.keys.map do |key|
+          raw = key.to_s[0, 1] == '_'
+          val = props[key].is_a?(String) && !raw ? "'#{props[key]}'" : props[key]
+          "#{raw ? key.to_s[1..-1] : key} : #{val}"
+        end
+        "{#{key_values.join(', ')}}"
+      end
+
       def create_clause_args_for(args)
         args.map do |arg|
           case arg

data/lib/neo4j-cypher/clause_list.rb

@@ -7,7 +7,8 @@ module Neo4j
 
       def initialize(variables = [])
         @variables = variables
-        @clause_list = []
+        @lists_of_clause_list = [[]]
+        @curr_clause_list = @lists_of_clause_list.first
         @insert_order = 0
       end
 
@@ -20,34 +21,41 @@ module Neo4j
       end
 
       def find(clause_type)
-        @clause_list.find { |c| c.clause_type == clause_type }
+        @curr_clause_list.find { |c| c.clause_type == clause_type }
       end
 
       def each
-        @clause_list.each { |c| yield c }
+        @curr_clause_list.each { |c| yield c }
       end
 
       def push
-        raise "Only support stack of depth 2" if @old_clause_list
-        @old_clause_list = @clause_list
-        @clause_list = []
+        @lists_of_clause_list << []
+        @curr_clause_list = @lists_of_clause_list.last
         self
       end
 
       def pop
-        @clause_list = @old_clause_list
-        @clause_list.sort!
-        @old_clause_list = nil
+        @lists_of_clause_list.pop
+        @curr_clause_list = @lists_of_clause_list.last
+        @curr_clause_list.sort!
         self
       end
 
+      def return_clause
+        @curr_clause_list.find{|r| r.respond_to?(:return_items)}
+      end
+
+      def depth
+        @lists_of_clause_list.count
+      end
+
       def insert(clause)
         ctype = clause.clause_type
 
         if Clause::ORDER.include?(ctype)
           # which list should we add the cluase to, the root or the sub list ?
           # ALl the start and return clauses should move to the clause_list
-          c = (@old_clause_list && (ctype == :start || ctype == :return)) ? @old_clause_list : @clause_list
+          c = (depth > 1 && (ctype == :start || ctype == :return)) ? @lists_of_clause_list.first : @curr_clause_list
           c << clause
           @insert_order += 1
           clause.insert_order = @insert_order
@@ -57,17 +65,16 @@ module Neo4j
       end
 
       def last
-        @clause_list.last
+        @curr_clause_list.last
       end
 
       def delete(clause_or_context)
         c = clause_or_context.respond_to?(:clause) ? clause_or_context.clause : clause_or_context
-        @clause_list.delete(c)
+        @curr_clause_list.delete(c)
       end
 
       #def debug
-      #  puts "ClauseList id: #{object_id}, vars: #{variables.size}"
-      #  @clause_list.each_with_index { |c, i| puts "  #{i} #{c.clause_type.inspect}, #{c.class} id: #{c.object_id} order #{c.insert_order}" }
+      #  @curr_clause_list.each_with_index { |c, i| puts "  #{i} #{c.clause_type.inspect}, #{c.to_cypher} - #{c.class} id: #{c.object_id} order #{c.insert_order}" }
       #end
 
       def create_variable(var)
@@ -96,9 +103,17 @@ module Neo4j
       end
 
       def prefix(list)
-        @old_clause_list && ![:set, :delete, :create].include?(list.first.clause_type) ? '' : "#{list.first.prefix} "
+        (depth > 1) && !prefix_for_depth_2.include?(list.first.clause_type) ? '' : "#{list.first.prefix} "
       end
 
+      def prefix_for_depth_2
+        if include?(:match) && include?(:where)
+          [:set, :delete, :create, :where]
+        else
+          [:set, :delete, :create]
+        end
+
+      end
     end
   end
 

data/lib/neo4j-cypher/collection.rb

@@ -0,0 +1,14 @@
+module Neo4j
+  module Cypher
+
+    class Collection < AbstractFilter
+
+      def initialize(clause_list, method_name, input_context, &block)
+        super(clause_list, :return_item)
+        clause_list.delete(input_context)
+        filter_initialize(input_context, method_name, " : ", &block)
+      end
+
+    end
+  end
+end

data/lib/neo4j-cypher/context.rb

@@ -99,33 +99,19 @@ module Neo4j
 
       module PredicateMethods
         def all?(&block)
-          self.respond_to?(:iterable)
-          Predicate.new(clause_list, :op => 'all', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block).eval_context
-        end
-
-        def extract(&block)
-          Predicate.new(clause_list, :op => 'extract', :clause => :return_item, :input => input, :iterable => iterable, :predicate_block => block).eval_context
-        end
-
-        def filter(&block)
-          Predicate.new(clause_list, :op => 'filter', :clause => :return_item, :input => input, :iterable => iterable, :predicate_block => block).eval_context
+          Predicate.new(clause_list, 'all', self, &block).eval_context
         end
 
         def any?(&block)
-          Predicate.new(clause_list, :op => 'any', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block).eval_context
+          Predicate.new(clause_list, 'any', self, &block).eval_context
         end
 
         def none?(&block)
-          Predicate.new(clause_list, :op => 'none', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block).eval_context
+          Predicate.new(clause_list, 'none', self, &block).eval_context
         end
 
         def single?(&block)
-          Predicate.new(clause_list, :op => 'single', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block).eval_context
-        end
-
-        def foreach(&block)
-          Predicate.new(clause_list, :op => '', :clause => :foreach, :input => input, :iterable => iterable, :predicate_block => block, :separator => ' FOREACH ').eval_context
-          input.eval_context
+          Predicate.new(clause_list, 'single', self, &block).eval_context
         end
       end
 
@@ -143,15 +129,31 @@ module Neo4j
           (self.is_a?(RootClause::EvalContext)) ? r : self
         end
 
+        # To return a single property, or the value of a function from a collection of nodes or relationships, you can use EXTRACT.
+        # It will go through a collection, run an expression on every element, and return the results in an collection with these values.
+        # It works like the map method in functional languages such as Lisp and Scala.
+        # Will generate:
+        #   EXTRACT( identifier in collection : expression )
+        def extract(&block)
+          Collection.new(clause_list, 'extract', self, &block).eval_context
+        end
+
+        # Returns all the elements in a collection that comply to a predicate.
+        # Will generate
+        #  FILTER(identifier in collection : predicate)
+        def filter(&block)
+          Collection.new(clause_list, 'filter', self, &block).eval_context
+        end
+
+        def foreach(&block)
+          Foreach.new(clause_list, self, &block).eval_context
+        end
+
       end
 
       module Sortable
         def _return_item
-          if self.is_a?(Neo4j::Cypher::ReturnItem::EvalContext)
-            self
-          else
-            @return_item ||= ReturnItem.new(clause_list, self).eval_context
-          end
+          @return_item ||= ReturnItem.new(clause_list, self).eval_context
         end
 
         def asc(*props)
@@ -265,14 +267,12 @@ module Neo4j
 
       module Variable
         def where(&block)
-          x = RootClause::EvalContext.new(self).instance_exec(self, &block)
-          Operator.new(clause_list, x.clause, nil, "").unary!
+          Where.new(clause_list, self, &block)
           self
         end
 
         def where_not(&block)
-          x = RootClause::EvalContext.new(self).instance_exec(self, &block)
-          Operator.new(clause_list, x.clause, nil, "not").unary!
+          Where.new(clause_list, self, &block).neg!
           self
         end