fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/swift_lane_manager.rb

@@ -0,0 +1,304 @@
+require_relative 'lane_manager_base.rb'
+require_relative 'swift_runner_upgrader.rb'
+
+module Fastlane
+  class SwiftLaneManager < LaneManagerBase
+    # @param lane_name The name of the lane to execute
+    # @param parameters [Hash] The parameters passed from the command line to the lane
+    # @param env Dot Env Information
+    def self.cruise_lane(lane, parameters = nil, env = nil, disable_runner_upgrades: false, swift_server_port: nil)
+      UI.user_error!("lane must be a string") unless lane.kind_of?(String) || lane.nil?
+      UI.user_error!("parameters must be a hash") unless parameters.kind_of?(Hash) || parameters.nil?
+
+      # Sets environment variable and lane context for lane name
+      ENV["FASTLANE_LANE_NAME"] = lane
+      Actions.lane_context[Actions::SharedValues::LANE_NAME] = lane
+
+      started = Time.now
+      e = nil
+      begin
+        display_upgraded_message = false
+        if disable_runner_upgrades
+          UI.verbose("disable_runner_upgrades is true, not attempting to update the FastlaneRunner project".yellow)
+        elsif Helper.ci?
+          UI.verbose("Running in CI, not attempting to update the FastlaneRunner project".yellow)
+        else
+          display_upgraded_message = self.ensure_runner_up_to_date_fastlane!
+        end
+
+        self.ensure_runner_built!
+        swift_server_port ||= 2000
+        socket_thread = self.start_socket_thread(port: swift_server_port)
+        sleep(0.250) while socket_thread[:ready].nil?
+        # wait on socket_thread to be in ready state, then start the runner thread
+        self.cruise_swift_lane_in_thread(lane, parameters, swift_server_port)
+
+        socket_thread.value
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        e = ex
+      end
+      # If we have a thread exception, drop that in the exception
+      # won't ever have a situation where e is non-nil, and socket_thread[:exception] is also non-nil
+      e ||= socket_thread[:exception]
+
+      unless e.nil?
+        print_lane_context
+
+        # 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
+        UI.error(e.to_s) if e.kind_of?(StandardError) # we don't want to print things like 'system exit'
+      end
+
+      skip_message = false
+
+      # if socket_thread is nil, we were probably debugging, or something else weird happened
+      exit_reason = :cancelled if socket_thread.nil?
+
+      # normal exit means we have a reason
+      exit_reason ||= socket_thread[:exit_reason]
+
+      if exit_reason == :cancelled && e.nil?
+        skip_message = true
+      end
+
+      duration = ((Time.now - started) / 60.0).round
+
+      finish_fastlane(nil, duration, e, skip_message: skip_message)
+
+      if display_upgraded_message
+        UI.message("We updated your FastlaneRunner project during this run to make it compatible with your current version of fastlane.".yellow)
+        UI.message("Please make sure to check the changes into source control.".yellow)
+      end
+    end
+
+    def self.display_lanes
+      self.ensure_runner_built!
+      return_value = Actions.sh(%(#{FastlaneCore::FastlaneFolder.swift_runner_path} lanes))
+      if FastlaneCore::Globals.verbose?
+        UI.message("runner output: ".yellow + return_value)
+      end
+    end
+
+    def self.cruise_swift_lane_in_thread(lane, parameters = nil, swift_server_port)
+      if parameters.nil?
+        parameters = {}
+      end
+
+      parameter_string = ""
+      parameters.each do |key, value|
+        parameter_string += " #{key} #{value}"
+      end
+
+      if FastlaneCore::Globals.verbose?
+        parameter_string += " logMode verbose"
+      end
+
+      parameter_string += " swiftServerPort #{swift_server_port}"
+
+      return Thread.new do
+        if FastlaneCore::Globals.verbose?
+          return_value = Actions.sh(%(#{FastlaneCore::FastlaneFolder.swift_runner_path} lane #{lane}#{parameter_string}))
+          UI.message("runner output: ".yellow + return_value)
+        else
+          Actions.sh(%(#{FastlaneCore::FastlaneFolder.swift_runner_path} lane #{lane}#{parameter_string} > /dev/null))
+        end
+      end
+    end
+
+    def self.swap_paths_in_target(target: nil, file_refs_to_swap: nil, expected_path_to_replacement_path_tuples: nil)
+      made_project_updates = false
+      file_refs_to_swap.each do |file_ref|
+        expected_path_to_replacement_path_tuples.each do |preinstalled_config_relative_path, user_config_relative_path|
+          next unless file_ref.path == preinstalled_config_relative_path
+
+          file_ref.path = user_config_relative_path
+          made_project_updates = true
+        end
+      end
+      return made_project_updates
+    end
+
+    # Find all the config files we care about (Deliverfile, Gymfile, etc), and build tuples of what file we'll look for
+    # in the Xcode project, and what file paths we'll need to swap (since we have to inject the user's configs)
+    #
+    # Return a mapping of what file paths we're looking => new file pathes we'll need to inject
+    def self.collect_tool_paths_for_replacement(all_user_tool_file_paths: nil, look_for_new_configs: nil)
+      new_user_tool_file_paths = all_user_tool_file_paths.select do |user_config, preinstalled_config_relative_path, user_config_relative_path|
+        if look_for_new_configs
+          File.exist?(user_config)
+        else
+          !File.exist?(user_config)
+        end
+      end
+
+      # Now strip out the fastlane-relative path and leave us with xcodeproj relative paths
+      new_user_tool_file_paths = new_user_tool_file_paths.map do |user_config, preinstalled_config_relative_path, user_config_relative_path|
+        if look_for_new_configs
+          [preinstalled_config_relative_path, user_config_relative_path]
+        else
+          [user_config_relative_path, preinstalled_config_relative_path]
+        end
+      end
+      return new_user_tool_file_paths
+    end
+
+    # open and return the swift project
+    def self.runner_project
+      runner_project_path = FastlaneCore::FastlaneFolder.swift_runner_project_path
+      require 'xcodeproj'
+      project = Xcodeproj::Project.open(runner_project_path)
+      return project
+    end
+
+    # return the FastlaneRunner build target
+    def self.target_for_fastlane_runner_project(runner_project: nil)
+      fastlane_runner_array = runner_project.targets.select do |target|
+        target.name == "FastlaneRunner"
+      end
+
+      # get runner target
+      runner_target = fastlane_runner_array.first
+      return runner_target
+    end
+
+    def self.target_source_file_refs(target: nil)
+      return target.source_build_phase.files.to_a.map(&:file_ref)
+    end
+
+    def self.first_time_setup
+      setup_message = ["fastlane is now configured to use a swift-based Fastfile (Fastfile.swift) 🦅"]
+      setup_message << "To edit your new Fastfile.swift, type: `open #{FastlaneCore::FastlaneFolder.swift_runner_project_path}`"
+
+      # Go through and link up whatever we generated during `fastlane init swift` so the user can edit them easily
+      self.link_user_configs_to_project(updated_message: setup_message.join("\n"))
+    end
+
+    def self.link_user_configs_to_project(updated_message: nil)
+      tool_files_folder = FastlaneCore::FastlaneFolder.path
+
+      # All the tools that could have <tool name>file.swift their paths, and where we expect to find the user's tool files.
+      all_user_tool_file_paths = TOOL_CONFIG_FILES.map do |tool_name|
+        [
+          File.join(tool_files_folder, "#{tool_name}.swift"),
+          "../#{tool_name}.swift",
+          "../../#{tool_name}.swift"
+        ]
+      end
+
+      # Tool files the user now provides
+      new_user_tool_file_paths = collect_tool_paths_for_replacement(all_user_tool_file_paths: all_user_tool_file_paths, look_for_new_configs: true)
+
+      # Tool files we provide AND the user doesn't provide
+      user_tool_files_possibly_removed = collect_tool_paths_for_replacement(all_user_tool_file_paths: all_user_tool_file_paths, look_for_new_configs: false)
+
+      fastlane_runner_project = self.runner_project
+      runner_target = target_for_fastlane_runner_project(runner_project: fastlane_runner_project)
+      target_file_refs = target_source_file_refs(target: runner_target)
+
+      # Swap in all new user supplied configs into the project
+      project_modified = swap_paths_in_target(
+        target: runner_target,
+        file_refs_to_swap: target_file_refs,
+        expected_path_to_replacement_path_tuples: new_user_tool_file_paths
+      )
+
+      # Swap out any configs the user has removed, inserting fastlane defaults
+      project_modified = swap_paths_in_target(
+        target: runner_target,
+        file_refs_to_swap: target_file_refs,
+        expected_path_to_replacement_path_tuples: user_tool_files_possibly_removed
+      ) || project_modified
+
+      if project_modified
+        fastlane_runner_project.save
+        updated_message ||= "Updated #{FastlaneCore::FastlaneFolder.swift_runner_project_path}"
+        UI.success(updated_message)
+      else
+        UI.success("FastlaneSwiftRunner project is up-to-date")
+      end
+
+      return project_modified
+    end
+
+    def self.start_socket_thread(port: nil)
+      require 'fastlane/server/socket_server'
+      require 'fastlane/server/socket_server_action_command_executor'
+
+      return Thread.new do
+        command_executor = SocketServerActionCommandExecutor.new
+        server = Fastlane::SocketServer.new(command_executor: command_executor, port: port)
+        server.start
+      end
+    end
+
+    def self.ensure_runner_built!
+      UI.verbose("Checking for new user-provided tool configuration files")
+      # if self.link_user_configs_to_project returns true, that means we need to rebuild the runner
+      runner_needs_building = self.link_user_configs_to_project
+
+      if FastlaneCore::FastlaneFolder.swift_runner_built?
+        runner_last_modified_age = File.mtime(FastlaneCore::FastlaneFolder.swift_runner_path).to_i
+        fastfile_last_modified_age = File.mtime(FastlaneCore::FastlaneFolder.fastfile_path).to_i
+
+        if runner_last_modified_age < fastfile_last_modified_age
+          # It's older than the Fastfile, so build it again
+          UI.verbose("Found changes to user's Fastfile.swift, setting re-build runner flag")
+          runner_needs_building = true
+        end
+      else
+        # Runner isn't built yet, so build it
+        UI.verbose("No runner found, setting re-build runner flag")
+        runner_needs_building = true
+      end
+
+      if runner_needs_building
+        self.build_runner!
+      end
+    end
+
+    # do we have the latest FastlaneSwiftRunner code from the current version of fastlane?
+    def self.ensure_runner_up_to_date_fastlane!
+      upgraded = false
+      upgrader = SwiftRunnerUpgrader.new
+
+      upgrade_needed = upgrader.upgrade_if_needed!(dry_run: true)
+      if upgrade_needed
+        UI.message("It looks like your `FastlaneSwiftRunner` project is not up-to-date".green)
+        UI.message("If you don't update it, fastlane could fail".green)
+        UI.message("We can try to automatically update it for you, usually this works 🎈 🐐".green)
+        user_wants_upgrade = UI.confirm("Should we try to upgrade just your `FastlaneSwiftRunner` project?")
+
+        UI.important("Ok, if things break, you can try to run this lane again and you'll be prompted to upgrade another time") unless user_wants_upgrade
+
+        if user_wants_upgrade
+          upgraded = upgrader.upgrade_if_needed!
+          UI.success("Updated your FastlaneSwiftRunner project with the newest runner code") if upgraded
+          self.build_runner! if upgraded
+        end
+      end
+
+      return upgraded
+    end
+
+    def self.build_runner!
+      UI.verbose("Building FastlaneSwiftRunner")
+      require 'fastlane_core'
+      require 'gym'
+      require 'gym/generators/build_command_generator'
+
+      project_options = {
+          project: FastlaneCore::FastlaneFolder.swift_runner_project_path,
+          skip_archive: true
+        }
+      Gym.config = FastlaneCore::Configuration.create(Gym::Options.available_options, project_options)
+      build_command = Gym::BuildCommandGenerator.generate
+
+      FastlaneCore::CommandExecutor.execute(
+        command: build_command,
+        print_all: false,
+        print_command: !Gym.config[:silent]
+      )
+    end
+  end
+end

data/fastlane/lib/fastlane/swift_runner_upgrader.rb

@@ -0,0 +1,265 @@
+require 'xcodeproj'
+require 'fileutils'
+
+module Fastlane
+  # current logic:
+  # - find all groups in existing project
+  # -- if a group is missing, add it
+  # --- add all files for group into new group, build target, and compile phase
+  # - iterate through existing groups
+  # -- update all files needing updating
+  # - iterate through existing groups
+  # -- if a file from the manifest is new, add it to group, build target, and compile phase
+  # - Save and return true if any action was taken to modify any file (project included)
+
+  # build project
+  class SwiftRunnerUpgrader
+    API_VERSION_REGEX = /FastlaneRunnerAPIVersion\s*\[\s*([0-9]+.[0-9]+.[0-9]+)\s*\]/ # also used by SwiftFastlaneAPIGenerator
+
+    attr_accessor :target_project # project we'll be updating
+    attr_accessor :fastlane_runner_target # FastlaneRunner xcodeproj target
+    attr_accessor :manifest_hash # hash of file names to group names they belong to
+    attr_accessor :manifest_groups # unique list of group names that came from the manifest
+    attr_accessor :target_swift_code_file_folder_path # location in filesystem where all swift files should exist when we're done
+    attr_accessor :source_swift_code_file_folder_path # source location of where we're copying file from during the upgrade process
+
+    RELATIVE_SOURCE_FILE_PATH = "../"
+
+    def initialize
+      @source_swift_code_file_folder_path = File.expand_path(File.join(Fastlane::ROOT, "/swift"))
+      @target_swift_code_file_folder_path = FastlaneCore::FastlaneFolder.swift_folder_path
+
+      Fastlane::Setup.setup_swift_support
+
+      manifest_file = File.join(@source_swift_code_file_folder_path, "/upgrade_manifest.json")
+      UI.success("loading manifest: #{manifest_file}")
+      @manifest_hash = JSON.parse(File.read(manifest_file))
+      @manifest_groups = @manifest_hash.values.uniq
+
+      runner_project_path = FastlaneCore::FastlaneFolder.swift_runner_project_path
+      @target_project = Xcodeproj::Project.open(runner_project_path)
+
+      @root_group = @target_project.groups.select { |group| group.name == "Fastlane Runner" }.first
+
+      @fastlane_runner_target = @target_project.targets.select { |target| target.name == "FastlaneRunner" }.first
+    end
+
+    def upgrade_if_needed!(dry_run: false)
+      upgraded = add_missing_flags!(dry_run: dry_run)
+      upgraded = add_missing_copy_phase!(dry_run: dry_run) || upgraded
+      upgraded = add_missing_groups_and_files!(dry_run: dry_run) || upgraded
+      upgraded = upgrade_files!(dry_run: dry_run) || upgraded
+      upgraded = add_new_files_to_groups! || upgraded
+
+      UI.verbose("FastlaneRunner project has been updated and can be written back to disk") if upgraded
+      unless dry_run
+        UI.verbose("FastlaneRunner project changes have been stored") if upgraded
+        target_project.save if upgraded
+      end
+
+      return upgraded
+    end
+
+    def upgrade_files!(dry_run: false)
+      upgraded_anything = false
+      self.manifest_hash.each do |filename, group|
+        upgraded_anything = copy_file_if_needed!(filename: filename, dry_run: dry_run) || upgraded_anything
+      end
+      return upgraded_anything
+    end
+
+    def find_missing_groups
+      missing_groups = []
+
+      existing_group_names_set = @root_group.groups.map { |group| group.name.downcase }.to_set
+      self.manifest_groups.each do |group_name|
+        unless existing_group_names_set.include?(group_name.downcase)
+          missing_groups << group_name
+        end
+      end
+      return missing_groups
+    end
+
+    # compares source file against the target file's FastlaneRunnerAPIVersion and returned `true` if there is a difference
+    def file_needs_update?(filename: nil)
+      # looking for something like: FastlaneRunnerAPIVersion [0.9.1]
+      regex_to_use = API_VERSION_REGEX
+
+      source = File.join(self.source_swift_code_file_folder_path, "/#{filename}")
+      target = File.join(self.target_swift_code_file_folder_path, "/#{filename}")
+
+      # target doesn't have the file yet, so ya, I'd say it needs to be updated
+      return true unless File.exist?(target)
+
+      source_file_content = File.read(source)
+      target_file_content = File.read(target)
+
+      # ignore if files don't contain FastlaneRunnerAPIVersion
+      return false unless source_file_content.include?("FastlaneRunnerAPIVersion")
+      return false unless target_file_content.include?("FastlaneRunnerAPIVersion")
+
+      bundled_version = source_file_content.match(regex_to_use)[1]
+      target_version = target_file_content.match(regex_to_use)[1]
+      file_versions_are_different = bundled_version != target_version
+
+      UI.verbose("#{filename} FastlaneRunnerAPIVersion (bundled/target): #{bundled_version}/#{target_version}")
+      files_are_different = source_file_content != target_file_content
+
+      if files_are_different && !file_versions_are_different
+        UI.verbose("File versions are the same, but the two files are not equal, so that's a problem, setting needs update to 'true'")
+      end
+
+      needs_update = file_versions_are_different || files_are_different
+
+      return needs_update
+    end
+
+    # currently just copies file, even if not needed.
+    def copy_file_if_needed!(filename: nil, dry_run: false)
+      needs_update = file_needs_update?(filename: filename)
+      UI.verbose("file #{filename} needs an update") if needs_update
+
+      # Ok, we know if this file needs an update, can return now if it's a dry run
+      return needs_update if dry_run
+
+      unless needs_update
+        # no work needed, just return
+        return false
+      end
+
+      source = File.join(self.source_swift_code_file_folder_path, "/#{filename}")
+      target = File.join(self.target_swift_code_file_folder_path, "/#{filename}")
+
+      FileUtils.cp(source, target)
+      UI.verbose("Copied #{source} to #{target}")
+      return true
+    end
+
+    def add_new_files_to_groups!
+      inverted_hash = {}
+
+      # need {group => [file1, file2, etc..]} instead of: {file1 => group, file2 => group, etc...}
+      self.manifest_hash.each do |filename, group_name|
+        group_name = group_name.downcase
+
+        files_in_group = inverted_hash[group_name]
+        if files_in_group.nil?
+          files_in_group = []
+          inverted_hash[group_name] = files_in_group
+        end
+        files_in_group << filename
+      end
+
+      # this helps us signal to the user that we made changes
+      updated_project = false
+      # iterate through the groups and collect all the swift files in each
+      @root_group.groups.each do |group|
+        # current group's filenames
+        existing_group_files_set = group.files
+                                        .select { |file| !file.name.nil? && file.name.end_with?(".swift") }
+                                        .map(&:name)
+                                        .to_set
+
+        group_name = group.name.downcase
+        manifest_group_filenames = inverted_hash[group_name]
+
+        # compare the current group files to what the manifest says should minially be there
+        manifest_group_filenames.each do |filename|
+          # current group is missing a file from the manifest, need to add it
+          next if existing_group_files_set.include?(filename)
+
+          UI.verbose("Adding new file #{filename} to group: `#{group.name}`")
+          new_file_reference = group.new_file("#{RELATIVE_SOURCE_FILE_PATH}#{filename}")
+
+          # add references to the target, and make sure they are added to the build phase to
+          self.fastlane_runner_target.source_build_phase.add_file_reference(new_file_reference)
+
+          updated_project = true
+        end
+      end
+
+      return updated_project
+    end
+
+    # adds new groups, and the files inside those groups
+    # Note: this does not add new files to existing groups, that is in add_new_files_to_groups!
+    def add_missing_groups_and_files!(dry_run: false)
+      missing_groups = self.find_missing_groups.to_set
+      unless missing_groups.length > 0
+        UI.verbose("No missing groups found, so we don't need to worry about adding new groups")
+        return false
+      end
+
+      # well, we know we have some changes to make, so if this is a dry run,
+      # don't bother doing anything and just return true
+      return true if dry_run
+
+      missing_groups.each do |missing_group_name|
+        new_group = @root_group.new_group(missing_group_name)
+
+        # find every file in the manifest that belongs to the new group, and add it to the new group
+        self.manifest_hash.each do |filename, group|
+          next unless group.casecmp(missing_group_name.downcase).zero?
+          # assumes this is a new file, we don't handle moving files between groups
+          new_file_reference = new_group.new_file("#{RELATIVE_SOURCE_FILE_PATH}#{filename}")
+
+          # add references to the target, and make sure they are added to the build phase to
+          self.fastlane_runner_target.source_build_phase.add_file_reference(new_file_reference)
+        end
+      end
+
+      return true # yup, we definitely updated groups
+    end
+
+    # adds build_settings flags to fastlane_runner_target
+    def add_missing_flags!(dry_run: false)
+      # Check if upgrade is needed
+      # If fastlane build settings exists already, we don't need any more changes to the Xcode project
+      self.fastlane_runner_target.build_configurations.each { |config|
+        return true if dry_run && config.build_settings["CODE_SIGN_IDENTITY"].nil?
+        return true if dry_run && config.build_settings["MACOSX_DEPLOYMENT_TARGET"].nil?
+      }
+      return false if dry_run
+
+      # Proceed to upgrade
+      self.fastlane_runner_target.build_configurations.each { |config|
+        config.build_settings["CODE_SIGN_IDENTITY"] = "-"
+        config.build_settings["MACOSX_DEPLOYMENT_TARGET"] = "10.12"
+      }
+      target_project.save
+    end
+
+    # adds new copy files build phase to fastlane_runner_target
+    def add_missing_copy_phase!(dry_run: false)
+      # Check if upgrade is needed
+      # If fastlane copy files build phase exists already, we don't need any more changes to the Xcode project
+      phase_copy_sign = self.fastlane_runner_target.copy_files_build_phases.select { |phase_copy| phase_copy.name == "FastlaneRunnerCopySigned" }.first
+
+      old_phase_copy_sign = self.fastlane_runner_target.shell_script_build_phases.select { |phase_copy| phase_copy.shell_script == "cd \"${SRCROOT}\"\ncd ../..\ncp \"${TARGET_BUILD_DIR}/${EXECUTABLE_PATH}\" .\n" }.first
+
+      return true if dry_run && phase_copy_sign.nil?
+
+      return false if dry_run
+
+      # Proceed to upgrade
+      old_phase_copy_sign.remove_from_project unless old_phase_copy_sign.nil?
+
+      unless phase_copy_sign
+        # Create a copy files build phase
+        phase_copy_sign = self.fastlane_runner_target.new_copy_files_build_phase("FastlaneRunnerCopySigned")
+        phase_copy_sign.dst_path = "$SRCROOT/../.."
+        phase_copy_sign.dst_subfolder_spec = "0"
+        phase_copy_sign.run_only_for_deployment_postprocessing = "0"
+        targetBinaryReference = self.fastlane_runner_target.product_reference
+        phase_copy_sign.add_file_reference(targetBinaryReference)
+
+        # Set "Code sign on copy" flag on Xcode for fastlane_runner_target
+        targetBinaryReference.build_files.each { |target_binary_build_file_reference|
+          target_binary_build_file_reference.settings = { "ATTRIBUTES": ["CodeSignOnCopy"] }
+        }
+      end
+
+      target_project.save
+    end
+  end
+end

data/fastlane/lib/fastlane/tools.rb

@@ -0,0 +1,50 @@
+module Fastlane
+  TOOLS = [
+    :fastlane,
+    :pilot,
+    :spaceship,
+    :produce,
+    :deliver,
+    :frameit,
+    :pem,
+    :snapshot,
+    :screengrab,
+    :supply,
+    :cert,
+    :sigh,
+    :match,
+    :scan,
+    :gym,
+    :precheck,
+    :trainer
+  ]
+
+  # a list of all the config files we currently expect
+  TOOL_CONFIG_FILES = [
+    "Appfile",
+    "Deliverfile",
+    "Fastfile",
+    "Gymfile",
+    "Matchfile",
+    "Precheckfile",
+    "Scanfile",
+    "Screengrabfile",
+    "Snapshotfile"
+  ]
+
+  TOOL_ALIASES = {
+    "get_certificates": "cert",
+    "upload_to_app_store": "deliver",
+    "frame_screenshots": "frameit",
+    "build_app": "gym",
+    "build_ios_app": "gym",
+    "build_mac_app": "gym",
+    "sync_code_signing": "match",
+    "get_push_certificate": "pem",
+    "check_app_store_metadata": "precheck",
+    "capture_android_screenshots": "screengrab",
+    "get_provisioning_profile": "sigh",
+    "capture_ios_screenshots": "snapshot",
+    "upload_to_play_store": "supply"
+  }
+end

data/fastlane/lib/fastlane/version.rb

@@ -0,0 +1,6 @@
+module Fastlane
+  VERSION = '2.212.1'.freeze
+  DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
+  MINIMUM_XCODE_RELEASE = "7.0".freeze
+  RUBOCOP_REQUIREMENT = '1.12.1'.freeze
+end

data/fastlane/lib/fastlane.rb

@@ -0,0 +1,53 @@
+require 'fastlane_core'
+
+require 'fastlane/version'
+require 'fastlane/features'
+require 'fastlane/shells'
+require 'fastlane/tools'
+require 'fastlane/documentation/actions_list'
+require 'fastlane/actions/actions_helper' # has to be before fast_file
+require 'fastlane/fast_file'
+require 'fastlane/runner'
+require 'fastlane/setup/setup'
+require 'fastlane/lane'
+require 'fastlane/junit_generator'
+require 'fastlane/lane_manager'
+require 'fastlane/lane_manager_base'
+require 'fastlane/swift_lane_manager'
+require 'fastlane/action'
+require 'fastlane/action_collector'
+require 'fastlane/supported_platforms'
+require 'fastlane/configuration_helper'
+require 'fastlane/one_off'
+require 'fastlane/server/socket_server_action_command_executor'
+require 'fastlane/server/socket_server'
+require 'fastlane/command_line_handler'
+require 'fastlane/documentation/docs_generator'
+require 'fastlane/other_action'
+require 'fastlane/plugins/plugins'
+require 'fastlane/fastlane_require'
+require "fastlane/swift_fastlane_api_generator.rb"
+
+module Fastlane
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+
+  class << self
+    def load_actions
+      Fastlane::Actions.load_default_actions
+      Fastlane::Actions.load_helpers
+
+      if FastlaneCore::FastlaneFolder.path
+        actions_path = File.join(FastlaneCore::FastlaneFolder.path, 'actions')
+        @external_actions = Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+      end
+    end
+
+    attr_reader :external_actions
+
+    def plugin_manager
+      @plugin_manager ||= Fastlane::PluginManager.new
+    end
+  end
+end