/** * Creates a new instance. * * @param body body (content) of the generated result * @param executable {@code true} if the generated result should be specified as executable when * persisted to a file, {@code false} otherwise * @param <T> class which represents result body, usually {@code Doc} or {@code byte[]} */ public static <T> GeneratedResult<T> create(T body, boolean executable) { return new AutoValue_GeneratedResult<>(body, executable); }
/** * Converts a map of results (body plus properties) to a map of bodies (stripping properties). * * @param results results map to convert * @param <T> class which represents result body */ public static <T> Map<String, T> extractBodies(Map<String, GeneratedResult<T>> results) { ImmutableMap.Builder<String, T> extractedResults = ImmutableMap.builder(); for (Map.Entry<String, GeneratedResult<T>> entry : results.entrySet()) { extractedResults.put(entry.getKey(), Objects.requireNonNull(entry.getValue().getBody())); } return extractedResults.build(); }
@Override protected Map<String, ?> run() throws IOException { Map<String, Object> output = new LinkedHashMap<>(); for (CodeGenerator<?> generator : discoGapicGenerators) { Map<String, ? extends GeneratedResult<?>> out = generator.generate(); for (Map.Entry<String, ? extends GeneratedResult<?>> entry : out.entrySet()) { Object value = (entry.getValue().getBody() instanceof byte[]) ? "Static or binary file content is not shown." : entry.getValue().getBody(); output.put(entry.getKey(), value); } } return output; }
@Override public Map<String, GeneratedResult<byte[]>> generate() throws IOException { ImmutableMap.Builder<String, GeneratedResult<byte[]>> results = ImmutableMap.builder(); for (Map.Entry<String, byte[]> entry : resourcesExtractor.getResources().entrySet()) { GeneratedResult<byte[]> result = GeneratedResult.create(entry.getValue(), executableFilenames.contains(entry.getKey())); results.put(entry.getKey(), result); } return results.build(); } }
public int run() throws Exception { String discoveryDocPath = options.get(DISCOVERY_DOC); List<String> configFileNames = options.get(GENERATOR_CONFIG_FILES); String packageConfig2File = options.get(PACKAGE_CONFIG2_FILE); String languageStr = options.get(LANGUAGE); List<String> enabledArtifacts = options.get(ENABLED_ARTIFACTS); List<CodeGenerator<?>> generators = getGenerators( discoveryDocPath, configFileNames, packageConfig2File, null, languageStr, enabledArtifacts, artifactType); Map<String, Object> outputFiles = Maps.newHashMap(); for (CodeGenerator<?> generator : generators) { outputFiles.putAll(GeneratedResult.extractBodies(generator.generate())); } writeCodeGenOutput(outputFiles, options.get(OUTPUT_FILE)); return 0; }
protected Map<String, GeneratedResult<Doc>> generate(Model model) throws IOException { TargetLanguage language = TargetLanguage.fromString(options.get(LANGUAGE)); PackageGeneratorFactory.create(language, artifactType, options, model, config); return generator.generate();
new PackageGeneratorApp(options, dependenciesYamlUrl).generate(model); if (TargetLanguage.fromString(language) == TargetLanguage.PYTHON) { OutputCollector collector = new OutputCollector(Paths.get(outFile)); Files.walkFileTree(Paths.get(outFile), collector); return new ImmutableMap.Builder<String, Doc>() .putAll(GeneratedResult.extractBodies(generatedDocs)) .putAll(GeneratedResult.extractBodies(collector.getResults())) .build(); } else { return new ImmutableMap.Builder<String, Doc>() .putAll(GeneratedResult.extractBodies(generatedDocs)) .build();
public DiscoGapicTestBase( TargetLanguage language, String name, String discoveryDocFileName, String[] gapicConfigFileNames, String packageConfigFileName) { this.language = language; this.name = name; this.discoveryDocFileName = discoveryDocFileName; this.gapicConfigFileNames = gapicConfigFileNames; this.packageConfigFileName = packageConfigFileName; String dir = language.toString().toLowerCase(); getTestDataLocator().addTestDataSource(getClass(), "testdata"); getTestDataLocator().addTestDataSource(getClass(), "testdata/" + dir); }
/** * Transforms entries of the input map into TargetLanguage, taking into account an optional * default setting. */ static <V> Map<TargetLanguage, V> buildMapWithDefault(Map<String, V> inputMap) { Map<TargetLanguage, V> outputMap = new HashMap<>(); if (inputMap == null) { return outputMap; } Set<TargetLanguage> configuredLanguages = new HashSet<>(); V defaultValue = null; for (Map.Entry<String, V> entry : inputMap.entrySet()) { if (entry.getKey().equals(CONFIG_KEY_DEFAULT)) { defaultValue = entry.getValue(); } else { TargetLanguage targetLanguage = TargetLanguage.fromString(entry.getKey()); configuredLanguages.add(targetLanguage); outputMap.put(targetLanguage, entry.getValue()); } for (TargetLanguage language : TargetLanguage.values()) { if (!configuredLanguages.contains(language)) { outputMap.put(language, defaultValue); } } } return outputMap; } }
snippetNames.addAll(generator.getInputFileNames()); language.toString().toLowerCase() + "_" + apiName + gapic_config_missing + ".baseline"; baseNames = Lists.asList(apiName, baseNames).toArray(new String[0]);
@Override protected void process() throws Exception { model.establishStage(Merged.KEY); if (model.getDiagReporter().getDiagCollector().getErrorCount() > 0) { for (Diag diag : model.getDiagReporter().getDiagCollector().getDiags()) { System.err.println(diag.toString()); } return; } Map<String, GeneratedResult<Doc>> results = generate(model); ToolUtil.writeFiles(GeneratedResult.extractBodies(results), options.get(OUTPUT_DIR)); }
List<LanguageSettingView> generateLanguageSettings(String packageName) { ImmutableList.Builder<LanguageSettingView> languageSettings = ImmutableList.builder(); for (Map.Entry<TargetLanguage, LanguageFormatter> entry : LANGUAGE_FORMATTERS.entrySet()) { LanguageFormatter languageFormatter = entry.getValue(); languageSettings.add( LanguageSettingView.newBuilder() .language(entry.getKey().name().toLowerCase()) .packageName(languageFormatter.getFormattedPackageName(packageName)) .build()); } return languageSettings.build(); } }
@Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) { // Top-level dir doesn't need an __init__.py if (dir.equals(inputPath)) { return FileVisitResult.CONTINUE; } String outFile = inputPath.relativize(dir.resolve("__init__.py")).toString(); // Version directory gets an empty __init__.py if (dir.getFileName().toString().equals(apiVersion)) { docBuilder.put(outFile, GeneratedResult.create(Doc.text("\n"), false)); // All others get become namespace packages } else { docBuilder.put( outFile, GeneratedResult.create( Doc.text("__import__('pkg_resources').declare_namespace(__name__)\n"), false)); pythonNamespacePackages.add(Joiner.on(".").join(inputPath.relativize(dir).iterator())); } return FileVisitResult.CONTINUE; }
public GapicTestBase2( TargetLanguage language, String[] gapicConfigFileNames, String packageConfigFileName, List<String> snippetNames, String baselineFile, String protoPackage, String clientPackage) { this.language = language; this.gapicConfigFileNames = gapicConfigFileNames; this.packageConfigFileName = packageConfigFileName; this.snippetNames = ImmutableList.copyOf(snippetNames); this.baselineFile = baselineFile; this.clientPackage = clientPackage; // Represents the test value for the --package flag. this.protoPackage = protoPackage; String dir = language.toString().toLowerCase(); if ("python".equals(dir)) { dir = "py"; } getTestDataLocator().addTestDataSource(CodegenTestUtil.class, dir); getTestDataLocator().addTestDataSource(getClass(), "testdata/" + dir); getTestDataLocator().addTestDataSource(CodegenTestUtil.class, "testsrc/common"); }
private Map<String, Doc> generateConfig(String outputPath) { Document document = setupDocument(options.get(DiscoGapicGeneratorApp.DISCOVERY_DOC), getDiagCollector()); ViewModel viewModel = new DiscoConfigTransformer().generateConfig(new DiscoApiModel(document, ""), outputPath); Map<String, GeneratedResult<Doc>> generatedConfig = new CommonSnippetSetRunner(new CommonRenderingUtil(), true).generate(viewModel); return GeneratedResult.extractBodies(generatedConfig); }
public ConfigNode mergeLanguageSettings( final String packageName, ConfigNode configNode, ConfigNode prevNode) { FieldConfigNode languageSettingsNode = MissingFieldTransformer.insert("language_settings", configNode, prevNode).generate(); if (NodeFinder.hasContent(languageSettingsNode.getChild())) { return languageSettingsNode; } ConfigNode languageSettingsValueNode = ListTransformer.generateList( LANGUAGE_FORMATTERS.entrySet(), languageSettingsNode, (startLine, entry) -> { ConfigNode languageNode = new FieldConfigNode(startLine, entry.getKey().name().toLowerCase()); mergeLanguageSetting(languageNode, entry.getValue(), packageName); return languageNode; }); return languageSettingsNode .setChild(languageSettingsValueNode) .setComment(new DefaultComment("The settings of generated code in a specific language.")); }
@Override @SuppressWarnings("unchecked") public Map<String, GeneratedResult<Doc>> generate( ElementT element, String snippetFileName, CodegenContext context) { ClientConfigSnippetSet<ElementT> snippets = SnippetSet.createSnippetInterface( ClientConfigSnippetSet.class, resourceRoot, snippetFileName, ImmutableMap.of("context", context)); String outputFilename = snippets.generateFilename(element).prettyPrint(); Doc body = snippets.generateBody(element); return body == null || body.isWhitespace() ? ImmutableMap.of() : ImmutableMap.of(outputFilename, GeneratedResult.create(body, false)); } }
protected void setupDiscovery() { for (String fileName : gapicConfigFileNames) { this.gapicConfigFilePaths.add(getTestDataLocator().findTestData(fileName).getFile()); } try { discoGapicGenerators = DiscoGapicGeneratorApp.getGenerators( getTestDataLocator().findTestData(discoveryDocFileName).getPath(), gapicConfigFilePaths, getTestDataLocator().findTestData(packageConfigFileName).getPath(), getTestDataLocator() .findTestData("com/google/api/codegen/testsrc/common/frozen_dependencies.yaml") .getPath(), language.toString().toLowerCase(), Collections.emptyList(), ArtifactType.LEGACY_DISCOGAPIC_AND_PACKAGE); } catch (IOException e) { throw new IllegalArgumentException("Problem creating DiscoGapic generator.", e); } config = CodegenTestUtil.readConfig( new SimpleDiagCollector(), getTestDataLocator(), gapicConfigFileNames); if (config == null) { throw new IllegalArgumentException("Problem fetching or parsing Gapic config files."); } }
public Map<String, GeneratedResult<Doc>> generate(ViewModel input) { SurfaceSnippetSet snippets = SnippetSet.createSnippetInterface( SurfaceSnippetSet.class, input.resourceRoot(), input.templateFileName(), ImmutableMap.of("util", utilObject)); Doc doc = snippets.generate(input); return doc == null || doc.isWhitespace() && !allowEmptyDocs ? ImmutableMap.of() : ImmutableMap.of(input.outputPath(), GeneratedResult.create(doc, false)); }
@Override public FileVisitResult visitFile(Path file, BasicFileAttributes attr) throws IOException { String filename = testDir.relativize(file).toString(); Doc doc = Doc.text(new String(Files.readAllBytes(file))); collectedFiles.put(filename, GeneratedResult.create(doc, false)); return FileVisitResult.CONTINUE; }