neo4j 1.0.0.beta.1

data/lib/neo4j.old/jars.rb

@@ -0,0 +1,6 @@
+include Java
+
+module Neo4j
+  require 'neo4j/jars/neo4j-kernel-1.0.jar'
+  require 'neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar'
+end

data/lib/neo4j.old/mixins/java_list_mixin.rb

@@ -0,0 +1,139 @@
+module Neo4j::JavaListMixin
+
+  # --------------------------------------------------------------------------
+  # List methods
+  #
+
+
+  # Returns true if this nodes belongs to a list of the given name
+  #
+  def list?(list_name)
+    regexp = Regexp.new "_list_#{list_name}"
+    rels.both.find { |rel| regexp.match(rel.relationship_type.to_s) } != nil
+  end
+
+  # Returns one or more list of the given list_name and list_node.
+  # If the optional list_node parameter is given the specific list belonging to that list node will be returned (or nil)
+  # If only the list_name parameter is given the first list matching the given list_name will be returned.
+  # (There might be several list of the same name but from different list nodes.)
+  #
+  # ==== Returns
+  #
+  # The node but with the extra instance methods
+  # * next - the next node in the list
+  # * prev - the previous node in the list
+  # * head - the head node (the node that has the has_list method)
+  # * size (if the size optional parameter is given in the has_list class method)
+  #
+  # ==== Example
+  #  class Foo
+  #    include Neo4j::NodeMixin
+  #    has_list :baar
+  #  end
+  #
+  #  f = Foo.new
+  #  n1 = Neo4j::Node.new
+  #  n2 = Neo4j::Node.new
+  #  f.baar << n1 << n2
+  #
+  #  n2.list(:baar).next # => n1
+  #  n2.list(:baar).prev # => f
+  #  n2.list(:baar).head # => f
+  #
+  def list(list_name, list_node = nil)
+    if list_node
+      list_id = "_list_#{list_name}_#{list_node.neo_id}"
+      add_list_item_methods(list_id, list_name, list_node)
+    else
+      list_items = []
+      lists(list_name) {|list_item| list_items << list_item}
+      list_items[0]
+    end
+  end
+
+
+  # Returns an array of lists with the given names that this nodes belongs to.
+  # Expects a block to yield for each found list
+  # That block will be given one parameter - the node with the extra method (see #list method)
+  #
+  def lists(*list_names)
+    list_names.collect! {|n| n.to_sym}
+
+    rels.both.inject({}) do |res, rel|
+      rel_type = rel.relationship_type.to_s
+      md = /_list_(\w*)_(\d*)/.match(rel_type)
+      next res if md.nil?
+      next res unless list_names.empty? || list_names.include?(md[1].to_sym)
+      res[rel_type] = [md[1], Neo4j.load_node(md[2])]
+      res
+    end.each_pair do |rel_id, list_name_and_head_node|
+      yield self.add_list_item_methods(rel_id, list_name_and_head_node[0], list_name_and_head_node[1]) # clone ?
+    end
+  end
+
+
+  def add_list_item_methods(list_id, list_name, head_node) #:no_doc:
+    mod = Module.new do
+      define_method :head do
+        head_node
+      end
+
+      define_method :size do
+        head_node["_#{list_name}_size"] || 0
+      end
+
+      define_method :size= do |new_size|
+        head_node["_#{list_name}_size"] = new_size
+      end
+
+      define_method :next do
+        next_node = rels.outgoing(list_id).nodes.first
+        return nil if next_node.nil?
+        next_node.add_list_item_methods(list_id, list_name, head_node)
+        next_node
+      end
+
+      define_method :next= do |new_next|
+        # does it have a next pointer ?
+        next_rel = rels.outgoing(list_id).first
+        # delete the relationship if exists
+        next_rel.delete if (next_rel.nil?)
+        rels.outgoing(list_id) << new_next unless new_next.nil?
+        nil
+      end
+
+      define_method :prev do
+        prev_node = rels.incoming(list_id).nodes.first
+        return nil if prev_node.nil?
+        prev_node.add_list_item_methods(list_id, list_name, head_node)
+        prev_node
+      end
+
+      define_method :prev= do |new_prev|
+        # does it have a next pointer ?
+        prev_rel = rels.incoming(list_id).first
+        # delete the relationship if exists
+        prev_rel.delete if (prev_rel.nil?)
+        rels.outgoing(list_id) << new_prev unless new_prev.nil?
+        nil
+      end
+    end
+
+    self.extend mod
+  end
+
+  def add_list_head_methods(list_name) # :nodoc:
+    prop_name = "_#{list_name}_size".to_sym
+    mod = Module.new do
+      define_method :size do
+        self[prop_name] || 0
+      end
+
+      define_method :size= do |new_size|
+        self[prop_name]=new_size
+      end
+    end
+    self.extend mod
+  end
+  
+end

data/lib/neo4j.old/mixins/java_node_mixin.rb

@@ -0,0 +1,205 @@
+module Neo4j::JavaNodeMixin
+
+
+  # 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.
+  # It will not return true only because the relationship is defined.
+  #
+  # ==== Parameters
+  # rel_name<#to_s>:: the key and value to be set
+  # dir:: optional default :outgoing (either, :outgoing, :incoming, :both)
+  #
+  # ==== Returns
+  # true if one or more relationships exists for the given rel_name and dir
+  # otherwise false
+  #
+  def rel? (rel_name, dir=:outgoing)
+    type = org.neo4j.graphdb.DynamicRelationshipType.withName(rel_name.to_s)
+    java_dir = _to_java_direction(dir)
+    hasRelationship(type, java_dir)
+  end
+
+
+  # Returns a Neo4j::Relationships::RelationshipDSL object for accessing relationships from and to this node.
+  # The Neo4j::Relationships::RelationshipDSL is an Enumerable that returns Neo4j::RelationshipMixin objects.
+  #
+  # ==== Returns
+  # A Neo4j::Relationships::RelationshipDSL object
+  #
+  # ==== See Also
+  # * Neo4j::Relationships::RelationshipDSL
+  # * Neo4j::RelationshipMixin
+  #
+  # ==== Example
+  #
+  #   person_node.rels.outgoing(:friends).each { ... }
+  #
+  def rels(direction = :outgoing)
+    Neo4j::Relationships::RelationshipDSL.new(self, direction)
+  end
+
+  # Returns a single relationship or nil if none available.
+  # If there are more then one relationship of the given type it will raise an exception.
+  #
+  # ==== Parameters
+  # type<#to_s>:: the key and value to be set
+  # dir:: optional, default :outgoing (either, :outgoing, :incoming, :both)
+  # raw:: optional, true|false (false default). If false return the ruby wrapped relationship object instead of the raw java neo4j obejct.
+
+  #
+  # ==== Returns
+  # An object that mixins the Neo4j::RelationshipMixin representing the given relationship type or nil if there are no relationships.
+  # If there are more then one relationship it will raise an Exception (java exception of type org.neo4j.graphdb.NotFoundException)
+  #
+  # ==== See Also
+  # * JavaDoc for http://api.neo4j.org/current/org/neo4j/api/core/Node.html#getSingleRelationship(org.neo4j.graphdb.RelationshipType,%20org.neo4j.graphdb.Direction)
+  # * Neo4j::RelationshipMixin
+  #
+  # ==== Example
+  #
+  #   person_node.rel(:address).end_node[:street]
+  #
+  def rel(rel_name, dir=:outgoing, raw=false)
+    java_dir = _to_java_direction(dir)
+    rel_type = org.neo4j.graphdb.DynamicRelationshipType.withName(rel_name.to_s)
+    rel = getSingleRelationship(rel_type, java_dir)
+    return nil if rel.nil?
+    return rel.wrapper unless raw
+    rel
+  end
+
+
+  # Adds an outgoing relationship from this node to another node.
+  # Will trigger a relationship_created event.
+  #
+  # ==== Parameters
+  # type:: the relationship type between the nodes (respond_to :to_s)
+  # to:: the other node (Neo4j::Node || kind_of?(Neo4j::NodeMixin)
+  #
+  # ==== Returns
+  # a Neo4j::Relationship object
+  #
+  # === Example
+  # nodeA = Neo4j::Node.new
+  # nodeB = Neo4j::Node.new
+  # nodeA.add_rel(:friend, nodeB)
+  #
+
+  # all creation of relationships uses this method
+  def add_rel (type, to, rel_clazz = nil) # :nodoc:
+    java_type = org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+    java_rel = createRelationshipTo(to._java_node, java_type)
+    # check if we should create a wrapped Ruby Relationship class or use the raw java one.
+    rel = (rel_clazz.nil?) ?  java_rel : rel_clazz.new(java_rel)
+    Neo4j.event_handler.relationship_created(rel)
+    @_wrapper.class.indexer.on_relationship_created(@_wrapper, type) if @_wrapper
+    rel
+  end
+
+  def _to_java_direction(dir) # :nodoc:
+    case dir
+      when :outgoing
+        org.neo4j.graphdb.Direction::OUTGOING
+      when :incoming
+        org.neo4j.graphdb.Direction::INCOMING
+      when :both
+        org.neo4j.graphdb.Direction::BOTH
+      else
+        raise "Unknown parameter: '#{dir}', only accept :outgoing, :incoming or :both"
+    end
+  end
+
+
+  # Returns a Neo4j::Relationships::NodeTraverser object for traversing outgoing nodes from and to this node.
+  # The Neo4j::Relationships::NodeTraverser is an Enumerable that returns Neo4j::NodeMixin objects.
+  #
+  # ==== See Also
+  # Neo4j::Relationships::NodeTraverser
+  #
+  # ==== Example
+  #
+  #   person_node.outgoing(:friends).each { ... }
+  #   person_node.outgoing(:friends).raw(true).each { }
+  #
+  # The raw false parameter means that the ruby wrapper object will not be loaded, instead the raw Java Neo4j object will be used,
+  # it might improve the performance.
+  #
+  def outgoing(*args)
+    Neo4j::Relationships::NodeTraverser.new(self).outgoing(*args)
+  end
+
+  # Returns a Neo4j::Relationships::NodeTraverser object for traversing outgoing nodes from and to this node.
+  # The Neo4j::Relationships::NodeTraverser is an Enumerable that returns Neo4j::NodeMixin objects.
+  #
+  # ==== See Also
+  # Neo4j::Relationships::NodeTraverser
+  #
+  # ==== Example
+  #
+  #   person_node.incoming(:friends).each { ... }
+  #   person_node.incoming(:friends).raw(true).each { }
+  #
+  # The raw false parameter means that the ruby wrapper object will not be loaded, instead the raw Java Neo4j object will be used,
+  # it might improve the performance.
+  #
+  def incoming(*args)
+    Neo4j::Relationships::NodeTraverser.new(self).incoming(*args)
+  end
+
+
+  # Deletes this node.
+  # Deletes all relationships as well.
+  # Invoking any methods on this node after delete() has returned is invalid and may lead to unspecified behavior.
+  #
+  # :api: public
+  def del
+    Neo4j.event_handler.node_deleted(wrapper)
+
+    # delete outgoing relationships, and check for cascade delete
+    rels.outgoing.each { |r| r.del; r.end_node.del if r[:_cascade_delete_outgoing]}
+
+    rels.incoming.each do |r|
+      r.del
+      if r[:_cascade_delete_incoming]
+        node_id = r[:_cascade_delete_incoming]
+        node = Neo4j.load_node(node_id)
+        # check node has no outgoing relationships
+        no_outgoing = node.rels.outgoing.empty?
+        # check node has only incoming relationship with cascade_delete_incoming
+        no_incoming = node.rels.incoming.find{|r| !node.ignore_incoming_cascade_delete?(r)}.nil?
+        # only cascade delete incoming if no outgoing and no incoming (exception cascade_delete_incoming) relationships
+        node.del if no_outgoing and no_incoming
+      end
+    end
+    delete
+    @_wrapper.class.indexer.delete_index(self) if @_wrapper
+  end
+
+  # --------------------------------------------------------------------------
+  # Debug
+  #
+
+  # Used for debugging purpose, traverse the graph of given depth and direction and prints nodes and relationship information.
+  def print(levels = 0, dir = :outgoing)
+    print_sub(0, levels, dir)
+  end
+
+  def print_sub(level, max_level, dir) # :nodoc:
+    spaces = "  " * level
+    node_class = (self[:_classname].nil?) ? Neo4j::Node.to_s : self[:_classname]
+    node_desc = "#{spaces}neo_id=#{neo_id} #{node_class}"
+    props.each_pair {|key, value| next if %w[id].include?(key) or key.match(/^_/) ; node_desc << " #{key}='#{value}'"}
+    puts node_desc
+
+    if (level != max_level)
+      rels(dir).each do |rel|
+        cascade_desc = ""
+        cascade_desc << "cascade in: #{rel[:_cascade_delete_incoming]}" if rel.property?(:_cascade_delete_incoming)
+        cascade_desc << "cascade out: #{rel[:_cascade_delete_outgoing]}" if rel.property?(:_cascade_delete_outgoing)
+        rel.other_node(self).print_sub(level + 1, max_level, dir)
+      end
+    end
+  end
+
+end

data/lib/neo4j.old/mixins/java_property_mixin.rb

@@ -0,0 +1,169 @@
+module Neo4j::JavaPropertyMixin
+
+  # This is the property to use to map ruby classes to Neo4j Nodes
+  CLASSNAME_PROPERTY = "_classname"
+
+  # Returns the unique id of this node.
+  # Ids are garbage collected over time so are only guaranteed to be unique at a specific set of time: if the node is deleted,
+  # it's likely that a new node at some point will get the old id. Note: this make node ids brittle as public APIs.
+  def neo_id
+    getId
+  end
+
+  def _wrapper=(wrapper) # :nodoc:
+    @_wrapper = wrapper
+  end
+
+  def _java_node
+    self
+  end
+
+  # Returns true if this property container has a property accessible through the given key, false otherwise.
+  def property?(key)
+    has_property?(key.to_s)
+  end
+
+  # Returns the given property if it exist or nil if it does not exist.
+  def [](key)
+    return unless property?(key)
+    if @_wrapper and @_wrapper.class.marshal?(key)
+      Marshal.load(String.from_java_bytes(get_property(key.to_s)))
+    else
+      get_property(key.to_s)
+    end
+  end
+
+  # Sets the given property to given value.
+  # Will generate an event if the property does not start with '_' (which could be an internal property, like _classname)
+  #
+  def []=(key, value)
+    k = key.to_s
+    old_value = self[key]
+
+    if value.nil?
+      delete_property(k)
+    elsif @_wrapper and @_wrapper.class.marshal?(key)
+      setProperty(k, Marshal.dump(value).to_java_bytes)
+    else
+      value = java.lang.Double.new(value) if value.is_a? Float
+      setProperty(k, value)
+    end
+
+    if (@_wrapper and k[0, 1] != '_') # do not want events on internal properties
+      @_wrapper.class.indexer.on_property_changed(@_wrapper, k) if @_wrapper.class.respond_to? :indexer
+      Neo4j.event_handler.property_changed(@_wrapper, k, old_value, value)
+    end
+
+  end
+
+
+  # Removes the property from this node.
+  # This is same as setting a property value to nil.
+  #
+  # For more information see JavaDoc PropertyContainer#removeProperty
+  #
+  # ==== Example
+  #   a = Node.new
+  #   a[:foo] = 2
+  #   a.delete_property('foo')
+  #   a[:foo] # => nil
+  #
+  # ==== Returns
+  # <tt>true</tt> if the property was removed, <tt>false</tt> otherwise
+  #
+  def delete_property (name)
+    removed = !removeProperty(name).nil?
+    if (removed and @_wrapper and name[0] != '_') # do not want events on internal properties
+      @_wrapper.class.indexer.on_property_changed(self, name)
+    end
+    removed
+  end
+
+  # Returns a hash of all properties.
+  #
+  # === Returns
+  # Hash:: property key and property value with the '_neo_id' as the neo_id
+  #
+  def props
+    ret = {"_neo_id" => getId()}
+    iter = getPropertyKeys.iterator
+    while (iter.hasNext) do
+      key = iter.next
+      ret[key] = getProperty(key)
+    end
+    ret
+  end
+
+  # Updates this node/relationship's properties by using the provided struct/hash.
+  # If the option <code>{:strict => true}</code> is given, any properties present on
+  # the node but not present in the hash will be removed from the node.
+  #
+  # === Parameters
+  # struct_or_hash<#each_pair>:: the key and value to be set, should respond to 'each_pair'
+  # options:: further options defining the context of the update, should be a Hash
+  #
+  # === Returns
+  # self
+  #
+  def update(struct_or_hash, options={})
+    strict = options[:strict]
+    keys_to_delete = props.keys - %w(_neo_id _classname) if strict  
+    struct_or_hash.each_pair do |key, value|
+      next if %w(_neo_id _classname).include? key.to_s # do not allow special properties to be mass assigned
+      keys_to_delete.delete(key) if strict
+      setter_meth = "#{key}=".to_sym
+      if @_wrapper && @_wrapper.respond_to?(setter_meth)
+        @_wrapper.send(setter_meth, value)
+      else
+        self[key] = value
+      end
+    end
+    keys_to_delete.each{|key| delete_property(key) } if strict
+    self
+  end
+
+
+  def equal?(o)
+    eql?(o)
+  end
+
+  def eql?(o)
+    return false unless o.respond_to?(:neo_id)
+    o.neo_id == neo_id
+  end
+
+  def ==(o)
+    eql?(o)
+  end
+
+
+  # Same as neo_id but returns a String instead of a Fixnum.
+  # Used by Ruby on Rails.
+  #
+  def to_param
+    neo_id.to_s
+  end
+
+  # Loads a Neo node wrapper if possible
+  # If the neo property '_classname' does not exist then it will map the neo node to the ruby class Neo4j::Node
+  def wrapper
+    return self unless wrapper?
+    @_wrapper ||= wrapper_class.new(self)
+    @_wrapper
+  end
+
+  def wrapper?
+    property?(CLASSNAME_PROPERTY)
+  end
+
+  def wrapper_class  # :nodoc: 
+    return nil unless wrapper?
+    classname = get_property(CLASSNAME_PROPERTY)
+    classname.split("::").inject(Kernel) do |container, name|
+      container.const_get(name.to_s)
+    end
+  end
+
+
+end
+