0Pricing
Swift Academy · Aula

Versionamento, resolução de conflitos e plugins do Swift

Gerencie intervalos de versões, resolva conflitos de dependências e use plugins de ferramentas de compilação.

Versionamento, resolução de conflitos e plugins do Swift é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Versionamento semântico no SPM

O SPM usa versionamento semântico: MAJOR.MINOR.PATCH. Declare requisitos com from:, exact: ou .upToNextMajor.

.package(url: "https://github.com/apple/swift-log", from: "1.5.0"),
.package(url: "https://github.com/vapor/vapor", exact: "4.83.0"),
.package(url: "https://github.com/pointfreeco/swift-composable-architecture",
  .upToNextMajor(from: "1.0.0"))

Package.resolved

Package.resolved fixa versões exatas para todas as dependências. Faça o commit desse arquivo em aplicativos; omita-o em bibliotecas.

// Package.resolved (auto-generated):
// Pins exact commit hash and version for every dependency
// Run "swift package update" to update pinned versions

Resolvendo conflitos de versão

Quando dois pacotes exigem versões diferentes da mesma dependência, o SPM tenta encontrar uma versão compatível. Conflitos que não podem ser resolvidos causam um erro de compilação.

// PackageA requires Logging 1.4.0
// PackageB requires Logging 1.5.0
// SPM resolves to 1.5.0 (satisfies both >= 1.x)
// Conflict: PackageA requires Logging 1.x, PackageB requires 2.x

Forçando uma versão

Adicione a dependência conflitante diretamente ao Package.swift do seu aplicativo para substituir a versão que o SPM escolheria de outra forma.

// Force Logging 1.5.0 by declaring it directly:
.package(url: "https://github.com/apple/swift-log", exact: "1.5.0")

Plugins de ferramentas de compilação

Plugins de ferramentas de compilação são executados durante a compilação para gerar código-fonte, processar recursos ou executar analisadores estáticos automaticamente.

// In Package.swift:
.plugin(
  name: "SourceGenerator",
  capability: .buildTool()
)

Implementando um plugin de ferramenta de compilação

Um plugin de ferramenta de compilação está em conformidade com BuildToolPlugin e retorna BuildCommand ou PrebuildCommand.

import PackagePlugin

@main
struct SourceGenerator: BuildToolPlugin {
  func createBuildCommands(context: PluginContext, target: Target) async throws -> [Command] {
    let output = context.pluginWorkDirectory.appending("Generated.swift")
    return [.buildCommand(
      displayName: "Generating sources",
      executable: try context.tool(named: "gen-tool").path,
      arguments: ["--output", output],
      outputFiles: [output]
    )]
  }
}

Plugins de comandos

Plugins de comandos são executados sob demanda a partir do Xcode ou da CLI, sendo úteis para formatação, análise estática ou geração de documentação.

// In Package.swift:
.plugin(
  name: "FormatPlugin",
  capability: .command(intent: .sourceCodeFormatting())
)

Executando um plugin de comandos

Execute plugins de comandos pelo terminal ou pelo menu de contexto acessado com o botão direito no Xcode.

// CLI:
swift package plugin format-source-code
// Xcode: right-click target → "Format Source Code"

Usando SwiftLint como plugin de compilação

O SwiftLint é distribuído como um plugin do SPM que é executado automaticamente em todas as compilações.

.package(url: "https://github.com/realm/SwiftLint", from: "0.54.0"),
// In target:
.plugin(name: "SwiftLintBuildToolPlugin", package: "SwiftLint")

Sandbox do plugin

Os plugins são executados em uma área isolada com acesso limitado ao sistema de arquivos por segurança. Eles só podem gravar no diretório de trabalho designado para eles.

// Accessible from plugins:
// context.pluginWorkDirectory — writable work dir
// context.package.directory — read-only source
// target.sourceFiles — source file list

Verificação rápida

Qual é a finalidade de Package.resolved em um pacote Swift?

Recapitulação da lição

Use intervalos de versionamento semântico no Package.swift. Faça o commit de Package.resolved em aplicativos para obter compilações reproduzíveis. Resolva conflitos de versão declarando a dependência diretamente. Plugins de ferramentas de compilação são executados automaticamente durante a compilação (analisadores estáticos e geradores de código). Plugins de comandos são executados sob demanda. Os plugins são isolados por segurança.

Perguntas Frequentes

A aula “Versionamento, resolução de conflitos e plugins do Swift” é grátis?

Sim — o texto completo de “Versionamento, resolução de conflitos e plugins do Swift” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Versionamento, resolução de conflitos e plugins do Swift”?

Gerencie intervalos de versões, resolva conflitos de dependências e use plugins de ferramentas de compilação. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Versionamento, resolução de conflitos e plugins do Swift”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Package.swift: destinos, produtos e dependências
  2. Pacotes locais e módulos de funcionalidades
  3. Destinos binários e XCFrameworks
  4. Versionamento, resolução de conflitos e plugins do Swift
← Voltar para Swift Academy