fastlane 1.111.0 → 2.0.1

data/{lib → fastlane/lib}/fastlane/actions/update_fastlane.rb

@@ -5,26 +5,7 @@ module Fastlane
   module Actions
     # Makes sure fastlane tools are up-to-date when running fastlane
     class UpdateFastlaneAction < Action
-      ALL_TOOLS = [
-        "fastlane",
-        "fastlane_core",
-        "deliver",
-        "snapshot",
-        "frameit",
-        "pem",
-        "sigh",
-        "produce",
-        "cert",
-        "codes",
-        "credentials_manager",
-        "gym",
-        "spaceship",
-        "pilot",
-        "supply",
-        "scan",
-        "screengrab",
-        "match"
-      ]
+      ALL_TOOLS = ["fastlane"]
 
       def self.run(options)
         if options[:no_update]

data/{lib → fastlane/lib}/fastlane/actions/update_urban_airship_configuration.rb

@@ -39,18 +39,22 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :development_app_key,
                                        optional: true,
                                        env_name: "URBAN_AIRSHIP_DEVELOPMENT_APP_KEY",
+                                       sensitive: true,
                                        description: "The development app key"),
           FastlaneCore::ConfigItem.new(key: :development_app_secret,
                                        optional: true,
                                        env_name: "URBAN_AIRSHIP_DEVELOPMENT_APP_SECRET",
+                                       sensitive: true,
                                        description: "The development app secret"),
           FastlaneCore::ConfigItem.new(key: :production_app_key,
                                        optional: true,
                                        env_name: "URBAN_AIRSHIP_PRODUCTION_APP_KEY",
+                                       sensitive: true,
                                        description: "The production app key"),
           FastlaneCore::ConfigItem.new(key: :production_app_secret,
                                        optional: true,
                                        env_name: "URBAN_AIRSHIP_PRODUCTION_APP_SECRET",
+                                       sensitive: true,
                                        description: "The production app secret"),
           FastlaneCore::ConfigItem.new(key: :detect_provisioning_mode,
                                        env_name: "URBAN_AIRSHIP_DETECT_PROVISIONING_MODE",

data/{lib → fastlane/lib}/fastlane/actions/upload_symbols_to_crashlytics.rb

@@ -113,6 +113,7 @@ module Fastlane
                                        end),
           FastlaneCore::ConfigItem.new(key: :api_token,
                                        env_name: "CRASHLYTICS_API_TOKEN",
+                                       sensitive: true,
                                        optional: true,
                                        description: "Crashlytics API Key",
                                        verify_block: proc do |value|

data/{lib → fastlane/lib}/fastlane/actions/upload_symbols_to_sentry.rb

@@ -89,10 +89,12 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :api_key,
                                        env_name: "SENTRY_API_KEY",
                                        description: "API key for Sentry",
+                                       sensitive: true,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :auth_token,
                                        env_name: "SENTRY_AUTH_TOKEN",
                                        description: "Authentication token for Sentry",
+                                       sensitive: true,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :org_slug,
                                        env_name: "SENTRY_ORG_SLUG",

data/{lib → fastlane/lib}/fastlane/actions/xcode_server_get_assets.rb

@@ -253,6 +253,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :password,
                                        env_name: "FL_XCODE_SERVER_GET_ASSETS_PASSWORD",
                                        description: "Password for your Xcode Server",
+                                       sensitive: true,
                                        optional: true,
                                        default_value: ""),
           FastlaneCore::ConfigItem.new(key: :target_folder,

data/{lib → fastlane/lib}/fastlane/actions/xctool.rb

@@ -20,7 +20,7 @@ module Fastlane
         [
           "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 available on GitHub: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Actions.md#xctool"
+          "More information available on GitHub: https://docs.fastlane.tools/actions#xctool"
         ].join(' ')
       end
 

data/fastlane/lib/fastlane/cli_tools_distributor.rb

@@ -0,0 +1,125 @@
+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 take_off
+        before_import_time = Time.now
+
+        require "fastlane" # this might take a long time if there is no Gemfile :(
+
+        # We want to avoid printing output other than the version number if we are running `fastlane -v`
+        if Time.now - before_import_time > 3 && !running_version_command?
+          print_slow_fastlane_warning
+        end
+
+        ARGV.unshift("spaceship") if ARGV.first == "spaceauth"
+        tool_name = ARGV.first ? ARGV.first.downcase : nil
+
+        tool_name = process_emojis(tool_name)
+
+        if tool_name
+          if 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
+              Object.const_get(tool_name.fastlane_module)::CommandsGenerator.start
+            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
+          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
+        end
+      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_slow_fastlane_warning
+        # `BUNDLE_BIN_PATH` is used when the user uses `bundle exec`
+        return if ENV['BUNDLE_BIN_PATH'] || ENV['SKIP_SLOW_FASTLANE_WARNING'] || FastlaneCore::Helper.contained_fastlane?
+
+        gemfile_path = PluginManager.new.gemfile_path
+        if gemfile_path
+          # The user has a Gemfile, but fastlane is still slow
+          # Let's tell the user how to use `bundle exec`
+          UI.important "Seems like launching fastlane takes a while"
+          UI.important "fastlane detected a Gemfile in this 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(' ')}"
+        else
+          # 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 "For more information, check out https://guides.cocoapods.org/using/a-gemfile.html"
+
+        sleep 1
+      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

data/{lib → fastlane/lib}/fastlane/commands_generator.rb

@@ -68,6 +68,7 @@ module Fastlane
     end
 
     def run
+      program :name, 'fastlane'
       program :version, Fastlane::VERSION
       program :description, [
         "CLI for 'fastlane' - #{Fastlane::DESCRIPTION}\n",
@@ -132,7 +133,7 @@ module Fastlane
         c.action do |args, options|
           if options.json || ensure_fastfile
             require 'fastlane/lane_list'
-            path = Fastlane::FastlaneFolder.fastfile_path
+            path = FastlaneCore::FastlaneFolder.fastfile_path
 
             if options.json
               Fastlane::LaneList.output_json(path)
@@ -148,7 +149,7 @@ module Fastlane
         c.description = 'Lists all available lanes without description'
         c.action do |args, options|
           if ensure_fastfile
-            ff = Fastlane::FastFile.new(Fastlane::FastlaneFolder.fastfile_path)
+            ff = Fastlane::FastFile.new(FastlaneCore::FastlaneFolder.fastfile_path)
             UI.message "Available lanes:"
             ff.runner.available_lanes.each do |lane|
               UI.message "- #{lane}"
@@ -165,7 +166,7 @@ module Fastlane
 
         c.action do |args, options|
           if ensure_fastfile
-            ff = Fastlane::FastFile.new(File.join(Fastlane::FastlaneFolder.path || '.', 'Fastfile'))
+            ff = Fastlane::FastFile.new(File.join(FastlaneCore::FastlaneFolder.path || '.', 'Fastfile'))
             UI.message "You don't need to run `fastlane docs` manually any more, this will be done automatically for you."
             Fastlane::DocsGenerator.run(ff)
           end
@@ -297,7 +298,7 @@ module Fastlane
     # if that's not the case
     # return true if the Fastfile is available
     def ensure_fastfile
-      return true if Fastlane::FastlaneFolder.setup?
+      return true if FastlaneCore::FastlaneFolder.setup?
 
       create = UI.confirm('Could not find fastlane in current directory. Would you like to set it up?')
       Fastlane::Setup.new.run if create

data/{lib → fastlane/lib}/fastlane/configuration_helper.rb

@@ -6,7 +6,6 @@ module Fastlane
       if first_element and first_element.kind_of? FastlaneCore::ConfigItem
         # default use case
         return FastlaneCore::Configuration.create(action.available_options, params)
-
       elsif first_element
         UI.error("Old configuration format for action '#{action}'") if Helper.is_test?
         return params

data/{lib → fastlane/lib}/fastlane/documentation/actions_list.rb

@@ -56,7 +56,7 @@ module Fastlane
         print_output_variables(action, filter)
         print_return_value(action, filter)
 
-        puts "More information can be found on https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Actions.md"
+        puts "More information can be found on https://docs.fastlane.tools/actions"
         puts ""
       else
         puts "Couldn't find action for the given filter.".red

data/{lib → fastlane/lib}/fastlane/documentation/docs_generator.rb

@@ -1,7 +1,7 @@
 module Fastlane
   class DocsGenerator
     def self.run(ff, output_path = nil)
-      output_path ||= File.join(Fastlane::FastlaneFolder.path || '.', 'README.md')
+      output_path ||= File.join(FastlaneCore::FastlaneFolder.path || '.', 'README.md')
 
       output = ["fastlane documentation"]
       output << "================"

data/{lib → fastlane/lib}/fastlane/environment_printer.rb

@@ -239,7 +239,7 @@ module Fastlane
     def self.print_fastlane_files
       env_output = "### fastlane files:\n\n"
 
-      fastlane_path = FastlaneFolder.fastfile_path
+      fastlane_path = FastlaneCore::FastlaneFolder.fastfile_path
 
       if fastlane_path && File.exist?(fastlane_path)
         env_output << "<details>"

data/{lib → fastlane/lib}/fastlane/fast_file.rb

@@ -40,7 +40,7 @@ module Fastlane
     def parse(data, path = nil)
       @runner ||= Runner.new
 
-      Dir.chdir(Fastlane::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder
+      Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder
         # create nice path that we want to print in case of some problem
         relative_path = path.nil? ? '(eval)' : Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
 

data/{lib → fastlane/lib}/fastlane/fastlane_require.rb

@@ -3,7 +3,6 @@ module Fastlane
     class << self
       def install_gem_if_needed(gem_name: nil, require_gem: true)
         gem_require_name = gem_name.tr("-", "/") # from "fastlane-plugin-xcversion" to "fastlane/plugin/xcversion"
-        bundle_path = "~/.fastlane/bin/"
 
         # check if it's installed
         if gem_installed?(gem_name)
@@ -16,18 +15,43 @@ module Fastlane
         installer = Gem::CommandManager.instance[:install]
 
         UI.important "Installing Ruby gem '#{gem_name}'..."
+
+        spec_name = self.find_gem_name(gem_name)
+        UI.important("Found gem \"#{spec_name}\" instead of the required name \"#{gem_name}\"") if spec_name != gem_name
+
         return if Helper.test?
 
         # We install the gem like this because we also want to gem to be available to be required
         # at this point. If we were to shell out, this wouldn't be the case
-        installer.install_gem(gem_name, Gem::Requirement.default)
-        UI.success("Successfully installed '#{gem_name}' to '#{bundle_path}'")
+        installer.install_gem(spec_name, Gem::Requirement.default)
+        UI.success("Successfully installed '#{gem_name}'")
         require gem_require_name if require_gem
       end
 
       def gem_installed?(name, req = Gem::Requirement.default)
+        # We fork and try to load a gem with that name in the child process so we
+        # don't actually load anything we don't want to load
+        # This is just to test if the gem is already preinstalled, e.g. YAML
+        # See https://github.com/fastlane/fastlane/issues/6951
+        fork do
+          begin
+            exit(1) unless require name
+          rescue LoadError
+            exit(1)
+          end
+        end
+        _, status = Process.wait2
+        return true if status.exitstatus == 0
+
         Gem::Specification.any? { |s| s.name == name and req =~ s.version }
       end
+
+      def find_gem_name(user_supplied_name)
+        fetcher = Gem::SpecFetcher.fetcher
+        gems = fetcher.suggest_gems_from_name(user_supplied_name)
+
+        return gems.first
+      end
     end
   end
 end