graphql 1.9.9 → 1.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d591b26a453b53597b0fdbd363cf87ff174835672d1922499ec24bf0a219a9a
-  data.tar.gz: aad2c15974f1f58cf03fbf620513b4f2de6e8ae26f615937523089e8a2a4b52d
+  metadata.gz: 239691cd4bf2f9f93314691a4ae3206438e2c51d544b3ef03f6928f62d5930a2
+  data.tar.gz: bb8c26e8da805c1020692ac979a5717a521aa14a353e17c0eaddb30ce1ebc092
 SHA512:
-  metadata.gz: d9058ce614080bcaa58692aef2287c5b67d63f8ed6fb27462976343801dc9e573cbc9a0e7e54dc545698d442ac66b832aa8ddda1f79dd30703aaed66fddf7564
-  data.tar.gz: b42bfa78dd4c0e71a02efbfdc1ee26e8fe00e2db43849728a2775ff1db2e062bd4fb17d95808c692a82b3c73982a368610e163abb3b7dc938913ff622d79fc30
+  metadata.gz: 32e52e6bc896c1b2f62bdefd4ce905ecbead2c81b52e2dac53700fd6a5956ccc594d4ff8eff5c314f496e44b16ab91ad7a3c1ed3c4e784bee489433b19853faa
+  data.tar.gz: 386a90ecd152c2b450d5c2045814241a6660180aef8edca92eea062cdc2285aa2545045390fa53bd92f0a5423ae2622aa18f7815e73fef5d902649f77e44b80b

data/lib/graphql/analysis/ast/query_depth.rb

@@ -3,13 +3,24 @@ module GraphQL
   module Analysis
     # A query reducer for measuring the depth of a given query.
     #
+    # See https://graphql-ruby.org/queries/ast_analysis.html for more examples.
+    #
     # @example Logging the depth of a query
     #   class LogQueryDepth < GraphQL::Analysis::QueryDepth
-    #     def on_analysis_end
+    #     def result
     #       log("GraphQL query depth: #{@max_depth}")
     #     end
     #   end
     #
+    #   # In your Schema file:
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Analysis::AST
+    #     query_analyzer LogQueryDepth
+    #   end
+    #
+    #   # When you run the query, the depth will get logged:
+    #
     #   Schema.execute(query_str)
     #   # GraphQL query depth: 8
     #

data/lib/graphql/language/nodes.rb

@@ -61,6 +61,7 @@ module GraphQL
         def initialize_copy(other)
           @children = nil
           @scalars = nil
+          @query_string = nil
         end
 
         # @return [Symbol] the method to call on {Language::Visitor} for this node
@@ -84,14 +85,7 @@ module GraphQL
         # @param new_options [Hash]
         # @return [AbstractNode] a shallow copy of `self`
         def merge(new_options)
-          copied_self = dup
-          new_options.each do |key, value|
-            copied_self.instance_variable_set(:"@#{key}", value)
-            if copied_self.instance_variable_defined?(:@query_string)
-              copied_self.instance_variable_set(:@query_string, nil)
-            end
-          end
-          copied_self
+          dup.merge!(new_options)
         end
 
         # Copy `self`, but modify the copy so that `previous_child` is replaced by `new_child`
@@ -129,6 +123,15 @@ module GraphQL
           copy_of_self
         end
 
+        protected
+
+        def merge!(new_options)
+          new_options.each do |key, value|
+            instance_variable_set(:"@#{key}", value)
+          end
+          self
+        end
+
         class << self
           # Add a default `#visit_method` and `#children_method_name` using the class name
           def inherited(child_class)

data/lib/graphql/query.rb

@@ -78,7 +78,7 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
@@ -127,8 +127,8 @@ module GraphQL
       @operation_name = operation_name
       @prepared_ast = false
       @validation_pipeline = nil
-      @max_depth = max_depth || schema.max_depth
-      @max_complexity = max_complexity || schema.max_complexity
+      @max_depth = max_depth
+      @max_complexity = max_complexity
 
       @result_values = nil
       @executed = false
@@ -368,7 +368,7 @@ module GraphQL
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,
-        max_complexity: @max_complexity || schema.max_complexity,
+        max_complexity: @max_complexity
       )
     end
 

data/lib/graphql/schema.rb

@@ -705,7 +705,7 @@ module GraphQL
       # Eventually, the methods will be moved into this class, removing the need for the singleton.
       def_delegators :graphql_definition,
         # Schema structure
-        :as_json, :to_json, :to_document, :to_definition,
+        :as_json, :to_json, :to_document, :to_definition, :ast_node,
         # Execution
         :execute, :multiplex,
         :static_validator, :introspection_system,

data/lib/graphql/schema/member/has_fields.rb

@@ -53,8 +53,8 @@ module GraphQL
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
-          if CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method)
-            warn "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`)"
+          if CONFLICT_FIELD_NAMES.include?(field_defn.original_name) && field_defn.original_name == field_defn.resolver_method
+            warn "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.original_name}` and `def resolve_#{field_defn.original_name}`)"
           end
           own_fields[field_defn.name] = field_defn
           nil

data/lib/graphql/schema/validation.rb

@@ -104,10 +104,6 @@ module GraphQL
         ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", ->(type) { type.arguments.values })
 
         DEFAULT_VALUE_IS_VALID_FOR_TYPE = ->(type) {
-          if !type.default_value.nil? && type.type.is_a?(NonNullType)
-            return %Q(Variable #{type.name} of type "#{type.type}" is required and will not use the default value. Perhaps you meant to use type "#{type.type.of_type}".)
-          end
-
           if !type.default_value.nil?
             coerced_value = begin
               type.type.coerce_isolated_result(type.default_value)

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -18,7 +18,7 @@ module GraphQL
       def assert_required_args(ast_node, defn)
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? }
+          .select { |a| a.type.kind.non_null? && !a.default_value? }
           .map(&:name)
 
         missing_names = required_argument_names - present_argument_names

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.9.9"
+  VERSION = "1.9.10"
 end

data/spec/graphql/analysis/ast/max_query_complexity_spec.rb

@@ -45,7 +45,7 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
 
   describe "when max_complexity is decreased at query-level" do
     before do
-      schema.max_complexity = 100
+      schema.max_complexity(100)
     end
 
     let(:max_complexity) { 7 }
@@ -58,7 +58,7 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
 
   describe "when max_complexity is increased at query-level" do
     before do
-      schema.max_complexity = 1
+      schema.max_complexity(1)
     end
 
     let(:max_complexity) { 10 }
@@ -68,6 +68,18 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
     end
   end
 
+  describe "when max_complexity is nil at query-level" do
+    let(:max_complexity) { nil }
+
+    before do
+      schema.max_complexity(1)
+    end
+
+    it "is applied" do
+      assert_nil result
+    end
+  end
+
   describe "across a multiplex" do
     before do
       schema.analysis_engine = GraphQL::Analysis::AST

data/spec/graphql/analysis/ast/max_query_depth_spec.rb

@@ -20,29 +20,27 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
       }
     }
   "}
-  let(:max_depth) { nil }
-  let(:query) {
-    GraphQL::Query.new(
-      schema.graphql_definition,
-      query_string,
-      variables: {},
-      max_depth: max_depth
-    )
-  }
+  let(:query) { GraphQL::Query.new(schema, query_string) }
   let(:result) {
     GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::MaxQueryDepth]).first
   }
 
   describe "when the query is deeper than max depth" do
-    let(:max_depth) { 5 }
-
     it "adds an error message for a too-deep query" do
       assert_equal "Query has depth of 7, which exceeds max depth of 5", result.message
     end
   end
 
   describe "when the query specifies a different max_depth" do
-    let(:max_depth) { 100 }
+    let(:query) { GraphQL::Query.new(schema, query_string, max_depth: 100) }
+
+    it "obeys that max_depth" do
+      assert_nil result
+    end
+  end
+
+  describe "when the query disables max_depth" do
+    let(:query) { GraphQL::Query.new(schema, query_string, max_depth: nil) }
 
     it "obeys that max_depth" do
       assert_nil result
@@ -51,7 +49,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "When the query is not deeper than max_depth" do
     before do
-      schema.max_depth = 100
+      schema.max_depth(100)
     end
 
     it "doesn't add an error" do
@@ -61,7 +59,8 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "when the max depth isn't set" do
     before do
-      schema.max_depth = nil
+      # Yuck - Can't override GraphQL::Schema.max_depth to return nil if it has already been set
+      schema.define_singleton_method(:max_depth) { |*| nil }
     end
 
     it "doesn't add an error message" do
@@ -71,7 +70,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "when a fragment exceeds max depth" do
     before do
-      schema.max_depth = 4
+      schema.max_depth(4)
     end
 
     let(:query_string) { "

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -16,7 +16,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when a query goes over max complexity" do
     before do
-      schema.max_complexity = 9
+      schema.max_complexity(9)
     end
 
     it "returns an error" do
@@ -25,9 +25,6 @@ describe GraphQL::Analysis::MaxQueryComplexity do
   end
 
   describe "when there is no max complexity" do
-    before do
-      schema.max_complexity = nil
-    end
     it "doesn't error" do
       assert_nil result["errors"]
     end
@@ -35,7 +32,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when the query is less than the max complexity" do
     before do
-      schema.max_complexity = 99
+      schema.max_complexity(99)
     end
     it "doesn't error" do
       assert_nil result["errors"]
@@ -44,7 +41,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when max_complexity is decreased at query-level" do
     before do
-      schema.max_complexity = 100
+      schema.max_complexity(100)
     end
     let(:result) {schema.execute(query_string, max_complexity: 7) }
 
@@ -55,7 +52,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when max_complexity is increased at query-level" do
     before do
-      schema.max_complexity = 1
+      schema.max_complexity(1)
     end
     let(:result) {schema.execute(query_string, max_complexity: 10) }
 
@@ -64,9 +61,20 @@ describe GraphQL::Analysis::MaxQueryComplexity do
     end
   end
 
+  describe "when max_complexity is nil query-level" do
+    before do
+      schema.max_complexity(1)
+    end
+    let(:result) {schema.execute(query_string, max_complexity: nil) }
+
+    it "is applied" do
+      assert_nil result["errors"]
+    end
+  end
+
   describe "across a multiplex" do
     before do
-      schema.max_complexity = 9
+      schema.max_complexity(9)
     end
 
     let(:queries) { 5.times.map { |n|  { query: "{ cheese(id: #{n}) { id } }" } } }

data/spec/graphql/analysis/max_query_depth_spec.rb

@@ -36,9 +36,17 @@ describe GraphQL::Analysis::MaxQueryDepth do
     end
   end
 
+  describe "when the query specifies a nil max_depth" do
+    let(:result) { schema.execute(query_string, max_depth: nil) }
+
+    it "obeys that max_depth" do
+      assert_nil result["errors"]
+    end
+  end
+
   describe "When the query is not deeper than max_depth" do
     before do
-      schema.max_depth = 100
+      schema.max_depth(100)
     end
 
     it "doesn't add an error" do
@@ -48,7 +56,8 @@ describe GraphQL::Analysis::MaxQueryDepth do
 
   describe "when the max depth isn't set" do
     before do
-      schema.max_depth = nil
+      # Yuck - Can't override GraphQL::Schema.max_depth to return nil if it has already been set
+      schema.define_singleton_method(:max_depth) { |*| nil }
     end
 
     it "doesn't add an error message" do
@@ -58,7 +67,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
 
   describe "when a fragment exceeds max depth" do
     before do
-      schema.max_depth = 4
+      schema.max_depth(4)
     end
 
     let(:query_string) { "

data/spec/graphql/query_spec.rb

@@ -30,7 +30,6 @@ describe GraphQL::Query do
     }
   |}
   let(:operation_name) { nil }
-  let(:max_depth) { nil }
   let(:query_variables) { {"cheeseId" => 2} }
   let(:schema) { Dummy::Schema }
   let(:document) { GraphQL.parse(query_string) }
@@ -39,8 +38,7 @@ describe GraphQL::Query do
     schema,
     query_string,
     variables: query_variables,
-    operation_name: operation_name,
-    max_depth: max_depth,
+    operation_name: operation_name
   )}
   let(:result) { query.result }
 
@@ -71,8 +69,7 @@ describe GraphQL::Query do
       res = GraphQL::Query.new(
         schema,
         variables: query_variables,
-        operation_name: operation_name,
-        max_depth: max_depth,
+        operation_name: operation_name
       ).result
       assert_equal 1, res["errors"].length
       assert_equal "No query string was present", res["errors"][0]["message"]
@@ -82,8 +79,7 @@ describe GraphQL::Query do
       query = GraphQL::Query.new(
         schema,
         variables: query_variables,
-        operation_name: operation_name,
-        max_depth: max_depth,
+        operation_name: operation_name
       )
       query.query_string = '{ __type(name: """Cheese""") { name } }'
       assert_equal "Cheese", query.result["data"] ["__type"]["name"]
@@ -174,8 +170,7 @@ describe GraphQL::Query do
       schema,
       document: document,
       variables: query_variables,
-      operation_name: operation_name,
-      max_depth: max_depth,
+      operation_name: operation_name
     )}
 
     it "runs the query using the already parsed document" do
@@ -560,7 +555,15 @@ describe GraphQL::Query do
     end
 
     describe "overriding max_depth" do
-      let(:max_depth) { 12 }
+      let(:query) {
+        GraphQL::Query.new(
+          schema,
+          query_string,
+          variables: query_variables,
+          operation_name: operation_name,
+          max_depth: 12
+        )
+      }
 
       it "overrides the schema's max_depth" do
         assert result["data"].key?("cheese")

data/spec/graphql/schema/argument_spec.rb

@@ -10,7 +10,7 @@ describe GraphQL::Schema::Argument do
         argument :arg_with_block, String, required: false do
           description "test"
         end
-
+        argument :required_with_default_arg, Int, required: true, default_value: 1
         argument :aliased_arg, String, required: false, as: :renamed
         argument :prepared_arg, Int, required: false, prepare: :multiply
         argument :prepared_by_proc_arg, Int, required: false, prepare: ->(val, context) { context[:multiply_by] * val }
@@ -30,7 +30,11 @@ describe GraphQL::Schema::Argument do
       end
 
       def field(**args)
-        args.inspect
+        # sort the fields so that they match the output of the new interpreter
+        sorted_keys = args.keys.sort
+        sorted_args = {}
+        sorted_keys.each  {|k| sorted_args[k] = args[k] }
+        sorted_args.inspect
       end
 
       def multiply(val)
@@ -48,7 +52,7 @@ describe GraphQL::Schema::Argument do
 
   describe "#keys" do
     it "is not overwritten by the 'keys' argument" do
-      expected_keys = ["aliasedArg", "arg", "argWithBlock", "explodingPreparedArg", "keys", "preparedArg", "preparedByCallableArg", "preparedByProcArg"]
+      expected_keys = ["aliasedArg", "arg", "argWithBlock", "explodingPreparedArg", "keys", "preparedArg", "preparedByCallableArg", "preparedByProcArg", "requiredWithDefaultArg"]
       assert_equal expected_keys, SchemaArgumentTest::Query.fields["field"].arguments.keys.sort
     end
   end
@@ -103,7 +107,7 @@ describe GraphQL::Schema::Argument do
 
       res = SchemaArgumentTest::Schema.execute(query_str)
       # Make sure it's getting the renamed symbol:
-      assert_equal '{:renamed=>"x"}', res["data"]["field"]
+      assert_equal '{:renamed=>"x", :required_with_default_arg=>1}', res["data"]["field"]
     end
   end
 
@@ -115,7 +119,7 @@ describe GraphQL::Schema::Argument do
 
       res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
       # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_arg=>15}', res["data"]["field"]
+      assert_equal '{:prepared_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
     end
 
     it "calls the method on the provided Proc" do
@@ -125,7 +129,7 @@ describe GraphQL::Schema::Argument do
 
       res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
       # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_by_proc_arg=>15}', res["data"]["field"]
+      assert_equal '{:prepared_by_proc_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
     end
 
     it "calls the method on the provided callable object" do
@@ -135,7 +139,7 @@ describe GraphQL::Schema::Argument do
 
       res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
       # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_by_callable_arg=>15}', res["data"]["field"]
+      assert_equal '{:prepared_by_callable_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
     end
 
     it "handles exceptions raised by prepare" do
@@ -144,9 +148,39 @@ describe GraphQL::Schema::Argument do
       GRAPHQL
 
       res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
-      assert_equal({ 'f1' => '{:arg=>"echo"}', 'f2' => nil }, res['data'])
+      assert_equal({ 'f1' => '{:arg=>"echo", :required_with_default_arg=>1}', 'f2' => nil }, res['data'])
       assert_equal(res['errors'][0]['message'], 'boom!')
       assert_equal(res['errors'][0]['path'], ['f2'])
     end
   end
+
+  describe "default_value:" do
+    it 'uses default_value: with no input' do
+      query_str = <<-GRAPHQL
+      { field() }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str)
+      assert_equal '{:required_with_default_arg=>1}', res["data"]["field"]
+    end
+
+    it 'uses provided input value' do
+      query_str = <<-GRAPHQL
+      { field(requiredWithDefaultArg: 2) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str)
+      assert_equal '{:required_with_default_arg=>2}', res["data"]["field"]
+    end
+
+    it 'respects non-null type' do
+      query_str = <<-GRAPHQL
+      { field(requiredWithDefaultArg: null) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str)
+      assert_equal "Argument 'requiredWithDefaultArg' on Field 'field' has an invalid value. Expected type 'Int!'.", res['errors'][0]['message']
+    end
+
+  end
 end

data/spec/graphql/schema/object_spec.rb

@@ -324,6 +324,16 @@ describe GraphQL::Schema::Object do
       end
     end
 
+    it "warns when override matches field name" do
+      expected_warning = "X's `field :object` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_object` and `def resolve_object`)\n"
+      assert_output "", expected_warning do
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name "X"
+          field :object, String, null: true, resolver_method: :object
+        end
+      end
+    end
+
     it "doesn't warn with an override" do
       assert_output "", "" do
         Class.new(GraphQL::Schema::Object) do
@@ -332,5 +342,14 @@ describe GraphQL::Schema::Object do
         end
       end
     end
+
+    it "doesn't warn when passing object through using resolver_method" do
+      assert_output "", "" do
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name "X"
+          field :thing, String, null: true, resolver_method: :object
+        end
+      end
+    end
   end
 end

data/spec/graphql/schema/printer_spec.rb

@@ -866,4 +866,18 @@ SCHEMA
       assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema, context: context, only: only_filter).print_schema
     end
   end
+
+  it "prints schemas from class" do
+    class TestPrintSchema < GraphQL::Schema
+      class OddlyNamedQuery < GraphQL::Schema::Object
+        field :int, Int, null: false
+      end
+
+      query(OddlyNamedQuery)
+    end
+
+
+    str = GraphQL::Schema::Printer.print_schema TestPrintSchema
+    assert_equal "schema {\n  query: OddlyNamedQuery\n}\n\ntype OddlyNamedQuery {\n  int: Int!\n}", str
+  end
 end

data/spec/graphql/schema/validation_spec.rb

@@ -297,9 +297,9 @@ describe GraphQL::Schema::Validation do
       end
     }
 
-    let(:invalid_default_argument_for_non_null_argument) {
+    let(:default_argument_for_non_null_argument) {
       GraphQL::Argument.define do
-        name "InvalidDefault"
+        name "ValidDefault"
         type !GraphQL::INT_TYPE
         default_value 1
       end
@@ -324,8 +324,8 @@ describe GraphQL::Schema::Validation do
       assert_error_includes untyped_argument, "must be a valid input type (Scalar or InputObject), not Symbol"
     end
 
-    it "does not allow default values for non-null argument" do
-      assert_error_includes invalid_default_argument_for_non_null_argument, 'Variable InvalidDefault of type "Int!" is required and will not use the default value. Perhaps you meant to use type "Int".'
+    it "allows default values for non-null argument" do
+      assert_nil GraphQL::Schema::Validation.validate(default_argument_for_non_null_argument)
     end
 
     it "cannot use reserved name" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.9.9
+  version: 1.9.10
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-30 00:00:00.000000000 Z
+date: 2019-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips