neo4j 3.0.0.alpha.8 → 3.0.0.alpha.9

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

@@ -0,0 +1,142 @@
+require 'active_support/inflector/inflections'
+
+module Neo4j
+  module ActiveNode
+    module HasN
+      class Association
+        attr_reader :type, :name, :relationship, :direction
+
+        def initialize(type, direction, name, options = {})
+          raise ArgumentError, "Invalid association type: #{type.inspect}" if not [:has_many, :has_one].include?(type.to_sym)
+          raise ArgumentError, "Invalid direction: #{direction.inspect}" if not [:out, :in, :both].include?(direction.to_sym)
+          @type = type.to_sym
+          @name = name
+          @direction = direction.to_sym
+          raise ArgumentError, "Cannot specify both :type and :origin (#{base_declaration})" if options[:type] && options[:origin]
+
+          @target_class_name_from_name = name.to_s.classify
+          @target_class_option = target_class_option(options)
+          @callbacks = {before: options[:before], after: options[:after]}
+          @relationship_type = options[:type] && options[:type].to_sym
+          @origin = options[:origin] && options[:origin].to_sym
+        end
+
+        def target_class_option(options)
+          if options[:model_class].nil?
+            @target_class_name_from_name
+          elsif options[:model_class]
+            options[:model_class]
+          end
+        end
+
+        # Return cypher partial query string for the relationship part of a MATCH (arrow / relationship definition)
+        def arrow_cypher(var = nil, properties = {}, create = false)
+          validate_origin!
+
+          relationship_type = relationship_type(create)
+          relationship_name_cypher = ":`#{relationship_type}`" if relationship_type
+
+          properties_string = get_properties_string(properties)
+          relationship_cypher = get_relationship_cypher(var, relationship_name_cypher, properties_string)
+          get_direction(relationship_cypher, create) 
+        end
+
+        def target_class_name
+          @target_class_option.to_s if @target_class_option
+        end
+
+        def target_class
+          return @target_class if @target_class
+
+          @target_class = target_class_name.constantize if target_class_name
+        rescue NameError
+          raise ArgumentError, "Could not find `#{@target_class}` class and no :model_class specified"
+        end
+
+        def callback(type)
+          @callbacks[type]
+        end
+
+        def perform_callback(caller, other_node, type)
+          return if callback(type).nil?
+          caller.send(callback(type), other_node)
+        end
+
+        def relationship_type(create = false)
+          if @relationship_type
+            @relationship_type
+          elsif @origin
+            origin_type
+          else
+            (create || exceptional_target_class?) && "##{@name}"
+          end
+        end
+
+        private
+
+        def get_direction(relationship_cypher, create)
+          dir = (create && @direction == :both) ? :out : @direction
+          case dir
+          when :out
+            "-#{relationship_cypher}->"
+          when :in
+            "<-#{relationship_cypher}-"
+          when :both
+            "-#{relationship_cypher}-"
+          end
+        end
+
+        def get_relationship_cypher(var, relationship_name_cypher, properties_string)
+          "[#{var}#{relationship_name_cypher}#{properties_string}]"
+        end
+
+        def get_properties_string(properties)
+          p = properties.map do |key, value|
+            "#{key}: #{value.inspect}"
+          end.join(', ')
+          p.size == 0 ? '' : " {#{p}}"
+        end
+
+        def origin_type
+          target_class.associations[@origin].relationship_type
+        end
+
+        # Return basic details about association as declared in the model
+        # @example
+        #   has_many :in, :bands
+        def base_declaration
+          "#{type} #{direction.inspect}, #{name.inspect}"
+        end
+
+
+        # Determine if model class as derived from the association name would be different than the one specified via the model_class key
+        # @example
+        #   has_many :friends                 # Would return false
+        #   has_many :friends, model_class: Friend  # Would return false
+        #   has_many :friends, model_class: Person  # Would return true
+        def exceptional_target_class?
+          # TODO: Exceptional if target_class.nil?? (when model_class false)
+
+          target_class && target_class.name != @target_class_name_from_name
+        end
+
+        def validate_origin!
+          if @origin
+            if target_class
+              if association = target_class.associations[@origin]
+                if @direction == association.direction
+                  raise ArgumentError, "Origin `#{@origin.inspect}` (specified in #{base_declaration}) has same direction `#{@direction}`)"
+                end
+              else
+                raise ArgumentError, "Origin `#{@origin.inspect}` association not found for #{target_class} (specified in #{base_declaration})"
+              end
+            else
+              raise ArgumentError, "Cannot use :origin without a model_class (implied or explicit)"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/neo4j/active_node/id_property.rb

@@ -0,0 +1,119 @@
+module Neo4j::ActiveNode
+
+  # This module makes it possible to use other IDs than the build it neo4j id (neo_id)
+  #
+  # @example using generated UUIDs
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     # creates a 'secret' neo4j property my_uuid which will be used as primary key
+  #     id_property :my_uuid, auto: :uuid
+  #   end
+  #
+  # @example using user defined ids
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     property :title
+  #     validates :title, :presence => true
+  #     id_property :title_id, on: :title_to_url
+  #
+  #     def title_to_url
+  #       self.title.urlize # uses https://github.com/cheef/string-urlize gem
+  #     end
+  #   end
+  #
+  module IdProperty
+    extend ActiveSupport::Concern
+
+
+    module TypeMethods
+      def define_id_methods(clazz, name, conf)
+        validate_conf(conf)
+        if conf[:on]
+          define_custom_method(clazz, name, conf[:on])
+        elsif conf[:auto]
+          raise "only :uuid auto id_property allowed, got #{conf[:auto]}" unless conf[:auto] == :uuid
+          define_uuid_method(clazz, name)
+        else conf.empty?
+          define_property_method(clazz, name)
+        end
+      end
+
+      private
+
+      def validate_conf(conf)
+        return if conf.empty?
+
+        raise "Expected a Hash, got #{conf.class} (#{conf.to_s}) for id_property" unless conf.is_a?(Hash)
+
+        unless conf.include?(:auto) || conf.include?(:on)
+          raise "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
+        end
+      end
+
+      def define_property_method(clazz, name)
+        clazz.module_eval(%Q{
+          def id
+            persisted? ? #{name} : nil
+          end
+
+          property :#{name}
+          validates_uniqueness_of :#{name}
+        }, __FILE__, __LINE__)
+      end
+
+
+      def define_uuid_method(clazz, name)
+        clazz.module_eval(%Q{
+          default_property :#{name} do
+             ::SecureRandom.uuid
+          end
+
+          def #{name}
+             default_property :#{name}
+          end
+
+          alias_method :id, :#{name}
+        }, __FILE__, __LINE__)
+      end
+
+      def define_custom_method(clazz, name, on)
+        clazz.module_eval(%Q{
+          default_property :#{name} do |instance|
+             raise "Specifying custom id_property #{name} on none existing method #{on}" unless instance.respond_to?(:#{on})
+             instance.#{on}
+          end
+
+          def #{name}
+             default_property :#{name}
+          end
+
+          alias_method :id, :#{name}
+        }, __FILE__, __LINE__)
+      end
+
+      extend self
+    end
+
+
+    module ClassMethods
+
+      def find_by_id(key)
+        Neo4j::Node.load(key.to_i)
+      end
+
+
+      def id_property(name, conf = {})
+        TypeMethods.define_id_methods(self, name, conf)
+
+        constraint name, type: :unique
+
+        self.define_singleton_method(:find_by_id) do |key|
+          self.where(name => key).first
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/neo4j/active_node/identity.rb

@@ -1,6 +1,5 @@
 module Neo4j::ActiveNode
   module Identity
-
     def ==(o)
       o.class == self.class && o.id == id
     end
@@ -17,13 +16,9 @@ module Neo4j::ActiveNode
       _persisted_node ? _persisted_node.neo_id : nil
     end
 
-    # @return [String, nil] same as #neo_id
     def id
       id = neo_id
       id.is_a?(Integer) ? id : nil
     end
-
-
   end
-
 end

data/lib/neo4j/active_node/initialize.rb

@@ -11,6 +11,7 @@ module Neo4j::ActiveNode::Initialize
     @_persisted_node = persisted_node
     changed_attributes && changed_attributes.clear
     @attributes = attributes.merge(properties.stringify_keys)
+    self.default_properties=properties
     @attributes = convert_properties_to :ruby, @attributes
   end
 

data/lib/neo4j/active_node/labels.rb

@@ -59,20 +59,19 @@ module Neo4j
       end
 
       module ClassMethods
-
         # Find all nodes/objects of this class
         def all
           self.query_as(:n).pluck(:n)
         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('n.neo_id').pluck(:n).first
+          self.query_as(:n).limit(1).order('ID(n)').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
-          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
+          self.query_as(:n).order('ID(n) DESC').limit(1).pluck(:n).first
         end
 
         # @return [Fixnum] number of nodes of this class
@@ -81,15 +80,14 @@ module Neo4j
         end
 
         # Returns the object with the specified neo4j id.
-        # @param [String,Fixnum] neo_id of node to find
+        # @param [String,Fixnum] 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)
+          raise "Unknown argument #{id.class} in find method (expected String or Fixnum)" if not [String, Fixnum].include?(id.class)
+          find_by_id(id)
         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 
+        # @param [Hash] args of arguments to find
         def find_by(*args)
           self.query_as(:n).where(n: eval(args.join)).limit(1).pluck(:n).first
         end
@@ -100,21 +98,51 @@ module Neo4j
           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
+        # Destroy all nodes and connected relationships
         def destroy_all
           self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`)-[r]-() DELETE n,r")
           self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
         end
 
         # Creates a Neo4j index on given property
+        #
+        # This can also be done on the property directly, see Neo4j::ActiveNode::Property::ClassMethods#property.
+        #
         # @param [Symbol] property the property we want a Neo4j index on
-        def index(property)
-          if self.neo4j_session
-            _index(property)
-          else
-            Neo4j::Session.add_listener do |event, _|
-              _index(property) if event == :session_available
-            end
+        # @param [Hash] conf optional property configuration
+        #
+        # @example
+        #   class Person
+        #      include Neo4j::ActiveNode
+        #      property :name
+        #      index :name
+        #    end
+        #
+        # @example with constraint
+        #   class Person
+        #      include Neo4j::ActiveNode
+        #      property :name
+        #
+        #      # below is same as: index :name, index: :exact, constraint: {type: :unique}
+        #      index :name, constraint: {type: :unique}
+        #    end
+        def index(property, conf = {})
+          Neo4j::Session.on_session_available do |_|
+            _index(property, conf)
+          end
+          @_indexed_properties ||= []
+          @_indexed_properties.push property unless @_indexed_properties.include? property
+        end
+
+        # Creates a neo4j constraint on this class for given property
+        #
+        # @example
+        #   Person.constraint :name, type: :unique
+        #
+        def constraint(property, constraints, session = Neo4j::Session.current)
+          Neo4j::Session.on_session_available do |_|
+            label = Neo4j::Label.create(mapped_label_name)
+            label.create_constraint(property, constraints, session)
           end
         end
 
@@ -132,17 +160,30 @@ module Neo4j
           @_label_name || self.to_s.to_sym
         end
 
-        def indexed_labels
+        # @return [Neo4j::Label] the label for this class
+        def mapped_label
+          Neo4j::Label.create(mapped_label_name)
+        end
 
+        def indexed_properties
+          @_indexed_properties
         end
 
+
         protected
 
-        def _index(property)
+        def _index(property, conf)
           mapped_labels.each do |label|
             # make sure the property is not indexed twice
             existing = label.indexes[:property_keys]
-            label.create_index(property) unless existing.flatten.include?(property)
+
+            # In neo4j constraint automatically creates an index
+            if conf[:constraint]
+              constraint(property, conf[:constraint])
+            else
+              label.create_index(property) unless existing.flatten.include?(property)
+            end
+
           end
         end
 
@@ -150,10 +191,6 @@ module Neo4j
           mapped_label_names.map{|label_name| Neo4j::Label.create(label_name)}
         end
 
-        def mapped_label
-          Neo4j::Label.create(mapped_label_name)
-        end
-
         def set_mapped_label_name(name)
           @_label_name = name.to_sym
         end

data/lib/neo4j/active_node/persistence.rb

@@ -28,6 +28,7 @@ module Neo4j::ActiveNode
     # @return true
     def create_model(*)
       set_timestamps
+      create_magic_properties
       properties = convert_properties_to :db, props
       node = _create_node(properties)
       init_on_load(node, node.props)
@@ -129,7 +130,9 @@ module Neo4j::ActiveNode
 
     def _create_node(*args)
       session = self.class.neo4j_session
-      props = args[0] if args[0].is_a?(Hash)
+      props = self.class.default_property_values(self)
+      props.merge!(args[0]) if args[0].is_a?(Hash)
+      set_classname(props)
       labels = self.class.mapped_label_names
       session.create_node(props, labels)
     end
@@ -193,15 +196,25 @@ module Neo4j::ActiveNode
     end
     alias_method :update_attributes!, :update!
 
+    def cache_key
+      if self.new_record?
+        "#{self.class.model_name.cache_key}/new"
+      elsif self.respond_to?(:updated_at) && !self.updated_at.blank?
+        "#{self.class.model_name.cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}" 
+      else
+        "#{self.class.model_name.cache_key}/#{neo_id}"
+      end
+    end
+
     module ClassMethods
       # Creates a saves a new node
       # @param [Hash] props the properties the new node should have
       def create(props = {})
-        relationship_props = extract_relationship_attributes!(props)
+        association_props = extract_association_attributes!(props)
 
         new(props).tap do |obj|
           obj.save
-          relationship_props.each do |prop, value|
+          association_props.each do |prop, value|
             obj.send("#{prop}=", value)
           end
         end
@@ -210,12 +223,12 @@ module Neo4j::ActiveNode
       # Same as #create, but raises an error if there is a problem during save.
       def create!(*args)
         props = args[0] || {}
-        relationship_props = extract_relationship_attributes!(props)
+        association_props = extract_association_attributes!(props)
 
         new(*args).tap do |o|
           yield o if block_given?
           o.save!
-          relationship_props.each do |prop, value|
+          association_props.each do |prop, value|
             o.send("#{prop}=", value)
           end
         end
@@ -229,10 +242,18 @@ module Neo4j::ActiveNode
 
     private
 
+    def create_magic_properties
+
+    end
+
     def update_magic_properties
       self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed?
     end
 
+    def set_classname(props)
+      props[Neo4j::Config.class_name_property] = self.class.name if self.class.cached_class?
+    end
+
     def assign_attributes(attributes)
       attributes.each do |attribute, value|
         send("#{attribute}=", value)