neo4j 6.0.0.alpha.9 → 6.0.0.alpha.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e9a0580979b896fd0ff1da7bdb6e42e8dc5a3dd
-  data.tar.gz: 9709fe48514ff2aad702b9e8606ca25f9afb0e64
+  metadata.gz: cbd147ccfe5710b9dd99035774e8ccac71f1a2fe
+  data.tar.gz: 0afb13bbc63f47ce1658313f13541586cdbaca8b
 SHA512:
-  metadata.gz: 96781c2cb44acf832b0eb205ffa25dd7a7fa86ea058d45ef647be8dc02bb5a8d0c2ce242a5d9ff75a4143c86f59a55ae7d4c4bd279c00a752c109eb3cef7057e
-  data.tar.gz: 46ebc2cf7bf7a7b0883eb36c46ed327762bba6e77a3d17a6dbb74e7d80b255225ae2ac64b149f8d662bf35263643364ee2d386cc390611cb56dbe9956c796d01
+  metadata.gz: ba9b1a7bed89c5e0d3be9349a527b496d0cd92a025b0602e68a89b38e4bcae5e45de4a667249abeb23c7fa63be7fcf26f152e48b117108eebcb6f38fe061729c
+  data.tar.gz: ccb77857f67f3bc4ac45087b10d71ef2117b6170ed437aae1593a77f4ff35549a709b76d9046430dd429419efc6cb829cd76e80e1e790b5faad49a454e6d88dd

data/CHANGELOG.md

@@ -3,6 +3,27 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [6.0.0.alpha.11] - 11-3-2015
+
+### Fixed
+- Regression RE: properties being overwritten with their defaults on save in alpha.10.
+
+### Changed
+- `#<<` and `#create` methods on associations now create with the `rel_class` when available so that validations/callbacks/defaults are all used as expected
+- Allow calling of `#method=` methods via model `new` method `Hash` argument
+
+### Added
+- Alternate `ActiveRel` init syntax: `RelClass.new(from_node, to_node, args)`. This is optional, so giving a single hash with props with or without nodes is still possible.
+
+## [6.0.0.alpha.10] - 11-2-2015
+
+### Fixed
+- Long properties in `ActiveNode`/`ActiveRel` `#inspect` are truncated
+- Property defaults are set initially when an instance of a model is loaded, then checked again before save to ensure `valid?` works.
+
+### Added
+- `ActiveRel` `create` actions can now handle unpersisted nodes.
+
 ## [6.0.0.alpha.9] - 10-27-2015
 
 ### Fixed

data/lib/neo4j.rb

@@ -41,11 +41,13 @@ require 'neo4j/shared/identity'
 require 'neo4j/shared/serialized_properties'
 require 'neo4j/shared/typecaster'
 require 'neo4j/shared/initialize'
+require 'neo4j/shared/query_factory'
 require 'neo4j/shared'
 
 require 'neo4j/active_rel/callbacks'
 require 'neo4j/active_rel/initialize'
 require 'neo4j/active_rel/property'
+require 'neo4j/active_rel/persistence/query_factory'
 require 'neo4j/active_rel/persistence'
 require 'neo4j/active_rel/validations'
 require 'neo4j/active_rel/query'

data/lib/neo4j/active_node.rb

@@ -45,15 +45,6 @@ module Neo4j
       _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
     end
 
-    def inspect
-      id_property_name = self.class.id_property_name.to_s
-      attribute_pairs = attributes.except(id_property_name).sort.map { |key, value| "#{key}: #{value.inspect}" }
-      attribute_pairs.unshift("#{id_property_name}: #{self.send(id_property_name).inspect}")
-      attribute_descriptions = attribute_pairs.join(', ')
-      separator = ' ' unless attribute_descriptions.empty?
-      "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
-    end
-
     included do
       include Neo4j::Timestamps if Neo4j::Config[:record_timestamps]
 

data/lib/neo4j/active_node/property.rb

@@ -44,5 +44,18 @@ module Neo4j::ActiveNode
           end
       end
     end
+
+    private
+
+    def inspect_attributes
+      id_property_name = self.class.id_property_name.to_s
+
+      attribute_pairs = attributes.except(id_property_name).sort.map do |key, value|
+        [key, (value.is_a?(String) && value.size > 100) ? value.dup.first(100) : value]
+      end
+
+      attribute_pairs.unshift([id_property_name, self.send(id_property_name)])
+      attribute_pairs
+    end
   end
 end

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

@@ -208,9 +208,21 @@ module Neo4j
         end
 
         def _create_relationship(other_node_or_nodes, properties)
-          _session.query(context: @options[:context])
-            .match(:start, :end).match_nodes(start: @start_object, end: other_node_or_nodes)
-            .send(association.create_method, "start#{_association_arrow(properties, true)}end").exec
+          if association.relationship_class
+            _create_relationship_with_rel_class(other_node_or_nodes, properties)
+          else
+            _session.query(context: @options[:context])
+              .match(:start, :end).match_nodes(start: @start_object, end: other_node_or_nodes)
+              .send(association.create_method, "start#{_association_arrow(properties, true)}end").exec
+          end
+        end
+
+        def _create_relationship_with_rel_class(other_node_or_nodes, properties)
+          Array(other_node_or_nodes).each do |other_node|
+            node_props = (association.direction == :in) ? {from_node: other_node, to_node: @start_object} : {from_node: @start_object, to_node: other_node}
+
+            association.relationship_class.create(properties.except(:_classname).merge(node_props))
+          end
         end
 
         def read_attribute_for_serialization(*args)
@@ -298,21 +310,20 @@ module Neo4j
         end
 
         def _association_chain_var
+          fail 'Crazy error' if !(start_object || @query_proxy)
+
           if start_object
             :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id}"
-          elsif @query_proxy
-            @query_proxy.node_var || :"node#{_chain_level}"
           else
-            fail 'Crazy error' # TODO: Better error
+            @query_proxy.node_var || :"node#{_chain_level}"
           end
         end
 
         def _association_query_start(var)
-          if object = (start_object || @query_proxy)
-            object.query_as(var)
-          else
-            fail 'Crazy error' # TODO: Better error
-          end
+          # TODO: Better error
+          fail 'Crazy error' if !(object = (start_object || @query_proxy))
+
+          object.query_as(var)
         end
 
         def _rel_chain_var
@@ -326,11 +337,8 @@ module Neo4j
         def instance_vars_from_options!(options)
           @node_var, @session, @source_object, @starting_query, @optional,
               @start_object, @query_proxy, @chain_level, @association_labels,
-              @rel_length = options.values_at(:node, :session, :source_object,
-                                              :starting_query, :optional,
-                                              :start_object, :query_proxy,
-                                              :chain_level, :association_labels,
-                                              :rel_length)
+              @rel_length = options.values_at(:node, :session, :source_object, :starting_query, :optional,
+                                              :start_object, :query_proxy, :chain_level, :association_labels, :rel_length)
         end
 
         def build_deeper_query_proxy(method, args)

data/lib/neo4j/active_rel.rb

@@ -17,18 +17,9 @@ module Neo4j
 
     class FrozenRelError < StandardError; end
 
-    def initialize(*args)
-      load_nodes
-      super
-    end
-
-    def inspect
-      attribute_pairs = attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }
-      attribute_descriptions = attribute_pairs.join(', ')
-      separator = ' ' unless attribute_descriptions.empty?
-
-      cypher_representation = "#{node_cypher_representation(from_node)}-[:#{type}]->#{node_cypher_representation(to_node)}"
-      "#<#{self.class.name} #{cypher_representation}#{separator}#{attribute_descriptions}>"
+    def initialize(from_node = nil, to_node = nil, args = nil)
+      load_nodes(node_or_nil(from_node), node_or_nil(to_node))
+      super(hash_or_nil(from_node, args))
     end
 
     def node_cypher_representation(node)
@@ -52,5 +43,15 @@ module Neo4j
     end
 
     ActiveSupport.run_load_hooks(:active_rel, self)
+
+    private
+
+    def node_or_nil(node)
+      node.is_a?(Neo4j::ActiveNode) || node.is_a?(Integer) ? node : nil
+    end
+
+    def hash_or_nil(node_or_hash, hash_or_nil)
+      node_or_hash.is_a?(Hash) ? node_or_hash : hash_or_nil
+    end
   end
 end

data/lib/neo4j/active_rel/persistence.rb

@@ -3,10 +3,24 @@ module Neo4j::ActiveRel
     extend ActiveSupport::Concern
     include Neo4j::Shared::Persistence
 
+    attr_writer :from_node_identifier, :to_node_identifier
+
     class RelInvalidError < RuntimeError; end
     class ModelClassInvalidError < RuntimeError; end
     class RelCreateFailedError < RuntimeError; end
 
+    def from_node_identifier
+      @from_node_identifier || :from_node
+    end
+
+    def to_node_identifier
+      @to_node_identifier || :to_node
+    end
+
+    def cypher_identifier
+      @cypher_identifier || :rel
+    end
+
     def save(*)
       create_or_update
     end
@@ -17,9 +31,9 @@ module Neo4j::ActiveRel
 
     def create_model
       validate_node_classes!
-      rel = _create_rel(from_node, to_node, props_for_create)
-      return self unless rel.respond_to?(:_persisted_obj)
-      init_on_load(rel._persisted_obj, from_node, to_node, @rel_type)
+      rel = _create_rel
+      return self unless rel.respond_to?(:props)
+      init_on_load(rel, from_node, to_node, @rel_type)
       true
     end
 
@@ -53,6 +67,10 @@ module Neo4j::ActiveRel
       end
     end
 
+    def create_method
+      self.class.create_method
+    end
+
     private
 
     def validate_node_classes!
@@ -81,28 +99,10 @@ module Neo4j::ActiveRel
       "Node class was #{node.class} (#{node.class.object_id}), expected #{type_class} (#{type_class.object_id})"
     end
 
-    def _create_rel(from_node, to_node, props = {})
-      if from_node.id.nil? || to_node.id.nil?
-        messages = []
-        messages << 'from_node ID is nil' if from_node.id.nil?
-        messages << 'to_node ID is nil' if to_node.id.nil?
-
-        fail RelCreateFailedError, "Unable to create relationship (#{messages.join(' / ')})"
-      end
-      _rel_creation_query(from_node, to_node, props)
-    end
-
-    N1_N2_STRING = 'n1, n2'
-    ACTIVEREL_NODE_MATCH_STRING = 'ID(n1) = {n1_neo_id} AND ID(n2) = {n2_neo_id}'
-    def _rel_creation_query(from_node, to_node, props)
-      Neo4j::Session.query.match(N1_N2_STRING)
-        .where(ACTIVEREL_NODE_MATCH_STRING).params(n1_neo_id: from_node.neo_id, n2_neo_id: to_node.neo_id).break
-        .send(create_method, "n1-[r:`#{type}`]->n2")
-        .with('r').set(r: props).pluck(:r).first
-    end
-
-    def create_method
-      self.class.create_method
+    def _create_rel
+      factory = QueryFactory.new(from_node, to_node, self)
+      factory.build!
+      factory.unwrapped_rel
     end
   end
 end

data/lib/neo4j/active_rel/persistence/query_factory.rb

@@ -0,0 +1,95 @@
+module Neo4j::ActiveRel::Persistence
+  # This class builds and executes a Cypher query, using information from the graph objects to determine
+  #   whether they need to be created simultaneously.
+  #   It keeps the rel instance from being responsible for inspecting the nodes or talking with Shared::QueryFactory.
+  class QueryFactory
+    NODE_SYMBOLS = [:from_node, :to_node]
+    attr_reader :from_node, :to_node, :rel, :unwrapped_rel
+
+    def initialize(from_node, to_node, rel)
+      @from_node = from_node
+      @to_node = to_node
+      @rel = rel
+    end
+
+    # TODO: This feels like it should also wrap the rel, but that is handled in Neo4j::ActiveRel::Persistence at the moment.
+    # Builds and executes the query using the objects giving during init.
+    # It holds the process:
+    #   * Execute node callbacks if needed
+    #   * Create and execute the query
+    #   * Mix the query response into the unpersisted objects given during init
+    def build!
+      node_before_callbacks! do
+        res = query_factory(rel, rel_id, iterative_query).query.unwrapped.return(*unpersisted_return_ids).first
+        node_symbols.each { |n| wrap!(send(n), res, n) }
+        @unwrapped_rel = res.send(rel_id)
+      end
+    end
+
+    private
+
+    def rel_id
+      @rel_id ||= rel.cypher_identifier
+    end
+
+    # Node callbacks only need to be executed if the node is not persisted. We let the `conditional_callback` method do the work,
+    #   we only have to give it the type of callback we expect to be run and the condition which, if true, will prevent it from executing.
+    def node_before_callbacks!
+      validate_unpersisted_nodes!
+      from_node.conditional_callback(:create, from_node.persisted?) do
+        to_node.conditional_callback(:create, to_node.persisted?) do
+          yield
+        end
+      end
+    end
+
+    def validate_unpersisted_nodes!
+      node_symbols.each do |s|
+        obj = send(s)
+        next if obj.persisted?
+        fail RelCreateFailedError, "Cannot create rel with unpersisted, invalid #{s}" unless obj.valid?
+      end
+    end
+
+    # Each node must be either created or matched before the relationshp can be created. This class does not know or care about
+    #   how that happens, it just knows that it needs a usable Neo4j::Core::Query object to do that.
+    # This method is "iterative" because it creates one factory for each node but the second builds upon the first.
+    def iterative_query
+      node_symbols.inject(false) do |iterative_query, sym|
+        obj = send(sym)
+        query_factory(obj, sym, iterative_query)
+      end
+    end
+
+    # Isolates the dependency to the shared class. This has an awareness of Neo4j::Core::Query and will match or create
+    #   based on the current state of the object passed in.
+    def query_factory(obj, sym, factory = false)
+      Neo4j::Shared::QueryFactory.create(obj, sym).tap do |factory_instance|
+        factory_instance.base_query = factory.blank? ? false : factory.query
+      end
+    end
+
+    # @return [Array<Symbol>] The Cypher identifiers that will be returned from the query.
+    # We only need to return objects from our query that were created during it, otherwise we impact performance.
+    def unpersisted_return_ids
+      [rel_id].tap do |result|
+        node_symbols.each { |k| result << k unless send(k).persisted? }
+      end
+    end
+
+    # @param [Neo4j::ActiveNode] node A node, persisted or unpersisted
+    # @param [Struct] res The result of calling `return` on a Neo4j::Core::Query object. It responds to the same keys
+    #   as our graph objects. If the object is unpersisted and was created during the query, the unwrapped node is mixed
+    #   in, making the object reflect as "persisted".
+    # @param [Symbol] key :from_node or :to_node, the object to request from the response.
+    def wrap!(node, res, key)
+      return if node.persisted? || !res.respond_to?(key)
+      unwrapped = res.send(key)
+      node.init_on_load(unwrapped, unwrapped.props)
+    end
+
+    def node_symbols
+      self.class::NODE_SYMBOLS
+    end
+  end
+end

data/lib/neo4j/active_rel/property.rb

@@ -90,5 +90,9 @@ WARNING
       @from_node = RelatedNode.new(from_node)
       @to_node = RelatedNode.new(to_node)
     end
+
+    def inspect_attributes
+      attributes.to_a
+    end
   end
 end

data/lib/neo4j/active_rel/related_node.rb

@@ -4,6 +4,7 @@ module Neo4j::ActiveRel
   # will result in a query to load the node if the node is not already loaded.
   class RelatedNode
     class InvalidParameterError < StandardError; end
+    class UnsetRelatedNodeError < StandardError; end
 
     # ActiveRel's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
     #
@@ -11,8 +12,6 @@ module Neo4j::ActiveRel
     #
     # Initialization with an integer happens when a relationship is loaded from the database. It loads using the ID
     # because that is provided by the Cypher response and does not require an extra query.
-    #
-    # Initialization with a node doesn't appear to happen in the code. TODO: maybe find out why this is an option.
     def initialize(node = nil)
       @node = valid_node_param?(node) ? node : (fail InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
     end
@@ -30,20 +29,41 @@ module Neo4j::ActiveRel
 
     # Loads a node from the database or returns the node if already laoded
     def loaded
+      fail NilRelatedNodeError, 'Node not set, cannot load' if @node.nil?
       @node = @node.respond_to?(:neo_id) ? @node : Neo4j::Node.load(@node)
     end
 
+    # @param [String, Symbol, Array] clazz An alternate label to use in the event the node is not present or loaded
+    def cypher_representation(clazz)
+      case
+      when !set?
+        "(#{formatted_label_list(clazz)})"
+      when set? && !loaded?
+        "(Node with neo_id #{@node})"
+      else
+        node_class = self.class
+        id_name = node_class.id_property_name
+        labels = ':' + node_class.mapped_label_names.join(':')
+
+        "(#{labels} {#{id_name}: #{@node.id.inspect}})"
+      end
+    end
+
     # @return [Boolean] indicates whether a node has or has not been fully loaded from the database
     def loaded?
       @node.respond_to?(:neo_id)
     end
 
+    def set?
+      !@node.nil?
+    end
+
     def method_missing(*args, &block)
       loaded.send(*args, &block)
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      loaded if @node.is_a?(Integer)
+      loaded if @node.is_a?(Numeric)
       @node.respond_to?(method_name) ? true : super
     end
 
@@ -53,6 +73,10 @@ module Neo4j::ActiveRel
 
     private
 
+    def formatted_label_list(list)
+      list.is_a?(Array) ? list.join(' || ') : list
+    end
+
     def valid_node_param?(node)
       node.nil? || node.is_a?(Integer) || node.respond_to?(:neo_id)
     end

data/lib/neo4j/shared/callbacks.rb

@@ -34,6 +34,14 @@ module Neo4j
         run_callbacks(:touch) { super }
       end
 
+      # Allows you to perform a callback if a condition is not satisfied.
+      # @param [Symbol] kind The callback type to execute unless the guard is true
+      # @param [TrueClass,FalseClass] guard When this value is true, the block is yielded without executing callbacks.
+      def conditional_callback(kind, guard)
+        return yield if guard
+        run_callbacks(kind) { yield }
+      end
+
       private
 
       def create_or_update #:nodoc:

data/lib/neo4j/shared/declared_properties.rb

@@ -155,6 +155,13 @@ module Neo4j::Shared
       convert_property(key, value, :to_ruby)
     end
 
+    def inject_defaults!(object, props)
+      declared_property_defaults.each_pair do |k, v|
+        props[k.to_sym] = v if object.send(k).nil? && props[k.to_sym].nil?
+      end
+      props
+    end
+
     protected
 
     # Prevents repeated calls to :_attribute_type, which isn't free and never changes.

data/lib/neo4j/shared/persistence.rb

@@ -25,9 +25,9 @@ module Neo4j::Shared
     # @return [Hash]
     def props_for_create
       inject_timestamps!
-      converted_props = props_for_db(props)
+      props_with_defaults = inject_defaults!(props)
+      converted_props = props_for_db(props_with_defaults)
       inject_classname!(converted_props)
-      inject_defaults!(converted_props)
       return converted_props unless self.class.respond_to?(:default_property_values)
       inject_primary_key!(converted_props)
     end
@@ -37,8 +37,8 @@ module Neo4j::Shared
       update_magic_properties
       changed_props = attributes.select { |k, _| changed_attributes.include?(k) }
       changed_props.symbolize_keys!
-      props_for_db(changed_props)
       inject_defaults!(changed_props)
+      props_for_db(changed_props)
     end
 
     # Convenience method to set attribute and #save at the same time
@@ -204,12 +204,7 @@ module Neo4j::Shared
       self.updated_at ||= now if respond_to?(:updated_at=)
     end
 
-    def inject_defaults!(properties)
-      self.class.declared_properties.declared_property_defaults.each_pair do |k, v|
-        properties[k.to_sym] = v if send(k).nil?
-      end
-      properties
-    end
+
 
     def set_timestamps
       warning = 'This method has been replaced with `inject_timestamps!` and will be removed in a future version'.freeze

data/lib/neo4j/shared/property.rb

@@ -14,18 +14,32 @@ module Neo4j::Shared
 
     attr_reader :_persisted_obj
 
+    def inspect
+      attribute_descriptions = inspect_attributes.map do |key, value|
+        "#{Neo4j::ANSI::CYAN}#{key}: #{Neo4j::ANSI::CLEAR}#{value.inspect}"
+      end.join(', ')
+
+      separator = ' ' unless attribute_descriptions.empty?
+      "#<#{Neo4j::ANSI::YELLOW}#{self.class.name}#{Neo4j::ANSI::CLEAR}#{separator}#{attribute_descriptions}>"
+    end
+
     # TODO: Remove the commented :super entirely once this code is part of a release.
     # It calls an init method in active_attr that has a very negative impact on performance.
     def initialize(attributes = nil)
       attributes = process_attributes(attributes)
       @relationship_props = self.class.extract_association_attributes!(attributes)
-      writer_method_props = extract_writer_methods!(attributes)
-      validate_attributes!(attributes)
+      modded_attributes = inject_defaults!(attributes)
+      validate_attributes!(modded_attributes)
+      writer_method_props = extract_writer_methods!(modded_attributes)
       send_props(writer_method_props)
-
       @_persisted_obj = nil
     end
 
+    def inject_defaults!(starting_props)
+      return starting_props if self.class.declared_properties.declared_property_defaults.empty?
+      self.class.declared_properties.inject_defaults!(self, starting_props || {})
+    end
+
     # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
     def read_attribute(name)
       super(name)
@@ -36,7 +50,7 @@ module Neo4j::Shared
 
     def send_props(hash)
       return hash if hash.blank?
-      hash.each { |key, value| self.send("#{key}=", value) }
+      hash.each { |key, value| send("#{key}=", value) }
     end
 
     protected
@@ -53,9 +67,11 @@ module Neo4j::Shared
 
     # Changes attributes hash to remove relationship keys
     # Raises an error if there are any keys left which haven't been defined as properties on the model
+    # TODO: use declared_properties instead of self.attributes
     def validate_attributes!(attributes)
       return attributes if attributes.blank?
       invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
+      invalid_properties.reject! { |name| self.respond_to?("#{name}=") }
       fail UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
     end
 

data/lib/neo4j/shared/query_factory.rb

@@ -0,0 +1,91 @@
+module Neo4j::Shared
+  # Acts as a bridge between the node and rel models and Neo4j::Core::Query.
+  # If the object is persisted, it returns a query matching; otherwise, it returns a query creating it.
+  # This class does not execute queries, so it keeps no record of what identifiers have been set or what has happened in previous factories.
+  class QueryFactory
+    attr_reader :graph_object, :identifier
+
+    def initialize(graph_object, identifier)
+      @graph_object = graph_object
+      @identifier = identifier.to_sym
+    end
+
+    def self.create(graph_object, identifier)
+      factory = case graph_object
+                when Neo4j::ActiveNode
+                  NodeQueryFactory
+                when Neo4j::ActiveRel
+                  RelQueryFactory
+                else
+                  fail "Unable to find factory for #{graph_object}"
+                end
+      factory.new(graph_object, identifier)
+    end
+
+    def query
+      graph_object.persisted? ? match_query : create_query
+    end
+
+    # @param [Neo4j::Core::Query] query An instance of Neo4j::Core::Query upon which methods will be chained.
+    def base_query=(query)
+      return if query.blank?
+      @base_query = query
+    end
+
+    def base_query
+      @base_query || Neo4j::Session.current.query
+    end
+
+    protected
+
+    def create_query
+      fail 'Abstract class, not implemented'
+    end
+
+    def match_query
+      base_query
+        .match(match_string).where("ID(#{identifier}) = {#{identifier_id}}")
+        .params(identifier_id.to_sym => graph_object.neo_id)
+    end
+
+    def identifier_id
+      @identifier_id ||= "#{identifier}_id"
+    end
+
+    def identifier_params
+      @identifier_params ||= "#{identifier}_params"
+    end
+  end
+
+  class NodeQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{identifier})"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      base_query.create(identifier => {graph_object.labels_for_create.join(':').to_sym => graph_object.props_for_create})
+    end
+  end
+
+  class RelQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{graph_object.from_node_identifier})-[#{identifier}]->()"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      base_query.send(graph_object.create_method, query_string).params(identifier_params.to_sym => graph_object.props_for_create)
+    end
+
+    private
+
+    def query_string
+      "#{graph_object.from_node_identifier}-[#{identifier}:#{graph_object.type} {#{identifier_params}}]->#{graph_object.to_node_identifier}"
+    end
+  end
+end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '6.0.0.alpha.9'
+  VERSION = '6.0.0.alpha.11'
 end

data/neo4j.gemspec

@@ -30,7 +30,7 @@ A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks h
   s.add_dependency('activemodel', '~> 4')
   s.add_dependency('activesupport', '~> 4')
   s.add_dependency('active_attr', '~> 0.8')
-  s.add_dependency('neo4j-core', '~> 6.0.0.alpha.5')
+  s.add_dependency('neo4j-core', '~> 6.0.0.alpha.6')
   s.add_dependency('neo4j-community', '~> 2.0') if RUBY_PLATFORM =~ /java/
   s.add_development_dependency('railties', '~> 4')
   s.add_development_dependency('pry')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 6.0.0.alpha.9
+  version: 6.0.0.alpha.11
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.alpha.5
+        version: 6.0.0.alpha.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.alpha.5
+        version: 6.0.0.alpha.6
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -260,6 +260,7 @@ files:
 - lib/neo4j/active_rel/callbacks.rb
 - lib/neo4j/active_rel/initialize.rb
 - lib/neo4j/active_rel/persistence.rb
+- lib/neo4j/active_rel/persistence/query_factory.rb
 - lib/neo4j/active_rel/property.rb
 - lib/neo4j/active_rel/query.rb
 - lib/neo4j/active_rel/rel_wrapper.rb
@@ -283,6 +284,7 @@ files:
 - lib/neo4j/shared/persistence.rb
 - lib/neo4j/shared/property.rb
 - lib/neo4j/shared/property/default_property.rb
+- lib/neo4j/shared/query_factory.rb
 - lib/neo4j/shared/rel_type_converters.rb
 - lib/neo4j/shared/serialized_properties.rb
 - lib/neo4j/shared/type_converters.rb