Examples with LanguageModel org.apache.camel.tooling.model.LanguageModel used on opensource projects

Example 1 with LanguageModel

use of org.apache.camel.tooling.model.LanguageModel in project camel-quarkus by apache.

the class CqCatalog method serialize.

static void serialize(final Path catalogPath, ArtifactModel<?> model) {
    final Path out = catalogPath.resolve(model.getKind() + "s").resolve(model.getName() + ".json");
    try {
        Files.createDirectories(out.getParent());
    } catch (IOException e) {
        throw new RuntimeException("Could not create " + out.getParent(), e);
    }
    String rawJson;
    switch(Kind.valueOf(model.getKind())) {
        case component:
            rawJson = JsonMapper.createParameterJsonSchema((ComponentModel) model);
            break;
        case language:
            rawJson = JsonMapper.createParameterJsonSchema((LanguageModel) model);
            break;
        case dataformat:
            rawJson = JsonMapper.createParameterJsonSchema((DataFormatModel) model);
            break;
        case other:
            rawJson = JsonMapper.createJsonSchema((OtherModel) model);
            break;
        default:
            throw new IllegalStateException("Cannot serialize kind " + model.getKind());
    }
    try {
        Files.write(out, rawJson.getBytes(StandardCharsets.UTF_8));
    } catch (IOException e) {
        throw new RuntimeException("Could not write to " + out, e);
    }
}

Example 2 with LanguageModel

use of org.apache.camel.tooling.model.LanguageModel in project camel-quarkus by apache.

the class PrepareCatalogQuarkusMojo method execute.

@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    final Path catalogPath = catalogBaseDir.toPath().resolve(CqCatalog.CQ_CATALOG_DIR);
    final Map<String, Set<String>> schemesByKind = new LinkedHashMap<>();
    CqCatalog.kinds().forEach(kind -> schemesByKind.put(kind.name(), new TreeSet<>()));
    final CqCatalog catalog = CqCatalog.findFirstFromClassPath();
    if (extendClassPathCatalog) {
        catalog.store(catalogBaseDir.toPath());
        catalog.models().forEach(model -> schemesByKind.get(model.getKind()).add(model.getName()));
    }
    findExtensions().forEach(ext -> {
        final String artifactIdBase = ext.getArtifactIdBase();
        final Path schemaFile = ext.getExtensionDir().resolve("component/src/generated/resources/org/apache/camel/component/" + artifactIdBase + "/" + artifactIdBase + ".json").toAbsolutePath().normalize();
        if (Files.isRegularFile(schemaFile)) {
            try {
                final String schema = new String(Files.readAllBytes(schemaFile), StandardCharsets.UTF_8);
                final String capBase = artifactIdBase.substring(0, 1).toUpperCase() + artifactIdBase.substring(1);
                getLog().debug("Adding an extra component " + artifactIdBase + " " + "org.apache.camel.component." + artifactIdBase + "." + capBase + "Component " + schema);
                catalog.addComponent(artifactIdBase, "org.apache.camel.component." + artifactIdBase + "." + capBase + "Component", schema);
            } catch (IOException e) {
                throw new RuntimeException("Could not read " + schemaFile, e);
            }
        }
    });
    findExtensions().forEach(extPath -> {
        final String artifactIdBase = extPath.getArtifactIdBase();
        final List<ArtifactModel<?>> models = catalog.filterModels(artifactIdBase).collect(Collectors.toList());
        final Path runtimePomXmlPath = extPath.getExtensionDir().resolve("runtime/pom.xml").toAbsolutePath().normalize();
        final CamelQuarkusExtension ext = CamelQuarkusExtension.read(runtimePomXmlPath);
        final boolean nativeSupported = ext.isNativeSupported();
        if (models.isEmpty()) {
            final ArtifactModel<?> model;
            final Kind extKind = ext.getKind();
            if (extKind == Kind.component) {
                model = new ComponentModel();
            } else if (extKind == Kind.language) {
                model = new LanguageModel();
            } else if (extKind == Kind.dataformat) {
                model = new DataFormatModel();
            } else {
                model = new OtherModel();
            }
            final String name = ext.getRuntimeArtifactId().replace("camel-quarkus-", "");
            model.setName(name);
            final String title = ext.getName().orElseThrow(() -> new RuntimeException("name is missing in " + ext.getRuntimePomXmlPath()));
            model.setTitle(title);
            model.setDescription(ext.getDescription().orElseThrow(() -> new RuntimeException("description is missing in " + ext.getRuntimePomXmlPath())));
            model.setDeprecated(CqUtils.isDeprecated(title, models, ext.isDeprecated()));
            model.setLabel(ext.getLabel().orElse("quarkus"));
            update(model, ext, nativeSupported);
            CqCatalog.serialize(catalogPath, model);
            schemesByKind.get(model.getKind()).add(model.getName());
        } else {
            for (ArtifactModel<?> model : models) {
                update(model, ext, nativeSupported);
                CqCatalog.serialize(catalogPath, model);
                schemesByKind.get(model.getKind()).add(model.getName());
            }
        }
    });
    CqCatalog.kinds().forEach(kind -> {
        final Path newCatalog = catalogPath.resolve(kind.name() + "s.properties");
        try {
            Files.createDirectories(newCatalog.getParent());
            Files.write(newCatalog, schemesByKind.get(kind.name()).stream().collect(Collectors.joining("\n")).getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            throw new RuntimeException("Could not write to " + newCatalog);
        }
    });
}

Example 3 with LanguageModel

use of org.apache.camel.tooling.model.LanguageModel in project camel-spring-boot by apache.

the class SpringBootAutoConfigurationMojo method executeLanguages.

private void executeLanguages(JarFile componentJar, Map<String, Supplier<String>> jsonFiles) throws MojoFailureException {
    // find the language names
    List<String> languageNames = findLanguageNames(componentJar);
    // create auto configuration for the languages
    if (!languageNames.isEmpty()) {
        getLog().debug("Found " + languageNames.size() + " languages");
        List<LanguageModel> allModels = new LinkedList<>();
        for (String languageName : languageNames) {
            String json = loadLanguageJson(jsonFiles, languageName);
            if (json != null) {
                LanguageModel model = JsonMapper.generateLanguageModel(json);
                allModels.add(model);
            }
        }
        // Group the models by implementing classes
        Map<String, List<LanguageModel>> grModels = allModels.stream().collect(Collectors.groupingBy(LanguageModel::getJavaType));
        for (String languageClass : grModels.keySet()) {
            List<LanguageModel> dfModels = grModels.get(languageClass);
            // They should be
            LanguageModel model = dfModels.get(0);
            // equivalent
            List<String> aliases = dfModels.stream().map(LanguageModel::getName).sorted().collect(Collectors.toList());
            // use springboot as sub package name so the code is not in
            // normal
            // package so the Spring Boot JARs can be optional at runtime
            int pos = model.getJavaType().lastIndexOf(".");
            String pkg = model.getJavaType().substring(0, pos) + ".springboot";
            String overrideLanguageName = null;
            if (aliases.size() > 1) {
                // determine language name when there are multiple ones
                overrideLanguageName = model.getArtifactId().replace("camel-", "");
            }
            boolean complexOptions = model.getOptions().stream().anyMatch(this::isComplexType);
            createLanguageConfigurationSource(pkg, model, overrideLanguageName);
            createLanguageAutoConfigurationSource(pkg, model, overrideLanguageName, complexOptions);
            if (complexOptions) {
                createLanguageConverterSource(pkg, model);
            }
            createLanguageSpringFactorySource(pkg, model);
        }
    }
}