neo4j 1.0.0.beta.9 → 1.0.0.beta.10

data/lib/neo4j.old/indexer.rb

@@ -1,187 +0,0 @@
-module Neo4j
-
-  # This class is responsible for both knowing which nodes that needs to be reindexed
-  # and how to perform the reindex operation (the document_updaters attribute).
-  # 
-  # There is one Indexer per Node root class.
-  #
-  class Indexer  #:nodoc:
-    attr_reader :document_updaters, :index_id
-    attr_reader :property_indexer # for testing purpose
-    
-    def initialize(indexed_class, query_for_nodes)
-      @relationship_indexers = {}
-      @query_for_nodes = query_for_nodes
-      @property_indexer = PropertyIndexer.new
-      @document_updaters = [@property_indexer]
-      # the file name of the lucene index if kept on disk
-      @index_id = "/" + indexed_class.to_s.gsub('::', '/')
-    end
-
-    # Returns the Indexer for the given Neo4j::NodeMixin class
-    def self.instance(clazz, query_for_nodes = true)
-      @instances ||= {}
-      @instances[clazz.root_class] ||= Indexer.new(clazz.root_class, query_for_nodes)
-      @instances[clazz.root_class]
-    end
-
-    # only for testing purpose, e.g we need to redefine an existing class
-    def self.remove_instance(clazz)
-      @instances.delete(clazz.root_class) if !@instances.nil? && clazz.respond_to?(:root_class)
-    end
-
-
-    # (Re)index the given node
-    def self.index(node)
-      indexer = instance(node.class)
-      indexer.index(node)
-    end
-
-    def find(query,block)
-      SearchResult.new lucene_index, query, @query_for_nodes, &block
-    end
-
-    def add_index_on_property(prop)
-      @property_indexer.properties << prop.to_sym
-    end
-
-    def remove_index_on_property(prop)
-      @property_indexer.properties.delete prop.to_sym
-    end
-
-    def add_index_in_relationship_on_property(updater_clazz, rel_name, rel_type, prop, namespace_type)
-      unless relationship_indexer_for?(namespace_type)
-        indexer = new_relationship_indexer_for(namespace_type, rel_name.to_sym)
-        self.class.instance(updater_clazz).document_updaters << indexer
-      end
-
-      # TODO make sure the same index is not added twice
-      relationship_indexer_for(namespace_type).properties << prop.to_sym
-    end
-
-    def index(node)
-      document = {:id => node.neo_id }
-
-      @document_updaters.each do |updater|
-        updater.update_document(document, node)
-      end
-
-      lucene_index << document
-    end
-
-    def delete_index(node)
-      lucene_index.delete(node.neo_id)
-    end
-
-
-    def lucene_index
-      Lucene::Index.new(@index_id)
-    end
-
-    def field_infos
-      lucene_index.field_infos
-    end
-
-    def on_property_changed(node, prop)
-      @relationship_indexers.values.each {|indexer| indexer.on_property_changed(node, prop.to_sym)}
-      @property_indexer.on_property_changed(node,prop.to_sym)
-    end
-
-    def on_relationship_created(node, rel_type)
-      @relationship_indexers.values.each {|indexer| indexer.on_relationship_created(node, rel_type.to_sym)}
-    end
-
-    def on_relationship_deleted(node, rel_type)
-      @relationship_indexers.values.each {|indexer| indexer.on_relationship_deleted(node, rel_type.to_sym)}
-    end
-
-    def relationship_indexer_for(rel_type)
-      @relationship_indexers[rel_type.to_sym]
-    end
-
-    def relationship_indexer_for?(rel_type)
-      !relationship_indexer_for(rel_type.to_sym).nil?
-    end
-
-    def new_relationship_indexer_for(rel_type, rel_name)
-      @relationship_indexers[rel_type.to_sym] = RelationshipIndexer.new(rel_name.to_sym, rel_type.to_sym)
-    end
-
-  end
-
-
-  class PropertyIndexer #:nodoc:
-    attr_reader :properties
-
-    def initialize
-      @properties = []
-    end
-
-    def on_property_changed(node, prop)
-      Indexer.index(node) if @properties.include?(prop)
-    end
-
-    def update_document(document, node)
-      # we have to check that the property exists since the index can be defined in a subclass
-      @properties.each {|prop| document[prop.to_sym] = node.send(prop) if node.respond_to?(prop)}
-    end
-  end
-
-
-  # If node class A has a relationship with type 'd' to node class B
-  #   A.x -d-> B.y  A.index d.y
-  # If property y on a B node changes then all its nodes in the relationship 'd' will
-  # be reindexed.  Those nodes (which will be of type node class A) will use the same RelationshipIndexer to update the
-  # index document with key field 'd.y' and values of property y of all nodes in the
-  # relationship 'd'
-  # 
-  class RelationshipIndexer #:nodoc:
-    attr_reader :rel_type, :properties
-    
-    def initialize(rel_name, rel_type)
-      @properties = []
-      @rel_type = rel_type
-      @rel_name = rel_name
-    end
-
-    def on_property_changed(node, prop)
-      # make sure we're interested in indexing this property
-      reindex_related_nodes(node) if @properties.include?(prop)
-    end
-
-    def on_relationship_deleted(node, rel_type)
-      Indexer.index(node) if @rel_type == rel_type
-    end
-
-    def on_relationship_created(node, rel_type)
-      # make sure we're interested in indexing this relationship
-      if @rel_type == rel_type
-        reindex_related_nodes(node)
-        Indexer.index(node)
-      end
-    end
-
-    def reindex_related_nodes(node)
-      related_nodes = node.rels.both(@rel_type).nodes
-      related_nodes.each do |related_node|
-        Indexer.index(related_node)
-      end
-    end
-
-    def index_key(property)
-      "#@rel_name.#{property}".to_sym
-    end
-
-    def update_document(document, node)
-      relationships = node.rels.both(@rel_type).nodes
-      relationships.each do |other_node|
-        @properties.each do |p|
-          index_key = index_key(p)
-          document[index_key] ||= []
-          document[index_key] << other_node.send(p)
-        end
-      end
-    end
-  end
-
-end

data/lib/neo4j.old/jars.rb

@@ -1,6 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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
-