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

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

@@ -61,11 +61,11 @@ module Neo4j
         end
 
         # Loads a node or wrapped node given a native java node or an id.
-        # If there is a Ruby wrapper for the node then it will create and return a Ruby object that will
-        # wrap the java node.
+        # If there is a Ruby wrapper for the node then it will create a Ruby object that will
+        # wrap the java node (see Neo4j::NodeMixin).
+        # To implement a wrapper you must implement a wrapper class method in the Neo4j::Node or Neo4j::Relationship.
         #
-        # @param [nil, #to_i] node_id the neo4j node id
-        # @return [Object, Neo4j::Node, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
+        # @return [Object, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
         def load(node_id, db = Neo4j.started_db)
           node = _load(node_id, db)
           node && node.wrapper

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

@@ -31,7 +31,14 @@ module Neo4j
         Neo4j::Node.exist?(self)
       end
 
-      # Overrides the class so that the java object feels like a Ruby object.
+      # 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
+
       def class
         Neo4j::Node
       end

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

@@ -5,7 +5,9 @@ module Neo4j
       # @return [Hash] all properties plus the id of the node with the key <tt>_neo_id</tt>
       def props
         ret = {"_neo_id" => neo_id}
-        property_keys.each do |key|
+        iter = get_property_keys.iterator
+        while (iter.hasNext) do
+          key = iter.next
           ret[key] = get_property(key)
         end
         ret

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

@@ -3,19 +3,16 @@ module Neo4j
     module Relationship
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getEndNode
-      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getEndNode()
       def _end_node
         get_end_node
       end
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getStartNode
-      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getStartNode()
       def _start_node
         get_start_node
       end
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getOtherNode
-      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getOtherNode()
       def _other_node(node)
         get_other_node(node)
       end
@@ -52,7 +49,6 @@ module Neo4j
       #
       # @param [Neo4j::Node] node the node that we don't want to return
       # @return [Neo4j::Node] the other node wrapper
-      # @see #_other_node
       def other_node(node)
         _other_node(node._java_node).wrapper
       end
@@ -60,7 +56,7 @@ module Neo4j
 
       # same as #_java_rel
       # Used so that we have same method for both relationship and nodes
-      def _java_entity
+      def wrapped_entity
         self
       end
 
@@ -74,15 +70,21 @@ 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
       #   a = Neo4j::Node.new
       #   a.outgoing(:friends) << Neo4j::Node.new
-      #   a.rels.first.rel_type # => :friends
-      # @return [Symbol] the type of the relationship
+      #   a.rels.first.rel_type # => 'friends'
+      # @return [String] the type of the relationship
       def rel_type
-        getType().name().to_sym
+        getType().name()
       end
 
       def class

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

@@ -2,8 +2,6 @@ module Neo4j
   module Core
     # Contains methods for traversing relationship object of depth one from one node.
     module Rels
-
-
       # Returns the only node of a given type and direction that is attached to this node, or nil.
       # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node.
       # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an exception.
@@ -78,9 +76,7 @@ module Neo4j
       #
       # @see Neo4j::Core::Node#wrapper #wrapper - The method used wrap to the node in a Ruby object if the node was found
       # @see Neo4j::Relationship#rel_type
-      # @raise an exception if the first parameter is not <tt>:both</tt>, <tt>;outgoing</tt> or <tt>:incoming</tt>
-      def rels(dir=:both, *types)
-        raise "Illegal argument, first argument must be :both, :incoming or :outgoing, got #{dir.inspect}" unless [:incoming, :outgoing, :both].include?(dir)
+      def rels(dir, *types)
         Neo4j::Core::Rels::Traverser.new(self, types, dir)
       end
 
@@ -118,15 +114,14 @@ module Neo4j
       # @return [Enumerable] of Neo4j::Relationship objects
       def _rels(dir=:both, *types)
         if types.size > 1
-          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types)).iterator
+          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types))
         elsif types.size == 1
-          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir)).iterator
+          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir))
         else
-          get_relationships(ToJava.dir_to_java(dir)).iterator
+          get_relationships(ToJava.dir_to_java(dir))
         end
       end
 
-
       # Check if the given relationship exists
       # Returns true if there are one or more relationships from this node to other nodes
       # with the given relationship.

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

@@ -26,8 +26,10 @@ module Neo4j
 
         # Implements the Ruby Enumerable mixin
         def each
-          iterator.each do |rel|
-            yield rel.wrapper if match_between?(rel)
+          iter = iterator
+          while (iter.has_next())
+            rel = iter.next
+            yield rel.wrapper if match_to_other?(rel)
           end
         end
 
@@ -41,30 +43,42 @@ module Neo4j
           @node._rels(@dir, *@types)
         end
 
+        # @return [Fixnum] the size of all matched relationship, also check if it #to_other node
+        # @see #to_other
+        def size
+          c = 0
+          iter = iterator
+          while (iter.has_next())
+            rel = iter.next
+            next unless match_to_other?(rel)
+            c += 1
+          end
+          c
+        end
+
+
         # @return [true,false] true if it match the specified other node
-        # @see #between
-        def match_between?(rel)
-          if @between.nil?
+        # @see #to_other
+        def match_to_other?(rel)
+          if @to_other.nil?
             true
           elsif @dir == :outgoing
-            rel._end_node == @between
+            rel._end_node == @to_other
           elsif @dir == :incoming
-            rel._start_node == @between
+            rel._start_node == @to_other
           else
-            rel._start_node == @between || rel._end_node == @between
+            rel._start_node == @to_other || rel._end_node == @to_other
           end
         end
 
         # Specifies that we only want relationship to the given node
-        # @param [Neo4j::Node] between a node or an object that implements the Neo4j::Core::Equal mixin
+        # @param [Neo4j::Node] to_other a node or an object that implements the Neo4j::Core::Equal mixin
         # @return self
-        def between(between)
-          @between = between
+        def to_other(to_other)
+          @to_other = to_other
           self
         end
 
-        alias_method :to_other, :between
-        
         # Deletes all the relationships
         def del
           each { |rel| rel.del }

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

@@ -1,9 +1,9 @@
 module Neo4j
   module Core
 
+    # Implements the Neo4j PruneEvaluator Java interface, only used internally.
+    # @private
     module Traversal
-      # Implements the Neo4j PruneEvaluator Java interface, only used internally.
-      # @private
       class PruneEvaluator
         include Java::OrgNeo4jGraphdbTraversal::PruneEvaluator
 

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

@@ -2,54 +2,6 @@ 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
@@ -65,27 +17,14 @@ 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
-            raise "Illegal direction #{dir.inspect}, expected :outgoing, :incoming or :both"
+            @type = type_to_java(type)
+            @dir = dir_to_java(dir)
+            @td = Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
           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
@@ -173,19 +112,11 @@ module Neo4j
         end
 
         def to_s
-          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth}"
+          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
         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)
@@ -199,49 +130,25 @@ 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 = {})
-          @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)
+          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
         end
 
         # @param (see Neo4j::Core::Traversal#both)
         # @see Neo4j::Core::Traversal#both
         def both(type)
-          @both_rel_types ||= []
-          @both_rel_types << type
-          _add_rel(:both, type)
+          @type = type_to_java(type) if type
+          @dir = dir_to_java(:both)
+          @td = @td.relationships(type_to_java(type), @dir)
           self
         end
 
@@ -258,9 +165,9 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#outgoing
         def outgoing(type)
-          @outgoing_rel_types ||= []
-          @outgoing_rel_types << type
-          _add_rel(:outgoing, type)
+          @type = type_to_java(type) if type
+          @dir = dir_to_java(:outgoing)
+          @td = @td.relationships(type_to_java(type), @dir)
           self
         end
 
@@ -269,19 +176,12 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#incoming
         def incoming(type)
-          @incoming_rel_types ||= []
-          @incoming_rel_types << type
-          _add_rel(:incoming, type)
+          @type = type_to_java(type) if type
+          @dir = dir_to_java(:incoming)
+          @td = @td.relationships(type_to_java(type), @dir)
           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
@@ -328,6 +228,12 @@ module Neo4j
           self
         end
 
+        #def size
+        #  s = 0
+        #  iterator.each { |_| s += 1 }
+        #  s
+        #end
+
         # @param [Fixnum] index the n'th node that will be return from the traversal
         def [](index)
           each_with_index { |node, i| break node if index == i }
@@ -389,7 +295,6 @@ module Neo4j
           end
 
         end
-
       end
     end
   end

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

@@ -0,0 +1,287 @@
+module Neo4j
+
+  # Responsible for converting values from and to Java Neo4j and Lucene.
+  # You can implement your own converter by implementing the method <tt>convert?</tt>
+  # <tt>to_java</tt> and <tt>to_ruby</tt> in this module.
+  #
+  # There are currently three default converters that are triggered when a Time, Date or a DateTime is read or written
+  # if there is a type declared for the property.
+  #
+  # ==== Example
+  #
+  # Example of writing your own marshalling converter:
+  #
+  #  class Foo
+  #     include Neo4j::NodeMixin
+  #     property :thing, :type => MyType
+  #  end
+  #
+  #  module Neo4j::TypeConverters
+  #    class MyTypeConverter
+  #      class << self
+  #        def convert?(type)
+  #          type == MyType
+  #        end
+  #
+  #        def to_java(val)
+  #          "silly:#{val}"
+  #        end
+  #
+  #        def to_ruby(val)
+  #          val.sub(/silly:/, '')
+  #        end
+  #      end
+  #    end
+  #  end
+  #
+  module TypeConverters
+
+    # The default converter to use if there isn't a specific converter for the type
+    class DefaultConverter
+      class << self
+
+        def to_java(value)
+          value
+        end
+
+        def to_ruby(value)
+          value
+        end
+      end
+    end
+
+
+    class BooleanConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          :boolean == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          !!value && value != '0'
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          !!value && value != '0'
+        end
+      end
+    end
+
+    class SymbolConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          :symbol == class_or_symbol || Symbol == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_sym
+        end
+      end
+    end
+
+
+    class StringConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          [String, :string, :text].include? class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_s
+        end
+      end
+    end
+
+
+
+    class FixnumConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          Fixnum == class_or_symbol || :fixnum == class_or_symbol || :numeric == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_i
+        end
+      end
+    end
+
+    class FloatConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Float == clazz_or_symbol || :float == clazz_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_f
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_f
+        end
+      end
+    end
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Date == clazz_or_symbol || :date == clazz_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc.to_date
+        end
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          DateTime == clazz_or_symbol || :datetime == clazz_or_symbol
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          t = Time.at(value).utc
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+      end
+    end
+
+    class TimeConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Time == clazz_or_symbol || :time == clazz_or_symbol
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            value.utc.to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+      end
+    end
+
+    class << self
+
+      # Mostly for testing purpose, You can use this method in order to
+      # add a converter while the neo4j has already started.
+      def converters=(converters)
+        @converters = converters
+      end
+      
+      # Always returns a converter that handles to_ruby or to_java
+      # if +enforce_type+ is set to false then it will raise in case of unknown type
+      # otherwise it will return the DefaultConverter.
+      def converter(type = nil, enforce_type = true)
+        return DefaultConverter unless type
+        @converters ||= begin
+          Neo4j::TypeConverters.constants.find_all do |c|
+            Neo4j::TypeConverters.const_get(c).respond_to?(:convert?)
+          end.map do  |c|
+            Neo4j::TypeConverters.const_get(c)
+          end
+        end
+        found = @converters.find {|c| c.convert?(type) }
+        raise "The type #{type.inspect} is unknown. Use one of #{@converters.map{|c| c.name }.join(", ")} or create a custom type converter." if !found && enforce_type
+        found or DefaultConverter
+      end
+
+      # Converts the given value to a Java type by using the registered converters.
+      # It just looks at the class of the given value unless an attribute name is given.
+      def convert(value, attribute = nil, klass = nil, enforce_type = true)
+        converter(attribute_type(value, attribute, klass), enforce_type).to_java(value)
+      end
+
+      # Converts the given property (key, value) to Java if there is a type converter for given type.
+      # The type must also be declared using Neo4j::NodeMixin#property property_name, :type => clazz
+      # If no Converter is defined for this value then it simply returns the given value.
+      def to_java(clazz, key, value)
+        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
+        converter(type).to_java(value)
+      end
+
+      # Converts the given property (key, value) to Ruby if there is a type converter for given type.
+      # If no Converter is defined for this value then it simply returns the given value.
+      def to_ruby(clazz, key, value)
+        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
+        converter(type).to_ruby(value)
+      end
+
+      private
+      def attribute_type(value, attribute = nil, klass = nil)
+        type = (attribute && klass) ? attribute_type_from_attribute_and_klass(value, attribute, klass) : nil
+        type || attribute_type_from_value(value)
+      end
+
+      def attribute_type_from_attribute_and_klass(value, attribute, klass)
+        if klass.respond_to?(:_decl_props)
+          (klass._decl_props.has_key?(attribute) && klass._decl_props[attribute][:type]) ? klass._decl_props[attribute][:type] : nil
+        end
+      end
+
+      def attribute_type_from_value(value)
+        value.class
+      end
+    end
+  end
+end