fastlane 2.69.0.beta.20171212010004 → 2.69.0

data/fastlane/lib/fastlane/swift_fastlane_function.rb

@@ -0,0 +1,342 @@
+module Fastlane
+  class SwiftFunction
+    attr_accessor :function_name
+    attr_accessor :return_type
+    attr_accessor :param_names
+    attr_accessor :param_descriptions
+    attr_accessor :param_default_values
+    attr_accessor :param_optionality_values
+    attr_accessor :param_type_overrides
+    attr_accessor :reserved_words
+    attr_accessor :default_values_to_ignore
+
+    def initialize(action_name: nil, keys: nil, key_descriptions: nil, key_default_values: nil, key_optionality_values: nil, key_type_overrides: nil, return_type: nil)
+      @function_name = action_name
+      @param_names = keys
+      @param_descriptions = key_descriptions
+      @param_default_values = key_default_values
+      @param_optionality_values = key_optionality_values
+      @return_type = return_type
+      @param_type_overrides = key_type_overrides
+
+      # rubocop:disable LineLength
+      # class instance?
+      @reserved_words = %w[associativity break case catch class continue convenience default deinit didSet do else enum extension fallthrough false final for func get guard if in infix init inout internal lazy let mutating nil operator override postfix precedence prefix private public repeat required return self set static struct subscript super switch throws true try var weak where while willSet].to_set
+      # rubocop:enable LineLength
+
+      @default_values_to_ignore = {
+        "cert" => ["keychain_path"].to_set,
+        "set_github_release" => ["api_token"].to_set,
+        "github_api" => ["api_token"].to_set,
+        "create_pull_request" => ["api_token", "head", "api_url"].to_set,
+        "commit_github_file" => ["api_token"].to_set,
+        "verify_xcode" => ["xcode_path"].to_set,
+        "produce" => ["sku"].to_set,
+        "create_app_online" => ["sku"].to_set,
+        "screengrab" => ["android_home"].to_set
+      }
+    end
+
+    def ignore_default_value?(function_name: nil, param_name: nil)
+      action_set = @default_values_to_ignore[function_name]
+      unless action_set
+        return false
+      end
+
+      return action_set.include?(param_name)
+    end
+
+    def sanitize_reserved_word(word: nil)
+      unless @reserved_words.include?(word)
+        return word
+      end
+      return "`#{word}`"
+    end
+
+    def return_declaration
+      expected_type = swift_type_for_return_type
+      unless expected_type.to_s.length > 0
+        return ""
+      end
+
+      return " -> #{expected_type}"
+    end
+
+    def swift_type_for_return_type
+      unless @return_type
+        return ""
+      end
+
+      case @return_type
+      when :string
+        return "String"
+      when :array_of_strings
+        return "[String]"
+      when :hash_of_strings
+        return "[String : String]"
+      when :bool
+        return "Bool"
+      when :int
+        return "Int"
+      else
+        return ""
+      end
+    end
+
+    def camel_case_lower(string: nil)
+      string.split('_').inject([]) { |buffer, e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+    end
+
+    def determine_type_from_override(type_override: nil, default_type: nil)
+      if type_override == Array
+        return "[String]"
+      elsif type_override == Hash
+        return "[String : Any]"
+      elsif type_override == Integer
+        return "Int"
+      elsif type_override == Boolean
+        return "Bool"
+      elsif type_override == :string_callback
+        return "((String) -> Void)"
+      else
+        return default_type
+      end
+    end
+
+    def override_default_value_if_not_correct_type(param_name: nil, param_type: nil, default_value: nil)
+      default_value = nil if ignore_default_value?(function_name: @function_name, param_name: param_name)
+
+      return "[]" if param_type == "[String]" && default_value == ""
+      return "{_ in }" if param_type == "((String) -> Void)"
+
+      return default_value
+    end
+
+    def get_type(param: nil, default_value: nil, optional: nil, param_type_override: nil)
+      unless param_type_override.nil?
+        type = determine_type_from_override(type_override: param_type_override)
+      end
+      type ||= "String"
+
+      optional_specifier = ""
+      # if we are optional and don't have a default value, we'll need to use ?
+      optional_specifier = "?" if (optional && default_value.nil?) && type != "((String) -> Void)"
+
+      if optional && ignore_default_value?(function_name: @function_name, param_name: param)
+        optional_specifier = "?"
+      end
+
+      # If we have a default value of true or false, we can infer it is a Bool
+      if default_value.class == FalseClass
+        type = "Bool"
+      elsif default_value.class == TrueClass
+        type = "Bool"
+      elsif default_value.kind_of?(Array)
+        type = "[String]"
+      end
+      return "#{type}#{optional_specifier}"
+    end
+
+    def parameters
+      unless @param_names
+        return ""
+      end
+
+      param_names_and_types = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides).map do |param, default_value, optional, param_type_override|
+        type = get_type(param: param, default_value: default_value, optional: optional, param_type_override: param_type_override)
+
+        unless default_value.nil?
+          if type == "[String : Any]"
+            # we can't handle default values for Hashes, yet
+            default_value = "[:]"
+          elsif type != "Bool" && type != "[String]" && type != "Int" && type != "((String) -> Void)"
+            default_value = "\"#{default_value}\""
+          end
+        end
+
+        # if we don't have a default value, but the param is optional, set a default value in Swift to be nil
+        if optional && default_value.nil?
+          default_value = "nil"
+        end
+
+        # sometimes we get to the point where we have a default value but its type is wrong
+        # so we need to correct that because [String] = "" is not valid swift
+        default_value = override_default_value_if_not_correct_type(param_type: type, param_name: param, default_value: default_value)
+
+        param = camel_case_lower(string: param)
+        param = sanitize_reserved_word(word: param)
+
+        if default_value.nil?
+          "#{param}: #{type}"
+        else
+          "#{param}: #{type} = #{default_value}"
+        end
+      end
+
+      return param_names_and_types
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def swift_code
+      function_name = camel_case_lower(string: self.function_name)
+      function_return_declaration = self.return_declaration
+      discardable_result = function_return_declaration.length > 0 ? "@discardableResult " : ''
+
+      # Calculate the necessary indent to line up parameter names on new lines
+      # with the first parameter after the opening paren following the function name.
+      # i.e.: @discardableResult func someFunctionName(firstParameter: T
+      #                                                secondParameter: T)
+      # This just creates a string with as many spaces are necessary given whether or not
+      # the function has a 'discardableResult' annotation, the 'func' keyword, function name
+      # and the opening paren.
+      function_keyword_definition = 'func '
+      open_paren = '('
+      closed_paren = ')'
+      indent = ' ' * (discardable_result.length + function_name.length + function_keyword_definition.length + open_paren.length)
+      params = self.parameters.join(",\n#{indent}")
+
+      return "#{discardable_result}#{function_keyword_definition}#{function_name}#{open_paren}#{params}#{closed_paren}#{function_return_declaration} {\n#{self.implementation}\n}"
+    end
+
+    def build_argument_list
+      unless @param_names
+        return "[]" # return empty list for argument
+      end
+
+      argument_object_strings = @param_names.zip(param_type_overrides).map do |name, type_override|
+        sanitized_name = camel_case_lower(string: name)
+        sanitized_name = sanitize_reserved_word(word: sanitized_name)
+        type_string = type_override == :string_callback ? ", type: .stringClosure" : nil
+
+        "RubyCommand.Argument(name: \"#{name}\", value: #{sanitized_name}#{type_string})"
+      end
+      return argument_object_strings
+    end
+
+    def return_statement
+      returned_object = "runner.executeCommand(command)"
+      case @return_type
+      when :array_of_strings
+        returned_object = "parseArray(fromString: #{returned_object})"
+      when :hash_of_strings
+        returned_object = "parseDictionary(fromString: #{returned_object})"
+      when :bool
+        returned_object = "parseBool(fromString: #{returned_object})"
+      when :int
+        returned_object = "parseInt(fromString: #{returned_object})"
+      end
+
+      expected_type = swift_type_for_return_type
+
+      return_string = "_ = "
+      if expected_type.length > 0
+        return_string = "return "
+      end
+      return "#{return_string}#{returned_object}"
+    end
+
+    def implementation
+      args = build_argument_list
+
+      implm = "  let command = RubyCommand(commandID: \"\", methodName: \"#{@function_name}\", className: nil, args: ["
+      # Get the indent of the first argument in the list to give each
+      # subsequent argument it's own line with proper indenting
+      indent = ' ' * implm.length
+      implm += args.join(",\n#{indent}")
+      implm += "])\n"
+      return implm + "  #{return_statement}"
+    end
+  end
+
+  class ToolSwiftFunction < SwiftFunction
+    def protocol_name
+      function_name = camel_case_lower(string: self.function_name)
+      return function_name.capitalize + "fileProtocol"
+    end
+
+    def class_name
+      function_name = camel_case_lower(string: self.function_name)
+      return function_name.capitalize + "file"
+    end
+
+    def swift_vars
+      unless @param_names
+        return []
+      end
+      swift_vars = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides).map do |param, default_value, optional, param_type_override|
+        type = get_type(param: param, default_value: default_value, optional: optional, param_type_override: param_type_override)
+
+        param = camel_case_lower(string: param)
+        param = sanitize_reserved_word(word: param)
+        static_var_for_parameter_name = param
+        "  var #{static_var_for_parameter_name}: #{type} { get }"
+      end
+
+      return swift_vars
+    end
+
+    def swift_default_implementations
+      unless @param_names
+        return []
+      end
+
+      swift_implementations = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides).map do |param, default_value, optional, param_type_override|
+        type = get_type(param: param, default_value: default_value, optional: optional, param_type_override: param_type_override)
+
+        default_value = nil if ignore_default_value?(function_name: @function_name, param_name: param)
+
+        param = camel_case_lower(string: param)
+        param = sanitize_reserved_word(word: param)
+        var_for_parameter_name = param
+
+        unless default_value.nil?
+          if type == "Bool" || type == "[String]" || type == "Int" || default_value.kind_of?(Array)
+            default_value = default_value.to_s
+          else
+            default_value = "\"#{default_value}\""
+          end
+        end
+
+        # if we don't have a default value, but the param is options, just set a default value to nil
+        if optional && default_value.nil?
+          default_value = "nil"
+        end
+
+        # if we don't have a default value still, we need to assign them based on type
+        if type == "String"
+          default_value ||= "\"\""
+        end
+
+        if type == "Bool"
+          default_value ||= "false"
+        end
+
+        if type == "[String]"
+          default_value ||= "[]"
+        end
+
+        "  var #{var_for_parameter_name}: #{type} { return #{default_value} }"
+      end
+
+      return swift_implementations
+    end
+
+    def parameters
+      unless @param_names
+        return ""
+      end
+
+      param_names_and_types = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides).map do |param, default_value, optional, param_type_override|
+        type = get_type(param: param, default_value: default_value, optional: optional, param_type_override: param_type_override)
+
+        param = camel_case_lower(string: param)
+        param = sanitize_reserved_word(word: param)
+        static_var_for_parameter_name = param
+
+        "#{param}: #{type} = #{self.class_name.downcase}.#{static_var_for_parameter_name}"
+      end
+
+      return param_names_and_types
+    end
+  end
+end

data/fastlane/lib/fastlane/swift_lane_manager.rb

@@ -0,0 +1,246 @@
+require_relative 'lane_manager_base.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)
+      UI.user_error!("lane must be a string") unless lane.kind_of?(String) or lane.nil?
+      UI.user_error!("parameters must be a hash") unless parameters.kind_of?(Hash) or parameters.nil?
+
+      # xcodeproj has a bug in certain versions that causes it to change directories
+      # and not return to the original working directory
+      # https://github.com/CocoaPods/Xcodeproj/issues/426
+      # Setting this environment variable causes xcodeproj to work around the problem
+      ENV["FORK_XCODE_WRITING"] = "true"
+
+      FastlaneCore.session.is_fastfile = true
+
+      load_dot_env(env)
+
+      started = Time.now
+      e = nil
+      begin
+        self.ensure_runner_built!
+        socket_thread = self.start_socket_thread
+        sleep(0.250) while socket_thread[:ready].nil?
+        # wait on socket_thread to be in ready state, then start the runner thread
+        runner_thread = self.cruise_swift_lane_in_thread(lane, parameters)
+
+        runner_thread.join
+        socket_thread.join
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        # 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
+
+        print_lane_context
+        UI.error ex.to_s if ex.kind_of?(StandardError) # we don't want to print things like 'system exit'
+        e = ex
+      end
+
+      duration = ((Time.now - started) / 60.0).round
+
+      finish_fastlane(nil, duration, e)
+    end
+
+    def self.display_lanes
+      self.ensure_runner_built!
+      Actions.sh(%(#{FastlaneCore::FastlaneFolder.swift_runner_path} lanes))
+    end
+
+    def self.cruise_swift_lane_in_thread(lane, parameters = nil)
+      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
+
+      return Thread.new do
+        Actions.sh(%(#{FastlaneCore::FastlaneFolder.swift_runner_path} lane #{lane}#{parameter_string} > /dev/null))
+      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
+      )
+
+      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
+      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)
+        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
+
+    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],
+        error: proc do |output|
+          ErrorHandler.handle_build_error(output)
+        end
+      )
+    end
+  end
+end