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

data/lib/neo4j/has_n/has_n.rb

@@ -1,3 +0,0 @@
-require 'neo4j/has_n/class_methods'
-require 'neo4j/has_n/decl_relationship_dsl'
-require 'neo4j/has_n/mapping'

data/lib/neo4j/has_n/mapping.rb

@@ -1,98 +0,0 @@
-require 'neo4j/has_n/class_methods'
-require 'neo4j/has_n/decl_relationship_dsl'
-require 'neo4j/has_n/mapping'
-
-module Neo4j
-  module HasN
-
-    # The object created by a has_n or has_one Neo4j::NodeMixin class method which enables creating and traversal of nodes.
-    #
-    # Includes the Enumerable mixin.
-    # The Neo4j::Mapping::ClassMethods::Relationship#has_n and Neo4j::Mapping::ClassMethods::Relationship#one
-    # methods returns an object of this type.
-    #
-    # ==== See Also
-    # Neo4j::HasN::ClassMethods
-    #
-    class Mapping
-      include Enumerable
-      include ToJava
-
-      def initialize(node, dsl) # :nodoc:
-        @node = node
-        @dsl = dsl
-      end
-
-      def to_s
-        "HasN::Mapping [#{@dsl.dir}, id: #{@node.neo_id} type: #{@dsl && @dsl.rel_type} dsl:#{@dsl}]"
-      end
-
-      def size
-        self.to_a.size # TODO: Optimise this
-      end
-
-      alias_method :length, :size
-
-
-      def [](index)
-        i = 0
-        each{|x| return x if i == index; i += 1}
-        nil # out of index
-      end
-
-      # Pretend we are an array - this is necessarily for Rails actionpack/actionview/formhelper to work with this
-      def is_a?(type)
-        # ActionView requires this for nested attributes to work
-        return true if Array == type
-        super
-      end
-
-      # Required by the Enumerable mixin.
-      def each
-        @dsl.each_node(@node) {|n| yield n} # Should use yield here as passing &block through doesn't always work (why?)
-      end
-
-      # returns none wrapped nodes, you may get better performance using this method
-      def _each
-        @dsl._each_node(@node) {|n| yield n}
-      end
-
-      # Returns an real ruby array.
-      def to_ary
-        self.to_a
-      end
-
-      # Returns true if there are no node in this type of relationship
-      def empty?
-        first == nil
-      end
-
-
-      # Creates a relationship instance between this and the other node.
-      # Returns the relationship object
-      def new(other)
-        @dsl.create_relationship_to(@node, other)
-      end
-
-
-      # Creates a relationship between this and the other node.
-      #
-      # ==== Example
-      # 
-      #   n1 = Node.new # Node has declared having a friend type of relationship
-      #   n2 = Node.new
-      #   n3 = Node.new
-      #
-      #   n1 << n2 << n3
-      #
-      # ==== Returns
-      # self
-      #
-      def <<(other)
-        @dsl.create_relationship_to(@node, other)
-        self
-      end
-    end
-
-  end
-end

data/lib/neo4j/identity_map.rb

@@ -1,140 +0,0 @@
-module Neo4j
-
-  # = Neo4j Identity Map
-  #
-  # Ensures that each object gets loaded only once by keeping every loaded
-  # object in a map. Looks up objects using the map when referring to them.
-  #
-  # More information on Identity Map pattern:
-  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
-  #
-  # == Configuration
-  #
-  # In order to enable IdentityMap, set <tt>config.neo4j.identity_map = true</tt>
-  # in your <tt>config/application.rb</tt> file. If used outside rails, set Neo4j::Config[:identity_map] = true.
-  #
-  # IdentityMap is disabled by default and still in development (i.e. use it with care).
-  #
-  module IdentityMap
-
-    class << self
-      def enabled=(flag)
-        Thread.current[:neo4j_identity_map] = flag
-      end
-
-      def enabled
-         Thread.current[:neo4j_identity_map]
-      end
-
-      alias enabled? enabled
-
-      def node_repository
-        Thread.current[:node_identity_map] ||= java.util.HashMap.new
-      end
-
-      def rel_repository
-        Thread.current[:rel_identity_map] ||= java.util.HashMap.new
-      end
-
-      def repository_for(neo_entity)
-        return nil unless enabled?
-        if neo_entity.class == Neo4j::Node
-          node_repository
-        elsif neo_entity.class == Neo4j::Relationship
-          rel_repository
-        else
-          nil
-        end
-      end
-
-      def use
-        old, self.enabled = enabled, true
-        yield if block_given?
-      ensure
-        self.enabled = old
-        clear
-      end
-
-      def without
-        old, self.enabled = enabled, false
-        yield if block_given?
-      ensure
-        self.enabled = old
-      end
-
-      def get(neo_entity)
-        r = repository_for(neo_entity)
-        r && r.get(neo_entity.neo_id)
-      end
-
-      def add(neo_entity, wrapped_entity)
-        r = repository_for(neo_entity)
-        r && r.put(neo_entity.neo_id, wrapped_entity)
-      end
-
-      def remove(neo_entity)
-        r = repository_for(neo_entity)
-        r && r.remove(neo_entity.neo_id)
-      end
-
-      def remove_node_by_id(node_id)
-        node_repository.remove(node_id)
-      end
-
-      def remove_rel_by_id(rel_id)
-        rel_repository.remove(rel_id)
-      end
-
-      def clear
-        node_repository.clear
-        rel_repository.clear
-      end
-
-      def on_after_commit(*)
-        clear
-      end
-
-      def on_neo4j_started(db)
-        if not Neo4j::Config[:identity_map]
-          db.event_handler.remove(self)
-        end
-      end
-
-    end
-
-
-    class Middleware
-      class Body #:nodoc:
-        def initialize(target, original)
-          @target = target
-          @original = original
-        end
-
-        def each(&block)
-          @target.each(&block)
-        end
-
-        def close
-          @target.close if @target.respond_to?(:close)
-        ensure
-          IdentityMap.enabled = @original
-          IdentityMap.clear
-        end
-      end
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        enabled = IdentityMap.enabled
-        IdentityMap.enabled = Neo4j::Config[:identity_map]
-        status, headers, body = @app.call(env)
-        [status, headers, Body.new(body, enabled)]
-      end
-    end
-  end
-end
-
-Neo4j.unstarted_db.event_handler.add(Neo4j::IdentityMap)
-

data/lib/neo4j/index/class_methods.rb

@@ -1,108 +0,0 @@
-module Neo4j
-  module Index
-    module ClassMethods
-      attr_reader :_indexer
-
-      extend Forwardable
-
-      def wp_query(options, pager, args, &block) #:nodoc:
-        params            = {} 
-        params[:page]     = pager.current_page
-        params[:per_page] = pager.per_page
-        query               = if args.empty?
-                              find(options, params, &block)
-                            else
-                              args << params.merge(options)
-                              find(*args, &block)
-                            end
-
-        pager.replace [*query]
-        pager.total_entries = query.size
-      end
-
-
-      ##
-      # 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
-
-      ##
-      # Specifies the location on the filesystem of the lucene index for the given index type.
-      #
-      # If not specified it will have the default location:
-      #
-      #   Neo4j.config[:storage_path]/index/lucene/node|relationship/ParentModuleName_SubModuleName_ClassName-indextype
-      #
-      # Forwards to the Indexer#index_names class
-      #
-      # ==== Example
-      #  module Foo
-      #    class Person
-      #       include Neo4j::NodeMixin
-      #       index :name
-      #       index_names[:fulltext] = 'my_location'
-      #    end
-      #  end
-      #
-      #  Person.index_names[:fulltext] => 'my_location'
-      #  Person.index_names[:exact] => 'Foo_Person-exact' # default Location
-      #
-      # The index can be prefixed, see Neo4j#threadlocal_ref_node= and multi dendency.
-      #
-      # :singleton-method: index_names
-
-
-      ##
-      # Returns a hash of which indexes has been defined and the type of index (:exact or :fulltext)
-      #
-      # :singleton-method: index_types
-
-
-      def_delegators :@_indexer, :index, :find, :index?, :index_type?, :delete_index_type, :rm_field_type, :add_index, :rm_index, :index_type_for, :index_names, :index_types
-
-      # 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,39 +0,0 @@
-require 'neo4j/index/class_methods'
-require 'neo4j/index/indexer_registry'
-require 'neo4j/index/indexer'
-require 'neo4j/index/lucene_query'
-
-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])
-      converted_value = Neo4j::TypeConverters.convert(value, field, self.class)
-      self.class.add_index(wrapped_entity, field.to_s, converted_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,341 +0,0 @@
-module Neo4j
-  module Index
-    class Indexer
-      attr_reader :indexer_for, :field_types, :via_relationships, :entity_type, :parent_indexers, :via_relationships
-      alias_method :index_types, :field_types  # public method accessible from node.index_types
-
-      def initialize(clazz, type) #:nodoc:
-        # part of the unique name of the index
-        @indexer_for       = clazz
-
-        # do we want to index nodes or relationships ?
-        @entity_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 :height, :weight, :type => Float
-      #     index :height, :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(*args)
-        conf = args.last.kind_of?(Hash) ? args.pop : {}
-        conf_no_via = conf.reject { |k,v| k == :via } # avoid endless recursion
-
-        args.uniq.each do | field |
-          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
-            via_indexer.index(field, conf_no_via)
-          else
-            @field_types[field.to_s] = conf[:type] || :exact
-          end
-        end
-      end
-
-      def remove_index_on_fields(node, props, deleted_relationship_set) #: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
-          deleted_relationship_set.relationships(node.getId).each do |rel|
-            indexer.remove_index_on_fields(rel._start_node, props, deleted_relationship_set)
-          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.has_key?(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)
-        conv_value = indexed_value_for(field, value)
-        index = index_for_field(field.to_s)
-        index.add(entity, field, conv_value)
-        @parent_indexers.each { |i| i.add_index(entity, field, value) }
-      end
-
-      def indexed_value_for(field, value)
-        # 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]
-        return value unless type
-
-        if String != type
-          org.neo4j.index.lucene.ValueContext.new(value).indexNumeric
-        else
-          org.neo4j.index.lucene.ValueContext.new(value)
-        end
-      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)
-        if query.is_a?(Hash) && (query.include?(:conditions) || query.include?(:sort))
-          params.merge! query.except(:conditions)
-          query.delete(:sort)
-          query = query.delete(:conditions) if query.include?(:conditions)
-        end
-        query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @decl_props, query, params) : 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)
-          key = index_key(type)
-          @indexes[key] && @indexes[key].delete
-          @indexes[key] = 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[index_key(type)] ||= create_index_with(type)
-      end
-
-      def index_for_type(type) #:nodoc:
-        @indexes[index_key(type)] ||= create_index_with(type)
-      end
-
-      def index_key(type)
-        index_names[type] + type.to_s
-      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 @entity_type == :node
-          db.lucene.for_nodes(index_names[type], index_config)
-        else
-          db.lucene.for_relationships(index_names[type], index_config)
-        end
-      end
-
-      def index_names
-        @index_names ||= Hash.new do |hash, index_type|
-          default_filename = index_prefix + @indexer_for.to_s.gsub('::', '_')
-          hash.fetch(index_type) {"#{default_filename}_#{index_type}"}
-        end
-      end
-
-      protected
-      def index_prefix
-        return "" unless Neo4j.running?
-        return "" unless @indexer_for.respond_to?(:ref_node_for_class)
-        ref_node = @indexer_for.ref_node_for_class.wrapper
-        prefix = ref_node.send(:_index_prefix) if ref_node.respond_to?(:_index_prefix)
-        prefix ||= ref_node[:name] # To maintain backward compatiblity
-        prefix.blank? ? "" : prefix + "_"
-      end
-    end
-  end
-end