Remove unused projects: cli, groowt-all, groowt-gradle, groowt-gradle-model.

This commit is contained in:
Jesse Brault 2025-02-16 11:09:46 -06:00
parent eb77f0a3d7
commit abc4b971d6
22 changed files with 1 additions and 703 deletions

View File

@ -1,46 +0,0 @@
plugins {
id 'groowt-conventions'
id 'groowt-logging'
id 'groowt-publish'
}
repositories {
maven {
url 'https://repo.gradle.org/gradle/libs-releases'
}
}
dependencies {
implementation libs.gradle.tooling
implementation libs.picocli
implementation project(':groowt-gradle-model')
}
tasks.named('jar', Jar) {
manifest {
attributes('Main-Class': 'groowt.cli.GroowtCli')
}
from sourceSets.main.runtimeClasspath.filter(File.&exists).collect { it.isDirectory() ? it : zipTree(it) }
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
dependsOn ':groowt-gradle-model:jar'
}
tasks.withType(GenerateModuleMetadata).configureEach {
enabled = false
}
publishing {
publications {
create('groowtCli', MavenPublication) {
artifactId = 'groowt-cli'
from components.java
pom {
withXml {
def rootNode = asNode()
def dependenciesNode = rootNode.get('dependencies')
rootNode.remove(dependenciesNode)
}
}
}
}
}

View File

@ -1,17 +0,0 @@
package groowt.cli;
import java.io.File;
public final class FileAndPathUtil {
public static File packageNameToFile(String packageName) {
return new File(packageName.replace(".", File.separator));
}
public static File resolve(File from, File to) {
return from.toPath().resolve(to.toPath()).toFile();
}
private FileAndPathUtil() {}
}

View File

@ -1,61 +0,0 @@
package groowt.cli;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.Callable;
@Command(name = "generate", aliases = "gen", description = "Generate a component, template, model, etc.")
public final class Generate implements Callable<Integer> {
@CommandLine.ParentCommand
private GroowtCli cli;
@CommandLine.Option(
names = { "-c", "--component" },
description = "Create a component with the given name."
)
private String componentName;
@CommandLine.Option(
names = { "-s", "--sourceSet" },
description = "The source set in which to generate the component, etc.",
defaultValue = "main"
)
private String sourceSet;
@CommandLine.Option(
names = { "-d", "--srcDir", "--sourceDir", "--sourceDirectory" },
description = "The directory in the source set in which to generate the component, etc."
)
private File sourceDir;
@SuppressWarnings("ResultOfMethodCallIgnored")
@Override
public Integer call() {
if (this.componentName != null) {
GradleUtil.doWithGroowtGradleModel(this.cli.getProjectDir(), model -> {
if (this.sourceDir == null) {
this.sourceDir = new File(String.join(File.separator, "src", this.sourceSet, "groovy"));
}
final File packageDir = FileAndPathUtil.resolve(
this.sourceDir,
FileAndPathUtil.packageNameToFile(model.getBasePackage())
);
packageDir.mkdirs();
final File componentFile = new File(packageDir, this.componentName + ".txt");
try (final OutputStream componentFileOutputStream = new FileOutputStream(componentFile)) {
componentFileOutputStream.write("Hello, Groowt!".getBytes());
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
return 0;
}
}

View File

@ -1,32 +0,0 @@
package groowt.cli;
import groowt.gradle.model.GroowtGradleModel;
import org.gradle.tooling.GradleConnector;
import org.gradle.tooling.ProjectConnection;
import java.io.File;
import java.util.function.Consumer;
public final class GradleUtil {
public static void doWith(File projectDir, Consumer<? super ProjectConnection> action) {
final var gradleConnector = GradleConnector.newConnector().forProjectDirectory(projectDir);
try (final var projectConnection = gradleConnector.connect()) {
action.accept(projectConnection);
}
}
public static <T> void doWith(File projectDir, Class<? extends T> modelClass, Consumer<? super T> modelConsumer) {
doWith(projectDir, projectConnection -> {
final T model = projectConnection.getModel(modelClass);
modelConsumer.accept(model);
});
}
public static void doWithGroowtGradleModel(File projectDir, Consumer<? super GroowtGradleModel> modelConsumer) {
doWith(projectDir, GroowtGradleModel.class, modelConsumer);
}
private GradleUtil() {}
}

View File

@ -1,46 +0,0 @@
package groowt.cli;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import picocli.CommandLine;
import java.io.File;
@CommandLine.Command(
name = "groowt",
description = "The command line interface facilitating development of a Groowt project.",
mixinStandardHelpOptions = true,
version = "0.1.0",
subcommands = { Generate.class }
)
public final class GroowtCli {
private static final Logger logger = LoggerFactory.getLogger(GroowtCli.class);
@CommandLine.Option(
names = { "-v", "--verbose" },
description = "Log verbosely to standard out."
)
private boolean verbose;
@CommandLine.Option(
names = { "--projectDir" },
defaultValue = ".",
description = "The root directory of the groowt project."
)
private File projectDir;
public static void main(String[] args) {
logger.info("Hello from Groowt! Version 0.1.0");
System.exit(new CommandLine(new GroowtCli()).execute(args));
}
public boolean isVerbose() {
return this.verbose;
}
public File getProjectDir() {
return this.projectDir;
}
}

View File

@ -1,17 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">
<Appenders>
<Console name="root">
<PatternLayout>
<LevelPatternSelector defaultPattern="[%t] %-5level %logger{1.} %msg%n">
<PatternMatch key="DEBUG" pattern="[%t] %-5level %logger{1.}.%M() %msg%n"/>
</LevelPatternSelector>
</PatternLayout>
</Console>
</Appenders>
<Loggers>
<Root level="INFO">
<AppenderRef ref="root"/>
</Root>
</Loggers>
</Configuration>

View File

@ -1,23 +0,0 @@
plugins {
id 'groowt-conventions'
id 'groowt-publish'
id 'java-library'
}
dependencies {
api project(':views')
api project(':view-components')
api project(':web-view-components')
api project(':di')
api project(':extensible')
api project(':fp')
}
publishing {
publications {
create('groowtAll', MavenPublication) {
artifactId = 'all'
from components.java
}
}
}

View File

@ -1,14 +0,0 @@
plugins {
id 'groowt-conventions'
id 'java-library'
id 'groowt-publish'
}
publishing {
publications {
create('groowtGradleModel', MavenPublication) {
artifactId = 'groowt-gradle-model'
from components.java
}
}
}

View File

@ -1,32 +0,0 @@
package groowt.gradle.model;
import java.io.File;
import java.io.Serializable;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
public class DefaultGroowtGradleModel implements GroowtGradleModel, Serializable {
private String basePackage;
private Map<String, Set<File>> sourceSetToTemplatesDirs;
@Override
public String getBasePackage() {
return this.basePackage;
}
public void setBasePackage(String basePackage) {
this.basePackage = Objects.requireNonNull(basePackage);
}
@Override
public Map<String, Set<File>> getSourceSetToTemplatesDirs() {
return Objects.requireNonNull(this.sourceSetToTemplatesDirs);
}
public void setSourceFileSets(Map<String, Set<File>> sourceSetToTemplateDir) {
this.sourceSetToTemplatesDirs = sourceSetToTemplateDir;
}
}

View File

@ -1,10 +0,0 @@
package groowt.gradle.model;
import java.io.File;
import java.util.Map;
import java.util.Set;
public interface GroowtGradleModel {
String getBasePackage();
Map<String, Set<File>> getSourceSetToTemplatesDirs();
}

View File

@ -1,32 +0,0 @@
plugins {
id 'groowt-conventions'
id 'java-gradle-plugin'
id 'groowt-publish'
}
repositories {
mavenCentral()
}
dependencies {
implementation libs.groovy
implementation project(':groowt-gradle-model')
}
gradlePlugin {
plugins {
create('groowtGradle') {
id = 'groowt-gradle'
implementationClass = 'groowt.gradle.GroowtGradlePlugin'
}
}
}
publishing {
publications {
create('groowtGradlePlugin', MavenPublication) {
artifactId = 'groowt-gradle'
from components.java
}
}
}

View File

@ -1,22 +0,0 @@
package groowt.gradle;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import javax.inject.Inject;
public class DefaultGroowtExtension implements GroowtExtension {
private final Property<String> basePackage;
@Inject
public DefaultGroowtExtension(ObjectFactory objectFactory) {
this.basePackage = objectFactory.property(String.class);
}
@Override
public Property<String> getBasePackage() {
return this.basePackage;
}
}

View File

@ -1,19 +0,0 @@
package groowt.gradle;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.internal.file.DefaultSourceDirectorySet;
import org.gradle.api.internal.tasks.TaskDependencyFactory;
import javax.inject.Inject;
public class DefaultTemplateSourceDirectorySet extends DefaultSourceDirectorySet implements TemplateSourceDirectorySet {
@Inject
public DefaultTemplateSourceDirectorySet(
SourceDirectorySet delegate,
TaskDependencyFactory taskDependencyFactory
) {
super(delegate, taskDependencyFactory);
}
}

View File

@ -1,61 +0,0 @@
package groowt.gradle;
import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.reflect.HasPublicType;
import org.gradle.api.reflect.TypeOf;
import org.gradle.util.internal.ConfigureUtil;
import javax.inject.Inject;
public class DefaultTemplateSourceSet implements TemplateSourceSet, HasPublicType {
private final TemplateSourceDirectorySet templateSourceDirectorySet;
private final SourceDirectorySet allTemplates;
@Inject
public DefaultTemplateSourceSet(ObjectFactory objectFactory, String name, String displayName) {
this.templateSourceDirectorySet = objectFactory.newInstance(
DefaultTemplateSourceDirectorySet.class,
objectFactory.sourceDirectorySet(name, displayName + " ComponentTemplate sources")
);
this.templateSourceDirectorySet.getFilter().include("**/*.wvc", "**/*.gst");
this.allTemplates = objectFactory.sourceDirectorySet(
"all" + name,
displayName + " ComponentTemplate sources"
);
this.allTemplates.source(this.templateSourceDirectorySet);
this.allTemplates.getFilter().include("**/*.wvc", "**/*.gst");
}
@Override
public TypeOf<?> getPublicType() {
return TypeOf.typeOf(TemplateSourceSet.class);
}
@Override
public TemplateSourceDirectorySet getTemplates() {
return this.templateSourceDirectorySet;
}
@Override
public TemplateSourceSet templates(Action<? super TemplateSourceDirectorySet> action) {
action.execute(this.templateSourceDirectorySet);
return this;
}
@SuppressWarnings("rawtypes")
@Override
public TemplateSourceSet templates(Closure closure) {
ConfigureUtil.configure(closure, this.templateSourceDirectorySet);
return this;
}
@Override
public SourceDirectorySet getAllTemplates() {
return this.allTemplates;
}
}

View File

@ -1,7 +0,0 @@
package groowt.gradle;
import org.gradle.api.provider.Property;
public interface GroowtExtension {
Property<String> getBasePackage();
}

View File

@ -1,91 +0,0 @@
package groowt.gradle;
import groowt.gradle.model.GroowtGradleModelBuilder;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.file.FileCollection;
import org.gradle.api.internal.tasks.DefaultSourceSet;
import org.gradle.api.plugins.GroovyPlugin;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry;
import javax.inject.Inject;
import static org.gradle.api.internal.lambdas.SerializableLambdas.spec;
public class GroowtGradlePlugin implements Plugin<Project> {
private final ToolingModelBuilderRegistry modelBuilderRegistry;
@Inject
public GroowtGradlePlugin(ToolingModelBuilderRegistry modelBuilderRegistry) {
this.modelBuilderRegistry = modelBuilderRegistry;
}
@Override
public void apply(Project project) {
// Apply java and groovy plugins, if not done already
final var pluginManager = project.getPluginManager();
pluginManager.apply(JavaPlugin.class);
pluginManager.apply(GroovyPlugin.class);
// Create our groowt configuration for storing the groowt dependencies
final Provider<Configuration> groowtConfigurationProvider = project.getConfigurations()
.register("groowt", configuration -> {
configuration.setCanBeConsumed(false);
configuration.setCanBeResolved(true);
});
// Create groowt extension and source sets.
final GroowtExtension groowtExtension = project.getExtensions().create(
GroowtExtension.class,
"groowt",
DefaultGroowtExtension.class
);
groowtExtension.getBasePackage().convention("");
final JavaPluginExtension javaExtension = project.getExtensions().getByType(JavaPluginExtension.class);
final SourceSetContainer javaSourceSets = javaExtension.getSourceSets();
// data resources, such as texts, json files, sqlite-databases, etc.
javaSourceSets.getByName("main", mainSourceSet -> {
mainSourceSet.getResources().srcDir("src/data");
});
// TODO: figure out how we can set the compile behavior for all of these.
javaSourceSets.forEach(sourceSet -> {
final TemplateSourceSet templateSourceSet = project.getObjects().newInstance(
DefaultTemplateSourceSet.class,
"wvc",
((DefaultSourceSet) sourceSet).getDisplayName()
);
final TemplateSourceDirectorySet templateSourceDirectorySet = templateSourceSet.getTemplates();
sourceSet.getExtensions().add(
TemplateSourceDirectorySet.class,
"templates",
templateSourceDirectorySet
);
templateSourceDirectorySet.srcDir("src/" + sourceSet.getName() + "/templates");
// Explicitly capture only a FileCollection in the lambda below for compatibility with configuration-cache.
@SuppressWarnings("UnnecessaryLocalVariable")
final FileCollection templateSourceFiles = templateSourceDirectorySet;
sourceSet.getResources().getFilter().exclude(
spec(element -> templateSourceFiles.contains(element.getFile()))
);
sourceSet.getAllJava().source(templateSourceDirectorySet);
sourceSet.getAllSource().source(templateSourceDirectorySet);
});
// create init task
project.getTasks().create("groowtInit", GroowtInitTask.class, groowtConfigurationProvider);
// tooling models for cli
this.modelBuilderRegistry.register(new GroowtGradleModelBuilder());
}
}

View File

@ -1,95 +0,0 @@
package groowt.gradle;
import org.gradle.api.DefaultTask;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.TaskAction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.inject.Inject;
import java.io.*;
import java.util.Set;
public class GroowtInitTask extends DefaultTask {
private static final Logger logger = LoggerFactory.getLogger(GroowtInitTask.class);
private static final Set<String> srcDirsToMake = Set.of("groovy", "templates");
private final Provider<Configuration> groowtConfigurationProvider;
private final File binDir;
private final File groowtDir;
@Inject
public GroowtInitTask(Project project, Provider<Configuration> groowtConfigurationProvider) {
this.groowtConfigurationProvider = groowtConfigurationProvider;
this.binDir = new File(project.getRootDir(), "bin");
this.groowtDir = new File(project.getRootDir(), "groowt");
}
protected void createBin() throws IOException {
//noinspection ResultOfMethodCallIgnored
this.binDir.mkdirs();
final var groowtFile = new File(this.binDir, "groowt");
try (final InputStream bootstrapInputStream = this.getClass().getResourceAsStream("groowt")) {
if (bootstrapInputStream != null) {
try (final OutputStream bootstrapOutputStream = new FileOutputStream(groowtFile)) {
bootstrapInputStream.transferTo(bootstrapOutputStream);
}
if (!groowtFile.setExecutable(true)) {
logger.warn("Could not set bin/groowt to executable; you will have to do this yourself.");
}
} else {
throw new RuntimeException("Could not find groowt shell script.");
}
}
}
protected void createGroowtFolder() throws IOException {
//noinspection ResultOfMethodCallIgnored
this.groowtDir.mkdirs();
final var groowtConfiguration = this.groowtConfigurationProvider.get();
final Set<File> groowtCliFiles = groowtConfiguration.files(dependency -> {
final var group = dependency.getGroup();
if (group == null || !group.equals("groowt")) {
return false;
} else {
return dependency.getName().equals("groowt-cli");
}
});
final File groowtCliJarFile = groowtCliFiles.stream()
.filter(file -> file.getName().endsWith(".jar"))
.findFirst()
.orElseThrow(() -> new RuntimeException("Could not find groowt-cli jar file."));
final File groowtCliJarOutputFile = new File(this.groowtDir, "groowt-cli.jar");
try (final InputStream groowtCliJarInputStream = new FileInputStream(groowtCliJarFile)) {
try (final OutputStream groowtCliJarOutputStream = new FileOutputStream(groowtCliJarOutputFile)) {
groowtCliJarInputStream.transferTo(groowtCliJarOutputStream);
}
}
}
protected void createSrcDirs() {
final var javaPluginExtension = this.getProject().getExtensions().getByType(JavaPluginExtension.class);
javaPluginExtension.getSourceSets().forEach(sourceSet -> {
final var srcDirs = sourceSet.getAllSource().getSrcDirs();
srcDirs.forEach(srcDir -> {
if (!sourceSet.getName().contains("test") && srcDirsToMake.contains(srcDir.getName())) {
//noinspection ResultOfMethodCallIgnored
srcDir.mkdirs();
}
});
});
}
@TaskAction
public void doInit() throws IOException {
this.createBin();
this.createGroowtFolder();
this.createSrcDirs();
}
}

View File

@ -1,5 +0,0 @@
package groowt.gradle;
import org.gradle.api.file.SourceDirectorySet;
public interface TemplateSourceDirectorySet extends SourceDirectorySet {}

View File

@ -1,18 +0,0 @@
package groowt.gradle;
import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.file.SourceDirectorySet;
public interface TemplateSourceSet {
TemplateSourceDirectorySet getTemplates();
SourceDirectorySet getAllTemplates();
TemplateSourceSet templates(Action<? super TemplateSourceDirectorySet> action);
@SuppressWarnings("rawtypes")
TemplateSourceSet templates(Closure closure);
}

View File

@ -1,50 +0,0 @@
package groowt.gradle.model;
import groowt.gradle.GroowtExtension;
import groowt.gradle.TemplateSourceDirectorySet;
import org.gradle.api.Project;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.provider.Property;
import org.gradle.tooling.provider.model.ToolingModelBuilder;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class GroowtGradleModelBuilder implements ToolingModelBuilder {
@Override
public boolean canBuild(String modelName) {
return modelName.equals(GroowtGradleModel.class.getName());
}
@Override
public @NotNull Object buildAll(@NotNull String modelName, Project project) {
final DefaultGroowtGradleModel model = new DefaultGroowtGradleModel();
final var groowtExtension = project.getExtensions().getByType(GroowtExtension.class);
// base package
final Property<String> basePackage = groowtExtension.getBasePackage();
if (!basePackage.isPresent()) {
throw new RuntimeException(
"The property 'basePackage' must be set under the 'groowt' extension in build.gradle"
);
}
model.setBasePackage(basePackage.get());
// templates dirs
final Map<String, Set<File>> sourceSetToTemplatesDirs = new HashMap<>();
final var javaExtension = project.getExtensions().getByType(JavaPluginExtension.class);
javaExtension.getSourceSets().forEach(sourceSet -> {
final TemplateSourceDirectorySet templateSourceDirectorySet =
sourceSet.getExtensions().getByType(TemplateSourceDirectorySet.class);
sourceSetToTemplatesDirs.put(sourceSet.getName(), templateSourceDirectorySet.getFiles());
});
model.setSourceFileSets(sourceSetToTemplatesDirs);
return model;
}
}

View File

@ -1,3 +0,0 @@
#!/usr/bin/env bash
java -jar groowt/groowt-cli.jar "$@"

View File

@ -6,8 +6,7 @@ pluginManagement {
rootProject.name = 'groowt' rootProject.name = 'groowt'
include 'cli', 'groowt-all', 'groowt-gradle', 'groowt-gradle-model', 'views', 'view-components', include 'views', 'view-components', 'web-view-components', 'web-view-components-compiler'
'web-view-components', 'web-view-components-compiler'
file('util').eachDir { file('util').eachDir {
include it.name include it.name