activegraph-extensions 0.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c33fee6eede1db2664a17ae82a9f7dcb0d3611b2665605a024fd184a2695fa9
+  data.tar.gz: ea57d1a76c541d3b5c8c655f1b4cea22142917c83500a2275f4f2fc177f120af
+SHA512:
+  metadata.gz: dc88d9b5d715d803ede073cfd97f60bdbb4b1efe93231416a95ba3963d5831af872bf7e55e53906061693009f9e052e725dea8e80bd8a1a5e44864221659b4ad
+  data.tar.gz: d0b79494bac58f25b9c972951c7bce4d27beb33c5bdcbf865905a81401375b344ab9b9cb101360e93aa1db9bfcc14015ecc1b7a853623e90f9a6a7ca59ff67a0

data/CHANGELOG.md

@@ -0,0 +1 @@
+# Change Log

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,45 @@
+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.platform = 'java'
+
+  s.add_dependency('parslet')
+  s.add_dependency('activegraph')
+  
+  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("neo4j-#{ENV['driver'] == 'java' ? 'java' : 'ruby'}-driver", '~> 4.1.0.beta.1')
+  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,79 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+      module QueryProxyEagerLoading
+        module AssociationLimiting
+          def self.included(base)
+            base.attr_reader(:default_assoc_limit)
+          end
+
+          private
+
+          def rel_collection_str(path)
+            limit = association_limit(path)
+            collection_name = "[#{relationship_name(path)}, #{escape(path_name(path))}] "
+            collection = limit.present? ? "apoc.agg.slice(#{collection_name}, 0, #{limit})" : "collect(#{collection_name})"
+            "#{collection} AS #{escape("#{path_name(path)}_collection")}"
+          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)
+            return if multipath?(path)
+
+            limit = path.last&.association_limit
+            limit.blank? || limit.to_i > default_assoc_limit ? default_assoc_limit : 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)
+            root_path = path[0..0]
+            query.where("`#{path_name(root_path)}` in [i IN #{node_from_collection(root_path)} | i[1]]")
+          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,67 @@
+# 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)
+            # head, rest = str.split('.', 2)
+            # head, association_limit = extract_assoc_limit(head)
+            # k, length = head.split('*', -2)
+            # length = { max: length } if length
+            #add_nested(k.to_sym, rest, length, association_limit)
+            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 extract_assoc_limit(str)
+          #   transformer = StringParsers::RelationParamTransformer.new(str)
+          #   [transformer.rel_name_n_length, transformer.rel_limit_number]
+          # 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,50 @@
+# 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", user: @opts[:user],
+                                                       properties: properties_for(rel_model),
+                                                       privileges: @opts[:privileges],
+                                                       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,148 @@
+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 = {})
+          @default_assoc_limit = opts[:default_assoc_limit]
+          @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_with_sideload_limit?(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/node/query.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+    module Query
+    end
+  end
+end

data/lib/active_graph_extensions/node.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module Node
+  end
+end

data/lib/active_graph_extensions/string_parsers/relation_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module StringParsers
+    # Parsing relationships with length
+    class RelationParser < ::Parslet::Parser
+      rule(:asterix)   { str('*') }
+      rule(:digit)     { match('[\d]').repeat }
+      rule(:range)     { str('..') }
+      rule(:dot)       { str('.') }
+      rule(:zero)      { str('0') }
+      rule(:length_1)  { zero.as(:min) >> range >> digit.maybe.as(:max) }
+      rule(:length_2)  { digit.maybe.as(:max) }
+      rule(:length)    { asterix >> (length_1 | length_2) }
+      rule(:rel)       { match('[a-z,_]').repeat.as(:rel_name) }
+      rule(:limit)     { digit.as(:limit_digit) >> asterix }
+      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.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActiveGraphExtensions
+  module StringParsers
+  end
+end

data/lib/active_graph_extensions/version.rb

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

data/lib/activegraph-extensions.rb

@@ -0,0 +1,15 @@
+require 'active_graph'
+require 'parslet'
+
+module ActiveGraphExtensions
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect 'version' => 'VERSION'
+loader.ignore(File.expand_path('activegraph-extensions.rb', __dir__))
+loader.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,264 @@
+--- !ruby/object:Gem::Specification
+name: activegraph-extensions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: java
+authors:
+- Amit Suryavanshi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: parslet
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: activegraph
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: guard
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: guard-rspec
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: guard-rubocop
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  name: neo4j-rake_tasks
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: os
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  name: railties
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+  name: rubocop
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: yard
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: dryspec
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  name: rspec
+  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/node.rb
+- lib/active_graph_extensions/node/query.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.rb
+- lib/active_graph_extensions/string_parsers/relation_parser.rb
+- lib/active_graph_extensions/version.rb
+- lib/activegraph-extensions.rb
+homepage: https://github.com/neo4jrb/activegraph-extensions/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+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.0.6
+signing_key:
+specification_version: 4
+summary: Additional features to activegraph
+test_files: []