Migracja projektu Xcode

O ile nie utworzysz nowego projektu przy użyciu Tuist, w którym to przypadku wszystko zostanie skonfigurowane automatycznie, będziesz musiał zdefiniować swoje projekty Xcode przy użyciu prymitywów Tuist. Żmudność tego procesu zależy od stopnia złożoności projektu.

Jak zapewne wiesz, projekty Xcode mogą z czasem stać się nieuporządkowane i złożone: grupy, które nie pasują do struktury katalogów, pliki, które są współdzielone między celami lub odniesienia do plików, które wskazują na nieistniejące pliki (by wspomnieć o niektórych). Cała ta nagromadzona złożoność utrudnia nam dostarczenie polecenia, które niezawodnie migruje projekt.

Co więcej, ręczna migracja jest doskonałym ćwiczeniem do czyszczenia i upraszczania projektów. Nie tylko deweloperzy w projekcie będą za to wdzięczni, ale także Xcode, który będzie je szybciej przetwarzał i indeksował. Gdy w pełni zaadoptujesz Tuist, upewnisz się, że projekty są spójnie zdefiniowane i pozostają proste.

Aby ułatwić tę pracę, przedstawiamy kilka wskazówek opartych na opiniach, które otrzymaliśmy od użytkowników.

Utwórz rusztowanie projektu {#create-project-scaffold}.

Przede wszystkim utwórz rusztowanie dla swojego projektu z następującymi plikami Tuist:

Tuist.swift

import ProjectDescription

let tuist = Tuist()

Project.swift

import ProjectDescription

let project = Project(
    name: "MyApp-Tuist",
    targets: [
        /** Targets will go here **/
    ]
)

Tuist/Package.swift

// swift-tools-version: 5.9
import PackageDescription

#if TUIST
    import ProjectDescription

    let packageSettings = PackageSettings(
        // Customize the product types for specific package product
        // Default is .staticFramework
        // productTypes: ["Alamofire": .framework,]
        productTypes: [:]
    )
#endif

let package = Package(
    name: "MyApp",
    dependencies: [
        // Add your own dependencies here:
        // .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0"),
        // You can read more about dependencies here: https://docs.tuist.io/documentation/tuist/dependencies
    ]
)

Project.swift to plik manifestu, w którym definiuje się projekt, a Package.swift to plik manifestu, w którym definiuje się zależności. Plik Tuist.swift to miejsce, w którym można zdefiniować ustawienia Tuist dla projektu.

NAZWA PROJEKTU Z SUFFIXEM -TUIST

Aby zapobiec konfliktom z istniejącym projektem Xcode, zalecamy dodanie przyrostka -Tuist do nazwy projektu. Można go usunąć po pełnej migracji projektu do Tuist.

Zbuduj i przetestuj projekt Tuist w CI {#build-and-test-the-tuist-project-in-ci}.

Aby upewnić się, że migracja każdej zmiany jest prawidłowa, zalecamy rozszerzenie ciągłej integracji w celu zbudowania i przetestowania projektu wygenerowanego przez Tuist z pliku manifestu:

tuist install
tuist generate
tuist build -- ...{xcodebuild flags} # or tuist test

Wyodrębnij ustawienia kompilacji projektu do plików .xcconfig {#extract-the-project-build-settings-into-xcconfig-files}.

Wyodrębnij ustawienia kompilacji z projektu do pliku .xcconfig, aby uprościć projekt i ułatwić migrację. Za pomocą poniższego polecenia można wyodrębnić ustawienia kompilacji z projektu do pliku .xcconfig:

mkdir -p xcconfigs/
tuist migration settings-to-xcconfig -p MyApp.xcodeproj -x xcconfigs/MyApp-Project.xcconfig

Następnie zaktualizuj plik Project.swift, aby wskazywał na właśnie utworzony plik .xcconfig:

import ProjectDescription

let project = Project(
    name: "MyApp",
    settings: .settings(configurations: [
        .debug(name: "Debug", xcconfig: "./xcconfigs/MyApp-Project.xcconfig"), 
        .release(name: "Release", xcconfig: "./xcconfigs/MyApp-Project.xcconfig"), 
    ]),
    targets: [
        /** Targets will go here **/
    ]
)

Następnie należy rozszerzyć potok ciągłej integracji, aby uruchomić następujące polecenie w celu zapewnienia, że zmiany ustawień kompilacji są wprowadzane bezpośrednio do plików .xcconfig:

tuist migration check-empty-settings -p Project.xcodeproj

Wyodrębnij zależności pakietów {#extract-package-dependencies}.

Wyodrębnij wszystkie zależności projektu do pliku Tuist/Package.swift:

// swift-tools-version: 5.9
import PackageDescription

#if TUIST
    import ProjectDescription

    let packageSettings = PackageSettings(
        // Customize the product types for specific package product
        // Default is .staticFramework
        // productTypes: ["Alamofire": .framework,]
        productTypes: [:]
    )
#endif

let package = Package(
    name: "MyApp",
    dependencies: [
        // Add your own dependencies here:
        // .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0"),
        // You can read more about dependencies here: https://docs.tuist.io/documentation/tuist/dependencies
        .package(url: "https://github.com/onevcat/Kingfisher", .upToNextMajor(from: "7.12.0")) 
    ]
)

TYPY PRODUKTÓW

Typ produktu dla określonego pakietu można zastąpić, dodając go do słownika productTypes w strukturze PackageSettings. Domyślnie Tuist zakłada, że wszystkie pakiety są statycznymi frameworkami.

:::

Określenie kolejności migracji {#determine-the-migration-order}.

Zalecamy migrację obiektów docelowych od tego, który jest najbardziej zależny do najmniej. Możesz użyć następującego polecenia, aby wyświetlić listę obiektów docelowych projektu, posortowanych według liczby zależności:

tuist migration list-targets -p Project.xcodeproj

Rozpocznij migrację celów z góry listy, ponieważ są one najbardziej zależne.

Migruj cele

Migruj cele jeden po drugim. Zalecamy wykonanie pull requesta dla każdego celu, aby upewnić się, że zmiany zostały sprawdzone i przetestowane przed ich scaleniem.

Wyodrębnij docelowe ustawienia kompilacji do plików .xcconfig {#extract-the-target-build-settings-into-xcconfig-files}.

Podobnie jak w przypadku ustawień kompilacji projektu, należy wyodrębnić docelowe ustawienia kompilacji do pliku .xcconfig, aby docelowa kompilacja była prostsza i łatwiejsza do migracji. Możesz użyć następującego polecenia, aby wyodrębnić ustawienia kompilacji z celu do pliku .xcconfig:

tuist migration settings-to-xcconfig -p MyApp.xcodeproj -t TargetX -x xcconfigs/TargetX.xcconfig

Zdefiniuj cel w pliku Project.swift {#define-the-target-in-the-projectswift-file}.

Zdefiniuj cel w Project.targets:

import ProjectDescription

let project = Project(
    name: "MyApp",
    settings: .settings(configurations: [
        .debug(name: "Debug", xcconfig: "./xcconfigs/Project.xcconfig"),
        .release(name: "Release", xcconfig: "./xcconfigs/Project.xcconfig"),
    ]),
    targets: [
        .target( 
            name: "TargetX", 
            destinations: .iOS, 
            product: .framework, // [!code ++] // or .staticFramework, .staticLibrary...
            bundleId: "dev.tuist.targetX", 
            sources: ["Sources/TargetX/**"], 
            dependencies: [ 
                /** Dependencies go here **/
                /** .external(name: "Kingfisher") **/
                /** .target(name: "OtherProjectTarget") **/
            ], 
            settings: .settings(configurations: [ 
                .debug(name: "Debug", xcconfig: "./xcconfigs/TargetX.xcconfig"), 
                .debug(name: "Release", xcconfig: "./xcconfigs/TargetX.xcconfig"), 
            ]) 
        ), 
    ]
)

TARGI TESTOWE

Jeśli cel ma powiązany cel testowy, należy go zdefiniować w pliku Project.swift, powtarzając te same kroki.

Zatwierdź migrację docelową {#validate-the-target-migration}.

Uruchom tuist build i tuist test, aby upewnić się, że projekt został zbudowany i testy zakończyły się pomyślnie. Dodatkowo możesz użyć xcdiff, aby porównać wygenerowany projekt Xcode z istniejącym, aby upewnić się, że zmiany są prawidłowe.

Powtórz

Powtarzaj tę czynność, aż wszystkie obiekty docelowe zostaną w pełni zmigrowane. Po zakończeniu zalecamy aktualizację potoków CI i CD w celu zbudowania i przetestowania projektu za pomocą poleceń tuist build i tuist test, aby skorzystać z szybkości i niezawodności zapewnianej przez Tuist.

Rozwiązywanie problemów

Błędy kompilacji z powodu brakujących plików.

Jeśli pliki powiązane z celami projektu Xcode nie były zawarte w katalogu systemu plików reprezentującym cel, projekt może się nie skompilować. Upewnij się, że lista plików po wygenerowaniu projektu za pomocą Tuist jest zgodna z listą plików w projekcie Xcode i skorzystaj z okazji, aby dostosować strukturę plików do struktury docelowej.