fastlane 2.69.0.beta.20171212010004 → 2.69.0

data/fastlane/lib/fastlane/server/socket_server_action_command_executor.rb

@@ -0,0 +1,100 @@
+require 'fastlane/server/command.rb'
+require 'fastlane/server/command_executor.rb'
+
+module Fastlane
+  # Handles receiving commands from the socket server, finding the Action to be invoked,
+  # invoking it, and returning any return values
+  class SocketServerActionCommandExecutor < CommandExecutor
+    attr_accessor :runner
+    attr_accessor :actions_requiring_special_handling
+
+    def initialize
+      Fastlane.load_actions
+      @runner = Runner.new
+      @actions_requiring_special_handling = ["sh"].to_set
+    end
+
+    def execute(command: nil, target_object: nil)
+      action_name = command.method_name
+      action_class_ref = class_ref_for_action(named: action_name)
+      parameter_map = {}
+      closure_argument_value = nil
+
+      command.args.each do |arg|
+        arg_value = arg.value
+        if arg.value_type.to_s.to_sym == :string_closure
+          closure = proc { |string_value| closure_argument_value = string_value }
+          arg_value = closure
+        end
+        parameter_map[arg.name.to_sym] = arg_value
+      end
+
+      if @actions_requiring_special_handling.include?(action_name)
+        command_return = run_action_requiring_special_handling(
+          command: command,
+          parameter_map: parameter_map,
+          action_return_type: action_class_ref.return_type
+        )
+        return command_return
+      end
+
+      action_return = run(
+        action_named: action_name,
+        action_class_ref: action_class_ref,
+        parameter_map: parameter_map
+      )
+
+      command_return = CommandReturn.new(
+        return_value: action_return,
+        return_value_type: action_class_ref.return_type,
+        closure_argument_value: closure_argument_value
+      )
+      return command_return
+    end
+
+    def class_ref_for_action(named: nil)
+      class_ref = Actions.action_class_ref(named)
+      unless class_ref
+        if Fastlane::Actions.formerly_bundled_actions.include?(action)
+          # This was a formerly bundled action which is now a plugin.
+          UI.verbose(caller.join("\n"))
+          UI.user_error!("The action '#{action}' is no longer bundled with fastlane. You can install it using `fastlane add_plugin #{action}`")
+        else
+          Fastlane::ActionsList.print_suggestions(action)
+          UI.user_error!("Action '#{action}' not available, run `fastlane actions` to get a full list")
+        end
+      end
+
+      return class_ref
+    end
+
+    def run(action_named: nil, action_class_ref: nil, parameter_map: nil)
+      action_return = runner.execute_action(action_named, action_class_ref, [parameter_map], custom_dir: '.', configuration_language: "swift")
+      return action_return
+    end
+
+    # Some actions have special handling in fast_file.rb, that means we can't directly call the action
+    # but we have to use the same logic that is in fast_file.rb instead.
+    # That's where this switch statement comes into play
+    def run_action_requiring_special_handling(command: nil, parameter_map: nil, action_return_type: nil)
+      action_return = nil
+      closure_argument_value = nil # only used if the action uses it
+
+      case command.method_name
+      when "sh"
+        error_callback = proc { |string_value| closure_argument_value = string_value }
+        command_param = parameter_map[:command]
+        log_param = parameter_map[:log]
+        action_return = Fastlane::FastFile.sh(command_param, log: log_param, error_callback: error_callback)
+      end
+
+      command_return = CommandReturn.new(
+        return_value: action_return,
+        return_value_type: action_return_type,
+        closure_argument_value: closure_argument_value
+      )
+
+      return command_return
+    end
+  end
+end

data/fastlane/lib/fastlane/setup/setup.rb

@@ -1,7 +1,7 @@
 module Fastlane
   class Setup
     # Start the setup process
-    def run(user: nil)
+    def run(user: nil, is_swift_fastfile: false)
       if FastlaneCore::FastlaneFolder.setup? and !Helper.is_test?
         UI.important("fastlane is already set up at path #{FastlaneCore::FastlaneFolder.path}")
         return
@@ -26,12 +26,17 @@ module Fastlane
       end
 
       if platform == :ios
-        SetupIos.new.run(user: user)
+        SetupIos.new.run(user: user, is_swift_fastfile: is_swift_fastfile)
       elsif platform == :android
         SetupAndroid.new.run
       else
         UI.user_error!("Couldn't find platform '#{platform}'")
       end
+
+      # Now that we've setup all the things, if we're using Swift, do the first time setup
+      if is_swift_fastfile
+        Fastlane::SwiftLaneManager.first_time_setup
+      end
     end
 
     def is_ios?

data/fastlane/lib/fastlane/setup/setup_ios.rb

@@ -16,7 +16,10 @@ module Fastlane
     attr_accessor :app_identifier
     attr_accessor :app_name
 
-    def run(user: nil)
+    attr_accessor :is_swift_fastfile
+
+    def run(user: nil, is_swift_fastfile: false)
+      self.is_swift_fastfile = is_swift_fastfile
       self.apple_id = user
       show_infos
 
@@ -110,6 +113,11 @@ module Fastlane
       end
       enable_deliver
       generate_fastfile(manually: false)
+
+      if self.is_swift_fastfile
+        update_swift_runner
+      end
+
       show_analytics
     end
 
@@ -119,6 +127,11 @@ module Fastlane
       detect_installed_tools # after copying the existing files
       ask_to_enable_other_tools
       generate_fastfile(manually: true)
+
+      if self.is_swift_fastfile
+        update_swift_runner
+      end
+
       show_analytics
     end
 
@@ -141,7 +154,6 @@ module Fastlane
       FastlaneCore::Project.detect_projects(config)
       self.project = FastlaneCore::Project.new(config)
       self.project.select_scheme(preferred_to_include: self.project.project_name)
-
       self.app_identifier = self.project.default_app_identifier # These two vars need to be accessed in order to be set
       self.app_name = self.project.default_app_name # They are set as a side effect, this could/should be changed down the road
     end
@@ -197,21 +209,25 @@ module Fastlane
     end
 
     def generate_appfile(manually: false)
-      template = File.read("#{Fastlane::ROOT}/lib/assets/AppfileTemplate")
+      template = File.read(appfile_template_path)
       if manually
         ask_for_app_identifier
         ask_for_apple_id
       end
 
       template.gsub!('[[DEV_PORTAL_TEAM_ID]]', self.dev_portal_team) if self.dev_portal_team
-
-      itc_team = self.itc_team ? "itc_team_id \"#{self.itc_team}\" # iTunes Connect Team ID\n" : ""
-      template.gsub!('[[ITC_TEAM]]', itc_team)
-
       template.gsub!('[[APP_IDENTIFIER]]', self.app_identifier)
       template.gsub!('[[APPLE_ID]]', self.apple_id)
 
-      path = File.join(folder, 'Appfile')
+      if self.is_swift_fastfile
+        itc_team = self.itc_team ? "\"#{self.itc_team}\"" : "nil"
+        path = File.join(folder, 'Appfile.swift')
+      else
+        itc_team = self.itc_team ? "itc_team_id \"#{self.itc_team}\" # iTunes Connect Team ID\n" : ""
+        path = File.join(folder, 'Appfile')
+      end
+      template.gsub!('[[ITC_TEAM]]', itc_team)
+
       File.write(path, template)
       UI.success("Created new file '#{path}'. Edit it to manage your preferred app metadata information.")
     end
@@ -255,6 +271,7 @@ module Fastlane
     def detect_installed_tools
       self.tools = {}
       self.tools[:snapshot] = File.exist?(File.join(folder, 'Snapfile'))
+      self.tools[:snapshot] ||= File.exist?(File.join(folder, 'Snapfile.swift'))
       self.tools[:cocoapods] = File.exist?(File.join(File.expand_path('..', folder), 'Podfile'))
       self.tools[:carthage] = File.exist?(File.join(File.expand_path('..', folder), 'Cartfile'))
     end
@@ -263,36 +280,51 @@ module Fastlane
       UI.message("Loading up 'deliver', this might take a few seconds")
       require 'deliver'
       require 'deliver/setup'
+
       options = FastlaneCore::Configuration.create(Deliver::Options.available_options, {})
       options[:run_precheck_before_submit] = false # precheck doesn't need to run during init
+      options[:username] = self.apple_id if self.apple_id
+      options[:app_identifier] = self.app_identifier if self.app_identifier
 
       Deliver::Runner.new(options) # to login...
-      Deliver::Setup.new.run(options)
+      Deliver::Setup.new.run(options, is_swift: self.is_swift_fastfile)
     end
 
     def generate_fastfile(manually: false)
       scheme = self.project.schemes.first unless manually
 
-      template = File.read("#{Fastlane::ROOT}/lib/assets/DefaultFastfileTemplate")
+      template = File.read(fastfile_template_path)
 
       scheme = UI.input("Optional: The scheme name of your app (If you don't need one, just hit Enter): ") unless scheme
       if scheme.length > 0
-        template.gsub!('[[SCHEME]]', "(scheme: \"#{scheme}\")")
+        if self.is_swift_fastfile
+          template.gsub!('[[SCHEME]]', "scheme: \"#{scheme}\"")
+        else
+          template.gsub!('[[SCHEME]]', "(scheme: \"#{scheme}\")")
+        end
       else
         template.gsub!('[[SCHEME]]', "")
       end
 
-      template.gsub!('snapshot', '# snapshot') unless self.tools[:snapshot]
-      template.gsub!('cocoapods', '# cocoapods') unless self.tools[:cocoapods]
-      template.gsub!('carthage', '# carthage') unless self.tools[:carthage]
       template.gsub!('[[FASTLANE_VERSION]]', Fastlane::VERSION)
 
+      if self.is_swift_fastfile
+        template.gsub!('snapshot()', '// snapshot') unless self.tools[:snapshot]
+        template.gsub!('cocoapods()', '// cocoapods()') unless self.tools[:cocoapods]
+        template.gsub!('carthage()', '// carthage()') unless self.tools[:carthage]
+        path = File.join(folder, 'Fastfile.swift')
+      else
+        template.gsub!('snapshot', '# snapshot') unless self.tools[:snapshot]
+        template.gsub!('cocoapods', '# cocoapods') unless self.tools[:cocoapods]
+        template.gsub!('carthage', '# cocoapods') unless self.tools[:carthage]
+        path = File.join(folder, 'Fastfile')
+      end
+
       self.tools.each do |key, value|
         UI.message("'#{key}' enabled.".magenta) if value
         UI.important("'#{key}' not enabled.") unless value
       end
 
-      path = File.join(folder, 'Fastfile')
       File.write(path, template)
       UI.success("Created new file '#{path}'. Edit it to manage your own deployment lanes.")
     end
@@ -301,6 +333,31 @@ module Fastlane
       FastlaneCore::FastlaneFolder.path
     end
 
+    def appfile_template_path
+      if self.is_swift_fastfile
+        return "#{Fastlane::ROOT}/lib/assets/AppfileTemplate.swift"
+      else
+        return "#{Fastlane::ROOT}/lib/assets/AppfileTemplate"
+      end
+    end
+
+    def fastfile_template_path
+      if self.is_swift_fastfile
+        return "#{Fastlane::ROOT}/lib/assets/DefaultFastfileTemplate.swift"
+      else
+        return "#{Fastlane::ROOT}/lib/assets/DefaultFastfileTemplate"
+      end
+    end
+
+    def update_swift_runner
+      runner_source_resources = "#{Fastlane::ROOT}/swift/."
+
+      destination_path = File.expand_path('swift', FastlaneCore::FastlaneFolder.path)
+      FileUtils.cp_r(runner_source_resources, destination_path)
+
+      UI.success("Copied Swift fastlane runner project to '#{destination_path}'.")
+    end
+
     def restore_previous_state
       # Move all moved files back
       files_to_copy.each do |current|

data/fastlane/lib/fastlane/swift_fastlane_api_generator.rb

@@ -0,0 +1,265 @@
+require 'fastlane/swift_fastlane_function.rb'
+
+module Fastlane
+  class SwiftToolDetail
+    attr_accessor :swift_class
+    attr_accessor :swift_protocol
+    attr_accessor :command_line_tool_name
+
+    def initialize(command_line_tool_name: nil, swift_class: nil, swift_protocol: nil)
+      self.command_line_tool_name = command_line_tool_name
+      self.swift_class = swift_class
+      self.swift_protocol = swift_protocol
+    end
+  end
+
+  class SwiftFastlaneAPIGenerator
+    attr_accessor :tools_option_files
+    attr_accessor :actions_not_supported
+    attr_accessor :action_options_to_ignore
+    attr_accessor :target_output_path
+
+    def initialize(target_output_path: "swift")
+      @target_output_path = File.expand_path(target_output_path)
+      require 'fastlane'
+      require 'fastlane/documentation/actions_list'
+      Fastlane.load_actions
+      # Tools that can be used with <Toolname>file, like Deliverfile, Screengrabfile
+      # this is important because we need to generate the proper api for these by creating a protocol
+      # with default implementation we can use in the Fastlane.swift API if people want to use
+      # <Toolname>file.swift files.
+      self.tools_option_files = TOOL_CONFIG_FILES.map { |config_file| config_file.downcase.chomp("file") }.to_set
+
+      self.actions_not_supported = ["import", "import_from_git"].to_set
+
+      self.action_options_to_ignore = {
+
+        "precheck" => [
+          "negative_apple_sentiment",
+          "placeholder_text",
+          "other_platforms",
+          "future_functionality",
+          "test_words",
+          "curse_words",
+          "custom_text",
+          "copyright_date",
+          "unreachable_urls"
+        ].to_set
+      }
+    end
+
+    def generate_swift
+      file_content = []
+      file_content << "import Foundation"
+
+      tool_details = []
+      ActionsList.all_actions do |action|
+        next if self.actions_not_supported.include?(action.action_name)
+
+        swift_function = process_action(action: action)
+        if defined?(swift_function.class_name)
+          tool_details << SwiftToolDetail.new(
+            command_line_tool_name: action.action_name,
+            swift_class: swift_function.class_name,
+            swift_protocol: swift_function.protocol_name
+          )
+        end
+        unless swift_function
+          next
+        end
+
+        file_content << swift_function.swift_code
+      end
+      file_content << "" # newline because we're adding an extension
+      file_content << "// These are all the parsing functions needed to transform our data into the expected types"
+      file_content << generate_lanefile_parsing_functions
+
+      tool_objects = generate_lanefile_tool_objects(classes: tool_details.map(&:swift_class))
+      file_content << tool_objects
+      file_content += autogen_version_warning_text_array
+
+      file_content = file_content.join("\n")
+      target_path = File.join(@target_output_path, "Fastlane.swift")
+      File.write(target_path, file_content)
+      UI.success(target_path)
+
+      generate_default_implementation_opening(tool_details: tool_details)
+    end
+
+    def write_lanefile(lanefile_implementation_opening: nil, class_name: nil, tool_name: nil)
+      disclaimer = []
+      disclaimer << "// This class is automatically included in FastlaneRunner during build"
+      disclaimer << ""
+      disclaimer << "// This autogenerated file will be overwritten or replaced during build time, or when you initialize `#{tool_name}`"
+      disclaimer << lanefile_implementation_opening
+      disclaimer << "// If you want to enable `#{tool_name}`, run `fastlane #{tool_name} init`"
+      disclaimer << "// After, this file will be replaced with a custom implementation that contains values you supplied"
+      disclaimer << "// during the `init` process, and you won't see this message"
+      disclaimer << "}"
+      disclaimer << ""
+      disclaimer << ""
+      disclaimer << ""
+      disclaimer << ""
+      disclaimer << ""
+      disclaimer << "// Generated with fastlane #{Fastlane::VERSION}"
+
+      file_content = disclaimer.join("\n")
+
+      target_path = File.join(@target_output_path, "#{class_name}.swift")
+      File.write(target_path, file_content)
+      UI.success(target_path)
+    end
+
+    def generate_default_implementation_opening(tool_details: nil)
+      tool_details.each do |tool_detail|
+        lanefile_implementation_opening = "class #{tool_detail.swift_class}: #{tool_detail.swift_protocol} {"
+        write_lanefile(
+          lanefile_implementation_opening: lanefile_implementation_opening,
+          class_name: tool_detail.swift_class,
+          tool_name: tool_detail.command_line_tool_name
+        )
+      end
+    end
+
+    def generate_lanefile_parsing_functions
+      parsing_functions = 'func parseArray(fromString: String, function: String = #function) -> [String] {
+  verbose(message: "parsing an Array from data: \(fromString), from function: \(function)")
+  let potentialArray: String
+  if fromString.count < 2 {
+    potentialArray = "[\(fromString)]"
+  } else {
+    potentialArray = fromString
+  }
+  let array: [String] = try! JSONSerialization.jsonObject(with: potentialArray.data(using: .utf8)!, options: []) as! [String]
+  return array
+}
+
+func parseDictionary(fromString: String, function: String = #function) -> [String : String] {
+  verbose(message: "parsing an Array from data: \(fromString), from function: \(function)")
+  let potentialDictionary: String
+  if fromString.count < 2 {
+    verbose(message: "Dictionary value too small: \(fromString), from function: \(function)")
+    potentialDictionary = "{}"
+  } else {
+      potentialDictionary = fromString
+  }
+  let dictionary: [String : String] = try! JSONSerialization.jsonObject(with: potentialDictionary.data(using: .utf8)!, options: []) as! [String : String]
+  return dictionary
+}
+
+func parseBool(fromString: String, function: String = #function) -> Bool {
+  verbose(message: "parsing a Bool from data: \(fromString), from function: \(function)")
+  return NSString(string: fromString).boolValue
+}
+
+func parseInt(fromString: String, function: String = #function) -> Int {
+  verbose(message: "parsing a Bool from data: \(fromString), from function: \(function)")
+  return NSString(string: fromString).integerValue
+}
+      '
+      return parsing_functions
+    end
+
+    def generate_lanefile_tool_objects(classes: nil)
+      objects = classes.map do |filename|
+        "let #{filename.downcase}: #{filename} = #{filename}()"
+      end
+      return objects
+    end
+
+    def autogen_version_warning_text_array
+      warning_text_array = []
+      warning_text_array << ""
+      warning_text_array << "// Please don't remove the lines below"
+      warning_text_array << "// They are used to detect outdated files"
+      warning_text_array << "// FastlaneRunnerAPIVersion [0.9.1]"
+      warning_text_array << ""
+      return warning_text_array
+    end
+
+    def generate_tool_protocol(tool_swift_function: nil)
+      protocol_content_array = []
+      protocol_name = tool_swift_function.protocol_name
+
+      protocol_content_array << "protocol #{protocol_name}: class {"
+      protocol_content_array += tool_swift_function.swift_vars
+      protocol_content_array << "}"
+      protocol_content_array << ""
+
+      protocol_content_array << "extension #{protocol_name} {"
+      protocol_content_array += tool_swift_function.swift_default_implementations
+      protocol_content_array << "}"
+      protocol_content_array << ""
+      protocol_content_array += autogen_version_warning_text_array
+
+      target_path = File.join(@target_output_path, "#{protocol_name}.swift")
+      file_content = protocol_content_array.join("\n")
+      File.write(target_path, file_content)
+      UI.success(target_path)
+    end
+
+    def ignore_param?(function_name: nil, param_name: nil)
+      option_set = @action_options_to_ignore[function_name.to_s]
+      unless option_set
+        return false
+      end
+
+      return option_set.include?(param_name.to_s)
+    end
+
+    def process_action(action: nil)
+      unless action.available_options
+        return nil
+      end
+      options = action.available_options
+
+      action_name = action.action_name
+      keys = []
+      key_descriptions = []
+      key_default_values = []
+      key_optionality_values = []
+      key_type_overrides = []
+
+      if options.kind_of? Array
+        options.each do |current|
+          next unless current.kind_of? FastlaneCore::ConfigItem
+
+          if ignore_param?(function_name: action_name, param_name: current.key)
+            next
+          end
+
+          keys << current.key.to_s
+          key_descriptions << current.description
+          key_default_values << current.default_value
+          key_optionality_values << current.optional
+          key_type_overrides << current.data_type
+        end
+      end
+      action_return_type = action.return_type
+
+      if self.tools_option_files.include?(action_name.to_s.downcase)
+        tool_swift_function = ToolSwiftFunction.new(
+          action_name: action_name,
+          keys: keys,
+          key_descriptions: key_descriptions,
+          key_default_values: key_default_values,
+          key_optionality_values: key_optionality_values,
+          key_type_overrides: key_type_overrides,
+          return_type: action_return_type
+        )
+        generate_tool_protocol(tool_swift_function: tool_swift_function)
+        return tool_swift_function
+      else
+        return SwiftFunction.new(
+          action_name: action_name,
+          keys: keys,
+          key_descriptions: key_descriptions,
+          key_default_values: key_default_values,
+          key_optionality_values: key_optionality_values,
+          key_type_overrides: key_type_overrides,
+          return_type: action_return_type
+        )
+      end
+    end
+  end
+end