fastlane 1.111.0 → 2.0.1

data/match/lib/assets/MatchfileTemplate

@@ -0,0 +1,9 @@
+git_url "[[GIT_URL]]"
+
+type "development" # The default type, can be: appstore, adhoc or development
+
+# app_identifier ["tools.fastlane.app", "tools.fastlane.app2"]
+# username "user@fastlane.tools" # Your Apple Developer Portal username
+
+# For all available options run `match --help`
+# Remove the # in the beginning of the line to enable the other options

data/match/lib/assets/READMETemplate.md

@@ -0,0 +1,49 @@
+## [fastlane match](https://github.com/fastlane/fastlane/tree/master/match#readme)
+
+This repository contains all your certificates and provisioning profiles needed to build and sign your applications. They are encrypted using OpenSSL via a passphrase.
+
+**Important:** Make sure this repository is set to private and only your team members have access to this repo.
+
+Do not modify this file, as it gets overwritten every time you run `match`.
+
+### Install [fastlane match](https://github.com/fastlane/fastlane/tree/master/match#readme)
+
+```
+sudo gem install fastlane
+```
+
+Make sure you have the latest version of the Xcode command line tools installed:
+
+```
+xcode-select --install
+```
+
+### Usage
+
+Navigate to your project folder and run
+
+```
+match appstore
+```
+```
+match adhoc
+```
+```
+match development
+```
+
+For more information open [fastlane match git repo](https://github.com/fastlane/fastlane/tree/master/match#readme)
+
+### Content
+
+#### certs
+
+This directory contains all your certificates with their private keys
+
+#### profiles
+
+This directory contains all provisioning profiles
+
+------------------------------------
+
+For more information open [fastlane match git repo](https://github.com/fastlane/fastlane/tree/master/match#readme)

data/match/lib/match.rb

@@ -0,0 +1,57 @@
+require 'match/options'
+require 'match/runner'
+require 'match/nuke'
+require 'match/utils'
+require 'match/table_printer'
+require 'match/git_helper'
+require 'match/generator'
+require 'match/setup'
+require 'match/encrypt'
+require 'match/spaceship_ensure'
+require 'match/change_password'
+
+require 'fastlane_core'
+require 'terminal-table'
+require 'spaceship'
+
+module Match
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+  DESCRIPTION = "Easily sync your certificates and profiles across your team using git"
+
+  def self.environments
+    envs = %w(appstore adhoc development)
+    envs << "enterprise" if self.enterprise?
+    return envs
+  end
+
+  # @return [Boolean] returns true if the unsupported enterprise mode should be enabled
+  def self.enterprise?
+    force_enterprise = ENV["MATCH_FORCE_ENTERPRISE"]
+
+    return false if (force_enterprise.kind_of?(String) || force_enterprise.kind_of?(Numeric)) &&
+                    (force_enterprise.to_s == "0")
+    return false if force_enterprise.kind_of?(String) &&
+                    (force_enterprise == "" || force_enterprise.casecmp("false") == 0 || force_enterprise.casecmp("no") == 0)
+    return !!force_enterprise
+  end
+
+  # @return [Boolean] returns true if match should interpret the given [certificate|profile] type as an enterprise one
+  def self.type_is_enterprise?(type)
+    Match.enterprise? && type != "development"
+  end
+
+  def self.profile_type_sym(type)
+    return :enterprise if self.type_is_enterprise? type
+    return :adhoc if type == "adhoc"
+    return :appstore if type == "appstore"
+    return :development
+  end
+
+  def self.cert_type_sym(type)
+    return :enterprise if self.type_is_enterprise? type
+    return :development if type == "development"
+    return :distribution
+  end
+end

data/match/lib/match/change_password.rb

@@ -0,0 +1,30 @@
+module Match
+  class ChangePassword
+    def self.update(params: nil, from: nil, to: nil)
+      to ||= ChangePassword.ask_password(message: "New passphrase for Git Repo: ", confirm: false)
+      from ||= ChangePassword.ask_password(message: "Old passphrase for Git Repo: ", confirm: true)
+      GitHelper.clear_changes
+      workspace = GitHelper.clone(params[:git_url], params[:shallow_clone], manual_password: from, skip_docs: params[:skip_docs], branch: params[:git_branch])
+      Encrypt.new.clear_password(params[:git_url])
+      Encrypt.new.store_password(params[:git_url], to)
+
+      message = "[fastlane] Changed passphrase"
+      GitHelper.commit_changes(workspace, message, params[:git_url], params[:git_branch])
+    end
+
+    def self.ask_password(message: "Passphrase for Git Repo: ", confirm: true)
+      loop do
+        password = UI.password(message)
+        if confirm
+          password2 = UI.password("Type passphrase again: ")
+          if password == password2
+            return password
+          end
+        else
+          return password
+        end
+        UI.error("Passhprases differ. Try again")
+      end
+    end
+  end
+end

data/match/lib/match/commands_generator.rb

@@ -0,0 +1,120 @@
+require 'commander'
+
+HighLine.track_eof = false
+
+module Match
+  class CommandsGenerator
+    include Commander::Methods
+    UI = FastlaneCore::UI
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'match'
+      program :version, Fastlane::VERSION
+      program :description, Match::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <match@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/match'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { $verbose = true }
+
+      FastlaneCore::CommanderGenerator.new.generate(Match::Options.available_options)
+
+      command :run do |c|
+        c.syntax = 'match'
+        c.description = Match::DESCRIPTION
+
+        c.action do |args, options|
+          if args.count > 0
+            FastlaneCore::UI.user_error!("Please run `match [type]`, allowed values: development, adhoc or appstore")
+          end
+
+          params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+          params.load_configuration_file("Matchfile")
+          Match::Runner.new.run(params)
+        end
+      end
+
+      Match.environments.each do |type|
+        command type do |c|
+          c.syntax = "match #{type}"
+          c.description = "Run match for a #{type} provisioning profile"
+
+          c.action do |args, options|
+            params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile") # this has to be done *before* overwriting the value
+            params[:type] = type.to_s
+            Match::Runner.new.run(params)
+          end
+        end
+      end
+
+      command :init do |c|
+        c.syntax = 'match init'
+        c.description = 'Create the Matchfile for you'
+        c.action do |args, options|
+          containing = (File.directory?("fastlane") ? 'fastlane' : '.')
+          path = File.join(containing, "Matchfile")
+
+          if File.exist?(path)
+            FastlaneCore::UI.user_error!("You already got a Matchfile in this directory")
+            return 0
+          end
+
+          Match::Setup.new.run(path)
+        end
+      end
+
+      command :change_password do |c|
+        c.syntax = 'match change_password'
+        c.description = 'Re-encrypt all files with a different password'
+        c.action do |args, options|
+          params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+          params.load_configuration_file("Matchfile")
+
+          Match::ChangePassword.update(params: params)
+          UI.success "Successfully changed the password. Make sure to update the password on all your clients and servers"
+        end
+      end
+
+      command :decrypt do |c|
+        c.syntax = "match decrypt"
+        c.description = "Decrypts the repository and keeps it on the filesystem"
+        c.action do |args, options|
+          params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+          params.load_configuration_file("Matchfile")
+          decrypted_repo = Match::GitHelper.clone(params[:git_url], params[:shallow_clone], branch: params[:git_branch])
+          UI.success "Repo is at: '#{decrypted_repo}'"
+        end
+      end
+      command "nuke" do |c|
+        # We have this empty command here, since otherwise the normal `match` command will be executed
+        c.syntax = "match nuke"
+        c.description = "Delete all certificates and provisioning profiles from the Apple Dev Portal"
+        c.action do |args, options|
+          FastlaneCore::UI.user_error!("Please run `match nuke [type], allowed values: distribution and development. For the 'adhoc' type, please use 'distribution' instead.")
+        end
+      end
+
+      ["development", "distribution"].each do |type|
+        command "nuke #{type}" do |c|
+          c.syntax = "match nuke #{type}"
+          c.description = "Delete all certificates and provisioning profiles from the Apple Dev Portal of the type #{type}"
+          c.action do |args, options|
+            params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+            Match::Nuke.new.run(params, type: type.to_s)
+          end
+        end
+      end
+
+      default_command :run
+
+      run!
+    end
+  end
+end

data/match/lib/match/encrypt.rb

@@ -0,0 +1,93 @@
+module Match
+  class Encrypt
+    require 'security'
+    require 'shellwords'
+
+    def server_name(git_url)
+      ["match", git_url].join("_")
+    end
+
+    def password(git_url)
+      password = ENV["MATCH_PASSWORD"]
+      unless password
+        item = Security::InternetPassword.find(server: server_name(git_url))
+        password = item.password if item
+      end
+
+      unless password
+        UI.important "Enter the passphrase that should be used to encrypt/decrypt your certificates"
+        UI.important "This passphrase is specific per repository and will be stored in your local keychain"
+        UI.important "Make sure to remember the password, as you'll need it when you run match on a different machine"
+        password = ChangePassword.ask_password(confirm: true)
+        store_password(git_url, password)
+      end
+
+      return password
+    end
+
+    def store_password(git_url, password)
+      Security::InternetPassword.add(server_name(git_url), "", password)
+    end
+
+    # removes the password from the keychain again
+    def clear_password(git_url)
+      Security::InternetPassword.delete(server: server_name(git_url))
+    end
+
+    def encrypt_repo(path: nil, git_url: nil)
+      iterate(path) do |current|
+        crypt(path: current,
+          password: password(git_url),
+           encrypt: true)
+        UI.success "🔒  Encrypted '#{File.basename(current)}'" if $verbose
+      end
+      UI.success "🔒  Successfully encrypted certificates repo"
+    end
+
+    def decrypt_repo(path: nil, git_url: nil, manual_password: nil)
+      iterate(path) do |current|
+        begin
+          crypt(path: current,
+            password: manual_password || password(git_url),
+             encrypt: false)
+        rescue
+          UI.error "Couldn't decrypt the repo, please make sure you enter the right password!"
+          UI.user_error!("Invalid password passed via 'MATCH_PASSWORD'") if ENV["MATCH_PASSWORD"]
+          clear_password(git_url)
+          decrypt_repo(path: path, git_url: git_url)
+          return
+        end
+        UI.success "🔓  Decrypted '#{File.basename(current)}'" if $verbose
+      end
+      UI.success "🔓  Successfully decrypted certificates repo"
+    end
+
+    private
+
+    def iterate(source_path)
+      Dir[File.join(source_path, "**", "*.{cer,p12,mobileprovision}")].each do |path|
+        next if File.directory?(path)
+        yield(path)
+      end
+    end
+
+    def crypt(path: nil, password: nil, encrypt: true)
+      if password.to_s.strip.length == 0 && encrypt
+        UI.user_error!("No password supplied")
+      end
+
+      tmpfile = File.join(Dir.mktmpdir, "temporary")
+      command = ["openssl aes-256-cbc"]
+      command << "-k #{password.shellescape}"
+      command << "-in #{path.shellescape}"
+      command << "-out #{tmpfile.shellescape}"
+      command << "-a"
+      command << "-d" unless encrypt
+      command << "&> /dev/null" unless $verbose # to show show an error message is something goes wrong
+      success = system(command.join(' '))
+
+      UI.crash!("Error decrypting '#{path}'") unless success
+      FileUtils.mv(tmpfile, path)
+    end
+  end
+end

data/match/lib/match/generator.rb

@@ -0,0 +1,74 @@
+module Match
+  # Generate missing resources
+  class Generator
+    def self.generate_certificate(params, cert_type)
+      require 'cert'
+      output_path = File.join(params[:workspace], "certs", cert_type.to_s)
+
+      arguments = FastlaneCore::Configuration.create(Cert::Options.available_options, {
+        development: params[:type] == "development",
+        output_path: output_path,
+        force: true, # we don't need a certificate without its private key, we only care about a new certificate
+        username: params[:username],
+        team_id: params[:team_id],
+        keychain_path: FastlaneCore::Helper.keychain_path(params[:keychain_name])
+      })
+
+      Cert.config = arguments
+
+      begin
+        cert_path = Cert::Runner.new.launch
+      rescue => ex
+        if ex.to_s.include?("You already have a current")
+          UI.user_error!("Could not create a new certificate as you reached the maximum number of certificates for this account. You can use the `match nuke` command to revoke your existing certificates. More information https://github.com/fastlane/fastlane/tree/master/match")
+        else
+          raise ex
+        end
+      end
+
+      # We don't care about the signing request
+      Dir[File.join(params[:workspace], "**", "*.certSigningRequest")].each { |path| File.delete(path) }
+
+      # we need to return the path
+      return cert_path
+    end
+
+    # @return (String) The UUID of the newly generated profile
+    def self.generate_provisioning_profile(params: nil, prov_type: nil, certificate_id: nil, app_identifier: nil)
+      require 'sigh'
+
+      prov_type = Match.profile_type_sym(params[:type])
+
+      profile_name = ["match", profile_type_name(prov_type), app_identifier].join(" ")
+
+      values = {
+        app_identifier: app_identifier,
+        output_path: File.join(params[:workspace], "profiles", prov_type.to_s),
+        username: params[:username],
+        force: true,
+        cert_id: certificate_id,
+        provisioning_name: profile_name,
+        ignore_profiles_with_different_name: true,
+        team_id: params[:team_id]
+      }
+
+      values[:adhoc] = true if prov_type == :adhoc
+      values[:development] = true if prov_type == :development
+
+      arguments = FastlaneCore::Configuration.create(Sigh::Options.available_options, values)
+
+      Sigh.config = arguments
+      path = Sigh::Manager.start
+      return path
+    end
+
+    # @return the name of the provisioning profile type
+    def self.profile_type_name(type)
+      return "Development" if type == :development
+      return "AdHoc" if type == :adhoc
+      return "AppStore" if type == :appstore
+      return "InHouse" if type == :enterprise
+      return "Unkown"
+    end
+  end
+end

data/match/lib/match/git_helper.rb

@@ -0,0 +1,139 @@
+module Match
+  class GitHelper
+    def self.clone(git_url, shallow_clone, manual_password: nil, skip_docs: false, branch: "master")
+      return @dir if @dir
+
+      @dir = Dir.mktmpdir
+
+      command = "git clone '#{git_url}' '#{@dir}'"
+      command << " --depth 1" if shallow_clone
+
+      UI.message "Cloning remote git repo..."
+      begin
+        # GIT_TERMINAL_PROMPT will fail the `git clone` command if user credentials are missing
+        FastlaneCore::CommandExecutor.execute(command: "GIT_TERMINAL_PROMPT=0 #{command}",
+                                            print_all: $verbose,
+                                        print_command: $verbose)
+      rescue
+        UI.error("Error cloning certificates repo, please make sure you have read access to the repository you want to use")
+        UI.error("Run the following command manually to make sure you're properly authenticated:")
+        UI.command(command)
+        UI.user_error!("Error cloning certificates git repo, please make sure you have access to the repository - see instructions above")
+      end
+
+      UI.user_error!("Error cloning repo, make sure you have access to it '#{git_url}'") unless File.directory?(@dir)
+
+      checkout_branch(branch) unless branch == "master"
+
+      if !Helper.test? and GitHelper.match_version(@dir).nil? and manual_password.nil? and File.exist?(File.join(@dir, "README.md"))
+        UI.important "Migrating to new match..."
+        ChangePassword.update(params: { git_url: git_url,
+                                    git_branch: branch,
+                                 shallow_clone: shallow_clone },
+                                          from: "",
+                                            to: Encrypt.new.password(git_url))
+        return self.clone(git_url, shallow_clone)
+      end
+
+      copy_readme(@dir) unless skip_docs
+      Encrypt.new.decrypt_repo(path: @dir, git_url: git_url, manual_password: manual_password)
+
+      return @dir
+    end
+
+    def self.generate_commit_message(params)
+      # 'Automatic commit via fastlane'
+      [
+        "[fastlane]",
+        "Updated",
+        params[:type].to_s
+      ].join(" ")
+    end
+
+    def self.match_version(workspace)
+      path = File.join(workspace, "match_version.txt")
+      if File.exist?(path)
+        Gem::Version.new(File.read(path))
+      end
+    end
+
+    def self.commit_changes(path, message, git_url, branch = "master")
+      Dir.chdir(path) do
+        return if `git status`.include?("nothing to commit")
+
+        Encrypt.new.encrypt_repo(path: path, git_url: git_url)
+        File.write("match_version.txt", Fastlane::VERSION) # unencrypted
+
+        commands = []
+        commands << "git add -A"
+        commands << "git commit -m #{message.shellescape}"
+        commands << "GIT_TERMINAL_PROMPT=0 git push origin #{branch.shellescape}"
+
+        UI.message "Pushing changes to remote git repo..."
+
+        commands.each do |command|
+          FastlaneCore::CommandExecutor.execute(command: command,
+                                              print_all: $verbose,
+                                          print_command: $verbose)
+        end
+      end
+      FileUtils.rm_rf(path)
+      @dir = nil
+    rescue => ex
+      UI.error("Couldn't commit or push changes back to git...")
+      UI.error(ex)
+    end
+
+    def self.clear_changes
+      return unless @dir
+
+      FileUtils.rm_rf(@dir)
+      UI.success "🔒  Successfully encrypted certificates repo" # so the user is happy
+      @dir = nil
+    end
+
+    # Create and checkout an specific branch in the git repo
+    def self.checkout_branch(branch)
+      return unless @dir
+
+      commands = []
+      if branch_exists?(branch)
+        # Checkout the branch if it already exists
+        commands << "git checkout #{branch.shellescape}"
+      else
+        # If a new branch is being created, we create it as an 'orphan' to not inherit changes from the master branch.
+        commands << "git checkout --orphan #{branch.shellescape}"
+        # We also need to reset the working directory to not transfer any uncommitted changes to the new branch.
+        commands << "git reset --hard"
+      end
+
+      UI.message "Checking out branch #{branch}..."
+
+      Dir.chdir(@dir) do
+        commands.each do |command|
+          FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: $verbose,
+                                                print_command: $verbose)
+        end
+      end
+    end
+
+    # Checks if a specific branch exists in the git repo
+    def self.branch_exists?(branch)
+      return unless @dir
+
+      result = Dir.chdir(@dir) do
+        FastlaneCore::CommandExecutor.execute(command: "git branch --list origin/#{branch.shellescape} --no-color -r",
+                                              print_all: $verbose,
+                                              print_command: $verbose)
+      end
+      return !result.empty?
+    end
+
+    # Copies the README.md into the git repo
+    def self.copy_readme(directory)
+      template = File.read("#{Match::ROOT}/lib/assets/READMETemplate.md")
+      File.write(File.join(directory, "README.md"), template)
+    end
+  end
+end