fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/install_on_device.rb

@@ -0,0 +1,92 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+    class InstallOnDeviceAction < Action
+      def self.run(params)
+        unless Helper.test?
+          UI.user_error!("ios-deploy not installed, see https://github.com/ios-control/ios-deploy for instructions") if `which ios-deploy`.length == 0
+        end
+        taxi_cmd = [
+          "ios-deploy",
+          params[:extra],
+          "--bundle",
+          params[:ipa].shellescape
+        ]
+        taxi_cmd << "--no-wifi" if params[:skip_wifi]
+        taxi_cmd << ["--id", params[:device_id]] if params[:device_id]
+        taxi_cmd.compact!
+        return taxi_cmd.join(" ") if Helper.test?
+        Actions.sh(taxi_cmd.join(" "))
+        UI.message("Deployed #{params[:ipa]} to device!")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Installs an .ipa file on a connected iOS-device via usb or wifi"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :extra,
+                                       short_option: "-X",
+                                       env_name: "FL_IOD_EXTRA",
+                                       description: "Extra Commandline arguments passed to ios-deploy",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :device_id,
+                                       short_option: "-d",
+                                       env_name: "FL_IOD_DEVICE_ID",
+                                       description: "id of the device / if not set defaults to first found device",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :skip_wifi,
+                                       short_option: "-w",
+                                       env_name: "FL_IOD_WIFI",
+                                       description: "Do not search for devices via WiFi",
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       short_option: "-i",
+                                       env_name: "FL_IOD_IPA",
+                                       description: "The IPA file to put on the device",
+                                       optional: true,
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] || Dir["*.ipa"].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         unless Helper.test?
+                                           UI.user_error!("Could not find ipa file at path '#{value}'") unless File.exist?(value)
+                                           UI.user_error!("'#{value}' doesn't seem to be an ipa file") unless value.end_with?(".ipa")
+                                         end
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.details
+        "Installs the ipa on the device. If no id is given, the first found iOS device will be used. Works via USB or Wi-Fi. This requires `ios-deploy` to be installed. Please have a look at [ios-deploy](https://github.com/ios-control/ios-deploy). To quickly install it, use `npm -g i ios-deploy`"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'install_on_device(
+            device_id: "a3be6c9ff7e5c3c6028597513243b0f933b876d4",
+            ipa: "./app.ipa"
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/install_provisioning_profile.rb

@@ -0,0 +1,62 @@
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    class InstallProvisioningProfileAction < Action
+      def self.run(params)
+        absolute_path = File.expand_path(params[:path])
+        FastlaneCore::ProvisioningProfile.install(absolute_path)
+      end
+
+      def self.description
+        "Install provisioning profile from path"
+      end
+
+      def self.details
+        "Install provisioning profile from path for current user"
+      end
+
+      def self.authors
+        ["SofteqDG"]
+      end
+
+      def self.category
+        :code_signing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                  env_name: "FL_INSTALL_PROVISIONING_PROFILE_PATH",
+                               description: "Path to provisioning profile",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                absolute_path = File.expand_path(value)
+                                unless File.exist?(absolute_path)
+                                  UI.user_error!("Could not find provisioning profile at path: '#{value}'")
+                                end
+                              end)
+        ]
+      end
+
+      def self.return_value
+        "The absolute path to the installed provisioning profile"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.example_code
+        [
+          'install_provisioning_profile(path: "profiles/profile.mobileprovision")'
+        ]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/install_xcode_plugin.rb

@@ -0,0 +1,91 @@
+module Fastlane
+  module Actions
+    class InstallXcodePluginAction < Action
+      def self.run(params)
+        require 'fileutils'
+
+        if params[:github]
+          base_api_url = params[:github].sub('https://github.com', 'https://api.github.com/repos')
+
+          GithubApiAction.run(
+            url: File.join(base_api_url, 'releases/latest'),
+            http_method: 'GET',
+            error_handlers: {
+              404 => proc do |result|
+                UI.error("No latest release found for the specified GitHub repository")
+              end,
+              '*' => proc do |result|
+                UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
+              end
+            }
+          ) do |result|
+            return nil if result[:json].nil?
+            params[:url] = result[:json]['assets'][0]['browser_download_url']
+          end
+        end
+
+        zip_path = File.join(Dir.tmpdir, 'plugin.zip')
+        sh("curl -Lso #{zip_path} #{params[:url]}")
+        plugins_path = "#{ENV['HOME']}/Library/Application Support/Developer/Shared/Xcode/Plug-ins"
+        FileUtils.mkdir_p(plugins_path)
+        Action.sh("unzip -qo '#{zip_path}' -d '#{plugins_path}'")
+
+        UI.success("Plugin #{File.basename(params[:url], '.zip')} installed successfully")
+        UI.message("Please restart Xcode to use the newly installed plugin")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Install an Xcode plugin for the current user"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :url,
+                                       env_name: "FL_XCODE_PLUGIN_URL",
+                                       description: "URL for Xcode plugin ZIP file",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No URL for InstallXcodePluginAction given, pass using `url: 'url'`") if value.to_s.length == 0
+                                         UI.user_error!("URL doesn't use HTTPS") unless value.start_with?("https://")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :github,
+                                       env_name: "FL_XCODE_PLUGIN_GITHUB",
+                                       description: "GitHub repository URL for Xcode plugin",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No GitHub URL for InstallXcodePluginAction given, pass using `github: 'url'`") if value.to_s.length == 0
+                                         UI.user_error!("URL doesn't use HTTPS") unless value.start_with?("https://")
+                                       end)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["NeoNachoSoto", "tommeier"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :tvos, :watchos, :caros].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'install_xcode_plugin(url: "https://example.com/clubmate/plugin.zip")',
+          'install_xcode_plugin(github: "https://github.com/contentful/ContentfulXcodePlugin")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/installr.rb

@@ -0,0 +1,129 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      INSTALLR_BUILD_INFORMATION = :INSTALLR_BUILD_INFORMATION
+    end
+
+    class InstallrAction < Action
+      INSTALLR_API = "https://www.installrapp.com/apps.json"
+
+      def self.run(params)
+        UI.success('Upload to Installr has been started. This may take some time.')
+
+        response = self.upload_build(params)
+
+        case response.status
+        when 200...300
+          Actions.lane_context[SharedValues::INSTALLR_BUILD_INFORMATION] = response.body
+          UI.success('Build successfully uploaded to Installr!')
+        else
+          UI.user_error!("Error when trying to upload build file to Installr: #{response.body}")
+        end
+      end
+
+      def self.upload_build(params)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        url = INSTALLR_API
+        connection = Faraday.new(url) do |builder|
+          builder.request(:multipart)
+          builder.request(:url_encoded)
+          builder.response(:json, content_type: /\bjson$/)
+          builder.use(FaradayMiddleware::FollowRedirects)
+          builder.adapter(:net_http)
+        end
+
+        options = {}
+        options[:qqfile] = Faraday::UploadIO.new(params[:ipa], 'application/octet-stream')
+
+        if params[:notes]
+          options[:releaseNotes] = params[:notes]
+        end
+
+        if params[:notify]
+          options[:notify] = params[:notify]
+        end
+
+        if params[:add]
+          options[:add] = params[:add]
+        end
+
+        post_request = connection.post do |req|
+          req.headers['X-InstallrAppToken'] = params[:api_token]
+          req.body = options
+        end
+
+        post_request.on_complete do |env|
+          yield(env[:status], env[:body]) if block_given?
+        end
+      end
+
+      def self.description
+        "Upload a new build to [Installr](http://installrapp.com/)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "INSTALLR_API_TOKEN",
+                                       sensitive: true,
+                                       description: "API Token for Installr Access",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API token for Installr given, pass using `api_token: 'token'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "INSTALLR_IPA_PATH",
+                                       description: "Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action",
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find build file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :notes,
+                                       env_name: "INSTALLR_NOTES",
+                                       description: "Release notes",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :notify,
+                                       env_name: "INSTALLR_NOTIFY",
+                                       description: "Groups to notify (e.g. 'dev,qa')",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :add,
+                                       env_name: "INSTALLR_ADD",
+                                       description: "Groups to add (e.g. 'exec,ops')",
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['INSTALLR_BUILD_INFORMATION', 'Contains release info like :appData. See http://help.installrapp.com/api/']
+        ]
+      end
+
+      def self.authors
+        ["scottrhoyt"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'installr(
+            api_token: "...",
+            ipa: "test.ipa",
+            notes: "The next great version of the app!",
+            notify: "dev,qa",
+            add: "exec,ops"
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ipa.rb

@@ -0,0 +1,246 @@
+# rubocop:disable Lint/AssignmentInCondition
+module Fastlane
+  module Actions
+    module SharedValues
+      IPA_OUTPUT_PATH ||= :IPA_OUTPUT_PATH # originally defined in BuildIosAppAction
+      DSYM_OUTPUT_PATH ||= :DSYM_OUTPUT_PATH # originally defined in BuildIosAppAction
+    end
+
+    ARGS_MAP = {
+      workspace: '-w',
+      project: '-p',
+      configuration: '-c',
+      scheme: '-s',
+      clean: '--clean',
+      archive: '--archive',
+      destination: '-d',
+      embed: '-m',
+      identity: '-i',
+      sdk: '--sdk',
+      ipa: '--ipa',
+      xcconfig: '--xcconfig',
+      xcargs: '--xcargs'
+    }
+
+    class IpaAction < Action
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.run(params)
+        Actions.verify_gem!('krausefx-shenzhen')
+
+        # The output directory of the IPA and dSYM
+        absolute_dest_directory = nil
+
+        # Used to get the final path of the IPA and dSYM
+        if dest = params[:destination]
+          absolute_dest_directory = File.expand_path(dest)
+        end
+
+        # The args we will build with
+        # Maps nice developer build parameters to Shenzhen args
+        build_args = params_to_build_args(params)
+
+        unless params[:scheme]
+          UI.important("You haven't specified a scheme. This might cause problems. If you can't see any output, please pass a `scheme`")
+        end
+
+        # If no dest directory given, default to current directory
+        absolute_dest_directory ||= Dir.pwd
+
+        if Helper.test?
+          Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] = File.join(absolute_dest_directory, 'test.ipa')
+          Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH] = File.join(absolute_dest_directory, 'test.app.dSYM.zip')
+          return build_args
+        end
+
+        # Joins args into space delimited string
+        build_args = build_args.join(' ')
+
+        core_command = "krausefx-ipa build #{build_args} --verbose | xcpretty"
+        command = "set -o pipefail && #{core_command}"
+        UI.verbose(command)
+
+        begin
+          Actions.sh(command)
+
+          # Finds absolute path of IPA and dSYM
+          absolute_ipa_path = find_ipa_file(absolute_dest_directory)
+          absolute_dsym_path = find_dsym_file(absolute_dest_directory)
+
+          # Sets shared values to use after this action is performed
+          Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] = absolute_ipa_path
+          Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH] = absolute_dsym_path
+          ENV[SharedValues::IPA_OUTPUT_PATH.to_s] = absolute_ipa_path # for deliver
+          ENV[SharedValues::DSYM_OUTPUT_PATH.to_s] = absolute_dsym_path
+
+          deprecation_warning
+        rescue => ex
+          [
+            "-------------------------------------------------------",
+            "Original Error:",
+            " => " + ex.to_s,
+            "A build error occurred. You are using legacy `shenzhen` for building",
+            "it is recommended to upgrade to _gym_: ",
+            "https://docs.fastlane.tools/actions/gym/",
+            core_command,
+            "-------------------------------------------------------"
+          ].each do |txt|
+            UI.error(txt)
+          end
+
+          # Raise a custom exception, as the the normal one is useless for the user
+          UI.user_error!("A build error occurred, this is usually related to code signing. Take a look at the error above")
+        end
+      end
+
+      def self.params_to_build_args(config)
+        params = config.values
+
+        params = params.delete_if { |k, v| v.nil? }
+        params = fill_in_default_values(params)
+
+        # Maps nice developer param names to Shenzhen's `ipa build` arguments
+        params.collect do |k, v|
+          v ||= ''
+          if ARGS_MAP[k]
+            if k == :clean
+              v == true ? '--clean' : '--no-clean'
+            elsif k == :archive
+              v == true ? '--archive' : '--no-archive'
+            else
+              value = (v.to_s.length > 0 ? "\"#{v}\"" : '')
+              "#{ARGS_MAP[k]} #{value}".strip
+            end
+          end
+        end.compact
+      end
+
+      def self.fill_in_default_values(params)
+        embed = Actions.lane_context[Actions::SharedValues::SIGH_PROFILE_PATH] || ENV["SIGH_PROFILE_PATH"]
+        params[:embed] ||= embed if embed
+        params
+      end
+
+      def self.find_ipa_file(dir)
+        # Finds last modified .ipa in the destination directory
+        Dir[File.join(dir, '*.ipa')].sort { |a, b| File.mtime(b) <=> File.mtime(a) }.first
+      end
+
+      def self.find_dsym_file(dir)
+        # Finds last modified .dSYM.zip in the destination directory
+        Dir[File.join(dir, '*.dSYM.zip')].sort { |a, b| File.mtime(b) <=> File.mtime(a) }.first
+      end
+
+      def self.description
+        "Easily build and sign your app using shenzhen"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :workspace,
+                                       env_name: "IPA_WORKSPACE",
+                                       description: "WORKSPACE Workspace (.xcworkspace) file to use to build app (automatically detected in current directory)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :project,
+                                       env_name: "IPA_PROJECT",
+                                       description: "Project (.xcodeproj) file to use to build app (automatically detected in current directory, overridden by --workspace option, if passed)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       env_name: "IPA_CONFIGURATION",
+                                       description: "Configuration used to build",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :scheme,
+                                       env_name: "IPA_SCHEME",
+                                       description: "Scheme used to build app",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       env_name: "IPA_CLEAN",
+                                       description: "Clean project before building",
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :archive,
+                                       env_name: "IPA_ARCHIVE",
+                                       description: "Archive project after building",
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       env_name: "IPA_DESTINATION",
+                                       description: "Build destination. Defaults to current directory",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :embed,
+                                       env_name: "IPA_EMBED",
+                                       description: "Sign .ipa file with .mobileprovision",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :identity,
+                                       env_name: "IPA_IDENTITY",
+                                       description: "Identity to be used along with --embed",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :sdk,
+                                       env_name: "IPA_SDK",
+                                       description: "Use SDK as the name or path of the base SDK when building the project",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "IPA_IPA",
+                                       description: "Specify the name of the .ipa file to generate (including file extension)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :xcconfig,
+                                       env_name: "IPA_XCCONFIG",
+                                       description: "Use an extra XCCONFIG file to build the app",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :xcargs,
+                                       env_name: "IPA_XCARGS",
+                                       description: "Pass additional arguments to xcodebuild when building the app. Be sure to quote multiple args",
+                                       optional: true,
+                                       type: :shell_string)
+        ]
+      end
+
+      def self.output
+        [
+          ['IPA_OUTPUT_PATH', 'The path to the newly generated ipa file'],
+          ['DSYM_OUTPUT_PATH', 'The path to the dsym file']
+        ]
+      end
+
+      def self.author
+        "joshdholtz"
+      end
+
+      def self.example_code
+        [
+          'ipa(
+            workspace: "MyApp.xcworkspace",
+            configuration: "Debug",
+            scheme: "MyApp",
+            # (optionals)
+            clean: true,                     # This means "Do Clean". Cleans project before building (the default if not specified).
+            destination: "path/to/dir",      # Destination directory. Defaults to current directory.
+            ipa: "my-app.ipa",               # specify the name of the .ipa file to generate (including file extension)
+            xcargs: "MY_ADHOC=0",            # pass additional arguments to xcodebuild when building the app.
+            embed: "my.mobileprovision",     # Sign .ipa file with .mobileprovision
+            identity: "MyIdentity",          # Identity to be used along with --embed
+            sdk: "10.0",                     # use SDK as the name or path of the base SDK when building the project.
+            archive: true                    # this means "Do Archive". Archive project after building (the default if not specified).
+          )'
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        [
+          "You are using legacy `shenzhen` to build your app, which will be removed soon!",
+          "It is recommended to upgrade to _gym_.",
+          "To do so, just replace `ipa(...)` with `gym(...)` in your Fastfile.",
+          "To make code signing work, follow [https://docs.fastlane.tools/codesigning/xcode-project/](https://docs.fastlane.tools/codesigning/xcode-project/)."
+        ].join("\n")
+      end
+    end
+  end
+end
+# rubocop:enable Lint/AssignmentInCondition

data/fastlane/lib/fastlane/actions/is_ci.rb

@@ -0,0 +1,51 @@
+module Fastlane
+  module Actions
+    class IsCiAction < Action
+      def self.run(params)
+        Helper.ci?
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Is the current run being executed on a CI system, like Jenkins or Travis"
+      end
+
+      def self.details
+        "The return value of this method is true if fastlane is currently executed on Travis, Jenkins, Circle or a similar CI service"
+      end
+
+      def self.available_options
+        []
+      end
+
+      def self.return_type
+        :bool
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'if is_ci
+            puts "I\'m a computer"
+          else
+            say "Hi Human!"
+          end'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end