23.11.2024

Aula 119: Gerenciando Dependências com Swift Package Manager

No desenvolvimento de software moderno, gerenciar dependências é uma tarefa crucial. O Swift Package Manager (SPM) é uma ferramenta poderosa que simplifica o processo de inclusão de bibliotecas e frameworks externos em seus projetos Swift. Nesta aula, exploraremos como gerenciar dependências usando o SPM, discutindo seus conceitos fundamentais, criando pacotes e adicionando-os aos nossos projetos.

O que é o Swift Package Manager?

O Swift Package Manager é uma ferramenta para gerenciar a distribuição de código Swift e está integrado ao sistema de build do Swift. Ele permite que os desenvolvedores adicionem, atualizem ou removam dependências em seus projetos de maneira fácil. O SPM suporta versionamento, o que facilita o controle da estabilidade de suas dependências.

Conceitos Fundamentais do SPM

1. Pacote: Um pacote é uma coleção de arquivos fonte que podem ser compilados em uma biblioteca ou executável. Cada pacote tem um arquivo manifesto chamado Package.swift.

2. Alvo (Target): Os alvos são os blocos de construção básicos de um pacote. Cada alvo pode ser uma biblioteca ou um executável.

3. Dependência: Uma dependência é outro pacote que seu pacote precisa para funcionar corretamente.

Criando um Pacote Swift

Vamos criar um pacote Swift simples para demonstrar como o SPM funciona.

1. Abra seu terminal e crie um novo pacote:

   mkdir MinhaBibliotecaMatematica
   cd MinhaBibliotecaMatematica
   swift package init --type library

   Este comando cria um novo diretório chamado MinhaBibliotecaMatematica com a estrutura de uma biblioteca.

2. Abra o arquivo Package.swift. Você verá a estrutura padrão do pacote, que se parece com isso:

   // swift-tools-version:5.3
   import PackageDescription
   
   let package = Package(
      name: "MinhaBibliotecaMatematica",
      products: [
          .library(
              name: "MinhaBibliotecaMatematica",
              targets: ["MinhaBibliotecaMatematica"]),
      ],
      dependencies: [],
      targets: [
          .target(
              name: "MinhaBibliotecaMatematica",
              dependencies: []),
          .testTarget(
              name: "MinhaBibliotecaMatematicaTests",
              dependencies: ["MinhaBibliotecaMatematica"]),
      ]
   )

3. Agora, vamos adicionar uma função matemática simples ao nosso pacote. Abra Sources/MinhaBibliotecaMatematica/MinhaBibliotecaMatematica.swift e adicione o seguinte código:

   public struct Math {
      public static func add(_ a: Int, _ b: Int) -> Int {
          return a + b
      }
   }

4. Em seguida, vamos adicionar um teste para nossa nova função. Abra Tests/MinhaBibliotecaMatematicaTests/MinhaBibliotecaMatematicaTests.swift e adicione o seguinte código:

   import XCTest
   @testable import MinhaBibliotecaMatematica
   
   final class MinhaBibliotecaMatematicaTests: XCTestCase {
      func testAdd() {
          XCTAssertEqual(Math.add(2, 3), 5)
      }
   }

5. De volta ao seu terminal, construa seu pacote e execute os testes:

   swift test

   Você deverá ver uma saída indicando que os testes passaram.

Adicionando Dependências

Agora que temos nosso próprio pacote, vamos explorar como adicionar dependências. Para demonstração, nós adicionaremos a popular biblioteca Alamofire, que é usada para fazer requisições HTTP.

1. Abra o arquivo Package.swift. Modifique a seção dependencies para incluir o Alamofire:

   dependencies: [
      .package(url: "https://github.com/Alamofire/Alamofire.git", from: "5.4.0"),
   ],

2. Especifique o Alamofire como uma dependência para seu alvo:

   targets: [
      .target(
          name: "MinhaBibliotecaMatematica",
          dependencies: ["Alamofire"]),
      .testTarget(
          name: "MinhaBibliotecaMatematicaTests",
          dependencies: ["MinhaBibliotecaMatematica"]),
   ]

3. Salve as alterações e atualize suas dependências de pacote:

   swift package update

4. Agora, você pode importar o Alamofire em seu pacote. Por exemplo, você pode adicionar um método que busca dados de uma URL:

   import Alamofire
   
   public struct GerenciadorDeRede {
      public static func fetchData(from url: String) {
          AF.request(url).response { response in
              // Manipular resposta
              debugPrint(response)
          }
      }
   }

Usando Seu Pacote em Outro Projeto

Para usar seu pacote recém-criado em outro projeto Swift, siga estes passos:

1. Crie um novo projeto Swift:

   mkdir MeuApp
   cd MeuApp
   swift package init --type executable

2. Abra o arquivo Package.swift em MeuApp. Modifique-o para incluir sua MinhaBibliotecaMatematica como uma dependência. Supondo que você tenha a biblioteca no mesmo diretório:

   dependencies: [
      .package(path: "../MinhaBibliotecaMatematica"),
   ],

3. Adicione MinhaBibliotecaMatematica às suas dependências de alvo:

   targets: [
      .target(
          name: "MeuApp",
          dependencies: ["MinhaBibliotecaMatematica"]),
   ]

4. Agora você pode usar MinhaBibliotecaMatematica em seu arquivo Sources/MeuApp/main.swift:

   import MinhaBibliotecaMatematica
   
   print(Math.add(3, 5)) // Saída: 8

5. Construa e execute seu aplicativo:

   swift run

Conclusão

Nesta aula, exploramos como gerenciar dependências usando o Swift Package Manager. Criamos nosso próprio pacote, adicionamos uma dependência e a consumimos em um projeto separado. O SPM facilita a gestão e integração de bibliotecas externas, permitindo que você se concentre na construção de suas aplicações. Continue experimentando com diferentes pacotes e aproveite os benefícios de um código modular!

Video

Navigation