fastlane 1.111.0 → 2.0.1

data/gym/lib/gym/generators/README.md

@@ -0,0 +1 @@
+All the classes that generate commands we want to execute

data/gym/lib/gym/generators/build_command_generator.rb

@@ -0,0 +1,136 @@
+require 'shellwords'
+
+module Gym
+  # Responsible for building the fully working xcodebuild command
+  class BuildCommandGenerator
+    class << self
+      def generate
+        parts = prefix
+        parts << "xcodebuild"
+        parts += options
+        parts += actions
+        parts += suffix
+        parts += pipe
+
+        parts
+      end
+
+      def prefix
+        ["set -o pipefail &&"]
+      end
+
+      # Path to the project or workspace as parameter
+      # This will also include the scheme (if given)
+      # @return [Array] The array with all the components to join
+      def project_path_array
+        proj = Gym.project.xcodebuild_parameters
+        return proj if proj.count > 0
+        UI.user_error!("No project/workspace found")
+      end
+
+      def options
+        config = Gym.config
+
+        options = []
+        options += project_path_array
+        options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+        options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
+        options << "-destination '#{config[:destination]}'" if config[:destination]
+        options << "-xcconfig '#{config[:xcconfig]}'" if config[:xcconfig]
+        options << "-archivePath #{archive_path.shellescape}"
+        options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
+        options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
+        options << config[:xcargs] if config[:xcargs]
+
+        options
+      end
+
+      def actions
+        config = Gym.config
+
+        actions = []
+        actions << :clean if config[:clean]
+        actions << :archive unless Gym.project.library? || Gym.project.framework?
+        actions << :build if Gym.project.library? || Gym.project.framework?
+
+        actions
+      end
+
+      def suffix
+        suffix = []
+        suffix << "CODE_SIGN_IDENTITY=#{Gym.config[:codesigning_identity].shellescape}" if Gym.config[:codesigning_identity]
+        suffix
+      end
+
+      def pipe
+        pipe = []
+        pipe << "| tee #{xcodebuild_log_path.shellescape}"
+        unless Gym.config[:disable_xcpretty]
+          formatter = Gym.config[:xcpretty_formatter]
+          pipe << "| xcpretty"
+          pipe << " --test" if Gym.config[:xcpretty_test_format]
+          pipe << " --no-color" if Helper.colors_disabled?
+          pipe << " --formatter " if formatter
+          pipe << formatter if formatter
+          report_output_junit = Gym.config[:xcpretty_report_junit]
+          report_output_html = Gym.config[:xcpretty_report_html]
+          report_output_json = Gym.config[:xcpretty_report_json]
+          if report_output_junit
+            pipe << " --report junit --output "
+            pipe << report_output_junit.shellescape
+          elsif report_output_html
+            pipe << " --report html --output "
+            pipe << report_output_html.shellescape
+          elsif report_output_json
+            pipe << " --report json-compilation-database --output "
+            pipe << report_output_json.shellescape
+          end
+        end
+        pipe << "> /dev/null" if Gym.config[:suppress_xcode_output]
+
+        pipe
+      end
+
+      def xcodebuild_log_path
+        file_name = "#{Gym.project.app_name}-#{Gym.config[:scheme]}.log"
+        containing = File.expand_path(Gym.config[:buildlog_path])
+        FileUtils.mkdir_p(containing)
+
+        return File.join(containing, file_name)
+      end
+
+      # The path where archive will be created
+      def build_path
+        unless Gym.cache[:build_path]
+          Gym.cache[:build_path] = Gym.config[:build_path]
+          unless Gym.cache[:build_path]
+            day = Time.now.strftime("%F") # e.g. 2015-08-07
+            Gym.cache[:build_path] = File.expand_path("~/Library/Developer/Xcode/Archives/#{day}/")
+          end
+          FileUtils.mkdir_p Gym.cache[:build_path]
+        end
+        Gym.cache[:build_path]
+      end
+
+      def archive_path
+        Gym.cache[:archive_path] ||= Gym.config[:archive_path]
+        unless Gym.cache[:archive_path]
+          file_name = [Gym.config[:output_name], Time.now.strftime("%F %H.%M.%S")] # e.g. 2015-08-07 14.49.12
+          Gym.cache[:archive_path] = File.join(build_path, file_name.join(" ") + ".xcarchive")
+        end
+
+        if File.extname(Gym.cache[:archive_path]) != ".xcarchive"
+          Gym.cache[:archive_path] += ".xcarchive"
+        end
+        return Gym.cache[:archive_path]
+      end
+
+      def result_bundle_path
+        unless Gym.cache[:result_bundle_path]
+          Gym.cache[:result_bundle_path] = File.join(Gym.config[:output_directory], Gym.config[:output_name]) + ".result"
+        end
+        return Gym.cache[:result_bundle_path]
+      end
+    end
+  end
+end

data/gym/lib/gym/generators/package_command_generator.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# from http://stackoverflow.com/a/9857493/445598
+# because of
+# `incompatible encoding regexp match (UTF-8 regexp with ASCII-8BIT string) (Encoding::CompatibilityError)`
+
+require 'shellwords'
+
+# The concrete implementations
+require 'gym/generators/package_command_generator_legacy'
+require 'gym/generators/package_command_generator_xcode7'
+
+module Gym
+  class PackageCommandGenerator
+    class << self
+      def generate
+        generator.generate
+      end
+
+      def appfile_path
+        generator.appfile_path
+      end
+
+      # The path in which the ipa file will be available after executing the command
+      def ipa_path
+        generator.ipa_path
+      end
+
+      def dsym_path
+        generator.dsym_path
+      end
+
+      def manifest_path
+        generator.manifest_path
+      end
+
+      def app_thinning_path
+        generator.app_thinning_path
+      end
+
+      def app_thinning_size_report_path
+        generator.app_thinning_size_report_path
+      end
+
+      def apps_path
+        generator.apps_path
+      end
+
+      # The generator we need to use for the currently used Xcode version
+      def generator
+        if Gym.config[:use_legacy_build_api]
+          PackageCommandGeneratorLegacy
+        else
+          PackageCommandGeneratorXcode7
+        end
+      end
+    end
+  end
+end

data/gym/lib/gym/generators/package_command_generator_legacy.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+# from http://stackoverflow.com/a/9857493/445598
+# because of
+# `incompatible encoding regexp match (UTF-8 regexp with ASCII-8BIT string) (Encoding::CompatibilityError)`
+
+module Gym
+  # Responsible for building the fully working xcodebuild command on Xcode < 7
+  #
+  # Because of a known bug in PackageApplication Perl script used by Xcode the packaging process is performed with
+  # a patched version of the script.
+  class PackageCommandGeneratorLegacy
+    class << self
+      def generate
+        print_legacy_information
+
+        parts = ["/usr/bin/xcrun #{XcodebuildFixes.patch_package_application.shellescape} -v"]
+        parts += options
+        parts += pipe
+
+        parts
+      end
+
+      def options
+        options = []
+
+        options << Shellwords.escape(appfile_path)
+        options << "-o '#{ipa_path}'"
+        options << "exportFormat ipa"
+
+        if Gym.config[:provisioning_profile_path]
+          options << "--embed '#{Gym.config[:provisioning_profile_path]}'"
+        end
+
+        if Gym.config[:codesigning_identity]
+          options << "--sign #{Gym.config[:codesigning_identity].shellescape}"
+        end
+
+        options
+      end
+
+      def pipe
+        [""]
+      end
+
+      # Place where the IPA file will be created, so it can be safely moved to the destination folder
+      def temporary_output_path
+        Gym.cache[:temporary_output_path] ||= Dir.mktmpdir('gym_output')
+      end
+
+      def appfile_path
+        path = Dir.glob("#{BuildCommandGenerator.archive_path}/Products/Applications/*.app").first
+        path ||= Dir[BuildCommandGenerator.archive_path + "/**/*.app"].first
+
+        return path
+      end
+
+      # We export it to the temporary folder and move it over to the actual output once it's finished and valid
+      def ipa_path
+        File.join(temporary_output_path, "#{Gym.config[:output_name]}.ipa")
+      end
+
+      # The path the the dsym file for this app. Might be nil
+      def dsym_path
+        Dir[BuildCommandGenerator.archive_path + "/**/*.app.dSYM"].last
+      end
+
+      def manifest_path
+        ""
+      end
+
+      def app_thinning_path
+        ""
+      end
+
+      def app_thinning_size_report_path
+        ""
+      end
+
+      def apps_path
+        ""
+      end
+
+      def print_legacy_information
+        if Gym.config[:include_bitcode]
+          UI.important "Legacy build api is enabled, the `include_bitcode` value will be ignored"
+        end
+
+        if Gym.config[:include_symbols]
+          UI.important "Legacy build api is enabled, the `include_symbols` value will be ignored"
+        end
+
+        if Gym.config[:export_team_id].to_s.length > 0
+          UI.important "Legacy build api is enabled, the `export_team_id` value will be ignored"
+        end
+
+        if Gym.config[:export_method].to_s.length > 0
+          UI.important "Legacy build api is enabled, the `export_method` value will be ignored"
+        end
+      end
+    end
+  end
+end

data/gym/lib/gym/generators/package_command_generator_xcode7.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+# from http://stackoverflow.com/a/9857493/445598
+# because of
+# `incompatible encoding regexp match (UTF-8 regexp with ASCII-8BIT string) (Encoding::CompatibilityError)`
+
+require 'tempfile'
+
+module Gym
+  # Responsible for building the fully working xcodebuild command
+  class PackageCommandGeneratorXcode7
+    class << self
+      def generate
+        print_legacy_information
+
+        parts = ["/usr/bin/xcrun #{XcodebuildFixes.wrap_xcodebuild.shellescape} -exportArchive"]
+        parts += options
+        parts += pipe
+
+        File.write(config_path, config_content) # overwrite everytime. Could be optimized
+
+        parts
+      end
+
+      def options
+        config = Gym.config
+
+        options = []
+        options << "-exportOptionsPlist '#{config_path}'"
+        options << "-archivePath #{BuildCommandGenerator.archive_path.shellescape}"
+        options << "-exportPath '#{temporary_output_path}'"
+        options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
+        options << config[:export_xcargs] if config[:export_xcargs]
+
+        options
+      end
+
+      def pipe
+        [""]
+      end
+
+      # We export the ipa into this directory, as we can't specify the ipa file directly
+      def temporary_output_path
+        Gym.cache[:temporary_output_path] ||= Dir.mktmpdir('gym_output')
+      end
+
+      def ipa_path
+        unless Gym.cache[:ipa_path]
+          path = Dir[File.join(temporary_output_path, "*.ipa")].last
+          # We need to process generic IPA
+          if path
+            # Try to find IPA file in the output directory, used when app thinning was not set
+            Gym.cache[:ipa_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.ipa")
+            FileUtils.mv(path, Gym.cache[:ipa_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:ipa_path]).downcase).zero?
+          elsif Dir.exist?(apps_path)
+            # Try to find "generic" IPA file inside "Apps" folder, used when app thinning was set
+            files = Dir[File.join(apps_path, "*.ipa")]
+            # Generic IPA file doesn't have suffix so its name is the shortest
+            path = files.min_by(&:length)
+            Gym.cache[:ipa_path] = File.join(temporary_output_path, "#{Gym.config[:output_name]}.ipa")
+            FileUtils.cp(path, Gym.cache[:ipa_path]) unless File.expand_path(path).casecmp(File.expand_path(Gym.cache[:ipa_path]).downcase).zero?
+          else
+            ErrorHandler.handle_empty_archive unless path
+          end
+        end
+        Gym.cache[:ipa_path]
+      end
+
+      # The path the the dsym file for this app. Might be nil
+      def dsym_path
+        Dir[BuildCommandGenerator.archive_path + "/**/*.app.dSYM"].last
+      end
+
+      # The path the config file we use to sign our app
+      def config_path
+        Gym.cache[:config_path] ||= "#{Tempfile.new('gym_config').path}.plist"
+        return Gym.cache[:config_path]
+      end
+
+      # The path to the manifest plist file
+      def manifest_path
+        Gym.cache[:manifest_path] ||= File.join(temporary_output_path, "manifest.plist")
+      end
+
+      # The path to the app-thinning plist file
+      def app_thinning_path
+        Gym.cache[:app_thinning] ||= File.join(temporary_output_path, "app-thinning.plist")
+      end
+
+      # The path to the App Thinning Size Report file
+      def app_thinning_size_report_path
+        Gym.cache[:app_thinning_size_report] ||= File.join(temporary_output_path, "App Thinning Size Report.txt")
+      end
+
+      # The path to the Apps folder
+      def apps_path
+        Gym.cache[:apps_path] ||= File.join(temporary_output_path, "Apps")
+      end
+
+      private
+
+      def normalize_export_options(hash)
+        # Normalize some values
+        hash[:onDemandResourcesAssetPacksBaseURL] = URI.escape(hash[:onDemandResourcesAssetPacksBaseURL]) if hash[:onDemandResourcesAssetPacksBaseURL]
+        if hash[:manifest]
+          hash[:manifest][:appURL] = URI.escape(hash[:manifest][:appURL]) if hash[:manifest][:appURL]
+          hash[:manifest][:displayImageURL] = URI.escape(hash[:manifest][:displayImageURL]) if hash[:manifest][:displayImageURL]
+          hash[:manifest][:fullSizeImageURL] = URI.escape(hash[:manifest][:fullSizeImageURL]) if hash[:manifest][:fullSizeImageURL]
+          hash[:manifest][:assetPackManifestURL] = URI.escape(hash[:manifest][:assetPackManifestURL]) if hash[:manifest][:assetPackManifestURL]
+        end
+        hash
+      end
+
+      def keys_to_symbols(hash)
+        # Convert keys to symbols
+        hash = hash.each_with_object({}) do |(k, v), memo|
+          memo[k.to_sym] = v
+          memo
+        end
+        hash
+      end
+
+      def read_export_options
+        # Reads export options
+        if Gym.config[:export_options]
+          if Gym.config[:export_options].kind_of?(Hash)
+            # Reads options from hash
+            hash = normalize_export_options(Gym.config[:export_options])
+          else
+            # Reads options from file
+            hash = Plist.parse_xml(Gym.config[:export_options])
+            # Convert keys to symbols
+            hash = keys_to_symbols(hash)
+          end
+
+          # Saves configuration for later use
+          Gym.config[:export_method] ||= hash[:method]
+          Gym.config[:include_symbols] = hash[:uploadSymbols] if Gym.config[:include_symbols].nil?
+          Gym.config[:include_bitcode] = hash[:uploadBitcode] if Gym.config[:include_bitcode].nil?
+          Gym.config[:export_team_id] ||= hash[:teamID]
+        else
+          hash = {}
+          # Sets default values
+          Gym.config[:export_method] ||= "app-store"
+          Gym.config[:include_symbols] = true if Gym.config[:include_symbols].nil?
+          Gym.config[:include_bitcode] = false if Gym.config[:include_bitcode].nil?
+        end
+        hash
+      end
+
+      def config_content
+        require 'plist'
+
+        hash = read_export_options
+
+        # Overrides export options if needed
+        hash[:method] = Gym.config[:export_method]
+        if Gym.config[:export_method] == 'app-store'
+          hash[:uploadSymbols] = (Gym.config[:include_symbols] ? true : false) unless Gym.config[:include_symbols].nil?
+          hash[:uploadBitcode] = (Gym.config[:include_bitcode] ? true : false) unless Gym.config[:include_bitcode].nil?
+        end
+        hash[:teamID] = Gym.config[:export_team_id] if Gym.config[:export_team_id]
+
+        UI.important("Generated plist file with the following values:")
+        UI.command_output("-----------------------------------------")
+        UI.command_output(JSON.pretty_generate(hash))
+        UI.command_output("-----------------------------------------")
+        if $verbose
+          UI.message("This results in the following plist file:")
+          UI.command_output("-----------------------------------------")
+          UI.command_output(to_plist(hash))
+          UI.command_output("-----------------------------------------")
+        end
+
+        to_plist(hash)
+      end
+
+      # Avoids a Hash#to_plist conflict between CFPropertyList and plist gems
+      def to_plist(hash)
+        Plist::Emit.dump(hash, true)
+      end
+
+      def print_legacy_information
+        return if Gym.config[:provisioning_profile_path].to_s.length == 0
+
+        UI.error "You're using Xcode 7 or above, the `provisioning_profile_path` value will be ignored"
+        UI.error "Please follow the Code Signing Guide: https://codesigning.guide (for match) or https://docs.fastlane.tools/codesigning/GettingStarted/"
+        UI.error "This is just a warning, gym will continue running just as expected, but the parameter will be ignored"
+      end
+    end
+  end
+end