activegraph 11.0.0.beta.1-java

data/lib/active_graph/relationship/persistence/query_factory.rb

@@ -0,0 +1,95 @@
+module ActiveGraph::Relationship::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 ActiveGraph::Relationship::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[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 ActiveGraph::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 ActiveGraph::Core::Query and will match or create
+    #   based on the current state of the object passed in.
+    def query_factory(obj, sym, factory = false)
+      ActiveGraph::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 [ActiveGraph::Node] node A node, persisted or unpersisted
+    # @param [Struct] res The result of calling `return` on a ActiveGraph::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.keys.include?(key)
+      unwrapped = res[key]
+      node.init_on_load(unwrapped, unwrapped.properties)
+    end
+
+    def node_symbols
+      self.class::NODE_SYMBOLS
+    end
+  end
+end

data/lib/active_graph/relationship/property.rb

@@ -0,0 +1,92 @@
+require 'active_graph/class_arguments'
+
+module ActiveGraph::Relationship
+  module Property
+    extend ActiveSupport::Concern
+    include ActiveGraph::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}_id") { send(direction).neo_id if direction }
+    end
+
+    # @return [String] a string representing the relationship type that will be created
+    def type
+      self.class.type
+    end
+
+    def initialize(attributes = nil)
+      super(attributes)
+    end
+
+    def creates_unique_option
+      self.class.creates_unique_option
+    end
+
+    module ClassMethods
+      include ActiveGraph::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?
+            ActiveGraph::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)
+        ActiveGraph::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/active_graph/relationship/query.rb

@@ -0,0 +1,99 @@
+module ActiveGraph::Relationship
+  module Query
+    extend ActiveSupport::Concern
+
+    class RecordNotFound < ActiveGraph::RecordNotFound; end
+
+    module ClassMethods
+      # Returns the object with the specified neo4j id.
+      # @param [String,Integer] id of node to find
+      def find(id)
+        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)
+      end
+
+      # Loads the relationship using its neo_id.
+      def find_by_id(key)
+        query = ActiveGraph::Base.new_query
+        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 ActiveGraph::Relationship::Query module has been deprecated and will be removed in a future version of the gem.', caller
+      end
+
+      def where_query
+        deprecation_warning!
+        ActiveGraph::Base.new_query.match("#{cypher_string(:outbound)}-[r1:`#{type}`]->#{cypher_string(:inbound)}")
+      end
+
+      def all_query
+        deprecation_warning!
+        ActiveGraph::Base.new_query.match("#{cypher_string}-[r1:`#{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 "Relationship 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

data/lib/active_graph/relationship/rel_wrapper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+wrapping_proc = proc do |relationship|
+  ActiveGraph::RelWrapping.wrapper(relationship)
+end
+Neo4j::Driver::Types::Relationship.wrapper_callback(wrapping_proc)
+
+module ActiveGraph
+  module RelWrapping
+    class << self
+      def wrapper(rel)
+        rel.properties.symbolize_keys!
+        begin
+          most_concrete_class = class_from_type(rel.type).constantize
+          return rel unless most_concrete_class < ActiveGraph::Relationship
+          most_concrete_class.new
+        rescue NameError => e
+          raise e unless e.message =~ /(uninitialized|wrong) constant/
+
+          return rel
+        end.tap do |wrapped_rel|
+          wrapped_rel.init_on_load(rel, rel.start_node_id, rel.end_node_id, rel.type)
+        end
+      end
+
+      def class_from_type(type)
+        ActiveGraph::Relationship::Types::WRAPPED_CLASSES[type] || ActiveGraph::Relationship::Types::WRAPPED_CLASSES[type] = type.to_s.downcase.camelize
+      end
+    end
+  end
+end

data/lib/active_graph/relationship/related_node.rb

@@ -0,0 +1,87 @@
+module ActiveGraph::Relationship
+  # A container for Relationship's :inbound and :outbound methods. It provides lazy loading of nodes.
+  # It's important (or maybe not really IMPORTANT, but at least worth mentioning) that calling method_missing
+  # will result in a query to load the node if the node is not already loaded.
+  class RelatedNode
+    class UnsetRelatedNodeError < ActiveGraph::Error; end
+
+    # Relationship's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
+    #
+    # Initialization with nothing happens when a new, non-persisted Relationship object is first initialized.
+    #
+    # 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.
+    def initialize(node = nil)
+      @node = valid_node_param?(node) ? node : (fail ActiveGraph::InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
+    end
+
+    # Loads the node if needed, then conducts comparison.
+    def ==(other)
+      loaded if @node.is_a?(Integer)
+      @node == other
+    end
+
+    # Returns the neo_id of a given node without loading.
+    def neo_id
+      loaded? ? @node.neo_id : @node
+    end
+
+    # Loads a node from the database or returns the node if already laoded
+    def loaded
+      fail UnsetRelatedNodeError, 'Node not set, cannot load' if @node.nil?
+      @node = if @node.respond_to?(:neo_id)
+                @node
+              else
+                ActiveGraph::Base.new_query.match(:n).where(n: {neo_id: @node}).pluck(:n).first
+              end
+    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?(Numeric)
+      @node.respond_to?(method_name) ? true : super
+    end
+
+    def class
+      loaded.send(:class)
+    end
+
+    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
+  end
+end

data/lib/active_graph/relationship/types.rb

@@ -0,0 +1,80 @@
+module ActiveGraph
+  module Relationship
+    # provides mapping of type to model name
+    module Types
+      extend ActiveSupport::Concern
+
+      # WRAPPED_CLASSES maps relationship types to Relationship models.
+      #
+      # Typically, it's a 1:1 relationship, with a type having a model of the same name. Sometimes, someone needs to be a precious
+      # snowflake and have a model name that doesn't match the rel type, so this comes in handy.
+      #
+      # As an example, Chris often finds it easier to name models after the classes that use the relationship: `StudentLesson` instead of
+      # `EnrolledIn`, because it's easier to remember "A student has a relationship to lesson" than "the type of relationship between Student
+      # and Lesson is 'EnrolledIn'." After all, that is a big part of why we have models, right? To make our lives easier?
+      #
+      # A model is added to WRAPPED_CLASSES when it is initalized AND when the `type` class method is called within a model. This means that
+      # it's possible a model will be added twice: once with the type version of the model name, again with the custom type. deal_with_it.gif.
+      WRAPPED_CLASSES = {}
+
+      included do
+        type self.namespaced_model_name, true
+      end
+
+      module ClassMethods
+        include ActiveGraph::Shared::RelTypeConverters
+
+        def inherited(subclass)
+          subclass.type subclass.namespaced_model_name, true
+        end
+
+        # When called without arguments, it will return the current setting or supply a default.
+        # When called with arguments, it will change the current setting.
+        # @param [String] given_type sets the relationship type when creating relationships via this class
+        # @param [Boolean] auto Should the given_type be changed in compliance with the gem's rel decorator setting?
+        def type(given_type = nil, auto = false)
+          case
+          when !given_type && type?
+            @type
+          when given_type
+            assign_type!(given_type, auto)
+          else
+            assign_type!(namespaced_model_name, true)
+          end
+        end
+
+        def namespaced_model_name
+          case ActiveGraph::Config[:module_handling]
+          when :demodulize
+            self.name.demodulize
+          when Proc
+            ActiveGraph::Config[:module_handling].call(self.name)
+          else
+            self.name
+          end
+        end
+
+        def _wrapped_classes
+          WRAPPED_CLASSES
+        end
+
+        def add_wrapped_class(type)
+          # WRAPPED_CLASSES[type.to_sym.downcase] = self.name
+          _wrapped_classes[type.to_sym] = self.name
+        end
+
+        def type?
+          !!@type
+        end
+
+        private
+
+        def assign_type!(given_type, auto)
+          @type = (auto ? decorated_rel_type(given_type) : given_type).tap do |type|
+            add_wrapped_class(type)
+          end
+        end
+      end
+    end
+  end
+end