graphql-fragment_cache 1.9.1 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 120cfa12166d6db93a1aa709916694555f102d9c8ebeca53ccaba76182360c27
-  data.tar.gz: ae01a7172430cbe6993ec0c8fabaa7024ab5786000869df42c95bd544f1e73f3
+  metadata.gz: 9c0987cb1e081b19356cfd389164150d7678c2fff2a479986f56e157ac485e79
+  data.tar.gz: 72cc6cf9a79c003be0c83dc60447840128ba1d8395e60171ce26a5eaf8190f2b
 SHA512:
-  metadata.gz: 39ecafa948ec5b2a5c4954520e3d68709dafcaae53a4f12b5748ecedd7576f40e0e73705f7abdcb5e39f66e3e07506493547a3ed19a2e6d3f19246e53a6d5f23
-  data.tar.gz: 9bb830762f4c155d70b068409fa8b1ddd49b34ebab0b4ce156d2e00a05127b1abd229dec4a61b029b6a60557254b6e0c650c7bc34b82bd713512acd6fcae4a63
+  metadata.gz: 78be339e321b1c76066e63960d615d85fc286531ba663eef4af3c62baee8b3d598867047cf1c52ca6085b7fca3cbd86ec0038718548e014aff5c8273740a3c9a
+  data.tar.gz: 005efd512fba6e4f91ba5aec08637ce058217f7c2e580ef4afa8c6323fef035a70c72a5abd74d418892f02b607b6e5fff288adfb9830ee9125985b852153775e

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 1.10.0 (2022-01-30)
+
+- [PR#77](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/77) Drop Ruby 2.5 support, add Ruby 3.0 ([@DmitryTsepelev][])
+
 ## 1.9.1 (2021-11-28)
 
 - [PR#76](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/76) Freeze parser version ([@DmitryTsepelev][])

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.9.1"
+    VERSION = "1.10.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.10.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-28 00:00:00.000000000 Z
+date: 2022-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -190,10 +190,6 @@ files:
 - README.md
 - bin/console
 - bin/setup
-- lib/.rbnext/2.3/graphql/fragment_cache/cache_key_builder.rb
-- lib/.rbnext/2.3/graphql/fragment_cache/memory_store.rb
-- lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb
-- lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
 - lib/graphql/fragment_cache/cache_key_builder.rb
@@ -219,7 +215,7 @@ metadata:
   homepage_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   source_code_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   changelog_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -227,15 +223,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Fragment cache for graphql-ruby
 test_files: []

data/lib/.rbnext/2.3/graphql/fragment_cache/cache_key_builder.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "digest"
-
-using RubyNext
-
-module GraphQL
-  module FragmentCache
-    using Ext
-
-    using(Module.new {
-      refine Array do
-        def traverse_argument(argument)
-          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-        end
-
-        def to_selections_key
-          map { |val|
-            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
-
-            field_name = val.field.name
-            field_alias = val.ast_nodes.map(&:alias).join
-            field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
-
-            unless val.arguments.empty?
-              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-              field_name += "(#{args})"
-            end
-
-            "#{field_name}#{children}"
-          }.join(".")
-        end
-      end
-
-      refine ::GraphQL::Language::Nodes::AbstractNode do
-        def alias?(_)
-          false
-        end
-      end
-
-      refine ::GraphQL::Language::Nodes::Field do
-        def alias?(val)
-          self.alias == val
-        end
-      end
-
-      refine ::GraphQL::Execution::Lookahead do
-        def selection_with_alias(name, **kwargs)
-          return selection(name, **kwargs) if selects?(name, **kwargs)
-          alias_selection(name, **kwargs)
-        end
-
-        def alias_selection(name, selected_type: @selected_type, arguments: nil)
-          return alias_selections[name] if alias_selections.key?(name)
-
-          alias_node = lookup_alias_node(ast_nodes, name)
-          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
-
-          next_field_name = alias_node.name
-
-          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
-          next_field_defn = get_class_based_field(selected_type, next_field_name)
-
-          alias_selections[name] =
-            if next_field_defn
-              next_nodes = []
-              arguments = @query.arguments_for(alias_node, next_field_defn)
-              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
-              @ast_nodes.each do |ast_node|
-                ast_node.selections.each do |selection|
-                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
-                end
-              end
-
-              if next_nodes.any?
-                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
-              else
-                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
-              end
-            else
-              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
-            end
-        end
-
-        def alias_selections
-          return @alias_selections if defined?(@alias_selections)
-          @alias_selections ||= {}
-        end
-
-        def lookup_alias_node(nodes, name)
-          return if nodes.empty?
-
-          nodes.find do |node|
-            if node.is_a?(GraphQL::Language::Nodes::FragmentSpread)
-              node = @query.fragments[node.name]
-              raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})") unless node
-            end
-
-            return node if node.alias?(name)
-            child = lookup_alias_node(node.children, name)
-            return child if child
-          end
-        end
-      end
-    })
-
-    # Builds cache key for fragment
-    class CacheKeyBuilder
-      using RubyNext
-
-      class << self
-        def call(**options)
-          new(**options).build
-        end
-      end
-
-      attr_reader :query, :path, :object, :schema
-
-      def initialize(object: nil, query:, path:, **options)
-        @object = object
-        @query = query
-        @schema = query.schema
-        @path = path
-        @options = options
-      end
-
-      def build
-        [
-          GraphQL::FragmentCache.namespace,
-          implicit_cache_key,
-          object_cache_key
-        ].compact.join("/")
-      end
-
-      private
-
-      def implicit_cache_key
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}")
-      end
-
-      def schema_cache_key
-        @options.fetch(:schema_cache_key) { schema.schema_cache_key }
-      end
-
-      def query_cache_key
-        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
-      end
-
-      def selections_cache_key
-        current_root =
-          path.reduce(query.lookahead) { |lkhd, field_name|
-            # Handle cached fields inside collections:
-            next lkhd if field_name.is_a?(Integer)
-
-            lkhd.selection_with_alias(field_name)
-          }
-
-        current_root.selections.to_selections_key
-      end
-
-      def path_cache_key
-        @options.fetch(:path_cache_key) do
-          lookahead = query.lookahead
-
-          path.map { |field_name|
-            # Handle cached fields inside collections:
-            next field_name if field_name.is_a?(Integer)
-
-            lookahead = lookahead.selection_with_alias(field_name)
-            raise "Failed to look ahead the field: #{field_name}" if lookahead.is_a?(::GraphQL::Execution::Lookahead::NullLookahead)
-
-            next lookahead.field.name if lookahead.arguments.empty?
-
-            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-            "#{lookahead.field.name}(#{args})"
-          }.join("/")
-        end
-      end
-
-      def traverse_argument(argument)
-        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-      end
-
-      def object_cache_key
-        @options[:object_cache_key] || object_key(object)
-      end
-
-      def object_key(obj)
-        ((!obj.nil?) || nil) && obj._graphql_cache_key
-      end
-    end
-  end
-end

data/lib/.rbnext/2.3/graphql/fragment_cache/memory_store.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-using RubyNext
-
-module GraphQL
-  module FragmentCache
-    # Memory adapter for storing cached fragments
-    class MemoryStore
-      using RubyNext
-
-      class Entry < Struct.new(:value, :expires_at, keyword_init: true)
-        def expired?
-          expires_at && expires_at < Time.now
-        end
-      end
-
-      attr_reader :default_expires_in
-
-      def initialize(expires_in: nil, **other)
-        raise ArgumentError, "Unsupported options: #{other.keys.join(",")}" unless other.empty?
-
-        @default_expires_in = expires_in
-        @storage = {}
-      end
-
-      def keys
-        storage.keys
-      end
-
-      def exist?(key)
-        storage.key?(key)
-      end
-
-      def read(key)
-        key = key.to_s
-        ((!storage[key].nil?) || nil) && storage[key].then do |entry|
-  if entry.expired?
-    delete(key)
-    next
-  end
-  entry.value
-end
-      end
-
-      def write(key, value, expires_in: default_expires_in, **options)
-        key = key.to_s
-        @storage[key] = Entry.new(value: value, expires_at: expires_in ? Time.now + expires_in : nil)
-      end
-
-      def delete(key)
-        key = key.to_s
-        storage.delete(key)
-      end
-
-      def clear
-        storage.clear
-      end
-
-      private
-
-      attr_reader :storage
-    end
-  end
-end

data/lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "digest"
-
-using RubyNext
-
-module GraphQL
-  module FragmentCache
-    using Ext
-
-    using(Module.new {
-      refine Array do
-        def traverse_argument(argument)
-          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-        end
-
-        def to_selections_key
-          map { |val|
-            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
-
-            field_name = val.field.name
-            field_alias = val.ast_nodes.map(&:alias).join
-            field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
-
-            unless val.arguments.empty?
-              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-              field_name += "(#{args})"
-            end
-
-            "#{field_name}#{children}"
-          }.join(".")
-        end
-      end
-
-      refine ::GraphQL::Language::Nodes::AbstractNode do
-        def alias?(_)
-          false
-        end
-      end
-
-      refine ::GraphQL::Language::Nodes::Field do
-        def alias?(val)
-          self.alias == val
-        end
-      end
-
-      refine ::GraphQL::Execution::Lookahead do
-        def selection_with_alias(name, **kwargs)
-          return selection(name, **kwargs) if selects?(name, **kwargs)
-          alias_selection(name, **kwargs)
-        end
-
-        def alias_selection(name, selected_type: @selected_type, arguments: nil)
-          return alias_selections[name] if alias_selections.key?(name)
-
-          alias_node = lookup_alias_node(ast_nodes, name)
-          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
-
-          next_field_name = alias_node.name
-
-          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
-          next_field_defn = get_class_based_field(selected_type, next_field_name)
-
-          alias_selections[name] =
-            if next_field_defn
-              next_nodes = []
-              arguments = @query.arguments_for(alias_node, next_field_defn)
-              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
-              @ast_nodes.each do |ast_node|
-                ast_node.selections.each do |selection|
-                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
-                end
-              end
-
-              if next_nodes.any?
-                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
-              else
-                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
-              end
-            else
-              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
-            end
-        end
-
-        def alias_selections
-          return @alias_selections if defined?(@alias_selections)
-          @alias_selections ||= {}
-        end
-
-        def lookup_alias_node(nodes, name)
-          return if nodes.empty?
-
-          nodes.find do |node|
-            if node.is_a?(GraphQL::Language::Nodes::FragmentSpread)
-              node = @query.fragments[node.name]
-              raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})") unless node
-            end
-
-            return node if node.alias?(name)
-            child = lookup_alias_node(node.children, name)
-            return child if child
-          end
-        end
-      end
-    })
-
-    # Builds cache key for fragment
-    class CacheKeyBuilder
-      using RubyNext
-
-      class << self
-        def call(**options)
-          new(**options).build
-        end
-      end
-
-      attr_reader :query, :path, :object, :schema
-
-      def initialize(object: nil, query:, path:, **options)
-        @object = object
-        @query = query
-        @schema = query.schema
-        @path = path
-        @options = options
-      end
-
-      def build
-        [
-          GraphQL::FragmentCache.namespace,
-          implicit_cache_key,
-          object_cache_key
-        ].compact.join("/")
-      end
-
-      private
-
-      def implicit_cache_key
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}")
-      end
-
-      def schema_cache_key
-        @options.fetch(:schema_cache_key) { schema.schema_cache_key }
-      end
-
-      def query_cache_key
-        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
-      end
-
-      def selections_cache_key
-        current_root =
-          path.reduce(query.lookahead) { |lkhd, field_name|
-            # Handle cached fields inside collections:
-            next lkhd if field_name.is_a?(Integer)
-
-            lkhd.selection_with_alias(field_name)
-          }
-
-        current_root.selections.to_selections_key
-      end
-
-      def path_cache_key
-        @options.fetch(:path_cache_key) do
-          lookahead = query.lookahead
-
-          path.map { |field_name|
-            # Handle cached fields inside collections:
-            next field_name if field_name.is_a?(Integer)
-
-            lookahead = lookahead.selection_with_alias(field_name)
-            raise "Failed to look ahead the field: #{field_name}" if lookahead.is_a?(::GraphQL::Execution::Lookahead::NullLookahead)
-
-            next lookahead.field.name if lookahead.arguments.empty?
-
-            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-            "#{lookahead.field.name}(#{args})"
-          }.join("/")
-        end
-      end
-
-      def traverse_argument(argument)
-        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-      end
-
-      def object_cache_key
-        @options[:object_cache_key] || object_key(object)
-      end
-
-      def object_key(obj)
-        obj&._graphql_cache_key
-      end
-    end
-  end
-end

data/lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module FragmentCache
-    module Ext
-      # Adds #_graphql_cache_key method to Object,
-      # which just call #graphql_cache_key or #cache_key.
-      #
-      # For other core classes returns string representation.
-      #
-      # Raises ArgumentError otherwise.
-      #
-      # We use a refinement to avoid case/if statements for type checking
-      refine Object do
-        def _graphql_cache_key
-          return graphql_cache_key if respond_to?(:graphql_cache_key)
-          return cache_key if respond_to?(:cache_key)
-          return to_a._graphql_cache_key if respond_to?(:to_a)
-
-          to_s
-        end
-      end
-
-      refine Array do
-        def _graphql_cache_key
-          map { |_1| _1._graphql_cache_key }.join("/")
-        end
-      end
-
-      refine NilClass do
-        def _graphql_cache_key
-          ""
-        end
-      end
-
-      refine TrueClass do
-        def _graphql_cache_key
-          "t"
-        end
-      end
-
-      refine FalseClass do
-        def _graphql_cache_key
-          "f"
-        end
-      end
-
-      refine String do
-        def _graphql_cache_key
-          self
-        end
-      end
-
-      refine Symbol do
-        def _graphql_cache_key
-          to_s
-        end
-      end
-
-      if RUBY_PLATFORM.match?(/java/i)
-        refine Integer do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-
-        refine Float do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-      else
-        refine Numeric do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-      end
-
-      refine Time do
-        def _graphql_cache_key
-          to_s
-        end
-      end
-
-      refine Module do
-        def _graphql_cache_key
-          name
-        end
-      end
-    end
-  end
-end