swift_fastlane_function.rb in fastlane-2.182.0

- old
+ new

@@ -27,14 +27,14 @@
       @return_type = return_type
       @return_value = non_empty(string: return_value)
       @sample_return_value = non_empty(string: sample_return_value)
       @param_type_overrides = key_type_overrides
 
-      # rubocop:disable LineLength
+      # rubocop:disable Layout/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 guard if in infix init inout internal lazy let mutating nil operator override precedence private public repeat required return self static struct subscript super switch throws true try var weak where while willSet].to_set
-      # rubocop:enable LineLength
+      # rubocop:enable Layout/LineLength
     end
 
     def sanitize_reserved_word(word: nil)
       unless @reserved_words.include?(word)
         return word
@@ -95,10 +95,12 @@
         return "Int"
       elsif type_override == Boolean
         return "Bool"
       elsif type_override == Float
         return "Float"
+      elsif type_override == String
+        return "String"
       elsif type_override == :string_callback
         # David Hart:
         # It doesn't make sense to add escaping annotations to optional closures because they aren't function types:
         # they are basically an enum (Optional) containing a function, the same way you would store a closure in any type:
         # it's implicitly escaping because it's owned by another type.
@@ -152,10 +154,11 @@
         end
       end
       return "#{type}#{optional_specifier}"
     end
 
+    # rubocop:disable Metrics/PerceivedComplexity
     def parameters
       unless @param_names
         return ""
       end
 
@@ -188,11 +191,17 @@
         param = sanitize_reserved_word(word: param)
 
         if default_value.nil?
           "#{param}: #{type}"
         else
-          "#{param}: #{type} = #{default_value}"
+          if type == "((String) -> Void)?"
+            "#{param}: #{type} = nil"
+          elsif optional && type.end_with?('?')
+            "#{param}: OptionalConfigValue<#{type}> = .fastlaneDefault(#{default_value})"
+          else
+            "#{param}: #{type} = #{default_value}"
+          end
         end
       end
 
       return param_names_and_types
     end
@@ -230,11 +239,11 @@
       separator = ''
       documentation_elements = [description, swift_parameter_documentation, swift_return_value_documentation, details].compact
       # Adds newlines between each documentation element.
       documentation = documentation_elements.flat_map { |element| [element, separator] }.tap(&:pop).join("\n")
 
-      return "/**\n#{documentation}\n*/\n"
+      return "/**\n#{documentation.gsub('/*', '/\\*')}\n*/\n"
     end
 
     def swift_parameter_documentation
       unless @param_names && @param_names.length > 0
         return nil
@@ -269,16 +278,20 @@
     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|
+      argument_object_strings = @param_names.zip(param_type_overrides, param_default_values, param_optionality_values).map do |name, type_override, default_value, is_optional|
         sanitized_name = camel_case_lower(string: name)
         sanitized_name = sanitize_reserved_word(word: sanitized_name)
-        type_string = type_override == :string_callback ? ", type: .stringClosure" : nil
+        type_string = type_override == :string_callback ? ".stringClosure" : "nil"
 
-        "RubyCommand.Argument(name: \"#{name}\", value: #{sanitized_name}#{type_string})"
+        if !(type_override == :string_callback || !(is_optional && default_value.nil?))
+          { name: "#{sanitized_name.gsub('`', '')}Arg", arg: "let #{sanitized_name.gsub('`', '')}Arg = #{sanitized_name}.asRubyArgument(name: \"#{name}\", type: #{type_string})" }
+        else
+          { name: "#{sanitized_name.gsub('`', '')}Arg", arg: "let #{sanitized_name.gsub('`', '')}Arg = RubyCommand.Argument(name: \"#{name}\", value: #{sanitized_name}, type: #{type_string})" }
+        end
       end
       return argument_object_strings
     end
 
     def return_statement
@@ -305,17 +318,19 @@
       return "#{return_string}#{returned_object}"
     end
 
     def implementation
       args = build_argument_list
+      implm = "#{args.group_by { |h| h[:arg] }.keys.join("\n")}\n"
+      if args.empty?
+        implm += "let args: [RubyCommand.Argument] = []\n"
+      else
+        implm += "let args = [#{args.group_by { |h| h[:name] }.keys.join(",\n")}]\n"
+        implm += ".compactMap { $0 }\n"
+      end
+      implm += "let command = RubyCommand(commandID: \"\", methodName: \"#{@function_name}\", className: nil, args: args)\n"
 
-      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
@@ -412,10 +427,16 @@
 
         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}"
+        if type == "((String) -> Void)?"
+          "#{param}: #{type} = nil"
+        elsif optional && type.end_with?('?')
+          "#{param}: OptionalConfigValue<#{type}> = .fastlaneDefault(#{self.class_name.downcase}.#{static_var_for_parameter_name})"
+        else
+          "#{param}: #{type} = #{self.class_name.downcase}.#{static_var_for_parameter_name}"
+        end
       end
 
       return param_names_and_types
     end
   end