neo4j 1.0.0.beta.26-java → 1.0.0.beta.27-java

data/lib/neo4j/config.rb

@@ -17,22 +17,51 @@ module Neo4j
   class Config
     # This code is copied from merb-core/config.rb.
     class << self
-      # Returns the hash of default config values for neo4j
+
+      # The location of the default configuration file
+      def default_file
+        @default_file ||= File.expand_path(File.join(File.dirname(__FILE__), "..", "..",  "config", "neo4j", "config.yml"))
+      end
+
+      # You can keep all the configuration in your own yaml file
+      # Also deletes all old configurations.
+      def default_file=(file_path)
+        @configuration = nil
+        @defaults = nil
+        @default_file = File.expand_path(file_path)
+      end
+
+      # Returns the hash of default config values for neo4j.
       #
       # ==== Returns
       # Hash:: The defaults for the config.
       def defaults
-        @defaults ||= {
-          :storage_path => 'tmp/neo4j',
-          :timestamps => true,
-          
-          :lucene => {
-                  :fulltext =>  {"provider" => "lucene", "type" => "fulltext" },
-                  :exact    =>  {"provider" => "lucene", "type" => "exact" }}
-        }
+        @defaults ||= YAML.load_file(default_file)
+      end
+
+      # Returns a Java HashMap used by the Java Neo4j API as configuration for the GraphDatabase
+      def to_java_map
+        map = java.util.HashMap.new
+        to_hash.each_pair do |k, v|
+          case v
+            when TrueClass
+              map[k.to_s] = "YES"
+            when FalseClass
+              map[k.to_s] = "NO"
+            when String, Fixnum, Float
+              map[k.to_s] = v.to_s
+            # skip list and hash values - not accepted by the Java Neo4j API
+          end
+        end
+        map
+      end
+
+
+      # Returns the expanded path of the Config[:storage_path] property
+      def storage_path
+        File.expand_path(self[:storage_path])
       end
 
-     
       # Yields the configuration.
       #
       # ==== Block parameters
@@ -116,7 +145,7 @@ module Neo4j
       # The a new configuration using default values as a hash.
       #
       def setup()
-        @configuration = {}
+        @configuration = ActiveSupport::HashWithIndifferentAccess.new(defaults)
         @configuration.merge!(defaults)
         @configuration
       end
@@ -128,7 +157,7 @@ module Neo4j
       # The config as a hash.
       #
       def to_hash
-        @configuration
+        @configuration ||= setup
       end
 
       # Returns the config as YAML.

data/lib/neo4j/database.rb

@@ -16,25 +16,46 @@ module Neo4j
     def start #:nodoc:
       return if running?
       @running = true
-      
-      if self.class.locked?
-        start_readonly_graph_db
-      else
-        start_local_graph_db
+
+      begin
+        if self.class.locked?
+          start_readonly_graph_db
+        elsif Neo4j::Config['ha.db']
+          start_ha_graph_db
+          Neo4j.migrate!
+        else
+          start_local_graph_db
+          Neo4j.migrate!
+        end
+      rescue
+        @running = false
+        raise
       end
 
       at_exit { shutdown }
     end
 
     def start_readonly_graph_db #:nodoc:
-      puts "Starting Neo4j in readonly mode since the #{Config[:storage_path]} is locked"
-      @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(Config[:storage_path])
+      Neo4j.logger.info "Starting Neo4j in readonly mode since the #{Neo4j.config.storage_path} is locked"
+      Neo4j.load_local_jars
+      @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(Config[:storage_path], Config.to_java_map)
     end
 
     def start_local_graph_db #:nodoc:
-      @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(Config[:storage_path])
+      Neo4j.logger.info "Starting local Neo4j using db #{Neo4j.config.storage_path}"
+      Neo4j.load_local_jars
+      @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(Neo4j.config.storage_path, Config.to_java_map)
+      @graph.register_transaction_event_handler(@event_handler)
+      @lucene = @graph.index
+      @event_handler.neo4j_started(self)
+    end
+
+    def start_ha_graph_db
+      Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.machine_id']} at #{Neo4j.config['ha.server']} db #{Neo4j.config.storage_path}"
+      Neo4j.load_ha_jars # those jars are only needed for the HighlyAvailableGraphDatabase
+      @graph = org.neo4j.kernel.HighlyAvailableGraphDatabase.new(Neo4j.config.storage_path, Neo4j.config.to_java_map)
       @graph.register_transaction_event_handler(@event_handler)
-      @lucene =  @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
+      @lucene = @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
       @event_handler.neo4j_started(self)
     end
 
@@ -50,7 +71,7 @@ module Neo4j
 
     # check if the database is locked. A neo4j database is locked when there is running.
     def self.locked?
-      lock_file = File.join(::Neo4j::Config[:storage_path], 'neostore')
+      lock_file = File.join(Neo4j.config.storage_path, 'neostore')
       return false unless File.exist?(lock_file)
       rfile = java.io.RandomAccessFile.new(lock_file, 'rw')
       begin
@@ -61,14 +82,14 @@ module Neo4j
         return false
       end
     end
-    
+
     def shutdown #:nodoc:
       if @running
         @graph.unregister_transaction_event_handler(@event_handler) unless read_only?
         @event_handler.neo4j_shutdown(self)
         @graph.shutdown
-        @graph  = nil
-        @lucene = nil
+        @graph   = nil
+        @lucene  = nil
         @running = false
       end
 

data/lib/neo4j/index/class_methods.rb

@@ -71,7 +71,7 @@ module Neo4j
       end
 
       def indexer(clazz, type) #:nodoc:
-        @_indexer = IndexerRegistry.create_for(self, clazz, type)
+        @_indexer ||= IndexerRegistry.create_for(self, clazz, type)
       end
     end
   end

data/lib/neo4j/index/lucene_query.rb

@@ -99,7 +99,9 @@ module Neo4j
       # Does simply loop all search items till the n'th is found.
       #
       def [](index)
-        each_with_index { |node, i| break node if index == i }
+        i = 0
+        each{|x| return x if i == index; i += 1}
+        nil # out of index
       end
 
       # Returns the number of search hits
@@ -199,7 +201,7 @@ module Neo4j
         and_query = org.apache.lucene.search.BooleanQuery.new
 
         query.each_pair do |key, value|
-          type = @decl_props[key.to_sym] && @decl_props[key.to_sym][:type]
+          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)

data/lib/neo4j/mapping/class_methods/relationship.rb

@@ -72,14 +72,13 @@ module Neo4j::Mapping
               end}, __FILE__, __LINE__)
 
         module_eval(%Q{def #{rel_type}
-                  #dsl = #{clazz}._decl_rels[:#{rel_type}]
                   dsl = _decl_rels_for(:#{rel_type})
                   dsl.single_node(self)
               end}, __FILE__, __LINE__)
 
         module_eval(%Q{def #{rel_type}_rel
+                  # TODO - use the class variable instance since we don't want to use none persisted rails relationships
                   dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-#                  dsl = _decl_rels_for(:#{rel_type})
                   dsl.single_relationship(self)
                end}, __FILE__, __LINE__)
 

data/lib/neo4j/mapping/class_methods/rule.rb

@@ -128,7 +128,7 @@ module Neo4j::Mapping
       end
 
       # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
-      # It also remove the given class method.
+      # It also remove all the rule class methods.
       def delete_rules
         singelton = class << self;
           self;
@@ -141,10 +141,42 @@ module Neo4j::Mapping
 
       # Force to trigger the rules.
       # You don't normally need that since it will be done automatically.
-      def trigger_rules(node)
-        Neo4j::Mapping::Rule.trigger_rules(node)
+      # This can be useful if you need to trigger rules on already existing nodes in the database.
+      # Can also be called from an migration.
+      #
+      def trigger_rules(node, *changes)
+        Neo4j::Mapping::Rule.trigger_rules(node, *changes)
+      end
+
+      # Returns a proc that will call add method on the given function
+      # Can be used in migration to trigger rules on already existing nodes.
+      # Parameter function_id is default to '_classname' which means that
+      # the function 'reacts' on changes on the property '_classname'.
+      # That property changes only when a node is created or deleted.
+      # Function using function_id '_classname' is typically used for counting number of nodes of a class.
+      def add_function_for(rule_name, function_name_or_class, function_id = '_classname')
+        function_for(:add, rule_name, function_name_or_class, function_id)
+      end
+
+      # See #add_function_for
+      # Calls the delete method on the function.
+      def delete_function_for(rule_name, function_name_or_class, function_id = '_classname')
+        function_for(:delete, rule_name, function_name_or_class, function_id)
       end
 
+      # Returns a proc that calls the given method on the given function.
+      def function_for(method, rule_name, function_name_or_class, function_id = '_classname')
+        function_name = function_name_or_class.is_a?(Symbol)? function_name_or_class : function_name_or_class.function_name
+        rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+        rule = rule_node.find_rule(rule_name)
+        rule_node_raw = rule_node.rule_node
+
+        function = rule_node.find_function(rule_name, function_name, function_id)
+        lambda do |node|
+          new_value = node[function_id]
+          function.send(method, rule.rule_name, rule_node_raw, new_value)
+        end
+      end
     end
 
     Neo4j.unstarted_db.event_handler.add(Neo4j::Mapping::Rule) unless Neo4j.read_only?

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -171,7 +171,7 @@ module Neo4j::Mapping
         if other_class_dsl
           @relationship = other_class_dsl.relationship_class
         else
-          puts "WARNING: Unknown outgoing relationship #{args[1]} on #{@target_class}"
+          Neo4j.logger.warn "Unknown outgoing relationship #{args[1]} on #{@target_class}"
         end
       elsif (Symbol === args[0])
         # handle unspecified (unprefixed) relationship, e.g. has_n(:known_by).from(:type)

data/lib/neo4j/mapping/has_n.rb

@@ -32,8 +32,11 @@ module Neo4j
 
       alias_method :length, :size
 
+
       def [](index)
-        each_with_index {|node,i| break node if index == i}
+        i = 0
+        each{|x| return x if i == index; i += 1}
+        nil # out of index
       end
 
       # Pretend we are an array - this is neccessarly for Rails actionpack/actionview/formhelper to work with this

data/lib/neo4j/mapping/node_mixin.rb

@@ -33,7 +33,7 @@ module Neo4j::Mapping
 
     delegate :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
              :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both, :expand, :get_property, :set_property,
-             :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel, 
+             :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel, :wrapped_entity,
              :to => :@_java_node, :allow_nil => true 
 
 

data/lib/neo4j/mapping/rule.rb

@@ -15,7 +15,7 @@ module Neo4j::Mapping
       @functions = props[:functions]
       @triggers  = [@triggers] if @triggers && !@triggers.respond_to?(:each)
       @functions = [@functions] if @functions && !@functions.respond_to?(:each)
-      @filter    = block.nil? ? Proc.new { |*| true } : block
+      @filter    = block
     end
 
     def to_s
@@ -41,7 +41,9 @@ module Neo4j::Mapping
     end
 
     def execute_filter(node)
-      if @filter.arity != 1
+      if @filter.nil?
+        true
+      elsif @filter.arity != 1
         node.wrapper.instance_eval(&@filter)
       else
         @filter.call(node)
@@ -54,9 +56,7 @@ module Neo4j::Mapping
 
     class << self
       def add(clazz, rule_name, props, &block)
-        @rule_nodes        ||= {}
-        @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
-        rule_node          = @rule_nodes[clazz.to_s]
+        rule_node = rule_node_for(clazz.to_s)
         rule_node.remove_rule(rule_name) # remove any previously inherited rules
         rule_node.add_rule(rule_name, props, &block)
       end
@@ -67,7 +67,9 @@ module Neo4j::Mapping
       end
 
       def rule_node_for(clazz)
-        @rule_nodes && @rule_nodes[clazz.to_s]
+        return nil if clazz.nil?
+        @rule_nodes             ||= {}
+        @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
       end
 
       def inherit(parent_class, subclass)
@@ -90,6 +92,7 @@ module Neo4j::Mapping
 
       def trigger_rules(node, *changes)
         classname = node[:_classname]
+        return unless classname # there are no rules if there is not a :_classname property
         rule_node = rule_node_for(classname)
         rule_node.execute_rules(node, *changes)
 

data/lib/neo4j/mapping/rule_node.rb

@@ -148,7 +148,6 @@ module Neo4j::Mapping
     end
 
     def find_functions_for_changes(rule, *changes)
-      # changes = [property, old_value, new_value]
       !changes.empty? && rule.functions_for(changes[0])
     end
 

data/lib/neo4j/migrations.rb

@@ -0,0 +1,12 @@
+require 'neo4j/migrations/extensions'
+require 'neo4j/migrations/lazy_migration_mixin'
+require 'neo4j/migrations/migration'
+require 'neo4j/migrations/migration_mixin'
+require 'neo4j/migrations/migrations'
+require 'neo4j/migrations/global_migration'
+
+module Neo4j
+  module Migrations
+
+  end
+end

data/lib/neo4j/migrations/extensions.rb

@@ -0,0 +1,57 @@
+module Neo4j
+
+  class << self
+    extend Forwardable
+
+    ##
+    # Returns the current version of the database.
+    # This version has been set by running one or more migrations.
+    # The version is stored on the reference node, with property 'db_version'
+    # (It Delegates to the Reference Node)
+    #
+    # === See Also
+    # Neo4j::MigrationMixin#db_version
+    #
+    # :singleton-method: db_version
+
+    ##
+    # Force Neo4j.rb to perform migrations
+    #
+    # === See Also
+    # Neo4j::MigrationMixin#migrate!
+    #
+    # :singleton-method: migrate!
+
+    ##
+    # Specifies a single migration.
+    # The up and down methods are automatically wrapped in a transaction.
+    #
+    # === Example
+    #
+    #   Neo4j.migration 1, :create_articles do
+    #    up do
+    #      Neo4j.ref_node.rels.outgoing(:colours) << Neo4j.Node.new(:colour => 'red')  << Neo4j.Node.new(:colour => 'blue')
+    #    end
+    #    down do
+    #      Neo4j.ref_node.rels.outgoing(:colours).each {|n| n.del }
+    #    end
+    #  end
+    #
+    # === See Also
+    # Neo4j::MigrationMixin::ClassMethods#migration
+    #
+    # :singleton-method: migration
+
+    ##
+    # Returns all migrations that has been defined.
+    #
+    # === See Also
+    # Neo4j::MigrationMixin::ClassMethods#migrations
+    #
+    # :singleton-method: migrations
+
+
+    def_delegators :'Neo4j::GlobalMigration', :db_version, :migrate!, :migrations, :migration
+
+  end
+end