neo4j 1.0.0.beta.21-java

data/lib/neo4j/rails/finders.rb

@@ -0,0 +1,134 @@
+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)
+					args = normalize_args(*args)
+					if args.empty?
+						# use the _all rule to recover all the stored instances of this node
+						_all
+					else
+						# 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
+				
+				def last(*args)
+					a = all(*args)
+					a.empty? ? nil : a[a.size - 1]
+				end
+				
+				def count
+					all.size
+				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?
+						
+						# TODO: Handle order
+						options.delete(:order)
+						
+						if options[:conditions]
+							args << options[:conditions] if options[:conditions].present?
+						else
+							args << options if options.present?
+						end
+					end
+					args
+				end
+      end
+		end
+	end
+end
+

data/lib/neo4j/rails/lucene_connection_closer.rb

@@ -0,0 +1,19 @@
+module Neo4j
+  module Rails
+    class LuceneConnectionCloser
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        Thread.current[:neo4j_lucene_connection].each {|hits| hits.close} if Thread.current[:neo4j_lucene_connection]
+        Thread.current[:neo4j_lucene_connection] = nil
+      end
+    end
+  end
+
+end
+
+Thread.current

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

@@ -0,0 +1,60 @@
+module Neo4j
+	module Rails
+		module Mapping
+			module Property
+				extend ActiveSupport::Concern
+					
+				module ClassMethods
+					# Handles options for the property
+					#
+					# Set the property type 				:type => Time
+					# Set a default  								:default => "default"
+					# Property must be there  			:null => false
+					# Property has a length limit  	:limit => 128
+					def property(*args)
+						options = args.extract_options!
+						args.each do |property_sym|
+							property_setup(property_sym, options)
+						end
+					end
+					
+					protected
+					def property_setup(property, options)
+						_decl_props[property] = options
+						handle_property_options_for(property, options)
+						define_property_methods_for(property, options)
+						_decl_props[property][:defined] = true
+					end
+					
+					def handle_property_options_for(property, options)
+						attribute_defaults[property.to_s] = options[:default] if options.has_key?(:default)
+						
+            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
+				end
+			end
+		end
+	end
+end

data/lib/neo4j/rails/model.rb

@@ -0,0 +1,105 @@
+module Neo4j
+  module Rails
+    class Model
+      include Neo4j::NodeMixin
+      
+      # Initialize a Node with a set of properties (or empty if nothing is passed)
+      def initialize(attributes = {})
+      	reset_attributes
+        clear_relationships
+        self.attributes = attributes
+      end
+
+      def id
+        neo_id.nil? ? nil : neo_id.to_s
+      end
+
+      def to_param
+        persisted? ? neo_id.to_s : nil
+      end
+
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if model.persisted? is false
+      def to_key
+        persisted? ? [id] : nil
+      end
+
+      def reject_if?(proc_or_symbol, attr)
+        return false if proc_or_symbol.nil?
+        if proc_or_symbol.is_a?(Symbol)
+          meth = method(proc_or_symbol)
+          meth.arity == 0 ? meth.call : meth.call(attr)
+        else
+          proc_or_symbol.call(attr)
+        end
+      end
+
+      def to_model
+        self
+      end
+
+      def ==(other)
+      	new? ? self.__id__ == other.__id__ : @_java_node == (other)
+      end
+      
+      # --------------------------------------
+      # Public Class Methods
+      # --------------------------------------
+      class << self
+        # NodeMixin overwrites the #new class method but it saves it as orig_new
+        # Here, we just get it back to normal
+        alias :new :orig_new
+        
+        def transaction(&block)
+          Neo4j::Rails::Transaction.run do |tx|
+            block.call(tx)
+          end 
+        end
+
+        def accepts_nested_attributes_for(*attr_names)
+          options = attr_names.pop if attr_names[-1].is_a?(Hash)
+
+          attr_names.each do |association_name|
+            # Do some validation that we have defined the relationships we want to nest
+            rel = self._decl_rels[association_name.to_sym]
+            raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
+            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 rel.target_class
+
+            if rel.has_one?
+              send(:define_method, "#{association_name}_attributes=") do |attributes|
+                update_nested_attributes(association_name.to_sym, attributes, options)
+              end
+            else
+              send(:define_method, "#{association_name}_attributes=") do |attributes|
+                if attributes.is_a?(Array)
+                  attributes.each do |attr|
+                    update_nested_attributes(association_name.to_sym, attr, options)
+                  end
+                else
+                  attributes.each_value do |attr|
+                    update_nested_attributes(association_name.to_sym, attr, options)
+                  end
+                end
+              end
+            end
+
+          end
+        end
+      end
+    end
+    
+    Model.class_eval do
+    	extend ActiveModel::Translation
+      
+      include Persistence				# handles how to save, create and update the model
+      include Attributes				# handles how to save and retrieve attributes
+      include Mapping::Property	# allows some additional options on the #property class method
+      include Serialization			# enable to_xml and to_json
+      include Timestamps				# handle created_at, updated_at timestamp properties
+      include Validations				# enable validations
+      include Callbacks					# enable callbacks
+      include Finders						# ActiveRecord style find
+      include Relationships     # for none persisted relationships
+    end
+  end
+end

data/lib/neo4j/rails/persistence.rb

@@ -0,0 +1,260 @@
+module Neo4j
+	module Rails
+		module Persistence
+			extend ActiveSupport::Concern
+			
+			included do
+				extend TxMethods
+				tx_methods :destroy, :create, :update, :update_nested_attributes
+			end
+
+			# Persist the object to the database.  Validations and Callbacks are included
+			# by default but validation can be disabled by passing :validate => false
+			# to #save.
+      def save(*)
+      	create_or_update
+      end
+      
+      # Persist the object to the database.  Validations and Callbacks are included
+			# by default but validation can be disabled by passing :validate => false
+			# to #save!.
+			#
+			# Raises a RecordInvalidError if there is a problem during save.
+      def save!(*args)
+				unless save(*args)
+					raise RecordInvalidError.new(self)
+				end
+			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
+			
+			# Removes the node from Neo4j and freezes the object.
+			def destroy
+				delete
+				freeze
+			end
+			
+			# Same as #destroy but doesn't run destroy callbacks and doesn't freeze
+			# the object
+			def delete
+				del unless new_record?
+				set_deleted_properties
+			end
+			
+			# Returns true if the object was destroyed.
+			def destroyed?()
+        @_deleted
+      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
+
+      # Same as #update_attributes, but raises an exception if saving fails.
+      def update_attributes!(attributes)
+        self.attributes = attributes
+        save!
+      end
+			
+      # Reload the object from the DB.
+      def reload(options = nil)
+        clear_changes
+        clear_relationships
+        reset_attributes
+        unless reload_from_database
+          set_deleted_properties
+          freeze
+        end
+        self
+      end
+
+      # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
+      def persisted?
+        !new_record? && !destroyed?
+      end
+      
+      # Returns true if the record hasn't been saved to Neo4j yet.
+      def new_record?
+        _java_node.nil?
+      end
+      
+      alias :new? :new_record?
+      
+      # Freeze the properties hash.
+			def freeze
+				@properties.freeze; self
+			end
+
+      # Returns +true+ if the properties hash has been frozen.
+      def frozen?
+        reload
+        @properties.frozen?
+      end
+
+      module ClassMethods
+        # Initialize a model and set a bunch of attributes at the same time.  Returns
+        # the object whether saved successfully or not.
+        def create(*args)
+          new(*args).tap { |o| o.save }
+        end
+
+        # Same as #create, but raises an error if there is a problem during save.
+        # Returns the object whether saved successfully or not.
+        def create!(*args)
+          new(*args).tap { |o| o.save! }
+        end
+
+        # Destroy each node in turn.  Runs the destroy callbacks for each node.
+        def destroy_all
+          all.each do |n|
+            n.destroy
+          end
+        end
+      end
+
+      protected
+      def create_or_update
+        result = persisted? ? update : create
+        unless result != false
+          Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running?
+          false
+        else
+          true
+        end
+      end
+
+      def update
+        write_changed_attributes
+        clear_changes
+        clear_relationships
+        true
+      end
+
+      def create
+        node = Neo4j::Node.new
+        #unless _java_node.save_nested(node)
+        #	Neo4j::Rails::Transaction.fail
+        #	false
+        #else
+        init_on_load(node)
+        init_on_create
+        clear_changes
+        clear_relationships
+        true
+      end
+
+      def init_on_create(*)
+        self["_classname"] = self.class.to_s
+        write_default_attributes
+        write_changed_attributes
+        write_changed_relationships
+      end
+
+      def reset_attributes
+        @properties = {}
+      end
+
+      def reload_from_database
+        if reloaded = self.class.load(id)
+          send(:attributes=, reloaded.attributes, false)
+        end
+        reloaded
+      end
+
+      def set_deleted_properties
+        @_deleted   = true
+        @_persisted = false
+        @_java_node = nil
+      end
+
+      # Ensure any defaults are stored in the DB
+      def write_default_attributes
+        attribute_defaults.each do |attribute, value|
+          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class)) 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 _add_relationship(rel_type, attr)
+        clazz = self.class._decl_rels[rel_type.to_sym].target_class
+        node  = clazz.new(attr)
+        if respond_to?("#{rel_type}=")
+          send("#{rel_type}=", node)
+        elsif respond_to?("#{rel_type}")
+          has_n = send("#{rel_type}")
+          has_n << node
+        else
+          raise "oops #{rel_type}"
+        end
+      end
+
+      def _find_node(rel_type, id)
+        if respond_to?("#{rel_type}=")
+          send("#{rel_type}")
+        elsif respond_to?("#{rel_type}")
+          has_n = send("#{rel_type}")
+          has_n.find { |n| n.id == id }
+        else
+          raise "oops #{rel_type}"
+        end
+      end
+
+      def update_nested_attributes(rel_type, attr, options)
+        allow_destroy, reject_if = [options[:allow_destroy], options[:reject_if]] if options
+
+        if new?
+          # We are updating a node that was created with the 'new' method.
+          # The relationship will only be kept in the Value object.
+          _add_relationship(rel_type, attr) unless reject_if?(reject_if, attr) || (allow_destroy && attr[:_destroy] && attr[:_destroy] != '0')
+        else
+          # We have a node that was created with the #create method - has real Neo4j relationships
+          # does it exist ?
+          found   = _find_node(rel_type, attr[:id])
+
+          # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
+          destroy = attr[:_destroy] && attr[:_destroy] != '0'
+
+          if found
+            if destroy
+              found.destroy if allow_destroy
+            else
+              found.update_attributes(attr) # it already exist, so update that one
+            end
+          elsif !destroy && !reject_if?(reject_if, attr)
+            _add_relationship(rel_type, attr)
+          end
+        end
+      end
+
+      public
+      class RecordInvalidError < RuntimeError
+        attr_reader :record
+
+        def initialize(record)
+          @record = record
+          super(@record.errors.full_messages.join(", "))
+        end
+      end
+		end
+	end
+end
+