neo4j 3.0.0.alpha.7 → 3.0.0.alpha.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a71bb2f48417b359fdef8ba5db8e94d13cfcd34
-  data.tar.gz: 03f4c0aa740b9f3b9a8b2f222cecc659a9cd50be
+  metadata.gz: d97243db16c4dce2d4e87eb9551116729065fe2a
+  data.tar.gz: 311559376e0de462bbde5d9dae2d348c041fd3f6
 SHA512:
-  metadata.gz: 8e04c5ccc3a1c56420dfcfa589afbab3219bc995ba92068b2f09d40a1e4e387222869a87f80bd8678b18baea3d606ee7b315020049d7a6d381b459b1908cd1f2
-  data.tar.gz: 6696edb9bc1aa5fcf1ba8c7f0ae7aea8fbd6e5cc881e62aa24ca0cf97dd199ef592cae2fac6ac410efa88a9436d9343121e1a92d93e7c13e5a94638bf24d1baf
+  metadata.gz: 197a923f6617ced1dab9a81adea38fb13fe55b5bd7429b4e84c461b53c2d98b31ff053ee2eb6228541792ba58309b3058d9dee4a0cece6ec68dff79eae921ac4
+  data.tar.gz: c1a71b84e759fd55ab9040c6d357d08cbdf22710e5e7eacbb7b4ddff01a3b07834a4e52c2dc378feb20a6d5c9a01891839216da5918d6ac4559b9e24cfcf87f2

data/CHANGELOG

@@ -1,3 +1,12 @@
+== 3.0.0.alpha.8
+* Integration with new Query API from neo4j-core including:
+* - .query_as and #query_as methods to get queries from models (#366)
+* - .qq method for QuickQuery syntax ( https://github.com/andreasronge/neo4j/wiki/Neo4j-v3#quickquery-work-in-progress / #366)
+* Before and after callbacks on associations (#373)
+* .find / .all / .count changed to be more like ActiveRecord
+* .first / .last methods (#378)
+* .find_by / .find_by! (#375)
+
 == 3.0.0.alpha.7
 * Bug fix uniqueness-validator (#356 from JohnKellyFerguson)
 * Many improvements, like update_attributes and validation while impl orm_adapter, Brian Underwood

data/lib/neo4j.rb

@@ -28,6 +28,9 @@ require 'neo4j/active_node/rels'
 require 'neo4j/active_node/has_n'
 require 'neo4j/active_node/has_n/decl_rel'
 require 'neo4j/active_node/has_n/nodes'
+require 'neo4j/active_node/query/query_proxy'
+require 'neo4j/active_node/query'
+require 'neo4j/active_node/quick_query'
 require 'neo4j/active_node'
 
 require 'neo4j/active_node/orm_adapter'

data/lib/neo4j/active_node.rb

@@ -38,6 +38,7 @@ module Neo4j
     include Neo4j::ActiveNode::Callbacks
     include Neo4j::ActiveNode::Rels
     include Neo4j::ActiveNode::HasN
+    include Neo4j::ActiveNode::Query
 
     def wrapper
       self

data/lib/neo4j/active_node/has_n.rb

@@ -75,7 +75,7 @@ module Neo4j::ActiveNode
       #
       #
       # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_n relationship can be further specified
-      def has_n(rel_type)
+      def has_n(rel_type, *callbacks)
         clazz = self
         module_eval(%Q{def #{rel_type}=(values)
                   #{rel_type}_rels.each {|rel| rel.del }
@@ -103,8 +103,7 @@ module Neo4j::ActiveNode
           def #{rel_type}
             _decl_rels[:#{rel_type}].rel_type
           end}, __FILE__, __LINE__)
-
-        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, false, clazz)
+        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, false, clazz, *callbacks)
       end
 
 
@@ -126,13 +125,14 @@ module Neo4j::ActiveNode
       #   file.folder_rel # => the relationship object between those nodes
       #
       # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_one relationship can be futher specified
-      def has_one(rel_type)
+      def has_one(rel_type, *callbacks)
         clazz = self
         module_eval(%Q{def #{rel_type}=(value)
+                  return if !value
                   dsl = _decl_rels_for(:#{rel_type})
                   rel = dsl.single_relationship(self)
                   rel && rel.del
-                  dsl.create_relationship_to(self, value) if value
+                  dsl.create_relationship_to(self, value)
               end}, __FILE__, __LINE__)
 
         module_eval(%Q{def #{rel_type}
@@ -150,7 +150,7 @@ module Neo4j::ActiveNode
             _decl_rels[:#{rel_type}].rel_type
           end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz)
+        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz, *callbacks)
       end
 
 

data/lib/neo4j/active_node/has_n/decl_rel.rb

@@ -33,12 +33,16 @@ module Neo4j
       class DeclRel
         attr_reader :source_class, :dir, :rel_type, :method_id
 
-        def initialize(method_id, has_one, source_class)
+        def initialize(method_id, has_one, source_class, *callbacks)
           @method_id = method_id
           @has_one = has_one
           @dir = :outgoing
           @rel_type = method_id.to_sym
           @source_class = source_class
+          unless callbacks.empty?
+            @before_callback = callbacks.first[:before] || nil
+            @after_callback = callbacks.first[:after] || nil
+          end
         end
 
         def inherit_new
@@ -223,7 +227,23 @@ module Neo4j
         # @private
         def create_relationship_to(node, other, relationship_props={}) # :nodoc:
           from, to = incoming? ? [other, node] : [node, other]
-          from.create_rel(@rel_type, to, relationship_props)
+          before_callback_result = do_before_callback(node, from, to)
+          return false if before_callback_result == false
+
+          result = from.create_rel(@rel_type, to, relationship_props)
+
+          after_callback_result = do_after_callback(node, from, to)
+          after_callback_result == false ? false : result
+        end
+
+        private
+
+        def do_before_callback(caller, from, to)
+          @before_callback ? caller.send(@before_callback, from, to) : true
+        end
+
+        def do_after_callback(caller, from, to)
+          @after_callback ? caller.send(@after_callback, from, to) : true
         end
 
       end

data/lib/neo4j/active_node/has_n/nodes.rb

@@ -81,8 +81,7 @@ module Neo4j
         #
         # @return self
         def <<(other)
-          @decl_rel.create_relationship_to(@node, other)
-          self
+          !@decl_rel.create_relationship_to(@node, other) ? false : self
         end
       end
 

data/lib/neo4j/active_node/labels.rb

@@ -8,6 +8,7 @@ module Neo4j
 
       WRAPPED_CLASSES = []
       class InvalidQueryError < StandardError; end
+      class RecordNotFound < StandardError; end
 
       # @return the labels
       # @see Neo4j-core
@@ -59,37 +60,45 @@ module Neo4j
 
       module ClassMethods
 
-        # Find all nodes/objects of this class, with given search criteria
-        # @param [Hash, nil] args the search critera or nil if finding all
-        # @param [Neo4j::Session] session defaults to the model's session
-        def all(args = nil, session = self.neo4j_session)
-          if args
-            find_by_hash(args, session)
-          else
-            Neo4j::Label.find_all_nodes(mapped_label_name, session)
-          end
+        # Find all nodes/objects of this class
+        def all
+          self.query_as(:n).pluck(:n)
+        end
+
+        def first
+          self.query_as(:n).limit(1).order('n.neo_id').pluck(:n).first
+        end
+
+        def last
+          count = self.count
+          final_count = count == 0 ? 0 : count - 1
+          self.query_as(:n).order('n.neo_id').skip(final_count).limit(1).pluck(:n).first
         end
 
         # @return [Fixnum] number of nodes of this class
-        def count(session = self.neo4j_session)
-          q = session.query(label: mapped_label_name, return: "count(n) AS count", map_return: :value)
-          q.to_a[0]
-        end
-
-        # Same as #all but return only one object
-        # If given a String or Fixnum it will return the object with that neo4j id.
-        # @param [Hash,String,Fixnum] args search criteria
-        def find(args, session = self.neo4j_session)
-          case args
-            when Hash
-              find_by_hash(args, session).first
-            when String, Fixnum
-              Neo4j::Node.load(args.to_i)
-            else
-              raise "Unknown argument #{args.class} in find method"
-          end
+        def count
+          self.query_as(:n).return("count(n) AS count").first.count
+        end
+
+        # Returns the object with the specified neo4j id.
+        # @param [String,Fixnum] neo_id of node to find
+        def find(id)
+          raise "Unknown argument #{id.class} in find method" if not [String, Fixnum].include?(id.class)
+          
+          Neo4j::Node.load(id.to_i)
+        end
+
+        # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
+        # @param [Hash] hash of arguments to find 
+        def find_by(*args)
+          self.query_as(:n).where(n: eval(args.join)).limit(1).pluck(:n).first
         end
 
+        # Like find_by, except that if no record is found, raises a RecordNotFound error. 
+        def find_by!(*args)
+          a = eval(args.join)
+          find_by(args) or raise RecordNotFound, "#{self.query_as(:n).where(n: a).limit(1).to_cypher} returned no results"
+        end
 
         # Destroy all nodes an connected relationships
         def destroy_all
@@ -129,54 +138,6 @@ module Neo4j
 
         protected
 
-        def find_by_hash(query, session)
-          validate_query!(query)
-
-          extract_relationship_conditions!(query)
-
-          session.query(query.merge(label: mapped_label_name))
-        end
-
-        # Raises an error if query is malformed
-        def validate_query!(query)
-          invalid_query_keys = query.keys.map(&:to_sym) - [:conditions, :order, :limit, :skip]
-
-          raise InvalidQueryError, "Invalid query keys: #{invalid_query_keys.join(', ')}" if not invalid_query_keys.empty?
-        end
-
-        # Takes out :conditions query keys for associations and creates corresponding :conditions and :match keys  
-        # example:
-        # class Person
-        #   property :name
-        #   has_n :friend
-        # end
-        #
-        #   :conditions => {name: 'Fred', friend: person}
-        # should result in:
-        #   :conditions => {name => 'Fred', 'id(n1)' => person.id}, :match => 'n--n1'
-        #
-        def extract_relationship_conditions!(query)
-          node_num = 1
-          if query[:conditions]
-            query[:conditions].dup.each do |key, value|
-              if has_one_relationship?(key)
-                neo_id = value.try(:neo_id) || value
-                raise InvalidQueryError, "Invalid value for '#{key}' condition" if not neo_id.is_a?(Integer)
-
-                query[:match] ||= []
-                n_string = "n#{node_num}"
-                dir = relationship_dir(key)
-
-                match = dir == :outgoing ? "n-->(#{n_string})" : "n<--(#{n_string})"
-                query[:match] << match
-                query[:conditions]["id(#{n_string})"] = neo_id.to_i
-                query[:conditions].delete(key)
-                node_num += 1
-              end
-            end
-          end
-        end
-
         def _index(property)
           mapped_labels.each do |label|
             # make sure the property is not indexed twice

data/lib/neo4j/active_node/orm_adapter.rb

@@ -37,12 +37,9 @@ module Neo4j
         extract_id!(conditions)
         order = hasherize_order(order)
 
-        if !order.empty?
-          klass.find(conditions: conditions, order: order)
-        else
-          result = klass.find(conditions: conditions)
-          result
-        end
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result.first
       end
 
       # Find all models matching conditions
@@ -51,12 +48,10 @@ module Neo4j
         extract_id!(conditions)
         order = hasherize_order(order)
 
-        result = if !order.empty?
-          klass.all(conditions: conditions, order: order, limit: limit, skip: offset)
-        else
-          klass.all(conditions: conditions)
-        end
-
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result = result.skip(offset) if offset
+        result = result.limit(limit) if limit
         result.to_a
       end
 
@@ -78,7 +73,7 @@ module Neo4j
 
       def extract_id!(conditions)
         if id = conditions.delete(:id)
-          conditions['id(n)'] = id.to_i
+          conditions[:neo_id] = id.to_i
         end
       end
 

data/lib/neo4j/active_node/persistence.rb

@@ -19,20 +19,15 @@ module Neo4j::ActiveNode
     # 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
       update_magic_properties
       create_or_update
     end
 
-    def update_magic_properties
-      self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed?
-    end
-
     # Creates a model with values matching those of the instance attributes and returns its id.
     # @private
     # @return true
     def create_model(*)
-      self.created_at = DateTime.now if respond_to?(:created_at=)
+      set_timestamps
       properties = convert_properties_to :db, props
       node = _create_node(properties)
       init_on_load(node, node.props)
@@ -234,12 +229,20 @@ module Neo4j::ActiveNode
 
     private
 
+    def update_magic_properties
+      self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed?
+    end
+
     def assign_attributes(attributes)
       attributes.each do |attribute, value|
         send("#{attribute}=", value)
       end
     end
 
+    def set_timestamps
+      self.created_at = DateTime.now if respond_to?(:created_at=)
+      self.updated_at = self.created_at if respond_to?(:updated_at=)
+    end
   end
 
 end

data/lib/neo4j/active_node/property.rb

@@ -15,9 +15,7 @@ module Neo4j::ActiveNode
     def initialize(attributes={}, options={})
       relationship_props = self.class.extract_relationship_attributes!(attributes)
       writer_method_props = extract_writer_methods!(attributes)
-
       validate_attributes!(attributes)
-
       writer_method_props.each do |key, value|
         self.send("#{key}=", value)
       end
@@ -59,11 +57,15 @@ module Neo4j::ActiveNode
     module ClassMethods
 
       def property(name, options={})
-        # Magic properties
-        options[:type] = DateTime if name.to_sym == :created_at || name.to_sym == :updated_at
+        magic_properties(name, options)
+
+        # if (name.to_s == 'remember_created_at')
+        #   binding.pry
+        # end
         attribute(name, options)
       end
 
+      #overrides ActiveAttr's attribute! method
       def attribute!(name, options={})
         super(name, options)
         define_method("#{name}=") do |value|
@@ -83,6 +85,24 @@ module Neo4j::ActiveNode
         end
       end
 
+      private
+
+      # Tweaks properties
+      def magic_properties(name, options)
+        set_stamp_type(name, options)
+        set_time_as_datetime(options)
+      end
+
+      def set_stamp_type(name, options)
+        options[:type] = DateTime if (name.to_sym == :created_at || name.to_sym == :updated_at)
+      end
+
+      # ActiveAttr does not handle "Time", Rails and Neo4j.rb 2.3 did
+      # Convert it to DateTime in the interest of consistency
+      def set_time_as_datetime(options)
+        options[:type] = DateTime if options[:type] == Time
+      end
+
     end
   end
 

data/lib/neo4j/active_node/query.rb

@@ -0,0 +1,54 @@
+module Neo4j
+  module ActiveNode
+
+    def qq(as = :n1)
+      QuickQuery.new(self, as, self.class)
+    end
+
+    # Helper methods to return Neo4j::Core::Query objects.  A query object can be used to successively build a cypher query
+    #
+    #    person.query_as(:n).match('n-[:friend]-o').return(o: :name) # Return the names of all the person's friends
+    #
+    module Query
+      extend ActiveSupport::Concern
+
+      # Returns a Query object with the current node matched the specified variable name
+      #
+      # @example Return the names of all of Mike's friends
+      #   # Generates: MATCH (mike:Person), mike-[:friend]-friend WHERE ID(mike) = 123 RETURN friend.name
+      #   mike.query_as(:mike).match('mike-[:friend]-friend').return(friend: :name) 
+      #
+      # @param var [Symbol, String] The variable name to specify in the query
+      # @return [Neo4j::Core::Query]
+      def query_as(var)
+        self.class.query_as(var).where("ID(#{var}) = #{self.neo_id}")
+      end
+
+      module ClassMethods
+        # Returns a Query object with all nodes for the model matched as the specified variable name
+        #
+        # @example Return the registration number of all cars owned by a person over the age of 30
+        #   # Generates: MATCH (person:Person), person-[:owned]-car WHERE person.age > 30 RETURN car.registration_number
+        #   Person.query_as(:person).where('person.age > 30').match('person-[:owned]-car').return(car: :registration_number)
+        #
+        # @param var [Symbol, String] The variable name to specify in the query
+        # @return [Neo4j::Core::Query]
+        def query_as(var)
+          label = self.respond_to?(:mapped_label_name) ? self.mapped_label_name : self
+          neo4j_session.query.match(var => label)
+        end
+
+        Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+          module_eval(%Q{
+            def #{method}(*args)
+              Neo4j::ActiveNode::Query::QueryProxy.new(self).#{method}(*args)
+            end}, __FILE__, __LINE__)
+        end
+
+        def qq(as = :n1)
+          QuickQuery.new(self.name.constantize, as)
+        end
+      end
+    end
+  end
+end