activegraph 11.3.1 → 11.5.0.alpha.1

data/lib/active_graph/node/query/{query_proxy_link.rb → query_proxy/link.rb}

@@ -3,6 +3,7 @@ module ActiveGraph
     module Query
       class QueryProxy
         class Link
+          OUTER_SUBQUERY_PREFIX = 'outer_'.freeze
           attr_reader :clause
 
           def initialize(clause, arg, args = [])
@@ -19,6 +20,26 @@ module ActiveGraph
             end
           end
 
+          def start_of_subquery?
+            clause == :call_subquery_start
+          end
+
+          def end_of_subquery?
+            clause == :call_subquery_end
+          end
+
+          def subquery_var(original_var)
+            return unless start_of_subquery?
+
+            "#{OUTER_SUBQUERY_PREFIX}#{original_var}"
+          end
+
+          def update_outer_query_var(original_var)
+            return original_var unless end_of_subquery?
+
+            original_var.delete_prefix(OUTER_SUBQUERY_PREFIX)
+          end
+
           class << self
             def for_clause(clause, arg, model, *args)
               method_to_call = "for_#{clause}_clause"
@@ -27,6 +48,75 @@ module ActiveGraph
               send(method_to_call, arg, model, *args)
             end
 
+            def for_union_clause(arg, model, *args)
+              links = []
+              links << new(:call_subquery_start, nil, *args)
+              arg[:subquery_parts].each_with_index do |subquery_part, loop_index|
+                links << init_union_link(arg[:proxy], model, subquery_part, loop_index, args)
+              end
+              links << new(:call_subquery_end, nil, *args)
+              links << post_subquery_with_clause(arg[:first_clause], args)
+            end
+
+            def post_subquery_with_clause(first_clause, args)
+              clause_arg_lambda = lambda do |v, _|
+                if first_clause
+                  [v]
+                else
+                  [v, "#{OUTER_SUBQUERY_PREFIX}#{v}"]
+                end
+              end
+
+              new(:with, clause_arg_lambda, *args)
+            end
+
+            def init_union_link(proxy, model, subquery_part, loop_index, args)
+              union_proc = if subquery_proxy_part = subquery_part.call rescue nil # rubocop:disable Style/RescueModifier
+                             independent_union_subquery_proc(subquery_proxy_part, loop_index)
+                           else
+                             continuation_union_subquery_proc(proxy, model, subquery_part, loop_index)
+                           end
+              new(:union, union_proc, *args)
+            end
+
+            def independent_union_subquery_proc(proxy, loop_index)
+              proxy_params = proxy.query.parameters
+              proxy_cypher = proxy.to_cypher
+              subquery_identity = proxy.identity
+              uniq_param_generator = uniq_param_generator_lambda
+
+              lambda do |identity, _|
+                proxy_params = uniq_param_generator.call(proxy_params, proxy_cypher, identity, loop_index) if proxy_params.present?
+                [subquery_identity, proxy_cypher, proxy_params, identity.delete_prefix(OUTER_SUBQUERY_PREFIX)]
+              end
+            end
+
+            def continuation_union_subquery_proc(outer_proxy, model, subquery_part, loop_index) # rubocop:disable Metrics/AbcSize
+              lambda do |identity, _|
+                proxy = outer_proxy.as(identity)
+                proxy_with_clause = proxy.query.with(proxy.identity).with(proxy.identity).proxy_as(model, proxy.identity)
+                complete_query = proxy_with_clause.instance_exec(&subquery_part) || proxy_with_clause
+                subquery_cypher = complete_query.to_cypher
+                subquery_cypher = subquery_cypher.delete_prefix(proxy.to_cypher) if proxy.send(:chain).present? || proxy.starting_query
+                subquery_parameters = (complete_query.query.parameters.to_a - proxy.query.parameters.to_a).to_h
+
+                subquery_parameters = uniq_param_generator_lambda.call(subquery_parameters, subquery_cypher, identity, loop_index) if subquery_parameters.present?
+                [complete_query.identity, subquery_cypher, subquery_parameters] + [identity.delete_prefix(OUTER_SUBQUERY_PREFIX)]
+              end
+            end
+
+            def uniq_param_generator_lambda
+              lambda do |proxy_params, proxy_cypher, identity, counter|
+                prefix = "#{identity}_UNION#{counter}_"
+                proxy_params.each_with_object({}) do |(param_name, param_val), new_params|
+                  new_params_key = "#{prefix}#{param_name}".to_sym
+                  new_params[new_params_key] = param_val
+                  proxy_cypher.gsub!(/\$#{param_name}(?=([^`'"]|'(\\.|[^'])*'|"(\\.|[^"])*"|`(\\.|[^`])*`)*\z)/, "$#{new_params_key}")
+                  new_params
+                end
+              end
+            end
+
             def for_where_clause(arg, model, *args)
               node_num = 1
               result = []
@@ -104,6 +194,8 @@ module ActiveGraph
                 [for_arg(model, clause, args[0], *args[1..-1])]
               elsif [:rel_where, :rel_where_not].include?(clause)
                 args.map { |arg| for_arg(model, clause, arg, association) }
+              elsif clause == :union
+                [for_arg(model, clause, args)]
               else
                 args.map { |arg| for_arg(model, clause, arg) }
               end

data/lib/active_graph/node/query/query_proxy.rb

@@ -94,13 +94,25 @@ module ActiveGraph
         #
         #   student.lessons.query_as(:l).with('your cypher here...')
         def query_as(var, with_labels = true)
-          query_from_chain(chain, base_query(var, with_labels).params(@params), var)
-            .tap { |query| query.proxy_chain_level = _chain_level }
+          init_outer_query_var(var)
+          var_name = @outer_query_var || var
+          query_obj = if chain.first&.start_of_subquery? && !@association && !starting_query
+                        _query
+                      else
+                        base_query(var_name, with_labels).params(@params)
+                      end
+
+          query_from_chain(chain, query_obj, var_name).tap { |query| query.proxy_chain_level = _chain_level }
+        end
+
+        def init_outer_query_var(var)
+          chain.find(&:start_of_subquery?)&.tap { |link| @outer_query_var = link.subquery_var(var) }
         end
 
         def query_from_chain(chain, base_query, var)
           chain.inject(base_query) do |query, link|
             args = link.args(var, rel_var)
+            var = link.update_outer_query_var(var)
 
             args.is_a?(Array) ? query.send(link.clause, *args) : query.send(link.clause, args)
           end
@@ -143,11 +155,16 @@ module ActiveGraph
           @model.current_scope = previous
         end
 
-        METHODS = %w(where where_not rel_where rel_where_not rel_order order skip limit)
+        METHODS = %w(where where_not rel_where rel_where_not rel_order order skip limit union)
 
         METHODS.each do |method|
           define_method(method) { |*args| build_deeper_query_proxy(method.to_sym, args) }
         end
+
+        def union(*args)
+          hash_args = {proxy: self, subquery_parts: args, first_clause: @chain.blank?}
+          build_deeper_query_proxy(:union, hash_args)
+        end
         # Since there are rel_where and rel_order methods, it seems only natural for there to be node_where and node_order
         alias node_where where
         alias node_order order

data/lib/active_graph/node/scope.rb

@@ -1,9 +1,11 @@
-require 'active_support/per_thread_registry'
-
 module ActiveGraph::Node
   module Scope
     extend ActiveSupport::Concern
 
+    included do
+      thread_mattr_accessor :current_scope
+    end
+
     module ClassMethods
       # Similar to ActiveRecord scope
       #
@@ -86,14 +88,6 @@ module ActiveGraph::Node
         end
       end
 
-      def current_scope #:nodoc:
-        ScopeRegistry.value_for(:current_scope, base_class.to_s)
-      end
-
-      def current_scope=(scope) #:nodoc:
-        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
-      end
-
       def all(new_var = nil)
         var = new_var || (current_scope ? current_scope.node_identity : :n)
         if current_scope
@@ -139,38 +133,5 @@ module ActiveGraph::Node
         @query_proxy_or_target ||= @query_proxy || @target
       end
     end
-
-
-    # Stolen from ActiveRecord
-    # https://github.com/rails/rails/blob/08754f12e65a9ec79633a605e986d0f1ffa4b251/activerecord/lib/active_record/scoping.rb#L57
-    class ScopeRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
-
-      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
-
-      def initialize
-        @registry = Hash.new { |hash, key| hash[key] = {} }
-      end
-
-      # Obtains the value for a given +scope_name+ and +variable_name+.
-      def value_for(scope_type, variable_name)
-        raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][variable_name]
-      end
-
-      # Sets the +value+ for a given +scope_type+ and +variable_name+.
-      def set_value_for(scope_type, variable_name, value)
-        raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][variable_name] = value
-      end
-
-      private
-
-      def raise_invalid_scope_type!(scope_type)
-        return if VALID_SCOPE_TYPES.include?(scope_type)
-
-        fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
-      end
-    end
   end
 end

data/lib/active_graph/node/wrapping.rb

@@ -0,0 +1,52 @@
+module ActiveGraph
+  module Node
+    module Wrapping
+      # Only load classes once for performance
+      CONSTANTS_FOR_LABELS_CACHE = {}
+
+      class << self
+        def wrapper(node)
+          found_class = class_to_wrap(node.labels)
+          return node unless found_class
+
+          found_class.new.tap do |wrapped_node|
+            wrapped_node.init_on_load(node, node.properties)
+          end
+        end
+
+        def class_to_wrap(labels)
+          load_classes_from_labels(labels)
+          ActiveGraph::Node::Labels.model_for_labels(labels).tap do |model_class|
+            populate_constants_for_labels_cache(model_class, labels)
+          end
+        end
+
+        private
+
+        def load_classes_from_labels(labels)
+          labels.each { |label| constant_for_label(label) }
+        end
+
+        def constant_for_label(label)
+          CONSTANTS_FOR_LABELS_CACHE[label] ||= constantized_label(label)
+        end
+
+        def constantized_label(label)
+          "#{association_model_namespace}::#{label}".constantize
+        rescue NameError, LoadError
+          nil
+        end
+
+        def populate_constants_for_labels_cache(model_class, labels)
+          labels.each do |label|
+            CONSTANTS_FOR_LABELS_CACHE[label] ||= model_class
+          end
+        end
+
+        def association_model_namespace
+          ActiveGraph::Config.association_model_namespace_string
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/node.rb

@@ -66,6 +66,7 @@ module ActiveGraph
     end
 
     module ClassMethods
+      include ::OrmAdapter::ToAdapter
       def nodeify(object)
         if object.is_a?(::ActiveGraph::Node) || object.nil?
           object

data/lib/active_graph/railtie.rb

@@ -1,9 +1,3 @@
-require 'active_support/notifications'
-require 'rails/railtie'
-# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
-require 'action_dispatch/railtie'
-require 'active_graph'
-
 module ActiveGraph
   class Railtie < ::Rails::Railtie
     def empty_config

data/lib/active_graph/relationship/property.rb

@@ -1,5 +1,3 @@
-require 'active_graph/class_arguments'
-
 module ActiveGraph::Relationship
   module Property
     extend ActiveSupport::Concern

data/lib/active_graph/relationship/wrapping.rb

@@ -0,0 +1,26 @@
+module ActiveGraph
+  module Relationship
+    module Wrapping
+      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
+end

data/lib/active_graph/shared/attributes.rb

@@ -18,9 +18,10 @@ module ActiveGraph::Shared
 
     # Methods deprecated on the Object class which can be safely overridden
     DEPRECATED_OBJECT_METHODS = %w(id type)
+    ATTRIBUTES_METHOD_PATTERNS = Gem::Requirement.create('>= 7.1').satisfied_by?(Gem.loaded_specs["activesupport"].version) ? :attribute_method_patterns : :attribute_method_matchers
 
     included do
-      attribute_method_suffix '' if attribute_method_matchers.none? { |matcher| matcher.prefix == '' && matcher.suffix == '' }
+      attribute_method_suffix '' if send(ATTRIBUTES_METHOD_PATTERNS).none? { |matcher| matcher.prefix == '' && matcher.suffix == '' }
       attribute_method_suffix '='
       attribute_method_suffix '?'
     end
@@ -204,7 +205,7 @@ module ActiveGraph::Shared
 
       # Expand an attribute name into its generated methods names
       def attribute_methods(name)
-        attribute_method_matchers.map { |matcher| matcher.method_name name }
+        send(ATTRIBUTES_METHOD_PATTERNS).map { |matcher| matcher.method_name name }
       end
 
       # Ruby inherited hook to assign superclass attributes to subclasses

data/lib/active_graph/shared/node_query_factory.rb

@@ -0,0 +1,15 @@
+module ActiveGraph::Shared
+  class NodeQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{identifier})"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      labels = graph_object.labels_for_create.map { |l| ":`#{l}`" }.join
+      base_query.create("(#{identifier}#{labels} $#{identifier}_params)").params(identifier_params => graph_object.props_for_create)
+    end
+  end
+end

data/lib/active_graph/shared/persistence.rb

@@ -217,7 +217,7 @@ module ActiveGraph::Shared
       if self.new_record?
         "#{model_cache_key}/new"
       elsif self.respond_to?(:updated_at) && !self.updated_at.blank?
-        "#{model_cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}"
+        "#{model_cache_key}/#{neo_id}-#{self.updated_at.utc.to_fs(:number)}"
       else
         "#{model_cache_key}/#{neo_id}"
       end

data/lib/active_graph/shared/query_factory.rb

@@ -59,64 +59,4 @@ module ActiveGraph::Shared
       @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?
-      labels = graph_object.labels_for_create.map { |l| ":`#{l}`" }.join
-      base_query.create("(#{identifier}#{labels} $#{identifier}_params)").params(identifier_params => 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?
-      create_props, set_props = filtered_props
-      base_query.send(graph_object.create_method, query_string(create_props)).break
-        .set(identifier => set_props)
-        .params(params(create_props))
-    end
-
-    private
-
-    def filtered_props
-      ActiveGraph::Shared::FilteredHash.new(graph_object.props_for_create, graph_object.creates_unique_option).filtered_base
-    end
-
-    def query_string(create_props)
-      "(#{graph_object.from_node_identifier})-[#{identifier}:`#{graph_object.type}` #{pattern(create_props)}]->(#{graph_object.to_node_identifier})"
-    end
-
-    def params(create_props)
-      unique? ? create_props.transform_keys { |key| scoped(key).to_sym } : { namespace.to_sym => create_props }
-    end
-
-    def unique?
-      graph_object.create_method == :create_unique
-    end
-
-    def pattern(create_props)
-      unique? ? "{#{create_props.keys.map { |key| "#{key}: $#{scoped(key)}" }.join(', ')}}" : "$#{namespace}"
-    end
-
-    def scoped(key)
-      "#{namespace}_#{key}"
-    end
-
-    def namespace
-      "#{identifier}_create_props"
-    end
-  end
 end

data/lib/active_graph/shared/rel_query_factory.rb

@@ -0,0 +1,47 @@
+module ActiveGraph::Shared
+  class RelQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{graph_object.from_node_identifier})-[#{identifier}]->()"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      create_props, set_props = filtered_props
+      base_query.send(graph_object.create_method, query_string(create_props)).break
+                .set(identifier => set_props)
+                .params(params(create_props))
+    end
+
+    private
+
+    def filtered_props
+      ActiveGraph::Shared::FilteredHash.new(graph_object.props_for_create, graph_object.creates_unique_option).filtered_base
+    end
+
+    def query_string(create_props)
+      "(#{graph_object.from_node_identifier})-[#{identifier}:`#{graph_object.type}` #{pattern(create_props)}]->(#{graph_object.to_node_identifier})"
+    end
+
+    def params(create_props)
+      unique? ? create_props.transform_keys { |key| scoped(key).to_sym } : { namespace.to_sym => create_props }
+    end
+
+    def unique?
+      graph_object.create_method == :create_unique
+    end
+
+    def pattern(create_props)
+      unique? ? "{#{create_props.keys.map { |key| "#{key}: $#{scoped(key)}" }.join(', ')}}" : "$#{namespace}"
+    end
+
+    def scoped(key)
+      "#{namespace}_#{key}"
+    end
+
+    def namespace
+      "#{identifier}_create_props"
+    end
+  end
+end

data/lib/active_graph/shared/type_converters.rb

@@ -1,9 +1,3 @@
-require 'date'
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'active_support/core_ext/big_decimal/conversions'
-require 'active_support/core_ext/string/conversions'
-
 module ActiveGraph::Shared
   class Boolean; end
 

data/lib/active_graph/tasks/migration.rake

@@ -1,7 +1,3 @@
-require 'rake'
-require 'active_support/concern'
-require 'active_graph/migration'
-
 if !defined?(Rails) && !Rake::Task.task_defined?('environment')
   desc 'Run a script against the database to perform system-wide changes'
   task :environment do

data/lib/active_graph/timestamps.rb

@@ -1,6 +1,3 @@
-require 'active_graph/timestamps/created'
-require 'active_graph/timestamps/updated'
-
 module ActiveGraph
   # This mixin includes timestamps in the included class
   module Timestamps

data/lib/active_graph/version.rb

@@ -1,3 +1,3 @@
 module ActiveGraph
-  VERSION = '11.3.1'
+  VERSION = '11.5.0.alpha.1'
 end