neo4j-core 0.0.9-java → 0.0.10-java

data/lib/neo4j-core.rb

@@ -64,4 +64,4 @@ require 'neo4j-core/cypher/result_wrapper'
 require 'neo4j/algo'
 require 'neo4j/cypher'
 require 'neo4j/node'
-require 'neo4j/relationship'
+require 'neo4j/relationship'

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

@@ -170,6 +170,24 @@ module Neo4j
           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]
@@ -665,6 +683,7 @@ module Neo4j
         def initialize(expressions, variables)
           @var_name = "v#{variables.size}"
           variables << self
+          @variables = variables
           @expressions = expressions
         end
 

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

@@ -21,18 +21,7 @@ module Neo4j
         #        trigger_on :ntype => 'foo', :name => ['bar', 'foobar']
         #
         #        prefix_index_name do
-        #          return "" unless Neo4j.running?
-        #          return "" unless @indexer_for.respond_to?(:ref_node_for_class)
-        #          ref_node = @indexer_for.ref_node_for_class.wrapper
-        #          prefix = ref_node.send(:_index_prefix) if ref_node.respond_to?(:_index_prefix)
-        #          prefix ||= ref_node[:name] # To maintain backward compatiblity
-        #          prefix.blank? ? "" : prefix + "_"
-        #         end
-        #
-        #
-        #        numeric do
-        #           type = decl_props && decl_props[field.to_sym] && decl_props[field.to_sym][:type]
-        #           type && !type.is_a?(String)
+        #          "Foo"  # this is used for example in multitenancy to let each domain have there own index files
         #        end
         #      end
         #   end
@@ -64,6 +53,17 @@ module Neo4j
           @_indexer ||= IndexerRegistry.instance.register(Indexer.new(index_config))
         end
 
+        # You can specify which nodes should be triggered.
+        # The index can be triggered by one or more properties having one or more values.
+        # This can also be done using the #node_indexer or #rel_indexer methods.
+        #
+        # @example trigger on property :type being 'MyType1'
+        #   Neo4j::NodeIndex.trigger_on(:type => 'MyType1')
+        #
+        def trigger_on(hash)
+          _config.trigger_on(hash)
+        end
+
 
         class << self
           private

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

@@ -2,7 +2,7 @@ module Neo4j
   module Core
 
     # A mixin which adds indexing behaviour to your own Ruby class
-    # You are expected to implement the method `wrapped_entity` returning the underlying Neo4j Node or Relationship
+    # You are expected to implement the method `java_entity` returning the underlying Neo4j Node or Relationship.
     module Index
 
       # Adds an index on the given property
@@ -16,7 +16,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#add_index
       #
       def add_index(field, value=self[field])
-        self.class.add_index(wrapped_entity, field.to_s, value)
+        self.class.add_index(java_entity, field.to_s, value)
       end
 
       # Removes an index on the given property.
@@ -26,7 +26,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#rm_index
       #
       def rm_index(field, value=self[field])
-        self.class.rm_index(wrapped_entity, field.to_s, value)
+        self.class.rm_index(java_entity, field.to_s, value)
       end
 
     end

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

@@ -60,7 +60,7 @@ module Neo4j
 
       # same as #_java_rel
       # Used so that we have same method for both relationship and nodes
-      def wrapped_entity
+      def java_entity
         self
       end
 

data/lib/neo4j-core/rels/traverser.rb

@@ -29,7 +29,7 @@ module Neo4j
           iter = iterator
           while (iter.has_next())
             rel = iter.next
-            yield rel.wrapper if match_to_other?(rel)
+            yield rel.wrapper if match_between?(rel)
           end
         end
 
@@ -44,27 +44,29 @@ module Neo4j
         end
 
         # @return [true,false] true if it match the specified other node
-        # @see #to_other
-        def match_to_other?(rel)
-          if @to_other.nil?
+        # @see #between
+        def match_between?(rel)
+          if @between.nil?
             true
           elsif @dir == :outgoing
-            rel._end_node == @to_other
+            rel._end_node == @between
           elsif @dir == :incoming
-            rel._start_node == @to_other
+            rel._start_node == @between
           else
-            rel._start_node == @to_other || rel._end_node == @to_other
+            rel._start_node == @between || rel._end_node == @between
           end
         end
 
         # Specifies that we only want relationship to the given node
-        # @param [Neo4j::Node] to_other a node or an object that implements the Neo4j::Core::Equal mixin
+        # @param [Neo4j::Node] between a node or an object that implements the Neo4j::Core::Equal mixin
         # @return self
-        def to_other(to_other)
-          @to_other = to_other
+        def between(between)
+          @between = between
           self
         end
 
+        alias_method :to_other, :between
+        
         # Deletes all the relationships
         def del
           each { |rel| rel.del }

data/lib/neo4j-core/traversal/traverser.rb

@@ -2,6 +2,54 @@ module Neo4j
   module Core
     module Traversal
 
+      class CypherQuery
+        include Enumerable
+        attr_accessor :query, :return_variable
+
+        def initialize(start_id, dir, types, query_hash=nil, &block)
+          this = self
+
+          rel_type = ":#{types.map{|x| "`#{x}`"}.join('|')}"
+
+          @query = Neo4j::Cypher.new do
+            default_ret = node(:default_ret)
+            n = node(start_id)
+            case dir
+              when :outgoing then
+                n > rel_type > default_ret
+              when :incoming then
+                n < rel_type < default_ret
+              when :both then
+                n - rel_type - default_ret
+            end
+
+            # where statement
+            ret_maybe = block && self.instance_exec(default_ret, &block)
+            ret = ret_maybe.respond_to?(:var_name) ? ret_maybe : default_ret
+            if query_hash
+              expr = []
+              query_hash.each{|pair|  expr << (ret[pair[0]] == pair[1])}.to_a
+              expr.each_with_index do |obj, i|
+                Neo4j::Core::Cypher::ExprOp.new(obj, expr[i+1], "and") if i < expr.size - 1
+              end
+            end
+
+            this.return_variable = ret.var_name.to_sym
+            ret
+          end.to_s
+        end
+
+        def to_s
+          @query
+        end
+
+        def each
+          Neo4j._query(query).each do |r|
+            yield r[return_variable]
+          end
+        end
+      end
+
       # By using this class you can both specify traversals and create new relationships.
       # This object is return from the Neo4j::Core::Traversal methods.
       # @see Neo4j::Core::Traversal#outgoing
@@ -17,14 +65,27 @@ module Neo4j
           if type.nil?
             raise "Traversing all relationship in direction #{dir.inspect} not supported, only :both supported" unless dir == :both
             @td = Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first()
+          elsif (dir == :both)
+            both(type)
+          elsif (dir == :incoming)
+            incoming(type)
+          elsif (dir == :outgoing)
+            outgoing(type)
           else
-            @type = type_to_java(type)
-            @dir = dir_to_java(dir)
-            @td = Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
+            raise "Illegal direction #{dir.inspect}, expected :outgoing, :incoming or :both"
           end
         end
 
 
+        def query(query_hash = nil, &block)
+          # only one direction is supported
+          rel_types = [@outgoing_rel_types, @incoming_rel_types, @both_rel_types].find_all { |x| !x.nil? }
+          raise "Only one direction is allowed, outgoing:#{@outgoing_rel_types}, incoming:#{@incoming_rel_types}, @both:#{@both_rel_types}" if rel_types.count != 1
+          start_id = @from.neo_id
+          dir = (@outgoing_rel_types && :outgoing) || (@incoming_rel_types && :incoming) || (@both_rel_types && :both)
+          CypherQuery.new(start_id, dir, rel_types.first, query_hash, &block)
+        end
+
         # Sets traversing depth first.
         #
         # The <tt>pre_or_post</tt> parameter parameter can have two values: :pre or :post
@@ -112,11 +173,19 @@ module Neo4j
         end
 
         def to_s
-          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
+          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth}"
         end
 
 
         # Creates a new relationship between given node and self
+        # It can create more then one relationship
+        #
+        # @example One outgoing relationships
+        #   node.outgoing(:foo) << other_node
+        #
+        # @example Two outgoing relationships
+        #   node.outgoing(:foo).outgoing(:bar) << other_node
+        #
         # @param [Neo4j::Node] other_node the node to which we want to create a relationship
         # @return (see #new)
         def <<(other_node)
@@ -130,25 +199,49 @@ module Neo4j
         end
 
         # Creates a new relationship between self and given node.
+        # It can create more then one relationship
+        # This method is used by the <tt><<</tt> operator.
+        #
+        # @example create one relationship
+        #   node.outgoing(:bar).new(other_node, rel_props)
+        #
+        # @example two relationships
+        #   node.outgoing(:bar).outgoing(:foo).new(other_node, rel_props)
+        #
+        # @example both incoming and outgoing - two relationships
+        #   node.both(:bar).new(other_node, rel_props)
+        #
+        # @see #<<
         # @param [Hash] props properties of new relationship
         # @return [Neo4j::Relationship] the created relationship
         def new(other_node, props = {})
-          case @dir
-            when Java::OrgNeo4jGraphdb::Direction::OUTGOING
-              @from.create_relationship_to(other_node, @type).update(props)
-            when Java::OrgNeo4jGraphdb::Direction::INCOMING
-              other_node.create_relationship_to(@from, @type).update(props)
-            else
-              raise "Only allowed to create outgoing or incoming relationships (not #@dir)"
-          end
+          @outgoing_rel_types && @outgoing_rel_types.each { |type| _new_out(other_node, type, props) }
+          @incoming_rel_types && @incoming_rel_types.each { |type| _new_in(other_node, type, props) }
+          @both_rel_types && @both_rel_types.each { |type| _new_both(other_node, type, props) }
+        end
+
+        # @private
+        def _new_out(other_node, type, props)
+          @from.create_relationship_to(other_node, type_to_java(type)).update(props)
+        end
+
+        # @private
+        def _new_in(other_node, type, props)
+          other_node.create_relationship_to(@from, type_to_java(type)).update(props)
+        end
+
+        # @private
+        def _new_both(other_node, type, props)
+          _new_out(other_node, type, props)
+          _new_in(other_node, type, props)
         end
 
         # @param (see Neo4j::Core::Traversal#both)
         # @see Neo4j::Core::Traversal#both
         def both(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:both)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @both_rel_types ||= []
+          @both_rel_types << type
+          _add_rel(:both, type)
           self
         end
 
@@ -165,9 +258,9 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#outgoing
         def outgoing(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:outgoing)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @outgoing_rel_types ||= []
+          @outgoing_rel_types << type
+          _add_rel(:outgoing, type)
           self
         end
 
@@ -176,12 +269,19 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#incoming
         def incoming(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:incoming)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @incoming_rel_types ||= []
+          @incoming_rel_types << type
+          _add_rel(:incoming, type)
           self
         end
 
+        # @private
+        def _add_rel(dir, type)
+          t = type_to_java(type)
+          d = dir_to_java(dir)
+          @td = @td ? @td.relationships(t, d) : Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first().relationships(t, d)
+        end
+
         # Cuts of of parts of the traversal.
         # @yield [path]
         # @yieldparam [Java::OrgNeo4jGraphdb::Path] path the path which can be used to filter nodes
@@ -289,6 +389,7 @@ module Neo4j
           end
 
         end
+
       end
     end
   end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.9"
+    VERSION = "0.0.10"
   end
 end

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

@@ -8,6 +8,13 @@ module Neo4j
       def wrapper
         self.class.wrapper(self)
       end
+
+      # This can be implemented by a wrapper to returned the underlying java node or relationship.
+      # You can override this method in your own wrapper class.
+      # @return self
+      def java_entity
+        self
+      end
     end
   end
 end

data/lib/neo4j/node.rb

@@ -9,9 +9,26 @@ 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
@@ -20,6 +37,11 @@ module Neo4j
     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
 
@@ -33,6 +55,7 @@ module Neo4j
           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,17 +29,26 @@ 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)
@@ -47,6 +56,10 @@ module Neo4j
     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:
         java_clazz.class_eval do
@@ -54,6 +67,7 @@ module Neo4j
           include Neo4j::Core::Equal
           include Neo4j::Core::Relationship
           include Neo4j::Core::Wrapper
+          include Neo4j::Core::Index
         end
       end
 

metadata

@@ -2,7 +2,7 @@
 name: neo4j-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.9
+  version: 0.0.10
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-15 00:00:00 Z
+date: 2012-04-17 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community