SwiftHTML & CSSSolidityDesenvolvimento de JogosSolana/Rust
23.11.2024

Lição: 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

Did you like this article? Rate it from 1 to 5:

Thank you for voting!