neo4j 1.0.0.beta.21-java

data/lib/neo4j/rails/railtie.rb

@@ -0,0 +1,21 @@
+module Neo4j
+  class Railtie < ::Rails::Railtie
+    config.neo4j = ActiveSupport::OrderedOptions.new
+
+    initializer "neo4j.tx" do |app|
+      app.config.middleware.use Neo4j::Rails::LuceneConnectionCloser
+    end
+    
+    # Add ActiveModel translations to the I18n load_path
+    initializer "i18n" do |app|
+    	config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]
+    end
+
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer "neo4j.start", :after => :load_config_initializers do |app|
+      Neo4j::Config.setup.merge!(app.config.neo4j.to_hash)
+      Neo4j.start
+    end
+  end
+end

data/lib/neo4j/rails/relationships/mapper.rb

@@ -0,0 +1,96 @@
+module Neo4j
+  module Rails
+    module Relationships
+
+      class Mapper
+        def initialize(rel_type, dsl=nil)
+          @rel_type      = rel_type
+          @relationships = []
+          @dsl           = dsl
+        end
+
+        def rel_type
+          (@dsl && @dsl.rel_type) || @rel_type
+        end
+
+        def direction
+          (@dsl && @dsl.direction) || :outgoing
+        end
+
+        def to_s
+          "#{self.class} #{object_id} dir: #{direction} rel_type: #{@rel_type} wrapped #{@dsl}"
+        end
+        
+        def single_relationship(*)
+          @relationships.first
+        end
+
+        def each(&block)
+          # TODO direction
+          # TODO DRY
+          @relationships.each do |rel|
+            block.call rel.end_node
+          end
+          @dsl.each(&block) if @dsl
+        end
+
+        def each_node(node, direction, &block) #:nodoc:
+          # TODO direction
+          @relationships.each do |rel|
+            block.call rel.end_node
+          end
+          @dsl.each_node(node, direction, &block) if @dsl && node.persisted?
+        end
+
+        def del_rel(rel)
+          # TODO, we need to delete this when it is saved
+          @relationships.delete(rel)
+        end
+
+        def create_relationship_to(from, to)
+          #rel_type = (@dsl && @dsl.rel_type) || @rel_type
+          #from, to = (@dsl && @dsl.incoming?) ? [to, from] : [from, to]
+          @relationships << Relationship.new(@rel_type, from, to, self)
+        end
+
+        def single_node(from)
+          if !@relationships.empty?
+            @relationships.first.end_node
+          else
+            @dsl.single_node(from) if @dsl && from.persisted?
+          end
+        end
+
+        def valid?
+          all_valid = true
+          !@relationships.each do |rel|
+            start_node = rel.start_node
+            end_node = rel.end_node
+
+            if !end_node.valid?
+              all_valid                = false
+              start_node.errors[@rel_type.to_sym] ||= []
+              start_node.errors[@rel_type.to_sym] << end_node.errors
+            end
+          end
+          all_valid
+        end
+
+        def persist
+          @relationships.each do |rel|
+            if @dsl
+              start_node = rel.start_node
+              end_node = rel.end_node
+
+              end_node.save!
+              @dsl.create_relationship_to(start_node, end_node)
+            else
+              rel.end_node.save!
+              rel.start_node.outgoing(@rel_type) << rel.end_node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/relationships/relationship.rb

@@ -0,0 +1,30 @@
+module Neo4j
+  module Rails
+    module Relationships
+
+      class Relationship
+        attr_reader :rel_type, :start_node, :end_node
+
+
+        def initialize(rel_type, start_node, end_node, decl)
+          @rel_type   = rel_type
+          @start_node = start_node
+          @end_node   = end_node
+          @decl       = decl
+        end
+
+        def del
+          @decl.del_rel(self)
+        end
+
+        def persist
+          @start_node._java
+        end
+
+        def to_s
+          "Rel [#{rel_type} start #{start_node} end #{end_node}]"
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/relationships/relationships.rb

@@ -0,0 +1,60 @@
+module Neo4j
+  module Rails
+    module Relationships
+
+      # TODO, reuse for incoming relationships ?
+      class OutgoingRelationship
+        include Enumerable
+
+        def initialize(from_node, mapper)
+          @from_node = from_node
+          @mapper    = mapper
+        end
+
+        def <<(other)
+          @mapper.create_relationship_to(@from_node, other)
+        end
+
+        def each(&block)
+          # TODO Direction
+          @mapper.each &block
+        end
+      end
+
+      
+      def write_changed_relationships
+        @relationships.each_value do |mapper|
+          mapper.persist
+        end
+      end
+
+      def valid_relationships?
+        !@relationships.values.find {|mapper| !mapper.valid?}
+      end
+
+      def _decl_rels_for(type)
+        dsl = super
+        if false && persisted?
+          dsl
+        else
+          @relationships[type] ||= Mapper.new(type, dsl)
+        end
+      end
+
+
+      def clear_relationships
+        @relationships = {}
+      end
+
+
+      def outgoing(rel_type)
+        if persisted?
+          super
+        else
+          @relationships[rel_type] ||= Mapper.new(rel_type)
+          OutgoingRelationship.new(self, @relationships[rel_type])
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/serialization.rb

@@ -0,0 +1,25 @@
+module Neo4j
+	module Rails
+		module Serialization
+			extend ActiveSupport::Concern
+			
+			included do
+				include ActiveModel::Serializers::Xml
+				
+				# Patch for ActiveModel's XML serializer.  There is a bug in the original where
+				# raw_value is used in the initializer and so demands always that the object being 
+				# serialized is sent the attribute's name as a method call.  This causes a problem
+				# for Neo4j properties that aren't declared and so don't have methods to call.  Besides
+				# which it's not necessary to re-call to get the value again if it has already
+				# been passed.
+				class ActiveModel::Serializers::Xml::Serializer::Attribute
+					def initialize(name, serializable, raw_value=nil)
+            @name, @serializable = name, serializable
+            @value = raw_value || @serializable.send(name)
+            @type  = compute_type
+          end
+        end
+			end
+		end
+	end
+end

data/lib/neo4j/rails/timestamps.rb

@@ -0,0 +1,65 @@
+# Handle all the created_at, updated_at, created_on, updated_on type stuff.
+module Neo4j
+	module Rails
+		module Timestamps
+			extend ActiveSupport::Concern
+			
+			TIMESTAMP_PROPERTIES = [ :created_at, :created_on, :updated_at, :updated_on ]
+			
+			def write_changed_attributes
+				update_timestamp
+				super
+			end
+			
+			def init_on_create(*args)
+				create_timestamp
+				super
+			end
+			
+			# Set the timestamps for this model if timestamps is set to true in the config
+			# and the model is set up with the correct property name, e.g.:
+			#
+			#   class Trackable < Neo4j::Rails::Model
+			#     property :updated_at, :type => DateTime
+			#   end
+			def update_timestamp
+				write_date_or_timestamp(:updated_at) if Neo4j::Config[:timestamps] && respond_to?(:updated_at)
+			end
+			
+			# Set the timestamps for this model if timestamps is set to true in the config
+			# and the model is set up with the correct property name, e.g.:
+			#
+			#   class Trackable < Neo4j::Rails::Model
+			#     property :created_at, :type => DateTime
+			#   end
+			def create_timestamp
+				write_date_or_timestamp(:created_at) if Neo4j::Config[:timestamps] && respond_to?(:created_at)
+			end
+			
+			# Write the timestamp as a Date, DateTime or Time depending on the property type
+			def write_date_or_timestamp(attribute)
+				value = case self.class._decl_props[attribute][:type].to_s
+				when "DateTime"
+					DateTime.now
+				when "Date"
+					Date.today
+				when "Time"
+					Time.now
+				end
+				
+				send("#{attribute}=", value)
+			end
+			
+			module ClassMethods
+				def property_setup(property, options)
+					super
+					
+					# ensure there's always a type on the timestamp properties
+					if Neo4j::Config[:timestamps] && TIMESTAMP_PROPERTIES.include?(property)
+						_decl_props[property][:type] = Time
+					end
+				end
+			end
+		end
+	end
+end

data/lib/neo4j/rails/transaction.rb

@@ -0,0 +1,67 @@
+module Neo4j
+  module Rails
+
+    # This method is typically used in an Rails ActionController as a filter method.
+    # It will guarantee that an transaction is create before your action is called,
+    # and that the transaction is finished after your action is called.
+    #
+    # Example:
+    #  class MyController < ActionController::Base
+    #      around_filter Neo4j::Rails::Transaction, :only => [:edit, :delete]
+    #      ...
+    #  end
+    class Transaction
+      class << self
+        def new
+          finish if Thread.current[:neo4j_transaction]
+          Thread.current[:neo4j_transaction] = Neo4j::Transaction.new
+        end
+
+        def current
+          Thread.current[:neo4j_transaction]
+        end
+
+        def running?
+          Thread.current[:neo4j_transaction] != nil
+        end
+
+        def fail?
+          Thread.current[:neo4j_transaction_fail] != nil
+        end
+
+        def fail
+          Thread.current[:neo4j_transaction_fail] = true
+        end
+
+        def success
+          Thread.current[:neo4j_transaction_fail] = nil
+        end
+
+        def finish
+          tx = Thread.current[:neo4j_transaction]
+          tx.success unless fail?
+          tx.finish
+          Thread.current[:neo4j_transaction] = nil
+          Thread.current[:neo4j_transaction_fail] = nil
+        end
+
+        def filter(*, &block)
+          run &block
+        end
+
+        def run
+          begin
+            new
+            ret = yield self
+          rescue
+            fail
+            raise
+          ensure
+            finish
+          end
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/tx_methods.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Rails
+    module TxMethods
+      def tx_methods(*methods)
+        methods.each do |method|
+          tx_method = "#{method}_in_tx"
+          send(:alias_method, tx_method, method)
+          send(:define_method, method) do |*args|
+            Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/validations.rb

@@ -0,0 +1,38 @@
+module Neo4j
+  module Rails
+    module Validations
+      include ActiveModel::Validations
+
+      def read_attribute_for_validation(key)
+        respond_to?(key) ? send(key) : self[key]
+      end
+
+      # The validation process on save can be skipped by passing false. The regular Model#save method is
+      # replaced with this when the validations module is mixed in, which it is by default.
+      def save(options={})
+        perform_validations(options) ? super : false
+      end
+
+      def valid?(context = nil)
+        context     ||= (new_record? ? :create : :update)
+        output      = super(context)
+        output_rels = valid_relationships?
+        errors.empty? && output && output_rels
+      end
+
+      private
+      def perform_validations(options={})
+        perform_validation = case options
+                               when Hash
+                                 options[:validate] != false
+                             end
+
+        if perform_validation
+          valid?(options.is_a?(Hash) ? options[:context] : nil)
+        else
+          true
+        end
+      end
+    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

@@ -0,0 +1,37 @@
+module Neo4j
+	module Rails
+		module Validations
+			extend ActiveSupport::Concern
+			
+			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.inspect} 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)
+					return if options[:allow_blank] && value.blank?
+					record.class.all("#{attribute}: \"#{value}\"").each do |rec|
+            if rec.id != record.id # it doesn't count if we find ourself!
+              record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+              break
+            end
+					end
+				end
+			end
+	
+			module ClassMethods
+				def validates_uniqueness_of(*attr_names)
+					validates_with UniquenessValidator, _merge_attributes(attr_names)
+				end
+			end
+		end
+	end
+end