graphql 1.8.0.pre4 → 1.8.0.pre5

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

@@ -102,7 +102,17 @@ module GraphQL
       def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
         spreads = spreads_for_context[node] - visited_fragments
         spreads.each do |spread_name|
-          def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
+          def_node = nil
+          variables = nil
+          # Implement `.find` by hand to avoid Ruby's internal allocations
+          fragment_definitions.each do |frag_def_node, vars|
+            if frag_def_node.name == spread_name
+              def_node = frag_def_node
+              variables = vars
+              break
+            end
+          end
+
           next if !def_node
           visited_fragments << spread_name
           variables.each do |name, child_usage|

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -15,17 +15,12 @@ module GraphQL
       }
 
       def platform_trace(platform_key, key, data)
-        service = options.fetch(:service, 'ruby-graphql')
+        tracer.trace(platform_key, service: service_name) do |span|
+          span.span_type = 'custom'
 
-        pin = Datadog::Pin.get_from(self)
-        unless pin
-          pin = Datadog::Pin.new(service)
-          pin.onto(self)
-        end
-
-        pin.tracer.trace(platform_key, service: pin.service) do |span|
           if key == 'execute_multiplex'
-            span.resource = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
+            operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
+            span.resource = operations unless operations.empty?
           end
 
           if key == 'execute_query'
@@ -33,10 +28,19 @@ module GraphQL
             span.set_tag(:selected_operation_type, data[:query].selected_operation.operation_type)
             span.set_tag(:query_string, data[:query].query_string)
           end
+
           yield
         end
       end
 
+      def service_name
+        options.fetch(:service, 'ruby-graphql')
+      end
+
+      def tracer
+        options.fetch(:tracer, Datadog.tracer)
+      end
+
       def platform_field_key(type, field)
         "#{type.name}.#{field.name}"
       end

data/lib/graphql/upgrader/member.rb

@@ -52,6 +52,13 @@ module GraphQL
           type_expr
         end
       end
+
+      def underscorize(str)
+        str
+          .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          .downcase
+      end
     end
 
     # Turns `{X} = GraphQL::{Y}Type.define do` into `class {X} < Types::Base{Y}`.
@@ -187,20 +194,13 @@ module GraphQL
     # (They'll be automatically camelized later.)
     class UnderscoreizeFieldNameTransform < Transform
       def apply(input_text)
-        input_text.sub /(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/ do
+        input_text.gsub /(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/ do
           field_type = $~[:field_type]
           camelized_name = $~[:name]
           underscored_name = underscorize(camelized_name)
           "#{field_type} :#{underscored_name}"
         end
       end
-
-      def underscorize(str)
-        str
-          .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-          .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-          .downcase
-      end
     end
 
     class ResolveProcToMethodTransform < Transform
@@ -215,6 +215,8 @@ module GraphQL
           # - Args is trickier:
           #   - If it's not used, remove it
           #   - If it's used, abandon ship and make it `**args`
+          #   - Convert string args access to symbol access, since it's a Ruby **splat
+          #   - Convert camelized arg names to underscored arg names
           #   - (It would be nice to correctly become Ruby kwargs, but that might be too hard)
           #   - Add a `# TODO` comment to the method source?
           # - Rebuild the method:
@@ -260,6 +262,15 @@ module GraphQL
           lines.unshift("\n#{method_def_indent}#{method_def}")
           lines << "#{method_def_indent}end\n"
           method_body = lines.join("\n")
+          # Update Argument access to be underscore and symbols
+          # Update `args[...]` and `args.key?`
+          method_body = method_body.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
+            method_begin = $~[:method_begin]
+            arg_name = underscorize($~[:arg_name])
+            method_end = $~[:method_end]
+            "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+          end
+
           # Replace the resolve proc with the method
           input_text[processor.resolve_start..processor.resolve_end] = ""
           # The replacement above might have left some preceeding whitespace,

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.0.pre4"
+  VERSION = "1.8.0.pre5"
 end

data/spec/graphql/backtrace_spec.rb

@@ -126,6 +126,16 @@ describe GraphQL::Backtrace do
       assert_includes err.message, "more lines"
     end
 
+    it "annotates errors from Query#result" do
+      query_str = "query StrField { field2 { strField } __typename }"
+      context = { backtrace: true }
+      query = GraphQL::Query.new(schema, query_str, context: context)
+      err = assert_raises(GraphQL::Backtrace::TracedError) {
+        query.result
+      }
+      assert_instance_of RuntimeError, err.cause
+    end
+
     it "annotates errors inside lazy resolution" do
       # Test context-based flag
       err = assert_raises(GraphQL::Backtrace::TracedError) {

data/spec/graphql/directive_spec.rb

@@ -31,7 +31,9 @@ describe GraphQL::Directive do
     describe "child fields" do
       let(:query_string) { <<-GRAPHQL
       {
-        __type(name: "Cheese") {
+        __type(name: """
+        Cheese
+        """) {
           fields { name }
           fields @skip(if: true) { isDeprecated }
         }

data/spec/graphql/language/block_string_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Language::BlockString do
+  describe "trimming whitespace" do
+    def trim_whitespace(str)
+      GraphQL::Language::BlockString.trim_whitespace(str)
+    end
+
+    it "matches the examples in graphql-js" do
+      # these are taken from:
+      # https://github.com/graphql/graphql-js/blob/36ec0e9d34666362ff0e2b2b18edeb98e3c9abee/src/language/__tests__/blockStringValue-test.js#L12
+      # A set of [before, after] pairs:
+      examples = [
+        [
+          # Removes common whitespace:
+          "
+          Hello,
+            World!
+
+          Yours,
+            GraphQL.
+          ",
+          "Hello,\n  World!\n\nYours,\n  GraphQL."
+        ],
+        [
+          # Removes leading and trailing newlines:
+          "
+
+          Hello,
+            World!
+
+          Yours,
+            GraphQL.
+
+          ",
+          "Hello,\n  World!\n\nYours,\n  GraphQL."
+        ],
+        [
+          # Removes blank lines (with whitespace _and_ newlines:)
+          "\n    \n
+          Hello,
+            World!
+
+          Yours,
+            GraphQL.
+
+          \n     \n",
+          "Hello,\n  World!\n\nYours,\n  GraphQL."
+        ],
+        [
+          # Retains indentation from the first line
+          "    Hello,\n      World!\n\n    Yours,\n      GraphQL.",
+          "    Hello,\n  World!\n\nYours,\n  GraphQL.",
+        ],
+        [
+          # Doesn't alter trailing spaces
+          "\n    \n    Hello,     \n      World!   \n\n    Yours,     \n      GraphQL.  ",
+          "Hello,     \n  World!   \n\nYours,     \n  GraphQL.  ",
+
+        ],
+      ]
+
+      examples.each_with_index do |(before, after), idx|
+        transformed_str = trim_whitespace(before)
+        assert_equal(after, transformed_str, "Example ##{idx + 1}")
+      end
+    end
+  end
+end

data/spec/graphql/language/lexer_spec.rb

@@ -26,6 +26,15 @@ describe GraphQL::Language::Lexer do
       assert_equal tokens[0], tokens[1].prev_token
     end
 
+    describe "block strings" do
+      let(:query_string) { %|{ a(b: """\nc\n  d\n""")}|}
+
+      it "tokenizes them" do
+        str_token = tokens[5]
+        assert_equal "c\n  d", str_token.value
+      end
+    end
+
     it "unescapes escaped characters" do
       assert_equal "\" \\ / \b \f \n \r \t", subject.tokenize('"\\" \\\\ \\/ \\b \\f \\n \\r \\t"').first.to_s
     end

data/spec/graphql/query_spec.rb

@@ -85,7 +85,7 @@ describe GraphQL::Query do
         operation_name: operation_name,
         max_depth: max_depth,
       )
-      query.query_string = '{ __type(name: "Cheese") { name } }'
+      query.query_string = '{ __type(name: """Cheese""") { name } }'
       assert_equal "Cheese", query.result["data"] ["__type"]["name"]
     end
   end

data/spec/graphql/schema/field_spec.rb

@@ -15,6 +15,14 @@ describe GraphQL::Schema::Field do
       assert_equal 'inspectInput', field.graphql_definition.name
     end
 
+    it "exposes the method override" do
+      assert_nil field.method
+      object = Class.new(Jazz::BaseObject) do
+        field :t, String, method: :tt, null: true
+      end
+      assert_equal :tt, object.fields["t"].method
+    end
+
     it "accepts a block for definition" do
       object = Class.new(Jazz::BaseObject) do
         graphql_name "JustAName"

data/spec/graphql/schema/finder_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Finder do
+  let(:finder) { GraphQL::Schema::Finder.new(Jazz::Schema) }
+
+  describe "#find" do
+    it "finds a valid object type" do
+      type = finder.find("Ensemble")
+      assert_equal "Ensemble", type.name
+    end
+
+    it "raises when finding an invalid object type" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("DoesNotExist")
+      end
+
+      assert_match /Could not find type `DoesNotExist` in schema./, exception.message
+    end
+
+    it "finds a valid directive" do
+      directive = finder.find("@include")
+      assert_equal "include", directive.name
+    end
+
+    it "raises when finding an invalid directive" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("@yolo")
+      end
+
+      assert_match /Could not find directive `@yolo` in schema./, exception.message
+    end
+
+    it "finds a valid field" do
+      field = finder.find("Ensemble.musicians")
+      assert_equal "musicians", field.name
+    end
+
+    it "finds a meta field" do
+      field = finder.find("Ensemble.__typename")
+      assert_equal "__typename", field.name
+    end
+
+    it "raises when finding an in valid field" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("Ensemble.nope")
+      end
+
+      assert_match /Could not find field `nope` on object type `Ensemble`./, exception.message
+    end
+
+    it "finds a valid argument" do
+      arg = finder.find("Query.find.id")
+      assert_equal "id", arg.name
+    end
+
+    it "raises when finding an invalid argument" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("Query.find.thisArgumentIsInvalid")
+      end
+
+      assert_match /Could not find argument `thisArgumentIsInvalid` on field `find`./, exception.message
+    end
+
+    it "raises when selecting on an argument" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("Query.find.id.whyYouDoThis")
+      end
+
+      assert_match /Cannot select member `whyYouDoThis` on a field./, exception.message
+    end
+
+    it "finds a valid interface" do
+      type = finder.find("NamedEntity")
+      assert_equal "NamedEntity", type.name
+    end
+
+    it "finds a valid input type" do
+      type = finder.find("LegacyInput")
+      assert_equal "LegacyInput", type.name
+    end
+
+    it "finds a valid input field" do
+      input_field = finder.find("LegacyInput.intValue")
+      assert_equal "intValue", input_field.name
+    end
+
+    it "raises when finding an invalid input field" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("LegacyInput.wat")
+      end
+
+      assert_match /Could not find input field `wat` on input object type `LegacyInput`./, exception.message
+    end
+
+    it "finds a valid union type" do
+      type = finder.find("PerformingAct")
+      assert_equal "PerformingAct", type.name
+    end
+
+    it "raises when selecting a possible type" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("PerformingAct.Musician")
+      end
+
+      assert_match /Cannot select union possible type `Musician`. Select the type directly instead./, exception.message
+    end
+
+    it "finds a valid enum type" do
+      type = finder.find("Family")
+      assert_equal "Family", type.name
+    end
+
+    it "finds a valid enum value" do
+      value = finder.find("Family.BRASS")
+      assert_equal "BRASS", value.name
+    end
+
+    it "raises when finding an invalid enum value" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("Family.THISISNOTASTATUS")
+      end
+
+      assert_match /Could not find enum value `THISISNOTASTATUS` on enum type `Family`./, exception.message
+    end
+
+    it "raises when selecting on an enum value" do
+      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
+        finder.find("Family.BRASS.wat")
+      end
+
+      assert_match /Cannot select member `wat` on an enum value./, exception.message
+    end
+  end
+end

data/spec/graphql/schema/printer_spec.rb

@@ -14,7 +14,11 @@ describe GraphQL::Schema::Printer do
 
       value "FOO", value: :foo
       value "BAR", value: :bar
-      value "BAZ", deprecation_reason: 'Use "BAR".'
+      value "BAZ", deprecation_reason: <<-REASON
+Use "BAR" instead.
+
+It's the replacement for this value.
+REASON
       value "WOZ", deprecation_reason: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
     end
 
@@ -352,7 +356,6 @@ SCHEMA
       custom_mutation = schema.mutation.redefine(name: "MyMutationRoot")
       custom_schema = schema.redefine(mutation: custom_mutation)
 
-
       expected = <<SCHEMA
 schema {
   query: Query
@@ -389,7 +392,7 @@ type Audio {
 
 enum Choice {
   BAR
-  BAZ @deprecated(reason: "Use "BAR".")
+  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
   FOO
   WOZ @deprecated
 }
@@ -438,7 +441,7 @@ interface Node {
 type Post {
   body: String!
   comments: [Comment!]
-  comments_count: Int! @deprecated(reason: "Use "comments".")
+  comments_count: Int! @deprecated(reason: "Use \\\"comments\\\".")
   id: ID!
   title: String!
 }
@@ -600,7 +603,7 @@ SCHEMA
 type Post {
   body: String!
   comments: [Comment!]
-  comments_count: Int! @deprecated(reason: "Use "comments".")
+  comments_count: Int! @deprecated(reason: "Use \\\"comments\\\".")
   id: ID!
   title: String!
 }
@@ -608,4 +611,44 @@ SCHEMA
       assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(schema.types['Post'])
     end
   end
+
+  describe "#print_directive" do
+    it "prints the deprecation reason in a single line escaped string including line breaks" do
+      expected = <<SCHEMA
+enum Choice {
+  BAR
+  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
+  FOO
+  WOZ @deprecated
+}
+
+type Subscription {
+}
+
+input Varied {
+  bool: Boolean
+  enum: Choice = FOO
+  float: Float
+  int: Int
+}
+SCHEMA
+
+      only_filter = ->(member, ctx) {
+        case member
+        when GraphQL::ScalarType
+          true
+        when GraphQL::BaseType
+          ctx[:names].include?(member.name)
+        when GraphQL::Argument
+          member.name != "id"
+        else
+          true
+        end
+      }
+
+      context = { names: ["Varied", "Choice", "Subscription"] }
+
+      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema, context: context, only: only_filter).print_schema
+    end
+  end
 end