fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/shells.rb

@@ -0,0 +1,6 @@
+module Fastlane
+  SHELLS = [
+    :bash,
+    :zsh
+  ]
+end

data/fastlane/lib/fastlane/supported_platforms.rb

@@ -0,0 +1,28 @@
+module Fastlane
+  class SupportedPlatforms
+    class << self
+      attr_accessor :extra
+      attr_reader :default
+
+      def extra=(value)
+        value ||= []
+        UI.important("Setting '#{value}' as extra SupportedPlatforms")
+        @extra = value
+      end
+    end
+
+    @default = [:ios, :mac, :android]
+    @extra = []
+
+    def self.all
+      (@default + @extra).flatten
+    end
+
+    # this will log a warning if the passed platform is not supported
+    def self.verify!(platform)
+      unless all.include?(platform.to_s.to_sym)
+        UI.important("Platform '#{platform}' is not officially supported. Currently supported platforms are #{self.all}.")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/swift_fastlane_api_generator.rb

@@ -0,0 +1,383 @@
+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
+    DEFAULT_API_VERSION_STRING = "0.9.1"
+    attr_accessor :tools_option_files
+    attr_accessor :actions_not_supported
+    attr_accessor :action_options_to_ignore
+    attr_accessor :target_output_path
+    attr_accessor :generated_paths # stores all file names of generated files (as they are generated)
+
+    def initialize(target_output_path: "swift")
+      @target_output_path = File.expand_path(target_output_path)
+      @generated_paths = []
+      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
+      self.generated_paths = [] # reset generated paths in case we're called multiple times
+      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
+      new_file_content = file_content.join("\n")
+
+      fastlane_swift_api_path = File.join(@target_output_path, "Fastlane.swift")
+      old_file_content = File.read(fastlane_swift_api_path)
+
+      # compare old file content to potential new file content
+      api_version = determine_api_version(new_file_content: new_file_content, old_file_content: old_file_content)
+      old_api_version = find_api_version_string(content: old_file_content)
+
+      # if there is a change, we need to write out the new file
+      if api_version != old_api_version
+        new_file_content.concat(autogen_version_warning_text(api_version: api_version))
+
+        File.write(fastlane_swift_api_path, new_file_content)
+        UI.success(fastlane_swift_api_path)
+        self.generated_paths << fastlane_swift_api_path
+      end
+
+      default_implementations_path = generate_default_implementations(tool_details: tool_details)
+
+      # we might not have any changes, like if it's a hotpatch
+      self.generated_paths += default_implementations_path if default_implementations_path.length > 0
+
+      return self.generated_paths
+    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}"
+      disclaimer << ""
+
+      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)
+      return target_path
+    end
+
+    def generate_default_implementations(tool_details: nil)
+      files_generated = []
+      tool_details.each do |tool_detail|
+        header = []
+        header << "//"
+        header << "//  ** NOTE **"
+        header << "//  This file is provided by fastlane and WILL be overwritten in future updates"
+        header << "//  If you want to add extra functionality to this project, create a new file in a"
+        header << "//  new group so that it won't be marked for upgrade"
+        header << "//"
+        header << ""
+        header << "class #{tool_detail.swift_class}: #{tool_detail.swift_protocol} {"
+        lanefile_implementation_opening = header.join("\n")
+
+        files_generated << write_lanefile(
+          lanefile_implementation_opening: lanefile_implementation_opening,
+          class_name: tool_detail.swift_class,
+          tool_name: tool_detail.command_line_tool_name
+        )
+      end
+      return files_generated
+    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] {
+    return parseDictionaryHelper(fromString: fromString, function: function) as! [String: String]
+}
+
+func parseDictionary(fromString: String, function: String = #function) -> [String : Any] {
+    return parseDictionaryHelper(fromString: fromString, function: function)
+}
+
+func parseDictionaryHelper(fromString: String, function: String = #function) -> [String : Any] {
+  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 : Any] = try! JSONSerialization.jsonObject(with: potentialDictionary.data(using: .utf8)!, options: []) as! [String : Any]
+  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.trimmingCharacters(in: .punctuationCharacters)).boolValue
+}
+
+func parseInt(fromString: String, function: String = #function) -> Int {
+  verbose(message: "parsing an Int from data: \(fromString), from function: \(function)")
+  return NSString(string: fromString.trimmingCharacters(in: .punctuationCharacters)).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(api_version: nil)
+      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 [#{api_version}]"
+      warning_text_array << ""
+      return warning_text_array.join("\n")
+    end
+
+    # compares the new file content to the old and figures out what api_version the new content should be
+    def determine_api_version(new_file_content: nil, old_file_content: nil)
+      # we know 100% there is a difference, so no need to compare
+      unless old_file_content.length >= new_file_content.length
+        old_api_version = find_api_version_string(content: old_file_content)
+
+        return DEFAULT_API_VERSION_STRING if old_api_version.nil?
+
+        return increment_api_version_string(api_version_string: old_api_version)
+      end
+
+      relevant_old_file_content = old_file_content[0..(new_file_content.length - 1)]
+
+      if relevant_old_file_content == new_file_content
+        # no changes at all, just return the same old api version string
+        return find_api_version_string(content: old_file_content)
+      else
+        # there are differences, so calculate a new api_version_string
+        old_api_version = find_api_version_string(content: old_file_content)
+
+        return DEFAULT_API_VERSION_STRING if old_api_version.nil?
+
+        return increment_api_version_string(api_version_string: old_api_version)
+      end
+    end
+
+    # expects format to be "X.Y.Z" where each value is a number
+    def increment_api_version_string(api_version_string: nil, increment_by: :patch)
+      versions = api_version_string.split(".")
+      major = versions[0].to_i
+      minor = versions[1].to_i
+      patch = versions[2].to_i
+
+      case increment_by
+      when :patch
+        patch += 1
+      when :minor
+        minor += 1
+        patch = 0
+      when :major
+        major += 1
+        minor = 0
+        patch = 0
+      end
+
+      new_version_string = [major, minor, patch].join(".")
+      return new_version_string
+    end
+
+    def find_api_version_string(content: nil)
+      regex = SwiftRunnerUpgrader::API_VERSION_REGEX
+      matches = content.match(regex)
+      if matches.length > 0
+        return matches[1]
+      else
+        return nil
+      end
+    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 << ""
+      new_file_content = protocol_content_array.join("\n")
+
+      target_path = File.join(@target_output_path, "#{protocol_name}.swift")
+
+      old_file_content = ""
+      # we might have a new file here, unlikely, but possible
+      if File.exist?(target_path)
+        old_file_content = File.read(target_path)
+      end
+
+      # compare old file content to potential new file content
+      api_version = determine_api_version(new_file_content: new_file_content, old_file_content: old_file_content)
+      old_api_version = find_api_version_string(content: old_file_content)
+
+      # we don't need to write this file out because the file versions are exactly the same
+      return nil if api_version == old_api_version
+
+      # use api_version to generate the disclaimer
+      api_version_disclaimer = autogen_version_warning_text(api_version: api_version)
+      new_file_content.concat(api_version_disclaimer)
+
+      target_path = File.join(@target_output_path, "#{protocol_name}.swift")
+
+      File.write(target_path, new_file_content)
+      UI.success(target_path)
+      return 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)
+      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.code_gen_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
+        )
+        generated_protocol_file_path = generate_tool_protocol(tool_swift_function: tool_swift_function)
+        self.generated_paths << generated_protocol_file_path unless generated_protocol_file_path.nil?
+        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

data/fastlane/lib/fastlane/swift_fastlane_function.rb

@@ -0,0 +1,320 @@
+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
+    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 :hash
+        return "[String : Any]"
+      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)
+      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 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]"
+      elsif default_value.kind_of?(Hash)
+        type = "[String : Any]"
+      elsif default_value.kind_of?(Integer)
+        type = "Int"
+      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 :hash
+        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)
+        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