fastlane_iac_publish 0.1.0

data/fastlane_core/lib/fastlane_core/env.rb

@@ -0,0 +1,9 @@
+module FastlaneCore
+  class Env
+    def self.truthy?(env)
+      return false unless ENV[env]
+      return false if ["no", "false", "off", "0"].include?(ENV[env].to_s)
+      return true
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/fastlane_folder.rb

@@ -0,0 +1,72 @@
+require_relative 'ui/ui'
+
+module FastlaneCore
+  class FastlaneFolder
+    FOLDER_NAME = 'fastlane'
+
+    # Path to the fastlane folder containing the Fastfile and other configuration files
+    def self.path
+      value ||= "./#{FOLDER_NAME}/" if File.directory?("./#{FOLDER_NAME}/")
+      value ||= "./.#{FOLDER_NAME}/" if File.directory?("./.#{FOLDER_NAME}/") # hidden folder
+      value ||= "./" if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile.swift') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile.swift') # inside the folder and hidden
+      value ||= "./" if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile') # inside the folder and hidden
+      return value
+    end
+
+    # path to the Swift runner executable if it has been built
+    def self.swift_runner_path
+      return File.join(self.path, 'FastlaneRunner')
+    end
+
+    def self.swift?
+      return false unless self.fastfile_path
+      return self.fastfile_path.downcase.end_with?(".swift")
+    end
+
+    def self.swift_folder_path
+      return File.join(self.path, 'swift')
+    end
+
+    def self.swift_runner_project_path
+      return File.join(self.swift_folder_path, 'FastlaneSwiftRunner', 'FastlaneSwiftRunner.xcodeproj')
+    end
+
+    def self.swift_runner_built?
+      swift_runner_path = self.swift_runner_path
+      if swift_runner_path.nil?
+        return false
+      end
+
+      return File.exist?(swift_runner_path)
+    end
+
+    # Path to the Fastfile inside the fastlane folder. This is nil when none is available
+    def self.fastfile_path
+      return nil if self.path.nil?
+
+      # Check for Swift first, because Swift is #1
+      path = File.join(self.path, 'Fastfile.swift')
+      return path if File.exist?(path)
+
+      path = File.join(self.path, 'Fastfile')
+      return path if File.exist?(path)
+      return nil
+    end
+
+    # Does a fastlane configuration already exist?
+    def self.setup?
+      return false unless self.fastfile_path
+      File.exist?(self.fastfile_path)
+    end
+
+    def self.create_folder!(path = nil)
+      path = File.join(path || '.', FOLDER_NAME)
+      return if File.directory?(path) # directory is already there
+      UI.user_error!("Found a file called 'fastlane' at path '#{path}', please delete it") if File.exist?(path)
+      FileUtils.mkdir_p(path)
+      UI.success("Created new folder '#{path}'.")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/fastlane_pty.rb

@@ -0,0 +1,57 @@
+# Source: Mix of https://github.com/fastlane/fastlane/pull/7202/files,
+# https://github.com/fastlane/fastlane/pull/11384#issuecomment-356084518 and
+# https://github.com/DragonBox/u3d/blob/59e471ad78ac00cb629f479dbe386c5ad2dc5075/lib/u3d_core/command_runner.rb#L88-L96
+
+class StandardError
+  def exit_status
+    return -1
+  end
+end
+
+module FastlaneCore
+  class FastlanePtyError < StandardError
+    attr_reader :exit_status
+    def initialize(e, exit_status)
+      super(e)
+      set_backtrace(e.backtrace) if e
+      @exit_status = exit_status
+    end
+  end
+
+  class FastlanePty
+    def self.spawn(command)
+      require 'pty'
+      PTY.spawn(command) do |command_stdout, command_stdin, pid|
+        begin
+          yield(command_stdout, command_stdin, pid)
+        rescue Errno::EIO
+          # Exception ignored intentionally.
+          # https://stackoverflow.com/questions/10238298/ruby-on-linux-pty-goes-away-without-eof-raises-errnoeio
+          # This is expected on some linux systems, that indicates that the subcommand finished
+          # and we kept trying to read, ignore it
+        ensure
+          begin
+            Process.wait(pid)
+          rescue Errno::ECHILD, PTY::ChildExited
+            # The process might have exited.
+          end
+        end
+      end
+      $?.exitstatus
+    rescue LoadError
+      require 'open3'
+      Open3.popen2e(command) do |command_stdin, command_stdout, p| # note the inversion
+        yield(command_stdout, command_stdin, p.value.pid)
+
+        command_stdin.close
+        command_stdout.close
+        p.value.exitstatus
+      end
+    rescue StandardError => e
+      # Wrapping any error in FastlanePtyError to allow
+      # callers to see and use $?.exitstatus that
+      # would usually get returned
+      raise FastlanePtyError.new(e, $?.exitstatus)
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/feature/feature.rb

@@ -0,0 +1,51 @@
+require_relative '../env'
+
+module FastlaneCore
+  class Feature
+    class << self
+      attr_reader :features
+
+      def register(env_var: nil, description: nil)
+        feature = self.new(description: description, env_var: env_var)
+        @features[feature.env_var] = feature
+      end
+
+      def enabled?(env_var)
+        feature = @features[env_var]
+        return false if feature.nil?
+        return FastlaneCore::Env.truthy?(feature.env_var)
+      end
+
+      def register_class_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.define_singleton_method(symbol) do |*args|
+          if Feature.enabled?(env_var)
+            klass.send(enabled_symbol, *args)
+          else
+            klass.send(disabled_symbol, *args)
+          end
+        end
+      end
+
+      def register_instance_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.send(:define_method, symbol.to_s) do |*args|
+          if Feature.enabled?(env_var)
+            send(enabled_symbol, *args)
+          else
+            send(disabled_symbol, *args)
+          end
+        end
+      end
+    end
+
+    @features = {}
+
+    attr_reader :env_var, :description
+    def initialize(env_var: nil, description: nil)
+      raise "Invalid Feature" if env_var.nil? || description.nil?
+      @env_var = env_var
+      @description = description
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/features.rb

@@ -0,0 +1,4 @@
+require_relative 'feature/feature'
+
+FastlaneCore::Feature.register(env_var: 'FASTLANE_ITUNES_TRANSPORTER_USE_SHELL_SCRIPT',
+                           description: 'Use iTunes Transporter shell script')

data/fastlane_core/lib/fastlane_core/globals.rb

@@ -0,0 +1,27 @@
+module FastlaneCore
+  class Globals
+    def self.captured_output
+      @captured_output ||= ""
+    end
+
+    class << self
+      attr_writer(:captured_output)
+      attr_writer(:capture_output)
+      attr_writer(:verbose)
+    end
+
+    def self.capture_output?
+      return nil unless @capture_output
+      return true
+    end
+
+    def self.captured_output?
+      @capture_output && @captured_output.to_s.length > 0
+    end
+
+    def self.verbose?
+      return nil unless @verbose
+      return true
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/helper.rb

@@ -0,0 +1,414 @@
+require 'logger'
+require 'colored'
+require 'tty-spinner'
+require 'pathname'
+
+require_relative 'fastlane_folder'
+require_relative 'ui/ui'
+require_relative 'env'
+
+module FastlaneCore
+  module Helper
+    # fastlane
+    #
+
+    def self.fastlane_enabled?
+      # This is called from the root context on the first start
+      @enabled ||= !FastlaneCore::FastlaneFolder.path.nil?
+    end
+
+    # Checks if fastlane is enabled for this project and returns the folder where the configuration lives
+    def self.fastlane_enabled_folder_path
+      fastlane_enabled? ? FastlaneCore::FastlaneFolder.path : '.'
+    end
+
+    # fastlane installation method
+    #
+
+    # @return [boolean] true if executing with bundler (like 'bundle exec fastlane [action]')
+    def self.bundler?
+      # Bundler environment variable
+      ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    # Do we run from a bundled fastlane, which contains Ruby and OpenSSL?
+    # Usually this means the fastlane directory is ~/.fastlane/bin/
+    # We set this value via the environment variable `FASTLANE_SELF_CONTAINED`
+    def self.contained_fastlane?
+      ENV["FASTLANE_SELF_CONTAINED"].to_s == "true" && !self.homebrew?
+    end
+
+    # returns true if fastlane was installed from the Fabric Mac app
+    def self.mac_app?
+      ENV["FASTLANE_SELF_CONTAINED"].to_s == "false"
+    end
+
+    # returns true if fastlane was installed via Homebrew
+    def self.homebrew?
+      ENV["FASTLANE_INSTALLED_VIA_HOMEBREW"].to_s == "true"
+    end
+
+    # returns true if fastlane was installed via RubyGems
+    def self.rubygems?
+      !self.bundler? && !self.contained_fastlane? && !self.homebrew? && !self.mac_app?
+    end
+
+    # environment
+    #
+
+    # @return true if the currently running program is a unit test
+    def self.test?
+      Object.const_defined?("SpecHelper")
+    end
+
+    # @return true if it is enabled to execute external commands
+    def self.sh_enabled?
+      !self.test?
+    end
+
+    # @return [boolean] true if building in a known CI environment
+    def self.ci?
+      # Check for Jenkins, Travis CI, ... environment variables
+      ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'CI', 'APPCENTER_BUILD_ID', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS', 'TF_BUILD'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    def self.operating_system
+      return "macOS" if RUBY_PLATFORM.downcase.include?("darwin")
+      return "Windows" if RUBY_PLATFORM.downcase.include?("mswin")
+      return "Linux" if RUBY_PLATFORM.downcase.include?("linux")
+      return "Unknown"
+    end
+
+    def self.windows?
+      # taken from: https://stackoverflow.com/a/171011/1945875
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def self.linux?
+      (/linux/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Is the currently running computer a Mac?
+    def self.mac?
+      (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Do we want to disable the colored output?
+    def self.colors_disabled?
+      FastlaneCore::Env.truthy?("FASTLANE_DISABLE_COLORS")
+    end
+
+    # Does the user use the Mac stock terminal
+    def self.mac_stock_terminal?
+      FastlaneCore::Env.truthy?("TERM_PROGRAM_VERSION")
+    end
+
+    # Logs base directory
+    def self.buildlog_path
+      return ENV["FL_BUILDLOG_PATH"] || "~/Library/Logs"
+    end
+
+    # Xcode
+    #
+
+    # @return the full path to the Xcode developer tools of the currently
+    #  running system
+    def self.xcode_path
+      return "" unless self.mac?
+
+      if self.xcode_server?
+        # Xcode server always creates a link here
+        xcode_server_xcode_path = "/Library/Developer/XcodeServer/CurrentXcodeSymlink/Contents/Developer"
+        UI.verbose("We're running as XcodeServer, setting path to #{xcode_server_xcode_path}")
+        return xcode_server_xcode_path
+      end
+
+      return `xcode-select -p`.delete("\n") + "/"
+    end
+
+    def self.xcode_server?
+      # XCS is set by Xcode Server
+      return ENV["XCS"].to_i == 1
+    end
+
+    # @return The version of the currently used Xcode installation (e.g. "7.0")
+    def self.xcode_version
+      return nil unless self.mac?
+      return @xcode_version if @xcode_version && @developer_dir == ENV['DEVELOPER_DIR']
+
+      xcodebuild_path = "#{xcode_path}/usr/bin/xcodebuild"
+
+      xcode_build_installed = File.exist?(xcodebuild_path)
+      unless xcode_build_installed
+        UI.verbose("Couldn't find xcodebuild at #{xcodebuild_path}, check that it exists")
+        return nil
+      end
+
+      begin
+        output = `DEVELOPER_DIR='' "#{xcodebuild_path}" -version`
+        @xcode_version = output.split("\n").first.split(' ')[1]
+        @developer_dir = ENV['DEVELOPER_DIR']
+      rescue => ex
+        UI.error(ex)
+        UI.user_error!("Error detecting currently used Xcode installation, please ensure that you have Xcode installed and set it using `sudo xcode-select -s [path]`")
+      end
+      @xcode_version
+    end
+
+    # @return true if Xcode version is higher than 8.3
+    def self.xcode_at_least?(version)
+      FastlaneCore::UI.user_error!("Unable to locate Xcode. Please make sure to have Xcode installed on your machine") if xcode_version.nil?
+      v = xcode_version
+      Gem::Version.new(v) >= Gem::Version.new(version)
+    end
+
+    # iTMSTransporter
+    #
+
+    def self.transporter_java_executable_path
+      return File.join(self.transporter_java_path, 'bin', 'java')
+    end
+
+    def self.transporter_java_ext_dir
+      return File.join(self.transporter_java_path, 'lib', 'ext')
+    end
+
+    def self.transporter_java_jar_path
+      return File.join(self.itms_path, 'lib', 'itmstransporter-launcher.jar')
+    end
+
+    def self.transporter_user_dir
+      return File.join(self.itms_path, 'bin')
+    end
+
+    def self.transporter_java_path
+      return File.join(self.itms_path, 'java')
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.transporter_path
+      return File.join(self.itms_path, 'bin', 'iTMSTransporter') unless Helper.windows?
+      return File.join(self.itms_path, 'iTMSTransporter')
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.itms_path
+      return ENV["FASTLANE_ITUNES_TRANSPORTER_PATH"] if FastlaneCore::Env.truthy?("FASTLANE_ITUNES_TRANSPORTER_PATH")
+
+      if self.mac?
+        # First check for manually install iTMSTransporter
+        user_local_itms_path = "/usr/local/itms"
+        return user_local_itms_path if File.exist?(user_local_itms_path)
+
+        # Then check for iTMSTransporter in the Xcode path
+        [
+          "../Applications/Application Loader.app/Contents/MacOS/itms",
+          "../Applications/Application Loader.app/Contents/itms",
+          "../SharedFrameworks/ContentDeliveryServices.framework/Versions/A/itms" # For Xcode 11
+        ].each do |path|
+          result = File.expand_path(File.join(self.xcode_path, path))
+          return result if File.exist?(result)
+        end
+        UI.user_error!("Could not find transporter at #{self.xcode_path}. Please make sure you set the correct path to your Xcode installation.")
+      elsif self.windows?
+        [
+          "C:/Program Files (x86)/itms"
+        ].each do |path|
+          return path if File.exist?(path)
+        end
+        UI.user_error!("Could not find transporter at usual locations. Please use environment variable `FASTLANE_ITUNES_TRANSPORTER_PATH` to specify your installation path.")
+      else
+        # not Mac or Windows
+        return ''
+      end
+    end
+
+    # keychain
+    #
+
+    def self.keychain_path(keychain_name)
+      # Existing code expects that a keychain name will be expanded into a default path to Library/Keychains
+      # in the user's home directory. However, this will not allow the user to pass an absolute path
+      # for the keychain value
+      #
+      # So, if the passed value can't be resolved as a file in Library/Keychains, just use it as-is
+      # as the keychain path.
+      #
+      # We need to expand each path because File.exist? won't handle directories including ~ properly
+      #
+      # We also try to append `-db` at the end of the file path, as with Sierra the default Keychain name
+      # has changed for some users: https://github.com/fastlane/fastlane/issues/5649
+
+      # Remove the ".keychain" at the end of the keychain name
+      name = keychain_name.sub(/\.keychain$/, "")
+
+      possible_locations = [
+        File.join(Dir.home, 'Library', 'Keychains', name),
+        name
+      ].map { |path| File.expand_path(path) }
+
+      # Transforms ["thing"] to ["thing-db", "thing.keychain-db", "thing", "thing.keychain"]
+      keychain_paths = []
+      possible_locations.each do |location|
+        keychain_paths << "#{location}-db"
+        keychain_paths << "#{location}.keychain-db"
+        keychain_paths << location
+        keychain_paths << "#{location}.keychain"
+      end
+
+      keychain_path = keychain_paths.find { |path| File.file?(path) }
+      UI.user_error!("Could not locate the provided keychain. Tried:\n\t#{keychain_paths.join("\n\t")}") unless keychain_path
+      keychain_path
+    end
+
+    # helper methods
+    #
+
+    # Runs a given command using backticks (`)
+    # and prints them out using the UI.command method
+    def self.backticks(command, print: true)
+      UI.command(command) if print
+      result = `#{command}`
+      UI.command_output(result) if print
+      return result
+    end
+
+    # removes ANSI colors from string
+    def self.strip_ansi_colors(str)
+      str.gsub(/\e\[([;\d]+)?m/, '')
+    end
+
+    # Zips directory
+    def self.zip_directory(path, output_path, contents_only: false, overwrite: false, print: true)
+      if overwrite
+        overwrite_command = " && rm -f '#{output_path}'"
+      else
+        overwrite_command = ""
+      end
+
+      if contents_only
+        command = "cd '#{path}'#{overwrite_command} && zip -r '#{output_path}' *"
+      else
+        containing_path = File.expand_path("..", path)
+        contents_path = File.basename(path)
+
+        command = "cd '#{containing_path}'#{overwrite_command} && zip -r '#{output_path}' '#{contents_path}'"
+      end
+
+      UI.command(command) unless print
+      Helper.backticks(command, print: print)
+    end
+
+    # Executes the provided block after adjusting the ENV to have the
+    # provided keys and values set as defined in hash. After the block
+    # completes, restores the ENV to its previous state.
+    def self.with_env_values(hash, &block)
+      old_vals = ENV.select { |k, v| hash.include?(k) }
+      hash.each do |k, v|
+        ENV[k] = hash[k]
+      end
+      yield
+    ensure
+      hash.each do |k, v|
+        ENV.delete(k) unless old_vals.include?(k)
+        ENV[k] = old_vals[k]
+      end
+    end
+
+    # loading indicator
+    #
+
+    def self.should_show_loading_indicator?
+      return false if FastlaneCore::Env.truthy?("FASTLANE_DISABLE_ANIMATION")
+      return false if Helper.ci?
+      return true
+    end
+
+    # Show/Hide loading indicator
+    def self.show_loading_indicator(text = nil)
+      if self.should_show_loading_indicator?
+        # we set the default here, instead of at the parameters
+        # as we don't want to `UI.message` a rocket that's just there for the loading indicator
+        text ||= "🚀"
+        @require_fastlane_spinner = TTY::Spinner.new("[:spinner] #{text} ", format: :dots)
+        @require_fastlane_spinner.auto_spin
+      else
+        UI.message(text) if text
+      end
+    end
+
+    def self.hide_loading_indicator
+      if self.should_show_loading_indicator? && @require_fastlane_spinner
+        @require_fastlane_spinner.success
+      end
+    end
+
+    # files
+    #
+
+    # checks if a given path is an executable file
+    def self.executable?(cmd_path)
+      # no executable files on Windows, so existing is enough there
+      cmd_path && !File.directory?(cmd_path) && (File.executable?(cmd_path) || (self.windows? && File.exist?(cmd_path)))
+    end
+
+    # checks if given file is a valid json file
+    # base taken from: http://stackoverflow.com/a/26235831/1945875
+    def self.json_file?(filename)
+      return false unless File.exist?(filename)
+      begin
+        JSON.parse(File.read(filename))
+        return true
+      rescue JSON::ParserError
+        return false
+      end
+    end
+
+    # deprecated
+    #
+
+    # Use Helper.test?, Helper.ci?, Helper.mac? or Helper.windows? instead (legacy calls)
+    def self.is_test?
+      self.test?
+    end
+
+    def self.is_ci?
+      ci?
+    end
+
+    def self.is_mac?
+      self.mac?
+    end
+
+    def self.is_windows?
+      self.windows?
+    end
+
+    # <b>DEPRECATED:</b> Use the `ROOT` constant from the appropriate tool module instead
+    # e.g. File.join(Sigh::ROOT, 'lib', 'assets', 'resign.sh')
+    #
+    # Path to the installed gem to load resources (e.g. resign.sh)
+    def self.gem_path(gem_name)
+      UI.deprecated('`Helper.gem_path` is deprecated. Use the `ROOT` constant from the appropriate tool module instead.')
+
+      if !Helper.test? && Gem::Specification.find_all_by_name(gem_name).any?
+        return Gem::Specification.find_by_name(gem_name).gem_dir
+      else
+        return './'
+      end
+    end
+
+    # This method is deprecated, use the `UI` class
+    # https://docs.fastlane.tools/advanced/#user-input-and-output
+    def self.log
+      UI.deprecated("Helper.log is deprecated. Use `UI` class instead")
+      UI.current.log
+    end
+  end
+end