neo4j 1.0.0.beta.19 → 1.0.0.beta.20

data/CONTRIBUTORS

@@ -3,6 +3,7 @@ Maintainer:
 
 Contributors:
 * Ben Jackson
+* Dwight van Tuyl
 * Martin Kleppmann
 * Peter Neubauer
 * Jan-Felix Wittmann

data/Gemfile

@@ -11,6 +11,6 @@ group 'test' do
   gem "test-unit"
 end
 
-gem 'ruby-debug-base19' if RUBY_VERSION.include? "1.9"
-gem 'ruby-debug-base' if RUBY_VERSION.include? "1.8"
-gem "ruby-debug-ide"
+#gem 'ruby-debug-base19' if RUBY_VERSION.include? "1.9"
+#gem 'ruby-debug-base' if RUBY_VERSION.include? "1.8"
+#gem "ruby-debug-ide"

data/README.rdoc

@@ -26,8 +26,8 @@ Here are some of the major benefits of Neo4j.rb
 
 === Documentation
 
-* {Documentation and Getting Started with Neo4j}[http://github.com/andreasronge/neo4j/wiki]
-* {API Documentation (released version)}[http://neo4j.rubyforge.org]
+* {API Documentation}[http://neo4j.rubyforge.org]
+* {Documentation and Getting Started with Neo4j}[http://neo4j.rubyforge.org/guides/index.html]
 
 === Some Examples
 
@@ -39,8 +39,8 @@ Example of creating a Neo4j::Node
   require 'neo4j'
 
   Neo4j::Transaction.run do
-    node = Neo4j::Node.new :name => 'andreas'
-    node.outgoing(:friends) << Neo4j::Node.new :name => 'peter'
+    node = Neo4j::Node.new (:name => 'andreas')
+    node.outgoing(:friends) << Neo4j::Node.new (:name => 'peter')
     node.outgoing(:friends).each {|node| puts "name #{node[:name]}"}
   end
 
@@ -59,8 +59,8 @@ Example of mapping a ruby class to a node and delaring properties and relationsh
   end
 
   # assume we have an transaction already running
-  andreas = Person.new :name => 'andreas'
-  andreas.friends << Person.new :name => 'peter'
+  andreas = Person.new (:name => 'andreas')
+  andreas.friends << Person.new (:name => 'peter')
   andreas.friends.each {|person| puts "name #{person.name}" }
   Person.find("name: andreas").first.name # => 'andreas'
 
@@ -88,6 +88,28 @@ Example of using Neo4j with Rails 3 (ActiveModel)
     ...
   end
 
+==== Generate a Rails Application
+
+Example of creating an Neo4j Application from scratch:
+
+ gem install rails
+ rails new myapp -m http://andreasronge.github.com/rails3.rb
+ cd myapp
+ bundle
+ rails generate scaffold User name:string email:string
+ rails s
+ open a webbrowser: http://localhost:3000/users
+
+You may get an error message "ERROR IOError: Connection reset by peer"
+using WEBrick (it still works). This error message is not shown when running
+the application with {Tomcat/Trinidad}[https://github.com/calavera/trinidad]
+
+To run it with Tomcat
+  
+  gem install trinidad
+  trinidad
+
+
 === Presentation Materials and other URLs
 * {Intoduction to Neo4j.rb}[http://www.slideshare.net/andreasronge/neo4jrb]
 * {Nordic Ruby 2010 May 21-23}[http://nordicruby.org/speakers#user_29]

data/lib/generators/neo4j/model/model_generator.rb

@@ -9,7 +9,7 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base
 	class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
 	
 	def create_model_file
-		template "model.rb", File.join('app/models', "#{singular_name}.rb")
+		template "model.erb", File.join('app/models', "#{singular_name}.rb")
 	end
 	
 	protected
@@ -27,11 +27,11 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base
 	
 	def timestamp_statements
 		%q{
-property :created_at, DateTime
-# property :created_on, Date
+  property :created_at, DateTime
+  # property :created_on, Date
 
-property :updated_at, DateTime
-# property :updated_on, Date
+  property :updated_at, DateTime
+  # property :updated_on, Date
 }            
 	end
 	

data/lib/generators/neo4j/model/templates/{model.rb → model.erb}

@@ -1,6 +1,6 @@
 class <%= class_name %> < <%= parent? ? options[:parent].classify : "Neo4j::Rails::Model" %>
 <% attributes.each do |attribute| -%>
-	property :<%= attribute.name %><%= ", :type => #{attribute.type_class}" unless attribute.type_class == "String" %>
+  property :<%= attribute.name %><%= ", :type => #{attribute.type_class}" %>
 <% end -%>
 
 <%= timestamp_statements if timestamps? -%>

data/lib/neo4j.rb

@@ -20,7 +20,7 @@ require 'neo4j/neo4j'
 
 require 'neo4j/index/index'
 require 'neo4j/index/class_methods'
-require 'neo4j/index/index_registry'
+require 'neo4j/index/indexer_registry'
 require 'neo4j/index/indexer'
 require 'neo4j/index/lucene_query'
 require 'neo4j/relationship_traverser'
@@ -53,8 +53,11 @@ require 'neo4j/rails/tx_methods'
 require 'neo4j/rails/transaction'
 require 'neo4j/rails/railtie'
 require 'neo4j/rails/validations/uniqueness'
+require 'neo4j/rails/validations/non_nil'
+require 'neo4j/rails/finders'
+require 'neo4j/rails/mapping/property'
 require 'neo4j/rails/model'
-require 'neo4j/rails/properties'
+require 'neo4j/rails/value_properties'
 require 'neo4j/rails/value'
 require 'neo4j/rails/lucene_connection_closer'
 

data/lib/neo4j/config.rb

@@ -26,6 +26,13 @@ module Neo4j
         @defaults ||= {
           :storage_path => 'tmp/neo4j',
           :timestamps => true,
+          
+          # TODO: Just pickup all converter classes that are in the Neo4j::TypeConverters module?
+          :converters => { 	Date 			=> Neo4j::TypeConverters::DateConverter, 
+          									DateTime 	=> Neo4j::TypeConverters::DateTimeConverter,
+          									Time 			=> Neo4j::TypeConverters::TimeConverter
+          								},
+          								
           :lucene => {
                   :fulltext =>  {"provider" => "lucene", "type" => "fulltext" },
                   :exact =>  {"provider" => "lucene", "type" => "exact" }}

data/lib/neo4j/index/indexer.rb

@@ -83,7 +83,7 @@ module Neo4j
           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.to_class._indexer
+          via_indexer = rel_dsl.target_class._indexer
 
           field = field.to_s
           @via_relationships[field] = rel_dsl
@@ -99,7 +99,7 @@ module Neo4j
         @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.to_class._indexer
+          indexer = dsl.target_class._indexer
           tx_data.deleted_relationships.each do |rel|
             start_node = rel._start_node
             next if node != rel._end_node
@@ -122,14 +122,14 @@ module Neo4j
         # 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.incoming_dsl.namespace_type == rel_type
+          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.to_class._indexer
+          indexer   = dsl.target_class._indexer
 
           # is the relationship created or deleted ?
           if is_created
@@ -143,11 +143,11 @@ module Neo4j
       def update_index_on(node, field, old_val, new_val) #:nodoc:
         if @via_relationships.include?(field)
           dsl = @via_relationships[field]
-          to_class = dsl.to_class
+          target_class = dsl.target_class
 
           dsl._all_relationships(node).each do |rel|
             other = rel._start_node
-            to_class._indexer.update_single_index_on(other, field, old_val, new_val)
+            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)
@@ -309,4 +309,4 @@ module Neo4j
 
   end
 
-end
+end

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

@@ -75,7 +75,6 @@ module Neo4j::Mapping
         return false if _decl_props[prop_name.to_sym].nil?
         _decl_props[prop_name.to_sym][:defined] == true
       end
-
     end
   end
 end

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -33,39 +33,26 @@ module Neo4j::Mapping
   class DeclRelationshipDsl
     include Neo4j::ToJava
 
-    attr_reader :to_type, :to_class, :cascade_delete_prop_name, :counter, :rel_id, :direction
+    attr_reader :target_class, :direction, :rel_type
 
-    def initialize(rel_id, has_one, to_class, params)
-      @direction = :outgoing
-      @rel_id = rel_id
-      @to_type = rel_id
-      @has_one = has_one
-      @namespace_type = rel_id
-      @to_class = to_class
-    end
-
-    def has_one?
-      @has_one
+    def initialize(method_id, has_one, target_class, params)
+      @direction    = :outgoing
+      @method_id    = method_id
+      @has_one      = has_one
+      @rel_type     = method_id
+      @target_class = target_class
     end
 
-    def class_and_type_from_args(args) # :nodoc:
-      if (args.size > 1)
-        return args[0], args[1]
-      elsif (Symbol === args[0])
-        return @to_class, args[0]
-      else
-        return args[0], @rel_id
-      end
+    def to_s
+      "DeclRelationshipDsl #{object_id} dir: #{@direction} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_class} rel_class:#{@relationship}"
     end
 
-
-    # The actual relationship type that this DSL will use
-    def namespace_type
-      @namespace_type
+    def has_one?
+      @has_one
     end
 
-    def each_node(node, direction, &block)
-      type = type_to_java(namespace_type)
+    def each_node(node, direction, &block) #:nodoc:
+      type = type_to_java(rel_type)
       dir  = dir_to_java(direction)
       node._java_node.getRelationships(type, dir).each do |rel|
         other = rel.getOtherNode(node).wrapper
@@ -73,59 +60,35 @@ module Neo4j::Mapping
       end
     end
 
-    def incoming?
+    def incoming? #:nodoc:
       @direction == :incoming
     end
 
-    def incoming_dsl
-      dsl = @to_class._decl_rels[to_type]
-      raise "Unspecified outgoing relationship '#{to_type}' for incoming relationship '#{rel_id}' on class #{to_class}" if dsl.nil?
-      dsl
-    end
-
-    def single_node(node)
+    def single_node(node) #:nodoc:
       rel = single_relationship(node)
       rel && rel.other_node(node).wrapper
     end
 
-    def single_relationship(node)
-      dir = direction
-      dsl = incoming? ? incoming_dsl : self
-      node._java_node.rel(dir, dsl.namespace_type)
+    def single_relationship(node) #:nodoc:
+      node._java_node.rel(direction, rel_type)
     end
 
-    def _all_relationships(node)
-      dsl = incoming? ? incoming_dsl : self
-      type = type_to_java(dsl.namespace_type)
+    def _all_relationships(node) #:nodoc:
+      type = type_to_java(rel_type)
       dir  = dir_to_java(direction)
       node._java_node.getRelationships(type, dir)
     end
 
-    def all_relationships(node)
-      dsl = incoming? ? incoming_dsl : self
-      Neo4j::RelationshipTraverser.new(node._java_node, [dsl.namespace_type], direction)
+    def all_relationships(node) #:nodoc:
+      Neo4j::RelationshipTraverser.new(node._java_node, [rel_type], direction)
     end
 
-    def create_relationship_to(node, other)
-    	if incoming?
-    		# If we are creating an incoming relationship, we need to swap incoming and outgoing nodes
-    		dsl = incoming_dsl
-    		from, to = other, node
-    	else
-    		dsl = self
-    		from, to = node, other
-    	end
-
-      java_type = type_to_java(dsl.namespace_type)
-
-      rel = from._java_node.create_relationship_to(to._java_node, java_type)
-      rel[:_classname] =  dsl.relationship_class.to_s if dsl.relationship_class
-
-      # TODO - not implemented yet
-      # the from.neo_id is only used for cascade_delete_incoming since that node will be deleted when all the list items has been deleted.
-      # if cascade_delete_outgoing all nodes will be deleted when the root node is deleted
-      # if cascade_delete_incoming then the root node will be deleted when all root nodes' outgoing nodes are deleted
-      #rel[@dsl.cascade_delete_prop_name] = node.neo_id if @dsl.cascade_delete?
+    def create_relationship_to(node, other) # :nodoc: 
+      from, to = incoming? ? [other, node] : [node, other]
+      java_type = type_to_java(rel_type)
+
+      rel       = from._java_node.create_relationship_to(to._java_node, java_type)
+      rel[:_classname] = relationship_class.to_s if relationship_class
       rel.wrapper
     end
 
@@ -148,33 +111,74 @@ module Neo4j::Mapping
     #
     def to(*args)
       @direction = :outgoing
-      @to_class, @to_type = class_and_type_from_args(args)
-      @namespace_type = "#{@to_class.to_s}##{@to_type.to_s}"
+
+      if (args.size > 1)
+        raise "only one argument expected - the class of the node this relationship points to, got #{args.inspect}"
+      elsif (Class === args[0])
+        # handle e.g. has_n(:friends).to(class)
+        @target_class = args[0]
+        @rel_type     = "#{@target_class}##{@method_id}"
+      else
+        raise "Expected a class for, got #{args[0]}"
+      end
       self
     end
 
     # Specifies an incoming relationship.
     # Will use the outgoing relationship given by the from class.
     #
-    # ==== Example
+    # ==== Example, with prefix FileNode
     #   class FolderNode
     #     include Neo4j::NodeMixin
     #     has_n(:files).to(FileNode)
     #   end
     #
-    #  class FileNode
-    #    include Neo4j::NodeMixin
-    #    has_one(:folder).from(FileNode, :files)
-    #  end
+    #   class FileNode
+    #     include Neo4j::NodeMixin
+    #     # will only traverse any incoming relationship of type files from node FileNode
+    #     has_one(:folder).from(FileNode, :files)
+    #   end
+    #
+    #   file = FileNode.new
+    #   # create an outgoing relationship of type 'FileNode#files' from folder node to file (FileNode is the prefix).
+    #   file.folder = FolderNode.new
+    #
+    # ==== Example, without prefix
+    #
+    #   class FolderNode
+    #     include Neo4j::NodeMixin
+    #     has_n(:files)
+    #   end
+    #
+    #   class FileNode
+    #     include Neo4j::NodeMixin
+    #     has_one(:folder).from(:files)  # will traverse any incoming relationship of type files
+    #   end
+    #
+    #   file = FileNode.new
+    #   # create an outgoing relationship of type 'FileNode#files' from folder node to file
+    #   file.folder = FolderNode.new
     #
-    #  file = FileNode.new
-    #  # create an outgoing relationship of type 'FileNode#files' from folder node to file
-    #  file.folder = FolderNode.new
     #
     def from(*args)
-      #(clazz, type)
       @direction = :incoming
-      @to_class, @to_type = class_and_type_from_args(args)
+
+      if (args.size > 1)
+        # handle specified (prefixed) relationship, e.g. has_n(:known_by).from(clazz, :type)
+        @rel_type       = "#{@target_class}##{args[1]}"
+        @target_class   = args[0]
+        other_class_dsl = @target_class._decl_rels[args[1]]
+        if other_class_dsl
+          @relationship = other_class_dsl.relationship_class
+        else
+          puts "WARNING: 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)
+        @rel_type = args[0]
+      else
+        raise "Expected a symbol for, got #{args[0]}"
+      end
       self
     end
 

data/lib/neo4j/mapping/has_n.rb

@@ -17,11 +17,11 @@ module Neo4j
       def initialize(node, dsl) # :nodoc:
         @node = node
         @direction = dsl.direction
-        @dsl = @direction == :outgoing ? dsl : dsl.incoming_dsl
+        @dsl = dsl
       end
 
       def to_s
-        "HasN [#@direction, #{@node.neo_id} #{@dsl.namespace_type}]"
+        "HasN [#@direction, id: #{@node.neo_id} type: #{@dsl.rel_type} dsl:#{@dsl}]"
       end
 
       def size
@@ -74,11 +74,7 @@ module Neo4j
       # self
       #
       def <<(other)
-      	if @direction == :incoming && @dsl.direction == :outgoing
-      		@dsl.create_relationship_to(other, @node)
-      	else
-      		@dsl.create_relationship_to(@node, other)
-      	end
+        @dsl.create_relationship_to(@node, other)
         self
       end
     end

data/lib/neo4j/neo4j.rb

@@ -86,5 +86,10 @@ module Neo4j
     def event_handler(this_db = default_db)
       this_db.event_handler
     end
+    
+    # Ruby to Java type converters
+    def converters
+    	Neo4j::Config[:converters] || {}
+    end
   end
 end

data/lib/neo4j/node_traverser.rb

@@ -61,8 +61,14 @@ module Neo4j
     end
 
     def new(other_node)
-      raise "Only allowed to create outgoing relationships, please add it on the other node if you want to create an incoming relationship" unless @dir == org.neo4j.graphdb.Direction::OUTGOING
-      @from.create_relationship_to(other_node, @type)
+      case @dir
+        when org.neo4j.graphdb.Direction::OUTGOING
+          @from.create_relationship_to(other_node, @type)
+        when org.neo4j.graphdb.Direction::INCOMING
+          other_node._java_node.create_relationship_to(@from, @type)
+        else
+          raise "Only allowed to create outgoing or incoming relationships (not #@dir)"
+      end
     end
 
     def both(type)

data/lib/neo4j/property.rb

@@ -27,8 +27,9 @@ module Neo4j
     #
     def attributes
       attr = props
-      attr.keys.each { |k| attr.delete k if k[0] == ?_ }
-      attr
+      ret = {}
+      attr.each_pair { |k, v| ret[k] = wrapper.respond_to?(k) ? wrapper.send(k) : v unless k.to_s[0] == ?_ }
+      ret
     end
 
     # Checks if the given key exist as a property.
@@ -107,4 +108,4 @@ module Neo4j
     end
 
   end
-end
+end

data/lib/neo4j/rails/finders.rb

@@ -0,0 +1,121 @@
+module Neo4j
+	module Rails
+		module Finders
+			extend ActiveSupport::Concern
+			
+			included do
+				rule :_all
+			end
+			
+			module ClassMethods
+				# overwrite the index method to add find_by_xxx class methods
+				def index(*args)
+					field = args.first
+					module_eval <<-RUBY, __FILE__, __LINE__
+						def self.all_by_#{field}(value)
+							find_with_indexer("#{field}: \\"\#{value}\\"")
+						end
+						
+						def self.find_by_#{field}(value)
+							all_by_#{field}(value).first
+						end
+					RUBY
+					
+					super
+				end
+				
+				# load an id or array of ids from the database
+				def load(*ids)
+          result = ids.map { |id| Neo4j::Node.load(id) }
+          if ids.length == 1
+            result.first
+          else
+            result
+          end
+        end
+        
+				# Behave like the ActiveRecord query interface
+				
+				# Handle Model.find(params[:id])
+				
+				# Model.find
+				# Model.find(:first)
+				
+				# Model.find("1")
+				# Model.find(1)
+				
+				# Model.find("name: test")
+				# Model.find(:name => "test")
+				
+				# Model.find(:first, "name: test")
+				# Model.find(:first, { :name => "test" })
+				
+				# Model.find(:first, :conditions => "name: test")
+				# Model.find(:first, :conditions => { :name => "test" })
+				
+				# Model.find(:all, "name: test")
+				# Model.find(:all, { :name => "test" })
+				
+				# Model.find(:all, :conditions => "name: test")
+				# Model.find(:all, :conditions => { :name => "test" })
+        def find(*args)
+        	case args.first
+        	when :all, :first
+        		kind = args.shift
+        		send(kind, *args)
+        	else
+        		find_with_ids(*args) or first(*args)
+        	end
+        end
+        
+				def all(*args)
+					if args.empty?
+						# use the _all rule to recover all the stored instances of this node
+						_all
+					else
+						args = normalize_args(*args)
+						# handle the special case of a search by id
+						if args.first.is_a?(Hash) && args.first[:id]
+							[find_with_ids(args.first[:id])].flatten
+						else
+							find_with_indexer(*args)
+						end
+					end
+				end
+				
+				def first(*args)
+					all(*args).first
+				end
+				
+				protected
+				def find_with_ids(*args)
+					if ((args.first.is_a?(String) || args.first.is_a?(Integer)) && args.first.to_i > 0)
+						load(*args.map { |p| p.to_i })
+					end
+				end
+				
+				def find_with_indexer(*args)
+					hits = _indexer.find(*args)
+					# We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
+					Thread.current[:neo4j_lucene_connection] ||= []
+					Thread.current[:neo4j_lucene_connection] << hits
+					hits
+				end
+				
+				def normalize_args(*args)
+					options = args.extract_options!
+					
+					if options.present?
+						if options[:conditions]
+							args << options[:conditions]
+						else
+							args << options
+						end
+					end
+					args
+				end
+      end
+		end
+	end
+end
+

data/lib/neo4j/rails/mapping/property.rb

@@ -0,0 +1,35 @@
+module Neo4j
+	module Rails
+		module Mapping
+			module Property
+				extend ActiveSupport::Concern
+					
+				def []=(key, value)
+					attribute_will_change!(key.to_s) if self[key.to_s] != value
+					super
+				end
+				
+				module ClassMethods
+					# Handle some additional options for the property
+					#
+					# Set a default - 							:default => "default"
+					# Prpoerty must be there - 			:null => false
+					# Property has a length limit - :limit => 128
+					def property(*args)
+						super
+						handle_property_options_for(args.first)
+					end
+					
+					protected
+					def handle_property_options_for(property)
+						options = _decl_props[property.to_sym]
+		
+						write_inheritable_attribute(:attribute_defaults, property => options[:default]) if options[:default]
+						validates(property, :non_nil => true) if options.has_key?(:null) && options[:null] == false
+						validates(property, :length => { :maximum => options[:limit] }) if options[:limit]
+					end
+				end
+			end
+		end
+	end
+end

data/lib/neo4j/rails/model.rb

@@ -2,6 +2,7 @@ module Neo4j
   module Rails
     class Model
       include Neo4j::NodeMixin
+      
       include ActiveModel::Serializers::Xml
       include ActiveModel::Validations
       include ActiveModel::Dirty
@@ -9,14 +10,19 @@ module Neo4j
 
       extend ActiveModel::Naming
       extend ActiveModel::Callbacks
-      extend Neo4j::Validations::ClassMethods
+      
+      include Neo4j::Rails::Validations
+      extend 	Neo4j::Rails::Validations::ClassMethods
+      
+      include Finders						# ActiveRecord style find
+      include Mapping::Property	# allows some additional options on the #property class method
+      
       extend TxMethods
 
-      define_model_callbacks :create, :save, :update, :destroy
-
-      rule :all
+      class_inheritable_hash :attribute_defaults
+      self.attribute_defaults = {}
       
-      UniquenessValidator = Neo4j::Validations::UniquenessValidator
+      define_model_callbacks :create, :save, :update, :destroy
 
       class RecordInvalidError < RuntimeError
         attr_reader :record
@@ -63,31 +69,15 @@ module Neo4j
           self.class.define_attribute_methods(self.class._decl_props.keys)
           # try again
           send(method_id, *args, &block)
+        elsif property?(method_id)
+        	send(:[], method_id)
+        else
+        	super
         end
       end
 
-      # redefine this methods so that ActiveModel::Dirty will work
-      def []=(key, new_value)
-        key = key.to_s
-        unless key[0] == ?_
-          old_value = self.send(:[], key)
-          attribute_will_change!(key) unless old_value == new_value
-        end
-        Neo4j::Rails::Transaction.running? ? super : Neo4j::Rails::Transaction.run { super }
-      end
-
-      def attribute_will_change!(attr)
-        begin
-          value = __send__(:[], attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
-        end
-        changed_attributes[attr] = value
-      end
-
-
       def read_attribute_for_validation(key)
-        respond_to?(key) ? send(key) : self[key]
+        send(key)
       end
 
       def attributes=(values)
@@ -159,9 +149,9 @@ module Neo4j
         end
       end
 
-      def save
+      def save(*args)
         _run_save_callbacks do
-          if create_or_update_node
+          if create_or_update_node(*args)
             true
           else
             # if not valid we should rollback the transaction so that the changes does not take place.
@@ -172,11 +162,13 @@ module Neo4j
         end
       end
 
-      def create_or_update_node
-        if valid?(:save)
+      def create_or_update_node(options = {})
+      	options.reverse_merge!({ :validate => true })
+      	
+      	if options[:validate] == false || valid?(:save)
           if new_record?
             _run_create_callbacks do
-              if valid?(:create)
+              if options[:validate] == false || valid?(:create)
                 node = Neo4j::Node.new(props)
                 return false unless _java_node.save_nested(node)
                 init_on_load(node)
@@ -188,7 +180,7 @@ module Neo4j
             end
           else
             _run_update_callbacks do
-              if valid?(:update)
+              if options[:validate] == false || valid?(:update)
                 clear_changes
                 self.updated_at = DateTime.now if Neo4j::Config[:timestamps] && respond_to?(:updated_at)
                 true
@@ -208,8 +200,8 @@ module Neo4j
 				reload_from_database or set_deleted_properties and return self
       end
       
-      def save!
-        raise RecordInvalidError.new(self) unless save
+      def save!(*args)
+        raise RecordInvalidError.new(self) unless save(*args)
       end
 
       # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
@@ -245,7 +237,8 @@ module Neo4j
         @_deleted
       end
 
-      tx_methods :destroy, :create_or_update_node, :update_attributes, :update_attributes!
+      # TODO: []= shouldn't need to be in a transaction because it shouldn't update the DB.  Need to refactor the @_java_node handling stuff if we want that to be the case though
+      tx_methods :destroy, :create_or_update_node, :[]=, :update_attributes, :update_attributes!, :update_nested_attributes
 
       # --------------------------------------
       # Class Methods
@@ -259,45 +252,10 @@ module Neo4j
           wrapped = self.orig_new
           value = Neo4j::Rails::Value.new(wrapped)
           wrapped.init_on_load(value)
-          wrapped.attributes=args[0] if args[0].respond_to?(:each_pair)
+          wrapped.attributes = initial_attributes(*args)
           wrapped
         end
 
-        # Behave like ActiveModel
-        def all_with_args(*args)
-					if args.empty?
-						all_without_args
-					else
-						hits = find_without_checking_for_id(*args)
-						# We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
-						Thread.current[:neo4j_lucene_connection] ||= []
-						Thread.current[:neo4j_lucene_connection] << hits
-						hits
-					end
-        end
-	
-        alias_method_chain :all, :args
-        
-        # Handle Model.find(params[:id])
-        def find_with_checking_for_id(*args)
-        	if args.length == 1 && String === args[0] && args[0].to_i != 0
-            load(*args)
-          else
-            all_with_args(*args).first
-          end
-        end
-
-        alias_method_chain :find, :checking_for_id
-
-        def load(*ids)
-          result = ids.map { |id| Neo4j::Node.load(id) }
-          if ids.length == 1
-            result.first
-          else
-            result
-          end
-        end
-
         alias_method :_orig_create, :create
 
         def create(*args)
@@ -308,10 +266,10 @@ module Neo4j
         	new(*args).tap { |o| o.save! }
         end
 
-        tx_methods :create, :create!
-
         def transaction(&block)
-          Neo4j::Rails::Transaction.run &block
+          Neo4j::Rails::Transaction.run do |tx|
+            block.call(tx)
+          end 
         end
 
         def accepts_nested_attributes_for(*attr_names)
@@ -320,29 +278,33 @@ module Neo4j
           attr_names.each do |association_name|
             rel = self._decl_rels[association_name.to_sym]
             raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
-            to_class = rel.to_class
-            raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless to_class
-            type = rel.namespace_type
+            target_class = rel.target_class
+            raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless target_class
+            type = rel.rel_type
             has_one = rel.has_one?
 
             send(:define_method, "#{association_name}_attributes=") do |attributes|
               if has_one
-                update_nested_attributes(type, to_class, true, attributes, options)
+                update_nested_attributes(type, target_class, true, attributes, options)
               else
                 if attributes.is_a?(Array)
                   attributes.each do |attr|
-                    update_nested_attributes(type, to_class, false, attr, options)
+                    update_nested_attributes(type, target_class, false, attr, options)
                   end
                 else
                   attributes.each_value do |attr|
-                    update_nested_attributes(type, to_class, false, attr, options)
+                    update_nested_attributes(type, target_class, false, attr, options)
                   end
                 end
               end
             end
-            tx_methods("#{association_name}_attributes=")
           end
         end
+        
+        protected
+        def initial_attributes(*args)
+        	args.first.is_a?(Hash) ? args.first.reverse_merge(attribute_defaults) : attribute_defaults
+        end
       end
       
       private

data/lib/neo4j/rails/transaction.rb

@@ -52,14 +52,14 @@ module Neo4j
         def run
           begin
             new
-            ret = yield
+            ret = yield self
           rescue
             fail
             raise
           ensure
             finish
           end
-	  ret
+          ret
         end
       end
     end

data/lib/neo4j/rails/validations/non_nil.rb

@@ -0,0 +1,11 @@
+module Neo4j
+	module Rails
+		module Validations
+			class NonNilValidator < ActiveModel::EachValidator
+				def validate_each(record, attribute, value)
+					record.errors.add(attribute, :nil, options.merge(:value => value)) if value.nil?
+				end
+			end
+		end
+  end
+end

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -1,29 +1,31 @@
 module Neo4j
-  module Validations
-    class UniquenessValidator < ActiveModel::EachValidator
-      def initialize(options)
-        super(options.reverse_merge(:case_sensitive => true))
-      end
-
-      def setup(klass)
-        @attributes.each do |attribute|
-          if klass.index_type_for(attribute) != :exact
-            raise "Can't validate property #{attribute} on class #{klass} since there is no :exact lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
-          end
-        end
-      end
-
-      def validate_each(record, attribute, value)
-        if record.class.find("#{attribute}: #{value}")
-          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-        end
-      end
-    end
-
-    module ClassMethods
-      def validates_uniqueness_of(*attr_names)
-        validates_with UniquenessValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
+	module Rails
+		module Validations
+			class UniquenessValidator < ActiveModel::EachValidator
+				def initialize(options)
+					super(options.reverse_merge(:case_sensitive => true))
+				end
+	
+				def setup(klass)
+					@attributes.each do |attribute|
+						if klass.index_type_for(attribute) != :exact
+							raise "Can't validate property #{attribute} on class #{klass} since there is no :exact lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
+						end
+					end
+				end
+	
+				def validate_each(record, attribute, value)
+					if record.class.find("#{attribute}: \"#{value}\"")
+						record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+					end
+				end
+			end
+	
+			module ClassMethods
+				def validates_uniqueness_of(*attr_names)
+					validates_with UniquenessValidator, _merge_attributes(attr_names)
+				end
+			end
+		end
+	end
 end

data/lib/neo4j/rails/value.rb

@@ -1,7 +1,7 @@
 module Neo4j::Rails
 
   class Value
-    include Properties
+    include ValueProperties
     include org.neo4j.graphdb.Node
 
     def initialize(wrapper)
@@ -60,7 +60,7 @@ module Neo4j::Rails
 
     class Relationship
     	include org.neo4j.graphdb.Relationship
-      include Properties
+      include ValueProperties
       
       attr_reader :end_node, :start_node
 

data/lib/neo4j/rails/{properties.rb → value_properties.rb}

@@ -1,7 +1,7 @@
+# provide some properties before we have a real node or relationship
 module Neo4j
 	module Rails
-    # provide some properties before we have a real node or relationship
-		module Properties # :nodoc:
+		module ValueProperties
 			include Neo4j::Property
 			
 			# override Neo4j::Property#props

data/lib/neo4j/relationship_traverser.rb

@@ -32,6 +32,10 @@ module Neo4j
       end
     end
 
+    def empty?
+      first == nil
+    end
+    
     def iterator
       if @types
         @node.get_relationships(@types).iterator

data/lib/neo4j/type_converters.rb

@@ -40,13 +40,29 @@ module Neo4j
         end
       end
     end
+    
+    class TimeConverter
+    	class << self
+    		# Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          value.utc.to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+    	end
+    end
 
     # Converts the given value to a Java type by using the registered converters.
     # It just looks at the class of the given value and will convert it if there is a converter
     # registered (in Neo4j::Config) for this value.
     def self.convert(value)
       type      = value.class
-      converter = Neo4j::Config[:converters][type]
+      converter = Neo4j.converters[type]
       return value unless converter
       converter.to_java(value)
     end
@@ -56,7 +72,7 @@ module Neo4j
     def self.to_java(clazz, key, value)
       type = clazz._decl_props[key] && clazz._decl_props[key][:type]
       if type
-        converter = Neo4j::Config[:converters][type]
+        converter = Neo4j.converters[type]
         converter ? converter.to_java(value) : value
       elsif clazz.superclass != Object
         to_java(clazz.superclass, key, value)
@@ -70,7 +86,7 @@ module Neo4j
     def self.to_ruby(clazz, key, value)
       type = clazz._decl_props[key] && clazz._decl_props[key][:type]
       if type
-        converter = Neo4j::Config[:converters][type]
+        converter = Neo4j.converters[type]
         converter ? converter.to_ruby(value) : value
       elsif clazz.superclass != Object
         to_ruby(clazz.superclass, key, value)
@@ -78,7 +94,5 @@ module Neo4j
         value
       end
     end
-
-    Neo4j::Config[:converters] = {Date => DateConverter, DateTime => DateTimeConverter}
   end
 end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.19"
+  VERSION = "1.0.0.beta.20"
 end

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 19
-  version: 1.0.0.beta.19
+    - 20
+  version: 1.0.0.beta.20
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-05 00:00:00 +01:00
+date: 2010-11-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -61,7 +61,7 @@ files:
   - lib/neo4j.rb
   - lib/generators/neo4j.rb
   - lib/generators/neo4j/model/model_generator.rb
-  - lib/generators/neo4j/model/templates/model.rb
+  - lib/generators/neo4j/model/templates/model.erb
   - lib/neo4j/event_handler.rb
   - lib/neo4j/model.rb
   - lib/neo4j/type_converters.rb
@@ -86,9 +86,12 @@ files:
   - lib/neo4j/rails/lucene_connection_closer.rb
   - lib/neo4j/rails/transaction.rb
   - lib/neo4j/rails/tx_methods.rb
-  - lib/neo4j/rails/properties.rb
+  - lib/neo4j/rails/value_properties.rb
+  - lib/neo4j/rails/finders.rb
   - lib/neo4j/rails/value.rb
+  - lib/neo4j/rails/mapping/property.rb
   - lib/neo4j/rails/validations/uniqueness.rb
+  - lib/neo4j/rails/validations/non_nil.rb
   - lib/neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar
   - lib/neo4j/jars/lucene-core-3.0.2.jar
   - lib/neo4j/jars/neo4j-index-1.2-1.2.M03.jar
@@ -104,9 +107,9 @@ files:
   - lib/neo4j/mapping/class_methods/root.rb
   - lib/neo4j/mapping/class_methods/init_rel.rb
   - lib/neo4j/mapping/class_methods/relationship.rb
-  - lib/neo4j/index/index_registry.rb
   - lib/neo4j/index/indexer.rb
   - lib/neo4j/index/lucene_query.rb
+  - lib/neo4j/index/indexer_registry.rb
   - lib/neo4j/index/class_methods.rb
   - lib/neo4j/index/index.rb
   - README.rdoc