neo4j 3.0.0.rc.3 → 3.0.0.rc.4

data/lib/neo4j/active_node/persistence.rb

@@ -1,8 +1,46 @@
 module Neo4j::ActiveNode
   module Persistence
+
+    class RecordInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(", "))
+      end
+    end
+
     extend ActiveSupport::Concern
     include Neo4j::Shared::Persistence
 
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise the existing record gets updated.
+    # If perform_validation is true validations run.
+    # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
+    # There’s a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
+    def save(*)
+      update_magic_properties
+      clear_association_cache
+      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!  Creates a new transaction.
+    #
+    # @raise a RecordInvalidError if there is a problem during save.
+    # @param (see Neo4j::Rails::Validations#save)
+    # @return nil
+    # @see #save
+    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
+    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
+    def save!(*args)
+      unless save(*args)
+        raise RecordInvalidError.new(self)
+      end
+    end
+
     # Creates a model with values matching those of the instance attributes and returns its id.
     # @private
     # @return true
@@ -60,6 +98,7 @@ module Neo4j::ActiveNode
       def load_entity(id)
         Neo4j::Node.load(id)
       end
+
     end
 
     private

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -5,6 +5,11 @@ module Neo4j
 
         include Enumerable
         include Neo4j::ActiveNode::Query::QueryProxyMethods
+        include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
+
+        # The most recent node to start a QueryProxy chain.
+        # Will be nil when using QueryProxy chains on class methods.
+        attr_reader :caller
 
         def initialize(model, association = nil, options = {})
           @model = model
@@ -14,6 +19,7 @@ module Neo4j
           @node_var = options[:node]
           @rel_var = options[:rel] || _rel_chain_var
           @session = options[:session]
+          @caller = options[:caller]
           @chain = []
           @params = options[:query_proxy] ? options[:query_proxy].instance_variable_get('@params') : {}
         end
@@ -22,16 +28,24 @@ module Neo4j
           @node_var || :result
         end
 
+        def enumerable_query(node, rel = nil)
+          pluck_this = rel.nil? ? [node] : [node, rel]
+          return self.pluck(*pluck_this) if @association.nil? || caller.nil?
+          cypher_string = self.to_cypher_with_params(pluck_this)
+          association_collection = caller.association_instance_get(cypher_string, @association)
+          if association_collection.nil?
+            association_collection = self.pluck(*pluck_this)
+            caller.association_instance_set(cypher_string, association_collection, @association) unless association_collection.empty?
+          end
+          association_collection
+        end
+
         def each(node = true, rel = nil, &block)
           if node && rel
-            self.pluck(identity, @rel_var).each do |obj, rel|
-              yield obj, rel
-            end
+            enumerable_query(identity, @rel_var).each { |obj, rel| yield obj, rel }
           else
             pluck_this = !rel ? identity : @rel_var
-            self.pluck(pluck_this).each do |obj|
-              yield obj
-            end
+            enumerable_query(pluck_this).each { |obj| yield obj }
           end
         end
 
@@ -97,6 +111,14 @@ module Neo4j
           query.to_cypher
         end
 
+        # Returns a string of the cypher query with return objects and params
+        # @param [Array] columns array containing symbols of identifiers used in the query
+        # @return [String]
+        def to_cypher_with_params(columns = [:result])
+          final_query = query.return_query(columns)
+          "#{final_query.to_cypher} | params: #{final_query.send(:merge_params)}"
+        end
+
         # To add a relationship for the node for the association on this QueryProxy
         def <<(other_node)
           create(other_node, {})
@@ -131,6 +153,7 @@ module Neo4j
               return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
 
               start_object = @options[:start_object]
+              start_object.clear_association_cache
               _session.query(context: @options[:context])
                 .start(start: "node(#{start_object.neo_id})", end: "node(#{other_node.neo_id})")
                 .create("start#{_association_arrow(properties, true)}end").exec

data/lib/neo4j/active_node/query/query_proxy_find_in_batches.rb

@@ -0,0 +1,20 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyFindInBatches
+        def find_in_batches(options = {})
+          query.return(identity).find_in_batches(identity, @model.primary_key, options) do |batch|
+            yield batch
+          end
+        end
+
+        def find_each(options = {})
+          query.return(identity).find_each(identity, @model.primary_key, options) do |result|
+            yield result
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -4,11 +4,6 @@ module Neo4j
       module QueryProxyMethods
         class InvalidParameterError < StandardError; end
 
-        def query_with_target(target, &block)
-          target = target.nil? ? identity : target
-          block.yield(target)
-        end
-
         def first(target=nil)
           query_with_target(target) { |target| first_and_last("ID(#{target})", target) }
         end
@@ -42,19 +37,36 @@ module Neo4j
         def include?(other, target=nil)
           raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
           query_with_target(target) do |target|
-            self.where("ID(#{target}) = {other_node_id}").params(other_node_id: other.neo_id).query.return("count(#{target}) AS count").first.count > 0
+            self.query.where(target => {@model.primary_key => other.id}).return("count(#{target}) AS count").first.count > 0
           end
         end
 
-        def exists?(node_id=nil, target=nil)
-          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
+        def exists?(node_condition=nil, target=nil)
+          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
           query_with_target(target) do |target|
-            start_q = self.query
-            end_q = node_id.nil? ? start_q : start_q.where("ID(#{target}) = #{node_id}")
-            end_q.return("COUNT(#{target}) AS count").first.count > 0
+            start_q = exists_query_start(self, node_condition, target)
+            start_q.query.return("COUNT(#{target}) AS count").first.count > 0
+          end
+        end
+
+        private
+
+        def query_with_target(target, &block)
+          target = target.nil? ? identity : target
+          block.yield(target)
+        end
+
+        def exists_query_start(origin, condition, target)
+          case
+          when condition.class == Fixnum
+            self.where("ID(#{target}) = #{condition}")
+          when condition.class == Hash
+            self.where(condition.keys.first => condition.values.first)
+          else
+            self
           end
         end
       end
     end
   end
-end
+end

data/lib/neo4j/active_node/query_methods.rb

@@ -3,21 +3,21 @@ module Neo4j
     module QueryMethods
       class InvalidParameterError < StandardError; end
 
-      def exists?(node_id=nil)
-        raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
-        start_q = self.query_as(:n)
-        end_q = node_id.nil? ? start_q : start_q.where("ID(n) = #{node_id}")
-        end_q.return("COUNT(n) AS count").first.count > 0
+      def exists?(node_condition=nil)
+        raise(InvalidParameterError, ':exists? only accepts ids or conditions') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
+        query_start = exists_query_start(node_condition)
+        start_q = query_start.respond_to?(:query_as) ? query_start.query_as(:n) : query_start
+        start_q.return("COUNT(n) AS count").first.count > 0
       end
 
       # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
       def first
-        self.query_as(:n).limit(1).order('ID(n)').pluck(:n).first
+        self.query_as(:n).limit(1).order(n: primary_key).pluck(:n).first
       end
 
       # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
       def last
-        self.query_as(:n).limit(1).order('ID(n) DESC').pluck(:n).first
+        self.query_as(:n).limit(1).order(n: {primary_key => :desc}).pluck(:n).first
       end
 
       # @return [Fixnum] number of nodes of this class
@@ -38,10 +38,21 @@ module Neo4j
 
       def include?(other)
         raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
-        self.query_as(:n).where("ID(n) = #{other.neo_id}").return("count(n) AS count").first.count > 0
+        self.query_as(:n).where(n: {primary_key => other.id}).return("count(n) AS count").first.count > 0
       end
 
-
+      private
+
+      def exists_query_start(node_condition)
+        case
+        when node_condition.class == Fixnum
+          self.query_as(:n).where("ID(n) = #{node_condition}")
+        when node_condition.class == Hash
+          self.where(node_condition.keys.first => node_condition.values.first)
+        else
+          self.query_as(:n)
+        end
+      end
     end
   end
-end
+end

data/lib/neo4j/active_node/reflection.rb

@@ -0,0 +1,85 @@
+module Neo4j::ActiveNode
+  # A reflection contains information about an association. 
+  # They are often used in connection with form builders to determine associated classes.
+  # This module contains methods related to the creation and retrieval of reflections.
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Adds methods to the class related to creating and retrieving reflections.
+    module ClassMethods
+      # @param macro [Symbol] the association type, :has_many or :has_one
+      # @param name [Symbol] the association name
+      # @param association_object [Neo4j::ActiveNode::HasN::Association] the association object created in the course of creating this reflection
+      def create_reflection(macro, name, association_object)
+        self.reflections = self.reflections.merge(name => AssociationReflection.new(macro, name, association_object))
+      end
+
+      private :create_reflection
+      # @param [Symbol] an association declared on the model
+      # @return [Neo4j::ActiveNode::Reflection::AssociationReflection] of the given association
+      def reflect_on_association(association)
+        reflections[association.to_sym]
+      end
+
+      # Returns an array containing one reflection for each association declared in the model.
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+    end
+
+    # The actual reflection object that contains information about the given association.
+    # These should never need to be created manually, they will always be created by declaring a :has_many or :has_one association on a model.
+    class AssociationReflection
+      # The name of the association
+      attr_reader :name
+
+      # The type of association
+      attr_reader :macro
+
+      # The association object referenced by this reflection
+      attr_reader :association
+
+      def initialize(macro, name, association)
+        @macro        = macro
+        @name         = name
+        @association  = association
+      end
+
+      # Returns the target model
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the name of the target model
+      def class_name
+        @class_name ||= association.target_class.name
+      end
+
+      def rel_klass
+        @rel_klass ||= rel_class_name.constantize
+      end
+
+      def rel_class_name
+        @rel_class_name ||= association.relationship_class.name.to_s
+      end
+
+      def type
+        @type ||= association.relationship_type
+      end
+
+      def collection?
+        macro == :has_many
+      end
+
+      def validate?
+        true
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/callbacks.rb

@@ -5,7 +5,9 @@ module Neo4j
       include Neo4j::Shared::Callbacks
 
       def save(*args)
-        raise Neo4j::ActiveRel::Persistence::RelInvalidError.new(self) unless self.persisted? || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
+        unless self.persisted? || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
+          raise Neo4j::ActiveRel::Persistence::RelInvalidError, 'from_node and to_node must be node objects'
+        end 
         super(*args)
       end
     end

data/lib/neo4j/active_rel/initialize.rb

@@ -10,12 +10,12 @@ module Neo4j::ActiveRel
     # @param [Neo4j::Relationship] start_node the starting node in the relationship.
     # @param [Neo4j::Relationship] end_node the ending node in the relationship
     # @param [String] type the relationship type
-    def init_on_load(persisted_rel, start_node_id, end_node_id, type)
+    def init_on_load(persisted_rel, from_node_id, to_node_id, type)
       @_persisted_obj = persisted_rel
       @rel_type = type
       changed_attributes && changed_attributes.clear
       @attributes = attributes.merge(persisted_rel.props.stringify_keys)
-      load_nodes(start_node_id, end_node_id)
+      load_nodes(from_node_id, to_node_id)
       self.default_properties = persisted_rel.props
       @attributes = convert_properties_to :ruby, @attributes
     end

data/lib/neo4j/active_rel/persistence.rb

@@ -3,14 +3,7 @@ module Neo4j::ActiveRel
     extend ActiveSupport::Concern
     include Neo4j::Shared::Persistence
 
-    class RelInvalidError < RuntimeError
-      attr_reader :record
-
-      def initialize(record)
-        @record = record
-        super(@record.errors.full_messages.join(", "))
-      end
-    end
+    class RelInvalidError < RuntimeError; end
 
     class ModelClassInvalidError < RuntimeError; end
 
@@ -31,7 +24,7 @@ module Neo4j::ActiveRel
       set_timestamps
       properties = convert_properties_to :db, props
       rel = _create_rel(from_node, to_node, properties)
-      init_on_load(rel, to_node, from_node, @rel_type)
+      init_on_load(rel, from_node, to_node, @rel_type)
       true
     end
 
@@ -61,10 +54,10 @@ module Neo4j::ActiveRel
 
     def confirm_node_classes
       [from_node, to_node].each do |node|
-        check = from_node == node ? :_from_class : :_to_class
-        next if self.class.send(check) == :any
-        unless self.class.send(check) == node.class        
-          raise ModelClassInvalidError, "Node class was #{node.class}, expected #{self.class.send(check)}" 
+        type = from_node == node ? :_from_class : :_to_class
+        next if allows_any_class?(type)
+        unless class_as_constant(type) == node.class
+          raise ModelClassInvalidError, "Node class was #{node.class}, expected #{self.class.send(type)}"
         end
       end
     end
@@ -75,5 +68,21 @@ module Neo4j::ActiveRel
       set_classname(props)
       from_node.create_rel(type, to_node, props)
     end
+
+    def class_as_constant(type)
+      given_class = self.class.send(type)
+      case
+      when given_class.is_a?(String)
+        given_class.constantize
+      when given_class.is_a?(Symbol)
+        given_class.to_s.constantize
+      else
+        given_class
+      end
+    end
+
+    def allows_any_class?(type)
+      self.class.send(type) == :any || self.class.send(type) == false
+    end
   end
-end
+end

data/lib/neo4j/active_rel/property.rb

@@ -1,4 +1,3 @@
-
 module Neo4j::ActiveRel
   module Property
     extend ActiveSupport::Concern
@@ -7,7 +6,7 @@ module Neo4j::ActiveRel
     %w[to_node from_node].each do |direction|
       define_method("#{direction}") { instance_variable_get("@#{direction}") }
       define_method("#{direction}=") do |argument|
-        raise FrozenRelError, "Relationship start/end nodes cannot be changed once persisted" if self.persisted?
+        raise FrozenRelError, 'Relationship start/end nodes cannot be changed once persisted' if self.persisted?
         instance_variable_set("@#{direction}", argument)
       end
     end
@@ -15,18 +14,18 @@ module Neo4j::ActiveRel
     alias_method :start_node, :from_node
     alias_method :end_node,   :to_node
 
+    # @return [String] a string representing the relationship type that will be created
     def type
       self.class._type
     end
 
-    def initialize(attributes={}, options={})
+    def initialize(attributes = {}, options = {})
       super(attributes, options)
 
       send_props(@relationship_props) unless @relationship_props.nil?
     end
 
     module ClassMethods
-
       # Extracts keys from attributes hash which are relationships of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
@@ -43,10 +42,12 @@ module Neo4j::ActiveRel
       alias_method :start_class,  :from_class
       alias_method :end_class,    :to_class
 
+      # @param type [String] sets the relationship type when creating relationships via this class
       def type(type = nil)
         @rel_type = type
       end
 
+      # @return [String] a string representing the relationship type that will be created
       def _type
         @rel_type
       end
@@ -54,15 +55,13 @@ module Neo4j::ActiveRel
       def load_entity(id)
         Neo4j::Node.load(id)
       end
-
     end
 
     private
 
-    def load_nodes(start_node=nil, end_node=nil)
-      @from_node = RelatedNode.new(end_node)
-      @to_node = RelatedNode.new(start_node)
+    def load_nodes(from_node = nil, to_node = nil)
+      @from_node = RelatedNode.new(from_node)
+      @to_node = RelatedNode.new(to_node)
     end
-
   end
-end
+end