fastlane 1.111.0 → 2.0.1

data/fastlane_core/lib/fastlane_core/provisioning_profile.rb

@@ -0,0 +1,69 @@
+module FastlaneCore
+  class ProvisioningProfile
+    class << self
+      # @return (Hash) The hash with the data of the provisioning profile
+      # @example
+      #  {"AppIDName"=>"My App Name",
+      #   "ApplicationIdentifierPrefix"=>["5A997XSAAA"],
+      #   "CreationDate"=>#<DateTime: 2015-05-24T20:38:03+00:00 ((2457167j,74283s,0n),+0s,2299161j)>,
+      #   "DeveloperCertificates"=>[#<StringIO:0x007f944b9666f8>],
+      #   "Entitlements"=>
+      #    {"keychain-access-groups"=>["5A997XSAAA.*"],
+      #     "get-task-allow"=>false,
+      #     "application-identifier"=>"5A997XAAA.net.sunapps.192",
+      #     "com.apple.developer.team-identifier"=>"5A997XAAAA",
+      #     "aps-environment"=>"production",
+      #     "beta-reports-active"=>true},
+      #   "ExpirationDate"=>#<DateTime: 2015-11-25T22:45:50+00:00 ((2457352j,81950s,0n),+0s,2299161j)>,
+      #   "Name"=>"net.sunapps.192 AppStore",
+      #   "TeamIdentifier"=>["5A997XSAAA"],
+      #   "TeamName"=>"SunApps GmbH",
+      #   "TimeToLive"=>185,
+      #   "UUID"=>"1752e382-53bd-4910-a393-aaa7de0005ad",
+      #   "Version"=>1}
+      def parse(path)
+        require 'plist'
+
+        plist = Plist.parse_xml(`security cms -D -i "#{path}" 2> /dev/null`) # /dev/null: https://github.com/fastlane/fastlane/issues/6387
+        if (plist || []).count > 5
+          plist
+        else
+          UI.error("Error parsing provisioning profile at path '#{path}'")
+          nil
+        end
+      end
+
+      # @return [String] The UUID of the given provisioning profile
+      def uuid(path)
+        parse(path).fetch("UUID")
+      end
+
+      def profiles_path
+        path = File.expand_path("~") + "/Library/MobileDevice/Provisioning Profiles/"
+        # If the directory doesn't exist, create it first
+        unless File.directory?(path)
+          FileUtils.mkdir_p(path)
+        end
+
+        return path
+      end
+
+      # Installs a provisioning profile for Xcode to use
+      def install(path)
+        UI.message("Installing provisioning profile...")
+        profile_filename = uuid(path) + ".mobileprovision"
+        destination = File.join(profiles_path, profile_filename)
+
+        if path != destination
+          # copy to Xcode provisioning profile directory
+          FileUtils.copy(path, destination)
+          unless File.exist?(destination)
+            UI.user_error!("Failed installation of provisioning profile at location: '#{destination}'")
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/string_filters.rb

@@ -0,0 +1,34 @@
+class String
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+  #   # => "Once upon a time in a..."
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
+  #   # => "Once upon a time in a..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>length</tt>:
+  #
+  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
+  #   # => "And they f... (continued)"
+  def truncate(truncate_at, options = {})
+    return dup unless length > truncate_at
+
+    omission = options[:omission] || '...'
+    length_with_room_for_omission = truncate_at - omission.length
+    stop = \
+      if options[:separator]
+        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
+
+    "#{self[0, stop]}#{omission}"
+  end
+end

data/fastlane_core/lib/fastlane_core/tool_collector.rb

@@ -0,0 +1,179 @@
+module FastlaneCore
+  class ToolCollector
+    HOST_URL = ENV['FASTLANE_ENHANCER_URL'] || "https://fastlane-enhancer.herokuapp.com"
+
+    # This is the original error reporting mechanism, which has always represented
+    # either controlled (UI.user_error!), or uncontrolled (UI.crash!, anything else)
+    # exceptions.
+    #
+    # Thus, if you call `did_crash`, it will record the failure both here, and in the
+    # newer, more specific `crash` field.
+    #
+    # This value is a String, which is the name of the tool that caused the error
+    attr_reader :error
+
+    # This is the newer field for tracking only uncontrolled exceptions.
+    #
+    # This is written to only when `did_crash` is called, and therefore excludes
+    # controlled exceptions.
+    #
+    # This value is a boolean, which is true if the error was an uncontrolled exception
+    attr_reader :crash
+
+    def initialize
+      @crash = false
+    end
+
+    def did_launch_action(name)
+      name = name_to_track(name.to_sym)
+      return unless name
+
+      launches[name] += 1
+      versions[name] ||= determine_version(name)
+    end
+
+    # Call when the problem is a caught/controlled exception (e.g. via UI.user_error!)
+    def did_raise_error(name)
+      name = name_to_track(name.to_sym)
+      return unless name
+
+      @error = name
+      # Don't write to the @crash field so that we can distinguish this exception later
+      # as being controlled
+    end
+
+    # Call when the problem is an uncaught/uncontrolled exception (e.g. via UI.crash!)
+    def did_crash(name)
+      name = name_to_track(name.to_sym)
+      return unless name
+
+      # Write to the @error field to maintain the historical behavior of the field, so
+      # that the server gets the same data in that field from old and new clients
+      @error = name
+      # Also specifically note that this exception was uncontrolled in the @crash field
+      @crash = true
+    end
+
+    def did_finish
+      return false if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
+
+      if !did_show_message? and !Helper.is_ci?
+        show_message
+      end
+
+      # `fastfile_id` helps us track success/failure metrics for Fastfiles we
+      # generate as part of an automated process.
+      require 'excon'
+      url = HOST_URL + '/did_launch?'
+      url += URI.encode_www_form(
+        versions: versions.to_json,
+        steps: launches.to_json,
+        error: @error || "",
+        crash: @crash ? @error : "",
+        fastfile_id: ENV["GENERATED_FASTFILE_ID"] || ""
+      )
+
+      if Helper.is_test? # don't send test data
+        return url
+      else
+        fork do
+          begin
+            Excon.post(url)
+          rescue
+            # we don't want to show a stack trace if something goes wrong
+          end
+        end
+        return true
+      end
+    rescue
+      # We don't care about connection errors
+    end
+
+    def show_message
+      UI.message("Sending Crash/Success information. More information on: https://github.com/fastlane/enhancer")
+      UI.message("No personal/sensitive data is sent. Only sharing the following:")
+      UI.message(launches)
+      UI.message(@error) if @error
+      UI.message("This information is used to fix failing tools and improve those that are most often used.")
+      UI.message("You can disable this by setting the environment variable: FASTLANE_OPT_OUT_USAGE=1")
+    end
+
+    def launches
+      @launches ||= Hash.new(0)
+    end
+
+    # Maintains a hash of tool names to their detected versions.
+    #
+    # This data is sent in the same manner as launches, as an inline form-encoded JSON value in the POST.
+    # For example:
+    #
+    # {
+    #   match: '0.5.0',
+    #   fastlane: '1.86.1'
+    # }
+    def versions
+      @versions ||= {}
+    end
+
+    # Override this in subclasses
+    def is_official?(name)
+      return true
+    end
+
+    # Returns nil if we shouldn't track this action
+    # Returns a (maybe modified) name that should be sent to the enhancer web service
+    # Modificiation is used to prefix the action name with the name of the plugin
+    def name_to_track(name)
+      return nil unless is_official?(name)
+      name
+    end
+
+    def did_show_message?
+      file_name = ".did_show_opt_info"
+
+      legacy_path = File.join(File.expand_path('~'), file_name)
+      new_path = File.join(FastlaneCore.fastlane_user_dir, file_name)
+      did_show = File.exist?(new_path) || File.exist?(legacy_path)
+
+      return did_show if did_show
+
+      File.write(new_path, '1')
+      false
+    end
+
+    def determine_version(name)
+      self.class.determine_version(name)
+    end
+
+    def self.determine_version(name)
+      return Fastlane::VERSION if Fastlane::ActionsList.find_action_named(name.to_s)
+
+      begin
+        name = name.to_s.downcase
+
+        # We need to pre-load the version file because tools that are invoked through their actions
+        # will not yet have run their action, and thus will not yet have loaded the file which defines
+        # the module and constant we need.
+        require File.join(name, "version")
+
+        # Go from :foo_bar to 'FooBar'
+        module_name = name.fastlane_module
+
+        # Look up the VERSION constant defined for the given tool name,
+        # or return 'unknown' if we can't find it where we'd expect
+        if Kernel.const_defined?(module_name)
+          tool_module = Kernel.const_get(module_name)
+
+          if tool_module.const_defined?('VERSION')
+            return tool_module.const_get('VERSION')
+          end
+        end
+      rescue LoadError
+        # If there is no version file to load, this is not a tool for which
+        # we can report a particular version
+      end
+
+      return nil
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/disable_colors.rb

@@ -0,0 +1,17 @@
+# This code overwrites the methods from the colored gem
+# via https://github.com/defunkt/colored/blob/master/lib/colored.rb
+
+require 'colored'
+
+class String
+  Colored::COLORS.keys.each do |color|
+    define_method(color) do
+      self # do nothing with the string, but return it
+    end
+  end
+  Colored::EXTRAS.keys.each do |extra|
+    define_method(extra) do
+      self # do nothing with the string, but return it
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/fastlane_runner.rb

@@ -0,0 +1,190 @@
+unless Object.const_defined?("Faraday")
+  # We create these empty error classes if we didn't require Faraday
+  # so that we can use it in the rescue block below even if we didn't
+  # require Faraday or didn't use it
+  module Faraday
+    class Error < StandardError; end
+    class ClientError < Error; end
+    class SSLError < ClientError; end
+    class ConnectionFailed < ClientError; end
+  end
+end
+
+module Commander
+  # This class override the run method with our custom stack trace handling
+  # In particular we want to distinguish between user_error! and crash! (one with, one without stack trace)
+  class Runner
+    # Code taken from https://github.com/commander-rb/commander/blob/master/lib/commander/runner.rb#L50
+    def run!
+      require_program :version, :description
+      trap('INT') { abort program(:int_message) } if program(:int_message)
+      trap('INT') { program(:int_block).call } if program(:int_block)
+      global_option('-h', '--help', 'Display help documentation') do
+        args = @args - %w(-h --help)
+        command(:help).run(*args)
+        return
+      end
+      global_option('-v', '--version', 'Display version information') do
+        say version
+        return
+      end
+      parse_global_options
+      remove_global_options options, @args
+
+      collector = FastlaneCore::ToolCollector.new
+
+      begin
+        collector.did_launch_action(@program[:name])
+        run_active_command
+      rescue InvalidCommandError => e
+        abort "#{e}. Use --help for more information"
+      rescue Interrupt => ex
+        # We catch it so that the stack trace is hidden by default when using ctrl + c
+        if $verbose
+          raise ex
+        else
+          puts "\nCancelled... use --verbose to show the stack trace"
+        end
+      rescue \
+        OptionParser::InvalidOption,
+        OptionParser::InvalidArgument,
+        OptionParser::MissingArgument => e
+        abort e.to_s
+      rescue FastlaneCore::Interface::FastlaneError => e # user_error!
+        collector.did_raise_error(@program[:name])
+        show_github_issues(e.message) if e.show_github_issues
+        display_user_error!(e, e.message)
+      rescue Faraday::SSLError => e # SSL issues are very common
+        handle_ssl_error!(e)
+      rescue Faraday::ConnectionFailed => e
+        if e.message.include? 'Connection reset by peer - SSL_connect'
+          handle_tls_error!(e)
+        else
+          handle_unknown_error!(e)
+        end
+      rescue => e # high chance this is actually FastlaneCore::Interface::FastlaneCrash, but can be anything else
+        collector.did_crash(@program[:name])
+        handle_unknown_error!(e)
+      ensure
+        collector.did_finish
+      end
+    end
+
+    def handle_tls_error!(e)
+      # Apple has upgraded its iTunes Connect servers to require TLS 1.2, but
+      # system Ruby 2.0 does not support it. We want to suggest that users upgrade
+      # their Ruby version
+      suggest_ruby_reinstall(e)
+      display_user_error!(e, e.to_s)
+    end
+
+    def handle_ssl_error!(e)
+      # SSL errors are very common when the Ruby or OpenSSL installation is somehow broken
+      # We want to show a nice error message to the user here
+      # We have over 20 GitHub issues just for this one error:
+      #   https://github.com/fastlane/fastlane/search?q=errno%3D0+state%3DSSLv3+read+server&type=Issues
+      suggest_ruby_reinstall(e)
+      display_user_error!(e, e.to_s)
+    end
+
+    def suggest_ruby_reinstall(e)
+      ui = FastlaneCore::UI
+      ui.error "-----------------------------------------------------------------------"
+      ui.error e.to_s
+      ui.error ""
+      ui.error "SSL errors can be caused by various components on your local machine."
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1')
+        ui.error "Apple has recently changed their servers to require TLS 1.2, which may"
+        ui.error "not be available to your system installed Ruby (#{RUBY_VERSION})"
+      end
+      ui.error ""
+      ui.error "The best solution is to use the self-contained fastlane version."
+      ui.error "Which ships with a bundled OpenSSL,ruby and all gems - so you don't depend on system libraries"
+      ui.error " - Use One-Click-Installer:"
+      ui.error "    - download fastlane at https://download.fastlane.tools"
+      ui.error "-----------------------------------------------------------"
+      ui.error "    - extract the archive and double click the `install`"
+      ui.error "-----------------------------------------------------------"
+      ui.error " - Use Homebrew"
+      ui.error "    - update brew with `brew update`"
+      ui.error "    - install fastlane:"
+      ui.error "-----------------------------------------------------------"
+      ui.error "      - 🚀 `brew cask install fastlane` 🚀"
+      ui.error "-----------------------------------------------------------"
+      ui.error "for more details on ways to install fastlane please refer the documentation:"
+      ui.error "-----------------------------------------------------------"
+      ui.error "        🚀       https://docs.fastlane.tools          🚀   "
+      ui.error "-----------------------------------------------------------"
+      ui.error ""
+      ui.error "You can also install a new version of Ruby"
+      ui.error ""
+      ui.error "- Make sure OpenSSL is installed with Homebrew: `brew update && brew upgrade openssl`"
+      ui.error "- If you use system Ruby:"
+      ui.error "  - Run `brew update && brew install ruby`"
+      ui.error "- If you use rbenv with ruby-build:"
+      ui.error "  - Run `brew update && brew upgrade ruby-build && rbenv install 2.3.1`"
+      ui.error "  - Run `rbenv global 2.3.1` to make it the new global default Ruby version"
+      ui.error "- If you use rvm:"
+      ui.error "  - First run `rvm osx-ssl-certs update all`"
+      ui.error "  - Then run `rvm reinstall ruby-2.3.1 --with-openssl-dir=/usr/local`"
+      ui.error ""
+      ui.error "If that doesn't fix your issue, please google for the following error message:"
+      ui.error "  '#{e}'"
+      ui.error "-----------------------------------------------------------------------"
+    end
+
+    def handle_unknown_error!(e)
+      # Some spaceship exception classes implement #preferred_error_info in order to share error info
+      # that we'd rather display instead of crashing with a stack trace. However, fastlane_core and
+      # spaceship can not know about each other's classes! To make this information passing work, we
+      # use a bit of Ruby duck-typing to check whether the unknown exception type implements the right
+      # method. If so, we'll present any returned error info in the manner of a user_error!
+      error_info = e.respond_to?(:preferred_error_info) ? e.preferred_error_info : nil
+
+      if error_info
+        error_info = error_info.join("\n\t") if error_info.kind_of?(Array)
+
+        show_github_issues(error_info)
+
+        display_user_error!(e, error_info)
+      else
+        # Pass the error instead of a message so that the inspector can do extra work to simplify the query
+        show_github_issues(e)
+
+        # From https://stackoverflow.com/a/4789702/445598
+        # We do this to make the actual error message red and therefore more visible
+        reraise_formatted!(e, e.message)
+      end
+    end
+
+    def display_user_error!(e, message)
+      if $verbose # with stack trace
+        reraise_formatted!(e, message)
+      else
+        abort "\n[!] #{message}".red # without stack trace
+      end
+    end
+
+    def reraise_formatted!(e, message)
+      raise e, "[!] #{message}".red, e.backtrace
+    end
+
+    def show_github_issues(message_or_error)
+      return if FastlaneCore::Env.truthy?("FASTLANE_HIDE_GITHUB_ISSUES")
+      return if FastlaneCore::Helper.test?
+
+      require 'gh_inspector'
+      require 'fastlane_core/ui/github_issue_inspector_reporter'
+
+      inspector = GhInspector::Inspector.new("fastlane", "fastlane", verbose: $verbose)
+      delegate = Fastlane::InspectorReporter.new
+      if message_or_error.kind_of?(String)
+        inspector.search_query(message_or_error, delegate)
+      else
+        inspector.search_exception(message_or_error, delegate)
+      end
+    rescue => ex
+      FastlaneCore::UI.error("Error finding relevant GitHub issues: #{ex}") if $verbose
+    end
+  end
+end