Lane — co to je, vytvoření a použití ve Fastlane

Co je Lane ve Fastlane

Lane je základní stavební prvek Fastlane, který definuje pojmenovaný scénář automatizace. Každý lane popisuje posloupnost akcí (actions), které se provádějí k dosažení konkrétního cíle: sestavit aplikaci, spustit testy, nahrát build do obchodu nebo nastavit prostředí. Lane se deklaruje v Fastfile a spouští se příkazem fastlane [název_lane] z kořenového adresáře projektu.

Koncept lane je převzat z Ruby DSL a zajišťuje čitelnost scénářů. Vývojář vidí celý CI/CD proces jako posloupnost volání actions srozumitelnými názvy a parametry. Lane může být jednoduchý (jeden příkaz) nebo složitý (větvení, cykly, volání jiných lanes).

Každý lane po provedení vrací výsledek — objekt obsahující stav provedení a data z actions. Výsledek lze použít v jiných lanes nebo předat CI/CD systému pro rozhodování. Pokud jakákoli akce v lane selže, provádění lane se zastaví a zavolá se blok error.

Syntaxe lane: deklarace a spuštění

Syntaxe deklarace lane následuje jednoduchý vzor Ruby DSL: klíčové slovo lane, název scénáře jako symbol Ruby (symbol), blok do ... end s tělem scénáře. Název lane musí být v rámci platformy jedinečný a skládat se z písmen, číslic a podtržítek.

Spuštění lane se provádí přes příkazový řádek: fastlane build (pro lane s názvem :build) nebo bundle exec fastlane build (pokud je Fastlane nainstalován přes Bundler). Pro platformové lanes použijte fastlane ios build nebo fastlane android build.

# Deklarace jednoduchého lane
lane :test do
  scan(scheme: 'App', devices: ['iPhone 15'])
end

lane :build_and_deploy do
  cocoapods
  test
  gym(scheme: 'App', export_method: 'app-store')
  pilot(skip_waiting_for_build_processing: true)
end

# Spuštění: fastlane build_and_deploy

Lane může obsahovat podmíněnou logiku na základě parametrů nebo proměnných prostředí. Použijte if/unless pro přeskočení kroků za určitých podmínek. K dispozici jsou také cykly each pro zpracování polí, což je užitečné pro sestavení více targetů nebo schémat aplikace v jednom lane.

Návrat hodnoty z lane

Lane může vracet hodnotu, která bude dostupná volajícímu kódu. Pro návrat se používá běžný Ruby return nebo poslední výraz v bloku lane. Vrácená hodnota může být řetězec, číslo, hash nebo výsledek akce. To umožňuje použít výsledek jednoho lane v jiném lane pro rozhodování.

Například lane :get_version může vrátit aktuální verzi aplikace z Info.plist a lane :deploy ji použít pro vytvoření zprávy ve Slacku. Vrácené hodnoty jsou zvláště užitečné v private lanes, kde je výsledek potřeba pro další zpracování ve volajícím lane.

Parametry lanes: předávání a zpracování

Parametry lane činí scénáře flexibilními a znovupoužitelnými. Lane přijímá parametry přes options hash, který se předává při spuštění z příkazového řádku: fastlane deploy scheme:AppStore version:2.1.0. Uvnitř lane jsou parametry dostupné jako options[:scheme] a options[:version].

Pro povinné parametry zkontrolujte existenci hodnoty na začátku lane a zavolejte UI.user_error! s jasnou zprávou. Pro volitelné parametry nastavte výchozí hodnoty pomocí operátoru ||. Fastlane také podporuje typované parametry pomocí metody options s určením typu, výchozí hodnoty a popisu.

# Lane se zpracováním parametrů
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("Nebylo zadáno scheme") unless scheme

  match(type: beta ? 'adhoc' : 'appstore')
  gym(scheme: scheme, export_method: beta ? 'ad-hoc' : 'app-store')

  if beta
    pilot(distribute_external: true)
  else
    deliver(submit_for_review: true)
  end
end

# Spuštění: fastlane deploy scheme:MyApp beta:true version:2.1.0

Pro práci s proměnnými prostředí uvnitř lane použijte ENV['VARIABLE_NAME']. Fastlane automaticky načítá .env soubory z adresáře fastlane. Toto je standardní způsob předávání citlivých údajů — API klíčů, hesel a tokenů — v CI/CD prostředí bez jejich ukládání do Fastfile.

Validace parametrů

Pro spolehlivý provoz lane je nezbytná validace parametrů na vstupu. Použijte UI.user_error! s popisem problému, pokud povinný parametr chybí nebo má nesprávný typ. Fastlane poskytuje metodu options, která umožňuje nastavit typ (String, Boolean, Integer, Array), výchozí hodnotu a popis pro každý parametr — validace se provádí automaticky při spuštění lane.

Dodatečně můžete použít kontroly přes verify blok: verify do |value| value.length > 0 end pro parametry řetězce. Při nesprávném formátu Fastlane zobrazí jasnou zprávu s očekávaným formátem a předanou hodnotou, což usnadňuje ladění v CI/CD prostředí.

Spojování lanes: before_all, after_all a error handling

Fastlane poskytuje životní cyklus hooks pro spuštění kódu před a po každém lane. Blok before_all se spustí před každým lane v dané platformě nebo globálně. Blok after_all se spustí po úspěšném dokončení lane. Blok error se spustí při jakékoli chybě uvnitř lane.

Hooks umožňují centralizovat opakovanou logiku: instalace závislostí v before_all, odesílání oznámení v after_all, čištění dočasných souborů a oznamování chyb v bloku error. To snižuje duplicitu kódu a činí lanes čistšími.

# Hooks životního cyklu lanes
default_platform(:ios)

before_all do
  cocoapods(try_repo_update_on_error: true)
  ensure_git_status_clean
end

after_all do |lane|
  slack(message: "Lane #{lane} proběhlo úspěšně")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} selhalo s chybou: #{exception}",
    success: false
  )
end

lane :deploy do
  match(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Blok error přijímá dva argumenty: název lane (symbol) a objekt výjimky. Uvnitř bloku můžete odeslat oznámení do Slacku, zapsat log do souboru nebo spustit alternativní scénář obnovy. Pokud blok error skončí úspěšně, Fastlane nepovažuje build za neúspěšný na úrovni CI/CD.

Private lanes a znovupoužití

Private lane je lane deklarovaný pomocí private_lane místo lane, který se nezobrazuje v seznamu dostupných příkazů a nelze jej spustit přímo z terminálu. Private lanes jsou určeny pro zapouzdření opakujících se kroků, které jsou volány z několika veřejných lanes.

Private lanes jsou zvláště užitečné pro složité posloupnosti akcí, které musí být provedeny v přesně daném pořadí. Například private lane :setup_signing může být volán z lanes :build_dev, :build_staging a :build_production s různými parametry, ale sám o sobě nedává smysl jako samostatný příkaz.

# Private lanes pro znovupoužití
private_lane :setup_environment do |options|
  cocoapods(try_repo_update_on_error: true)
  match(type: options[:type], readonly: true)
  increment_build_number
end

lane :dev_build do
  setup_environment(type: 'development')
  gym(export_method: 'development')
end

lane :appstore_build do
  setup_environment(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Private lanes mohou volat jiné private lanes a vytvářet tak hierarchii abstrakcí. Doporučuje se omezit hloubku vnoření na 2–3 úrovně pro zachování čitelnosti Fastfile. Dokumentujte každý private lane komentářem s popisem jeho účelu a očekávaných parametrů.

Příklady lanes pro iOS a Android

Podívejme se na praktické příklady lanes pro iOS a Android projekty. iOS lanes obvykle používají scan pro testy, match pro certifikáty, gym pro sestavení a pilot nebo deliver pro doručení. Android lanes používají gradle pro sestavení, supply pro publikování a firebase_test_lab pro cloudové testování.

// Lane pro kompletní CI/CD iOS aplikace
lane :ci_full_ios do
  scan(scheme: 'App', code_coverage: true)
  gym(scheme: 'App', export_method: 'app-store')
  pilot(distribute_external: true)
  slack(message: 'iOS CI/CD úspěšně dokončeno')
end

/* Lane pro kompletní CI/CD Android aplikace */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

Kombinováním lanes pro iOS a Android můžete vytvořit jednotný CI/CD proces pro cross-platformovou aplikaci. Použijte platformové bloky platform :ios a platform :android pro seskupení platformově specifických lanes a volejte je z společného orchestrator lane, který řídí pořadí provádění.

Nejlepší postupy psaní lanes

Při psaní lanes se doporučuje dodržovat soubor postupů, které zajišťují čitelnost, udržovatelnost a spolehlivost scénářů. První pravidlo — každý lane by měl provádět jeden úkol. Pokud lane dělá příliš mnoho, rozdělte jej na několik lanes a private lanes.

Druhé pravidlo — pojmenování lanes by mělo být sloveso nebo slovesná fráze: build, deploy, test, upload_screenshots. Vyhněte se abstraktním názvům jako process nebo do_all. Používejte podtržítka pro oddělení slov v názvu lane.

Třetí pravidlo — zpracovávejte chyby explicitně. Použijte UI.user_error! pro jasné zprávy o problémech. Nespoléhejte na standardní chybové zprávy Fastlane — poskytněte vývojáři kontext: „Nebyl nalezen soubor GoogleService-Info.plist — přidejte jej do projektu“ místo „File not found“.

Čtvrté pravidlo — testujte lanes lokálně před spuštěním na CI/CD. Fastlane podporuje režim dry-run pomocí přepínače --dry-run, který ukazuje, které akce budou provedeny, bez skutečného spuštění. Použijte fastlane run_test pro izolované testování jednotlivých lanes před integrací.

Dokumentace lanes

Dokumentace každého lane je důležitým postupem pro týmový vývoj. Fastlane podporuje automatické generování dokumentace z bloku desc umístěného před deklarací lane. Text desc se zobrazuje při spuštění fastlane lanes a fastlane list, což pomáhá vývojářům pochopit účel každého scénáře bez čtení zdrojového kódu Fastfile.

Pro dokumentaci parametrů použijte Ruby komentáře s popisem očekávaných hodnot. Fastlane může generovat README.md s úplným seznamem lanes a jejich popisem pomocí příkazu fastlane generate_docs, což je vhodné pro adaptaci nových členů týmu na CI/CD procesy projektu.