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

data/CHANGELOG

@@ -1,3 +1,15 @@
+== 2.0.0.alpha.6 / 2012-04-15
+* Complete rewrite and smaller change of API + lots of refactoring and better RSpecs
+* Moved code to the neo4j-core and neo4j-wrapper gems
+* Changed API - index properties using the Neo4j::Rails::Model (property :name, :index => :exact)
+* Changed API - rel_type always returns a Symbol
+* Changed API - #rels and #rel first parameter is always :outgoing, :incoming or :both
+* Cypher DSL support, see neo4j-core
+* Made the Lucene indexing more flexible
+* Renamed size methods to count since it does simply count all the relationships (e.g. Person.all.count)
+* Modularization - e.g. make it possible to create your own wrapper
+* Added builder method for has_one relationships (just like ActiveRecord build_best_friend)
+
 == 2.0.0.alpha.5 / 2012-03-27
 * Fix for HA/cluster bug [#173]
 * Upgrade to neo4j-community jars 1.7.0.alpha.1

data/Gemfile

@@ -2,9 +2,6 @@ source :gemcutter
 
 gemspec
 
-gem 'neo4j-advanced', "1.7.0.alpha.1",  :require => false
-gem 'neo4j-enterprise', "1.7.0.alpha.1", :require => false
-
 group 'development' do
   gem 'guard'
   gem 'ruby_gntp', :require => false # GrowlNotify for Mac
@@ -12,7 +9,6 @@ group 'development' do
   gem 'rb-fsevent', :require => false
   gem 'rb-fchange', :require => false
   gem "guard-rspec"
-  gem "horo", ">= 1.0.2" # TODO: Why horo, YARD seems to be much better option?
   #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

@@ -1,4 +1,4 @@
-== Welcome to Neo4j.rb {<img src="https://secure.travis-ci.org/andreasronge/neo4j.png" />}[http://travis-ci.org/andreasronge/neo4j] {<img src="https://gemnasium.com/andreasronge/neo4j.png" />}[https://gemnasium.com/andreasronge/neo4j]
+= Welcome to Neo4j.rb {<img src="https://secure.travis-ci.org/andreasronge/neo4j.png" />}[http://travis-ci.org/andreasronge/neo4j] {<img src="https://gemnasium.com/andreasronge/neo4j.png" />}[https://gemnasium.com/andreasronge/neo4j]
 
 Neo4j.rb is a graph database for JRuby.
 
@@ -9,25 +9,28 @@ It uses two powerful and mature Java libraries:
 * {Neo4J}[http://www.neo4j.org] - for persistence and traversal of the graph
 * {Lucene}[http://lucene.apache.org/java/docs/index.html] for querying and indexing.
 
-=== Documentation
+== Documentation
+
+==== Version < 2.0.alpha.5
 
 * {Guides and API}[http://neo4j.rubyforge.org/guides/index.html]
 * {RDoc}[http://neo4j.rubyforge.org]
 * {Blog: Neo4j and Rails 3}[http://blog.jayway.com/2011/03/02/neo4j-rb-1-0-0-and-rails-3/]
 * {Kvitter Example Application}[https://github.com/andreasronge/kvitter/]
 
-=== Status of Upcomming 2.0 Release
+==== Version >= 2.0
 
-See the {neo4j-core gem}[https://github.com/andreasronge/neo4j-core] and GitHub issues.
+* {YARD}[http://rdoc.info/github/andreasronge/neo4j/master/frames]
+* RSpecs - There are 2023 RSpecs (478/neo4j-core, 425/neo4j-wrapper and 1120/this gem - 2012 April)
 
-Improvements:
-* More modular (create your own wrapper or use Neo4j::NodeMixin/Neo4j::Rails::Model)
-* Better performance 
-* More consistent API
-* Better quality of RSpecs, code and docs (YARD)
+=== Presentation Materials and other URLs
 
+* {JRubyConf 2012 May}[http://jrubyconf.com/#speakers]
+* {Presentation: RailsConf 2011}[http://andreasronge.github.com/neo4j-railsconf.pdf]
+* {Nordic Ruby 2010 May 21-23}[http://nordicruby.org/speakers#user_29]
+* {Docs from NeoTechnology}[http://docs.neo4j.org/]
 
-=== Why Neo4j.rb or a Graph Database ?
+== Why Neo4j.rb or a Graph Database ?
 
 Here are some of the major benefits of Neo4j.rb
 
@@ -43,64 +46,50 @@ Here are some of the major benefits of Neo4j.rb
 * ACID Transaction with rollbacks support.
 
 
-=== Some Examples
-
-==== Neo4j::Node
+== Public API
 
-Example of creating a Neo4j::Node
+The neo4j gem depends on the neo4j-wrapper and neo4j-core gems.
 
-  require "rubygems"
-  require 'neo4j'
+=== neo4j gem
 
-  Neo4j::Transaction.run do
-    node = Neo4j::Node.new (:name => 'andreas')
-    node.outgoing(:friends) << Neo4j::Node.new (:name => 'peter')
-    node.outgoing(:friends).each {|node| puts "name #{node[:name]}"}
-  end
+{Neo4j::Rails::Model}
 
-==== Neo4j::NodeMixin
+{Neo4j::Rails::Relationship}
 
-Example of mapping a ruby class to a node and delaring properties and relationships and lucene index.
+{Neo4j::Rails::Observer}
 
-  class Person
-    include Neo4j::NodeMixin
-    property :name
-    property :city
+{Neo4j::Railtie}
 
-    has_n :friends
-    has_one :address
-    index :name
-  end
+{Neo4j::Rails::Versioning}
 
-  # assume we have an transaction already running
-  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'
 
-==== Neo4j::Rails::Model
+==== Example
 
 Example of using Neo4j with Rails 3 (ActiveModel)
 
-  class User < Neo4j::Model
-    attr_accessor :password
-    attr_accessible :email, :password, :password_confirmation, :pending_account
+    class User < Neo4j::Rails::Model
+      attr_accessor :password
+      attr_accessible :email, :password, :password_confirmation, :pending_account
+
+      after_save   :encrypt_password
 
-    after_save   :encrypt_password
+      email_regex = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
 
-    email_regex = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+      # add an exact lucene index on the email property
+      property :email, :index => :exact
 
-    property :email
-    index :email
+      has_one(:avatar).to(Avator)
 
-    has_one(:avatar).to(Avator)
+      validates :email, :presence => true,:format   => { :with => email_regex }
+      validates :email, :uniqueness => true, :unless => :pending_account?
+      accepts_nested_attributes_for :avatar, :allow_destroy => true
 
-    validates :email, :presence => true,:format   => { :with => email_regex }
-    validates :email, :uniqueness => true, :unless => :pending_account?
-    accepts_nested_attributes_for :avatar, :allow_destroy => true
+    end
 
-    ...
-  end
+    u = User.new(:name => 'kalle', :age => 42, :email => "bla@foo.com")
+    u.save
+
+Make sure you are using JRuby !
 
 ==== Generate a Rails Application
 
@@ -116,33 +105,85 @@ Example of creating an Neo4j Application from scratch:
  open a webbrowser: http://localhost:3000/users
 
 To run it with Tomcat instead of WEBrick
-  
+
   gem install trinidad
   trinidad
 
-=== Architecture
+
+=== {neo4j-wrapper}[http://github.com/andreasronge/neo4j-wrapper]
+
+{Neo4j::NodeMixin}[http://rdoc.info/github/andreasronge/neo4j-wrapper/Neo4j/NodeMixin]
+
+{Neo4j::RelationshipMixin}[http://rdoc.info/github/andreasronge/neo4j-wrapper/Neo4j/RelationshipMixin]
+
+==== Example
+
+Example of mapping a ruby class to a node and delaring properties and relationships and lucene index.
+
+    class Person
+      include Neo4j::NodeMixin
+      property :name
+      property :city
+
+      has_n :friends
+      has_one :address
+      index :name
+    end
+
+    # assume we have an transaction already running !
+    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'
+
+The Neo4j::NodeMixin and Neo4j::RelationshipMixin is implemented in the {neo4j-wrapper}[http://github.com/andreasronge/neo4j-wrapper] gem
+
+
+=== neo4j-core gem
+
+{Neo4j::Node}[http://rdoc.info/github/andreasronge/neo4j-core/Neo4j/Node] The Java Neo4j Node
+
+{Neo4j::Relationship}[http://rdoc.info/github/andreasronge/neo4j-core/Neo4j/Relationship] The Java Relationship
+
+{Neo4j}[http://rdoc.info/github/andreasronge/neo4j-core/Neo4j] The Database
+
+{Neo4j::Cypher}[http://rdoc.info/github/andreasronge/neo4j-core/Neo4j/Cypher] Cypher DSL, see RSpec spec/neo4j/cypher_spec
+
+{Neo4j::Algo}[http://rdoc.info/github/andreasronge/neo4j-core/Neo4j/Algo] Included algorithms, like shortest path
+
+==== Example
+
+Example of creating a Neo4j::Node
+
+    require "rubygems"
+    require 'neo4j'
+
+    Neo4j::Transaction.run do
+      node = Neo4j::Node.new(:name => 'andreas')
+      node.outgoing(:friends) << Neo4j::Node.new(:name => 'peter')
+      node.outgoing(:friends).each {|node| puts "name #{node[:name]}"}
+    end
+
+The Neo4j::Node and Neo4j::Relationship is implemented in the {neo4j-core}[http://github.com/andreasronge/neo4j-core] gem.
+
+== Architecture
 
 As you seen above, neo4j.rb consists of a three layers API:
 
-* Layer 1. For interacting with the basic building blocks of the graph database (node, properties and relationship), see Neo4j::Node and Neo4j::Relationship classes.
-* Layer 2. A binding API to Ruby objects, see Neo4j::NodeMixin and Neo4j::RelationshipMixin modules.
-* Layer 3. An implementation of the Rails Active Model and a subset of the Active Record API, see Neo4j::Rails::Model class.
+* Layer 1, neo4j-core. For interacting with the basic building blocks of the graph database (node, properties and relationship), see Neo4j::Node and Neo4j::Relationship classes.
+* Layer 2, neo4j-wrapper. A binding API to Ruby objects, see Neo4j::NodeMixin and Neo4j::RelationshipMixin modules.
+* Layer 3, neo4j. An implementation of the Rails Active Model and a subset of the Active Record API, see Neo4j::RailsNode and Neo4j::RailsRelationship class.
 
 Notice that you can always access the lower layers if you want to do some more advanced. You can even access the Java API directly.
 
-=== Presentation Materials and other URLs
-* {Presentation: RailsConf 2011}[http://andreasronge.github.com/neo4j-railsconf.pdf]
-* {Nordic Ruby 2010 May 21-23}[http://nordicruby.org/speakers#user_29]
-* {Neo4j wiki, check the guidelines and domain modeling gallery pages}[http://wiki.neo4j.org/content/Main_Page]
-
-=== Project information
+== Project information
 * {GitHub}[http://github.com/andreasronge/neo4j/tree/master]
 * {Issue Tracking}[https://github.com/andreasronge/neo4j/issues]
 * {Twitter}[http://twitter.com/ronge]
 * {Mailing list, neo4jrb@googlegroups.com}[http://groups.google.com/group/neo4jrb]
 * {Read only, old lighthouse issues}[http://neo4j.lighthouseapp.com]
 
-=== Configuration
+== Configuration
 
 {Development configuration}[http://neo4j.rubyforge.org/guides/index.html#development-and-testing-configuration] - You can configure Neo4j through the {Neo4j::Config}[http://neo4j.rubyforge.org/Neo4j/Config.html] object.
 
@@ -163,3 +204,6 @@ Do you need help - send me an email (andreas.ronge at gmail dot com).
 * Neo4j.rb - MIT, see the LICENSE file http://github.com/andreasronge/neo4j/tree/master/LICENSE.
 * Lucene -  Apache, see http://lucene.apache.org/java/docs/features.html
 * \Neo4j - Dual free software/commercial license, see http://neo4j.org/
+
+Notice there are different license for the neo4j-community, neo4j-advanced and neo4j-enterprise jar gems.
+Only the neo4j-community gem is by default required.

data/lib/neo4j.rb

@@ -1,4 +1,3 @@
-require 'enumerator'
 require 'forwardable'
 require 'time'
 require 'date'
@@ -6,43 +5,18 @@ require 'tmpdir'
 
 # Rails
 require 'rails/railtie'
+require 'active_support/concern'
 require 'active_support/core_ext/hash/indifferent_access'
-require 'active_model'
-
-# core extensions
-require 'neo4j/core_ext/class/inheritable_attributes'
-
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
 
-module Neo4j
-  include Java
+require 'active_model'
 
-  # Enumerator has been moved to top level in Ruby 1.9.2, make it compatible with Ruby 1.8.7
-  Enumerator = Enumerable::Enumerator unless defined? Enumerator
-end
+require 'neo4j-core'
+require 'neo4j-wrapper'
 
-require 'neo4j-community'
-require 'neo4j/version'
-require 'neo4j/neo4j'
-require 'neo4j/paginated'
-require 'neo4j/node'
-require 'neo4j/relationship'
-require 'neo4j/relationship_set'
-require 'neo4j/type_converters/type_converters'
-require 'neo4j/index/index'
-require 'neo4j/traversal/traversal'
-require 'neo4j/property/property'
-require 'neo4j/has_n/has_n'
-require 'neo4j/node_mixin/node_mixin'
-require 'neo4j/relationship_mixin/relationship_mixin'
-require 'neo4j/rule/rule'
-require 'neo4j/rels/rels'
 require 'neo4j/rails/rails'
-require 'neo4j/model'
-require 'neo4j/migrations/migrations'
-require 'neo4j/algo/algo'
-require 'neo4j/batch/batch'
-require 'orm_adapter/adapters/neo4j'
-require 'neo4j/identity_map'
 
 
+require 'orm_adapter/adapters/neo4j'
 Dir["#{File.dirname(__FILE__)}/tasks/**/*.rake"].each { |ext| load ext } if defined?(Rake) && respond_to?(:namespace)

data/lib/neo4j/performance.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'neo4j'
+
+class MyIndex
+  include Neo4j::NodeMixin
+  index(:name) # default :exact
+  index(:things)
+  index(:age, :field_type => Fixnum) # default :exact
+  index(:wheels, :field_type => Fixnum)
+  index(:description, :type => :fulltext)
+end
+
+def rm_db_storage
+  FileUtils.rm_rf Neo4j::Config[:storage_path]
+  raise "Can't delete db" if File.exist?(Neo4j::Config[:storage_path])
+end
+
+def finish_tx
+  return unless @tx
+  @tx.success
+  @tx.finish
+  @tx = nil
+end
+
+def new_tx
+  finish_tx if @tx
+  @tx = Neo4j::Transaction.new
+end
+
+rm_db_storage
+
+10.times do
+  t = Time.now
+  new_tx
+  (0..1000).each do
+    MyIndex.new :things => 'bla', :name => 'foo', :age => 42, :wheels => 53, :description => "Bla bla"
+  end
+  d1 = Time.now - t
+  t = Time.now
+  finish_tx
+  d2 = Time.now - t
+  puts "Index #{d2}, create #{d1} tot #{d1 + d2} - #{d2/(d1 + d2).round(2)}"
+end

data/lib/neo4j/rails/accept_id.rb

@@ -1,15 +1,16 @@
 module Neo4j::Rails
-  # Allows accepting id for association objects. For example
-  # class Book < Neo4j::Model
-  #   has_one(:author).to(Author)
-  #   accepts_id_for :author
-  # end
+  # Allows accepting id for association objects.
+  # @example
+  #   class Book < Neo4j::Rails::Model
+  #     has_one(:author).to(Author)
+  #     accepts_id_for :author
+  #   end
   #
-  # This would add a author_id getter and setter on Book. You could use
-  # book = Book.new(:name => 'Graph DBs', :author_id => 11)
-  # book.author_id # 11
-  # book.author_id = 13
-  # TODO: Support for has_n associations
+  #   # This would add a author_id getter and setter on Book. You could use
+  #   book = Book.new(:name => 'Graph DBs', :author_id => 11)
+  #   book.author_id # 11
+  #   book.author_id = 13
+  # @note TODO: Support for has_n associations
   module AcceptId
     extend ActiveSupport::Concern
 
@@ -17,11 +18,11 @@ module Neo4j::Rails
       # Adds association_id getter and setter for one or more has_one associations
       #
       # @example
-      # class Book < Neo4j::Model
-      #   has_one(:author).to(Author)
-      #   has_one(:publisher).to(Publisher)
-      #   accepts_id_for :author, :publisher
-      # end
+      #   class Book < Neo4j::Rails::Model
+      #     has_one(:author).to(Author)
+      #     has_one(:publisher).to(Publisher)
+      #     accepts_id_for :author, :publisher
+      #   end
       def accepts_id_for(*association_names)
         association_names.each do |association_name|
           define_association_id_getter(association_name)
@@ -32,8 +33,8 @@ module Neo4j::Rails
 
       # Check if model accepsts id for its association
       # @example
-      # Book.accepts_id_for?(:author) => true
-      # Book.accepts_id_for?(:genre) => false
+      #   Book.accepts_id_for?(:author) => true
+      #   Book.accepts_id_for?(:genre) => false
       def accepts_id_for?(association_name)
         accepts_id_associations.include?(association_name)
       end
@@ -56,7 +57,7 @@ module Neo4j::Rails
         class_eval %Q{
           def #{association_name}_id=(id)
             relation_target_class = self.class._decl_rels[:#{association_name}].target_class
-            association_class =  relation_target_class <= self.class ?  Neo4j::Model : relation_target_class
+            association_class =  relation_target_class <= self.class ?  Neo4j::Rails::Model : relation_target_class
             self.#{association_name} = id.present? ? association_class.find(id) : nil
           end
         }, __FILE__, __LINE__

data/lib/neo4j/rails/attributes.rb

@@ -10,12 +10,16 @@ module Neo4j
     # about attributes, we mean all the properties apart from those hidden ones.
     module Attributes
       extend ActiveSupport::Concern
+      extend TxMethods
 
       included do
         include ActiveModel::Dirty # track changes to attributes
         include ActiveModel::MassAssignmentSecurity # handle attribute hash assignment
 
-        class_inheritable_accessor :attribute_defaults
+        class << self
+          attr_accessor :attribute_defaults
+        end
+
         self.attribute_defaults ||= {}
 
         # save the original [] and []= to use as read/write to Neo4j
@@ -29,16 +33,184 @@ module Neo4j
         # whenever we refer to [] or []=. use our local properties store
         alias_method :[], :read_local_property
         alias_method :[]=, :write_local_property
+
+        def self.inherited(sub_klass)
+          super
+          return if sub_klass.to_s[0..0] == '#' # this is really for anonymous test classes
+          setup_neo4j_subclass(sub_klass)
+          sub_klass.send(:define_method, :attribute_defaults) do
+            self.class.attribute_defaults
+          end
+          sub_klass.attribute_defaults = self.attribute_defaults.clone
+          # Hmm, could not do this from the Finders Mixin Module - should be moved
+          sub_klass.rule(:_all, :functions => Neo4j::Wrapper::Rule::Functions::Size.new) if sub_klass.respond_to?(:rule)
+        end
+      end
+
+      def init_on_create(*)
+        self._classname = self.class.to_s
+        write_default_attributes
+        write_changed_attributes
+        clear_changes
+      end
+
+      def initialize_attributes(attributes)
+        @_properties = {}
+        @_properties_before_type_cast={}
+        self.attributes = attributes if attributes
+      end
+
+      # Mass-assign attributes.  Stops any protected attributes from being assigned.
+      def attributes=(attributes, guard_protected_attributes = true)
+        attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
+
+        multi_parameter_attributes = []
+        attributes.each do |k, v|
+          if k.to_s.include?("(")
+            multi_parameter_attributes << [k, v]
+          else
+            respond_to?("#{k}=") ? send("#{k}=", v) : self[k] = v
+          end
+        end
+
+        assign_multiparameter_attributes(multi_parameter_attributes)
+      end
+
+      def attribute_defaults
+        self.class.attribute_defaults
+      end
+
+      # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
+      # If saving fails because the resource is invalid then false will be returned.
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+      tx_methods :update_attributes
+
+      # Same as #update_attributes, but raises an exception if saving fails.
+      def update_attributes!(attributes)
+        self.attributes = attributes
+        save!
+      end
+      tx_methods :update_attributes!
+
+      def reset_attributes
+        @_properties = {}
+      end
+
+
+
+      # Updates a single attribute and saves the record.
+      # This is especially useful for boolean flags on existing records. Also note that
+      #
+      # * Validation is skipped.
+      # * Callbacks are invoked.
+      # * Updates all the attributes that are dirty in this object.
+      #
+      def update_attribute(name, value)
+        respond_to?("#{name}=") ? send("#{name}=", value) : self[name] = value
+        save(:validate => false)
+      end
+
+      def hash
+        persisted? ? _java_entity.neo_id.hash : super
+      end
+
+      def to_param
+        persisted? ? neo_id.to_s : nil
+      end
+
+      def to_model
+        self
+      end
+
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if model.persisted? is false
+      def to_key
+        persisted? ? [id] : nil
+      end
+
+      # Return the properties from the Neo4j Node, merged with those that haven't
+      # yet been saved
+      def props
+        ret = {}
+        property_names.each do |property_name|
+          ret[property_name] = respond_to?(property_name) ? send(property_name) : send(:[], property_name)
+        end
+        ret
+      end
+
+      # Return all the attributes for this model as a hash attr => value.  Doesn't
+      # include properties that start with <tt>_</tt>.
+      def attributes
+        ret = {}
+        attribute_names.each do |attribute_name|
+          ret[attribute_name] = self.class._decl_props[attribute_name.to_sym] ? send(attribute_name) : send(:[], attribute_name)
+        end
+        ret
+      end
+
+      # Known properties are either in the @_properties, the declared
+      # attributes or the property keys for the persisted node.
+      def property_names
+        # initialize @_properties if needed since
+        # we can ask property names before the object is initialized (active_support initialize callbacks, respond_to?)
+        @_properties ||= {}
+        keys = @_properties.keys + self.class._decl_props.keys.map(&:to_s)
+        keys += _java_entity.property_keys.to_a if persisted?
+        keys.flatten.uniq
+      end
+
+      # Known attributes are either in the @_properties, the declared
+      # attributes or the property keys for the persisted node.  Any attributes
+      # that start with <tt>_</tt> are rejected
+      def attribute_names
+        property_names.reject { |property_name| _invalid_attribute_name?(property_name) }
+      end
+
+      # Known properties are either in the @_properties, the declared
+      # properties or the property keys for the persisted node
+      def property?(name)
+        return false unless @_properties
+        @_properties.has_key?(name) ||
+            self.class._decl_props.has_key?(name) ||
+            persisted? && super
+      end
+
+      def property_changed?
+        return !@_properties.empty? unless persisted?
+        !!@_properties.keys.find { |k| self._java_node[k] != @_properties[k] }
+      end
+
+      # Return true if method_name is the name of an appropriate attribute
+      # method
+      def attribute?(name)
+        name[0] != ?_ && property?(name)
       end
 
+
+      # Wrap the getter in a conversion from Java to Ruby
+      def read_local_property_with_type_conversion(property)
+        self.class._converter(property).to_ruby(read_local_property_without_type_conversion(property))
+      end
+
+      # Wrap the setter in a conversion from Ruby to Java
+      def write_local_property_with_type_conversion(property, value)
+        @_properties_before_type_cast[property.to_sym]=value if self.class._decl_props.has_key? property.to_sym
+        conv_value = self.class._converter(property.to_sym).to_java(value)
+        write_local_property_without_type_conversion(property, conv_value)
+      end
+
+
       # The behaviour of []= changes with a Rails Model, where nothing gets written
       # to Neo4j until the object is saved, during which time all the validations
       # and callbacks are run to ensure correctness
       def write_local_property(key, value)
         key_s = key.to_s
-        if !@properties.has_key?(key_s) || @properties[key_s] != value
+        if !@_properties.has_key?(key_s) || @_properties[key_s] != value
           attribute_will_change!(key_s)
-          @properties[key_s] = value.nil? ? attribute_defaults[key_s] : value
+          @_properties[key_s] = value.nil? ? attribute_defaults[key_s] : value
         end
         value
       end
@@ -47,29 +219,186 @@ module Neo4j
       # the DB if we don't have one
       def read_local_property(key)
         key = key.to_s
-        if @properties.has_key?(key)
-          @properties[key]
+        if @_properties.has_key?(key)
+          @_properties[key]
         else
-          @properties[key] = (persisted? && _java_entity.has_property?(key)) ? read_attribute(key) : attribute_defaults[key]
+          @_properties[key] = (persisted? && _java_entity.has_property?(key)) ? read_attribute(key) : attribute_defaults[key]
         end
       end
 
-      # Mass-assign attributes.  Stops any protected attributes from being assigned.
-      def attributes=(attributes, guard_protected_attributes = true)
-        attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
 
-        multi_parameter_attributes = []
-        attributes.each do |k, v|
-          if k.to_s.include?("(")
-            multi_parameter_attributes << [ k, v ]
-          else
-            respond_to?("#{k}=") ? send("#{k}=", v) : self[k] = v
+      module ClassMethods
+        # Returns all defined properties
+        def columns
+          self._decl_props.keys
+        end
+
+
+        # Declares a property.
+        # It support the following hash options:
+        # <tt>:default</tt>,<tt>:null</tt>,<tt>:limit</tt>,<tt>:type</tt>,<tt>:index</tt>,<tt>:converter</tt>
+        #
+        # @example Set the property type,
+        #   class Person < Neo4j::RailsModel
+        #     property :age, :type => Time
+        #   end
+        #
+        # @example Set the property type,
+        #   class Person < Neo4j::RailsModel
+        #     property :age, :default => 0
+        #   end
+        # @example
+        #   class Person < Neo4j::RailsModel
+        #     property :age, :null => false
+        #   end
+        # Property must be there
+        #
+        # @example Property has a length limit
+        #   class Person < Neo4j::RailsModel
+        #     property :name, :limit => 128
+        #   end
+        #
+        # @example Index with lucene.
+        #   class Person < Neo4j::RailsModel
+        #     property :name, :index => :exact
+        #     property :year, :index => :exact, :type => Fixnum  # index as fixnum too
+        #     property :description, :index => :fulltext
+        #   end
+        #
+        # @example Using a custom converter
+        #   module MyConverter
+        #     def to_java(v)
+        #       "Java:#{v}"
+        #     end
+        #
+        #     def to_ruby(v)
+        #       "Ruby:#{v}"
+        #     end
+        #
+        #     def index_as
+        #       String
+        #     end
+        #
+        #     extend self
+        #   end
+        #
+        #   class Person < Neo4j::RailsModel
+        #     property :name, :converter => MyConverter
+        #   end
+        #
+        def property(*args)
+          options = args.extract_options!
+          args.each do |property_sym|
+            property_setup(property_sym, options)
           end
         end
 
-        assign_multiparameter_attributes(multi_parameter_attributes)
+
+        protected
+        def property_setup(property, options)
+          _decl_props[property] = options
+          handle_property_options_for(property, options)
+          define_property_methods_for(property, options)
+          define_property_before_type_cast_methods_for(property, options)
+        end
+
+        def handle_property_options_for(property, options)
+          attribute_defaults[property.to_s] = options[:default] if options.has_key?(:default)
+
+          converter = options[:converter] || Neo4j::TypeConverters.converter(_decl_props[property][:type])
+          _decl_props[property][:converter] = converter
+
+          if options.include?(:index)
+            index(property, :type => options[:index], :field_type => converter.index_as)
+          end
+
+          if options.has_key?(:null) && options[:null] === false
+            validates(property, :non_nil => true, :on => :create)
+            validates(property, :non_nil => true, :on => :update)
+          end
+          validates(property, :length => {:maximum => options[:limit]}) if options[:limit]
+        end
+
+        def define_property_methods_for(property, options)
+          unless method_defined?(property)
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def #{property}
+                send(:[], "#{property}")
+              end
+            RUBY
+          end
+
+          unless method_defined?("#{property}=".to_sym)
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def #{property}=(value)
+                send(:[]=, "#{property}", value)
+              end
+            RUBY
+          end
+        end
+
+        def define_property_before_type_cast_methods_for(property, options)
+          property_before_type_cast = "#{property}_before_type_cast"
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{property_before_type_cast}=(value)
+              @_properties_before_type_cast[:#{property}]=value
+            end
+
+            def #{property_before_type_cast}
+              @_properties_before_type_cast.has_key?(:#{property}) ? @_properties_before_type_cast[:#{property}] : self.#{property}
+            end
+          RUBY
+        end
+      end
+
+
+      protected
+
+
+      # Ensure any defaults are stored in the DB
+      def write_default_attributes
+        self.class.attribute_defaults.each do |attribute, value|
+          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class, false)) unless changed_attributes.has_key?(attribute) || _java_node.has_property?(attribute)
+        end
+      end
+
+      # Write attributes to the Neo4j DB only if they're altered
+      def write_changed_attributes
+        @_properties.each do |attribute, value|
+          write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
+        end
+      end
+
+
+
+      def attribute_missing(method_id, *args, &block)
+        method_name = method_id.method_name
+        if property?(method_name)
+          self[method_name]
+        else
+          super
+        end
       end
 
+      # TODO THIS IS ONLY NEEDED IN ACTIVEMODEL < 3.2, ?
+      # To get ActiveModel::Dirty to work, we need to be able to call undeclared
+      # properties as though they have get methods
+      def method_missing(method_id, *args, &block)
+        method_name = method_id.to_s
+        if property?(method_name)
+          self[method_name]
+        else
+          super
+        end
+      end
+
+      def _invalid_attribute_name?(attr_name)
+        attr_name.to_s[0] == ?_ && !self.class._decl_props.include?(attr_name.to_sym)
+      end
+
+
+
+
       # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
       # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
       # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
@@ -79,7 +408,7 @@ module Neo4j
       # attribute will be set to nil.
       def assign_multiparameter_attributes(pairs)
         execute_callstack_for_multiparameter_attributes(
-          extract_callstack_for_multiparameter_attributes(pairs)
+            extract_callstack_for_multiparameter_attributes(pairs)
         )
       end
 
@@ -100,19 +429,21 @@ module Neo4j
 
               #TODO: Consider extracting hardcoded assignments into "Binders"
               value = if Neo4j::TypeConverters::TimeConverter.convert?(decl_type)
-                instantiate_time_object(name, values)
-              elsif Neo4j::TypeConverters::DateConverter.convert?(decl_type)
-                begin
-                  values = values_with_empty_parameters.collect do |v| v.nil? ? 1 : v end
-                  Date.new(*values)
-                rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
-                  instantiate_time_object(name, values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
-                end
-              elsif Neo4j::TypeConverters::DateTimeConverter.convert?(decl_type)
-                DateTime.new(*values)
-              else
-                raise "Unknown type #{decl_type}"
-              end
+                        instantiate_time_object(name, values)
+                      elsif Neo4j::TypeConverters::DateConverter.convert?(decl_type)
+                        begin
+                          values = values_with_empty_parameters.collect do |v|
+                            v.nil? ? 1 : v
+                          end
+                          Date.new(*values)
+                        rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
+                          instantiate_time_object(name, values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
+                        end
+                      elsif Neo4j::TypeConverters::DateTimeConverter.convert?(decl_type)
+                        DateTime.new(*values)
+                      else
+                        raise "Unknown type #{decl_type}"
+                      end
 
               send(name + "=", value)
             end
@@ -129,12 +460,12 @@ module Neo4j
 #        if self.class.send(:create_time_zone_conversion_attribute?, name, column_for_attribute(name))
 #          Time.zone.local(*values)
 #        else
-          Time.time_with_datetime_fallback(self.class.default_timezone, *values)
+        Time.time_with_datetime_fallback(self.class.default_timezone, *values)
 #        end
       end
 
       def extract_callstack_for_multiparameter_attributes(pairs)
-        attributes = { }
+        attributes = {}
 
         for pair in pairs
           multiparameter_name, value = pair
@@ -142,10 +473,10 @@ module Neo4j
           attributes[attribute_name] = [] unless attributes.include?(attribute_name)
 
           parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
-          attributes[attribute_name] << [ find_parameter_position(multiparameter_name), parameter_value ]
+          attributes[attribute_name] << [find_parameter_position(multiparameter_name), parameter_value]
         end
 
-        attributes.each { |name, values| attributes[name] = values.sort_by{ |v| v.first }.collect { |v| v.last } }
+        attributes.each { |name, values| attributes[name] = values.sort_by { |v| v.first }.collect { |v| v.last } }
       end
 
 
@@ -164,99 +495,14 @@ module Neo4j
         @changed_attributes.clear
       end
 
-      # Return the properties from the Neo4j Node, merged with those that haven't
-      # yet been saved
-      def props
-        ret = {}
-        property_names.each do |property_name|
-          ret[property_name] = respond_to?(property_name) ? send(property_name) : send(:[], property_name)
-        end
-        ret
-      end
-
-      # Return all the attributes for this model as a hash attr => value.  Doesn't
-      # include properties that start with <tt>_</tt>.
-      def attributes
-        ret = {}
-        attribute_names.each do |attribute_name|
-          ret[attribute_name] = self._decl_props[attribute_name.to_sym] ? send(attribute_name) :  send(:[], attribute_name)
-        end
-        ret
-      end
-
-      # Known properties are either in the @properties, the declared
-      # attributes or the property keys for the persisted node.
-      def property_names
-        # initialize @properties if needed since
-        # we can ask property names before the object is initialized (active_support initialize callbacks, respond_to?)
-        @properties ||= {}
-        keys = @properties.keys + self.class._decl_props.keys.map { |k| k.to_s }
-        keys += _java_entity.property_keys.to_a if persisted?
-        keys.flatten.uniq
-      end
-
-      # Known attributes are either in the @properties, the declared
-      # attributes or the property keys for the persisted node.  Any attributes
-      # that start with <tt>_</tt> are rejected
-      def attribute_names
-        property_names.reject { |property_name| _invalid_attribute_name?(property_name) }
-      end
-
-      def _invalid_attribute_name?(attr_name)
-        attr_name.to_s[0] == ?_ && !self.class._decl_props.include?(attr_name.to_sym)
-      end
-
-      # Known properties are either in the @properties, the declared
-      # properties or the property keys for the persisted node
-      def property?(name)
-        return false unless @properties
-        @properties.has_key?(name) ||
-            self.class._decl_props.has_key?(name) ||
-            persisted? && super
-      end
-
-      def property_changed?
-        return !@properties.empty? unless persisted?
-        !!@properties.keys.find{|k| self._java_node.getProperty(k.to_s) != @properties[k] }
-      end
-
-      # Return true if method_name is the name of an appropriate attribute
-      # method
-      def attribute?(name)
-        name[0] != ?_ && property?(name)
-      end
-
       def _classname
         self.class.to_s
       end
 
       def _classname=(value)
-        write_local_property_without_type_conversion("_classname",value)
-      end
-
-
-      # TODO THIS IS ONLY NEEDED IN ACTIVEMODEL < 3.2, ?
-      # To get ActiveModel::Dirty to work, we need to be able to call undeclared
-      # properties as though they have get methods
-      def method_missing(method_id, *args, &block)
-        method_name = method_id.to_s
-        if property?(method_name)
-          self[method_name]
-        else
-          super
-        end
+        write_local_property_without_type_conversion("_classname", value)
       end
 
-      # Wrap the getter in a conversion from Java to Ruby
-      def read_local_property_with_type_conversion(property)
-        Neo4j::TypeConverters.to_ruby(self.class, property, read_local_property_without_type_conversion(property))
-      end
-
-      # Wrap the setter in a conversion from Ruby to Java
-      def write_local_property_with_type_conversion(property, value)
-        @properties_before_type_cast[property.to_sym]=value if self.class._decl_props.has_key? property.to_sym
-        write_local_property_without_type_conversion(property, Neo4j::TypeConverters.to_java(self.class, property, value))
-      end
     end
   end
 end