neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/index/indexer_registry.rb

@@ -1,68 +0,0 @@
-module Neo4j
-  module Index
-    class IndexerRegistry #:nodoc:
-      class << self
-
-        def delete_all_indexes
-          @@indexers.values.each {|i| i.delete_index_type}
-        end
-
-        def create_for(this_clazz, using_other_clazz, type)
-          @@indexers                  ||= {}
-          index                       = Indexer.new(this_clazz, type)
-          index.inherit_fields_from(@@indexers[using_other_clazz.to_s]) if @@indexers[using_other_clazz.to_s]
-          @@indexers[this_clazz.to_s] = index
-        end
-
-        def find_by_class(classname)
-          @@indexers[classname]
-        end
-
-        def on_node_deleted(node, old_props, deleted_relationship_set, deleted_identity_map)
-          indexer = find_by_class(old_props['_classname'] || node.class.to_s)
-          indexer && indexer.remove_index_on_fields(node, old_props, deleted_relationship_set)
-        end
-
-        def on_property_changed(node, field, old_val, new_val)
-          classname = node['_classname'] || node.class.to_s
-          indexer = find_by_class(classname)
-
-          indexer && indexer.update_index_on(node, field, old_val, new_val)
-        end
-
-        def on_rel_property_changed(rel, field, old_val, new_val)
-          # works exactly like for nodes
-          on_property_changed(rel, field, old_val, new_val)
-        end
-
-        def on_relationship_created(rel,created_identity_map)
-          end_node = rel._end_node
-          # if end_node was created in this transaction then it will be handled in on_property_changed
-          created = created_identity_map.get(end_node.neo_id)
-          unless created
-            indexer = find_by_class(end_node['_classname'])
-            indexer && indexer.update_on_new_relationship(rel)
-          end
-        end
-
-        def on_relationship_deleted(rel, old_props, deleted_relationship_set, deleted_identity_map)
-          on_node_deleted(rel, old_props, deleted_relationship_set, deleted_identity_map)
-          # if only the relationship has been deleted then we have to remove the index
-          # if both the relationship and the node has been deleted then the index will be removed in the
-          # on_node_deleted callback
-          end_node = rel._end_node
-          deleted = deleted_identity_map.get(end_node.neo_id)
-          unless deleted
-            indexer = find_by_class(end_node['_classname'])
-            indexer && indexer.update_on_deleted_relationship(rel)
-          end
-        end
-
-        def on_neo4j_shutdown(*)
-          @@indexers.each_value {|indexer| indexer.on_neo4j_shutdown}
-        end
-      end
-    end
-    Neo4j.unstarted_db.event_handler.add(IndexerRegistry) unless Neo4j.read_only?
-  end
-end

data/lib/neo4j/index/lucene_query.rb

@@ -1,256 +0,0 @@
-module Neo4j
-  module Index
-    # == LuceneQuery
-    #
-    # This object is returned when you call the #find method on the Node, Relationship.
-    # The actual query is not executed until the first item is requested.
-    #
-    # You can perform a query in many different ways:
-    #
-    # ==== By Hash
-    #
-    # Example:
-    #  Person.find(:name => 'foo', :age => 3)
-    #
-    # ==== By Range
-    #
-    # Example:
-    #  Person.find(:age).between(15,35)
-    #
-    # ==== By Lucene Query Syntax
-    #
-    # Example
-    #  Car.find('wheels:"4" AND colour: "blue")
-    #
-    # For more information about the syntax see http://lucene.apache.org/java/3_0_2/queryparsersyntax.html
-    #
-    # ==== By Compound Queries
-    #
-    # You can combine several queries by <tt>AND</tt>ing those together.
-    #
-    # Example:
-    #   Vehicle.find(:weight).between(5.0, 100000.0).and(:name).between('a', 'd')
-    #
-    # === See Also
-    # * Neo4j::Index::Indexer#index
-    # * Neo4j::Index::Indexer#find - which returns an LuceneQuery
-    #
-    class LuceneQuery
-      include Enumerable
-      attr_accessor :left_and_query, :left_or_query, :right_not_query
-
-      def initialize(index, decl_props, query, params={})
-        @index      = index
-        @query      = query
-        @decl_props = decl_props
-        @params     = params
-
-        if params.include?(:sort)
-          @order = {}
-          params[:sort].each_pair { |k, v| @order[k] = (v == :desc) }
-        end
-      end
-
-      # Implements the Ruby +Enumerable+ interface
-      def each
-        hits.each { |x| yield x.wrapper }
-      end
-
-      # Close hits
-      #
-      # Closes the underlying search result. This method should be called whenever you've got what you wanted from the result and won't use it anymore.
-      # It's necessary to call it so that underlying indexes can dispose of allocated resources for this search result.
-      # You can however skip to call this method if you loop through the whole result, then close() will be called automatically.
-      # Even if you loop through the entire result and then call this method it will silently ignore any consequtive call (for convenience).
-      #
-      # This must be done according to the Neo4j Java Documentation:
-      def close
-        @hits.close if @hits
-        @hits = nil
-      end
-
-      # True if there is no search hits.
-      def empty?
-        hits.size == 0
-      end
-
-      # returns the n'th search item
-      # Does simply loop all search items till the n'th is found.
-      #
-      def [](index)
-        i = 0
-        each{|x| return x if i == index; i += 1}
-        nil # out of index
-      end
-
-      # Returns the number of search hits
-      def size
-        hits.size
-      end
-
-      def hits #:nodoc:
-        close
-        @hits = perform_query
-      end
-
-      # Performs a range query
-      # Notice that if you don't specify a type when declaring a property a String range query will be performed.
-      #
-      def between(lower, upper, lower_incusive=false, upper_inclusive=false)
-        raise "Expected a symbol. Syntax for range queries example: index(:weight).between(a,b)" unless Symbol === @query
-        raise "Can't only do range queries on Neo4j::NodeMixin, Neo4j::Model, Neo4j::RelationshipMixin" unless @decl_props
-        # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
-        type = @decl_props[@query] && @decl_props[@query][:type]
-        raise "find(#{@query}).between(#{lower}, #{upper}): #{lower} not a #{type}" if type && !type === lower.class
-        raise "find(#{@query}).between(#{lower}, #{upper}): #{upper} not a #{type}" if type && !type === upper.class
-
-        # Make it possible to convert those values
-        @query = range_query(@query, lower, upper, lower_incusive, upper_inclusive)
-        self
-      end
-
-      def range_query(field, lower, upper, lower_incusive, upper_inclusive)
-        lower = TypeConverters.convert(lower)
-        upper = TypeConverters.convert(upper)
-
-        case lower
-          when Fixnum
-            org.apache.lucene.search.NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
-          when Float
-            org.apache.lucene.search.NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
-          else
-            org.apache.lucene.search.TermRangeQuery.new(field.to_s, lower, upper, lower_incusive, upper_inclusive)
-        end
-      end
-
-
-      # Create a compound lucene query.
-      #
-      # ==== Parameters
-      # query2 :: the query that should be AND together
-      #
-      # ==== Example
-      #
-      #  Person.find(:name=>'kalle').and(:age => 3)
-      #
-      def and(query2)
-        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.left_and_query = self }
-      end
-
-      # Create an OR lucene query.
-      #
-      # ==== Parameters
-      # query2 :: the query that should be OR together
-      #
-      # ==== Example
-      #
-      #  Person.find(:name=>'kalle').or(:age => 3)
-      #
-      def or(query2)
-        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.left_or_query = self }
-      end
-
-      # Create a NOT lucene query.
-      #
-      # ==== Parameters
-      # query2 :: the query that should exclude matching results
-      #
-      # ==== Example
-      #
-      #  Person.find(:age => 3).not(:name=>'kalle')
-      #
-      def not(query2)
-        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.right_not_query = self }
-      end
-
-
-      # Sort descending the given fields.
-      def desc(*fields)
-        @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
-        self
-      end
-
-      # Sort ascending the given fields.
-      def asc(*fields)
-        @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
-        self
-      end
-
-      def build_and_query(query) #:nodoc:
-        build_composite_query(@left_and_query.build_query, query, org.apache.lucene.search.BooleanClause::Occur::MUST)
-      end
-
-      def build_or_query(query) #:nodoc:
-        build_composite_query(@left_or_query.build_query, query, org.apache.lucene.search.BooleanClause::Occur::SHOULD)
-      end
-
-      def build_not_query(query) #:nodoc:
-        right_query = @right_not_query.build_query
-        composite_query  = org.apache.lucene.search.BooleanQuery.new
-        composite_query.add(query, org.apache.lucene.search.BooleanClause::Occur::MUST_NOT)
-        composite_query.add(right_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
-        composite_query
-      end
-
-      def build_composite_query(left_query, right_query, opeartor) #:nodoc:
-        composite_query  = org.apache.lucene.search.BooleanQuery.new
-        composite_query.add(left_query, opeartor)
-        composite_query.add(right_query, opeartor)
-        composite_query
-      end
-
-      def build_sort_query(query) #:nodoc:
-        java_sort_fields = @order.keys.inject([]) do |memo, field|
-          decl_type = @decl_props && @decl_props[field] && @decl_props[field][:type]
-          type      = case
-                        when Float == decl_type
-                          org.apache.lucene.search.SortField::DOUBLE
-                        when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
-                          org.apache.lucene.search.SortField::LONG
-                        else
-                          org.apache.lucene.search.SortField::STRING
-                      end
-          memo << org.apache.lucene.search.SortField.new(field.to_s, type, @order[field])
-        end
-        sort             = org.apache.lucene.search.Sort.new(*java_sort_fields)
-        org.neo4j.index.lucene.QueryContext.new(query).sort(sort)
-      end
-
-      def build_hash_query(query) #:nodoc:
-        and_query = org.apache.lucene.search.BooleanQuery.new
-
-        query.each_pair do |key, value|
-          type = @decl_props && @decl_props[key.to_sym] && @decl_props[key.to_sym][:type]
-          if !type.nil? && type != String
-            if Range === value
-              and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), org.apache.lucene.search.BooleanClause::Occur::MUST)
-            else
-              and_query.add(range_query(key, value, value, true, true), org.apache.lucene.search.BooleanClause::Occur::MUST)
-            end
-          else
-            conv_value = type ? TypeConverters.convert(value) : value.to_s
-            term       = org.apache.lucene.index.Term.new(key.to_s, conv_value)
-            term_query = org.apache.lucene.search.TermQuery.new(term)
-            and_query.add(term_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
-          end
-        end
-        and_query
-      end
-
-      def build_query #:nodoc:
-        query = @query
-        query = build_hash_query(query) if Hash === query
-        query = build_and_query(query) if @left_and_query
-        query = build_or_query(query) if @left_or_query
-        query = build_not_query(query) if @right_not_query
-        query = build_sort_query(query) if @order
-        query
-      end
-
-      def perform_query #:nodoc:
-        @index.query(build_query)
-      end
-    end
-  end
-end
-

data/lib/neo4j/load.rb

@@ -1,25 +0,0 @@
-module Neo4j
-
-  # === Mixin responsible for loading Ruby wrappers for Neo4j Nodes and Relationship.
-  #
-  module Load
-    def wrapper(entity) # :nodoc:
-      return entity unless entity.property?(:_classname)
-      existing_instance = Neo4j::IdentityMap.get(entity)
-      return existing_instance if existing_instance
-      new_instance = to_class(entity[:_classname]).load_wrapper(entity)
-      Neo4j::IdentityMap.add(entity, new_instance)
-      new_instance
-    end
-
-    def to_class(class_name) # :nodoc:
-      class_name.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
-    end
-
-    # Checks if the given entity (node/relationship) or entity id (#neo_id) exists in the database.
-    def exist?(entity_or_entity_id, db = Neo4j.started_db)
-      id = entity_or_entity_id.kind_of?(Fixnum) ?  entity_or_entity_id : entity_or_entity_id.id
-      _load(id, db) != nil
-    end
-  end
-end

data/lib/neo4j/migrations/class_methods.rb

@@ -1,110 +0,0 @@
-module Neo4j
-  module Migrations
-    module ClassMethods
-
-      # Sets the the version we request to migrate to
-      # If not set will migrate to the highest possible migration
-      def migrate_to=(version)
-        @migrate_to = version
-      end
-
-      def migrate_to
-        @migrate_to
-      end
-
-      def latest_migration
-        migrations.keys.sort.reverse[0]
-      end
-
-      # contains all the migrations defined with the #migration DSL method
-      def migrations
-        @migrations ||= {}
-      end
-
-      # Remote all migration and set migrate_to = nil
-      # Does not change the version of nodes.
-      def reset_migrations!
-        @migrations = nil
-        @migrate_to = nil
-      end
-
-
-      # Specifies a migration to be performed.
-      # Updates the migrate_to variable so that it will migrate to the latest migration.
-      #
-      # === Example
-      #
-      # In the following example the up and down method will be evaluated in the context of a Person node.
-      #
-      #   Person.migration 1, :my_first_migration do
-      #     up { ... }
-      #     down { ... }
-      #   end
-      #
-      # See the Neo4j::Migrations::Migration which the DSL is evaluated in.
-      #
-      def migration(version, name, &block)
-        migration = Migration.new(version, name)
-        migration.instance_eval(&block)
-        migrations[version] = migration
-        self.migrate_to = latest_migration
-      end
-
-
-      def _migrate!(context, meta_node, version=nil) #:nodoc:
-        # set the version we want to migrate to if provided
-        self.migrate_to = version if version
-
-        # requested to migrate to a version ?
-        return if self.migrate_to.nil?
-
-        # which version are we on now ?
-        current_version = meta_node[:_db_version] || 0
-
-        # do we need to migrate ?
-        return if current_version == self.migrate_to
-
-        # ok, so we are running some migrations
-        if Neo4j::Config['migration_thread']
-          Thread.new { _upgrade_or_downgrade(current_version, context, meta_node) }
-        else
-          _upgrade_or_downgrade(current_version, context, meta_node)
-        end
-      end
-
-      def _upgrade_or_downgrade(current_version, context, meta_node) #:nodoc:
-        if (current_version < self.migrate_to)
-          upgrade((current_version+1).upto(self.migrate_to).collect { |ver| migrations[ver] }, context, meta_node)
-        else
-          downgrade(current_version.downto(self.migrate_to+1).collect { |ver| migrations[ver] }, context, meta_node)
-        end
-
-      end
-
-
-      # Running the up method on the given migrations.
-      #
-      # === Parameters
-      # migrations :: an enumerable of Migration objects
-      def upgrade(migrations, context, meta_node)
-        migrations.each do |m|
-          Neo4j.logger.info "Running upgrade: #{m}"
-          m.execute_up(context, meta_node)
-        end
-      end
-
-      # Running the down method on the given migrations.
-      #
-      # === Parameters
-      # migrations:: an enumerable of Migration objects
-      def downgrade(migrations, context, meta_node)
-        migrations.each do |m|
-          Neo4j.logger.info "Running downgrade: #{m}"
-          m.execute_down(context, meta_node)
-        end
-      end
-
-    end
-  end
-
-end