neo4j-core 2.0.0.alpha.1-java → 2.0.0-java

data/lib/neo4j-core/cypher/result_wrapper.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module Core
+    module Cypher
+      # Wraps the Cypher query result.
+      # Loads the node and relationships wrapper if possible and use symbol as column keys.
+      # @notice The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
+      #
+      # @example
+      #   result = Neo4j.query(@a, @b){|a,b| node(a,b).as(:n)}
+      #   r = @query_result.to_a # can only loop once
+      #   r.size.should == 2
+      #   r.first.should include(:n)
+      #   r[0][:n].neo_id.should == @a.neo_id
+      #   r[1][:n].neo_id.should == @b.neo_id
+      class ResultWrapper
+        include Enumerable
+
+        # @return the original result from the Neo4j Cypher Engine, once forward read only !
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+        end
+
+        # @return [Array<Symbol>] the columns in the query result
+        def columns
+          @source.columns.map{|x| x.to_sym}
+        end
+
+        # for the Enumerable contract
+        def each
+          @source.each { |row| yield map(row) }
+        end
+
+        # Maps each row so that we can use symbols for column names.
+        # @private
+        def map(row)
+          out = {} # move to a real hash!
+          row.each do |key, value|
+            out[key.to_sym] = value.respond_to?(:wrapper) ? value.wrapper : value
+          end
+          out
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j-core/database.rb

@@ -53,10 +53,10 @@ module Neo4j
             start_readonly_graph_db
           elsif Neo4j::Config['ha.db']
             start_ha_graph_db
-            Neo4j.migrate!
+            Neo4j.migrate! if Neo4j.respond_to?(:migrate!)
           else
             start_local_graph_db
-            Neo4j.migrate!
+            Neo4j.migrate! if Neo4j.respond_to?(:migrate!)
           end
         rescue
           @running = false
@@ -67,7 +67,8 @@ module Neo4j
       end
 
 
-      def running? #:nodoc:
+      # true if the database has started
+      def running?
         @running
       end
 
@@ -163,8 +164,6 @@ module Neo4j
         Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.server_id']} at #{Neo4j.config['ha.server']} db #{@storage_path}"
         # Modify the public base classes for the HA Node and Relationships
         # (instead of private Java::OrgNeo4jKernel::HighlyAvailableGraphDatabase::LookupNode)
-        Neo4j::Node.extend_java_class(Java::OrgNeo4jToolingWrap::WrappedNode)
-        Neo4j::Relationship.extend_java_class(Java::OrgNeo4jToolingWrap::WrappedRelationship)
         @graph = Java::OrgNeo4jKernel::HighlyAvailableGraphDatabase.new(@storage_path, Neo4j.config.to_java_map)
         @graph.register_transaction_event_handler(@event_handler)
         @lucene = @graph.index

data/lib/neo4j-core/event_handler.rb

@@ -88,7 +88,7 @@ module Neo4j
     # You only need to implement the methods that you need.
     #
     class EventHandler
-      include org.neo4j.graphdb.event.TransactionEventHandler
+      include Java::OrgNeo4jGraphdbEvent::TransactionEventHandler
 
       def initialize
         @listeners = []

data/lib/neo4j-core/hash_with_indifferent_access.rb

@@ -0,0 +1,165 @@
+module Neo4j
+  module Core
+    # Stolen from http://as.rubyonrails.org/classes/HashWithIndifferentAccess.html
+    # We don't want to depend on active support
+    class HashWithIndifferentAccess < Hash
+
+      # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
+      def extractable_options?
+        true
+      end
+
+      def with_indifferent_access
+        dup
+      end
+
+      def nested_under_indifferent_access
+        self
+      end
+
+      def initialize(constructor = {})
+        if constructor.is_a?(Hash)
+          super()
+          update(constructor)
+        else
+          super(constructor)
+        end
+      end
+
+      def default(key = nil)
+        if key.is_a?(Symbol) && include?(key = key.to_s)
+          self[key]
+        else
+          super
+        end
+      end
+
+      def self.new_from_hash_copying_default(hash)
+        new(hash).tap do |new_hash|
+          new_hash.default = hash.default
+        end
+      end
+
+      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+      alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+      # Assigns a new value to the hash:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash[:key] = "value"
+      #
+      def []=(key, value)
+        regular_writer(convert_key(key), convert_value(value))
+      end
+
+      alias_method :store, :[]=
+
+      # Updates the instantized hash with values from the second:
+      #
+      #   hash_1 = HashWithIndifferentAccess.new
+      #   hash_1[:key] = "value"
+      #
+      #   hash_2 = HashWithIndifferentAccess.new
+      #   hash_2[:key] = "New Value!"
+      #
+      #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+      #
+      def update(other_hash)
+        if other_hash.is_a? HashWithIndifferentAccess
+          super(other_hash)
+        else
+          other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+          self
+        end
+      end
+
+      alias_method :merge!, :update
+
+      # Checks the hash for a key matching the argument passed in:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash["key"] = "value"
+      #   hash.key? :key  # => true
+      #   hash.key? "key" # => true
+      #
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      # Fetches the value for the specified key, same as doing hash[key]
+      def fetch(key, *extras)
+        super(convert_key(key), *extras)
+      end
+
+      # Returns an array of the values at the specified indices:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash[:a] = "x"
+      #   hash[:b] = "y"
+      #   hash.values_at("a", "b") # => ["x", "y"]
+      #
+      def values_at(*indices)
+        indices.collect {|key| self[convert_key(key)]}
+      end
+
+      # Returns an exact copy of the hash.
+      def dup
+        self.class.new(self).tap do |new_hash|
+          new_hash.default = default
+        end
+      end
+
+      # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
+      # Does not overwrite the existing hash.
+      def merge(hash)
+        self.dup.update(hash)
+      end
+
+      # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+      # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
+      def reverse_merge(other_hash)
+        super self.class.new_from_hash_copying_default(other_hash)
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge( other_hash ))
+      end
+
+      # Removes a specified key from the hash.
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def stringify_keys!; self end
+      def stringify_keys; dup end
+#      undef :symbolize_keys!
+      def symbolize_keys; to_hash.symbolize_keys end
+      def to_options!; self end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge!(self)
+      end
+
+      protected
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
+
+        def convert_value(value)
+          if value.is_a? Hash
+            value #.nested_under_indifferent_access
+          elsif value.is_a?(Array)
+            value.dup.replace(value.map { |e| convert_value(e) })
+          else
+            value
+          end
+        end
+    end
+
+  end
+end

data/lib/neo4j-core/index/class_methods.rb

@@ -7,7 +7,6 @@ module Neo4j
         attr_reader :_indexer
 
 
-        # TODO fix YARD docs update using DSL
         # Sets which indexer should be used for the given node class.
         # You can share an indexer between several different classes.
         #
@@ -20,49 +19,18 @@ module Neo4j
         #      node_indexer do
         #        index_names :exact => 'myindex_exact', :fulltext => 'myindex_fulltext'
         #        trigger_on :ntype => 'foo', :name => ['bar', 'foobar']
-        #        # TODO multitenancy support
-        #        prefix_index_name do
-        #          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
-        #
         #
-        #        TODO ...
-        #        numeric do
-        #           type = decl_props && decl_props[field.to_sym] && decl_props[field.to_sym][:type]
-        #           type && !type.is_a?(String)
+        #        prefix_index_name do
+        #          "Foo"  # this is used for example in multitenancy to let each domain have there own index files
         #        end
         #      end
         #   end
         #
-        # @example Using Neo4j::NodeMixin
-        #
-        #   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 !
-        #
+        # @param [Neo4j::Core::Index::IndexConfig] config the configuration used as context for the config_dsl
         # @return [Neo4j::Core::Index::Indexer] The indexer that should be used to index the given class
         # @see Neo4j::Core::Index::IndexConfig for possible configuration values in the +config_dsl+ block
         # @yield evaluated in the a Neo4j::Core::Index::IndexConfig object to configure it.
-        def node_indexer(&config_dsl)
-          # TODO reuse an existing index config
-          config = IndexConfig.new(:node)
+        def node_indexer(config = _config || IndexConfig.new(:node), &config_dsl)
           config.instance_eval(&config_dsl)
           indexer(config)
         end
@@ -70,17 +38,32 @@ module Neo4j
         # Sets which indexer should be used for the given relationship class
         # Same as #node_indexer except that it indexes relationships instead of nodes.
         #
-        # @see #node_indexer
-        # @return [Neo4j::Core::Index::Indexer] The indexer that should be used to index the given class
-        def rel_indexer(clazz)
-          indexer(clazz, :rel)
+        # @param (see #node_indexer)
+        # @return (see #node_indexer)
+        def rel_indexer(config = _config || IndexConfig.new(:rel), &config_dsl)
+          config.instance_eval(&config_dsl)
+          indexer(config)
         end
 
+        def _config
+          @_indexer && @_indexer.config
+        end
 
         def indexer(index_config)
           @_indexer ||= IndexerRegistry.instance.register(Indexer.new(index_config))
         end
 
+        # You can specify which nodes should be triggered.
+        # The index can be triggered by one or more properties having one or more values.
+        # This can also be done using the #node_indexer or #rel_indexer methods.
+        #
+        # @example trigger on property :type being 'MyType1'
+        #   Neo4j::NodeIndex.trigger_on(:type => 'MyType1')
+        #
+        def trigger_on(hash)
+          _config.trigger_on(hash)
+        end
+
 
         class << self
           private
@@ -93,7 +76,7 @@ module Neo4j
           def delegate(method_name)
             class_eval(<<-EOM, __FILE__, __LINE__)
               def #{method_name}(*args, &block)
-                @_indexer.send(:#{method_name}, *args, &block)
+                _indexer.send(:#{method_name}, *args, &block)
               end
             EOM
           end
@@ -109,6 +92,9 @@ module Neo4j
         delegate :add_index
         delegate :rm_index
         delegate :index_type
+        delegate :index_name_for_type
+        delegate :index_for_type
+        delegate :put_if_absent
       end
 
 

data/lib/neo4j-core/index/index.rb

@@ -2,7 +2,7 @@ module Neo4j
   module Core
 
     # A mixin which adds indexing behaviour to your own Ruby class
-    # You are expected to implement the method `wrapped_entity` returning the underlying Neo4j Node or Relationship
+    # You are expected to implement the method `_java_entity` returning the underlying Neo4j Node or Relationship.
     module Index
 
       # Adds an index on the given property
@@ -16,8 +16,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#add_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)
+        self.class.add_index(_java_entity, field.to_s, value)
       end
 
       # Removes an index on the given property.
@@ -27,7 +26,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#rm_index
       #
       def rm_index(field, value=self[field])
-        self.class.rm_index(wrapped_entity, field.to_s, value)
+        self.class.rm_index(_java_entity, field.to_s, value)
       end
 
     end

data/lib/neo4j-core/index/index_config.rb

@@ -5,14 +5,25 @@ module Neo4j
       # Responsible for holding the configuration for one index
       # Is used in a DSL to configure the index.
       class IndexConfig
-        attr_reader :_trigger_on, :_index_names, :entity_type
+        attr_reader :_trigger_on, :_index_names, :entity_type, :_index_type, :_field_types
 
+        # @param [:rel, :node] entity_type the type of index
         def initialize(entity_type)
           @entity_type = entity_type
-          @index_type = {}
-          @numeric_types = []
+          @_index_type = {}
+          @_field_types = {}
           @_trigger_on = {}
-          @decl_type = {}
+        end
+
+        def to_s
+          "IndexConfig [#@entity_type, _index_type: #{@_index_type.inspect}, _field_types: #{@_field_types.inspect}, _trigger_on: #{@_trigger_on.inspect}]"
+        end
+
+        def inherit_from(clazz)
+          c = clazz._indexer.config
+          raise "Can't inherit from different index type #{@entity_type} != #{c.entity_type}" if @entity_type != c.entity_type
+          @_index_type.merge!(c._index_type)
+          @_field_types.merge!(c._field_types)
         end
 
         # Specifies which property and values the index should be triggered on.
@@ -22,11 +33,8 @@ module Neo4j
           merge_and_to_string(@_trigger_on, hash)
         end
 
-        # Specifies the types of the properties being indexed so that the proper sort order can be applied.
-        # Used in the Index DSL.
-        # @see Neo4j::Core::Index::ClassMethods#node_indexer
-        def decl_type(prop_and_type_hash)
-          merge_and_to_string(@decl_type, prop_and_type_hash)
+        def field_type(key)
+          @_field_types[key.to_s]
         end
 
         # Specifies an index with configuration
@@ -37,15 +45,15 @@ module Neo4j
           conf = args.last.kind_of?(Hash) ? args.pop : {}
 
           args.uniq.each do |field|
-            @index_type[field.to_s] = conf[:type] || :exact
-            @numeric_types << field.to_s if conf[:numeric] == true
+            @_index_type[field.to_s] = conf[:type] || :exact
+            @_field_types[field.to_s] = conf[:field_type] || String
           end
         end
 
-        # @return [Class] the specified type of the property or String
+        # @return [Class,nil] the specified type of the property or nil
         # @see #decl_type
         def decl_type_on(prop)
-          @decl_type[prop] || String
+          @_field_types[prop]
         end
 
         # @return [true, false] if the props can/should trigger an index operation
@@ -71,31 +79,30 @@ module Neo4j
           @_index_names = hash
         end
 
-
         def rm_index_config
-          @index_type = {}
-          @numeric_types = []
+          @_index_type = {}
+          @_field_types = {}
         end
 
         def index_type(field)
-          @index_type[field.to_s]
+          @_index_type[field.to_s]
         end
 
         def has_index_type?(type)
-          @index_type.values.include?(type)
+          @_index_type.values.include?(type)
         end
 
         def fields
-          @index_type.keys
+          @_index_type.keys
         end
 
         def index?(field)
-          @index_type.include?(field.to_s)
+          @_index_type.include?(field.to_s)
         end
 
         def numeric?(field)
-          return true if @numeric_types.include?(field)
-          # TODO callback to numeric dsl for Neo4j::NodeMixin decl_props check
+          raise "No index on #{field.inspect}, has fields: #{@field_types.inspect}" unless @_field_types[field]
+          @_field_types[field] != String
         end
 
         private
@@ -103,7 +110,7 @@ module Neo4j
         def merge_and_to_string(existing_hash, new_hash)
           new_hash.each_pair do |k, v|
             existing_hash[k.to_s] ||= Set.new
-            existing_hash[k.to_s].merge(v.is_a?(Array)? v : [v])
+            existing_hash[k.to_s].merge(v.is_a?(Array) ? v : [v])
           end
         end
       end