SBT para Iniciantes: Guia Rápido e Prático para Programação

SBT para Iniciantes: Guia Rápido e Prático para Programação

Por

SBT para Iniciantes: Guia Rápido e Prático para Programação

Se você está começando a desenvolver projetos em Scala, provavelmente já ouviu falar do SBT (Simple Build Tool). O SBT é uma ferramenta de construção poderosa e flexível, amplamente utilizada na comunidade Scala, e também em projetos Java, para automatizar tarefas como compilação, teste, empacotamento e publicação de projetos.

Este guia tem como objetivo fornecer uma introdução prática e acessível ao SBT, cobrindo os conceitos fundamentais e os comandos mais comuns para que você possa começar a usá-lo em seus próprios projetos Scala.

O Que é SBT?

Em sua essência, o SBT é um sistema de construção. Ele lê um arquivo de configuração (build.sbt) que descreve seu projeto, suas dependências e as tarefas que devem ser executadas. Com base nessa configuração, o SBT automatiza o processo de construção, economizando tempo e garantindo a consistência do seu projeto.

Instalação do SBT

A instalação do SBT varia dependendo do seu sistema operacional. Aqui estão algumas opções:

  • Linux: Geralmente, o SBT pode ser instalado através do gerenciador de pacotes da sua distribuição (por exemplo, apt-get install sbt no Debian/Ubuntu).

  • macOS: O Homebrew é uma opção popular: brew install sbt.

  • Windows: O SDKMAN! é uma boa alternativa. Após instalar o SDKMAN!, execute sdk install sbt.

Após a instalação, você pode verificar se o SBT está funcionando corretamente abrindo um terminal e digitando sbt sbtVersion. Isso deve exibir a versão instalada do SBT.

Estrutura de Diretórios do Projeto SBT

O SBT segue uma estrutura de diretórios padrão que facilita a organização do seu projeto. Veja um exemplo:



    meu-projeto/

    ├── build.sbt

    ├── project/

    │   └── plugins.sbt

    └── src/

        ├── main/

        │   ├── scala/

        │   │   └── MeuPrograma.scala

        │   └── resources/

        └── test/

            ├── scala/

            │   └── MeuProgramaTest.scala

            └── resources/

Explicando os diretórios:

  • build.sbt: O arquivo principal de configuração do SBT. Ele define o nome do projeto, a versão, as dependências e outras configurações.

  • project/: Contém arquivos de configuração adicionais, como plugins.sbt, que define os plugins que o SBT deve utilizar.

  • src/main/scala/: Onde você coloca o código fonte principal do seu projeto Scala.

  • src/main/resources/: Recursos que seu programa utiliza, como arquivos de configuração ou imagens.

  • src/test/scala/: Onde você coloca os testes unitários do seu projeto.

  • src/test/resources/: Recursos utilizados nos testes.

O Arquivo build.sbt

O arquivo build.sbt é o coração da configuração do seu projeto SBT. Aqui está um exemplo básico:



    

name := "meu-projeto"
version := "1.0-SNAPSHOT"
scalaVersion := "2.13.8"
libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.12" % "test"

Vamos analisar cada linha:

  • name := "meu-projeto": Define o nome do seu projeto.

  • version := "1.0-SNAPSHOT": Define a versão do seu projeto. “SNAPSHOT” indica que é uma versão de desenvolvimento.

  • scalaVersion := "2.13.8": Define a versão do Scala que você está utilizando.

  • libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.12" % "test": Adiciona uma dependência ao seu projeto. Neste caso, estamos adicionando o ScalaTest para testes.

A sintaxe %% é usada para indicar que a versão do Scala deve ser adicionada automaticamente ao nome da dependência, garantindo a compatibilidade.

Comandos Básicos do SBT

O SBT oferece uma série de comandos que você pode executar a partir do terminal. Aqui estão alguns dos mais comuns:

  • compile: Compila o código fonte do seu projeto.

  • test: Executa os testes unitários.

  • run: Executa a aplicação principal.

  • package: Cria um arquivo JAR (Java Archive) contendo o seu código compilado e as dependências.

  • clean: Remove todos os arquivos gerados pelo SBT, como classes compiladas e arquivos JAR.

  • console: Abre um console Scala com o classpath do seu projeto.

  • reload: Recarrega a configuração do build.sbt. Útil quando você modifica o arquivo.

  • sbtVersion: Exibe a versão do SBT.

  • exit: Sai do console do SBT.

Para executar um comando, basta abrir um terminal na raiz do seu projeto e digitar sbt [comando]. Por exemplo, para compilar o projeto, você digitaria sbt compile.

Adicionando Dependências

Um dos maiores benefícios do SBT é a facilidade com que você pode gerenciar as dependências do seu projeto. Como vimos no exemplo do build.sbt, você usa a chave libraryDependencies para adicionar as bibliotecas que seu projeto precisa.

Você pode encontrar as dependências que precisa no Maven Central Repository (mvnrepository.com). Ao encontrar uma dependência, basta copiar o trecho de código correspondente e adicioná-lo ao seu build.sbt.

Por exemplo, para adicionar a biblioteca Apache Commons Lang, você adicionaria a seguinte linha ao seu build.sbt:



    

libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.12.0"

Após modificar o build.sbt, você pode executar o comando sbt reload para que o SBT recarregue a configuração e baixe as dependências adicionadas.

Plugins do SBT

Os plugins do SBT permitem estender a funcionalidade da ferramenta, adicionando novas tarefas e configurações. Existem plugins para praticamente tudo, desde geração de documentação até deploy em servidores.

Para adicionar um plugin, você precisa criar um arquivo chamado plugins.sbt dentro do diretório project/ do seu projeto. Neste arquivo, você adiciona a dependência do plugin.

Por exemplo, para adicionar o plugin Scalafmt, que formata automaticamente o seu código Scala, você adicionaria a seguinte linha ao project/plugins.sbt:



    

addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.2")

Após adicionar o plugin, execute sbt reload para que o SBT o carregue. Em seguida, você pode usar os comandos fornecidos pelo plugin (neste caso, scalafmtAll para formatar todo o código do projeto).

Exemplo Prático: Criando um Projeto “Hello, World!”

Vamos criar um projeto Scala simples que imprime “Hello, World!” no console.

  1. Crie um diretório para o seu projeto: mkdir hello-world e entre no diretório: cd hello-world.

  2. Crie o arquivo build.sbt: Com o seguinte conteúdo:



    

name := "hello-world"
version := "1.0-SNAPSHOT"
scalaVersion := "2.13.8"

  1. Crie a estrutura de diretórios: mkdir -p src/main/scala.

  2. Crie o arquivo src/main/scala/Main.scala: Com o seguinte conteúdo:



    

object Main {

  def main(args: Array[String]): Unit = {

    println("Hello, World!")

  }

}

  1. Execute o projeto: Abra um terminal na raiz do projeto e digite sbt run.

Você deverá ver “Hello, World!” impresso no console.

Conclusão

O SBT é uma ferramenta essencial para o desenvolvimento de projetos Scala. Embora possa parecer complexo no início, com este guia rápido e prático, você tem as bases necessárias para começar a usar o SBT em seus próprios projetos. Explore os comandos, experimente com as configurações e aproveite o poder da automação para otimizar o seu fluxo de trabalho de desenvolvimento.

Perguntas Frequentes (FAQs)

O que fazer se o SBT não reconhecer um comando?

Certifique-se de estar executando o comando na raiz do seu projeto SBT (onde o arquivo build.sbt está localizado). Verifique também se o comando que você está tentando executar é um comando padrão do SBT ou se é fornecido por um plugin. Se for um plugin, certifique-se de que o plugin está instalado e carregado corretamente (execute sbt reload após adicionar o plugin).

Como resolver problemas de dependências conflitantes?

O SBT possui um mecanismo de resolução de dependências que tenta encontrar a melhor versão compatível de cada dependência. No entanto, em alguns casos, pode haver conflitos. Você pode usar o comando sbt dependencyTree para visualizar a árvore de dependências do seu projeto e identificar os conflitos. Em seguida, você pode usar a chave dependencyOverrides no seu build.sbt para forçar uma versão específica de uma dependência.

Como publicar um projeto SBT no Maven Central?

Publicar um projeto no Maven Central envolve algumas etapas, incluindo configurar as credenciais do Sonatype, assinar os artefatos com GPG e usar um plugin como sbt-sonatype. Existem diversos tutoriais online que explicam o processo detalhadamente. Consulte a documentação do sbt-sonatype para obter informações precisas e atualizadas.

O SBT funciona apenas com Scala?

Embora seja mais comumente usado com Scala, o SBT também pode ser usado para construir projetos Java. A configuração básica é semelhante, e você pode usar as mesmas chaves para definir o nome do projeto, a versão e as dependências. No entanto, você precisará ajustar algumas configurações para compilar e executar código Java.

Como atualizar a versão do SBT?

A atualização da versão do SBT depende do método de instalação que você utilizou. Se você usou o SDKMAN!, pode executar sdk update sbt. Se usou o Homebrew, pode executar brew upgrade sbt. Se usou o gerenciador de pacotes da sua distribuição Linux, use o comando correspondente (por exemplo, apt-get update && apt-get upgrade sbt). Depois de atualizar a versão do SBT, você pode precisar atualizar a versão do SBT utilizada no seu projeto especificando a chave `sbtPlugin` em `project/plugins.sbt`. Consulte a documentação do SBT para mais detalhes.

Deixe um comentário