graphql-schema_comparator 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 510c4140ffe9cca7a012282eabc3570cae2bf084
-  data.tar.gz: 2b1236ab94f83ed213f73afc9dcb941a5ac7e097
+  metadata.gz: de7ab5aa8da6dcfe86369cab4a4278f4e243365e
+  data.tar.gz: a0cf175638ba9b983a793555514c3c51a91c6725
 SHA512:
-  metadata.gz: 2734f4d3159c8b0e0851aacd92e94f016d8aeebdffa4ec33a8473436bb8347dfcf72e8b4c0d821243426f267092efcf2bf1571d83f7f04a3ac598e377da65801
-  data.tar.gz: b00933509012e0c900b6ced4e40c48a09c4ff06278ba9cd5a6a3109d70f6f5d879737f448171da4c9ce0e4c23e2383c7f6b94bd4bc06a0f7d077c166dc931582
+  metadata.gz: cc5dd38fb9f71124dd18323a1ceb8e123994476bee91a134854140e160075a515c0975fb60fc662d918ea7deac6e0b6c48a015da5afb53a14191a22de8514837
+  data.tar.gz: c9f9ca7b7672748246ee7519b35e06f36b49ad55fba891699249de86107518fac2f0033afe22e2ae8529b5d4f9b9ba17a31aa701a977ab9a9ae8bcdf9ba2d095

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.3.0 (Oct 14 2017)
+
+### New features
+
+- Top level Directive definitions are now diffed, but not directives used on definitions (Coming soon)
+- Base class for changes added.
+
+### breaking changes
+
+- `breaking` method on change objects has been renamed `breaking?` for style
+
+### Bug fixes
+
+- Fix message for `EnumValueRemoved` (#5)
+
 ## 0.2.0 (Aug 18 2017)
 
 ### New features

data/lib/graphql/schema_comparator.rb

@@ -1,9 +1,21 @@
 require "graphql"
+
 require "graphql/schema_comparator/version"
-require "graphql/schema_comparator/diff/schema"
 require "graphql/schema_comparator/changes"
 require "graphql/schema_comparator/result"
 
+require "graphql/schema_comparator/diff/schema"
+require "graphql/schema_comparator/diff/argument"
+require "graphql/schema_comparator/diff/directive"
+require "graphql/schema_comparator/diff/directive_argument"
+require "graphql/schema_comparator/diff/enum"
+require "graphql/schema_comparator/diff/field"
+require "graphql/schema_comparator/diff/input_object"
+require "graphql/schema_comparator/diff/input_field"
+require "graphql/schema_comparator/diff/object_type"
+require "graphql/schema_comparator/diff/interface"
+require "graphql/schema_comparator/diff/union"
+
 module GraphQL
   module SchemaComparator
     def self.compare(old_schema, new_schema)

data/lib/graphql/schema_comparator/changes.rb

@@ -1,36 +1,52 @@
 module GraphQL
   module SchemaComparator
     module Changes
-      # Breaking Changes
+      class AbstractChange
+        def message
+          raise NotImplementedError
+        end
+
+        def breaking?
+          raise NotImplementedError
+        end
+      end
 
-      class TypeRemoved
-        attr_reader :removed_type, :breaking
+      class TypeRemoved < AbstractChange
+        attr_reader :removed_type
 
         def initialize(removed_type)
           @removed_type = removed_type
           @breaking = true
         end
 
+        def breaking?
+          !!@breaking
+        end
+
         def message
-          "#{removed_type.name} was removed"
+          "`#{removed_type.name}` was removed"
         end
       end
 
-      class DirectiveRemoved
-        attr_reader :removed_directive, :breaking
+      class DirectiveRemoved < AbstractChange
+        attr_reader :directive
 
-        def initialize(removed_directive)
-          @removed_directive = removed_directive
+        def initialize(directive)
+          @directive = directive
           @breaking = true
         end
 
         def message
-          "#{removed_directive.name} was removed"
+          "`#{directive.name}` was removed"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class TypeKindChanged
-        attr_reader :old_type, :new_type, :breaking
+      class TypeKindChanged < AbstractChange
+        attr_reader :old_type, :new_type
 
         def initialize(old_type, new_type)
           @old_type = old_type
@@ -41,10 +57,14 @@ module GraphQL
         def message
           "`#{old_type.name}` kind changed from `#{old_type.kind}` to `#{new_type.kind}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class EnumValueRemoved
-        attr_reader :enum_value, :enum_type, :breaking
+      class EnumValueRemoved < AbstractChange
+        attr_reader :enum_value, :enum_type
 
         def initialize(enum_type, enum_value)
           @enum_value = enum_value
@@ -55,10 +75,14 @@ module GraphQL
         def message
           "Enum value `#{enum_value.name}` was removed from enum `#{enum_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class UnionMemberRemoved
-        attr_reader :union_type, :union_member, :breaking
+      class UnionMemberRemoved < AbstractChange
+        attr_reader :union_type, :union_member
 
         def initialize(union_type, union_member)
           @union_member = union_member
@@ -69,10 +93,14 @@ module GraphQL
         def message
           "Union member `#{union_member.name}` was removed from Union type `#{union_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class InputFieldRemoved
-        attr_reader :input_object_type, :field, :breaking
+      class InputFieldRemoved < AbstractChange
+        attr_reader :input_object_type, :field
 
         def initialize(input_object_type, field)
           @input_object_type = input_object_type
@@ -83,10 +111,14 @@ module GraphQL
         def message
           "Input field `#{field.name}` was removed from input object type `#{input_object_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldArgumentRemoved
-        attr_reader :object_type, :field, :argument, :breaking
+      class FieldArgumentRemoved < AbstractChange
+        attr_reader :object_type, :field, :argument
 
         def initialize(object_type, field, argument)
           @object_type = object_type
@@ -98,14 +130,32 @@ module GraphQL
         def message
           "Argument `#{argument.name}: #{argument.type}` was removed from field `#{object_type.name}.#{field.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      # TODO
-      # class DirectiveArgumentRemoved
-      # end
+      class DirectiveArgumentRemoved < AbstractChange
+        attr_reader :directive, :argument
+
+        def initialize(directive, argument)
+          @directive = directive
+          @argument = argument
+          @breaking = true
+        end
 
-      class SchemaQueryTypeChanged
-        attr_reader :old_schema, :new_schema, :breaking
+        def message
+          "Argument `#{argument.name}` was removed from directive `#{directive.name}`"
+        end
+
+        def breaking?
+          !!@breaking
+        end
+      end
+
+      class SchemaQueryTypeChanged < AbstractChange
+        attr_reader :old_schema, :new_schema
 
         def initialize(old_schema, new_schema)
           @old_schema = old_schema
@@ -116,10 +166,14 @@ module GraphQL
         def message
           "Schema query root has changed from `#{old_schema.query.name}` to `#{new_schema.query.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldRemoved
-        attr_reader :object_type, :field, :breaking
+      class FieldRemoved < AbstractChange
+        attr_reader :object_type, :field
 
         def initialize(object_type, field)
           @object_type = object_type
@@ -130,14 +184,32 @@ module GraphQL
         def message
           "Field `#{field.name}` was removed from object type `#{object_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      # TODO
-      # class DirectiveLocationRemoved
-      # end
+      class DirectiveLocationRemoved < AbstractChange
+        attr_reader :directive, :location
+
+        def initialize(directive, location)
+          @directive = directive
+          @location = location
+          @breaking = true
+        end
+
+        def message
+          "Location `#{location}` was removed from directive `#{directive.name}`"
+        end
+
+        def breaking?
+          !!@breaking
+        end
+      end
 
-      class ObjectTypeInterfaceRemoved
-        attr_reader :interface, :object_type, :breaking
+      class ObjectTypeInterfaceRemoved < AbstractChange
+        attr_reader :interface, :object_type
 
         def initialize(interface, object_type)
           @interface = interface
@@ -148,12 +220,14 @@ module GraphQL
         def message
           "`#{object_type.name}` object type no longer implements `#{interface.name}` interface"
         end
-      end
 
-      # Non-Breaking Changes
+        def breaking?
+          !!@breaking
+        end
+      end
 
-      class TypeAdded
-        attr_reader :type, :breaking
+      class TypeAdded < AbstractChange
+        attr_reader :type
 
         def initialize(type)
           @type = type
@@ -163,18 +237,31 @@ module GraphQL
         def message
           "Type `#{type.name}` was added"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveAdded
-        attr_reader :breaking
+      class DirectiveAdded < AbstractChange
+        attr_reader :directive
 
-        def initialize(*)
+        def initialize(directive)
+          @directive = directive
           @breaking = false
         end
+
+        def message
+          "Directive `#{directive.name}` was added"
+        end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class TypeDescriptionChanged
-        attr_reader :old_type, :new_type, :breaking
+      class TypeDescriptionChanged < AbstractChange
+        attr_reader :old_type, :new_type
 
         def initialize(old_type, new_type)
           @old_type = old_type
@@ -185,10 +272,14 @@ module GraphQL
         def message
           "Description `#{old_type.description}` on type `#{old_type.name}` has changed to `#{new_type.description}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class EnumValueAdded
-        attr_reader :enum_type, :enum_value, :breaking
+      class EnumValueAdded < AbstractChange
+        attr_reader :enum_type, :enum_value
 
         def initialize(enum_type, enum_value)
           @enum_type = enum_type
@@ -199,20 +290,26 @@ module GraphQL
         def message
           "Enum value `#{enum_value.name}` was added to enum `#{enum_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class EnumValueDescriptionChanged
+      # TODO
+      class EnumValueDescriptionChanged < AbstractChange
         def initialize(*)
         end
       end
 
-      class EnumValueDeprecated
+      # TODO
+      class EnumValueDeprecated < AbstractChange
         def initialize(*)
         end
       end
 
-      class UnionMemberAdded
-        attr_reader :union_type, :union_member, :breaking
+      class UnionMemberAdded < AbstractChange
+        attr_reader :union_type, :union_member
 
         def initialize(union_type, union_member)
           @union_member = union_member
@@ -223,10 +320,14 @@ module GraphQL
         def message
           "Union member `#{union_member.name}` was added to Union type `#{union_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class InputFieldDescriptionChanged
-        attr_reader :input_type, :old_field, :new_field, :breaking
+      class InputFieldDescriptionChanged < AbstractChange
+        attr_reader :input_type, :old_field, :new_field
 
         def initialize(input_type, old_field, new_field)
           @input_type = input_type
@@ -239,15 +340,33 @@ module GraphQL
           "Input field `#{input_type.name}.#{old_field.name}` description changed"\
             " from `#{old_field.description}` to `#{new_field.description}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveDescriptionChanged
-        def initialize(*)
+      class DirectiveDescriptionChanged < AbstractChange
+        attr_reader :old_directive, :new_directive
+
+        def initialize(old_directive, new_directive)
+          @old_directive = old_directive
+          @new_directive = new_directive
+          @breaking = false
+        end
+
+        def message
+          "Directive `#{new_directive.name}` description changed"\
+            " from `#{old_directive.description}` to `#{new_directive.description}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class FieldDescriptionChanged
-        attr_reader :type, :old_field, :new_field, :breaking
+      class FieldDescriptionChanged < AbstractChange
+        attr_reader :type, :old_field, :new_field
 
         def initialize(type, old_field, new_field)
           @type = type
@@ -260,10 +379,14 @@ module GraphQL
           "Field `#{type.name}.#{old_field.name}` description changed"\
             " from `#{old_field.description}` to `#{new_field.description}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldArgumentDescriptionChanged
-        attr_reader :type, :field, :old_argument, :new_argument, :breaking
+      class FieldArgumentDescriptionChanged < AbstractChange
+        attr_reader :type, :field, :old_argument, :new_argument
 
         def initialize(type, field, old_argument, new_argument)
           @type = type
@@ -277,15 +400,34 @@ module GraphQL
           "Description for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
             " from `#{old_argument.description}` to `#{new_argument.description}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveArgumentDescriptionChanged
-        def initialize(*)
+      class DirectiveArgumentDescriptionChanged < AbstractChange
+        attr_reader :directive, :old_argument, :new_argument
+
+        def initialize(directive, old_argument, new_argument)
+          @directive = directive
+          @old_argument = old_argument
+          @new_argument = new_argument
+          @breaking = false
+        end
+
+        def message
+          "Description for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
+            " from `#{old_argument.description}` to `#{new_argument.description}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class FieldDeprecationChanged
-        attr_reader :type, :old_field, :new_field, :breaking
+      class FieldDeprecationChanged < AbstractChange
+        attr_reader :type, :old_field, :new_field
 
         def initialize(type, old_field, new_field)
           @type = type
@@ -298,10 +440,14 @@ module GraphQL
           "Deprecation reason on field `#{type.name}.#{new_field.name}` has changed "\
             "from `#{old_field.deprecation_reason}` to `#{new_field.deprecation_reason}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class InputFieldDefaultChanged
-        attr_reader :input_type, :old_field, :new_field, :breaking
+      class InputFieldDefaultChanged < AbstractChange
+        attr_reader :input_type, :old_field, :new_field
 
         def initialize(input_type, old_field, new_field)
           @input_type = input_type
@@ -314,10 +460,14 @@ module GraphQL
           "Input field `#{input_type.name}.#{old_field.name}` default changed"\
             " from `#{old_field.default_value}` to `#{new_field.default_value}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldArgumentDefaultChanged
-        attr_reader :type, :field, :old_argument, :new_argument, :breaking
+      class FieldArgumentDefaultChanged < AbstractChange
+        attr_reader :type, :field, :old_argument, :new_argument
 
         def initialize(type, field, old_argument, new_argument)
           @type = type
@@ -331,15 +481,34 @@ module GraphQL
           "Default value for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
             " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveArgumentDefaultChanged
-        def initialize(*)
+      class DirectiveArgumentDefaultChanged < AbstractChange
+        attr_reader :directive, :old_argument, :new_argument
+
+        def initialize(directive, old_argument, new_argument)
+          @directive = directive
+          @old_argument = old_argument
+          @new_argument = new_argument
+          @breaking = false
+        end
+
+        def message
+          "Default value for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
+            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class ObjectTypeInterfaceAdded
-        attr_reader :interface, :object_type, :breaking
+      class ObjectTypeInterfaceAdded < AbstractChange
+        attr_reader :interface, :object_type
 
         def initialize(interface, object_type)
           @interface = interface
@@ -350,10 +519,14 @@ module GraphQL
         def message
           "`#{object_type.name}` object implements `#{interface.name}` interface"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldAdded
-        attr_reader :object_type, :field, :breaking
+      class FieldAdded < AbstractChange
+        attr_reader :object_type, :field
 
         def initialize(object_type, field)
           @object_type = object_type
@@ -364,137 +537,176 @@ module GraphQL
         def message
           "Field `#{field.name}` was added to object type `#{object_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveLocationAdded
-        def initialize(*)
+      class DirectiveLocationAdded < AbstractChange
+        attr_reader :directive, :location
+
+        def initialize(directive, location)
+          @directive = directive
+          @location = location
+          @breaking = false
+        end
+
+        def message
+          "Location `#{location}` was added to directive `#{directive.name}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class FieldAstDirectiveAdded
+      # TODO
+      class FieldAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class FieldAstDirectiveRemoved
+      # TODO
+      class FieldAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class EnumValueAstDirectiveAdded
+      # TODO
+      class EnumValueAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class EnumValueAstDirectiveRemoved
+      # TODO
+      class EnumValueAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class InputFieldAstDirectiveAdded
+      # TODO
+      class InputFieldAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class InputFieldAstDirectiveRemoved
+      # TODO
+      class InputFieldAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class DirectiveArgumentAstDirectiveAdded
+      # TODO
+      class DirectiveArgumentAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class DirectiveArgumentAstDirectiveRemoved
+      # TODO
+      class DirectiveArgumentAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class FieldArgumentAstDirectiveAdded
+      # TODO
+      class FieldArgumentAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class FieldArgumentAstDirectiveRemoved
+      # TODO
+      class FieldArgumentAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class ObjectTypeAstDirectiveAdded
+      # TODO
+      class ObjectTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class ObjectTypeAstDirectiveRemoved
+      # TODO
+      class ObjectTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class InterfaceTypeAstDirectiveAdded
+      # TODO
+      class InterfaceTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class InterfaceTypeAstDirectiveRemoved
+      # TODO
+      class InterfaceTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class UnionTypeAstDirectiveAdded
+      # TODO
+      class UnionTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class UnionTypeAstDirectiveRemoved
+      # TODO
+      class UnionTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class EnumTypeAstDirectiveAdded
+      # TODO
+      class EnumTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class EnumTypeAstDirectiveRemoved
+      # TODO
+      class EnumTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class ScalarTypeAstDirectiveAdded
+      # TODO
+      class ScalarTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class ScalarTypeAstDirectiveRemoved
+      # TODO
+      class ScalarTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class InputObjectTypeAstDirectiveAdded
+      # TODO
+      class InputObjectTypeAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class InputObjectTypeAstDirectiveRemoved
+      # TODO
+      class InputObjectTypeAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      class SchemaAstDirectiveAdded
+      # TODO
+      class SchemaAstDirectiveAdded < AbstractChange
         def initialize(*)
         end
       end
 
-      class SchemaAstDirectiveRemoved
+      # TODO
+      class SchemaAstDirectiveRemoved < AbstractChange
         def initialize(*)
         end
       end
 
-      # Maybe Breaking
-
-      class InputFieldAdded
-        attr_reader :input_object_type, :field, :breaking
+      class InputFieldAdded < AbstractChange
+        attr_reader :input_object_type, :field
 
         def initialize(input_object_type, field)
           @input_object_type = input_object_type
@@ -505,10 +717,14 @@ module GraphQL
         def message
           "Input field `#{field.name}` was added to input object type `#{input_object_type.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldArgumentAdded
-        attr_reader :type, :field, :argument, :breaking
+      class FieldArgumentAdded < AbstractChange
+        attr_reader :type, :field, :argument
 
         def initialize(type, field, argument)
           @type = type
@@ -521,15 +737,32 @@ module GraphQL
         def message
           "Argument `#{argument.name}: #{argument.type}` added to field `#{type.name}.#{field.name}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveArgumentAdded
-        def initialize(*)
+      class DirectiveArgumentAdded < AbstractChange
+        attr_reader :directive, :argument
+
+        def initialize(directive, argument)
+          @directive = directive
+          @argument = argument
+          @breaking = false
+        end
+
+        def message
+          "Argument `#{argument.name}` was added to directive `#{directive.name}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class InputFieldTypeChanged
-        attr_reader :input_type, :old_input_field, :new_input_field, :breaking
+      class InputFieldTypeChanged < AbstractChange
+        attr_reader :input_type, :old_input_field, :new_input_field
 
         def initialize(input_type, old_input_field, new_input_field)
           @input_type = input_type
@@ -541,10 +774,14 @@ module GraphQL
         def message
           "Input field `#{input_type}.#{old_input_field.name}` changed type from #{old_input_field.type} to #{new_input_field.type}"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class FieldArgumentTypeChanged
-        attr_reader :type, :field, :old_argument, :new_argument, :breaking
+      class FieldArgumentTypeChanged < AbstractChange
+        attr_reader :type, :field, :old_argument, :new_argument
 
         def initialize(type, field, old_argument, new_argument)
           @type = type
@@ -558,15 +795,34 @@ module GraphQL
           "Type for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
             " from `#{old_argument.type}` to `#{new_argument.type}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class DirectiveArgumentTypeChanged
-        def initialize(*)
+      class DirectiveArgumentTypeChanged < AbstractChange
+        attr_reader :directive, :old_argument, :new_argument
+
+        def initialize(directive, old_argument, new_argument)
+          @directive = directive
+          @old_argument = old_argument
+          @new_argument = new_argument
+          @breaking = false
+        end
+
+        def message
+          "Type for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
+            " from `#{old_argument.type}` to `#{new_argument.type}`"
+        end
+
+        def breaking?
+          !!@breaking
         end
       end
 
-      class FieldTypeChanged
-        attr_reader :type, :old_field, :new_field, :breaking
+      class FieldTypeChanged < AbstractChange
+        attr_reader :type, :old_field, :new_field
 
         def initialize(type, old_field, new_field)
           @type = type
@@ -578,10 +834,14 @@ module GraphQL
         def message
           "Field `#{type}.#{old_field.name}` changed type from `#{old_field.type}` to `#{new_field.type}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class SchemaMutationTypeChanged
-        attr_reader :old_schema, :new_schema, :breaking
+      class SchemaMutationTypeChanged < AbstractChange
+        attr_reader :old_schema, :new_schema
 
         def initialize(old_schema, new_schema)
           @old_schema = old_schema
@@ -592,9 +852,13 @@ module GraphQL
         def message
           "Schema mutation root has changed from `#{old_schema.mutation}` to `#{new_schema.mutation}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
 
-      class SchemaSubscriptionTypeChanged
+      class SchemaSubscriptionTypeChanged < AbstractChange
         def initialize(old_schema, new_schema)
           @old_schema = old_schema
           @new_schema = new_schema
@@ -604,6 +868,10 @@ module GraphQL
         def message
           "Schema subscription type has changed from `#{old_schema.subscription}` to `#{new_schema.subscription}`"
         end
+
+        def breaking?
+          !!@breaking
+        end
       end
     end
   end

data/lib/graphql/schema_comparator/diff/directive.rb

@@ -0,0 +1,63 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Directive
+        def initialize(old_directive, new_directive)
+          @old_directive = old_directive
+          @new_directive = new_directive
+          @old_arguments = old_directive.arguments
+          @new_arguments = new_directive.arguments
+        end
+
+        def diff
+          changes = []
+
+          if old_directive.description != new_directive.description
+            changes << Changes::DirectiveDescriptionChanged.new(old_directive, new_directive)
+          end
+
+          changes += removed_locations.map { |location| Changes::DirectiveLocationRemoved.new(new_directive, location) }
+          changes += added_locations.map { |location| Changes::DirectiveLocationAdded.new(new_directive, location) }
+          changes += added_arguments.map { |argument| Changes::DirectiveArgumentAdded.new(new_directive, argument) }
+          changes += removed_arguments.map { |argument| Changes::DirectiveArgumentRemoved.new(new_directive, argument) }
+
+          each_common_argument do |old_argument, new_argument|
+            changes += Diff::DirectiveArgument.new(new_directive, old_argument, new_argument).diff
+          end
+
+          changes
+        end
+
+        private
+
+        def removed_locations
+          (old_directive.locations - new_directive.locations)
+        end
+
+        def added_locations
+          (new_directive.locations - old_directive.locations)
+        end
+
+        def removed_arguments
+          old_arguments.values.select { |arg| !new_arguments[arg.name] }
+        end
+
+        def added_arguments
+          new_arguments.values.select { |arg| !old_arguments[arg.name] }
+        end
+
+        def each_common_argument(&block)
+          intersection = old_arguments.keys & new_arguments.keys
+          intersection.each do |common_arg|
+            old_arg = new_directive.arguments[common_arg]
+            new_arg = old_directive.arguments[common_arg]
+
+            block.call(old_arg, new_arg)
+          end
+        end
+
+        attr_reader(:old_directive, :new_directive, :old_arguments, :new_arguments)
+      end
+    end
+  end
+end

data/lib/graphql/schema_comparator/diff/directive_argument.rb

@@ -0,0 +1,37 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class DirectiveArgument
+        def initialize(directive, old_arg, new_arg)
+          @directive = directive
+          @old_arg = old_arg
+          @new_arg = new_arg
+        end
+
+        def diff
+          changes = []
+
+          if old_arg.description != new_arg.description
+            changes << Changes::DirectiveArgumentDescriptionChanged.new(directive, old_arg, new_arg)
+          end
+
+          if old_arg.default_value != new_arg.default_value
+            changes << Changes::DirectiveArgumentDefaultChanged.new(directive, old_arg, new_arg)
+          end
+
+          if old_arg.type != new_arg.type
+            changes << Changes::DirectiveArgumentTypeChanged.new(directive, old_arg, new_arg)
+          end
+
+          # TODO directives on directive arguments
+
+          changes
+        end
+
+        private
+
+        attr_reader(:directive, :new_arg, :old_arg)
+      end
+    end
+  end
+end

data/lib/graphql/schema_comparator/diff/field.rb

@@ -36,8 +36,6 @@ module GraphQL
             changes += Diff::Argument.new(new_type, new_field, old_arg, new_arg).diff
           end
 
-          # TODO: directives
-
           changes
         end
 

data/lib/graphql/schema_comparator/diff/schema.rb

@@ -1,12 +1,3 @@
-require "graphql/schema_comparator/diff/enum"
-require "graphql/schema_comparator/diff/union"
-require "graphql/schema_comparator/diff/input_object"
-require "graphql/schema_comparator/diff/input_field"
-require "graphql/schema_comparator/diff/object_type"
-require "graphql/schema_comparator/diff/interface"
-require "graphql/schema_comparator/diff/field"
-require "graphql/schema_comparator/diff/argument"
-
 module GraphQL
   module SchemaComparator
     module Diff
@@ -17,6 +8,9 @@ module GraphQL
 
           @old_types = old_schema.types
           @new_types = new_schema.types
+
+          @old_directives = old_schema.directives
+          @new_directives = new_schema.directives
         end
 
         def diff
@@ -86,8 +80,16 @@ module GraphQL
         end
 
         def changes_in_directives
-          # TODO
-          []
+          changes = []
+
+          changes += removed_directives.map { |directive| Changes::DirectiveRemoved.new(directive) }
+          changes += added_directives.map { |directive| Changes::DirectiveAdded.new(directive) }
+
+          each_common_directive do |old_directive, new_directive|
+            changes += Diff::Directive.new(old_directive, new_directive).diff
+          end
+
+          changes
         end
 
         private
@@ -110,7 +112,25 @@ module GraphQL
           (new_types.keys - old_types.keys).map { |type_name| new_schema.types[type_name] }
         end
 
-        attr_reader :old_schema, :new_schema, :old_types, :new_types
+        def removed_directives
+          (old_directives.keys - new_directives.keys).map { |directive_name| old_schema.directives[directive_name] }
+        end
+
+        def added_directives
+          (new_directives.keys - old_directives.keys).map { |directive_name| new_schema.directives[directive_name] }
+        end
+
+        def each_common_directive(&block)
+          intersection = old_directives.keys & new_directives.keys
+          intersection.each do |common_directive_name|
+            old_directive = old_schema.directives[common_directive_name]
+            new_directive = new_schema.directives[common_directive_name]
+
+            block.call(old_directive, new_directive)
+          end
+        end
+
+        attr_reader :old_schema, :new_schema, :old_types, :new_types, :old_directives, :new_directives
       end
     end
   end

data/lib/graphql/schema_comparator/result.rb

@@ -4,8 +4,8 @@ module GraphQL
       attr_reader :changes, :breaking_changes, :non_breaking_changes
 
       def initialize(changes)
-        @changes = changes.sort_by { |c| [c.breaking ? 1 : 2, c.message] }
-        @breaking_changes, @non_breaking_changes = @changes.partition(&:breaking)
+        @changes = changes.sort_by { |c| [c.breaking? ? 1 : 2, c.message] }
+        @breaking_changes, @non_breaking_changes = @changes.partition(&:breaking?)
       end
 
       def identical?

data/lib/graphql/schema_comparator/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module SchemaComparator
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-schema_comparator
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Marc-Andre Giroux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -118,8 +118,11 @@ files:
 - lib/graphql/schema_comparator.rb
 - lib/graphql/schema_comparator/changes.rb
 - lib/graphql/schema_comparator/diff/argument.rb
+- lib/graphql/schema_comparator/diff/directive.rb
+- lib/graphql/schema_comparator/diff/directive_argument.rb
 - lib/graphql/schema_comparator/diff/enum.rb
 - lib/graphql/schema_comparator/diff/field.rb
+- lib/graphql/schema_comparator/diff/has_directives.rb
 - lib/graphql/schema_comparator/diff/input_field.rb
 - lib/graphql/schema_comparator/diff/input_object.rb
 - lib/graphql/schema_comparator/diff/interface.rb
@@ -149,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Compare GraphQL schemas and get the changes that happened.