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

def self.choose_lane(ff, platform)
  loop do
    UI.error "You must provide a lane to drive. Available lanes:"
    available = ff.runner.available_lanes(platform)

    available.each_with_index do |lane, index|
      UI.message "#{index + 1}) #{lane}"
    end

    i = $stdin.gets.strip.to_i - 1
    if i >= 0 and available[i]
      selection = available[i]
      UI.important "Driving the lane #{selection}. Next time launch fastlane using `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
    end

    UI.error "Invalid input. Please enter the number of the lane you want to use"
  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)
  raise 'lane must be a string' unless lane.kind_of?(String) or lane.nil?
  raise 'platform must be a string' unless platform.kind_of?(String) or platform.nil?
  raise 'parameters must be a hash' unless parameters.kind_of?(Hash) or parameters.nil?

  ff = Fastlane::FastFile.new(File.join(Fastlane::FastlaneFolder.path, 'Fastfile'))

  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 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/fastlane/lane_manager.rb', line 133

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