Class: Fastlane::LaneManager

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

Class Method Summary collapse

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



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/fastlane/lane_manager.rb', line 105

def self.choose_lane(ff, platform)
  available = ff.runner.lanes[platform].to_a
  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!"]

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

  UI.message "Welcome to fastlane! Here's what your app is setup to do:"

  puts table

  i = UI.input "Which number would you like 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 #{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` the next time you need to build, test or release your app 🚀"
  end
end

.cruise_lane(platform, lane, parameters = nil, env = 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

  • env (defaults to: nil) —

    Dot Env Information



7
8
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
 
# File 'lib/fastlane/lane_manager.rb', line 7

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

  ff = Fastlane::FastFile.new(Fastlane::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 and 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

  load_dot_env(env)

  started = Time.now
  e = nil
  begin
    ff.runner.execute(lane, platform, parameters)
  rescue => ex
    UI.important 'Variable Dump:'.yellow
    UI.message Actions.lane_context
    UI.error ex.to_s
    e = ex
  end

  # After running the lanes, since skip_docs might be somewhere in-between
  Fastlane::DocsGenerator.run(ff) unless ENV["FASTLANE_SKIP_DOCS"]

  duration = ((Time.now - started) / 60.0).round

  finish_fastlane(ff, duration, e)

  return ff
end

.finish_fastlane(ff, duration, error) ⇒ Object

All the finishing up that needs to be done



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/fastlane/lane_manager.rb', line 65

def self.finish_fastlane(ff, duration, error)
  ff.runner.did_finish

  # Finished with all the lanes
  Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
  print_table(Fastlane::Actions.executed_actions)

  if error
    UI.error 'fastlane finished with errors'
    raise error
  elsif duration > 5
    UI.success "fastlane.tools just saved you #{duration} minutes! 🎉"
  else
    UI.success 'fastlane.tools finished successfully 🎉'
  end
end

.load_dot_env(env) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/fastlane/lane_manager.rb', line 148

def self.load_dot_env(env)
  return if Dir.glob("**/*.env*", File::FNM_DOTMATCH).count == 0
  require 'dotenv'

  Actions.lane_context[Actions::SharedValues::ENVIRONMENT] = env if env

  # Making sure the default '.env' and '.env.default' get loaded
  env_file = File.join(Fastlane::FastlaneFolder.path || "", '.env')
  env_default_file = File.join(Fastlane::FastlaneFolder.path || "", '.env.default')
  Dotenv.load(env_file, env_default_file)

  # Loads .env file for the environment passed in through options
  if env
    env_file = File.join(Fastlane::FastlaneFolder.path || "", ".env.#{env}")
    UI.success "Loading from '#{env_file}'"
    Dotenv.overload(env_file)
  end
end

.print_table(actions) ⇒ Object

Print a table as summary of the executed actions



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/fastlane/lane_manager.rb', line 83

def self.print_table(actions)
  return if actions.count == 0

  require 'terminal-table'

  rows = []
  actions.each_with_index do |current, i|
    name = current[:name][0..60]
    rows << [i + 1, name, current[:time].to_i]
  end

  puts ""
  puts Terminal::Table.new(
    title: "fastlane summary".green,
    headings: ["Step", "Action", "Time (in s)"],
    rows: rows
  )
  puts ""
end