TODO.md

@@ -20,13 +20,12 @@ For example:
     - di
     - extensible
     - fp
-- [x] Remove cli, groowt-all, groowt-gradle, groowt-gradle-model.
-- [ ] Get rid of wvc compiler dependency on fp, di.
+- [ ] Cli: add commands for:
+  - [ ] `server`: start a server for the project, optionally with `-l`/`--live-reload`.
+  - [ ] `render`: one-off render a template, either from a file (to be compiled) or a class
+  - [ ] `generate`/`gen`/`g`: generate a template, component, route, etc., in the appropriate source directory
+- [ ] Get rid of wvc compiler dependency on di
 - [ ] Remove as much cruft as possible from web-view-components-compiler, etc.
-- [ ] Use new namespaces (i.e., packages) the individual projects: 
-  - `com.jessebrault.groowt`: for views
-  - `com.jessebrault.groowt.component`: for view-components
-  - `com.jessebrault.groowt.web`: for web-view-components and web-view-components-compiler
 
 ## 0.1.3
 - [ ] ~~refactor tools/gradle start scripts to use dist instead of custom bin script~~

cli/build.gradle

@@ -0,0 +1,46 @@
+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)
+                }
+            }
+        }
+    }
+}

cli/src/main/java/groowt/cli/FileAndPathUtil.java

@@ -0,0 +1,17 @@
+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() {}
+
+}

cli/src/main/java/groowt/cli/Generate.java

@@ -0,0 +1,61 @@
+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;
+    }
+
+}

cli/src/main/java/groowt/cli/GradleUtil.java

@@ -0,0 +1,32 @@
+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() {}
+
+}

cli/src/main/java/groowt/cli/GroowtCli.java

@@ -0,0 +1,46 @@
+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;
+    }
+
+}

cli/src/main/resources/log4j2.xml

@@ -0,0 +1,17 @@
+<?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>

groowt-all/build.gradle

@@ -0,0 +1,23 @@
+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
+        }
+    }
+}

groowt-gradle-model/build.gradle

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

groowt-gradle-model/src/main/java/groowt/gradle/model/DefaultGroowtGradleModel.java

@@ -0,0 +1,32 @@
+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;
+    }
+
+}

groowt-gradle-model/src/main/java/groowt/gradle/model/GroowtGradleModel.java

@@ -0,0 +1,10 @@
+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();
+}

groowt-gradle/build.gradle

@@ -0,0 +1,32 @@
+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
+        }
+    }
+}

groowt-gradle/src/main/java/groowt/gradle/DefaultGroowtExtension.java

@@ -0,0 +1,22 @@
+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;
+    }
+
+}

groowt-gradle/src/main/java/groowt/gradle/DefaultTemplateSourceDirectorySet.java

@@ -0,0 +1,19 @@
+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);
+    }
+
+}

groowt-gradle/src/main/java/groowt/gradle/DefaultTemplateSourceSet.java

@@ -0,0 +1,61 @@
+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;
+    }
+
+}

groowt-gradle/src/main/java/groowt/gradle/GroowtExtension.java

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

groowt-gradle/src/main/java/groowt/gradle/GroowtGradlePlugin.java

@@ -0,0 +1,91 @@
+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());
+    }
+
+}

groowt-gradle/src/main/java/groowt/gradle/GroowtInitTask.java

@@ -0,0 +1,95 @@
+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();
+    }
+
+}

groowt-gradle/src/main/java/groowt/gradle/TemplateSourceDirectorySet.java

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

groowt-gradle/src/main/java/groowt/gradle/TemplateSourceSet.java

@@ -0,0 +1,18 @@
+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);
+
+}

groowt-gradle/src/main/java/groowt/gradle/model/GroowtGradleModelBuilder.java

@@ -0,0 +1,50 @@
+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;
+    }
+
+}

groowt-gradle/src/main/resources/groowt/gradle/groowt

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

settings.gradle

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