fix warden, sort by name

Author: Marc-Andre Giroux

lib/graphql/language/document_from_schema_definition.rb

@@ -17,18 +17,13 @@ def initialize(
       )
         @schema = schema
         @always_include_schema = always_include_schema
-
-        filter = GraphQL::Language::DocumentFromSchemaDefinition::Filter.new(
-          only,
-          except,
-          include_introspection_types: include_introspection_types,
-          include_built_ins: include_built_ins,
-        )
+        @include_introspection_types = include_introspection_types
+        @include_built_ins = include_built_ins
 
         @warden = GraphQL::Schema::Warden.new(
-          filter,
+          GraphQL::Filter.new(only: only, except: except),
           schema: @schema,
-          context: @context
+          context: context,
         )
       end
 
@@ -59,7 +54,7 @@ def build_schema_node
       def build_object_type_node(object_type)
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.name,
-          interfaces: warden.interfaces(object_type).map { |iface| build_type_name_node(iface) },
+          interfaces: warden.interfaces(object_type).sort_by(&:name).map { |iface| build_type_name_node(iface) },
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
         )
@@ -78,7 +73,7 @@ def build_union_type_node(union_type)
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.name,
           description: union_type.description,
-          types: warden.possible_types(union_type).map { |type| build_type_name_node(type) }
+          types: warden.possible_types(union_type).sort_by(&:name).map { |type| build_type_name_node(type) }
         )
       end
 
@@ -93,7 +88,7 @@ def build_interface_type_node(interface_type)
       def build_enum_type_node(enum_type)
         GraphQL::Language::Nodes::EnumTypeDefinition.new(
           name: enum_type.name,
-          values: warden.enum_values(enum_type).map do |enum_value|
+          values: warden.enum_values(enum_type).sort_by(&:name).map do |enum_value|
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
@@ -175,11 +170,19 @@ def build_type_definition_node(type)
       end
 
       def build_argument_nodes(arguments)
-        arguments.map { |arg| build_argument_node(arg) }
+        arguments
+          .map { |arg| build_argument_node(arg) }
+          .sort_by(&:name)
       end
 
       def build_directive_nodes(directives)
-        directives.map { |directive| build_directive_node(directive) }
+        if !include_built_ins
+          directives = directives.reject { |directive| built_in?(directive) }
+        end
+
+        directives
+          .map { |directive| build_directive_node(directive) }
+          .sort_by(&:name)
       end
 
       def build_definition_nodes
@@ -190,61 +193,42 @@ def build_definition_nodes
       end
 
       def build_type_definition_nodes(types)
-        types.map { |type| build_type_definition_node(type) }
-      end
-
-      def build_field_nodes(fields)
-        fields.map { |field| build_field_node(field) }
-      end
-
-      class Filter
-        def initialize(only, except, include_introspection_types:, include_built_ins:)
-          @only = only
-          @except = except
-          @include_introspection_types = include_introspection_types
-          @include_built_ins = include_built_ins
+        if !include_introspection_types
+          types = types.reject { |type| introspection?(type) }
         end
 
-        def call(member, context)
-          if !include_introspection_types && introspection?(member)
-            return false
-          end
-
-          if !include_built_ins && built_in?(member)
-            return false
-          end
-
-          if only
-            !only.call(member, context)
-          elsif except
-            except.call(member, context)
-          else
-            true
-          end
+        if !include_built_ins
+          types = types.reject { |type| built_in?(type) }
         end
 
-        private
+        types
+          .map { |type| build_type_definition_node(type) }
+          .sort_by(&:name)
+      end
 
-        attr_reader :include_introspection_types, :include_built_ins,
-          :only, :except
+      def build_field_nodes(fields)
+        fields
+          .map { |field| build_field_node(field) }
+          .sort_by(&:name)
+      end
 
-        def introspection?(member)
-          member.is_a?(BaseType) && member.introspection?
-        end
+      private
 
-        def built_in?(member)
-          (member.is_a?(GraphQL::ScalarType) && member.default_scalar?) ||
-          (member.is_a?(GraphQL::Directive) && member.default_directive?)
-        end
+      def introspection?(member)
+        member.is_a?(BaseType) && member.introspection?
       end
 
-      private
+      def built_in?(member)
+        (member.is_a?(GraphQL::ScalarType) && member.default_scalar?) ||
+        (member.is_a?(GraphQL::Directive) && member.default_directive?)
+      end
 
       def include_schema_node?
-        @always_include_schema || !schema.respects_root_name_conventions?
+        always_include_schema || !schema.respects_root_name_conventions?
       end
 
-      attr_reader :schema, :warden
+      attr_reader :schema, :warden, :always_include_schema,
+        :include_introspection_types, :include_built_ins
     end
   end
 end

lib/graphql/language/printer.rb

@@ -319,7 +319,7 @@ def print_node(node, indent: "")
           print_input_object_type_definition(node)
         when Nodes::DirectiveDefinition
           print_directive_definition(node)
-        when FalseClass, Float, Integer, NilClass, String, TrueClass
+        when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol
           GraphQL::Language.serialize(node)
         when Array
           "[#{node.map { |v| print_node(v) }.join(", ")}]".dup

lib/graphql/schema/printer.rb

@@ -45,7 +45,7 @@ class Printer
       # @param except [<#call(member, ctx)>]
       # @param introspection [Boolean] Should include the introspection types in the string?
       def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
-        @document_generator = GraphQL::Language::DocumentFromSchemaDefinition.new(
+        @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
           context: context,
           only: only,
@@ -54,6 +54,8 @@ def initialize(schema, context: nil, only: nil, except: nil, introspection: fals
           include_built_ins: false,
         )
 
+        @document = @document_from_schema.document
+
         @schema = schema
       end
 
@@ -78,50 +80,17 @@ def self.print_schema(schema, **args)
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        document = @document_generator.document
-        document.to_query_string
+        @document.to_query_string
       end
 
       def print_type(type)
-        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
+        binding.pry
+        node = @document_from_schema.build_object_type_node(type)
+        node.to_query_string
       end
 
       private
 
-      # By default, these are included in a schema printout
-      IS_USER_DEFINED_MEMBER = ->(member) {
-        case member
-        when GraphQL::BaseType
-          !member.introspection?
-        when GraphQL::Directive
-          !member.default_directive?
-        else
-          true
-        end
-      }
-
-      private_constant :IS_USER_DEFINED_MEMBER
-
-      def build_blacklist(only, except, introspection:)
-        if introspection
-          if only
-            ->(m, ctx) { !only.call(m, ctx) }
-          elsif except
-            except
-          else
-            ->(m, ctx) { false }
-          end
-        else
-          if only
-            ->(m, ctx) { !(IS_USER_DEFINED_MEMBER.call(m) && only.call(m, ctx)) }
-          elsif except
-            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) || except.call(m, ctx) }
-          else
-            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) }
-          end
-        end
-      end
-
       def print_schema_definition
         if (schema.query.nil? || schema.query.name == 'Query') &&
            (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&