Many minor adjustments

README.md

@@ -5,162 +5,202 @@
 ![CI Workflow](https://github.com/Liber-UFPE/project-starter/actions/workflows/build.yml/badge.svg?branch=main)
 ![Main Workflow](https://github.com/Liber-UFPE/project-starter/actions/workflows/main.yml/badge.svg?branch=main)
 
-This is a project starter template. There are a few things you need to do after creating your repository using this template:
+Esse é um template para iniciar projetos. Há algumas coisas que você precisa fazer após criar seu repositório usando este template:
 
-- [ ] Replace `project-starter`, `PROJECT_STARTER` (and other mentions) with your project's name
-- [ ] Edit `src/main/resources/public/stylesheets/main.css` as needed (different colors, fonts, etc.)
-- [ ] Edit `src/main/resources/public/javascript/main.js` as needed
-- [ ] Edit `src/main/jte/layout.kte` as necessary to support your project's navigation
+- [ ] Substituir `project-starter`, `PROJECT_STARTER` (e outras menções) pelo nome do seu projeto
+- [ ] Editar `src/main/resources/public/stylesheets/main.css` conforme necessário (cores diferentes, fontes, etc.)
+- [ ] Editar `src/main/resources/public/javascript/main.js` conforme necessário
+- [ ] Editar `src/main/jte/layout.kte` conforme necessário para suportar a navegação do seu projeto
 
-## Adding a new page
+## Adicionando uma nova página
 
-To add a new page, you need to edit a few files:
+Para adicionar uma nova página, você precisa editar alguns arquivos:
 
 ### 1. View
 
-Add a new template such as `src/main/jte/my-new-page.kte` that uses the project layout:
+Adicione um novo template como `src/main/jte/my-new-page.kte` que usa o layout do projeto:
 
 ```html
-@template.layout(title = "Page title", content = @`
-    @template.sections.top(title = "Main top section title", subtext = @`
-        <h1>Main top section content</h1>
-        <p>It is <abbr title="HyperText Markup Language">HTML</abbr>.</p>
-    `)
-    @template.sections.main(content = @`
-        <div class="row mb-2">
-            <p>Secondary section HTML</p>
+@template.layout(title = "Página", content = @`
+    <section class="main-section-bg">
+        <div class="px-4 pt-8 mx-auto max-w-screen-xl z-10 relative md:pt-16 text-center">
+            <h1 class="mb-4 leading-none text-6xl text-gray-800 tracking-tight text-white md:text-8xl lg:text-8xl">Headline para a página</h1>
         </div>
+    </section>
+    @template.partials.content-section(content = @`
+        <article class="format lg:format-lg">
+            <p class="mb-3 text-3xl text-gray-800">Texto do primeiro paragrafo</p>
+            <p class="text-gray-800 leading-relaxed mb-4">Texto do segundo paragrafo</p>
+        </article>
     `)
+`, metadata = @`
+    <meta name="description" content="Meta descrição da página">
 `)
 ```
 
 ### 2. Controller / Route
 
-Such as `src/main/kotlin/br/ufpe/liber/controllers/IndexController.kt`, or another one if necessary:
+Como `src/main/kotlin/br/ufpe/liber/controllers/IndexController.kt`, ou outro se necessário:
 
 ```kotlin
 @Get("/my-new-page")
-fun index() = ok(templates.myNewPage()) // `myNewPage` is generated automatically
+fun index() = ok(templates.myNewPage()) // `myNewPage` é gerado automaticamente
 ```
 
-### 3. Layout changes
+### 3. Mudanças no layout
 
-If this adds to your project's navigation, you can new links to the `navbar` in the `src/main/jte/layout.kte` file:
+Se isso adiciona à navegação do seu projeto, você pode adicionar novos links à `navbar` no arquivo `src/main/jte/layout.kte`:
 
 ```diff
-        <li class="nav-item">
-            <a class="nav-link btn btn-outline-success" href="/" role="button">Index</a>
-        </li>
-+       <li class="nav-item">
-+           <a class="nav-link btn btn-outline-success" href="/my-new-page" role="button">My New Page</a>
-+       </li>
-    </ul>
-    <form class="d-flex" role="search">
-        <input class="form-control me-2" type="search" placeholder="Busca" aria-label="Search">
-
+ <ul class="flex flex-col p-4 mt-4 font-medium md:space-x-8 md:flex-row md:mt-0">
+     <li>
+         @template.partials.navlink(path = "/", text = "Inicio", title = "Página inicial")
+     </li>
++    <li>
++        @template.partials.navlink(path = "#", text = "Link #1", title = "Link #1")
++    </li>
+ </ul>
 ```
 
-### 4. Tests
+### 4. Testes
+
+Adicione alguns testes para a sua nova página / rota.
 
-Add some tests for your new page / route.
+> [!TIP]
+> Se sua rota:
+> 
+> - Não recebe parâmetros
+> - Retorna HTML
+> 
+> Então ela será testada automaticamente pelos testes de acessibilidade.
 
-## Run locally
 
-To run the project locally, open a terminal and execute:
+## Executar localmente
+
+Para executar o projeto localmente, abra um terminal e execute:
 
 ```shell
 ./gradlew run
 ```
 
-If you want to reload the application for every code change, run [Gradle in _continuous_ mode](https://docs.micronaut.io/latest/guide/#gradleReload):
+A aplicação ficará acessível em <http://localhost:8080/>.
+
+Se você quiser recarregar a aplicação a cada alteração de código, execute [o Gradle em modo contínuo](https://docs.micronaut.io/latest/guide/index.html#gradleReload):
 
 ```shell
 ./gradlew run -t
 ```
 
-## Requirements
+## Simular ambiente de produção
 
-1. Java 21 (easier to install with [SDKMAN](https://sdkman.io/))
-2. [Docker Desktop](https://www.docker.com/products/docker-desktop/) (if you want to test docker images)
-3. [Ktlint CLI](https://pinterest.github.io/ktlint/1.0.0/install/cli/) (if you want to run code inspections locally)
-4. [Gradle](https://gradle.org/install/#with-a-package-manager) (if you don't want to use the `./gradlew` script)
-5. [chromedriver](https://chromedriver.chromium.org/downloads) (if you want to run browser tests)
+O aplicativo é executado usando o [nginx](https://nginx.org/) como proxy, em uma máquina com o [Rocky Linux](https://rockylinux.org/). Para simular este ambiente, você pode usar o [Vagrant][vagrant], que irá configurar todos os detalhes usando um único comando:
 
-## Technical aspects
+```shell
+./gradlew clean vagrantUp
+```
 
-The project is developed using Micronaut Framework, [Gradle](https://gradle.org/), and [Kotlin](https://kotlinlang.org/).
+O servidor nginx ficará acessível em <http://localhost:9080/>, e a aplicação em <http://localhost:9080/project-starter>.
 
-### Micronaut Documentation
+Para acessar a VM via SSH, execute:
 
-- [User Guide](https://docs.micronaut.io/4.1.3/guide/index.html)
-- [API Reference](https://docs.micronaut.io/4.1.3/api/index.html)
-- [Configuration Reference](https://docs.micronaut.io/4.1.3/guide/configurationreference.html)
-- [Micronaut Guides](https://guides.micronaut.io/index.html)
+```shell
+vagrant ssh
+```
 
-### Template Engine
+### Destruir / Reiniciar a VM Vagrant
+
+Se a VM estiver executando, execute o seguinte comando para destruí-lo:
 
-It uses JTE/KTE as the template engine.
+```shell
+vagrant destroy --graceful --force
+```
 
-- [JTE Website](https://jte.gg/)
-- [Micronaut JTE Views documentation](https://micronaut-projects.github.io/micronaut-views/latest/guide/#jte)
+## Requisitos
 
-### CI & CD
+1. Java 21 (mais fácil de instalar com [SDKMAN](https://sdkman.io/))
+2. [Node.js 20](https://nodejs.org/en)
+3. [Docker Desktop](https://www.docker.com/products/docker-desktop/) (se você quiser testar as imagens Docker)
+4. [Ktlint CLI][ktlint-cli] (se você quiser executar inspeções de código localmente)
+5. [Gradle](https://gradle.org/install/#with-a-package-manager) (se você não quiser usar o script `./gradlew`)
+6. [Vagrant][vagrant] (se você quiser rodar o projeto usando uma VM)
+
+
+## Aspectos técnicos
+
+O projeto é desenvolvido usando:
 
-The project uses [GitHub Actions](https://docs.github.com/en/actions) to run tests, package a new version, and deploy it to [Railway.app](https://railway.app/) (experimental).
+- [Micronaut Framework][micronaut]
+- [Gradle][gradle]
+- [Kotlin][kotlin]
+- [Tailwind CSS][tailwind]
 
-### Tests & Code Coverage
+### Documentação de Micronaut
 
-We use [Kotest](https://kotest.io/) as the test framework, and [Kover](https://github.com/Kotlin/kotlinx-kover) as the Code Coverage tool. See also [Micronaut Kotest integration docs](https://micronaut-projects.github.io/micronaut-test/latest/guide/#kotest5).
+- [Guia do usuário](https://docs.micronaut.io/latest/guide/index.html)
+- [API Referência](https://docs.micronaut.io/latest/api/index.html)
+- [Referência de Configuração](https://docs.micronaut.io/latest/guide/configurationreference.html)
+- [Guias sobre o Micronaut](https://guides.micronaut.io/index.html)
 
-### Code Inspections
+### Template Engine
+
+O projeto usa JTE / KTE como template engine.
+
+- [Documentação do JTE](https://jte.gg)
+- [Tutorial JTE](https://javalin.io/tutorials/jte)
+
+### CI & CD
 
-For every merge/push, and also for pull requests, there are GitHub Actions to run [ktlint](https://github.com/pinterest/ktlint) and [detekt](https://github.com/detekt/detekt). There is also an (experimental) integration with [DeepSource](https://deepsource.com/).
+O projeto usa [GitHub Actions](https://docs.github.com/en/actions) para executar testes e outras validações descritas abaixo.
 
-Ktlint is configured to use `intellij_idea` code style so that it won't conflict with code formatting action in IDEA.
+#### Inspeções de código
 
-### Project Directory Layout
+Para cada merge/push, e também para pull requests, existem ações do GitHub para executar [ktlint][ktlint], [detekt](https://github.com/detekt), e [DiKTat](https://diktat.saveourtool.com/) (experimental).
 
-Project follow the default [Maven Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) for Kotlin projects. The main folders are:
+O ktlint está configurado para usar o estilo de código `intellij_idea` para que ele não entre em conflito com a ação de formatação de código da IntelliJ IDEA.
 
-| Directory                   | Description                                          |
-|:----------------------------|:-----------------------------------------------------|
-| `src/main`                  | Root folder for application code                     |
-| `src/main/jte`              | JTE template folder                                  |
-| `src/main/kotlin`           | Application Kotlin code                              |
-| `src/main/resources`        | Configurations and other resources                   |
-| `src/main/resources/public` | Web assets such as images, javascript, and css files |
-| `src/test`                  | Root folder for test code                            |
-| `src/accessibilityTest`     | Root folder for accessibility test code              |
-| `.github`                   | Root folder for GitHub configurations                |
-| `.github/workflows`         | GitHub Actions configuration                         |
+Há também uma integração com o Sonar Cloud: <https://sonarcloud.io/project/overview?id=Liber-UFPE_project-starter>.
 
-## Micronaut 4.2.0 Documentation
+### Testes e Cobertura de Código
 
-- [User Guide](https://docs.micronaut.io/4.2.0/guide/index.html)
-- [API Reference](https://docs.micronaut.io/4.2.0/api/index.html)
-- [Configuration Reference](https://docs.micronaut.io/4.2.0/guide/configurationreference.html)
-- [Micronaut Guides](https://guides.micronaut.io/index.html)
+Usamos [Kotest](https://kotest.io/) como framework de teste, e [Kover](https://github.com/Kotlin/kotlinx-kover) como a ferramenta de cobertura de código. Ver também [Micronaut Kotest integrações docs](https://micronaut-projects.github.io/micronaut-test/latest/guide/index.html#kotest5).
 
----
+> [!TIP]
+> Veja a cobertura de código mais recente na [página do projeto no SonarCloud](https://sonarcloud.io/component_measures?metric=coverage&view=list&id=Liber-UFPE_project-starter).
 
-- [Shadow Gradle Plugin](https://plugins.gradle.org/plugin/com.github.johnrengelman.shadow)
-- [Micronaut Gradle Plugin documentation](https://micronaut-projects.github.io/micronaut-gradle-plugin/latest/)
-- [GraalVM Gradle Plugin documentation](https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html)
+### Assets Pipeline
 
-## Feature serialization-jackson documentation
+Para garantir que as páginas carreguem rapidamente, há um processamento dos assets estáticos (JavaScripts, CSS, imagens).
+O [esbuild](https://esbuild.github.io/) é usado em conjunto com alguns pacotes npm:
 
-- [Micronaut Serialization Jackson Core documentation](https://micronaut-projects.github.io/micronaut-serialization/latest/guide/)
+- [sharp](https://github.com/lovell/sharp) para gerar versões `webp` das images
+- [gzipper](https://github.com/gios/gzipper) para gerar versões comprimidas (`gzip`, `brotli`, `deflate`)
+- [postcss](https://postcss.org/) para otimizar o uso do [Tailwind CSS][tailwind] e manter apenas os estilos efetivamente usados.
 
-## Feature ksp documentation
+Esse processamento é então integrado ao `build` principal da aplicação usando o [Gradle Plugin for Node](https://github.com/node-gradle/gradle-node-plugin).
 
-- [Micronaut Kotlin Symbol Processing (KSP) documentation](https://docs.micronaut.io/latest/guide/#kotlin)
-- [https://kotlinlang.org/docs/ksp-overview.html](https://kotlinlang.org/docs/ksp-overview.html)
+> [!TIP]
+> Dá para testar o processamento dos assets de maneira isolada executando diretamente `node assets-pipeline.mjs`.
 
-## Feature kotest documentation
+### Layout de Diretório de Projetos
 
-- [Micronaut Test Kotest5 documentation](https://micronaut-projects.github.io/micronaut-test/latest/guide/#kotest5)
-- [https://kotest.io/](https://kotest.io/)
+O projeto segue o padrão [Maven Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) para projetos Kotlin. As pastas principais são:
 
-## Feature micronaut-aot documentation
+| Diretório                   | Descrição                                          |
+|:----------------------------|:---------------------------------------------------|
+| `src/main`                  | Pasta raiz para código de aplicação                |
+| `src/main/jte`              | Pasta de templates JTE                             |
+| `src/main/kotlin`           | Código Kotlin da aplicação                         |
+| `src/main/resources`        | Configurações e outros recursos                    |
+| `src/main/resources/public` | Web assets como imagens, javascript e arquivos css |
+| `src/test`                  | Pasta raiz para código de teste                    |
+| `scripts`                   | Pasta com scripts para deploy usando o Vagrant     |
+| `github`                    | Pasta raiz para configurações do GitHub            |
+| `.github/workflows`         | GitHub Ações configuração                          |
 
-- [Micronaut AOT documentation](https://micronaut-projects.github.io/micronaut-aot/latest/guide/)
+[gradle]: https://gradle.org/
+[kotlin]: https://kotlinlang.org/
+[micronaut]: https://micronaut.io/
+[tailwind]: https://tailwindcss.com/
+[vagrant]: https://www.vagrantup.com/
+[ktlint]: https://github.com/pinterest/ktlint
+[ktlint-cli]: https://pinterest.github.io/ktlint/latest/install/cli/

application.gradle.kts

@@ -0,0 +1,2 @@
+// This is where application specific build configuration should live.
+// For example, it can add dependencies to the project, new tasks, etc.

build.gradle.kts

@@ -287,3 +287,5 @@ dependencies {
     accessibilityTestImplementation("org.seleniumhq.selenium:selenium-java:4.17.0")
     accessibilityTestImplementation("com.deque.html.axe-core:selenium:4.8.1")
 }
+
+apply(from = "application.gradle.kts")

scripts/project-starter.service

@@ -24,11 +24,11 @@ Environment="MICRONAUT_ENVIRONMENTS=baremetal"
 # MUST be consistent with what is defined in nginx proxy pass
 # location for this application.
 Environment="PROJECT_STARTER_PORT=8082"
-Environment="PROJECT_STARTER_PATH=/hyginia"
+Environment="PROJECT_STARTER_PATH=/project-starter"
 
 WorkingDirectory=/opt/javaapps
 # Valores apenas de exemplo, mas nos testes que fiz essa quantidade de memoria parecia suficiente.
-ExecStart=/usr/bin/java -Xms128m -Xmx256m -jar hyginia-all.jar
+ExecStart=/usr/bin/java -Xms128m -Xmx256m -jar project-starter-all.jar
 ExecStop=/bin/kill -15 $MAINPID
 
 [Install]