Class: Fastlane::Runner
- Inherits:
-
Object
- Object
- Fastlane::Runner
- Defined in:
- lib/fastlane/runner.rb
Instance Attribute Summary collapse
-
#current_lane ⇒ Object
Symbol for the current lane.
-
#current_platform ⇒ Object
Symbol for the current platform.
-
#lanes ⇒ Hash
All the lanes available, first the platform, then the lane.
Instance Method Summary collapse
- #add_lane(lane, override = false) ⇒ Object
- #after_all_blocks ⇒ Object
-
#available_lanes(filter_platform = nil) ⇒ Object
An array of lanes (platform lane_name) to print them out to the user.
- #before_all_blocks ⇒ Object
- #collector ⇒ Object
-
#did_finish ⇒ Object
Fastfile was finished executing.
- #error_blocks ⇒ Object
-
#execute(lane, platform = nil, parameters = nil) ⇒ Object
This will take care of executing one lane.
- #execute_action(method_sym, class_ref, arguments, custom_dir: '..') ⇒ Object
- #full_lane_name ⇒ Object
- #set_after_all(platform, block) ⇒ Object
- #set_before_all(platform, block) ⇒ Object
- #set_error(platform, block) ⇒ Object
-
#try_switch_to_lane(new_lane, parameters) ⇒ Object
All the methods that are usually called on execution.
- #verify_supported_os(name, class_ref) ⇒ Object
Instance Attribute Details
#current_lane ⇒ Object
Symbol for the current lane
4 5 6 |
# File 'lib/fastlane/runner.rb', line 4 def current_lane @current_lane end |
#current_platform ⇒ Object
Symbol for the current platform
7 8 9 |
# File 'lib/fastlane/runner.rb', line 7 def current_platform @current_platform end |
#lanes ⇒ Hash
Returns All the lanes available, first the platform, then the lane.
10 11 12 |
# File 'lib/fastlane/runner.rb', line 10 def lanes @lanes end |
Instance Method Details
#add_lane(lane, override = false) ⇒ Object
178 179 180 181 182 183 184 185 186 |
# File 'lib/fastlane/runner.rb', line 178 def add_lane(lane, override = false) lanes[lane.platform] ||= {} if !override and lanes[lane.platform][lane.name] UI.user_error!("Lane '#{lane.name}' was defined multiple times!") end lanes[lane.platform][lane.name] = lane end |
#after_all_blocks ⇒ Object
208 209 210 |
# File 'lib/fastlane/runner.rb', line 208 def after_all_blocks @after_all ||= {} end |
#available_lanes(filter_platform = nil) ⇒ Object
Returns an array of lanes (platform lane_name) to print them out to the user.
77 78 79 80 81 82 83 84 85 86 87 |
# File 'lib/fastlane/runner.rb', line 77 def available_lanes(filter_platform = nil) all = [] lanes.each do |platform, platform_lanes| next if filter_platform && filter_platform.to_s != platform.to_s # skip actions that don't match platform_lanes.each do |lane_name, lane| all << [platform, lane_name].reject(&:nil?).join(' ') unless lane.is_private end end all end |
#before_all_blocks ⇒ Object
204 205 206 |
# File 'lib/fastlane/runner.rb', line 204 def before_all_blocks @before_all ||= {} end |
#collector ⇒ Object
165 166 167 |
# File 'lib/fastlane/runner.rb', line 165 def collector @collector ||= ActionCollector.new end |
#did_finish ⇒ Object
Fastfile was finished executing
170 171 172 |
# File 'lib/fastlane/runner.rb', line 170 def did_finish collector.did_finish end |
#error_blocks ⇒ Object
212 213 214 |
# File 'lib/fastlane/runner.rb', line 212 def error_blocks @error_blocks ||= {} end |
#execute(lane, platform = nil, parameters = nil) ⇒ Object
This will take care of executing one lane. Thatβs when the user triggers a lane from the CLI for example This method is not executed when switching a lane rubocop:disable Metrics/AbcSize
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 70 71 72 |
# File 'lib/fastlane/runner.rb', line 22 def execute(lane, platform = nil, parameters = nil) UI.crash!("No lane given") unless lane self.current_lane = lane.to_sym self.current_platform = (platform ? platform.to_sym : nil) lane_obj = lanes.fetch(current_platform, {}).fetch(current_lane, nil) UI.user_error!("Could not find lane '#{full_lane_name}'. Available lanes: #{available_lanes.join(', ')}") unless lane_obj UI.user_error!("You can't call the private lane '#{lane}' directly") if lane_obj.is_private ENV["FASTLANE_LANE_NAME"] = current_lane.to_s ENV["FASTLANE_PLATFORM_NAME"] = (current_platform ? current_platform.to_s : nil) Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] = current_platform Actions.lane_context[Actions::SharedValues::LANE_NAME] = full_lane_name UI.success "Driving the lane '#{full_lane_name}' π" return_val = nil path_to_use = Fastlane::FastlaneFolder.path || Dir.pwd parameters ||= {} begin Dir.chdir(path_to_use) do # the file is located in the fastlane folder # Call the platform specific before_all block and then the general one before_all_blocks[current_platform].call(current_lane, parameters) if before_all_blocks[current_platform] && current_platform before_all_blocks[nil].call(current_lane, parameters) if before_all_blocks[nil] return_val = lane_obj.call(parameters) # by default no parameters # `after_all` is only called if no exception was raised before # Call the platform specific before_all block and then the general one after_all_blocks[current_platform].call(current_lane, parameters) if after_all_blocks[current_platform] && current_platform after_all_blocks[nil].call(current_lane, parameters) if after_all_blocks[nil] end return return_val rescue => ex Dir.chdir(path_to_use) do # Provide error block exception without colour code error_ex = ex.exception(ex..gsub(/\033\[\d+m/, '')) error_blocks[current_platform].call(current_lane, error_ex, parameters) if error_blocks[current_platform] && current_platform error_blocks[nil].call(current_lane, error_ex, parameters) if error_blocks[nil] end raise ex end end |
#execute_action(method_sym, class_ref, arguments, custom_dir: '..') ⇒ Object
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 147 148 149 150 |
# File 'lib/fastlane/runner.rb', line 122 def execute_action(method_sym, class_ref, arguments, custom_dir: '..') collector.did_launch_action(method_sym) verify_supported_os(method_sym, class_ref) begin Dir.chdir(custom_dir) do # go up from the fastlane folder, to the project folder Actions.execute_action(class_ref.step_text) do # arguments is an array by default, containing an hash with the actual parameters # Since we usually just need the passed hash, we'll just use the first object if there is only one if arguments.count == 0 arguments = ConfigurationHelper.parse(class_ref, {}) # no parameters => empty hash elsif arguments.count == 1 and arguments.first.kind_of? Hash arguments = ConfigurationHelper.parse(class_ref, arguments.first) # Correct configuration passed elsif !class_ref. # This action does not use the new action format # Just passing the arguments to this method else UI.user_error!("You have to call the integration like `#{method_sym}(key: \"value\")`. Run `fastlane action #{method_sym}` for all available keys. Please check out the current documentation on GitHub.") end class_ref.run(arguments) end end rescue => ex collector.did_raise_error(method_sym) raise ex end end |
#full_lane_name ⇒ Object
12 13 14 |
# File 'lib/fastlane/runner.rb', line 12 def full_lane_name [current_platform, current_lane].reject(&:nil?).join(' ') end |
#set_after_all(platform, block) ⇒ Object
192 193 194 |
# File 'lib/fastlane/runner.rb', line 192 def set_after_all(platform, block) after_all_blocks[platform] = block end |
#set_before_all(platform, block) ⇒ Object
188 189 190 |
# File 'lib/fastlane/runner.rb', line 188 def set_before_all(platform, block) before_all_blocks[platform] = block end |
#set_error(platform, block) ⇒ Object
196 197 198 |
# File 'lib/fastlane/runner.rb', line 196 def set_error(platform, block) error_blocks[platform] = block end |
#try_switch_to_lane(new_lane, parameters) ⇒ Object
All the methods that are usually called on execution
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 |
# File 'lib/fastlane/runner.rb', line 93 def try_switch_to_lane(new_lane, parameters) block = lanes.fetch(current_platform, {}).fetch(new_lane, nil) block ||= lanes.fetch(nil, {}).fetch(new_lane, nil) # fallback to general lane for multiple platforms if block original_full = full_lane_name original_lane = current_lane UI.user_error!("Parameters for a lane must always be a hash") unless (parameters.first || {}).kind_of? Hash pretty = [new_lane] pretty = [current_platform, new_lane] if current_platform Actions.execute_action("Switch to #{pretty.join(' ')} lane") {} # log the action UI.success "Cruising over to lane '#{pretty.join(' ')}' π" # Actually switch lane now self.current_lane = new_lane collector.did_launch_action(:lane_switch) result = block.call(parameters.first || {}) # to always pass a hash self.current_lane = original_lane UI.success "Cruising back to lane '#{original_full}' π".green return result else # No action and no lane, raising an exception now UI.error caller.join("\n") UI.user_error!("Could not find action or lane '#{new_lane}'. Check out the README for more details: https://github.com/fastlane/fastlane/tree/master/fastlane") end end |
#verify_supported_os(name, class_ref) ⇒ Object
152 153 154 155 156 157 158 159 160 161 162 163 |
# File 'lib/fastlane/runner.rb', line 152 def verify_supported_os(name, class_ref) if class_ref.respond_to?(:is_supported?) if Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] # This value is filled in based on the executed platform block. Might be nil when lane is in root of Fastfile platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] unless class_ref.is_supported?(platform) UI.user_error!("Action '#{name}' doesn't support required operating system '#{platform}'.") end end end end |