code review fixes

Author: yarinvak

README.md

@@ -427,7 +427,7 @@ For example, we wish to create a directive that adds suffix to graphql fields.
 ```
 
 - must be annotated with `@GraphQLDirectiveDefinition` and to supply a wiring class to it (will be explained later)
-- the name of the directive will be taken from the class name `(Suffix)` or if annotated with `@GraphQLName` - from its value
+- the name of the directive will be taken from the class name (`Suffix`) or if annotated with `@GraphQLName` - from its value
 - the description is taken from the `@GraphQLDescription` annotation
 - must be annotated with `@Retention` with a `RUNTIME` policy
 - must be annotated with `@DirectiveLocations` in order to specify where we can put this directive on (for example - field definition, interface)

src/main/java/graphql/annotations/processor/GraphQLAnnotations.java

@@ -14,8 +14,8 @@
  */
 package graphql.annotations.processor;
 
-import graphql.annotations.annotationTypes.directives.definition.GraphQLDirectiveDefinition;
 import graphql.annotations.annotationTypes.GraphQLName;
+import graphql.annotations.annotationTypes.directives.definition.GraphQLDirectiveDefinition;
 import graphql.annotations.processor.directives.CommonPropertiesCreator;
 import graphql.annotations.processor.directives.DirectiveArgumentCreator;
 import graphql.annotations.processor.directives.DirectiveCreator;
@@ -49,6 +49,7 @@
  */
 public class GraphQLAnnotations implements GraphQLAnnotationsProcessor {
 
+    public static final String NOT_PROPERLY_ANNOTATION_ERROR = "The supplied class %s is not annotated with a GraphQLDirectiveDefinition annotation";
     private GraphQLObjectHandler graphQLObjectHandler;
     private GraphQLExtensionsHandler graphQLExtensionsHandler;
     private DirectiveCreator directiveCreator;
@@ -131,7 +132,7 @@ public GraphQLObjectType object(Class<?> object) throws GraphQLAnnotationsExcept
 
     @Deprecated
     public GraphQLObjectType object(Class<?> object, DirectiveAndWiring... directives) throws GraphQLAnnotationsException {
-        Arrays.stream(directives).forEach(directive -> this.getContainer().getDirectiveRegistry().put(directive.getDirective().getName(), directive));
+        Arrays.stream(directives).forEach(directiveAndWiring -> this.getContainer().getDirectiveRegistry().put(directiveAndWiring.getDirective().getName(), directiveAndWiring));
         try {
             return this.graphQLObjectHandler.getGraphQLType(object, this.getContainer());
         } catch (GraphQLAnnotationsException e) {
@@ -143,7 +144,7 @@ public GraphQLObjectType object(Class<?> object, DirectiveAndWiring... directive
 
     public GraphQLDirective directive(Class<?> object) throws GraphQLAnnotationsException {
         if (!object.isAnnotationPresent(GraphQLDirectiveDefinition.class)){
-            throw new GraphQLAnnotationsException(String.format("The supplied class %s is not annotated with a GraphQLDirectiveDefinition annotation", object.getSimpleName()), null);
+            throw new GraphQLAnnotationsException(String.format(NOT_PROPERLY_ANNOTATION_ERROR, object.getSimpleName()), null);
         }
 
         try {
@@ -181,9 +182,9 @@ public Set<GraphQLDirective> directives(Class<?> directivesDeclarationClass) {
         Arrays.stream(methods).sequential().filter(method -> method.isAnnotationPresent(GraphQLDirectiveDefinition.class))
                 .forEach(method -> {
                     try {
-                        DirectiveAndWiring directive = this.directiveCreator.getDirective(method);
-                        this.getContainer().getDirectiveRegistry().put(directive.getDirective().getName(), directive);
-                        directiveSet.add(directive.getDirective());
+                        DirectiveAndWiring directiveAndWiring = this.directiveCreator.getDirectiveAndWiring(method);
+                        this.getContainer().getDirectiveRegistry().put(directiveAndWiring.getDirective().getName(), directiveAndWiring);
+                        directiveSet.add(directiveAndWiring.getDirective());
                     } catch (GraphQLAnnotationsException e) {
                         this.getContainer().getProcessing().clear();
                         this.getTypeRegistry().clear();

src/main/java/graphql/annotations/processor/directives/DirectiveCreator.java

@@ -14,16 +14,15 @@
  */
 package graphql.annotations.processor.directives;
 
+import graphql.annotations.annotationTypes.directives.definition.DirectiveLocations;
 import graphql.annotations.annotationTypes.directives.definition.GraphQLDirectiveDefinition;
 import graphql.annotations.directives.AnnotationsDirectiveWiring;
-import graphql.annotations.annotationTypes.directives.definition.DirectiveLocations;
 import graphql.annotations.processor.DirectiveAndWiring;
 import graphql.annotations.processor.exceptions.GraphQLAnnotationsException;
 import graphql.introspection.Introspection;
 import graphql.schema.GraphQLDirective;
 
 import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Method;
 import java.util.Arrays;
@@ -56,7 +55,7 @@ public GraphQLDirective getDirective(Class<?> annotatedClass) {
         return builder.build();
     }
 
-    public DirectiveAndWiring getDirective(Method directiveMethod){
+    public DirectiveAndWiring getDirectiveAndWiring(Method directiveMethod){
         GraphQLDirective.Builder builder = newDirective()
                 .name(commonPropertiesCreator.getName(directiveMethod))
                 .description(commonPropertiesCreator.getDescription(directiveMethod));

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/DirectivesBuilder.java

@@ -35,6 +35,10 @@
 
 
 public class DirectivesBuilder implements Builder<GraphQLDirective[]> {
+    public static final String NOT_FOUND_IN_DIRECTIVE_REGISTRY_ERROR = "No directive named %s is found in the directive registry";
+    public static final String TOO_MUCH_ARGUMENTS_ERROR = "Directive '%s' is supplied with more argument values than it supports";
+    public static final String DIRECTIVE_ARGUMENT_TYPE_MUST_BE_A_SCALAR = "Directive argument type must be a scalar!";
+    public static final String COULD_NOT_PARSE_ARGUMENT_VALUE_TO_ARGUMENT_TYPE = "Could not parse argument value to argument type";
     private AnnotatedElement object;
     private ProcessingElementsContainer container;
 
@@ -54,7 +58,7 @@ public GraphQLDirective[] build() {
                         GraphQLDirective graphQLDirective = transformArgs(container.getDirectiveRegistry().get(name).getDirective(), annotation);
                         graphQLDirectives.add(graphQLDirective);
                     } else {
-                        throw new GraphQLAnnotationsException(String.format("No directive named %s is found in the directive registry", name), null);
+                        throw new GraphQLAnnotationsException(String.format(NOT_FOUND_IN_DIRECTIVE_REGISTRY_ERROR, name), null);
                     }
                 });
 
@@ -66,7 +70,7 @@ public GraphQLDirective[] build() {
                                 if (container.getDirectiveRegistry().containsKey(x.name())) {
                                     return transformArgs(container.getDirectiveRegistry().get(x.name()).getDirective(), x.argumentsValues());
                                 } else {
-                                    throw new GraphQLAnnotationsException(String.format("No directive named %s is found in the directive registry", x.name()), null);
+                                    throw new GraphQLAnnotationsException(String.format(NOT_FOUND_IN_DIRECTIVE_REGISTRY_ERROR, x.name()), null);
                                 }
                             }
                     ).collect(Collectors.toList());
@@ -84,7 +88,7 @@ private GraphQLDirective transformArgs(GraphQLDirective graphQLDirective, Annota
         List<GraphQLArgument> arguments = graphQLDirective.getArguments();
 
         if (annotation.annotationType().getDeclaredMethods().length > arguments.size()) {
-            throw new GraphQLAnnotationsException(String.format("Directive '%s' is supplied with more argument values than it supports", graphQLDirective.getName()), null);
+            throw new GraphQLAnnotationsException(String.format(TOO_MUCH_ARGUMENTS_ERROR, graphQLDirective.getName()), null);
         }
 
         for (int i = 0; i < annotation.annotationType().getDeclaredMethods().length; i++) {
@@ -105,7 +109,7 @@ private GraphQLDirective transformArgs(GraphQLDirective graphQLDirective, String
         List<GraphQLArgument> arguments = graphQLDirective.getArguments();
 
         if (argumentValues.length > arguments.size()) {
-            throw new GraphQLAnnotationsException(String.format("Directive '%s' is supplied with more argument values than it supports", graphQLDirective.getName()), null);
+            throw new GraphQLAnnotationsException(String.format(TOO_MUCH_ARGUMENTS_ERROR, graphQLDirective.getName()), null);
         }
 
         for (int i = 0; i < argumentValues.length; i++) {
@@ -138,10 +142,10 @@ private void transformArgument(Annotation annotation, GraphQLDirective.Builder d
                     }
                     builder.value(value);
                 } catch (Exception e) {
-                    throw new GraphQLAnnotationsException("Could not parse argument value to argument type", e);
+                    throw new GraphQLAnnotationsException(COULD_NOT_PARSE_ARGUMENT_VALUE_TO_ARGUMENT_TYPE, e);
                 }
             } else {
-                throw new GraphQLAnnotationsException("Directive argument type must be a scalar!", null);
+                throw new GraphQLAnnotationsException(DIRECTIVE_ARGUMENT_TYPE_MUST_BE_A_SCALAR, null);
             }
         }));
     }
@@ -159,10 +163,10 @@ private void transformArgument(String[] argumentValues, GraphQLDirective.Builder
                     Object value = ((GraphQLScalarType) graphQLArgument.getType()).getCoercing().parseValue(argumentValue);
                     builder.value(value);
                 } catch (Exception e) {
-                    throw new GraphQLAnnotationsException("Could not parse argument value to argument type", e);
+                    throw new GraphQLAnnotationsException(COULD_NOT_PARSE_ARGUMENT_VALUE_TO_ARGUMENT_TYPE, e);
                 }
             } else {
-                throw new GraphQLAnnotationsException("Directive argument type must be a scalar!", null);
+                throw new GraphQLAnnotationsException(DIRECTIVE_ARGUMENT_TYPE_MUST_BE_A_SCALAR, null);
             }
         }));
     }