neo4j-core 0.0.2-java → 0.0.3-java

data/README.rdoc

@@ -4,17 +4,13 @@ This gem only contains the JRuby mapping of the Neo4j graph database.
 The neo4j.rb gem will be split up into two gems, neo4j-core and neo4j.
 This gem will be included by neo4j 2.0.0 gem.
 
-Changes from the neo4j.rb
-* Use of YARD instead of RDoc
-* Some tidy up of the API and code (e.g. Neo4j::Node#rels methods)
-* Change of Ruby module structure.
-* More RSpecs and more use of mocking combined with real testing of the Java layer
-* Make sure that we retrieve relationships and nodes lazy if possible.
-* Cypher Query DSL
-
 This gem contains two modules: Neo4j and Neo4j::Core
 The Neo4j module is public and the Neo4j::Core(::*) are private modules.
 
+== Documentation
+
+* {YARD}[http://rdoc.info/github/andreasronge/neo4j-core/file/README.rdoc]
+
 == The public API
 
 {Neo4j::Node} The Java Neo4j Node
@@ -25,3 +21,182 @@ The Neo4j module is public and the Neo4j::Core(::*) are private modules.
 
 {Neo4j::Cypher} Cypher Query Generator, see RSpec spec/neo4j/cypher_spec
 
+== Custom Index
+
+You can create your own indexer
+
+  class MyIndex
+    extend Neo4j::Core::Index::ClassMethods
+    include Neo4j::Core::Index
+
+    node_indexer do
+      index_names :exact => 'myindex_exact', :fulltext => 'myindex_fulltext'
+      trigger_on :myindex => true, :things => ['a', 'b']
+    end
+
+    index :name
+  end
+
+All nodes with the property <tt>myindex == true</tt> or property <tt>things</tt> <tt>'a'</tt> or <tt>'b'</tt>
+will be indexed using this index.
+
+Exampel:
+  n = Neo4j::Node.new(:myindex = true, :name => 'foo')
+  MyIndex.find('name: foo').first #=> n
+
+
+
+== Cypher
+
+Example:
+  Neo4j.query { node(3) }
+
+Example with parameters:
+  Neo4j.query(Neo4j.ref_node} do |ref|
+     ref <=> :x
+     :x
+  end
+
+Notice
+* The last statement in the expression will be the return value.
+* You can skip the start, match, where and ret (they are just empty methods).
+
+=== Cypher Examples
+
+"START n0=node(3) RETURN n0"
+  Neo4j.query do
+    start n = node(3)
+    ret n
+  end
+  # the above is same as:
+  Neo4j.query { node(3) }
+
+"START n0=node(42) RETURN n0"
+  node(Neo4j::Node.new)
+
+"START r0=relationship(3,4) RETURN r0"
+  rel(3,4)
+
+"START n0=node(3) MATCH (n0)--(x) RETURN x"
+  start n = node(3)
+  match n <=> :x
+  ret :x
+
+"START n0=node(3) MATCH (n0)--(v0) RETURN v0"
+  x = node
+  n = node(3)
+  match n <=> x
+  ret x
+
+"START n0=node(3) MATCH (n0)--(v0) RETURN v0.name"
+  x = node
+  n = node(3)
+  match n <=> x
+  ret x[:name]
+
+"START n0=node(1) RETURN n0.name AS SomethingTotallyDifferent"
+  x = node(1)
+  x[:name].as('SomethingTotallyDifferent')
+
+"START n0=node:fooindex_exact(name:A) RETURN n0"
+  query(FooIndex, "name:A")
+
+"START n0=node:fooindex_fulltext(desc="A") RETURN n0"
+  lookup(FooIndex, "desc", "A")
+
+"START n0=node(1),n1=node(2) RETURN n0,n1"
+  [node(1), node(2)]
+
+"START n0=node(3) MATCH (n0)-->(c)-->(d) RETURN c"
+  node(3) >> node(:c) >> :d
+  :c
+
+"START n0=node(3) MATCH (n0)-[r]->(x) RETURN r"
+  node(3) > :r > :x
+  :r
+
+"START n0=node(3) MATCH (n0)-[r:friends]->(x) RETURN r"
+  r = rel('r:friends').as(:r)
+  node(3) > r > :x
+  r
+
+"START n0=node(3,1) WHERE n0.age < 30 RETURN n0"
+  n=node(3, 1)
+  where n[:age] < 30
+  ret n
+
+"START n0=node(3,4) WHERE n0.desc = "hej" RETURN n0"
+  n=node(3, 4)
+  n[:desc] == "hej"
+  n
+
+"START n0=node(3) MATCH (n0)<-[:knows]-(c) RETURN c"
+  a=node(3)
+  a < ':knows' < :c
+  :c
+
+"START n0=node(3) MATCH (n0)-[r]->(v1) WHERE type(r) =~ /K.*/ RETURN r"
+  n=node(3)
+  n > (r=rel('r')) > node
+  r.rel_type =~ /K.*/
+  r
+
+"START n0=node(3) MATCH m2 = (n0)-->(b) RETURN b,length(m2)"
+  p = node(3) >> :b; [:b, p.length]
+
+"START n0=node(1) MATCH (n0)-->(b) RETURN distinct n0"
+  n=node(1); n>>:b; n.distinct
+
+"START n0=node(2) MATCH (n0)-->(x) RETURN n0,count(*)"
+  n = node(2))>>:x
+  [n, count]
+
+"START n0=node(2,3,4) RETURN sum(n0.property)"
+  n=node(2, 3, 4)
+  n[:property].sum
+
+"START n0=node(2) MATCH (n0)-->(b) RETURN count(distinct n0.eyes)"
+  n=node(2); n>>:b
+  n[:eyes].distinct.count
+
+"START n0=node(3,4,5) RETURN ID(n0)"
+  node(3, 4, 5).neo_id
+
+"START n0=node(2) WHERE any(x in n0.array WHERE x = "one") RETURN n0"
+  a = node(2)
+  a[:array].any? { |x| x == 'one' }
+  a
+
+"START n0=node(3),n1=node(4),n2=node(1) MATCH m4 = (n0)-->(n1)-->(n2) RETURN extract(x in nodes(m4) : x.age)"
+  a=node(3)
+  b=node(4)
+  c=node(1)
+  p=a>>b>>c
+  p.nodes.extract { |x| x[:age] }
+
+"START n0=node(3) WHERE abs(n0.x) = 3 RETURN n0"
+  a=node(3); a[:x].abs==3
+  a
+
+"START n0=node(3,4,5,1,2) RETURN n0 ORDER BY n0.name SKIP 1 LIMIT 2"
+  a=node(3,4,5,1,2); ret(a).asc(a[:name]).skip(1).limit(2)
+  # o same as
+  a=node(3,4,5,1,2); ret a, :asc => a[:name], :skip => 1, :limit => 2
+
+For more examples, see the RSpecs
+
+== Creates Your Own Wrapper
+
+Todo, see {Neo4j::Core::Wrapper}
+
+
+== Changes
+
+Changes from the neo4j.rb
+* Use of YARD instead of RDoc
+* Some tidy up of the API and code (e.g. Neo4j::Node#rels methods)
+* Change of Ruby module structure.
+* More RSpecs and more use of mocking combined with real testing of the Java layer
+* Make sure that we retrieve relationships and nodes lazy if possible.
+* Cypher Query DSL
+

data/lib/neo4j-core.rb

@@ -39,6 +39,9 @@ require 'neo4j-core/index/lucene_query'
 
 require 'neo4j-core/equal/equal'
 
+require 'neo4j-core/wrapper/class_methods'
+require 'neo4j-core/wrapper/wrapper'
+
 require 'neo4j-core/relationship/relationship'
 require 'neo4j-core/relationship/class_methods'
 

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

@@ -31,14 +31,7 @@ module Neo4j
         Neo4j::Node.exist?(self)
       end
 
-      # Tries to load the wrapper object for this node by calling the class #wrapper method.
-      # This allows you to create a custom Ruby wrapper class around the Neo4j::Node.
-      # This is for example done in the <tt>neo4j<//t> ruby gem <tt>Neo4j::NodeMixin</tt>
-      # @return a wrapper object or self
-      def wrapper
-        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
-      end
-
+      # Overrides the class so that the java object feels like a Ruby object.
       def class
         Neo4j::Node
       end

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

@@ -70,12 +70,6 @@ module Neo4j
         Neo4j::Relationship.exist?(self)
       end
 
-      # Loads the wrapper using the #wrapper class method if it exists, otherwise return self.
-      def wrapper
-        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
-      end
-
-
       # Returns the relationship name
       #
       # @example

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/neo4j-core/wrapper/class_methods.rb

@@ -0,0 +1,22 @@
+module Neo4j
+  module Core
+    module Wrapper
+      module ClassMethods
+
+        # Tries to load a wrapper for this node if possible
+        # @see #wrapper_proc=
+        def wrapper(entity)
+          @_wrapper_proc ? @_wrapper_proc.call(entity) : entity
+        end
+
+        # Sets the procs to be used to load wrappers
+        # @see #wrapper
+        def wrapper_proc=(proc)
+          @_wrapper_proc = proc
+        end
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Neo4j
+  module Core
+    # Can be used to define your own wrapper class around nodes and relationships
+    module Wrapper
+
+      # @return [self, Object] return self or a wrapper Ruby object
+      # @see  Neo4j::Node::ClassMethods#wrapper
+      def wrapper
+        self.class.wrapper(self)
+      end
+    end
+  end
+end

data/lib/neo4j/node.rb

@@ -11,12 +11,14 @@ module Neo4j
   #
   class Node
     extend Neo4j::Core::Node::ClassMethods
+    extend Neo4j::Core::Wrapper::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
 
     class << self
 
@@ -29,6 +31,7 @@ module Neo4j
           include Neo4j::Core::Traversal
           include Neo4j::Core::Equal
           include Neo4j::Core::Node
+          include Neo4j::Core::Wrapper
         end
       end
     end

data/lib/neo4j/relationship.rb

@@ -33,9 +33,12 @@ module Neo4j
   #
   class Relationship
     extend Neo4j::Core::Relationship::ClassMethods
+    extend Neo4j::Core::Wrapper::ClassMethods
+
     include Neo4j::Core::Property
     include Neo4j::Core::Equal
     include Neo4j::Core::Relationship
+    include Neo4j::Core::Wrapper
 
     # (see Neo4j::Core::Relationship::ClassMethods#new)
     def initialize(rel_type, start_node, end_node, props={})
@@ -48,6 +51,7 @@ module Neo4j
           include Neo4j::Core::Property
           include Neo4j::Core::Equal
           include Neo4j::Core::Relationship
+          include Neo4j::Core::Wrapper
         end
       end
 

metadata

@@ -2,7 +2,7 @@
 name: neo4j-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-21 00:00:00 Z
+date: 2012-03-22 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -64,6 +64,8 @@ files:
   - lib/neo4j-core/traversal/evaluator.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