fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/xcov.rb

@@ -0,0 +1,66 @@
+module Fastlane
+  module Actions
+    class XcovAction < Action
+      def self.run(values)
+        Actions.verify_gem!('xcov')
+        require 'xcov'
+
+        Xcov::Manager.new(values).run
+      end
+
+      def self.description
+        "Nice code coverage reports without hassle"
+      end
+
+      def self.details
+        [
+          "Create nice code coverage reports and post coverage summaries on Slack *(xcov gem is required)*.",
+          "More information: [https://github.com/nakiostudio/xcov](https://github.com/nakiostudio/xcov)."
+        ].join("\n")
+      end
+
+      def self.author
+        "nakiostudio"
+      end
+
+      def self.available_options
+        return [] unless Helper.mac?
+
+        # We call Gem::Specification.find_by_name in many more places than this, but for right now
+        # this is the only place we're having trouble. If there are other reports about RubyGems
+        # 2.6.2 causing problems, we may need to move this code and require it someplace better,
+        # like fastlane_core
+        require 'fastlane/core_ext/bundler_monkey_patch'
+
+        begin
+          Gem::Specification.find_by_name('xcov')
+        rescue Gem::LoadError
+          # Catched missing gem exception and returned empty array
+          # to avoid unused_options_spec failure
+          return []
+        end
+
+        require 'xcov'
+        Xcov::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xcov(
+            workspace: "YourWorkspace.xcworkspace",
+            scheme: "YourScheme",
+            output_directory: "xcov_output"
+          )'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/xctool.rb

@@ -0,0 +1,55 @@
+module Fastlane
+  module Actions
+    class XctoolAction < Action
+      def self.run(params)
+        UI.important("Have you seen the new 'scan' tool to run tests? https://docs.fastlane.tools/actions/scan/")
+        unless Helper.test?
+          UI.user_error!("xctool not installed, please install using `brew install xctool`") if `which xctool`.length == 0
+        end
+
+        params = [] if params.kind_of?(FastlaneCore::Configuration)
+
+        Actions.sh('xctool ' + params.join(' '))
+      end
+
+      def self.description
+        "Run tests using xctool"
+      end
+
+      def self.details
+        [
+          "You can run any `xctool` action. This will require having [xctool](https://github.com/facebook/xctool) installed through [Homebrew](http://brew.sh).",
+          "It is recommended to store the build configuration in the `.xctool-args` file.",
+          "More information: [https://docs.fastlane.tools/actions/xctool/](https://docs.fastlane.tools/actions/xctool/)."
+        ].join("\n")
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xctool(:test)',
+
+          '# If you prefer to have the build configuration stored in the `Fastfile`:
+          xctool(:test, [
+            "--workspace", "\'AwesomeApp.xcworkspace\'",
+            "--scheme", "\'Schema Name\'",
+            "--configuration", "Debug",
+            "--sdk", "iphonesimulator",
+            "--arch", "i386"
+          ].join(" "))'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/xcversion.rb

@@ -0,0 +1,55 @@
+module Fastlane
+  module Actions
+    class XcversionAction < Action
+      def self.run(params)
+        Actions.verify_gem!('xcode-install')
+
+        version = params[:version]
+        xcode = Helper::XcversionHelper.find_xcode(version)
+        UI.user_error!("Cannot find an installed Xcode satisfying '#{version}'") if xcode.nil?
+
+        UI.verbose("Found Xcode version #{xcode.version} at #{xcode.path} satisfying requirement #{version}")
+        UI.message("Setting Xcode version to #{xcode.path} for all build steps")
+
+        ENV["DEVELOPER_DIR"] = File.join(xcode.path, "/Contents/Developer")
+      end
+
+      def self.description
+        "Select an Xcode to use by version specifier"
+      end
+
+      def self.details
+        "Finds and selects a version of an installed Xcode that best matches the provided [`Gem::Version` requirement specifier](http://www.rubydoc.info/github/rubygems/rubygems/Gem/Version)"
+      end
+
+      def self.authors
+        ["oysta"]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "FL_XCODE_VERSION",
+                                       description: "The version of Xcode to select specified as a Gem::Version requirement string (e.g. '~> 7.1.0')",
+                                       optional: false,
+                                       verify_block: Helper::XcversionHelper::Verify.method(:requirement))
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xcversion(version: "8.1") # Selects Xcode 8.1.0',
+          'xcversion(version: "~> 8.1.0") # Selects the latest installed version from the 8.1.x set'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/zip.rb

@@ -0,0 +1,120 @@
+module Fastlane
+  module Actions
+    class ZipAction < Action
+      def self.run(params)
+        UI.message("Compressing #{params[:path]}...")
+
+        params[:output_path] ||= params[:path]
+
+        absolute_output_path = File.expand_path(params[:output_path])
+
+        # Appends ".zip" if path does not end in ".zip"
+        unless absolute_output_path.end_with?(".zip")
+          absolute_output_path += ".zip"
+        end
+
+        absolute_output_dir = File.expand_path("..", absolute_output_path)
+        FileUtils.mkdir_p(absolute_output_dir)
+
+        Dir.chdir(File.expand_path("..", params[:path])) do # required to properly zip
+          zip_options = params[:verbose] ? "r" : "rq"
+          zip_options += "y" if params[:symlinks]
+
+          if params[:password]
+            password_option = "-P '#{params[:password]}'"
+            Actions.sh("zip -#{zip_options} #{password_option} #{absolute_output_path.shellescape} #{File.basename(params[:path]).shellescape}")
+          else
+            Actions.sh("zip -#{zip_options} #{absolute_output_path.shellescape} #{File.basename(params[:path]).shellescape}")
+          end
+        end
+
+        UI.success("Successfully generated zip file at path '#{File.expand_path(absolute_output_path)}'")
+        return File.expand_path(absolute_output_path)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Compress a file or folder to a zip"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_ZIP_PATH",
+                                       description: "Path to the directory or file to be zipped",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find file/folder at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                       env_name: "FL_ZIP_OUTPUT_NAME",
+                                       description: "The name of the resulting zip file",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_ZIP_VERBOSE",
+                                       description: "Enable verbose output of zipped file",
+                                       default_value: true,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_ZIP_PASSWORD",
+                                       description: "Encrypt the contents of the zip archive using a password",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :symlinks,
+                                       env_name: "FL_ZIP_SYMLINKS",
+                                       description: "Store symbolic links as such in the zip archive",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.example_code
+        [
+          'zip',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip"
+          )',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip",
+            verbose: false
+          )',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip",
+            verbose: false,
+            symlinks: true
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.output
+        []
+      end
+
+      def self.return_value
+        "The path to the output zip file"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/auto_complete.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+module Fastlane
+  # Enable tab auto completion
+  class AutoComplete
+    # This method copies the tab auto completion scripts to the user's home folder,
+    # while optionally adding custom commands for which to enable auto complete
+    # @param [Array] options An array of all options (e.g. --custom fl)
+    def self.execute(args, options)
+      shell = ENV['SHELL']
+
+      if shell.end_with?("fish")
+        fish_completions_dir = "~/.config/fish/completions"
+
+        if UI.interactive?
+          confirm = UI.confirm("This will copy a fish script into #{fish_completions_dir} that provides the command tab completion. If the directory does not exist it will be created. Sound good?")
+          return unless confirm
+        end
+
+        fish_completions_dir = File.expand_path(fish_completions_dir)
+        FileUtils.mkdir_p(fish_completions_dir)
+
+        completion_script_path = File.join(Fastlane::ROOT, 'lib', 'assets', 'completions', 'completion.fish')
+        final_completion_script_path = File.join(fish_completions_dir, 'fastlane.fish')
+
+        FileUtils.cp(completion_script_path, final_completion_script_path)
+
+        UI.success("Copied! You can now use tab completion for lanes")
+      else
+        fastlane_conf_dir = "~/.fastlane"
+
+        if UI.interactive?
+          confirm = UI.confirm("This will copy a shell script into #{fastlane_conf_dir} that provides the command tab completion. Sound good?")
+          return unless confirm
+        end
+
+        # create the ~/.fastlane directory
+        fastlane_conf_dir = File.expand_path(fastlane_conf_dir)
+        FileUtils.mkdir_p(fastlane_conf_dir)
+
+        # then copy all of the completions files into it from the gem
+        completion_script_path = File.join(Fastlane::ROOT, 'lib', 'assets', 'completions')
+        FileUtils.cp_r(completion_script_path, fastlane_conf_dir)
+
+        custom_commands = options.custom.to_s.split(',')
+
+        Fastlane::SHELLS.each do |shell_name|
+          open("#{fastlane_conf_dir}/completions/completion.#{shell_name}", 'a') do |file|
+            default_line_prefix = Helper.bundler? ? "bundle exec " : ""
+
+            file.puts(self.get_auto_complete_line(shell_name, "#{default_line_prefix}fastlane"))
+
+            custom_commands.each do |command|
+              auto_complete_line = self.get_auto_complete_line(shell_name, command)
+
+              next if auto_complete_line.nil?
+
+              file.puts(auto_complete_line)
+            end
+          end
+        end
+
+        UI.success("Copied! To use auto complete for fastlane, add the following line to your favorite rc file (e.g. ~/.bashrc)")
+        UI.important("  . ~/.fastlane/completions/completion.sh")
+        UI.success("Don't forget to source that file in your current shell! 🐚")
+      end
+    end
+
+    # Helper to get the auto complete register script line
+    def self.get_auto_complete_line(shell, command)
+      if shell == :bash
+        prefix = "complete -F"
+      elsif shell == :zsh
+        prefix = "compctl -K"
+      else
+        return nil
+      end
+
+      return "#{prefix} _fastlane_complete #{command}"
+    end
+  end
+end

data/fastlane/lib/fastlane/boolean.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  class Boolean
+    # Used in config item generation
+  end
+end

data/fastlane/lib/fastlane/cli_tools_distributor.rb

@@ -0,0 +1,185 @@
+module Fastlane
+  # This class is responsible for checking the ARGV
+  # to see if the user wants to launch another fastlane
+  # tool or fastlane itself
+  class CLIToolsDistributor
+    class << self
+      def running_version_command?
+        ARGV.include?('-v') || ARGV.include?('--version')
+      end
+
+      def running_help_command?
+        ARGV.include?('-h') || ARGV.include?('--help')
+      end
+
+      def running_init_command?
+        ARGV.include?("init")
+      end
+
+      def utf8_locale?
+        (ENV['LANG'] || "").end_with?("UTF-8", "utf8") || (ENV['LC_ALL'] || "").end_with?("UTF-8", "utf8") || (FastlaneCore::CommandExecutor.which('locale') && `locale charmap`.strip == "UTF-8")
+      end
+
+      def take_off
+        before_import_time = Time.now
+
+        if !ENV["FASTLANE_DISABLE_ANIMATION"]
+          # Usually in the fastlane code base we use
+          #
+          #   Helper.show_loading_indicator
+          #   longer_taking_task_here
+          #   Helper.hide_loading_indicator
+          #
+          # but in this case we haven't required FastlaneCore yet
+          # so we'll have to access the raw API for now
+          require "tty-spinner"
+          require_fastlane_spinner = TTY::Spinner.new("[:spinner] 🚀 ", format: :dots)
+          require_fastlane_spinner.auto_spin
+
+          # this might take a long time if there is no Gemfile :(
+          # That's why we show the loading indicator here also
+          require "fastlane"
+
+          require_fastlane_spinner.success
+        else
+          require "fastlane"
+        end
+        # We want to avoid printing output other than the version number if we are running `fastlane -v`
+        unless running_version_command? || running_init_command?
+          print_bundle_exec_warning(is_slow: (Time.now - before_import_time > 3))
+        end
+
+        # Try to check UTF-8 with `locale`, fallback to environment variables
+        unless utf8_locale?
+          warn = "WARNING: fastlane requires your locale to be set to UTF-8. To learn more go to https://docs.fastlane.tools/getting-started/ios/setup/#set-up-environment-variables"
+          UI.error(warn)
+          at_exit do
+            # Repeat warning here so users hopefully see it
+            UI.error(warn)
+          end
+        end
+
+        # Loading any .env files before any lanes are called since
+        # variables like FASTLANE_HIDE_CHANGELOG and FASTLANE_DISABLE_COLORS
+        # need to be set early on in execution
+        require 'fastlane/helper/dotenv_helper'
+        Fastlane::Helper::DotenvHelper.load_dot_env(nil)
+
+        # Needs to go after load_dot_env for variable FASTLANE_SKIP_UPDATE_CHECK
+        FastlaneCore::UpdateChecker.start_looking_for_update('fastlane')
+
+        # Disabling colors if environment variable set
+        require 'fastlane_core/ui/disable_colors' if FastlaneCore::Helper.colors_disabled?
+
+        ARGV.unshift("spaceship") if ARGV.first == "spaceauth"
+        tool_name = ARGV.first ? ARGV.first.downcase : nil
+
+        tool_name = process_emojis(tool_name)
+
+        if tool_name && Fastlane::TOOLS.include?(tool_name.to_sym) && !available_lanes.include?(tool_name.to_sym)
+          # Triggering a specific tool
+          # This happens when the users uses things like
+          #
+          #   fastlane sigh
+          #   fastlane snapshot
+          #
+          require tool_name
+          begin
+            # First, remove the tool's name from the arguments
+            # Since it will be parsed by the `commander` at a later point
+            # and it must not contain the binary name
+            ARGV.shift
+
+            # Import the CommandsGenerator class, which is used to parse
+            # the user input
+            require File.join(tool_name, "commands_generator")
+
+            # Call the tool's CommandsGenerator class and let it do its thing
+            commands_generator = Object.const_get(tool_name.fastlane_module)::CommandsGenerator
+          rescue LoadError
+            # This will only happen if the tool we call here, doesn't provide
+            # a CommandsGenerator class yet
+            # When we launch this feature, this should never be the case
+            abort("#{tool_name} can't be called via `fastlane #{tool_name}`, run '#{tool_name}' directly instead".red)
+          end
+
+          # Some of the tools use other actions so need to load all
+          # actions before we start the tool generator
+          # Example: scan uses slack
+          Fastlane.load_actions
+
+          commands_generator.start
+        elsif tool_name == "fastlane-credentials"
+          require 'credentials_manager'
+          ARGV.shift
+          CredentialsManager::CLI.new.run
+        else
+          # Triggering fastlane to call a lane
+          require "fastlane/commands_generator"
+          Fastlane::CommandsGenerator.start
+        end
+      ensure
+        FastlaneCore::UpdateChecker.show_update_status('fastlane', Fastlane::VERSION)
+      end
+
+      # Since fastlane also supports the rocket and biceps emoji as executable
+      # we need to map those to the appropriate tools
+      def process_emojis(tool_name)
+        return {
+          "🚀" => "fastlane",
+          "💪" => "gym"
+        }[tool_name] || tool_name
+      end
+
+      def print_bundle_exec_warning(is_slow: false)
+        return if FastlaneCore::Helper.bundler? # user is alread using bundler
+        return if FastlaneCore::Env.truthy?('SKIP_SLOW_FASTLANE_WARNING') # user disabled the warnings
+        return if FastlaneCore::Helper.contained_fastlane? # user uses the bundled fastlane
+
+        gemfile_path = PluginManager.new.gemfile_path
+        if gemfile_path
+          # The user has a Gemfile, but forgot to use `bundle exec`
+          # Let's tell the user how to use `bundle exec`
+          # We show this warning no matter if the command is slow or not
+          UI.important("fastlane detected a Gemfile in the current directory")
+          UI.important("however it seems like you don't use `bundle exec`")
+          UI.important("to launch fastlane faster, please use")
+          UI.message("")
+          UI.command "bundle exec fastlane #{ARGV.join(' ')}"
+          UI.message("")
+        elsif is_slow
+          # fastlane is slow and there is no Gemfile
+          # Let's tell the user how to use `gem cleanup` and how to
+          # start using a Gemfile
+          UI.important("Seems like launching fastlane takes a while - please run")
+          UI.message("")
+          UI.command "[sudo] gem cleanup"
+          UI.message("")
+          UI.important("to uninstall outdated gems and make fastlane launch faster")
+          UI.important("Alternatively it's recommended to start using a Gemfile to lock your dependencies")
+          UI.important("To get started with a Gemfile, run")
+          UI.message("")
+          UI.command "bundle init"
+          UI.command "echo 'gem \"fastlane\"' >> Gemfile"
+          UI.command "bundle install"
+          UI.message("")
+          UI.important("After creating the Gemfile and Gemfile.lock, commit those files into version control")
+        end
+        UI.important("Get started using a Gemfile for fastlane https://docs.fastlane.tools/getting-started/ios/setup/#use-a-gemfile")
+      end
+
+      # Returns an array of symbols for the available lanes for the Fastfile
+      # This doesn't actually use the Fastfile parser, but only
+      # the available lanes. This way it's much faster, which
+      # is very important in this case, since it will be executed
+      # every time one of the tools is launched
+      # Use this only if performance is :key:
+      def available_lanes
+        fastfile_path = FastlaneCore::FastlaneFolder.fastfile_path
+        return [] if fastfile_path.nil?
+        output = `cat #{fastfile_path.shellescape} | grep \"^\s*lane \:\" | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}'`
+        return output.strip.split(" ").collect(&:to_sym)
+      end
+    end
+  end
+end