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

data/lib/neo4j/active_node/property.rb

@@ -9,11 +9,12 @@ module Neo4j::ActiveNode
     include ActiveAttr::QueryAttributes
     include ActiveModel::Dirty
 
-    class UndefinedPropertyError < RuntimeError
-    end
+    class UndefinedPropertyError < RuntimeError; end
+    class MultiparameterAssignmentError < StandardError; end
 
     def initialize(attributes={}, options={})
-      relationship_props = self.class.extract_relationship_attributes!(attributes)
+      attributes = process_attributes(attributes)
+
       writer_method_props = extract_writer_methods!(attributes)
       validate_attributes!(attributes)
       writer_method_props.each do |key, value|
@@ -23,12 +24,6 @@ module Neo4j::ActiveNode
       super(attributes, options)
     end
 
-    def save_properties
-      @previously_changed = changes
-      changed_attributes.clear
-    end
-
-
     # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
     def read_attribute(name)
       super(name)
@@ -37,6 +32,23 @@ module Neo4j::ActiveNode
     end
     alias_method :[], :read_attribute
 
+    def default_properties=(properties)
+      keys = self.class.default_properties.keys
+      @default_properties = properties.reject{|key| !keys.include?(key)}
+    end
+
+    def default_property(key)
+      keys = self.class.default_properties.keys
+      keys.include?(key.to_sym) ? default_properties[key.to_sym] : nil
+    end
+
+    def default_properties
+      @default_properties ||= {}
+      # keys = self.class.default_properties.keys
+      # _persisted_node.props.reject{|key| !keys.include?(key)}
+    end
+
+
     private
 
     # Changes attributes hash to remove relationship keys
@@ -54,18 +66,105 @@ module Neo4j::ActiveNode
       end
     end
 
+    # Gives support for Rails date_select, datetime_select, time_select helpers.
+    def process_attributes(attributes = nil)
+      multi_parameter_attributes = {}
+      new_attributes = {}
+      attributes.each_pair do |key, value|
+        if key =~ /\A([^\(]+)\((\d+)([if])\)$/
+          found_key, index = $1, $2.to_i
+          (multi_parameter_attributes[found_key] ||= {})[index] = value.empty? ? nil : value.send("to_#{$3}")
+        else
+          new_attributes[key] = value
+        end
+      end
+
+      multi_parameter_attributes.empty? ? new_attributes : process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
+    end
+
+    def process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
+      multi_parameter_attributes.each_pair do |key, values|
+        begin
+          values = (values.keys.min..values.keys.max).map { |i| values[i] }
+          field = self.class.attributes[key.to_sym]
+          new_attributes[key] = instantiate_object(field, values)
+        rescue => e
+          raise MultiparameterAssignmentError, "error on assignment #{values.inspect} to #{key}"
+        end
+      end
+      new_attributes
+    end
+
+    def instantiate_object(field, values_with_empty_parameters)
+      return nil if values_with_empty_parameters.all? { |v| v.nil? }
+      values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
+      klass = field[:type]
+      if klass
+        klass.new(*values)
+      else
+        values
+      end
+    end
+
     module ClassMethods
 
+      # Defines a property on the class
+      #
+      # See active_attr gem for allowed options, e.g which type
+      # Notice, in Neo4j you don't have to declare properties before using them, see the neo4j-core api.
+      #
+      # @example Without type
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name
+      #    end
+      #
+      # @example With type and a default value
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :score, type: Integer, default: 0
+      #    end
+      #
+      # @example With an index
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name, index: :exact
+      #    end
+      #
+      # @example With a constraint
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name, constraint: :unique
+      #    end
       def property(name, options={})
         magic_properties(name, options)
-
-        # if (name.to_s == 'remember_created_at')
-        #   binding.pry
-        # end
         attribute(name, options)
+
+        # either constraint or index, do not set both
+        if options[:constraint]
+          raise "unknown constraint type #{options[:constraint]}, only :unique supported" if options[:constraint] != :unique
+          constraint(name, type: :unique)
+        elsif options[:index]
+          raise "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
+          index(name, options) if options[:index] == :exact
+        end
+      end
+
+      def default_property(name, &block)
+        default_properties[name] = block
+      end
+
+      # @return [Hash<Symbol,Proc>]
+      def default_properties
+        @default_property ||= {}
+      end
+
+      def default_property_values(instance)
+        default_properties.inject({}) do |result,pair|
+          result.tap{|obj| obj[pair[0]] = pair[1].call(instance)}
+        end
       end
 
-      #overrides ActiveAttr's attribute! method
       def attribute!(name, options={})
         super(name, options)
         define_method("#{name}=") do |value|
@@ -75,13 +174,17 @@ module Neo4j::ActiveNode
         end
       end
 
+      def cached_class?
+        !!Neo4j::Config[:cache_class_names]
+      end
+
       # 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_relationship_attributes!(attributes)
-        attributes.keys.inject({}) do |relationship_props, key|
-          relationship_props[key] = attributes.delete(key) if self.has_relationship?(key)
+      def extract_association_attributes!(attributes)
+        attributes.keys.inject({}) do |association_props, key|
+          association_props[key] = attributes.delete(key) if self.has_association?(key)
 
-          relationship_props
+          association_props
         end
       end
 

data/lib/neo4j/active_node/query.rb

@@ -1,10 +1,6 @@
 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
@@ -25,6 +21,14 @@ module Neo4j
       end
 
       module ClassMethods
+        include Enumerable
+
+        attr_writer :query_proxy
+
+        def each
+          self.query_as(:n).pluck(:n).each {|o| yield o }
+        end
+
         # 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
@@ -34,20 +38,24 @@ module Neo4j
         # @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)
+          query_proxy.query_as(var)
         end
 
         Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
           module_eval(%Q{
             def #{method}(*args)
-              Neo4j::ActiveNode::Query::QueryProxy.new(self).#{method}(*args)
+              self.query_proxy.#{method}(*args)
             end}, __FILE__, __LINE__)
         end
 
-        def qq(as = :n1)
-          QuickQuery.new(self.name.constantize, as)
+        def query_proxy(options = {})
+          @query_proxy || Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
+        end
+
+        def as(node_var)
+          query_proxy(node: node_var)
         end
+
       end
     end
   end

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

@@ -5,17 +5,42 @@ module Neo4j
       class QueryProxy
         include Enumerable
 
-        def initialize(model)
+        def initialize(model, association = nil, options = {})
           @model = model
+          @association = association
+          @options = options
+          @node_var = options[:node]
+          @rel_var = options[:rel] || _rel_chain_var
+          @session = options[:session]
           @chain = []
+          @params = {}
         end
 
-        def each
-          query_as(:n).pluck(:n).each do |obj|
-            yield obj
+        def each(node = true, rel = nil, &block)
+          if node && rel
+            self.pluck((@node_var || :result), @rel_var).each do |obj, rel|
+              yield obj, rel
+            end
+          else
+            pluck_this = !rel ? (@node_var || :result) : @rel_var
+            self.pluck(pluck_this).each do |obj|
+              yield obj
+            end
           end
         end
 
+        def each_rel(&block)
+          block_given? ? each(false, true, &block) : to_enum(:each, false, true)
+        end
+
+        def each_with_rel(&block)
+          block_given? ? each(true, true, &block) : to_enum(:each, true, true)
+        end
+
+        def ==(value)
+          self.to_a == value
+        end
+
         METHODS = %w[where order skip limit]
 
         METHODS.each do |method|
@@ -28,75 +53,206 @@ module Neo4j
         alias_method :offset, :skip
         alias_method :order_by, :order
 
+        # For getting variables which have been defined as part of the association chain
+        def pluck(*args)
+          self.query.pluck(*args)
+        end
+
+        def params(params)
+          self.dup.tap do |new_query|
+            new_query._add_params(params)
+          end
+        end
+
+        # Like calling #query_as, but for when you don't care about the variable name
+        def query
+          query_as(@node_var || :result)
+        end
+
+        # Build a Neo4j::Core::Query object for the QueryProxy
         def query_as(var)
-          query = @model.query_as(var).return(var)
+          var = @node_var if @node_var
 
-          @chain.inject(query) do |query, (method, arg)|
-            if arg.respond_to?(:call)
-              query.send(method, arg.call(var))
-            else
-              query.send(method, arg)
-            end
+          query = if @association
+            chain_var = _association_chain_var
+            label_string = @model && ":`#{@model.name}`"
+            (_association_query_start(chain_var) & _query_model_as(var)).match("#{chain_var}#{_association_arrow}(#{var}#{label_string})")
+          else
+            _query_model_as(var)
+          end
+
+          # Build a query chain via the chain, return the result
+          @chain.inject(query.params(@params)) do |query, (method, arg)|
+            query.send(method, arg.respond_to?(:call) ? arg.call(var) : arg)
           end
         end
 
+        # Cypher string for the QueryProxy's query
         def to_cypher
-          query_as(:n).to_cypher
+          query.to_cypher
+        end
+
+        # To add a relationship for the node for the association on this QueryProxy
+        def <<(other_node)
+          create(other_node, {})
+
+          self
+        end
+
+        def [](index)
+          # TODO: Maybe for this and other methods, use array if already loaded, otherwise
+          # use OFFSET and LIMIT 1?
+          self.to_a[index]
+        end
+
+        def create(other_nodes, properties)
+          raise "Can only create associations on associations" unless @association
+          other_nodes = [other_nodes].flatten
+
+          raise ArgumentError, "Node must be of the association's class when model is specified" if @model && other_nodes.any? {|other_node| other_node.class != @model }
+          other_nodes.each do |other_node|
+            #Neo4j::Transaction.run do
+              other_node.save if not other_node.persisted?
+
+              return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
+
+              _association_query_start(:start)
+                .match(end: other_node.class)
+                .where(end: {neo_id: other_node.neo_id})
+                .create("start#{_association_arrow(properties, true)}end").exec
+
+              @association.perform_callback(@options[:start_object], other_node, :after)
+            #end
+          end
+        end
+
+        # QueryProxy objects act as a representation of a model at the class level so we pass through calls
+        # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
+        def method_missing(method_name, *args)
+          if @model && @model.respond_to?(method_name)
+            @model.query_proxy = self
+            result = @model.send(method_name, *args)
+            @model.query_proxy = nil
+            result
+          else
+            super
+          end
         end
 
         protected
+        # Methods are underscored to prevent conflict with user class methods
+
+        attr_reader :node_var
+
+        def _add_params(params)
+          @params = @params.merge(params)
+        end
 
-        def add_links(links)
+        def _add_links(links)
           @chain += links
         end
 
+        def _query_model_as(var)
+          if @model
+            label = @model.respond_to?(:mapped_label_name) ? @model.mapped_label_name : @model
+            _session.query.match(var => label)
+          else
+            _session.query.match(var)
+          end
+        end
+
+        def _session
+          @session || (@model && @model.neo4j_session)
+        end
+
+        def _association_arrow(properties = {}, create = false)
+          @association && @association.arrow_cypher(@rel_var, properties, create)
+        end
+
+        def _chain_level
+          if @options[:start_object]
+            1
+          elsif query_proxy = @options[:query_proxy]
+            query_proxy._chain_level + 1
+          else
+            1
+          end
+        end
+
+        def _association_chain_var
+          if start_object = @options[:start_object]
+            :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id}"
+          elsif query_proxy = @options[:query_proxy]
+            query_proxy.node_var || :"node#{_chain_level}"
+          else
+            raise "Crazy error" # TODO: Better error
+          end
+        end
+
+        def _association_query_start(var)
+          if start_object = @options[:start_object]
+            start_object.query_as(var)
+          elsif query_proxy = @options[:query_proxy]
+            query_proxy.query_as(var)
+          else
+            raise "Crazy error" # TODO: Better error
+          end
+        end
+
+        def _rel_chain_var
+          :"rel#{_chain_level - 1}"
+        end
+
         private
 
         def build_deeper_query_proxy(method, args)
           self.dup.tap do |new_query|
-          args.each do |arg|
-            new_query.add_links(links_for_arg(method, arg))
+            args.each do |arg|
+              new_query._add_links(links_for_arg(method, arg))
+            end
           end
         end
-      end
 
-      def links_for_arg(method, arg)
-        method_to_call = "links_for_#{method}_arg"
+        def links_for_arg(method, arg)
+          method_to_call = "links_for_#{method}_arg"
 
-        default = [[method, arg]]
+          default = [[method, arg]]
 
-        self.send(method_to_call, arg) || default
-      rescue NoMethodError
-        default
-      end
+          self.send(method_to_call, arg) || default
+        rescue NoMethodError
+          default
+        end
+
+        def links_for_where_arg(arg)
+          node_num = 1
+          result = []
+          if arg.is_a?(Hash)
+            arg.map do |key, value|
+              if @model && @model.has_association?(key)
+
+                neo_id = value.try(:neo_id) || value
+                raise ArgumentError, "Invalid value for '#{key}' condition" if not neo_id.is_a?(Integer)
 
-      def links_for_where_arg(arg)
-        node_num = 1
-        result = []
-        if arg.is_a?(Hash)
-          arg.map do |key, value|
-            if @model.has_one_relationship?(key)
-              neo_id = value.try(:neo_id) || value
-              raise ArgumentError, "Invalid value for '#{key}' condition" if not neo_id.is_a?(Integer)
-
-              n_string = "n#{node_num}"
-              dir = @model.relationship_dir(key)
-
-              arrow = dir == :outgoing ? '-->' : '<--'
-              result << [:match, ->(v) { "#{v}#{arrow}(#{n_string})" }]
-              result << [:where, ->(v) { {"ID(#{n_string})" => neo_id.to_i} }]
-              node_num += 1
-            else
-              result << [:where, ->(v) { {v => {key => value}}}]
+                n_string = "n#{node_num}"
+                dir = @model.associations[key].direction
+
+                arrow = dir == :out ? '-->' : '<--'
+                result << [:match, ->(v) { "#{v}#{arrow}(#{n_string})" }]
+                result << [:where, ->(v) { {"ID(#{n_string})" => neo_id.to_i} }]
+                node_num += 1
+              else
+                result << [:where, ->(v) { {v => {key => value}}}]
+              end
             end
+          elsif arg.is_a?(String)
+            result << [:where, arg]
           end
+          result
         end
-        result
-      end
 
-      def links_for_order_arg(arg)
-        [[:order, ->(v) { {v => arg} }]]
-      end
+        def links_for_order_arg(arg)
+          [[:order, ->(v) { {v => arg} }]]
+        end
 
 
       end