neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j/equal.rb

@@ -1,21 +0,0 @@
-module Neo4j
-
-  # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
-  #
-  module Equal
-    def equal?(o)
-      eql?(o)
-    end
-
-    def eql?(o)
-      return false unless o.respond_to?(:getId)
-      o.getId == getId
-    end
-
-    def ==(o)
-      eql?(o)
-    end
-
-  end
-
-end

data/lib/neo4j/event_handler.rb

@@ -1,116 +0,0 @@
-module Neo4j
-
-  # == Handles Transactional Events
-  #
-  # You can use this to receive event before the transaction commits.
-  # The following events are supported:
-  # * <tt>on_neo4j_started</tt>
-  # * <tt>on_neo4j_shutdown</tt>
-  # * <tt>on_node_created</tt>
-  # * <tt>on_node_deleted</tt>
-  # * <tt>on_relationship_created</tt>
-  # * <tt>on_relationship_deleted</tt>
-  # * <tt>on_property_changed</tt>
-  # * <tt>on_rel_property_changed</tt>
-  #
-  # === Usage
-  #
-  #   class MyListener
-  #     def on_node_deleted(node, old_props, tx_data)
-  #     end
-  #   end
-  #
-  #   # to add an listener without starting neo4j:
-  #   Neo4j.unstarted_db.event_handler.add(MyListener.new)
-  #
-  # You only need to implement the methods that you need.
-  #
-  class EventHandler
-    include org.neo4j.graphdb.event.TransactionEventHandler
-
-    def initialize
-      @listeners = []
-    end
-
-
-    def after_commit(data, state)
-    end
-
-    def after_rollback(data, state)
-    end
-
-    def before_commit(data)
-      data.created_nodes.each{|node| node_created(node)}
-      data.assigned_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
-      data.removed_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless data.deleted_nodes.include?(tx_data.entity) }
-      data.deleted_nodes.each { |node| node_deleted(node, deleted_properties_for(node,data), data)}
-      data.created_relationships.each {|rel| relationship_created(rel, data)}
-      data.deleted_relationships.each {|rel| relationship_deleted(rel, deleted_rel_properties_for(rel, data), data)}
-      data.assigned_relationship_properties.each { |tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
-      data.removed_relationship_properties.each {|tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless data.deleted_relationships.include?(tx_data.entity) }
-    end
-
-    def deleted_properties_for(node, data)
-      data.removed_node_properties.find_all{|tx_data| tx_data.entity == node}.inject({}) do |memo, tx_data|
-        memo[tx_data.key] = tx_data.previously_commited_value
-        memo
-      end
-    end
-
-    def deleted_rel_properties_for(rel, data)
-      data.removed_relationship_properties.find_all{|tx_data| tx_data.entity == rel}.inject({}) do |memo, tx_data|
-        memo[tx_data.key] = tx_data.previously_commited_value
-        memo
-      end
-    end
-
-    def add(listener)
-      @listeners << listener unless @listeners.include?(listener)
-    end
-
-    def remove(listener)
-      @listeners.delete(listener)
-    end
-
-    def remove_all
-      @listeners = []
-    end
-
-    def print
-      puts "Listeners #{@listeners.size}"
-      @listeners.each {|li| puts "  Listener '#{li}'"}
-    end
-
-    def neo4j_started(db)
-      @listeners.each { |li| li.on_neo4j_started(db) if li.respond_to?(:on_neo4j_started) }
-    end
-
-    def neo4j_shutdown(db)
-      @listeners.each { |li| li.on_neo4j_shutdown(db) if li.respond_to?(:on_neo4j_shutdown) }
-    end
-
-    def node_created(node)
-      @listeners.each {|li| li.on_node_created(node) if li.respond_to?(:on_node_created)}
-    end
-
-    def node_deleted(node,old_properties, data)
-      @listeners.each {|li| li.on_node_deleted(node,old_properties, data) if li.respond_to?(:on_node_deleted)}
-    end
-
-    def relationship_created(relationship, tx_data)
-      @listeners.each {|li| li.on_relationship_created(relationship, tx_data) if li.respond_to?(:on_relationship_created)}
-    end
-
-    def relationship_deleted(relationship, old_props, data)
-      @listeners.each {|li| li.on_relationship_deleted(relationship, old_props, data) if li.respond_to?(:on_relationship_deleted)}
-    end
-
-    def property_changed(node, key, old_value, new_value)
-      @listeners.each {|li| li.on_property_changed(node, key, old_value, new_value) if li.respond_to?(:on_property_changed)}
-    end
-
-    def rel_property_changed(rel, key, old_value, new_value)
-      @listeners.each {|li| li.on_rel_property_changed(rel, key, old_value, new_value) if li.respond_to?(:on_rel_property_changed)}
-    end
-  end
-end

data/lib/neo4j/index/class_methods.rb

@@ -1,62 +0,0 @@
-module Neo4j
-  module Index
-    module ClassMethods
-      attr_reader :_indexer
-
-      extend Forwardable
-
-      ##
-      # See Neo4j::Index::Indexer#index
-      # Forwards to the indexer that should be used.
-      # It is possible to share the same index for several different classes, see #node_indexer.
-      # :singleton-method: index
-
-      ##
-      # See Neo4j::Index::Indexer#find
-      # Forwards to the indexer that should be used.
-      # It is possible to share the same index for several different classes, see #node_indexer.
-      # :singleton-method: find
-
-
-      def_delegators :@_indexer, :index, :find, :index?, :index_type?, :delete_index_type, :rm_field_type, :add_index, :rm_index, :index_type_for, :index_name
-
-
-      # Sets which indexer should be used for the given node class.
-      # You can share an indexer between several different classes.
-      #
-      # ==== Example
-      #   class Contact
-      #      include Neo4j::NodeMixin
-      #      index :name
-      #      has_one :phone
-      #   end
-      #
-      #   class Phone
-      #      include Neo4j::NodeMixin
-      #      property :phone
-      #      node_indexer Contact  # put index on the Contact class instead
-      #      index :phone
-      #   end
-      #
-      #   # Find an contact with a phone number, this works since they share the same index
-      #   Contact.find('phone: 12345').first #=> a phone object !
-      #
-      # ==== Returns
-      # The indexer that should be used to index the given class
-      def node_indexer(clazz)
-        indexer(clazz, :node)
-      end
-
-      # Sets which indexer should be used for the given relationship class
-      # Same as #node_indexer except that it indexes relationships instead of nodes.
-      #
-      def rel_indexer(clazz)
-        indexer(clazz, :rel)
-      end
-
-      def indexer(clazz, type) #:nodoc:
-        @_indexer = IndexerRegistry.create_for(self, clazz, type)
-      end
-    end
-  end
-end

data/lib/neo4j/index/index.rb

@@ -1,33 +0,0 @@
-module Neo4j
-
-  module Index
-
-    # Adds an index on the given property
-    # Notice that you normally don't have to do that since you simply can declare
-    # that the property and index should be updated automatically by using the class method #index.
-    #
-    # The index operation will take place immediately unlike when using the Neo4j::Index::ClassMethods::index
-    # method which instead will guarantee that the neo4j database and the lucene database will be consistent.
-    # It uses a two phase commit when the transaction is about to be committed.
-    #
-    # ==== See also
-    # Neo4j::Index::ClassMethods::index
-    #
-    def add_index(field, value=self[field])
-      self.class.add_index(wrapped_entity, field.to_s, value)
-    end
-
-    # Removes an index on the given property.
-    # Just like #add_index this is normally not needed since you instead can declare it with the
-    # #index class method instead.
-    #
-    # ==== See also
-    # Neo4j::Index::ClassMethods::index
-    # Neo4j::Index#add_index
-    #
-    def rm_index(field, value=self[field])
-      self.class.rm_index(wrapped_entity, field.to_s, value)
-    end
-
-  end
-end

data/lib/neo4j/index/indexer.rb

@@ -1,312 +0,0 @@
-module Neo4j
-  module Index
-    class Indexer 
-      attr_reader :indexer_for, :field_types, :via_relationships
-
-      def initialize(clazz, type) #:nodoc:
-        # part of the unique name of the index
-        @indexer_for       = clazz
-
-        # do we want to index nodes or relationships ?
-        @type              = type
-
-        @indexes           = {} # key = type, value = java neo4j index
-        @field_types       = {} # key = field, value = type (e.g. :exact or :fulltext)
-        @via_relationships = {} # key = field, value = relationship
-
-        # to enable subclass indexing to work properly, store a list of parent indexers and
-        # whenever an operation is performed on this one, perform it on all
-        @parent_indexers   = []
-      end
-
-      def inherit_fields_from(parent_index) #:nodoc:
-        return unless parent_index
-        @field_types.reverse_merge!(parent_index.field_types) if parent_index.respond_to?(:field_types)
-        @via_relationships.reverse_merge!(parent_index.via_relationships) if parent_index.respond_to?(:via_relationships)
-        @parent_indexers << parent_index
-      end
-
-      def to_s
-        "Indexer @#{object_id} [index_for:#{@indexer_for}, field_types=#{@field_types.keys.join(', ')}, via=#{@via_relationships.inspect}]"
-      end
-
-      # Add an index on a field so that it will be automatically updated by neo4j transactional events.
-      #
-      # The index method takes an optional configuration hash which allows you to:
-      #
-      # === Add an index on an a property
-      #
-      # Example:
-      #   class Person
-      #     include Neo4j::NodeMixin
-      #     index :name
-      #   end
-      #
-      # When the property name is changed/deleted or the node created it will keep the lucene index in sync.
-      # You can then perform a lucene query like this: Person.find('name: andreas')
-      #'
-      # === Add index on other nodes.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Neo4j::NodeMixin
-      #     has_n(:friends).to(Contact)
-      #     has_n(:known_by).from(:friends)
-      #     index :user_id, :via => :known_by
-      #   end
-      #
-      # Notice that you *must* specify an incoming relationship with the via key, as shown above.
-      # In the example above an index <tt>user_id</tt> will be added to all Person nodes which has a <tt>friends</tt> relationship
-      # that person with that user_id. This allows you to do lucene queries on your friends properties.
-      #
-      # === Set the type value to index
-      # By default all values will be indexed as Strings.
-      # If you want for example to do a numerical range query you must tell Neo4j.rb to index it as a numeric value.
-      # You do that with the key <tt>type</tt> on the property.
-      #
-      # Example:
-      #   class Person
-      #     include Neo4j::NodeMixin
-      #     property :weight, :type => Float
-      #     index :weight
-      #   end
-      #
-      # Supported values for <tt>:type</tt> is <tt>String</tt>, <tt>Float</tt>, <tt>Date</tt>, <tt>DateTime</tt> and <tt>Fixnum</tt>
-      #
-      # === For more information
-      # * See Neo4j::Index::LuceneQuery
-      # * See #find
-      #
-      def index(field, conf = {})
-        if conf[:via]
-          rel_dsl = @indexer_for._decl_rels[conf[:via]]
-          raise "No relationship defined for '#{conf[:via]}'. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]} <-- error. Define it with a has_one or has_n" unless rel_dsl
-          raise "Only incoming relationship are possible to define index on. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]}" unless rel_dsl.incoming?
-          via_indexer = rel_dsl.target_class._indexer
-
-          field = field.to_s
-          @via_relationships[field] = rel_dsl
-          conf.delete :via # avoid endless recursion
-          via_indexer.index(field, conf)
-        else
-#          raise "Already defined an (via?) index on #{field}, Using the same index for from two classes ? Check index :#{field}, :via => :#{@indexer_for}" if @field_types[field.to_s]
-          @field_types[field.to_s] = conf[:type] || :exact
-        end
-      end
-
-      def remove_index_on_fields(node, props, tx_data) #:nodoc:
-        @field_types.keys.each { |field| rm_index(node, field, props[field]) if props[field] }
-        # remove all via indexed fields
-        @via_relationships.each_value do |dsl|
-          indexer = dsl.target_class._indexer
-          tx_data.deleted_relationships.each do |rel|
-            start_node = rel._start_node
-            next if node != rel._end_node
-            indexer.remove_index_on_fields(start_node, props, tx_data)
-          end
-        end
-      end
-
-      def update_on_deleted_relationship(relationship) #:nodoc:
-        update_on_relationship(relationship, false)
-      end
-
-      def update_on_new_relationship(relationship) #:nodoc:
-        update_on_relationship(relationship, true)
-      end
-
-      def update_on_relationship(relationship, is_created) #:nodoc:
-        rel_type = relationship.rel_type
-        end_node = relationship._end_node
-        # find which via relationship match rel_type
-        @via_relationships.each_pair do |field, dsl|
-          # have we declared an index on this changed relationship ?
-          next unless dsl.rel_type == rel_type
-
-          # yes, so find the node and value we should update the index on
-          val        = end_node[field]
-          start_node = relationship._start_node
-
-          # find the indexer to use
-          indexer   = dsl.target_class._indexer
-
-          # is the relationship created or deleted ?
-          if is_created
-            indexer.update_index_on(start_node, field, nil, val)
-          else
-            indexer.update_index_on(start_node, field, val, nil)
-          end
-        end
-      end
-
-      def update_index_on(node, field, old_val, new_val) #:nodoc:
-        if @via_relationships.include?(field)
-          dsl = @via_relationships[field]
-          target_class = dsl.target_class
-
-          dsl._all_relationships(node).each do |rel|
-            other = rel._start_node
-            target_class._indexer.update_single_index_on(other, field, old_val, new_val)
-          end
-        end
-        update_single_index_on(node, field, old_val, new_val)
-      end
-
-      def update_single_index_on(node, field, old_val, new_val) #:nodoc:
-        if @field_types.include?(field)
-          rm_index(node, field, old_val) if old_val
-          add_index(node, field, new_val) if new_val
-        end
-      end
-
-      # Returns true if there is an index on the given field.
-      #
-      def index?(field)
-        @field_types.include?(field.to_s)
-      end
-
-      # Returns the type of index for the given field (e.g. :exact or :fulltext)
-      #
-      def index_type_for(field) #:nodoc:
-        return nil unless index?(field)
-        @field_types[field.to_s]
-      end
-
-      # Returns true if there is an index of the given type defined.
-      def index_type?(type)
-        @field_types.values.include?(type)
-      end
-
-      # Adds an index on the given entity
-      # This is normally not needed since you can instead declare an index which will automatically keep
-      # the lucene index in sync. See #index
-      #
-      def add_index(entity, field, value)
-       	return false unless @field_types.has_key?(field)
-
-        # we might need to know what type the properties are when indexing and querying
-        @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
-
-        type = @decl_props && @decl_props[field.to_sym] && @decl_props[field.to_sym][:type]
-        if type
-          value = if String != type
-                    org.neo4j.index.impl.lucene.ValueContext.new(value).indexNumeric
-                  else
-                    org.neo4j.index.impl.lucene.ValueContext.new(value)
-                  end
-        end
-
-        index_for_field(field.to_s).add(entity, field, value)
-      	@parent_indexers.each { |i| i.add_index(entity, field, value) }
-      end
-
-      # Removes an index on the given entity
-      # This is normally not needed since you can instead declare an index which will automatically keep
-      # the lucene index in sync. See #index
-      #
-      def rm_index(entity, field, value)
-        return false unless @field_types.has_key?(field)
-        index_for_field(field).remove(entity, field, value)
-        @parent_indexers.each { |i| i.rm_index(entity, field, value) }
-      end
-
-      # Performs a Lucene Query.
-      #
-      # In order to use this you have to declare an index on the fields first, see #index.
-      # Notice that you should close the lucene query after the query has been executed.
-      # You can do that either by provide an block or calling the Neo4j::Index::LuceneQuery#close
-      # method. When performing queries from Ruby on Rails you do not need this since it will be automatically closed
-      # (by Rack).
-      #
-      # === Example, with a block
-      #   
-      #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
-      #
-      # ==== Example
-      #
-      #   query = Person.find('name: kalle')
-      #   puts "First item #{query.first}"
-      #   query.close
-      #
-      # === Return Value
-      # It will return a Neo4j::Index::LuceneQuery object
-      #
-      #
-      def find(query, params = {})
-        # we might need to know what type the properties are when indexing and querying
-        @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
-
-        index = index_for_type(params[:type] || :exact)
-        query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @decl_props, query) : index.query(query)
-
-        if block_given?
-          begin
-            ret = yield query
-          ensure
-            query.close
-          end
-          ret
-        else
-          query
-        end
-      end
-
-      # delete the index, if no type is provided clear all types of indexes
-      def delete_index_type(type=nil)
-        if type
-          #raise "can't clear index of type '#{type}' since it does not exist ([#{@field_types.values.join(',')}] exists)" unless index_type?(type)
-          @indexes[type] && @indexes[type].delete
-          @indexes[type] = nil
-        else
-          @indexes.each_value { |index| index.delete }
-          @indexes.clear
-        end
-      end
-
-      def on_neo4j_shutdown #:nodoc:
-        # Since we might start the database again we must make sure that we don't keep any references to
-        # an old lucene index in memory.
-        @indexes.clear
-      end
-
-      # Removes the cached lucene index, can be useful for some RSpecs which needs to restart the Neo4j.
-      #
-      def rm_field_type(type=nil)
-        if type
-          @field_types.delete_if { |k, v| v == type }
-        else
-          @field_types.clear
-        end
-      end
-
-      def index_for_field(field) #:nodoc:
-        type = @field_types[field]
-        @indexes[type] ||= create_index_with(type)
-      end
-
-      def index_for_type(type) #:nodoc:
-        @indexes[type] ||= create_index_with(type)
-      end
-
-      def lucene_config(type) #:nodoc:
-        conf = Neo4j::Config[:lucene][type.to_sym]
-        raise "unknown lucene type #{type}" unless conf
-        conf
-      end
-
-      def create_index_with(type) #:nodoc:
-        db=Neo4j.started_db
-        index_config = lucene_config(type)
-        if @type == :node
-          db.lucene.for_nodes("#{@indexer_for}-#{type}", index_config)
-        else
-          db.lucene.for_relationships("#{@indexer_for}-#{type}", index_config)
-        end
-      end
-
-    end
-
-  end
-
-end