Merge branch 'master' into postgresql

Gemfile

@@ -5,5 +5,6 @@ gemspec
 gem 'ruby-prof', :platform => :ruby
 gem 'sqlite3', :platform => :ruby
 gem 'pg', :platform => :ruby
-
+gem 'pry'
+gem 'pry-stack_explorer', :platform => :ruby
 gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby

guides/css/main.scss

@@ -15,7 +15,7 @@ $muted-color: #777777;
 $subtle-color: #aaaaaa;
 $font: 'Rubik', sans-serif;
 $font-color: black;
-$code-font: 'Source Sans Pro', monospace;
+$code-font: 'Monaco', monospace;
 
 body {
   font-family: $font;
@@ -92,10 +92,14 @@ pre {
   overflow-x: scroll;
 }
 
-p, li, pre {
+p, li {
   line-height: 1.3rem;
 }
 
+pre {
+  line-height: 1.4rem;
+}
+
 p, ul {
   margin-bottom: 10px;
 }

lib/graphql/execution/multiplex.rb

@@ -35,17 +35,18 @@ def initialize(schema:, queries:, context:)
       end
 
       class << self
-        def run_all(schema, query_options, *rest)
+        def run_all(schema, query_options, *args)
           queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
-          run_queries(schema, queries, *rest)
+          run_queries(schema, queries, *args)
         end
 
         # @param schema [GraphQL::Schema]
         # @param queries [Array<GraphQL::Query>]
         # @param context [Hash]
-        # @param max_complexity [Integer]
+        # @param max_complexity [Integer, nil]
         # @return [Array<Hash>] One result per query
-        def run_queries(schema, queries, context: {}, max_complexity: nil)
+        def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
+
           if has_custom_strategy?(schema)
             if queries.length != 1
               raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
@@ -161,7 +162,7 @@ def with_instrumentation(schema, queries, context:, max_complexity:)
           end
 
           multiplex_analyzers = schema.multiplex_analyzers
-          if max_complexity ||= schema.max_complexity
+          if max_complexity
             multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
           end
 

lib/graphql/schema.rb

@@ -226,7 +226,8 @@ def execute(query_str = nil, **kwargs)
       if query_str
         kwargs[:query] = query_str
       end
-      all_results = multiplex([kwargs])
+      # Since we're running one query, don't run a multiplex-level complexity analyzer
+      all_results = multiplex([kwargs], max_complexity: nil)
       all_results[0]
     end
 
@@ -248,9 +249,9 @@ def execute(query_str = nil, **kwargs)
     # @param queries [Array<Hash>] Keyword arguments for each query
     # @param context [Hash] Multiplex-level context
     # @return [Array<Hash>] One result for each query in the input
-    def multiplex(*args)
+    def multiplex(queries, **kwargs)
       with_definition_error_check {
-        GraphQL::Execution::Multiplex.run_all(self, *args)
+        GraphQL::Execution::Multiplex.run_all(self, queries, **kwargs)
       }
     end
 

spec/graphql/analysis/max_query_complexity_spec.rb

@@ -50,7 +50,7 @@
     end
   end
 
-  describe "when complexity is overriden at query-level" do
+  describe "when max_complexity is decreased at query-level" do
     before do
       Dummy::Schema.max_complexity = 100
     end
@@ -61,6 +61,17 @@
     end
   end
 
+  describe "when max_complexity is increased at query-level" do
+    before do
+      Dummy::Schema.max_complexity = 1
+    end
+    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 10) }
+
+    it "doesn't error" do
+      assert_equal nil, result["errors"]
+    end
+  end
+
   describe "across a multiplex" do
     before do
       Dummy::Schema.max_complexity = 9

spec/spec_helper.rb

@@ -11,6 +11,7 @@
 require "graphql"
 require "graphql/rake_task"
 require "benchmark"
+require "pry"
 require "minitest/autorun"
 require "minitest/focus"
 require "minitest/reporters"