Class: Fastlane::LaneManager

Inherits:
LaneManagerBase show all
Defined in:
fastlane/lib/fastlane/lane_manager.rb

Class Method Summary collapse

Methods inherited from LaneManagerBase

finish_fastlane, print_error_line, print_lane_context, print_table

Class Method Details

.choose_lane(ff, platform) ⇒ Object

Lane chooser if user didn’t provide a lane

Parameters:

  • platform: —

    is probably nil, but user might have called ‘fastlane android`, and only wants to list those actions



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'fastlane/lib/fastlane/lane_manager.rb', line 77

def self.choose_lane(ff, platform)
  available = []

  # nil is the key for lanes that are not under a specific platform
  lane_platforms = [nil] + Fastlane::SupportedPlatforms.all
  lane_platforms.each do |p|
    available += ff.runner.lanes[p].to_a.reject { |lane| lane.last.is_private }
  end

  if available.empty?
    UI.user_error!("It looks like you don't have any lanes to run just yet. Check out how to get started here: https://github.com/fastlane/fastlane 🚀")
  end

  rows = []
  available.each_with_index do |lane, index|
    rows << [index + 1, lane.last.pretty_name, lane.last.description.join("\n")]
  end

  rows << [0, "cancel", "No selection, exit fastlane!"]

  require 'terminal-table'

  table = Terminal::Table.new(
    title: "Available lanes to run",
    headings: ['Number', 'Lane Name', 'Description'],
    rows: FastlaneCore::PrintTable.transform_output(rows)
  )

  UI.message("Welcome to fastlane! Here's what your app is set up to do:")

  puts(table)

  fastlane_command = Helper.bundler? ? "bundle exec fastlane" : "fastlane"
  i = UI.input("Which number would you like to run?")

  i = i.to_i - 1
  if i >= 0 && available[i]
    selection = available[i].last.pretty_name
    UI.important("Running lane `#{selection}`. Next time you can do this by directly typing `#{fastlane_command} #{selection}` 🚀.")
    platform = selection.split(' ')[0]
    lane_name = selection.split(' ')[1]

    unless lane_name # no specific platform, just a root lane
      lane_name = platform
      platform = nil
    end

    return platform, lane_name # yeah
  else
    UI.user_error!("Run `#{fastlane_command}` the next time you need to build, test or release your app 🚀")
  end
end

.cruise_lane(platform, lane, parameters = nil, fastfile_path = nil) ⇒ Object

Parameters:

  • platform —

    The name of the platform to execute

  • lane_name —

    The name of the lane to execute

  • parameters (Hash) (defaults to: nil) —

    The parameters passed from the command line to the lane

  • A —

    custom Fastfile path, this is used by fastlane.ci



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'fastlane/lib/fastlane/lane_manager.rb', line 9

def self.cruise_lane(platform, lane, parameters = nil, fastfile_path = nil)
  UI.user_error!("lane must be a string") unless lane.kind_of?(String) || lane.nil?
  UI.user_error!("platform must be a string") unless platform.kind_of?(String) || platform.nil?
  UI.user_error!("parameters must be a hash") unless parameters.kind_of?(Hash) || parameters.nil?

  ff = Fastlane::FastFile.new(fastfile_path || FastlaneCore::FastlaneFolder.fastfile_path)

  is_platform = false
  begin
    is_platform = ff.is_platform_block?(lane)
  rescue # rescue, because this raises an exception if it can't be found at all
  end

  unless is_platform
    # maybe the user specified a default platform
    # We'll only do this, if the lane specified isn't a platform, as we want to list all platforms then

    # Make sure that's not a lane without a platform
    unless ff.runner.available_lanes.include?(lane)
      platform ||= Actions.lane_context[Actions::SharedValues::DEFAULT_PLATFORM]
    end
  end

  if !platform && lane
    # Either, the user runs a specific lane in root or want to auto complete the available lanes for a platform
    # e.g. `fastlane ios` should list all available iOS actions
    if ff.is_platform_block?(lane)
      platform = lane
      lane = nil
    end
  end

  platform, lane = choose_lane(ff, platform) unless lane

  started = Time.now
  e = nil
  begin
    ff.runner.execute(lane, platform, parameters)
  rescue NameError => ex
    print_lane_context
    print_error_line(ex)
    e = ex
  rescue Exception => ex # rubocop:disable Lint/RescueException
    # We also catch Exception, since the implemented action might send a SystemExit signal
    # (or similar). We still want to catch that, since we want properly finish running fastlane
    # Tested with `xcake`, which throws a `Xcake::Informative` object

    print_lane_context
    print_error_line(ex)
    UI.error(ex.to_s) if ex.kind_of?(StandardError) # we don't want to print things like 'system exit'
    e = ex
  end

  # After running the lanes, since skip_docs might be somewhere in-between
  Fastlane::DocsGenerator.run(ff) unless skip_docs?

  duration = ((Time.now - started) / 60.0).round
  finish_fastlane(ff, duration, e)

  return ff
end

.skip_docs? ⇒ Boolean

Returns:



71
72
73
 
# File 'fastlane/lib/fastlane/lane_manager.rb', line 71

def self.skip_docs?
  Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_SKIP_DOCS")
end