neo4j 1.0.0.beta.21-java

data/lib/neo4j/relationship.rb

@@ -0,0 +1,169 @@
+module Neo4j
+
+  org.neo4j.kernel.impl.core.RelationshipProxy.class_eval do
+    include Neo4j::Property
+    include Neo4j::Equal
+
+    alias_method :_end_node, :getEndNode
+    alias_method :_start_node, :getStartNode
+    alias_method :_other_node, :getOtherNode
+
+
+    def del
+      delete
+    end
+
+    def end_node # :nodoc:
+      getEndNode.wrapper
+    end
+
+    def start_node # :nodoc:
+      getStartNode.wrapper
+    end
+
+    def other_node(node) # :nodoc:
+      getOtherNode(node._java_node).wrapper
+    end
+
+
+    # same as _java_rel
+    # Used so that we have same method for both relationship and nodes
+    def wrapped_entity
+      self
+    end
+
+    def _java_rel
+      self
+    end
+
+
+    # Returns true if the relationship exists
+    def exist?
+      Neo4j::Relationship.exist?(self)
+    end
+
+    # Loads the Ruby wrapper for this node
+    # If there is no _classname property for this node then it will simply return itself.
+    # Same as Neo4j::Node.load_wrapper(node)
+    def wrapper
+      self.class.wrapper(self)
+    end
+
+
+    # Returns the relationship name
+    #
+    # ====Example
+    #   a = Neo4j::Node.new
+    #   a.outgoing(:friends) << Neo4j::Node.new
+    #   a.rels.first.rel_type # => 'friends'
+    #
+    def rel_type
+      getType().name()
+    end
+
+    def class
+      Neo4j::Relationship
+    end
+
+  end
+
+  #
+  # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
+  # You can attach properties to relationships with the API specified in Neo4j::JavaPropertyMixin.
+  #
+  # Relationship are created by invoking the << operator on the rels method on the node as follow:
+  #  node.outgoing(:friends) << other_node << yet_another_node
+  #
+  # or using the Neo4j::Relationship#new method (which does the same thing):
+  #  rel = Neo4j::Relationship.new(:friends, node, other_node)
+  #
+  # The fact that the relationship API gives meaning to start and end nodes implicitly means that all relationships have a direction.
+  # In the example above, rel would be directed from node to otherNode.
+  # A relationship's start node and end node and their relation to outgoing and incoming are defined so that the assertions in the following code are true:
+  #
+  #   a = Neo4j::Node.new
+  #   b = Neo4j::Node.new
+  #   rel = Neo4j::Relationship.new(:some_type, a, b)
+  #   # Now we have: (a) --- REL_TYPE ---> (b)
+  #
+  #    rel.start_node # => a
+  #    rel.end_node   # => b
+  #
+  # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
+  # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-null nodes.
+  #
+  # See also the Neo4j::RelationshipMixin if you want to wrap a relationship with your own Ruby class.
+  #
+  # === Included Mixins
+  # * Neo4j::Property
+  # * Neo4j::Equal
+  #
+  # (Those mixin are actually not included in the Neo4j::Relationship but instead directly included in the java class org.neo4j.kernel.impl.core.RelationshipProxy)
+  #
+  class Relationship
+    extend Neo4j::Index::ClassMethods
+
+    self.rel_indexer self
+
+    class << self
+      include Neo4j::Load
+      include Neo4j::ToJava
+
+
+      # Returns a org.neo4j.graphdb.Relationship java object (!)
+      # Will trigger a event that the relationship was created.
+      #
+      # === Parameters
+      # type :: the type of relationship
+      # from_node :: the start node of this relationship
+      # end_node  :: the end node of this relationship
+      # props :: optional properties for the created relationship
+      #
+      # === Returns
+      # org.neo4j.graphdb.Relationship java object
+      #
+      # === Examples
+      #
+      #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
+      #
+      def new(type, from_node, to_node, props=nil)
+        java_type = type_to_java(type)
+        rel = from_node._java_node.create_relationship_to(to_node._java_node, java_type)
+        props.each_pair {|k,v| rel[k] = v} if props
+        rel
+      end
+
+      # create is the same as new
+      alias_method :create, :new
+
+      # Loads a relationship or wrapped relationship given a native java relationship or an id.
+      # If there is a Ruby wrapper for the node then it will create a Ruby object that will
+      # wrap the java node (see Neo4j::RelationshipMixin).
+      #
+      # If the relationship does not exist it will return nil
+      #
+      def load(rel_id, db = Neo4j.started_db)
+        rel = _load(rel_id, db)
+        return nil if rel.nil?
+        rel.wrapper
+      end
+
+      # Same as load but does not return the node as a wrapped Ruby object.
+      #
+      def _load(rel_id, db)
+        rel = db.graph.get_relationship_by_id(rel_id.to_i)
+        rel.hasProperty('_classname')  # since we want a IllegalStateException which is otherwise not triggered
+        rel
+      rescue java.lang.IllegalStateException
+        nil # the node has been deleted
+      rescue org.neo4j.graphdb.NotFoundException
+        nil
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/neo4j/relationship_mixin.rb

@@ -0,0 +1,4 @@
+module Neo4j
+  # make an alias so that we don't have to write the long name Neo4j::Mapping::Relationship
+  RelationshipMixin = Neo4j::Mapping::RelationshipMixin
+end

data/lib/neo4j/relationship_traverser.rb

@@ -0,0 +1,92 @@
+module Neo4j
+
+  class RelationshipTraverser
+    include Enumerable
+    include ToJava
+
+    def initialize(node, types, direction)
+      @node      = node
+      if types.size > 1
+        @types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
+      elsif types.size == 1
+        @type = type_to_java(types[0])
+      end
+      @direction = direction
+    end
+
+    def to_s
+      if @type
+        "#{self.class} [type: #{@type} dir:#{@direction}]"
+      elsif @types
+        "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
+      else
+        "#{self.class} [types: ANY dir:#{@direction}]"
+      end
+    end
+
+    def each
+      iter = iterator
+      while (iter.hasNext())
+        rel = iter.next
+        yield rel.wrapper if match_to_other?(rel)
+      end
+    end
+
+    def empty?
+      first == nil
+    end
+    
+    def iterator
+      if @types
+        @node.get_relationships(@types).iterator
+      elsif @type
+        @node.get_relationships(@type, dir_to_java(@direction))
+      else
+        @node.get_relationships(dir_to_java(@direction))
+      end
+    end
+
+    def match_to_other?(rel)
+      if @to_other.nil?
+        true
+      elsif @direction == :outgoing
+        rel._end_node == @to_other
+      elsif @direction == :incoming
+        rel._start_node == @to_other
+      else
+        rel._start_node == @to_other || rel._end_node == @to_other
+      end
+    end
+
+    def to_other(to_other)
+      @to_other = to_other
+      self
+    end
+
+    def del
+      each { |rel| rel.del }
+    end
+
+    def size
+      [*self].size
+    end
+
+    def both
+      @direction = :both
+      self
+    end
+
+    def incoming
+      raise "Not allowed calling incoming when finding several relationships types" if @types
+      @direction = :incoming
+      self
+    end
+
+    def outgoing
+      raise "Not allowed calling outgoing when finding several relationships types" if @types
+      @direction = :outgoing
+      self
+    end
+
+  end
+end

data/lib/neo4j/to_java.rb

@@ -0,0 +1,31 @@
+module Neo4j
+  module ToJava
+
+    def type_to_java(type)
+      org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+    end
+
+    def dir_to_java(dir)
+      case dir
+        when :outgoing then org.neo4j.graphdb.Direction::OUTGOING
+        when :both     then org.neo4j.graphdb.Direction::BOTH
+        when :incoming then org.neo4j.graphdb.Direction::INCOMING
+        else raise "unknown direction '#{dir}', expects :outgoing, :incoming or :both"
+      end
+    end
+  end
+end
+
+
+org.neo4j.kernel.impl.core.IntArrayIterator.class_eval do
+  def each_wrapped
+    while(hasNext())
+      yield self.next().wrapper
+    end
+  end
+
+  def wrapped
+    Enumerator.new(self, :each_wrapped)
+  end
+
+end

data/lib/neo4j/transaction.rb

@@ -0,0 +1,68 @@
+module Neo4j
+  #
+  # All modifying operations that work with the node space must be wrapped in a transaction. Transactions are thread confined.
+  # Neo4j does not implement true nested transaction, instead it uses flat nested transactions
+  # see http://wiki.neo4j.org/content/Flat_nested_transactions
+  #
+  class Transaction
+
+    # Starts a new Neo4j Transaction
+    # Returns a Java Neo4j Transaction object
+    # See http://api.neo4j.org/current/org/neo4j/graphdb/Transaction.html
+    #
+    # Example:
+    #  tx = Neo4j::Transaction.new
+    #  # modify something
+    #  tx.success
+    #  tx.finish
+    def self.new(instance = Neo4j.started_db)
+      instance.begin_tx
+    end
+
+    # Runs a block in a Neo4j transaction
+    #
+    # Many operations on neo requires an transaction. You will get much better performance if
+    # one transaction is wrapped around several neo operation instead of running one transaction per
+    # neo operation.
+    # If one transaction is already running then a 'placebo' transaction will be created.
+    # Performing a finish on a placebo transaction will not finish the 'real' transaction.
+    #
+    # ==== Params
+    # ::yield:: the block to be performed in one transaction
+    #
+    # ==== Examples
+    #  include 'neo4j'
+    #
+    #  Neo4j::Transaction.run {
+    #    node = PersonNode.new
+    #  }
+    #
+    # You have also access to transaction object
+    #
+    #   Neo4j::Transaction.run { |t|
+    #     # something failed
+    #     t.failure # will cause a rollback
+    #   }
+
+    # If an exception occurs inside the block the transaction will rollback automatically
+    #
+    # ==== Returns
+    # The value of the evaluated provided block
+    #
+    def self.run # :yield: block that will be executed in a transaction
+      raise ArgumentError.new("Expected a block to run in Transaction.run") unless block_given?
+
+      begin
+        tx = Neo4j::Transaction.new
+        ret = yield tx
+        tx.success
+      rescue Exception
+        tx.failure unless tx.nil?
+        raise
+      ensure
+        tx.finish unless tx.nil?
+      end
+      ret
+    end
+  end
+end

data/lib/neo4j/type_converters.rb

@@ -0,0 +1,117 @@
+module Neo4j
+
+  # Responsible for converting values from and to Java Neo4j and Lucene.
+  # You can implement your own converter by implementing the method <tt>to_java</tt> and <tt>to_ruby</tt>
+  # and add it to the Neo4j::Config with the key <tt>:converters</tt>
+  #
+  # There are currently two default converters that are triggered when a Date or a DateTime is read or written.
+  #
+  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
+  	
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+        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
+        end
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
+        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
+    		# Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          value.utc.to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+    	end
+    end
+
+    class << self
+			# Always returns a converter that handles to_ruby or to_java
+			def converter(type = nil)
+				Neo4j.converters[type] || 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.
+			# It will convert it if there is a converter registered (in Neo4j::Config) for this value.
+			def convert(value, attribute = nil, klass = nil)
+				converter(attribute_type(value, attribute, klass)).to_java(value)
+			end
+	
+			# Converts the given property (key, value) to Java by using configuration from the given class.
+			# 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 by using configuration from the given class.
+			# 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