neo4j-cypher 1.0.0.rc1 → 1.0.0.rc2

data/README.rdoc

@@ -69,3 +69,33 @@ Matching relationships can be done with operators: <,>, -, and <=> or with the b
          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
+
+
+== License
+
+The neo4j-cypher gem is released under the {MIT license}[www.opensource.org/licenses/MIT]
+
+

data/lib/neo4j-cypher/argument.rb

@@ -18,7 +18,7 @@ module Neo4j
       end
 
       def self.new_arg_from_clause(clause)
-        Argument.new(clause.clause_list, clause.return_value, clause.as_alias? && clause.var_name)
+        Argument.new(clause.clause_list, clause.return_value, clause.as_alias? && clause.alias_name)
       end
 
       def self.new_arg_from_string(string, clause_list)

data/lib/neo4j-cypher/clause_list.rb

@@ -2,7 +2,7 @@ module Neo4j
   module Cypher
 
     class ClauseList
-      attr_accessor :variables
+      attr_accessor :variables, :clause_list
       include Enumerable
 
       def initialize(variables = [])
@@ -16,6 +16,10 @@ module Neo4j
       end
 
       def include?(clause_type)
+        !!find(clause_type)
+      end
+
+      def find(clause_type)
         @clause_list.find { |c| c.clause_type == clause_type }
       end
 

data/lib/neo4j-cypher/context.rb

@@ -146,21 +146,33 @@ module Neo4j
       end
 
       module Sortable
-        def _sort_args(prop)
-          return self if prop.nil?
-          prop.is_a?(Symbol) ? Property.new(clause, prop).eval_context : prop
+        def _return_item
+          if self.is_a?(Neo4j::Cypher::ReturnItem::EvalContext)
+            self
+          else
+            @return_item ||= ReturnItem.new(clause_list, self).eval_context
+          end
         end
 
         def asc(*props)
-          @return_item ||= ReturnItem.new(clause_list, self).eval_context
-          @return_item.asc(_sort_args(props.first))
+          _return_item.asc(*props)
+          self
         end
 
         def desc(*props)
-          @return_item ||= ReturnItem.new(clause_list, self).eval_context
-          @return_item.desc(_sort_args(props.first))
+          _return_item.desc(*props)
+          self
         end
 
+        def skip(val)
+          _return_item.skip(val)
+          self
+        end
+
+        def limit(val)
+          _return_item.limit(val)
+          self
+        end
       end
 
       module ReturnOrder
@@ -253,15 +265,13 @@ module Neo4j
 
       module Variable
         def where(&block)
-          x = block.call(self)
-          clause_list.delete(x)
+          x = RootClause::EvalContext.new(self).instance_exec(self, &block)
           Operator.new(clause_list, x.clause, nil, "").unary!
           self
         end
 
         def where_not(&block)
-          x = block.call(self)
-          clause_list.delete(x)
+          x = RootClause::EvalContext.new(self).instance_exec(self, &block)
           Operator.new(clause_list, x.clause, nil, "not").unary!
           self
         end
@@ -301,6 +311,24 @@ module Neo4j
 
       module Matchable
 
+        ## Only in 1.9
+        if RUBY_VERSION > "1.9.0"
+          eval %{
+            def !=(other)
+              Operator.new(clause_list, clause, other, "<>").eval_context
+            end  }
+        end
+
+        def ==(other)
+          Operator.new(clause_list, clause, other, "=").eval_context
+        end
+
+
+        def match(&cypher_dsl)
+          RootClause::EvalContext.new(self).instance_exec(self, &cypher_dsl)
+          self
+        end
+
         def with(*args, &cypher_dsl)
           With.new(clause_list, :where, self, *args, &cypher_dsl)
           self

data/lib/neo4j-cypher/mixins.rb

@@ -18,10 +18,14 @@ module Neo4j
       end
 
       def as_alias(new_name)
-        @alias = true
+        @alias = new_name
         self.var_name = new_name
       end
 
+      def alias_name
+        @alias
+      end
+
       def as_alias?
         !!@alias && var_name != return_value
       end

data/lib/neo4j-cypher/node_var.rb

@@ -41,6 +41,7 @@ module Neo4j
         include Returnable
         include Aggregate
         include Alias
+        include Sortable
 
 
         def initialize(clause)

data/lib/neo4j-cypher/operator.rb

@@ -47,13 +47,18 @@ module Neo4j
         @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)
+        # 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)
 
         @neg = nil
       end
 
+      def declare_operand?(operand)
+        clause = operand.respond_to?(:clause) ? operand.clause : operand
+        clause.kind_of?(Clause) && clause.clause_type == :start
+      end
+
       def separator
         " and "
       end

data/lib/neo4j-cypher/property.rb

@@ -16,15 +16,25 @@ module Neo4j
       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
 
+      def var_name
+        @var.var_name
+      end
+
+      def expr
+        if @function
+          "#{@prop_name}(#{var_name})"
+        else
+          @prop_name ? "#{@var.var_name}.#{@prop_name}" : @var.var_name.to_s
+        end
+      end
 
       # @private
       def to_function!(prop_name = nil)
-        @expr = "#{prop_name || @prop_name}(#{var_name})"
+        @prop_name = prop_name if prop_name
+        @function = true
         eval_context
       end
 
@@ -44,7 +54,7 @@ module Neo4j
 
 
       def to_cypher
-        @expr
+        expr
       end
 
       class EvalContext

data/lib/neo4j-cypher/rel_var.rb

@@ -74,6 +74,8 @@ module Neo4j
         include Returnable
         include Aggregate
         include Alias
+        include Sortable
+
 
         def rel_type
           Property.new(clause, 'type').to_function!

data/lib/neo4j-cypher/return.rb

@@ -49,9 +49,9 @@ module Neo4j
       def to_cypher
         @orders.map do |pair|
           if pair[0] == :asc
-            pair[1].map(&:return_value).join(', ')
+            pair[1].map{|p| p.alias_name || p.return_value}.join(', ')
           else
-            pair[1].map(&:return_value).join(', ') + " DESC"
+            pair[1].map{|p| p.alias_name || p.return_value}.join(', ') + " DESC"
           end
         end.join(', ')
       end
@@ -85,13 +85,14 @@ module Neo4j
     class ReturnItem
       include Clause
       include Referenceable
+      attr_accessor :order_by
 
       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?
+          as_alias(@delegated_clause.alias_name) if @delegated_clause.as_alias?
         else
           @return_value = name_or_ref.to_s
         end
@@ -102,7 +103,7 @@ module Neo4j
       end
 
       def return_value_with_alias
-        as_alias? ? "#{return_value} as #{var_name}" : return_value
+        as_alias? ? "#{return_value} as #{alias_name}" : return_value
       end
 
       def return_value

data/lib/neo4j-cypher/root.rb

@@ -33,8 +33,8 @@ module Neo4j
       end
 
       def return_names
-        ret = clause_list.last
-        ret.respond_to?(:return_items) ? ret.return_items.map { |ri| ri.var_name.to_sym } : []
+        ret = clause_list.clause_list.find{|r| r.respond_to?(:return_items)}
+        ret ? ret.return_items.map { |ri| (ri.alias_name || ri.return_value).to_sym } : []
       end
 
       class EvalContext

data/lib/neo4j-cypher/start.rb

@@ -72,9 +72,14 @@ module Neo4j
 
       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)
+        if index_class.respond_to?(:index_type)
+          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)
+        else
+          @index_name = index_class
+        end
+
         @query = %Q[#{key}="#{value}"]
       end
 

data/lib/neo4j-cypher/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Cypher
-    VERSION = '1.0.0.rc1'
+    VERSION = '1.0.0.rc2'
   end
 end

data/lib/neo4j-cypher/with.rb

@@ -28,7 +28,7 @@ module Neo4j
       class EvalContext
         include Context
         include Alias
-        include ReturnOrder
+        include Sortable
         include Aggregate
         include Comparable
         include Returnable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-cypher
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-20 00:00:00.000000000 Z
+date: 2012-09-21 00:00:00.000000000 Z
 dependencies: []
 description: ! 'This gem is used in the JRuby neo4j gem but should work on any Ruby
   implementation since it simply