neo4j_legacy 7.2.0.1

data/lib/backports/active_support/concern.rb

@@ -0,0 +1,13 @@
+unless ActiveSupport::Concern.method_defined? :class_methods
+  module ActiveSupport
+    module Concern
+      def class_methods(&class_methods_module_definition)
+        mod = const_defined?(:ClassMethods, false) ?
+          const_get(:ClassMethods) :
+          const_set(:ClassMethods, Module.new)
+
+        mod.module_eval(&class_methods_module_definition)
+      end
+    end
+  end
+end

data/lib/backports/active_support/core_ext/module/attribute_accessors.rb

@@ -0,0 +1,10 @@
+unless Module.method_defined? :cattr_accessor
+  require 'active_support/core_ext/module/attribute_accessors'
+
+  class Module
+    alias :cattr_reader :mattr_reader
+    alias :cattr_writer :mattr_writer
+    alias :cattr_accessor :mattr_accessor
+  end
+end
+

data/lib/backports/active_support/logger.rb

@@ -0,0 +1,99 @@
+unless defined? ActiveSupport::Logger
+  require 'active_support/core_ext/module/attribute_accessors'
+  require 'backports/active_support/core_ext/module/attribute_accessors'
+  require 'backports/active_support/logger_silence'
+  require 'backports/active_support/logger_thread_safe_level'
+  require 'logger'
+
+  module ActiveSupport
+    class Logger < ::Logger
+      include ActiveSupport::LoggerThreadSafeLevel
+      include LoggerSilence
+
+      # Broadcasts logs to multiple loggers.
+      def self.broadcast(logger) # :nodoc:
+        Module.new do
+          define_method(:add) do |*args, &block|
+            logger.add(*args, &block)
+            super(*args, &block)
+          end
+
+          define_method(:<<) do |x|
+            logger << x
+            super(x)
+          end
+
+          define_method(:close) do
+            logger.close
+            super()
+          end
+
+          define_method(:progname=) do |name|
+            logger.progname = name
+            super(name)
+          end
+
+          define_method(:formatter=) do |formatter|
+            logger.formatter = formatter
+            super(formatter)
+          end
+
+          define_method(:level=) do |level|
+            logger.level = level
+            super(level)
+          end
+
+          define_method(:local_level=) do |level|
+            logger.local_level = level if logger.respond_to?(:local_level=)
+            super(level) if respond_to?(:local_level=)
+          end
+
+          define_method(:silence) do |level = Logger::ERROR, &block|
+            if logger.respond_to?(:silence) && logger.method(:silence).owner != ::Kernel
+              logger.silence(level) do
+                if respond_to?(:silence) && method(:silence).owner != ::Kernel
+                  super(level, &block)
+                else
+                  block.call(self)
+                end
+              end
+            else
+              if respond_to?(:silence) && method(:silence).owner != ::Kernel
+                super(level, &block)
+              else
+                block.call(self)
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(*args)
+        super
+        @formatter = SimpleFormatter.new
+        after_initialize if respond_to? :after_initialize
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        return true if @logdev.nil? || (severity || UNKNOWN) < level
+        super
+      end
+
+      Logger::Severity.constants.each do |severity|
+        class_eval(<<-EOT, __FILE__, __LINE__ + 1)
+          def #{severity.downcase}?                # def debug?
+            Logger::#{severity} >= level           #   DEBUG >= level
+          end                                      # end
+        EOT
+      end
+
+      # Simple formatter which only displays the message.
+      class SimpleFormatter < ::Logger::Formatter
+        # This method is invoked when a log event occurs
+        def call(severity, timestamp, progname, msg)
+          "#{String === msg ? msg : msg.inspect}\n"
+        end
+      end
+    end
+  end
+end

data/lib/backports/active_support/logger_silence.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+require 'thread_safe'
+
+module LoggerSilence
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :silencer
+    self.silencer = true
+  end
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_local_level            = local_level
+        self.local_level           = temporary_level
+
+        yield self
+      ensure
+        self.local_level = old_local_level
+      end
+    else
+      yield self
+    end
+  end
+end

data/lib/backports/active_support/logger_thread_safe_level.rb

@@ -0,0 +1,32 @@
+require 'active_support/concern'
+require 'thread_safe'
+
+module ActiveSupport
+  module LoggerThreadSafeLevel
+    extend ActiveSupport::Concern
+
+    def after_initialize
+      @local_levels = ThreadSafe::Cache.new
+    end
+
+    def local_log_id
+      Thread.current.__id__
+    end
+
+    def local_level
+      @local_levels[local_log_id]
+    end
+
+    def local_level=(level)
+      if level
+        @local_levels[local_log_id] = level
+      else
+        @local_levels.delete(local_log_id)
+      end
+    end
+
+    def level
+      local_level || super
+    end
+  end
+end

data/lib/backports/active_support/per_thread_registry.rb

@@ -0,0 +1,60 @@
+unless defined? ActiveSupport::PerThreadRegistry
+  require "active_support/core_ext/module/delegation"
+
+  module ActiveSupport
+    # NOTE: This approach has been deprecated for end-user code in favor of {thread_mattr_accessor}[rdoc-ref:Module#thread_mattr_accessor] and friends.
+    # Please use that approach instead.
+    #
+    # This module is used to encapsulate access to thread local variables.
+    #
+    # Instead of polluting the thread locals namespace:
+    #
+    #   Thread.current[:connection_handler]
+    #
+    # you define a class that extends this module:
+    #
+    #   module ActiveRecord
+    #     class RuntimeRegistry
+    #       extend ActiveSupport::PerThreadRegistry
+    #
+    #       attr_accessor :connection_handler
+    #     end
+    #   end
+    #
+    # and invoke the declared instance accessors as class methods. So
+    #
+    #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
+    #
+    # sets a connection handler local to the current thread, and
+    #
+    #   ActiveRecord::RuntimeRegistry.connection_handler
+    #
+    # returns a connection handler local to the current thread.
+    #
+    # This feature is accomplished by instantiating the class and storing the
+    # instance as a thread local keyed by the class name. In the example above
+    # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
+    # The class methods proxy to said thread local instance.
+    #
+    # If the class has an initializer, it must accept no arguments.
+    module PerThreadRegistry
+      def self.extended(object)
+        object.instance_variable_set "@per_thread_registry_key", object.name.freeze
+      end
+
+      def instance
+        Thread.current[@per_thread_registry_key] ||= new
+      end
+
+      protected
+        def method_missing(name, *args, &block) # :nodoc:
+          # Caches the method definition as a singleton method of the receiver.
+          #
+          # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+          singleton_class.delegate name, to: :instance
+
+          send(name, *args, &block)
+        end
+    end
+  end
+end

data/lib/backports.rb

@@ -0,0 +1,4 @@
+require 'backports/active_support/concern'
+require 'backports/active_support/core_ext/module/attribute_accessors'
+require 'backports/active_support/logger'
+require 'backports/active_model/forbidden_attributes_protection'

data/lib/neo4j/active_node/callbacks.rb

@@ -0,0 +1,8 @@
+module Neo4j
+  module ActiveNode
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Callbacks
+    end
+  end
+end

data/lib/neo4j/active_node/dependent/association_methods.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      module AssociationMethods
+        def validate_dependent(value)
+          fail ArgumentError, "Invalid dependent value: #{value.inspect}" if not valid_dependent_value?(value)
+        end
+
+        def add_destroy_callbacks(model)
+          return if dependent.nil?
+
+          model.before_destroy(&method("dependent_#{dependent}_callback"))
+        rescue NameError
+          raise "Unknown dependent option #{dependent}"
+        end
+
+        private
+
+        def valid_dependent_value?(value)
+          return true if value.nil?
+
+          self.respond_to?("dependent_#{value}_callback", true)
+        end
+
+        # Callback methods
+        def dependent_delete_callback(object)
+          object.association_query_proxy(name).delete_all
+        end
+
+        def dependent_delete_orphans_callback(object)
+          object.as(:self).unique_nodes(self, :self, :n, :other_rel).query.delete(:n, :other_rel).exec
+        end
+
+        def dependent_destroy_callback(object)
+          unique_query = object.association_query_proxy(name)
+          unique_query.each_for_destruction(object, &:destroy) if unique_query
+        end
+
+        def dependent_destroy_orphans_callback(object)
+          unique_query = object.as(:self).unique_nodes(self, :self, :n, :other_rel)
+          unique_query.each_for_destruction(object, &:destroy) if unique_query
+        end
+
+        # End callback methods
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/dependent/query_proxy_methods.rb

@@ -0,0 +1,50 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      # methods used to resolve association dependencies
+      module QueryProxyMethods
+        # Used as part of `dependent: :destroy` and may not have any utility otherwise.
+        # It keeps track of the node responsible for a cascading `destroy` process.
+        # @param owning_node [#dependent_children] source_object The node that called this method. Typically, we would use QueryProxy's `source_object` method
+        # but this is not always available, so we require it explicitly.
+        def each_for_destruction(owning_node)
+          target = owning_node.called_by || owning_node
+          objects = pluck(identity).compact.reject do |obj|
+            target.dependent_children.include?(obj)
+          end
+
+          objects.each do |obj|
+            obj.called_by = target
+            target.dependent_children << obj
+            yield obj
+          end
+        end
+
+        # This will match nodes who only have a single relationship of a given type.
+        # It's used  by `dependent: :delete_orphans` and `dependent: :destroy_orphans` and may not have much utility otherwise.
+        # @param [Neo4j::ActiveNode::HasN::Association] association The Association object used throughout the match.
+        # @param [String, Symbol] other_node The identifier to use for the other end of the chain.
+        # @param [String, Symbol] other_rel The identifier to use for the relationship in the optional match.
+        # @return [Neo4j::ActiveNode::Query::QueryProxy]
+        def unique_nodes(association, self_identifer, other_node, other_rel)
+          fail 'Only supported by in QueryProxy chains started by an instance' unless source_object
+          return false if send(association.name).empty?
+          unique_nodes_query(association, self_identifer, other_node, other_rel)
+            .proxy_as(association.target_class, other_node)
+        end
+
+        private
+
+        def unique_nodes_query(association, self_identifer, other_node, other_rel)
+          query.with(identity).proxy_as_optional(source_object.class, self_identifer)
+            .send(association.name, other_node, other_rel)
+            .query
+            .with(other_node)
+            .match("()#{association.arrow_cypher(:orphan_rel)}(#{other_node})")
+            .with(other_node, count: 'count(*)')
+            .where('count = {one}', one: 1)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/dependent.rb

@@ -0,0 +1,11 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      def dependent_children
+        @dependent_children ||= []
+      end
+
+      attr_writer :called_by
+    end
+  end
+end

data/lib/neo4j/active_node/enum.rb

@@ -0,0 +1,29 @@
+module Neo4j::ActiveNode
+  module Enum
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Enum
+
+    module ClassMethods
+      protected
+
+      def build_property_options(enum_keys, options = {})
+        if options[:_index]
+          super.merge!(index: :exact)
+        else
+          super
+        end
+      end
+
+      def define_enum_methods(property_name, enum_keys, options)
+        super
+        define_enum_scopes(property_name, enum_keys)
+      end
+
+      def define_enum_scopes(property_name, enum_keys)
+        enum_keys.keys.each do |name|
+          scope name, -> { where(property_name => name) }
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/has_n/association/rel_factory.rb

@@ -0,0 +1,61 @@
+module Neo4j::ActiveNode::HasN
+  class Association
+    class RelFactory
+      [:start_object, :other_node_or_nodes, :properties, :association].tap do |accessors|
+        attr_reader(*accessors)
+        private(*accessors)
+      end
+
+      def self.create(start_object, other_node_or_nodes, properties, association)
+        factory = new(start_object, other_node_or_nodes, properties, association)
+        factory._create_relationship
+      end
+
+      def _create_relationship
+        creator = association.relationship_class ? :rel_class : :factory
+        send(:"_create_relationship_with_#{creator}")
+      end
+
+      private
+
+      def initialize(start_object, other_node_or_nodes, properties, association)
+        @start_object = start_object
+        @other_node_or_nodes = other_node_or_nodes
+        @properties = properties
+        @association = association
+      end
+
+      def _create_relationship_with_rel_class
+        Array(other_node_or_nodes).each do |other_node|
+          node_props = _nodes_for_create(other_node, :from_node, :to_node)
+          association.relationship_class.create!(properties.merge(node_props))
+        end
+      end
+
+      def _create_relationship_with_factory
+        Array(other_node_or_nodes).each do |other_node|
+          wrapper = _rel_wrapper(properties)
+          base = _match_query(other_node, wrapper)
+          factory = Neo4j::Shared::RelQueryFactory.new(wrapper, wrapper.rel_identifier)
+          factory.base_query = base
+          factory.query.exec
+        end
+      end
+
+      def _match_query(other_node, wrapper)
+        nodes = _nodes_for_create(other_node, wrapper.from_node_identifier, wrapper.to_node_identifier)
+        Neo4j::Session.current.query.match_nodes(nodes)
+      end
+
+      def _nodes_for_create(other_node, from_node_id, to_node_id)
+        nodes = [@start_object, other_node]
+        nodes.reverse! if association.direction == :in
+        {from_node_id => nodes[0], to_node_id => nodes[1]}
+      end
+
+      def _rel_wrapper(properties)
+        Neo4j::ActiveNode::HasN::Association::RelWrapper.new(association, properties)
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/has_n/association/rel_wrapper.rb

@@ -0,0 +1,23 @@
+class Neo4j::ActiveNode::HasN::Association
+  # Provides the interface needed to interact with the ActiveRel query factory.
+  class RelWrapper
+    include Neo4j::Shared::Cypher::RelIdentifiers
+    include Neo4j::Shared::Cypher::CreateMethod
+
+    attr_reader :type, :association
+    attr_accessor :properties
+    private :association
+    alias_method :props_for_create, :properties
+
+    def initialize(association, properties = {})
+      @association = association
+      @properties = properties
+      @type = association.relationship_type(true)
+      creates_unique(association.creates_unique_option) if association.unique?
+    end
+
+    def persisted?
+      false
+    end
+  end
+end