neo4j-core 0.0.15-java → 2.0.0.alpha.1-java

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.15"
+    VERSION = "2.0.0.alpha.1"
   end
 end

data/lib/neo4j-core/version.rb~

@@ -0,0 +1,3 @@
+module Neo4jCore
+
+end

data/lib/neo4j/config.rb

@@ -37,7 +37,7 @@ module Neo4j
       # @return [Hash] the default file loaded by yaml
       def defaults
         require 'yaml'
-        @defaults ||= Neo4j::Core::HashWithIndifferentAccess.new(YAML.load_file(default_file))
+        @defaults ||= YAML.load_file(default_file)
       end
 
       # @return [String] the expanded path of the Config[:storage_path] property
@@ -56,7 +56,7 @@ module Neo4j
       # @yield config
       # @yieldparam [Neo4j::Config] config - this configuration class
       def use
-        @configuration ||= Neo4j::Core::HashWithIndifferentAccess.new
+        @configuration ||= {}
         yield @configuration
         nil
       end
@@ -123,13 +123,16 @@ module Neo4j
         map
       end
 
+      private
+
       # @return The a new configuration using default values as a hash.
       def setup()
-        @configuration = Neo4j::Core::HashWithIndifferentAccess.new
+        @configuration = {}
         @configuration.merge!(defaults)
         @configuration
       end
 
+
     end
   end
 

data/lib/neo4j/neo4j.rb

@@ -5,17 +5,10 @@
 # The Neo4j modules is used to interact with an Neo4j Database instance.
 # You can for example start and stop an instance and list all the nodes that exist in the database.
 #
-# @example
-#   require 'neo4j'
-#   Neo4j::Transaction.run { Neo4j.ref_node.outgoing(:friends) << Neo4j::Node.new(:name => 'andreas')}
-#   Neo4j.ref_node.node(:outgoing, :friends)[:name] #=> 'andreas'
-#   Neo4j.query(Neo4j.ref_node){|ref| ref > ':friends' > :x; :x}
-#
-# ==== Notice - Starting and Stopping Neo4j
+# === Starting and Stopping Neo4j
 # You don't normally need to start the Neo4j database since it will be automatically started when needed.
 # Before the database is started you should configure where the database is stored, see {Neo4j::Config]}.
 #
-#
 module Neo4j
 
   # @return [String] The version of the Neo4j jar files
@@ -58,10 +51,9 @@ module Neo4j
     end
 
     # Checks read only mode of the database. Only one process can have write access to the database.
-    # It will always return false if the database is not started yet.
     # @return [true, false] if the database has started up in read only mode
     def read_only?
-      !!(@db && @db.graph && @db.read_only?)
+      (@db && @db.graph && @db.read_only?)
     end
 
     # Returns a started db instance. Starts it's not running.
@@ -72,10 +64,14 @@ module Neo4j
       db
     end
 
-    # If the database is not running it returns Neo4j::Config.storage_path otherwise it asks the database
-    # @return [String] the current storage path of the database
+    # Runs all user defined migrations.
+    def migrate!
+
+    end
+
+    # @return [String, nil] the current storage path of a running neo4j database. If the database is not running it returns nil.
     def storage_path
-      return Neo4j::Config.storage_path unless db.running?
+      return nil unless db.running?
       db.storage_path
     end
 
@@ -89,42 +85,18 @@ module Neo4j
     # Check the neo4j 
     # Returns an enumerable of hash values.
     #
-    # @example Using the Cypher DSL
-    #  q = Neo4j.query{ match node(3) <=> node(:x); ret :x}
-    #  q.first[:n] #=> the @node
-    #  q.columns.first => :n
-    #
-    # @example Using the Cypher DSL and one parameter (n=Neo4j.ref_node)
-    #  q = Neo4j.query(Neo4j.ref_node){|n| n <=> node(:x); :x}
-    #  q.first[:n] #=> the @node
-    #  q.columns.first => :n
-    #
-    # @example Using an array of nodes
-    #  # same as - two_nodes=node(Neo4j.ref_node.neo_id, node_b.neo_id), b = node(b.neo_id)
-    #  q = Neo4j.query([Neo4j.ref_node, node_b], node_c){|two_nodes, b| two_nodes <=> b; b}
+    # @example
     #
-    # @example With an string
-    #  q = Neo4j._query("START n=node(42) RETURN n")
-    #  q.first(:n) #=> the @node
-    #  q.columns.first => :n
+    #  q = Neo4j.query("START n=node({node}) RETURN n", 'node' => @node.neo_id)
+    #  q.first['n'] #=> the @node
+    #  q.columns.first => 'n'
     #
-    # @see Cypher
-    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
+    # @see {http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation}
     # @note Returns a read-once only forward iterable.
-    # @param params parameter for the query_dsl block
-    # @return [Neo4j::Core::Cypher::ResultWrapper] a forward read once only Enumerable, containing hash values.
-    def query(*params, &query_dsl)
-      q = Cypher.new(*params, &query_dsl).to_s
-      _query(q)
-    end
-
-    # Performs a cypher query with given string
-    # @param [String] q the cypher query as a String
-    # @return (see #query)
-    def _query(q)
-      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(db)
-      result = engine.execute(q)
-      Neo4j::Core::Cypher::ResultWrapper.new(result)
+    # @return [Enumerable] a forward read once only Enumerable, containing hash values.
+    def query(query, params = {})
+      engine = org.neo4j.cypher.javacompat.ExecutionEngine.new(db)
+      engine.execute(query, params)
     end
 
 
@@ -193,7 +165,7 @@ module Neo4j
 
     # Usually, a client attaches relationships to this node that leads into various parts of the node space.
     # ®return the reference node, which is a "starting point" in the node space.
-    # @note In case the ref_node has been assigned via the threadlocal_ref_node method,
+    # @note In case the ref_node has been assigned via the threadlocal_ref_node method, 
     #       then that node will be returned instead.
     # @see the design guide at http://wiki.neo4j.org/content/Design_Guide
     def ref_node(this_db = self.started_db)
@@ -227,16 +199,15 @@ module Neo4j
     # Neo4j.management(org.neo4j.management.HighAvailability).isMaster
     #
     # @param jmx_clazz the JMX class http://api.neo4j.org/current/org/neo4j/management/package-summary.html
-    # @param this_db default currently running instance or a newly started neo4j db instance
+    # @param this_db default currently runnig instance or a newly started neo4j db instance
     # @see for the jmx_clazz p
-    # @node this
-    def management(jmx_clazz = Java::OrgNeo4jJmx::Primitives, this_db = self.started_db)
+    def management(jmx_clazz = org.neo4j.jmx.Primitives, this_db = self.started_db)
       this_db.management(jmx_clazz)
     end
 
     # @return [Enumerable] all nodes in the database
     def all_nodes(this_db = self.started_db)
-      Enumerator.new(this_db, :each_node)
+      Enumerable::Enumerator.new(this_db, :each_node)
     end
 
     # @return [Enumerable] all nodes in the database but not wrapped in ruby classes.

data/lib/neo4j/node.rb

@@ -9,39 +9,14 @@ module Neo4j
   # *org.neo4j.kernel.impl.core.NodeProxy* object. This java object includes the same mixin as this class. The #class method on the java object
   # returns Neo4j::Node in order to make it feel like an ordinary Ruby object.
   #
-  # @example Create a node with one property (see {Neo4j::Core::Node::ClassMethods})
-  #   Neo4j::Node.new(:name => 'andreas')
-  #
-  # @example Create a relationship (see {Neo4j::Core::Traversal})
-  #   Neo4j::Node.new.outgoing(:friends) << Neo4j::Node.new
-  #
-  # @example Finding relationships (see {Neo4j::Core::Rels})
-  #   node.rels(:outgoing, :friends)
-  #
-  # @example Lucene index (see {Neo4j::Core::Index})
-  #   Neo4j::Node.trigger_on(:typex => 'MyTypeX')
-  #   Neo4j::Node.index(:name)
-  #   a = Neo4j::Node.new(:name => 'andreas', :typex => 'MyTypeX')
-  #   # finish_tx
-  #   Neo4j::Node.find(:name => 'andreas').first.should == a
-  #
   class Node
     extend Neo4j::Core::Node::ClassMethods
-    extend Neo4j::Core::Wrapper::ClassMethods
-    extend Neo4j::Core::Index::ClassMethods
 
     include Neo4j::Core::Property
     include Neo4j::Core::Rels
     include Neo4j::Core::Traversal
     include Neo4j::Core::Equal
     include Neo4j::Core::Node
-    include Neo4j::Core::Wrapper
-    include Neo4j::Core::Property::Java # for documentation purpose only
-    include Neo4j::Core::Index
-
-    node_indexer do
-      index_names :exact => 'default_node_index_exact', :fulltext => 'default_node_index_fulltext'
-    end
 
     class << self
 
@@ -54,8 +29,6 @@ module Neo4j
           include Neo4j::Core::Traversal
           include Neo4j::Core::Equal
           include Neo4j::Core::Node
-          include Neo4j::Core::Wrapper
-          include Neo4j::Core::Index
         end
       end
     end

data/lib/neo4j/relationship.rb

@@ -29,36 +29,13 @@ module Neo4j
   #
   #   node.outgoing(:friends) << other_node << yet_another_node
   #
-  # @example lucene index
-  #  Neo4j::Relationship.trigger_on(:typey => 123)
-  #  Neo4j::Relationship.index(:name)
-  #  a = Neo4j::Relationship.new(:friends, Neo4j::Node.new, Neo4j::Node.new, :typey => 123, :name => 'kalle')
-  #  # Finish tx
-  #  Neo4j::Relationship.find(:name => 'kalle').first.should be_nil
-  #
   # @see http://api.neo4j.org/current/org/neo4j/graphdb/Relationship.html
   #
   class Relationship
     extend Neo4j::Core::Relationship::ClassMethods
-    extend Neo4j::Core::Wrapper::ClassMethods
-    extend Neo4j::Core::Index::ClassMethods
-
     include Neo4j::Core::Property
     include Neo4j::Core::Equal
     include Neo4j::Core::Relationship
-    include Neo4j::Core::Wrapper
-    include Neo4j::Core::Property::Java # for documentation purpose only
-    include Neo4j::Core::Index
-
-
-    # (see Neo4j::Core::Relationship::ClassMethods#new)
-    def initialize(rel_type, start_node, end_node, props={})
-    end
-
-
-    rel_indexer do
-      index_names :exact => 'default_rel_index_exact', :fulltext => 'default_rel_index_fulltext'
-    end
 
     class << self
       def extend_java_class(java_clazz) #:nodoc:
@@ -66,8 +43,6 @@ module Neo4j
           include Neo4j::Core::Property
           include Neo4j::Core::Equal
           include Neo4j::Core::Relationship
-          include Neo4j::Core::Wrapper
-          include Neo4j::Core::Index
         end
       end
 

data/lib/test.rb

@@ -0,0 +1,27 @@
+puts "TEST"
+
+class LazyMap
+  include Enumerable
+
+  def initialize(stuff, &map_block)
+    @stuff = stuff
+    @map_block = map_block
+  end
+
+  def each
+    @stuff.each{|x| yield @map_block.call(x)}
+  end
+
+end
+
+class Foo
+  include Enumerable
+
+  def each
+    (1..5).to_a.each do |x|
+      yield x
+    end
+  end
+end
+e = LazyMap.new(Foo.new, &:to_s)
+puts "Max #{e.find{|x| x == "2"}}"

data/neo4j-core.gemspec

@@ -25,7 +25,7 @@ It comes included with the Apache Lucene document database.
   s.files = Dir.glob("{bin,lib,config}/**/*") + %w(README.rdoc Gemfile neo4j-core.gemspec)
   s.has_rdoc = true
   s.extra_rdoc_files = %w( README.rdoc )
-  s.rdoc_options = ["--quiet", "--title", "Neo4j::Core", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+  s.rdoc_options = ["--quiet", "--title", "Neo4j.rb", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
 
-  s.add_dependency("neo4j-community", ">= 1.7.0")
+  s.add_dependency("neo4j-community", "1.6.1.alpha.1")
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: neo4j-core
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.15
+  prerelease: 6
+  version: 2.0.0.alpha.1
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-27 00:00:00 Z
+date: 2012-03-11 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -18,9 +18,9 @@ dependencies:
     requirement: &id001 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
-        - - ">="
+        - - "="
           - !ruby/object:Gem::Version 
-            version: 1.7.0
+            version: 1.6.1.alpha.1
     type: :runtime
     version_requirements: *id001
 description: |
@@ -37,10 +37,9 @@ extensions: []
 extra_rdoc_files: 
   - README.rdoc
 files: 
+  - lib/test.rb
   - lib/neo4j-core.rb
   - lib/neo4j/config.rb
-  - lib/neo4j/algo.rb
-  - lib/neo4j/cypher.rb
   - lib/neo4j/transaction.rb
   - lib/neo4j/neo4j.rb
   - lib/neo4j/neo4j.rb~
@@ -48,14 +47,13 @@ files:
   - lib/neo4j/relationship.rb
   - lib/neo4j-core/event_handler.rb
   - lib/neo4j-core/lazy_map.rb
-  - lib/neo4j-core/hash_with_indifferent_access.rb
+  - lib/neo4j-core/version.rb~
   - lib/neo4j-core/database.rb
   - lib/neo4j-core/relationship_set.rb
   - lib/neo4j-core/version.rb
   - lib/neo4j-core/to_java.rb
   - lib/neo4j-core/node/node.rb
   - lib/neo4j-core/node/class_methods.rb
-  - lib/neo4j-core/property/java.rb
   - lib/neo4j-core/property/property.rb
   - lib/neo4j-core/equal/equal.rb
   - lib/neo4j-core/traversal/rel_expander.rb
@@ -64,21 +62,17 @@ files:
   - lib/neo4j-core/traversal/traversal.rb
   - lib/neo4j-core/traversal/traverser.rb
   - lib/neo4j-core/traversal/evaluator.rb
+  - lib/neo4j-core/type_converters/type_converters.rb
   - lib/neo4j-core/rels/traverser.rb
   - lib/neo4j-core/rels/rels.rb
-  - lib/neo4j-core/wrapper/wrapper.rb
-  - lib/neo4j-core/wrapper/class_methods.rb
   - lib/neo4j-core/index/index_config.rb
   - lib/neo4j-core/index/indexer.rb
   - lib/neo4j-core/index/lucene_query.rb
   - lib/neo4j-core/index/indexer_registry.rb
-  - lib/neo4j-core/index/unique_factory.rb
   - lib/neo4j-core/index/class_methods.rb
   - lib/neo4j-core/index/index.rb
   - lib/neo4j-core/relationship/class_methods.rb
   - lib/neo4j-core/relationship/relationship.rb
-  - lib/neo4j-core/cypher/cypher.rb
-  - lib/neo4j-core/cypher/result_wrapper.rb
   - config/neo4j/config.yml
   - README.rdoc
   - Gemfile
@@ -90,7 +84,7 @@ post_install_message:
 rdoc_options: 
   - --quiet
   - --title
-  - Neo4j::Core
+  - Neo4j.rb
   - --line-numbers
   - --main
   - README.rdoc
@@ -106,9 +100,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.3.1
 requirements: []
 
 rubyforge_project: neo4j-core

data/lib/neo4j-core/cypher/cypher.rb

@@ -1,969 +0,0 @@
-module Neo4j
-  module Core
-
-    # This module contains a number of mixins and classes used by the neo4j.rb cypher DSL.
-    # The Cypher DSL is evaluated in the context of {Neo4j::Cypher} which contains a number of methods (e.g. {Neo4j::Cypher#node})
-    # which returns classes from this module.
-    module Cypher
-
-      module MathFunctions
-        def abs(value=nil)
-          _add_math_func(:abs, value)
-        end
-
-        def sqrt(value=nil)
-          _add_math_func(:sqrt, value)
-        end
-
-        def round(value=nil)
-          _add_math_func(:round, value)
-        end
-
-        def sign(value=nil)
-          _add_math_func(:sign, value)
-        end
-
-        # @private
-        def _add_math_func(name, value=nil)
-          value ||= self.respond_to?(:var_name) ? self.var_name : to_s
-          expressions.delete(self)
-          Property.new(expressions, nil, name).to_function!(value)
-        end
-      end
-
-      module MathOperator
-        def -(other)
-          ExprOp.new(self, other, '-')
-        end
-
-        def +(other)
-          ExprOp.new(self, other, '+')
-        end
-      end
-
-      module Comparable
-        def <(other)
-          ExprOp.new(self, other, '<')
-        end
-
-        def <=(other)
-          ExprOp.new(self, other, '<=')
-        end
-
-        def =~(other)
-          ExprOp.new(self, other, '=~')
-        end
-
-        def >(other)
-          ExprOp.new(self, other, '>')
-        end
-
-        def >=(other)
-          ExprOp.new(self, other, '>=')
-        end
-
-        ## Only in 1.9
-        if RUBY_VERSION > "1.9.0"
-          eval %{
-            def !=(other)
-              other.is_a?(String) ?  ExprOp.new(self, other, "!=") : super
-            end  }
-        end
-
-        def ==(other)
-          if other.is_a?(Fixnum) || other.is_a?(String) || other.is_a?(Regexp)
-            ExprOp.new(self, other, "=")
-          else
-            super
-          end
-        end
-      end
-
-      module PredicateMethods
-        def all?(&block)
-          self.respond_to?(:iterable)
-          Predicate.new(expressions, :op => 'all', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-        def extract(&block)
-          Predicate.new(expressions, :op => 'extract', :clause => :return, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-        def filter(&block)
-          Predicate.new(expressions, :op => 'filter', :clause => :return, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-        def any?(&block)
-          Predicate.new(@expressions, :op => 'any', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-        def none?(&block)
-          Predicate.new(@expressions, :op => 'none', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-        def single?(&block)
-          Predicate.new(@expressions, :op => 'single', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
-        end
-
-      end
-
-      module Variable
-        attr_accessor :return_method
-
-        def distinct
-          self.return_method = {:name => 'distinct', :bracket => false}
-          self
-        end
-
-        def [](prop_name)
-          Property.new(expressions, self, prop_name)
-        end
-
-        def as(v)
-          @var_name = v
-          self
-        end
-
-        # generates a <tt>ID</tt> cypher fragment.
-        def neo_id
-          Property.new(@expressions, self, 'ID').to_function!
-        end
-
-        # generates a <tt>has</tt> cypher fragment.
-        def property?(p)
-          p = Property.new(expressions, self, p)
-          p.binary_operator("has")
-        end
-
-        # generates a <tt>is null</tt> cypher fragment.
-        def exist?
-          p = Property.new(expressions, self, p)
-          p.binary_operator("", " is null")
-        end
-
-        # Can be used instead of [_classname] == klass
-        def is_a?(klass)
-          return super if klass.class != Class || !klass.respond_to?(:_load_wrapper)
-          self[:_classname] == klass.to_s
-        end
-      end
-
-      module Matchable
-        # This operator means related to, without regard to type or direction.
-        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
-        # @return [MatchRelLeft, MatchNode]
-        def <=>(other)
-          MatchNode.new(self, other, expressions, :both)
-        end
-
-        # This operator means outgoing related to
-        # @param [Symbol, #var_name, String] other the relationship
-        # @return [MatchRelLeft, MatchNode]
-        def >(other)
-          MatchRelLeft.new(self, other, expressions, :outgoing)
-        end
-
-        # This operator means any direction related to
-        # @param (see #>)
-        # @return [MatchRelLeft, MatchNode]
-        def -(other)
-          MatchRelLeft.new(self, other, expressions, :both)
-        end
-
-        # This operator means incoming related to
-        # @param (see #>)
-        # @return [MatchRelLeft, MatchNode]
-        def <(other)
-          MatchRelLeft.new(self, other, expressions, :incoming)
-        end
-
-        # Outgoing relationship to other node
-        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
-        # @return [MatchRelLeft, MatchNode]
-        def >>(other)
-          MatchNode.new(self, other, expressions, :outgoing)
-        end
-
-        def outgoing(rel_type)
-          node = NodeVar.new(@expressions, @variables)
-          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :outgoing) > node
-          node
-        end
-
-        def incoming(rel_type)
-          node = NodeVar.new(@expressions, @variables)
-          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :incoming) < node
-          node
-        end
-
-        def both(rel_type)
-          node = NodeVar.new(@expressions, @variables)
-          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :both) < node
-          node
-        end
-
-        # Incoming relationship to other node
-        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
-        # @return [MatchRelLeft, MatchNode]
-        def <<(other)
-          MatchNode.new(self, other, expressions, :incoming)
-        end
-      end
-
-      class Expression
-        attr_reader :expressions
-        attr_accessor :separator, :clause
-
-        def initialize(expressions, clause)
-          @clause = clause
-          @expressions = expressions
-          insert_last(clause)
-          @separator = ","
-        end
-
-        def insert_last(clause)
-          i = @expressions.reverse.index { |e| e.clause == clause }
-          if i.nil?
-            @expressions << self
-          else
-            pos = @expressions.size - i
-            @expressions.insert(pos, self)
-          end
-        end
-
-        def prefixes
-          {:start => "START", :where => " WHERE", :match => " MATCH", :return => " RETURN", :order_by => " ORDER BY", :skip => " SKIP", :limit => " LIMIT"}
-        end
-
-        def prefix
-          prefixes[clause]
-        end
-
-        def valid?
-          true
-        end
-
-      end
-
-      # 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
-        # @private
-        attr_reader :expressions, :var_name
-        include Comparable
-        include MathOperator
-        include MathFunctions
-        include PredicateMethods
-
-        def initialize(expressions, var, prop_name)
-          @var = var.respond_to?(:var_name) ? var.var_name : var
-          @expressions = expressions
-          @prop_name = prop_name
-          @var_name = @prop_name ? "#{@var.to_s}.#{@prop_name}" : @var.to_s
-        end
-
-        # @private
-        def to_function!(var = @var.to_s)
-          @var_name = "#{@prop_name}(#{var})"
-          self
-        end
-
-        # Make it possible to rename a property with a different name (AS)
-        def as(new_name)
-          @var_name = "#{@var_name} AS #{new_name}"
-        end
-
-        # required by the Predicate Methods Module
-        # @see PredicateMethods
-        # @private
-        def iterable
-          var_name
-        end
-
-        def input
-          self
-        end
-
-        # @private
-        def in?(values)
-          binary_operator("", " IN [#{values.map { |x| %Q["#{x}"] }.join(',')}]")
-        end
-
-        # Only return distinct values/nodes/rels/paths
-        def distinct
-          @var_name = "distinct #{@var_name}"
-          self
-        end
-
-        def length
-          @prop_name = "length"
-          to_function!
-          self
-        end
-
-        %w[count sum avg min max collect head last tail].each do |meth_name|
-          define_method(meth_name) do
-            function(meth_name.to_s)
-          end
-        end
-
-        # @private
-        def function(func_name_pre, func_name_post = "")
-          ExprOp.new(self, nil, func_name_pre, func_name_post)
-        end
-
-        # @private
-        def binary_operator(op, post_fix = "")
-          ExprOp.new(self, nil, op, post_fix).binary!
-        end
-      end
-
-      class Start < Expression
-        # @private
-        attr_reader :var_name
-        include Variable
-        include Matchable
-
-        def initialize(var_name, expressions)
-          @var_name = "#{var_name}#{expressions.size}"
-          super(expressions, :start)
-        end
-
-      end
-
-      # Can be created from a <tt>node</tt> dsl method.
-      class StartNode < Start
-        # @private
-        attr_reader :nodes
-
-        def initialize(nodes, expressions)
-          super("n", expressions)
-
-          @nodes = nodes.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
-        end
-
-        def to_s
-          "#{var_name}=node(#{nodes.join(',')})"
-        end
-      end
-
-
-      # Can be created from a <tt>rel</tt> dsl method.
-      class StartRel < Start
-        # @private
-        attr_reader :rels
-
-        def initialize(rels, expressions)
-          super("r", expressions)
-          @rels = rels.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
-        end
-
-        def to_s
-          "#{var_name}=relationship(#{rels.join(',')})"
-        end
-      end
-
-      class NodeQuery < Start
-        attr_reader :index_name, :query
-
-        def initialize(index_class, query, index_type, expressions)
-          super("n", expressions)
-          @index_name = index_class.index_name_for_type(index_type)
-          @query = query
-        end
-
-        def to_s
-          "#{var_name}=node:#{index_name}(#{query})"
-        end
-      end
-
-      class NodeLookup < Start
-        attr_reader :index_name, :query
-
-        def initialize(index_class, key, value, expressions)
-          super("n", expressions)
-          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_s
-          %Q[#{var_name}=node:#{index_name}(#{query})]
-        end
-
-      end
-
-      # The return statement in the cypher query
-      class Return < Expression
-        attr_reader :var_name
-
-        def initialize(name_or_ref, expressions, opts = {})
-          super(expressions, :return)
-          @name_or_ref = name_or_ref
-          @name_or_ref.referenced! if @name_or_ref.respond_to?(:referenced!)
-          @var_name = @name_or_ref.respond_to?(:var_name) ? @name_or_ref.var_name : @name_or_ref.to_s
-          opts.each_pair { |k, v| self.send(k, v) }
-        end
-
-        # @private
-        def return_method
-          @name_or_ref.respond_to?(:return_method) && @name_or_ref.return_method
-        end
-
-        # @private
-        def as_return_method
-          if return_method[:bracket]
-            "#{return_method[:name]}(#@var_name)"
-          else
-            "#{return_method[:name]} #@var_name"
-          end
-        end
-
-        # Specifies an <tt>ORDER BY</tt> cypher query
-        # @param [Property] props the properties which should be sorted
-        # @return self
-        def asc(*props)
-          @order_by ||= OrderBy.new(expressions)
-          @order_by.asc(props)
-          self
-        end
-
-        # Specifies an <tt>ORDER BY</tt> cypher query
-        # @param [Property] props the properties which should be sorted
-        # @return self
-        def desc(*props)
-          @order_by ||= OrderBy.new(expressions)
-          @order_by.desc(props)
-          self
-        end
-
-        # Creates a <tt>SKIP</tt> cypher clause
-        # @param [Fixnum] val the number of entries to skip
-        # @return self
-        def skip(val)
-          Skip.new(expressions, val)
-          self
-        end
-
-        # Creates a <tt>LIMIT</tt> cypher clause
-        # @param [Fixnum] val the number of entries to limit
-        # @return self
-        def limit(val)
-          Limit.new(expressions, val)
-          self
-        end
-
-        def to_s
-          return_method ? as_return_method : var_name.to_s
-        end
-      end
-
-      # Can be used to skip result from a return clause
-      class Skip < Expression
-        def initialize(expressions, value)
-          super(expressions, :skip)
-          @value = value
-        end
-
-        def to_s
-          @value
-        end
-      end
-
-      # Can be used to limit result from a return clause
-      class Limit < Expression
-        def initialize(expressions, value)
-          super(expressions, :limit)
-          @value = value
-        end
-
-        def to_s
-          @value
-        end
-      end
-
-      class OrderBy < Expression
-        def initialize(expressions)
-          super(expressions, :order_by)
-          @orders = []
-        end
-
-        def asc(props)
-          @orders << [:asc, props]
-        end
-
-        def desc(props)
-          @orders << [:desc, props]
-        end
-
-        def to_s
-          @orders.map do |pair|
-            if pair[0] == :asc
-              pair[1].map(&:var_name).join(', ')
-            else
-              pair[1].map(&:var_name).join(', ') + " DESC"
-            end
-          end.join(', ')
-        end
-      end
-
-      # Created from a node's match operator like >> or <.
-      class Match < Expression
-        # @private
-        attr_reader :dir, :expressions, :left, :right, :var_name, :dir_op
-        # @private
-        attr_accessor :algorithm, :next, :prev
-        include Variable
-
-        def initialize(left, right, expressions, dir, dir_op)
-          super(expressions, :match)
-          @var_name = "m#{expressions.size}"
-          @dir = dir
-          @dir_op = dir_op
-          @prev = left if left.is_a?(Match)
-          @left = left
-          @right = right
-        end
-
-
-        # Generates a <tt>x in nodes(m3)</tt> cypher expression.
-        #
-        # @example
-        #   p.nodes.all? { |x| x[:age] > 30 }
-        def nodes
-          Entities.new(@expressions, "nodes", self)
-        end
-
-        # Generates a <tt>x in relationships(m3)</tt> cypher expression.
-        #
-        # @example
-        #   p.relationships.all? { |x| x[:age] > 30 }
-        def rels
-          Entities.new(@expressions, "relationships", self)
-        end
-
-        # returns the length of the path
-        def length
-          self.return_method = {:name => 'length', :bracket => true}
-          self
-        end
-
-        # @private
-        def find_match_start
-          c = self
-          while (c.prev) do
-            c = c.prev
-          end
-          c
-        end
-
-        # @private
-        def left_var_name
-          @left.respond_to?(:var_name) ? @left.var_name : @left.to_s
-        end
-
-        # @private
-        def right_var_name
-          @right.respond_to?(:var_name) ? @right.var_name : @right.to_s
-        end
-
-        # @private
-        def right_expr
-          @right.respond_to?(:expr) ? @right.expr : right_var_name
-        end
-
-        # @private
-        def referenced!
-          @referenced = true
-        end
-
-        # @private
-        def referenced?
-          !!@referenced
-        end
-
-        # @private
-        def to_s
-          curr = find_match_start
-          result = (referenced? || curr.referenced?) ? "#{var_name} = " : ""
-          result << (algorithm ? "#{algorithm}(" : "")
-          begin
-            result << curr.expr
-          end while (curr = curr.next)
-          result << ")" if algorithm
-          result
-        end
-      end
-
-      # The left part of a match clause, e.g. node < rel(':friends')
-      # Can return {MatchRelRight} using a match operator method.
-      class MatchRelLeft < Match
-        def initialize(left, right, expressions, dir)
-          super(left, right, expressions, dir, dir == :incoming ? '<-' : '-')
-        end
-
-        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
-        # @return [MatchRelRight] the right part of an relationship cypher query.
-        def >(other)
-          expressions.delete(self)
-          self.next = MatchRelRight.new(self, other, expressions, :outgoing)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def <(other)
-          expressions.delete(self)
-          self.next = MatchRelRight.new(self, other, expressions, :incoming)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def -(other)
-          expressions.delete(self)
-          self.next = MatchRelRight.new(self, other, expressions, :both)
-        end
-
-        # @return [String] a cypher string for this match.
-        def expr
-          if prev
-            # we have chained more then one relationships in a match expression
-            "#{dir_op}[#{right_expr}]"
-          else
-            # the right is an relationship and could be an expressions, e.g "r?"
-            "(#{left_var_name})#{dir_op}[#{right_expr}]"
-          end
-        end
-      end
-
-      class MatchRelRight < Match
-        # @param left the left part of the query
-        # @param [Symbol,NodeVar,String] right part of the match cypher statement.
-        def initialize(left, right, expressions, dir)
-          super(left, right, expressions, dir, dir == :outgoing ? '->' : '-')
-        end
-
-        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
-        # @return [MatchRelLeft] the right part of an relationship cypher query.
-        def >(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :outgoing)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def <(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :incoming)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def -(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :both)
-        end
-
-        # @return [String] a cypher string for this match.
-        def expr
-          "#{dir_op}(#{right_var_name})"
-        end
-
-        # negate this match
-        def not
-          expressions.delete(self)
-          ExprOp.new(left, nil, "not").binary!
-        end
-
-        if RUBY_VERSION > "1.9.0"
-          eval %{
-             def !
-          expressions.delete(self)
-          ExprOp.new(left, nil, "not").binary!
-             end
-             }
-        end
-
-      end
-
-      # The right part of a match clause (node_b), e.g. node_a > rel(':friends') > node_b
-      #
-      class MatchNode < Match
-        attr_reader :dir_op
-
-        def initialize(left, right, expressions, dir)
-          dir_op = case dir
-                     when :outgoing then
-                       "-->"
-                     when :incoming then
-                       "<--"
-                     when :both then
-                       "--"
-                   end
-          super(left, right, expressions, dir, dir_op)
-        end
-
-        # @return [String] a cypher string for this match.
-        def expr
-          if prev
-            # we have chained more then one relationships in a match expression
-            "#{dir_op}(#{right_expr})"
-          else
-            # the right is an relationship and could be an expressions, e.g "r?"
-            "(#{left_var_name})#{dir_op}(#{right_expr})"
-          end
-        end
-
-        def <<(other)
-          expressions.delete(self)
-          self.next = MatchNode.new(self, other, expressions, :incoming)
-        end
-
-        def >>(other)
-          expressions.delete(self)
-          self.next = MatchNode.new(self, other, expressions, :outgoing)
-        end
-
-        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
-        # @return [MatchRelRight] the right part of an relationship cypher query.
-        def >(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :outgoing)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def <(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :incoming)
-        end
-
-        # @see #>
-        # @return (see #>)
-        def -(other)
-          expressions.delete(self)
-          self.next = MatchRelLeft.new(self, other, expressions, :both)
-        end
-
-      end
-
-      # Represents an unbound node variable used in match statements
-      class NodeVar
-        include Variable
-        include Matchable
-
-        # @return the name of the variable
-        attr_reader :var_name
-        attr_reader :expressions
-
-        def initialize(expressions, variables)
-          variables ||= []
-          @var_name = "v#{variables.size}"
-          variables << self
-          @variables = variables
-          @expressions = expressions
-        end
-
-        # @return [String] a cypher string for this node variable
-        def to_s
-          var_name
-        end
-
-      end
-
-      # represent an unbound relationship variable used in match,where,return statement
-      class RelVar
-        include Variable
-
-        attr_reader :var_name, :expr, :expressions
-
-        def initialize(expressions, variables, expr)
-          variables << self
-          @expr = expr
-          @expressions = expressions
-          guess = expr ? /([[:alpha:]]*)/.match(expr)[1] : ""
-          @var_name = guess.empty? ? "v#{variables.size}" : guess
-        end
-
-        def rel_type
-          Property.new(@expressions, self, 'type').to_function!
-        end
-
-        # @return [String] a cypher string for this relationship variable
-        def to_s
-          var_name
-        end
-
-      end
-
-      class ExprOp < Expression
-        attr_reader :left, :right, :op, :neg, :post_fix
-        include MathFunctions
-
-        def initialize(left, right, op, post_fix = "")
-          super(left.expressions, :where)
-          @op = op
-          @post_fix = post_fix
-          self.expressions.delete(left)
-          self.expressions.delete(right)
-          @left = quote(left)
-          if regexp?(right)
-            @op = "=~"
-            @right = to_regexp(right)
-          else
-            @right = right && quote(right)
-          end
-          @neg = nil
-        end
-
-        def separator
-          " "
-        end
-
-        def quote(val)
-          if val.respond_to?(:var_name) && !val.kind_of?(Match)
-            val.var_name
-          else
-            val.is_a?(String) ? %Q["#{val}"] : val
-          end
-        end
-
-        def regexp?(right)
-          @op == "=~" || right.is_a?(Regexp)
-        end
-
-        def to_regexp(val)
-          %Q[/#{val.respond_to?(:source) ? val.source : val.to_s}/]
-        end
-
-        def count
-          ExprOp.new(self, nil, 'count')
-        end
-
-        def &(other)
-          ExprOp.new(self, other, "and")
-        end
-
-        def |(other)
-          ExprOp.new(self, other, "or")
-        end
-
-        def -@
-          @neg = "not"
-          self
-        end
-
-        def not
-          @neg = "not"
-          self
-        end
-
-        # Only in 1.9
-        if RUBY_VERSION > "1.9.0"
-          eval %{
-             def !
-               @neg = "not"
-               self
-             end
-             }
-        end
-
-        def left_to_s
-          left.is_a?(ExprOp) ? "(#{left})" : left
-        end
-
-        def right_to_s
-          right.is_a?(ExprOp) ? "(#{right})" : right
-        end
-
-        def binary!
-          @binary = true
-          self
-        end
-
-        def valid?
-          #        puts "valid? @binary=#{@binary} (#@left #@op #@right) in clause #{clause} ret #{@binary ? !!@left : !!@left && !!@right}"
-          # it is only valid in a where clause if it's either binary or it has right and left values
-          @binary ? @left : @left && @right
-        end
-
-        def to_s
-          if @right
-            neg ? "#{neg}(#{left_to_s} #{op} #{right_to_s})" : "#{left_to_s} #{op} #{right_to_s}"
-          else
-            # binary operator
-            neg ? "#{neg}#{op}(#{left_to_s}#{post_fix})" : "#{op}(#{left_to_s}#{post_fix})"
-          end
-        end
-      end
-
-      class Where < Expression
-        def initialize(expressions, where_statement = nil)
-          super(expressions, :where)
-          @where_statement = where_statement
-        end
-
-        def to_s
-          @where_statement.to_s
-        end
-      end
-
-      class Predicate < Expression
-        attr_accessor :params
-
-        def initialize(expressions, params)
-          @params = params
-          @identifier = :x
-          params[:input].referenced! if params[:input].respond_to?(:referenced!)
-          super(expressions, params[:clause])
-        end
-
-        def identifier(i)
-          @identifier = i
-          self
-        end
-
-        def to_s
-          input = params[:input]
-          if input.kind_of?(Property)
-            yield_param = Property.new([], @identifier, nil)
-            args = ""
-          else
-            yield_param = NodeVar.new([], []).as(@identifier.to_sym)
-            args = "(#{input.var_name})"
-          end
-          context = Neo4j::Cypher.new(yield_param, &params[:predicate_block])
-          context.expressions.each { |e| e.clause = nil }
-          if params[:clause] == :return
-            where_or_colon = ':'
-          else
-            where_or_colon = 'WHERE'
-          end
-          predicate_value = context.to_s[1..-1] # skip separator ,
-          "#{params[:op]}(#@identifier in #{params[:iterable]}#{args} #{where_or_colon} #{predicate_value})"
-        end
-      end
-
-      class Entities
-        include PredicateMethods
-        attr_reader :input, :expressions, :iterable
-
-        def initialize(expressions, iterable, input)
-          @iterable = iterable
-          @input = input
-          @expressions = expressions
-        end
-
-      end
-
-    end
-
-  end
-
-end