class Fastlane::FastFile
Constants
Attributes
the platform in which we're currently in when parsing the Fastfile This is used to identify the platform in which the lane is in
Stores all relevant information from the currently running process
Public Class Methods
@return The runner which can be executed to trigger the given actions
# File fastlane/lib/fastlane/fast_file.rb, line 15 def initialize(path = nil) return unless (path || '').length > 0 UI.user_error!("Could not find Fastfile at path '#{path}'") unless File.exist?(path) @path = File.expand_path(path) content = File.read(path, encoding: "utf-8") # From https://github.com/orta/danger/blob/master/lib/danger/Dangerfile.rb if content.tr!('“”‘’‛', %(""''')) UI.error("Your #{File.basename(path)} has had smart quotes sanitised. " \ 'To avoid issues in the future, you should not use ' \ 'TextEdit for editing it. If you are not using TextEdit, ' \ 'you should turn off smart quotes in your editor of choice.') end content.scan(/^\s*require ["'](.*?)["']/).each do |current| gem_name = current.last next if gem_name.include?(".") # these are local gems begin require(gem_name) rescue LoadError UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require '#{gem_name}'` to ensure the gem is installed locally.") end end parse(content, @path) end
# File fastlane/lib/fastlane/fast_file.rb, line 220 def self.sh(*command, step_name: nil, log: true, error_callback: nil, &b) command_header = log ? step_name || Actions.shell_command_from_args(*command) : "shell command" Actions.execute_action(command_header) do Actions.sh_no_action(*command, log: log, error_callback: error_callback, &b) end end
Public Instance Methods
# File fastlane/lib/fastlane/fast_file.rb, line 444 def action_completed(action_name, status: nil) completion_context = FastlaneCore::ActionCompletionContext.context_for_action_name(action_name, args: ARGV, status: status) FastlaneCore.session.action_completed(completion_context: completion_context) end
# File fastlane/lib/fastlane/fast_file.rb, line 437 def action_launched(action_name) action_launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(action_name, fastlane_client_language: :ruby, args: ARGV) FastlaneCore.session.action_launched(launch_context: action_launch_context) end
# File fastlane/lib/fastlane/fast_file.rb, line 183 def actions_path(path) UI.crash!("Path '#{path}' not found!") unless File.directory?(path) Actions.load_external_actions(path) end
Is executed after each test run
# File fastlane/lib/fastlane/fast_file.rb, line 143 def after_all(&block) @runner.set_after_all(@current_platform, block) end
Is executed before each lane
# File fastlane/lib/fastlane/fast_file.rb, line 148 def after_each(&block) @runner.set_after_each(@current_platform, block) end
Is executed before each test run
# File fastlane/lib/fastlane/fast_file.rb, line 133 def before_all(&block) @runner.set_before_all(@current_platform, block) end
Is executed before each lane
# File fastlane/lib/fastlane/fast_file.rb, line 138 def before_each(&block) @runner.set_before_each(@current_platform, block) end
# File fastlane/lib/fastlane/fast_file.rb, line 227 def desc(string) desc_collection << string end
# File fastlane/lib/fastlane/fast_file.rb, line 231 def desc_collection @desc_collection ||= [] end
Is executed if an error occurred during fastlane execution
# File fastlane/lib/fastlane/fast_file.rb, line 153 def error(&block) @runner.set_error(@current_platform, block) end
# File fastlane/lib/fastlane/fast_file.rb, line 235 def fastlane_require(gem_name) FastlaneRequire.install_gem_if_needed(gem_name: gem_name, require_gem: true) end
# File fastlane/lib/fastlane/fast_file.rb, line 266 def find_tag(folder: nil, version: nil, remote: false) req = Gem::Requirement.new(version) all_tags = get_tags(folder: folder, remote: remote) return all_tags.select { |t| req =~ FastlaneCore::TagVersion.new(t) }.last end
# File fastlane/lib/fastlane/fast_file.rb, line 239 def generated_fastfile_id(id) UI.important("The `generated_fastfile_id` action was deprecated, you can remove the line from your `Fastfile`") end
# File fastlane/lib/fastlane/fast_file.rb, line 243 def import(path = nil) UI.user_error!("Please pass a path to the `import` action") unless path path = path.dup.gsub("~", Dir.home) unless Pathname.new(path).absolute? # unless an absolute path path = File.join(File.expand_path('..', @path), path) end UI.user_error!("Could not find Fastfile at path '#{path}'") unless File.exist?(path) # First check if there are local actions to import in the same directory as the Fastfile actions_path = File.join(File.expand_path("..", path), 'actions') Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path) action_launched('import') return_value = parse(File.read(path), path) action_completed('import', status: FastlaneCore::ActionCompletionStatus::SUCCESS) return return_value end
@param url [String] The git URL to clone the repository from @param branch [String] The branch to checkout in the repository @param path [String] The path to the Fastfile @param version [String, Array] Version requirement for repo tags @param dependencies [Array] An optional array of additional Fastfiles in the repository @param cache_path [String] An optional path to a directory where the repository should be cloned into
# File fastlane/lib/fastlane/fast_file.rb, line 279 def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile', version: nil, dependencies: [], cache_path: nil) # rubocop:disable Metrics/PerceivedComplexity UI.user_error!("Please pass a path to the `import_from_git` action") if url.to_s.length == 0 Actions.execute_action('import_from_git') do require 'tmpdir' action_launched('import_from_git') is_eligible_for_caching = !cache_path.nil? UI.message("Eligible for caching") if is_eligible_for_caching # Checkout the repo repo_name = url.split("/").last checkout_param = branch import_block = proc do |target_path| clone_folder = File.join(target_path, repo_name) branch_option = "--branch #{branch}" if branch != 'HEAD' checkout_dependencies = dependencies.map(&:shellescape).join(" ") # If the current call is eligible for caching, we check out all the # files and directories. If not, we only check out the specified # `path` and `dependencies`. checkout_path = is_eligible_for_caching ? "" : "#{path.shellescape} #{checkout_dependencies}" if Dir[clone_folder].empty? UI.message("Cloning remote git repo...") Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do # When using cached clones, we need the entire repository history # so we can switch between tags or branches instantly, or else, # it would defeat the caching's purpose. depth = is_eligible_for_caching ? "" : "--depth 1" Actions.sh("git clone #{url.shellescape} #{clone_folder.shellescape} #{depth} --no-checkout #{branch_option}") end end unless version.nil? if is_eligible_for_caching checkout_param = find_tag(folder: clone_folder, version: version, remote: false) if checkout_param.nil? # Update the repo and try again before failing UI.message("Updating git repo...") Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do Actions.sh("cd #{clone_folder.shellescape} && git checkout #{branch} && git reset --hard && git pull --all") end checkout_param = find_tag(folder: clone_folder, version: version, remote: false) else UI.message("Found tag #{checkout_param}. No git repo update needed.") end else checkout_param = find_tag(folder: clone_folder, version: version, remote: true) end UI.user_error!("No tag found matching #{version.inspect}") if checkout_param.nil? end if is_eligible_for_caching && version.nil? # Update the repo if it's eligible for caching but the version isn't specified UI.message("Fetching remote git branches and updating git repo...") Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do Actions.sh("cd #{clone_folder.shellescape} && git fetch --all --quiet && git checkout #{checkout_param.shellescape} #{checkout_path} && git reset --hard && git rebase") end else Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{checkout_path}") end # Knowing that we check out all the files and directories when the # current call is eligible for caching, we don't need to also # explicitly check out the "actions" directory. unless is_eligible_for_caching # We also want to check out all the local actions of this fastlane setup containing = path.split(File::SEPARATOR)[0..-2] containing = "." if containing.count == 0 actions_folder = File.join(containing, "actions") begin Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{actions_folder.shellescape}") rescue # We don't care about a failure here, as local actions are optional end end return_value = nil if dependencies.any? return_value = [import(File.join(clone_folder, path))] return_value += dependencies.map { |file_path| import(File.join(clone_folder, file_path)) } else return_value = import(File.join(clone_folder, path)) end action_completed('import_from_git', status: FastlaneCore::ActionCompletionStatus::SUCCESS) return return_value end if is_eligible_for_caching import_block.call(File.expand_path(cache_path)) else Dir.mktmpdir("fl_clone", &import_block) end end end
Is the given key a platform block or a lane?
# File fastlane/lib/fastlane/fast_file.rb, line 167 def is_platform_block?(key) UI.crash!('No key given') unless key return false if self.runner.lanes.fetch(nil, {}).fetch(key.to_sym, nil) return true if self.runner.lanes[key.to_sym].kind_of?(Hash) if key.to_sym == :update # The user ran `fastlane update`, instead of `fastlane update_fastlane` # We're gonna be nice and understand what the user is trying to do require 'fastlane/one_off' Fastlane::OneOff.run(action: "update_fastlane", parameters: {}) else UI.user_error!("Could not find '#{key}'. Available lanes: #{self.runner.available_lanes.join(', ')}") end end
User defines a new lane
# File fastlane/lib/fastlane/fast_file.rb, line 83 def lane(lane_name, &block) UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block self.runner.add_lane(Lane.new(platform: self.current_platform, block: block, description: desc_collection, name: lane_name, is_private: false)) @desc_collection = nil # reset the collected description again for the next lane end
Is used to look if the method is implemented as an action
# File fastlane/lib/fastlane/fast_file.rb, line 158 def method_missing(method_sym, *arguments, &_block) self.runner.trigger_action_by_name(method_sym, nil, false, *arguments) end
User defines a lane that can overwrite existing lanes. Useful when importing a Fastfile
# File fastlane/lib/fastlane/fast_file.rb, line 109 def override_lane(lane_name, &block) UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block self.runner.add_lane(Lane.new(platform: self.current_platform, block: block, description: desc_collection, name: lane_name, is_private: false), true) @desc_collection = nil # reset the collected description again for the next lane end
# File fastlane/lib/fastlane/fast_file.rb, line 47 def parse(data, path = nil) @runner ||= Runner.new Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder # create nice path that we want to print in case of some problem relative_path = path.nil? ? '(eval)' : Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s begin # We have to use #get_binding method, because some test files defines method called `path` (for example SwitcherFastfile) # and local variable has higher priority, so it causes to remove content of original Fastfile for example. With #get_binding # is this always clear and safe to declare any local variables we want, because the eval function uses the instance scope # instead of local. # rubocop:disable Security/Eval eval(data, parsing_binding, relative_path) # using eval is ok for this case # rubocop:enable Security/Eval rescue SyntaxError => ex match = ex.to_s.match(/#{Regexp.escape(relative_path)}:(\d+)/) if match line = match[1] UI.content_error(data, line) UI.user_error!("Syntax error in your Fastfile on line #{line}: #{ex}") else UI.user_error!("Syntax error in your Fastfile: #{ex}") end end end self end
# File fastlane/lib/fastlane/fast_file.rb, line 43 def parsing_binding binding end
User defines a platform block
# File fastlane/lib/fastlane/fast_file.rb, line 122 def platform(platform_name) SupportedPlatforms.verify!(platform_name) self.current_platform = platform_name yield self.current_platform = nil end
User defines a new private lane, which can't be called from the CLI
# File fastlane/lib/fastlane/fast_file.rb, line 96 def private_lane(lane_name, &block) UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block self.runner.add_lane(Lane.new(platform: self.current_platform, block: block, description: desc_collection, name: lane_name, is_private: true)) @desc_collection = nil # reset the collected description again for the next lane end
# File fastlane/lib/fastlane/fast_file.rb, line 422 def puts(value) # Overwrite this, since there is already a 'puts' method defined in the Ruby standard library value ||= yield if block_given? action_launched('puts') return_value = Fastlane::Actions::PutsAction.run([value]) action_completed('puts', status: FastlaneCore::ActionCompletionStatus::SUCCESS) return return_value end
Speak out loud
# File fastlane/lib/fastlane/fast_file.rb, line 414 def say(value) # Overwrite this, since there is already a 'say' method defined in the Ruby standard library value ||= yield value = { text: value } if value.kind_of?(String) || value.kind_of?(Array) self.runner.trigger_action_by_name(:say, nil, false, value) end
Execute shell command Accepts arguments with with and without the command named keyword so that sh behaves like other actions with named keywords github.com/fastlane/fastlane/issues/14930
Example:
sh("ls") sh("ls", log: false) sh(command: "ls") sh(command: "ls", step_name: "listing the files") sh(command: "ls", log: false)
# File fastlane/lib/fastlane/fast_file.rb, line 200 def sh(*args, &b) # First accepts hash (or named keywords) like other actions # Otherwise uses sh method that doesn't have an interface like an action if args.count == 1 && args.first.kind_of?(Hash) options = args.first command = options.delete(:command) raise ArgumentError, "sh requires :command keyword in argument" if command.nil? log = options[:log].nil? ? true : options[:log] FastFile.sh(*command, step_name: options[:step_name], log: log, error_callback: options[:error_callback], &b) elsif args.count != 1 && args.last.kind_of?(Hash) new_args = args.dup options = new_args.pop log = options[:log].nil? ? true : options[:log] FastFile.sh(*new_args, step_name: options[:step_name], log: log, error_callback: options[:error_callback], &b) else FastFile.sh(*args, &b) end end
# File fastlane/lib/fastlane/fast_file.rb, line 432 def test(params = {}) # Overwrite this, since there is already a 'test' method defined in the Ruby standard library self.runner.try_switch_to_lane(:test, [params]) end