activegraph-extensions 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b28feac8e1598634606281d5dd8b70f019ac3038682abc635a5ef1d92c0e8b1e
+  data.tar.gz: 1c021a54e63267817077da6942f9fa4f0c61437e112de2677f54db7f440f653e
+SHA512:
+  metadata.gz: e6094af1c1c28ea6af47650e7b8399703e6c356addc72ac454b5c862c92fea563e284a5b80a96435cb41c9646a5f32f711cb0e314aea7a01c838d9476fe3d64b
+  data.tar.gz: 7e56b8b83defdf3d9b21887dbecad56eb21927ff5c72a742b4f477bc2ad422aa24ebc135ff054a8398e18ebae6fe83642cb31f9cd526adbce3b2ddd38ab2bddc

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+
+## [0.0.3] 2023-02-23
+
+## Fixed
+
+- Fixed issue where there was 500 error when we are eagerloding relations with multiple optional matches and some previous match was having authorization and next one was skipping authorization for those same nodes. This would result in a collection of related nodes where some nodes were null and corresponding next optional match nodes on path had values.
+
+## [0.1.0] 2025-01-13
+
+## Added
+
+- Support for MRI

data/Gemfile

@@ -0,0 +1,24 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'listen', '< 3.1'
+active_model_version = ENV['ACTIVE_MODEL_VERSION']
+gem 'activemodel', "~> #{active_model_version}" if active_model_version&.length&.positive?
+
+#gem 'zeitwerk'
+
+group :test do
+  gem 'coveralls', require: false
+  gem 'overcommit'
+  gem 'codecov', require: false
+  gem 'simplecov', require: false
+  gem 'simplecov-html', require: false
+  gem 'its'
+  gem 'test-unit'
+  gem 'colored'
+  gem 'dotenv'
+  gem 'timecop'
+  gem 'pry'
+  gem 'activegraph'
+end

data/README.md

@@ -0,0 +1 @@
+# Extensions to activegraph gem.

data/activegraph-extensions.gemspec

@@ -0,0 +1,42 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require 'active_graph_extensions/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'activegraph-extensions'
+  s.version  = ActiveGraphExtensions::VERSION
+
+  s.required_ruby_version = '>= 2.5'
+
+  s.authors  = 'Amit Suryavanshi'
+  s.email    = 'amitbsuryavabshi@mail.com'
+  s.homepage = 'https://github.com/neo4jrb/activegraph-extensions/'
+  s.summary = 'Additional features to activegraph'
+  s.license = 'MIT'
+  s.description = <<-DESCRIPTION
+  Additional features to activegraph, like sideload limiting, authorizing sideloads etc.
+DESCRIPTION
+
+  s.require_path = 'lib'
+  s.files = Dir.glob('{bin,lib,config}/**/*') + %w(README.md CHANGELOG.md Gemfile activegraph-extensions.gemspec)
+  s.executables = []
+  s.extra_rdoc_files = %w( README.md )
+  s.rdoc_options = ['--quiet', '--title', 'Neo4j.rb', '--line-numbers', '--main', 'README.rdoc', '--inline-source']
+
+  s.add_dependency('parslet')
+  s.add_dependency('activegraph', '>= 12.0.0.beta.5')
+  
+  s.add_development_dependency('guard')
+  s.add_development_dependency('guard-rspec')
+  s.add_development_dependency('guard-rubocop')
+  s.add_development_dependency('neo4j-rake_tasks', '>= 0.3.0')
+  s.add_development_dependency('os')
+  s.add_development_dependency('pry')
+  s.add_development_dependency('railties', '>= 4.0')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rubocop', '>= 0.56.0')
+  s.add_development_dependency('yard')
+  s.add_development_dependency('dryspec')
+  s.add_development_dependency('rspec', '< 3.10') # Cannot proxy frozen objects
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      # We need earlier proxy to generate cypher in query proxy eagerloading
+      module QueryProxy
+        def branch(&block)
+          proxy = super
+          proxy.instance_variable_set(:@break_proxy, as(identity).instance_eval(&block))
+          proxy
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading/association_eager_load.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        # Used for eager loading associations with scope
+        module AssociationEagerLoad
+          extend ActiveSupport::Concern
+
+          class_methods do
+            def associations_to_eagerload
+              @associations_to_eagerload
+            end
+
+            def association_nodes(key, ids, filter)
+              send(@associations_to_eagerload[key], ids, filter)
+            end
+
+            def eagerload_associations(config)
+              @associations_to_eagerload = config
+            end
+
+            def eagerload_association?(key)
+              @associations_to_eagerload.keys.include?(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading/association_limiting.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        module AssociationLimiting
+          def self.included(base)
+            base.attr_reader(:max_page_size)
+            base.attr_reader(:paginate)
+          end
+
+          private
+
+          def rel_collection_str(path)
+            collection_name = "[#{relationship_name(path)}, #{escape(path_name(path))}] "
+            collection = apply_limit?(path) ? "apoc.agg.slice(#{collection_name}, 0, #{association_limit(path)})" : "collect(#{collection_name})"
+            "#{collection} AS #{escape("#{path_name(path)}_collection")}"
+          end
+
+          def apply_limit?(path)
+            !multipath?(path) && (path.last&.association_limit || paginate)
+          end
+
+          def relationship_name(path)
+            if path.last.rel_length
+              "last(relationships(#{escape("#{path_name(path)}_path")}))"
+            else
+              escape("#{path_name(path)}_rel")
+            end
+          end
+
+          def convert_to_list(collection_name, limit)
+            limit.present? ? "apoc.agg.slice(#{collection_name}, 0, #{limit})" : "collect(#{collection_name})"
+          end
+
+          def association_limit(path)
+            limit = path.last&.association_limit
+            limit.blank? || limit.to_i > max_page_size ? max_page_size : limit
+          end
+
+          def with_association_query_part(base_query, path, previous_with_vars)
+            with_args = [identity, rel_collection_str(path), *previous_with_vars]
+
+            optional_match_with_where(base_query, path, previous_with_vars).with(with_args)
+          end
+
+          def limit_node_in_where_clause(query, path)
+            (path.length - 1).times.inject(query) do |query_with_where, index|
+              query_with_where.where("`#{path_name(path[0..index])}` in [i IN #{node_from_collection(path[0..index])} | i[1]]")
+            end
+          end
+
+          def node_from_collection(path_step)
+            "`#{path_name(path_step)}_collection`"
+          end
+
+          def path_alias(node_alias)
+            var_fix(node_alias, :path)
+          end
+
+          def rel_alias(node_alias)
+            var_fix(node_alias, :rel)
+          end
+
+          def multipath?(path)
+            path.size > 1
+          end
+
+          def association_limit_present?(path)
+            association_limit(path).present?
+          end
+
+          def multipath_with_sideload_limit?(path)
+            multipath?(path) && association_limit_present?(path[0..0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading/eager_loading_order.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        # Used to append auth scopes to query proxy eagerloading
+        module EagerLoadingOrder
+          def optional_order(query, path, previous_with_vars)
+            node_alias = path_name(path)
+            order_clause = order_clause_for_query(node_alias)
+            if path.last.rel_length
+              order_clause.reject! { |el| el.include?('_rel') }
+              query.order("length(`#{node_alias}_path`)", *order_clause)
+                   .with(*with_variables(path, node_alias, previous_with_vars))
+            else
+              query.order(*order_clause).with(*with_variables(path, node_alias, previous_with_vars))
+            end
+          end
+
+          def order_clause_for_query(node_alias)
+            (order = @order_spec&.fetch(node_alias, nil)) ? order.map(&method(:nested_order_clause).curry.call(node_alias)) : []
+          end
+
+          def nested_order_clause(node_alias, order_spec)
+            [node_or_rel_alias(node_alias, order_spec), name(order_spec)].join('.')
+          end
+
+          def order_clause(key, order_spec)
+            property_with_direction = name(order_spec)
+            node_alias = node_aliase_for_collection(key, order_spec) || node_aliase_for_order(property_with_direction)
+            [node_alias, property_with_direction].compact.join('.')
+          end
+
+          def skip_order?
+            @order_spec.blank? || @order_spec.keys.all?(&:blank?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading/enhanced_tree.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        # Tree allowing storage of additional information about the associations
+        class EnhancedTree < ::ActiveGraph::Node::Query::QueryProxyEagerLoading::AssociationTree
+          attr_reader :options, :association_limit
+
+          def initialize(model, name = nil, rel_length = nil, association_limit = nil)
+            @association_limit = association_limit
+            super(model, name, rel_length)
+          end
+
+          def add_spec_and_validate(spec)
+            add_spec(spec)
+            validate_for_zero_length_paths
+          end
+
+          def validate_for_zero_length_paths
+            fail 'Can not eager load more than one zero length path.' if values.count(&:zero_length_path?) > 1
+          end
+
+          def zero_length_path?
+            rel_length&.fetch(:min, nil)&.to_s == '0' || values.any?(&:zero_length_path?)
+          end
+
+          def add_key(key, length = nil, assoc_limit = nil)
+            self[key] ||= self.class.new(model, key, length, assoc_limit)
+          end
+
+          def add_nested(key, value, length = nil, assoc_limit = nil)
+            add_key(key, length, assoc_limit).add_spec(value)
+          end
+
+          def process_string(str)
+            map = StringParsers::RelationParser.new.parse(str)
+            add_nested(map[:rel_name].to_sym, map[:rest_str].to_s.presence, map[:length_part], map[:limit_digit])
+          end
+
+          def process_hash(spec)
+            spec = spec.dup
+            @options = spec.delete(:_options)
+            super(spec)
+          end
+
+          def target_class(model, key)
+            association = model.associations[key.to_sym]
+            fail "Invalid association: #{[*path, key].join('.')}" unless association
+            model.associations[key].target_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading/scope_eager_loading.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        # Used to append auth scopes to query proxy eagerloading
+        module ScopeEagerLoading
+          def authorized_rel(path, var)
+            rel_model = relationship_model(path)
+            return {} if @opts.blank? || !(auth_scope = authorized_scope(rel_model, path))
+            conf = { rels: [], chain: {} }
+            proxy = auth_scope.call(var, "#{var}_rel", @opts.merge(properties: properties_for(rel_model),
+                                                                   rel_length: path.last.rel_length))
+            proxy_rel_parts(proxy.instance_variable_get(:@break_proxy) || proxy, conf)
+            conf
+          end
+
+          def properties_for(rel_model)
+            return [] unless @opts[:properties]
+            @opts[:properties].select { |prop| prop.model.name == rel_model.name }.map(&:name)
+          end
+
+          def relationship_model(path)
+            path[0..-2].inject(model) { |mod, rel| mod.send(rel.name).model }
+          end
+
+          def authorized_scope(rel_model, path)
+            rel_model.scopes["authorized_#{path.last.association.name}".to_sym]
+          end
+
+          def proxy_rel_parts(auth_proxy, conf)
+            return unless auth_proxy&.association
+            rel_length = auth_proxy.instance_variable_get(:@rel_length)
+            conf[:rels] << relationship_part(auth_proxy.association, auth_proxy.identity, rel_length)
+            assign_config_chain(conf, auth_proxy, rel_length)
+            proxy_rel_parts(auth_proxy.query_proxy, conf)
+          end
+
+          def assign_config_chain(conf, auth_proxy, rel_length)
+            return unless (auth_chain = auth_proxy.instance_variable_get(:@chain))
+            conf[:chain][[auth_proxy.identity, rel_length ? "#{auth_proxy.identity}_rel" : nil]] = auth_chain
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/node/query/query_proxy_eager_loading.rb

@@ -0,0 +1,149 @@
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        extend ActiveSupport::Concern
+        include AssociationLimiting
+        include ScopeEagerLoading
+        include EagerLoadingOrder
+
+        def association_tree_class
+          EnhancedTree
+        end
+
+        def with_ordered_associations(spec, order, opts = {})
+          @max_page_size = opts[:max_page_size]
+          @paginate = opts[:paginate]
+          @with_vars = opts[:with_vars]
+          @order_spec = order.with_indifferent_access unless spec.empty?
+          @opts = opts
+          with_associations(spec)
+        end
+
+        def first
+          limit(1).to_a.first
+        end
+
+        class_methods do
+          def rel?(order_spec)
+            order_spec.is_a?(Hash) ? 0 : 1
+          end
+        end
+
+        def with_associations(*spec)
+          new_link.tap do |new_query_proxy|
+            new_query_proxy.with_associations_tree = with_associations_tree.clone
+            new_query_proxy.with_associations_tree.add_spec_and_validate(spec)
+          end
+        end
+
+        private
+
+        def query_from_association_tree
+          previous_with_vars = defalut_previous_with_vars
+          with_associations_tree.paths.inject(query_as(identity).with(base_query_with_vars)) do |query, path|
+            with_association_query_part(query, path, previous_with_vars).tap do
+              previous_with_vars << var_fix(path_name(path), :collection)
+            end
+          end
+        end
+
+        def defalut_previous_with_vars
+          @with_vars&.dup || []
+        end
+
+        def base_query_with_vars
+          [ensure_distinct(identity)] + (@with_vars || [])
+        end
+
+        def optional_match_with_where(query, path, vars)
+          computed_query = super
+          computed_query = limit_node_in_where_clause(computed_query, path) if multipath?(path)
+          skip_order? && !path.last.rel_length ? computed_query : optional_order(computed_query, path, vars)
+        end
+
+        def optional_match(base_query, path)
+          start_path = "#{escape("#{path_name(path)}_path")}=(#{identity})"
+          conf = authorized_rel(path, path_name(path[0..-1]))
+          query = construct_optional_match(start_path, base_query, conf[:rels] ? path[0..-2] : path, conf[:rels])
+          conf[:rels] ? apply_chain(conf[:chain], query) : query
+        end
+
+        def construct_optional_match(start_path, base_query, path, scope_rels)
+          base_query.optional_match(
+            "#{start_path}#{path.each_with_index.map do |element, index|
+              relationship_part(element.association, path_name(path[0..index]), element.rel_length)
+            end.join}#{(scope_rels || []).reverse.join}"
+          )
+        end
+
+        def apply_chain(chain, query)
+          chain.each do |key, links|
+            query = links.inject(query) do |q, link|
+              args = link.args(*key)
+              args.is_a?(Array) ? q.send(link.clause, *args) : q.send(link.clause, args)
+            end
+          end
+          query
+        end
+
+        def with_variables(path, node_alias, previous_with_vars)
+          [identity, path.last.rel_length ? path_alias(node_alias) : rel_alias(node_alias), var_fix(node_alias)] +
+            previous_with_vars
+        end
+
+        def before_pluck(query)
+          return query if skip_order? && !include_with_path_length?
+          base_query = query.order(
+            (@order_spec || []).flat_map { |key, order_specs| order_specs.map(&method(:order_clause).curry.call(key)) }
+          )
+          query_from_chain(@postponed_chain, base_query, identity)
+        end
+
+        def node_aliase_for_collection(key, order_spec)
+          "#{var(key, :collection, &:itself)}[0][#{self.class.rel?(order_spec)}]" if key.present?
+        end
+
+        def node_aliase_for_order(property_with_direction)
+          identity unless @with_vars&.include?(property_with_direction.split(' ').first.to_sym)
+        end
+
+        def name(order_spec)
+          Array(order_spec).flatten.last.to_s
+        end
+
+        def node_or_rel_alias(node_alias, order_spec)
+          var(node_alias, order_spec.is_a?(Hash) ? :rel : nil, &:itself)
+        end
+
+        CLAUSES_TO_POSTPONE = %i[limit order skip].freeze
+
+        def include_with_path_length?(path = @with_associations_tree)
+          path.present? && (path.rel_length.present? || path.any? { |_, val| include_with_path_length?(val) })
+        end
+
+        def chain
+          return super if skip_order? && !include_with_path_length?
+          clauses = !skip_order? ? CLAUSES_TO_POSTPONE : %i[order]
+          @postponed_chain, other_chain = super.partition { |link| clauses.include?(link.clause) }
+          other_chain
+        end
+
+        def perform_query
+          @_cache = ActiveGraph::Node::Query::QueryProxyEagerLoading::IdentityMap.new
+          build_query
+            .map do |record, eager_data|
+            record = cache_and_init(record, with_associations_tree)
+            eager_data.zip(with_associations_tree.paths.map(&:last)).each do |eager_records, element|
+              eager_records.each do |eager_record|
+                next unless eager_record.first&.type&.to_s == element.association.relationship_type.to_s
+                add_to_cache(*eager_record, element)
+              end
+            end
+            record
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/string_parsers/relation_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module StringParsers
+    # Parsing relationships with length
+    class RelationParser < ::Parslet::Parser
+      include SharedRules
+
+      # TODO: It is very bad to build a grammar with none terminals. Please note that none here are necessary to
+      # mimic the previous behavior of `repeat` which is `repeat(0)` which effectively allows empty strings as
+      # identifiers
+      rule(:zero) { str('0') }
+      rule(:length_1) { zero.as(:min) >> range >> number?.maybe.as(:max) }
+      rule(:length_2) { number?.maybe.as(:max) }
+      rule(:length) { asterisk >> (length_1 | length_2) }
+      rule(:limit) { number?.as(:limit_digit) >> asterisk }
+      rule(:key) { limit.maybe >> rel >> length.as(:length_part).maybe }
+      rule(:anything) { match('.').repeat }
+      rule(:root) { key >> dot.maybe >> anything.maybe.as(:rest_str) }
+      rule(:rel_sequence) { infix_expression(key, [dot, 1, :left]) }
+    end
+  end
+end

data/lib/active_graph_extensions/string_parsers/shared_rules.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module StringParsers
+    module SharedRules
+      extend ActiveSupport::Concern
+      VAR_CHAR = 'a-z_'
+      included do
+        rule(:asterisk) { str('*') }
+        rule(:number) { match('[\d]').repeat(1) }
+        rule(:none) { str('') }
+        rule(:number?) { number | none }
+        rule(:range) { str('..') }
+        rule(:dot) { str('.') }
+        rule(:identifier) { match("[#{VAR_CHAR}]") >> match("[#{VAR_CHAR}0-9]").repeat(0) }
+        rule(:identifier?) { identifier | none }
+        rule(:rel) { identifier?.as(:rel_name) }
+      end
+    end
+  end
+end

data/lib/active_graph_extensions/version.rb

@@ -0,0 +1,3 @@
+module ActiveGraphExtensions
+  VERSION = '0.1.0'
+end

data/lib/active_graph_extensions.rb

@@ -0,0 +1,12 @@
+require 'active_graph'
+require 'parslet'
+
+module ActiveGraphExtensions
+end
+
+Zeitwerk::Loader.for_gem.setup
+
+ActiveGraph::Node::Query::QueryProxy.include ActiveGraphExtensions::Node::Query::QueryProxyEagerLoading
+ActiveGraph::Node::Query::QueryProxy.prepend ActiveGraphExtensions::Node::Query::QueryProxy
+
+ActiveGraph::Node.include ActiveGraphExtensions::Node::Query::QueryProxyEagerLoading::AssociationEagerLoad

metadata

@@ -0,0 +1,259 @@
+--- !ruby/object:Gem::Specification
+name: activegraph-extensions
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Amit Suryavanshi
+bindir: bin
+cert_chain: []
+date: 2025-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activegraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.0.0.beta.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.0.0.beta.5
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: neo4j-rake_tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dryspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: "  Additional features to activegraph, like sideload limiting, authorizing
+  sideloads etc.\n"
+email: amitbsuryavabshi@mail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- activegraph-extensions.gemspec
+- lib/active_graph_extensions.rb
+- lib/active_graph_extensions/node/query/query_proxy.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading/association_eager_load.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading/association_limiting.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading/eager_loading_order.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading/enhanced_tree.rb
+- lib/active_graph_extensions/node/query/query_proxy_eager_loading/scope_eager_loading.rb
+- lib/active_graph_extensions/string_parsers/relation_parser.rb
+- lib/active_graph_extensions/string_parsers/shared_rules.rb
+- lib/active_graph_extensions/version.rb
+homepage: https://github.com/neo4jrb/activegraph-extensions/
+licenses:
+- MIT
+metadata: {}
+rdoc_options:
+- "--quiet"
+- "--title"
+- Neo4j.rb
+- "--line-numbers"
+- "--main"
+- README.rdoc
+- "--inline-source"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Additional features to activegraph
+test_files: []