activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_rel/initialize.rb

@@ -0,0 +1,28 @@
+module Neo4j::ActiveRel
+  module Initialize
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Initialize
+
+    # called when loading the rel from the database
+    # @param [Neo4j::Embedded::EmbeddedRelationship, Neo4j::Server::CypherRelationship] persisted_rel properties of this relationship
+    # @param [Neo4j::Relationship] from_node_id The neo_id of the starting node of this rel
+    # @param [Neo4j::Relationship] to_node_id The neo_id of the ending node of this rel
+    # @param [String] type the relationship type
+    def init_on_load(persisted_rel, from_node_id, to_node_id, type)
+      @rel_type = type
+      @_persisted_obj = persisted_rel
+      changed_attributes_clear!
+      @attributes = convert_and_assign_attributes(persisted_rel.props)
+      load_nodes(from_node_id, to_node_id)
+    end
+
+    def init_on_reload(unwrapped_reloaded)
+      @attributes = nil
+      init_on_load(unwrapped_reloaded,
+                   unwrapped_reloaded.start_node_id,
+                   unwrapped_reloaded.end_node_id,
+                   unwrapped_reloaded.rel_type)
+      self
+    end
+  end
+end

data/lib/neo4j/active_rel/persistence.rb

@@ -0,0 +1,134 @@
+module Neo4j::ActiveRel
+  module Persistence
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Cypher::RelIdentifiers
+    include Neo4j::Shared::Persistence
+
+    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 from_node_identifier=(id)
+      @from_node_identifier = id.to_sym
+    end
+
+    def to_node_identifier=(id)
+      @to_node_identifier = id.to_sym
+    end
+
+    def cypher_identifier
+      @cypher_identifier || :rel
+    end
+
+    def save(*)
+      create_or_update
+    end
+
+    def save!(*args)
+      save(*args) or fail(RelInvalidError, inspect) # rubocop:disable Style/AndOr
+    end
+
+    # Increments concurrently a numeric attribute by a centain amount
+    # @param [Symbol, String] name of the attribute to increment
+    # @param [Integer, Float] amount to increment
+    def concurrent_increment!(attribute, by = 1)
+      increment_by_query! query_as(:r), attribute, by, :r
+    end
+
+    def create_model
+      validate_node_classes!
+      validate_has_one_rel
+      rel = _create_rel
+      return self unless rel.respond_to?(:props)
+      init_on_load(rel, from_node, to_node, @rel_type)
+      true
+    end
+
+    def validate_has_one_rel
+      return unless Neo4j::Config[:enforce_has_one]
+      to_node.validate_reverse_has_one_active_rel(self, :in, from_node) if to_node.persisted?
+      from_node.validate_reverse_has_one_active_rel(self, :out, to_node) if from_node.persisted?
+    end
+
+    def query_as(var)
+      # This should query based on the nodes, not the rel neo_id, I think
+      # Also, picky point: Should the var be `n`?
+      self.class.query_as(neo_id, var)
+    end
+
+    module ClassMethods
+      # Creates a new relationship between objects
+      # @param [Hash] props the properties the new relationship should have
+      def create(*args)
+        new(*args).tap(&:save)
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(*args)
+        new(*args).tap(&:save!)
+      end
+
+      def create_method
+        creates_unique? ? :create_unique : :create
+      end
+
+      def load_entity(id)
+        query_as(id).pluck(:r).first
+      end
+
+      def query_as(neo_id, var = :r)
+        Neo4j::ActiveBase.new_query.match("()-[#{var}]->()").where(var => {neo_id: neo_id})
+      end
+    end
+
+    def create_method
+      self.class.create_method
+    end
+
+    private
+
+    def destroy_query
+      query_as(:r).delete(:r)
+    end
+
+    def validate_node_classes!
+      [from_node, to_node].each do |node|
+        type = from_node == node ? :_from_class : :_to_class
+        type_class = self.class.send(type)
+
+        unless valid_type?(type_class, node)
+          fail ModelClassInvalidError, type_validation_error_message(node, type_class)
+        end
+      end
+    end
+
+    def valid_type?(type_object, node)
+      case type_object
+      when false, :any
+        true
+      when Array
+        type_object.any? { |c| valid_type?(c, node) }
+      else
+        node.class.mapped_label_names.include?(type_object.to_s.constantize.mapped_label_name)
+      end
+    end
+
+    def type_validation_error_message(node, type_class)
+      "Node class was #{node.class} (#{node.class.object_id}), expected #{type_class} (#{type_class.object_id})"
+    end
+
+    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.rel_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 relationship 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

@@ -0,0 +1,95 @@
+require 'neo4j/class_arguments'
+
+module Neo4j::ActiveRel
+  module Property
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Property
+
+    %w(to_node from_node).each do |direction|
+      define_method(direction.to_s) { instance_variable_get("@#{direction}") }
+      define_method("#{direction}=") do |argument|
+        fail FrozenRelError, 'Relationship start/end nodes cannot be changed once persisted' if _persisted_obj
+        instance_variable_set("@#{direction}", argument)
+      end
+    end
+
+    alias start_node from_node
+    alias end_node to_node
+
+    %w(start_node end_node).each do |direction|
+      define_method("#{direction}_neo_id") { send(direction).neo_id if direction }
+    end
+    alias from_node_neo_id start_node_neo_id
+    alias to_node_neo_id end_node_neo_id
+
+    # @return [String] a string representing the relationship type that will be created
+    def type
+      self.class.type
+    end
+    alias rel_type type
+
+    def initialize(attributes = nil)
+      super(attributes)
+    end
+
+    def creates_unique_option
+      self.class.creates_unique_option
+    end
+
+    module ClassMethods
+      include Neo4j::Shared::Cypher::CreateMethod
+
+      # 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)
+        return if attributes.blank?
+        {}.tap do |relationship_props|
+          attributes.each_key do |key|
+            relationship_props[key] = attributes.delete(key) if [:from_node, :to_node].include?(key)
+          end
+        end
+      end
+
+      def id_property_name
+        false
+      end
+
+      %w(to_class from_class).each do |direction|
+        define_method(direction.to_s) do |argument = nil|
+          if !argument.nil?
+            Neo4j::ClassArguments.validate_argument!(argument, direction)
+
+            instance_variable_set("@#{direction}", argument)
+          end
+
+          self.instance_variable_get("@#{direction}")
+        end
+
+        define_method("_#{direction}") { instance_variable_get "@#{direction}" }
+      end
+
+      def valid_class_argument?(class_argument)
+        [String, Symbol, FalseClass].include?(class_argument.class) ||
+          (class_argument.is_a?(Array) && class_argument.all? { |c| [String, Symbol].include?(c.class) })
+      end
+
+      alias start_class from_class
+      alias end_class to_class
+
+      def load_entity(id)
+        Neo4j::Node.load(id)
+      end
+    end
+
+    private
+
+    def load_nodes(from_node = nil, to_node = nil)
+      @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/query.rb

@@ -0,0 +1,101 @@
+module Neo4j::ActiveRel
+  module Query
+    extend ActiveSupport::Concern
+
+    class RecordNotFound < Neo4j::RecordNotFound; end
+
+    module ClassMethods
+      # Returns the object with the specified neo4j id.
+      # @param [String,Integer] id of node to find
+      # @param [Neo4j::Session] session optional
+      def find(id, session = self.neo4j_session)
+        fail "Unknown argument #{id.class} in find method (expected String or Integer)" if !(id.is_a?(String) || id.is_a?(Integer))
+        find_by_id(id, session)
+      end
+
+      # Loads the relationship using its neo_id.
+      def find_by_id(key, session = nil)
+        options = session ? {session: session} : {}
+        query ||= Neo4j::ActiveBase.new_query(options)
+        result = query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first
+        fail RecordNotFound.new("Couldn't find #{name} with 'id'=#{key.inspect}", name, key) if result.blank?
+        result.r
+      end
+
+      # Performs a very basic match on the relationship.
+      # This is not executed lazily, it will immediately return matching objects.
+      # To use a string, prefix the property with "r1"
+      # @example Match with a string
+      #   MyRelClass.where('r1.grade > r1')
+      def where(args = {})
+        where_query.where(where_string(args)).pluck(:r1)
+      end
+
+      # Performs a basic match on the relationship, returning all results.
+      # This is not executed lazily, it will immediately return matching objects.
+      def all
+        all_query.pluck(:r1)
+      end
+
+      def first
+        all_query.limit(1).order('ID(r1)').pluck(:r1).first
+      end
+
+      def last
+        all_query.limit(1).order('ID(r1) DESC').pluck(:r1).first
+      end
+
+      private
+
+      def deprecation_warning!
+        ActiveSupport::Deprecation.warn 'The Neo4j::ActiveRel::Query module has been deprecated and will be removed in a future version of the gem.', caller
+      end
+
+      def where_query
+        deprecation_warning!
+        Neo4j::ActiveBase.new_query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
+      end
+
+      def all_query
+        deprecation_warning!
+        Neo4j::ActiveBase.new_query.match("#{cypher_string}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
+      end
+
+      def cypher_string(dir = :outbound)
+        case dir
+        when :outbound
+          identifier = '(n1'
+          identifier + (_from_class == :any ? ')' : cypher_label(:outbound))
+        when :inbound
+          identifier = '(n2'
+          identifier + (_to_class == :any ? ')' : cypher_label(:inbound))
+        end
+      end
+
+      def cypher_label(dir = :outbound)
+        target_class = dir == :outbound ? as_constant(_from_class) : as_constant(_to_class)
+        ":`#{target_class.mapped_label_name}`)"
+      end
+
+      def as_constant(given_class)
+        case given_class
+        when String, Symbol
+          given_class.to_s.constantize
+        when Array
+          fail "ActiveRel query methods are being deprecated and do not support Array (from|to)_class options. Current value: #{given_class}"
+        else
+          given_class
+        end
+      end
+
+      def where_string(args)
+        case args
+        when Hash
+          args.map { |k, v| v.is_a?(Integer) ? "r1.#{k} = #{v}" : "r1.#{k} = '#{v}'" }.join(', ')
+        else
+          args
+        end
+      end
+    end
+  end
+end