graphql 1.8.7 → 1.9.0

data/lib/graphql/language/comments.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Language
-    module Comments
-      extend self
-
-      def commentize(description, indent: '')
-        lines = description.split("\n")
-
-        comment = ''.dup
-
-        lines.each do |line|
-          if line == ''
-            comment << "#{indent}#\n"
-          else
-            sublines = break_line(line, 120 - indent.length)
-            sublines.each do |subline|
-              comment << "#{indent}# #{subline}\n"
-            end
-          end
-        end
-
-        comment
-      end
-
-      private
-
-      def break_line(line, length)
-        return [line] if line.length < length + 5
-
-        parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
-        return [line] if parts.length < 4
-
-        sublines = [parts.slice!(0, 3).join]
-
-        parts.each_with_index do |part, i|
-          next if i % 2 == 1
-          sublines << "#{part[1..-1]}#{parts[i + 1]}"
-        end
-
-        sublines
-      end
-    end
-  end
-end

data/lib/graphql/static_validation/arguments_validator.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    # Implement validate_node
-    class ArgumentsValidator
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        visitor = context.visitor
-        visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
-          case parent
-          when GraphQL::Language::Nodes::InputObject
-            arg_defn = context.argument_definition
-            if arg_defn.nil?
-              return
-            else
-              parent_defn = arg_defn.type.unwrap
-              if !parent_defn.is_a?(GraphQL::InputObjectType)
-                return
-              end
-            end
-          when GraphQL::Language::Nodes::Directive
-            parent_defn = context.schema.directives[parent.name]
-          when GraphQL::Language::Nodes::Field
-            parent_defn = context.field_definition
-          else
-            raise "Unexpected argument parent: #{parent.class} (##{parent})"
-          end
-          validate_node(parent, node, parent_defn, context)
-        }
-      end
-
-      private
-
-      def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
-          parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
-          parent.name
-        end
-      end
-
-      def node_type(parent)
-        parent.class.name.split("::").last
-      end
-    end
-  end
-end

data/spec/graphql/schema/member/has_fields_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Member::HasFields do
-  module SuperTest
-    class BaseObject < GraphQL::Schema::Object
-    end
-
-    module BaseInterface
-      include GraphQL::Schema::Interface
-    end
-
-    module InterfaceWithFloatField
-      include BaseInterface
-      field :float, Float, null: false
-      def float
-        # This should call the default implementation
-        super * 0.5
-      end
-    end
-
-    module SubInterfaceWithFloatField
-      include InterfaceWithFloatField
-      def float
-        # This should call `InterfaceWithFloatField#float`
-        super * 0.1
-      end
-    end
-
-    class ObjectWithFloatField < BaseObject
-      implements InterfaceWithFloatField
-    end
-
-    class ObjectWithSubFloatField < BaseObject
-      implements SubInterfaceWithFloatField
-    end
-
-    module InterfaceWithStringField
-      include BaseInterface
-      field :string, String, null: false
-      def string
-        # Return a literal value to ensure this method was called
-        "here's a string"
-      end
-    end
-
-    class ObjectWithStringField < BaseObject
-      implements InterfaceWithStringField
-      def string
-        # This should call to `InterfaceWithStringField#string`
-        super.upcase
-      end
-    end
-
-    class SubObjectWithStringField < ObjectWithStringField
-      def string
-        # This should call to `ObjectWithStringField#string`
-        super.reverse
-      end
-    end
-
-    class SubSubObjectWithStringField < SubObjectWithStringField
-      field :string, String, null: false
-    end
-
-    class Query < BaseObject
-      field :int, Integer, null: false
-      def int
-        # This should call default resolution
-        super * 2
-      end
-
-      field :string1, ObjectWithStringField, null: false, method: :object
-      field :string2, SubObjectWithStringField, null: false, method: :object
-      field :string3, SubSubObjectWithStringField, null: false, method: :object
-      field :float1, ObjectWithFloatField, null: false, method: :object
-      field :float2, ObjectWithSubFloatField, null: false, method: :object
-    end
-
-    class Schema < GraphQL::Schema
-      query(Query)
-    end
-  end
-
-  describe "Calling super in field methods" do
-    # Test that calling `super` in field methods "works", which means:
-    # - If there is a super method in the user-created hierarchy (either a class or module), it is called
-    #   This is tested by putting random transformations in method bodies,
-    #   then asserting that they are called.
-    # - If there's no user-defined super method, it calls the built-in default behavior
-    #   This is tested by putting values in the `root_value` hash.
-    #   The default behavior is to fetch hash values by key, so we assert that
-    #   those values are subject to the specified transformations.
-
-    describe "Object methods" do
-      it "may call super to default implementation" do
-        res = SuperTest::Schema.execute("{ int }", root_value: { int: 4 })
-        assert_equal 8, res["data"]["int"]
-      end
-
-      it "may call super to interface method" do
-        res = SuperTest::Schema.execute(" { string1 { string } }", root_value: {})
-        assert_equal "HERE'S A STRING", res["data"]["string1"]["string"]
-      end
-
-      it "may call super to superclass method" do
-        res = SuperTest::Schema.execute(" { string2 { string } }", root_value: {})
-        assert_equal "GNIRTS A S'EREH", res["data"]["string2"]["string"]
-      end
-
-      it "can get a super method from a newly-added field" do
-        res = SuperTest::Schema.execute(" { string3 { string } }", root_value: {})
-        assert_equal "GNIRTS A S'EREH", res["data"]["string3"]["string"]
-      end
-    end
-
-    describe "Interface methods" do
-      it "may call super to interface method" do
-        res = SuperTest::Schema.execute(" { float1 { float } }", root_value: { float: 6.0 })
-        assert_equal 3.0, res["data"]["float1"]["float"]
-      end
-
-      it "may call super to superclass method" do
-        res = SuperTest::Schema.execute(" { float2 { float } }", root_value: { float: 6.0 })
-        assert_in_delta 0.001, 0.3, res["data"]["float2"]["float"]
-      end
-    end
-  end
-end

data/spec/rails_dependency_sanity_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe 'Rails dependency sanity check' do
-  if rails_should_be_installed?
-    it "should have rails installed" do
-      assert defined?(Rails)
-    end
-  else
-    it "should not have rails installed" do
-      refute defined?(Rails)
-    end
-  end
-end