neo4j_legacy 7.2.0.1

data/lib/neo4j/active_rel/persistence.rb

@@ -0,0 +1,114 @@
+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)
+      query_rel = Neo4j::Session.query.match('()-[n]-()').where(n: {neo_id: neo_id})
+      increment_by_query! query_rel, attribute, by
+    end
+
+    def create_model
+      validate_node_classes!
+      rel = _create_rel
+      return self unless rel.respond_to?(:props)
+      init_on_load(rel, from_node, to_node, @rel_type)
+      true
+    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)
+        Neo4j::Relationship.load(id)
+      end
+    end
+
+    def create_method
+      self.class.create_method
+    end
+
+    private
+
+    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/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}") { 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_method :start_node, :from_node
+    alias_method :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_method :from_node_neo_id, :start_node_neo_id
+    alias_method :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_method :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}") 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_method :start_class,  :from_class
+      alias_method :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,95 @@
+module Neo4j::ActiveRel
+  module Query
+    extend ActiveSupport::Concern
+
+    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 = Neo4j::Session.current!)
+        session.query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first.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::Session.query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
+      end
+
+      def all_query
+        deprecation_warning!
+        Neo4j::Session.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

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -0,0 +1,22 @@
+class Neo4j::Relationship
+  module Wrapper
+    def wrapper
+      props.symbolize_keys!
+      begin
+        most_concrete_class = class_from_type
+        wrapped_rel = most_concrete_class.constantize.new
+      rescue NameError
+        return self
+      end
+
+      wrapped_rel.init_on_load(self, self._start_node_id, self._end_node_id, self.rel_type)
+      wrapped_rel
+    end
+
+    private
+
+    def class_from_type
+      Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] || Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] = rel_type.camelize
+    end
+  end
+end

data/lib/neo4j/active_rel/related_node.rb

@@ -0,0 +1,83 @@
+module Neo4j::ActiveRel
+  # A container for ActiveRel'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 < Neo4j::Error; end
+
+    # ActiveRel's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
+    #
+    # Initialization with nothing happens when a new, non-persisted ActiveRel 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 Neo4j::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 = @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?(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/neo4j/active_rel/types.rb

@@ -0,0 +1,82 @@
+module Neo4j
+  module ActiveRel
+    # provides mapping of type to model name
+    module Types
+      extend ActiveSupport::Concern
+
+      # WRAPPED_CLASSES maps relationship types to ActiveRel 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 rel_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 Neo4j::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 && rel_type?
+            @rel_type
+          when given_type
+            assign_type!(given_type, auto)
+          else
+            assign_type!(namespaced_model_name, true)
+          end
+        end
+        alias_method :rel_type, :type
+        alias_method :_type, :type # should be deprecated
+
+        def namespaced_model_name
+          case Neo4j::Config[:module_handling]
+          when :demodulize
+            self.name.demodulize
+          when Proc
+            Neo4j::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 rel_type?
+          !!@rel_type
+        end
+
+        private
+
+        def assign_type!(given_type, auto)
+          @rel_type = (auto ? decorated_rel_type(given_type) : given_type).tap do |type|
+            add_wrapped_class(type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/validations.rb

@@ -0,0 +1,8 @@
+module Neo4j
+  module ActiveRel
+    module Validations
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Validations
+    end
+  end
+end

data/lib/neo4j/active_rel.rb

@@ -0,0 +1,67 @@
+module Neo4j
+  # Makes Neo4j Relationships more or less act like ActiveRecord objects.
+  # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
+  module ActiveRel
+    extend ActiveSupport::Concern
+
+    MARSHAL_INSTANCE_VARIABLES = [:@attributes, :@rel_type, :@_persisted_obj]
+
+    include Neo4j::Shared
+    include Neo4j::ActiveRel::Initialize
+    include Neo4j::Shared::Identity
+    include Neo4j::Shared::Marshal
+    include Neo4j::Shared::SerializedProperties
+    include Neo4j::ActiveRel::Property
+    include Neo4j::ActiveRel::Persistence
+    include Neo4j::ActiveRel::Validations
+    include Neo4j::ActiveRel::Callbacks
+    include Neo4j::ActiveRel::Query
+    include Neo4j::ActiveRel::Types
+    include Neo4j::Shared::Enum
+    include Neo4j::Shared::PermittedAttributes
+
+    class FrozenRelError < Neo4j::Error; end
+
+    def initialize(from_node = nil, to_node = nil, args = nil)
+      load_nodes(node_or_nil(from_node), node_or_nil(to_node))
+      resolved_args = hash_or_nil(from_node, args)
+      symbol_args = sanitize_input_parameters(resolved_args)
+      super(symbol_args)
+    end
+
+    def node_cypher_representation(node)
+      node_class = node.class
+      id_name = node_class.id_property_name
+      labels = ':' + node_class.mapped_label_names.join(':')
+
+      "(#{labels} {#{id_name}: #{node.id.inspect}})"
+    end
+
+    def neo4j_obj
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
+    end
+
+    included do
+      include Neo4j::Timestamps if Neo4j::Config[:record_timestamps]
+
+      def self.inherited(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+        super
+      end
+    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)
+      hash_or_parameter?(node_or_hash) ? node_or_hash : hash_or_nil
+    end
+  end
+end

data/lib/neo4j/class_arguments.rb

@@ -0,0 +1,39 @@
+module Neo4j
+  module ClassArguments
+    class << self
+      INVALID_CLASS_ARGUMENT_ERROR = 'option must by String, Symbol, false, nil, or an Array of Symbols/Strings'
+
+      def valid_argument?(class_argument)
+        [NilClass, String, Symbol, FalseClass].include?(class_argument.class) ||
+          (class_argument.is_a?(Array) && class_argument.all? { |c| [Symbol, String].include?(c.class) })
+      end
+
+      def validate_argument!(class_argument, context)
+        return if valid_argument?(class_argument)
+
+        fail ArgumentError, "#{context} #{INVALID_CLASS_ARGUMENT_ERROR} (was #{class_argument.inspect})"
+      end
+
+      def active_node_model?(class_constant)
+        class_constant.included_modules.include?(Neo4j::ActiveNode)
+      end
+
+      def constantize_argument(class_argument)
+        case class_argument
+        when 'any', :any, false, nil
+          nil
+        when Array
+          class_argument.map(&method(:constantize_argument))
+        else
+          class_argument.to_s.constantize.tap do |class_constant|
+            if !active_node_model?(class_constant)
+              fail ArgumentError, "#{class_constant} is not an ActiveNode model"
+            end
+          end
+        end
+      rescue NameError
+        raise ArgumentError, "Could not find class: #{class_argument}"
+      end
+    end
+  end
+end