2150

Committed 08 Apr 2024 05:09PM CUT coverage: 98.082%. Remained the same

Build # 2150

Build Type

push

circleci

Committed by

web-flow

Commit Message

Update dependency commons-io:commons-io to v2.16.1

Run Details

818 of 834 relevant lines covered (98.08%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/sorter/src/main/java/sortgraphql/SorterService.java

package sortgraphql;

import static java.util.stream.Collectors.joining;

import graphql.language.*;
import graphql.schema.*;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaGenerator.Options;
import graphql.schema.idl.TypeDefinitionRegistry;
import graphql.schema.idl.errors.SchemaProblem;
import java.io.File;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import sortgraphql.exception.FailureException;
import sortgraphql.logger.SortingLogger;
import sortgraphql.parameter.PluginParameters;
import sortgraphql.sort.FakeRuntimeWiringFactory;
import sortgraphql.sort.OptionsBuilder;
import sortgraphql.sort.SchemaParser;
import sortgraphql.sort.SchemaPrinter;
import sortgraphql.util.FileUtil;

/** Contain the concrete methods to sort the schema */
public class SorterService {

  private static final Options SCHEMA_GENERATOR_OPTIONS =
      Options.defaultOptions().useCommentsAsDescriptions(false);
  private final FileUtil fileUtil = new FileUtil();
  private final FakeRuntimeWiringFactory wiringFactory = new FakeRuntimeWiringFactory();

  private SortingLogger log;

  private boolean createBackupFile;
  private String backupFileExtension;
  private boolean skipUnionTypeSorting;
  private boolean skipFieldArgumentSorting;
  private boolean generateSchemaDefinition;
  private boolean generateAllDirectiveDefinitions;
  private boolean descriptionsAsHashComments;

  public void setup(SortingLogger log, PluginParameters pluginParameters) {
    this.log = log;
    this.createBackupFile = pluginParameters.createBackupFile;
    this.backupFileExtension = pluginParameters.backupFileExtension;
    this.skipUnionTypeSorting = pluginParameters.skipUnionTypeSorting;
    this.skipFieldArgumentSorting = pluginParameters.skipFieldArgumentSorting;
    this.generateSchemaDefinition = pluginParameters.generateSchemaDefinition;
    this.generateAllDirectiveDefinitions = pluginParameters.generateAllDirectiveDefinitions;
    this.descriptionsAsHashComments = pluginParameters.descriptionsAsHashComments;

    fileUtil.setup(pluginParameters);
  }

  public Map<File, String> getSchemaContents(List<File> schemaFiles) {
    return schemaFiles.stream()
        .collect(
            Collectors.toMap(
                file -> file, fileUtil::getSchemaContent, (s1, s2) -> s1, LinkedHashMap::new));
  }

  public GraphQLSchema createMergedSchema(Collection<String> schemaContents, List<File> fileNames) {
    var registry = new TypeDefinitionRegistry();

    var nameIterator = fileNames.iterator();
    var schemaParser = new SchemaParser();
    schemaContents.forEach(
        schemaContent ->
            registry.merge(schemaParser.parse(schemaContent, nameIterator.next().getName())));

    addArtificialQueryTypeIfMissing(registry);

    var runtimeWiring = wiringFactory.createFakeRuntime(registry);

    try {
      return new SchemaGenerator()
          .makeExecutableSchema(SCHEMA_GENERATOR_OPTIONS, registry, runtimeWiring);
    } catch (SchemaProblem schemaProblem) {
      throw new FailureException(
          String.format(
              "Cannot process schema from filename '%s', %s",
              fileNames.stream().map(File::toString).collect(joining(", ")),
              schemaProblem.getMessage()));
    }
  }

  private void addArtificialQueryTypeIfMissing(TypeDefinitionRegistry registry) {
    var queryType = registry.getType("Query");
    if (queryType.isEmpty()) {
      registry.add(
          ObjectTypeDefinition.newObjectTypeDefinition()
              .name("Query")
              .sourceLocation(new SourceLocation(0, 0, "internal_artificial_type"))
              .fieldDefinitions(
                  List.of(new FieldDefinition("internal_artificial_field", new TypeName("Int"))))
              .build());
    }
  }

  public String sortSchema(GraphQLSchema graphQLSchema, String schemaFileName) {
    var options =
        OptionsBuilder.defaultOptions()
            .setIncludeDirectiveDefinitions(generateAllDirectiveDefinitions)
            .setIncludeDefinedDirectiveDefinitions(true)
            .setDescriptionsAsHashComments(descriptionsAsHashComments)
            .setIncludeSchemaDefinition(generateSchemaDefinition);

    if (skipUnionTypeSorting) {
      var environment =
          GraphqlTypeComparatorEnvironment.newEnvironment()
              .parentType(GraphQLUnionType.class)
              .elementType(GraphQLOutputType.class)
              .build();
      options =
          options.addComparatorToRegistry(
              environment, (Comparator<GraphQLOutputType>) (o1, o2) -> 0);
    }
    if (skipFieldArgumentSorting) {
      var environment =
          GraphqlTypeComparatorEnvironment.newEnvironment()
              .parentType(GraphQLFieldDefinition.class)
              .elementType(GraphQLArgument.class)
              .build();
      options =
          options.addComparatorToRegistry(environment, (Comparator<GraphQLArgument>) (o1, o2) -> 0);
    }
    options = options.setNodeDescriptionFilter(sourceLocationPredicate(schemaFileName));

    return new SchemaPrinter(options.build()).print(graphQLSchema);
  }

  private Predicate<AbstractDescribedNode<?>> sourceLocationPredicate(String schemaFileName) {
    return node -> {
      if (node == null || node.getSourceLocation() == null) {
        // If we cannot find description or source location, just print the node
        return true;
      }
      return schemaFileName.equals(node.getSourceLocation().getSourceName());
    };
  }

  public boolean isSchemaSorted(String schemaContent, String sortedContent) {
    return schemaContent.equals(sortedContent);
  }

  public void createBackupFile(File schemaFile) {
    if (!createBackupFile) {
      return;
    }
    if (backupFileExtension.trim().length() == 0) {
      throw new FailureException("Could not create backup file, extension name was empty");
    }
    fileUtil.backupFile(schemaFile);
    log.info(
        String.format(
            "Saved backup of %s to %s%s",
            schemaFile.getAbsolutePath(), schemaFile.getAbsolutePath(), backupFileExtension));
  }

  public void saveSortedContent(String sortedContent, File schemaFile) {
    fileUtil.saveSchema(sortedContent, schemaFile);
  }
}

1	package sortgraphql;
2
3	import static java.util.stream.Collectors.joining;
4
5	import graphql.language.*;
6	import graphql.schema.*;
7	import graphql.schema.idl.SchemaGenerator;
8	import graphql.schema.idl.SchemaGenerator.Options;
9	import graphql.schema.idl.TypeDefinitionRegistry;
10	import graphql.schema.idl.errors.SchemaProblem;
11	import java.io.File;
12	import java.util.*;
13	import java.util.function.Predicate;
14	import java.util.stream.Collectors;
15	import sortgraphql.exception.FailureException;
16	import sortgraphql.logger.SortingLogger;
17	import sortgraphql.parameter.PluginParameters;
18	import sortgraphql.sort.FakeRuntimeWiringFactory;
19	import sortgraphql.sort.OptionsBuilder;
20	import sortgraphql.sort.SchemaParser;
21	import sortgraphql.sort.SchemaPrinter;
22	import sortgraphql.util.FileUtil;
23
24	/** Contain the concrete methods to sort the schema */
25	public class SorterService {	1✔
26
27	private static final Options SCHEMA_GENERATOR_OPTIONS =	1✔
28	Options.defaultOptions().useCommentsAsDescriptions(false);	1✔
29	private final FileUtil fileUtil = new FileUtil();	1✔
30	private final FakeRuntimeWiringFactory wiringFactory = new FakeRuntimeWiringFactory();	1✔
31
32	private SortingLogger log;
33
34	private boolean createBackupFile;
35	private String backupFileExtension;
36	private boolean skipUnionTypeSorting;
37	private boolean skipFieldArgumentSorting;
38	private boolean generateSchemaDefinition;
39	private boolean generateAllDirectiveDefinitions;
40	private boolean descriptionsAsHashComments;
41
42	public void setup(SortingLogger log, PluginParameters pluginParameters) {
43	this.log = log;	1✔
44	this.createBackupFile = pluginParameters.createBackupFile;	1✔
45	this.backupFileExtension = pluginParameters.backupFileExtension;	1✔
46	this.skipUnionTypeSorting = pluginParameters.skipUnionTypeSorting;	1✔
47	this.skipFieldArgumentSorting = pluginParameters.skipFieldArgumentSorting;	1✔
48	this.generateSchemaDefinition = pluginParameters.generateSchemaDefinition;	1✔
49	this.generateAllDirectiveDefinitions = pluginParameters.generateAllDirectiveDefinitions;	1✔
50	this.descriptionsAsHashComments = pluginParameters.descriptionsAsHashComments;	1✔
51
52	fileUtil.setup(pluginParameters);	1✔
53	}	1✔
54
55	public Map<File, String> getSchemaContents(List<File> schemaFiles) {
56	return schemaFiles.stream()	1✔
57	.collect(	1✔
58	Collectors.toMap(	1✔
59	file -> file, fileUtil::getSchemaContent, (s1, s2) -> s1, LinkedHashMap::new));	1✔
60	}
61
62	public GraphQLSchema createMergedSchema(Collection<String> schemaContents, List<File> fileNames) {
63	var registry = new TypeDefinitionRegistry();	1✔
64
65	var nameIterator = fileNames.iterator();	1✔
66	var schemaParser = new SchemaParser();	1✔
67	schemaContents.forEach(	1✔
68	schemaContent ->
69	registry.merge(schemaParser.parse(schemaContent, nameIterator.next().getName())));	1✔
70
71	addArtificialQueryTypeIfMissing(registry);	1✔
72
73	var runtimeWiring = wiringFactory.createFakeRuntime(registry);	1✔
74
75	try {
76	return new SchemaGenerator()	1✔
77	.makeExecutableSchema(SCHEMA_GENERATOR_OPTIONS, registry, runtimeWiring);	1✔
78	} catch (SchemaProblem schemaProblem) {	1✔
79	throw new FailureException(	1✔
80	String.format(	1✔
81	"Cannot process schema from filename '%s', %s",
82	fileNames.stream().map(File::toString).collect(joining(", ")),	1✔
83	schemaProblem.getMessage()));	1✔
84	}
85	}
86
87	private void addArtificialQueryTypeIfMissing(TypeDefinitionRegistry registry) {
88	var queryType = registry.getType("Query");	1✔
89	if (queryType.isEmpty()) {	1✔
90	registry.add(	1✔
91	ObjectTypeDefinition.newObjectTypeDefinition()	1✔
92	.name("Query")	1✔
93	.sourceLocation(new SourceLocation(0, 0, "internal_artificial_type"))	1✔
94	.fieldDefinitions(	1✔
95	List.of(new FieldDefinition("internal_artificial_field", new TypeName("Int"))))	1✔
96	.build());	1✔
97	}
98	}	1✔
99
100	public String sortSchema(GraphQLSchema graphQLSchema, String schemaFileName) {
101	var options =
102	OptionsBuilder.defaultOptions()	1✔
103	.setIncludeDirectiveDefinitions(generateAllDirectiveDefinitions)	1✔
104	.setIncludeDefinedDirectiveDefinitions(true)	1✔
105	.setDescriptionsAsHashComments(descriptionsAsHashComments)	1✔
106	.setIncludeSchemaDefinition(generateSchemaDefinition);	1✔
107
108	if (skipUnionTypeSorting) {	1✔
109	var environment =
110	GraphqlTypeComparatorEnvironment.newEnvironment()	1✔
111	.parentType(GraphQLUnionType.class)	1✔
112	.elementType(GraphQLOutputType.class)	1✔
113	.build();	1✔
114	options =	1✔
115	options.addComparatorToRegistry(	1✔
116	environment, (Comparator<GraphQLOutputType>) (o1, o2) -> 0);	1✔
117	}
118	if (skipFieldArgumentSorting) {	1✔
119	var environment =
120	GraphqlTypeComparatorEnvironment.newEnvironment()	1✔
121	.parentType(GraphQLFieldDefinition.class)	1✔
122	.elementType(GraphQLArgument.class)	1✔
123	.build();	1✔
124	options =	1✔
125	options.addComparatorToRegistry(environment, (Comparator<GraphQLArgument>) (o1, o2) -> 0);	1✔
126	}
127	options = options.setNodeDescriptionFilter(sourceLocationPredicate(schemaFileName));	1✔
128
129	return new SchemaPrinter(options.build()).print(graphQLSchema);	1✔
130	}
131
132	private Predicate<AbstractDescribedNode<?>> sourceLocationPredicate(String schemaFileName) {
133	return node -> {	1✔
134	if (node == null \|\| node.getSourceLocation() == null) {	1✔
135	// If we cannot find description or source location, just print the node
136	return true;	1✔
137	}
138	return schemaFileName.equals(node.getSourceLocation().getSourceName());	1✔
139	};
140	}
141
142	public boolean isSchemaSorted(String schemaContent, String sortedContent) {
143	return schemaContent.equals(sortedContent);	1✔
144	}
145
146	public void createBackupFile(File schemaFile) {
147	if (!createBackupFile) {	1✔
148	return;	1✔
149	}
150	if (backupFileExtension.trim().length() == 0) {	1✔
151	throw new FailureException("Could not create backup file, extension name was empty");	1✔
152	}
153	fileUtil.backupFile(schemaFile);	1✔
154	log.info(	1✔
155	String.format(	1✔
156	"Saved backup of %s to %s%s",
157	schemaFile.getAbsolutePath(), schemaFile.getAbsolutePath(), backupFileExtension));	1✔
158	}	1✔
159
160	public void saveSortedContent(String sortedContent, File schemaFile) {
161	fileUtil.saveSchema(sortedContent, schemaFile);	1✔
162	}	1✔
163	}

Ekryd / sortgraphql / 2150

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous