fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/build_app.rb

@@ -0,0 +1,171 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      IPA_OUTPUT_PATH ||= :IPA_OUTPUT_PATH
+      PKG_OUTPUT_PATH ||= :PKG_OUTPUT_PATH
+      DSYM_OUTPUT_PATH ||= :DSYM_OUTPUT_PATH
+      XCODEBUILD_ARCHIVE ||= :XCODEBUILD_ARCHIVE # originally defined in XcodebuildAction
+    end
+
+    class BuildAppAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.run(values)
+        require 'gym'
+
+        unless Actions.lane_context[SharedValues::SIGH_PROFILE_TYPE].to_s == "development"
+          values[:export_method] ||= Actions.lane_context[SharedValues::SIGH_PROFILE_TYPE]
+        end
+
+        if Actions.lane_context[SharedValues::MATCH_PROVISIONING_PROFILE_MAPPING]
+          # Since Xcode 9 you need to explicitly provide the provisioning profile per app target
+          # If the user is smart and uses match and gym together with fastlane, we can do all
+          # the heavy lifting for them
+          values[:export_options] ||= {}
+          # It's not always a hash, because the user might have passed a string path to a ready plist file
+          # If that's the case, we won't set the provisioning profiles
+          # see https://github.com/fastlane/fastlane/issues/9490
+          if values[:export_options].kind_of?(Hash)
+            match_mapping = (Actions.lane_context[SharedValues::MATCH_PROVISIONING_PROFILE_MAPPING] || {}).dup
+            existing_mapping = (values[:export_options][:provisioningProfiles] || {}).dup
+
+            # Be smart about how we merge those mappings in case there are conflicts
+            mapping_object = Gym::CodeSigningMapping.new
+            hash_to_use = mapping_object.merge_profile_mapping(primary_mapping: existing_mapping,
+                                                             secondary_mapping: match_mapping,
+                                                                export_method: values[:export_method])
+
+            values[:export_options][:provisioningProfiles] = hash_to_use
+          else
+            self.show_xcode_9_warning
+          end
+        elsif Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS]
+          # Since Xcode 9 you need to explicitly provide the provisioning profile per app target
+          # If the user used sigh we can match the profiles from sigh
+          values[:export_options] ||= {}
+          if values[:export_options].kind_of?(Hash)
+            # It's not always a hash, because the user might have passed a string path to a ready plist file
+            # If that's the case, we won't set the provisioning profiles
+            # see https://github.com/fastlane/fastlane/issues/9684
+            values[:export_options][:provisioningProfiles] ||= {}
+            Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS].each do |profile_path|
+              begin
+                profile = FastlaneCore::ProvisioningProfile.parse(profile_path)
+                app_id_prefix = profile["ApplicationIdentifierPrefix"].first
+                entitlements = profile["Entitlements"]
+                bundle_id = (entitlements["application-identifier"] || entitlements["com.apple.application-identifier"]).gsub("#{app_id_prefix}.", "")
+                values[:export_options][:provisioningProfiles][bundle_id] = profile["Name"]
+              rescue => ex
+                UI.error("Couldn't load profile at path: #{profile_path}")
+                UI.error(ex)
+                UI.verbose(ex.backtrace.join("\n"))
+              end
+            end
+          else
+            self.show_xcode_9_warning
+          end
+        end
+
+        gym_output_path = Gym::Manager.new.work(values)
+        if gym_output_path.nil?
+          UI.important("No output path received from gym")
+          return nil
+        end
+
+        absolute_output_path = File.expand_path(gym_output_path)
+
+        # Binary path
+        if File.extname(absolute_output_path) == ".ipa"
+          absolute_dsym_path = absolute_output_path.gsub(/.ipa$/, ".app.dSYM.zip")
+
+          Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] = absolute_output_path
+          ENV[SharedValues::IPA_OUTPUT_PATH.to_s] = absolute_output_path # for deliver
+        elsif File.extname(absolute_output_path) == ".pkg"
+          absolute_dsym_path = absolute_output_path.gsub(/.pkg$/, ".dSYM.zip")
+
+          Actions.lane_context[SharedValues::PKG_OUTPUT_PATH] = absolute_output_path
+          ENV[SharedValues::PKG_OUTPUT_PATH.to_s] = absolute_output_path # for deliver
+        end
+
+        # xcarchive path
+        Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE] = Gym::BuildCommandGenerator.archive_path
+
+        # dSYM path
+        if absolute_dsym_path && File.exist?(absolute_dsym_path)
+          Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH] = absolute_dsym_path
+          ENV[SharedValues::DSYM_OUTPUT_PATH.to_s] = absolute_dsym_path
+        end
+
+        return absolute_output_path
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.description
+        "Easily build and sign your app (via _gym_)"
+      end
+
+      def self.details
+        "More information: https://fastlane.tools/gym"
+      end
+
+      def self.output
+        [
+          ['IPA_OUTPUT_PATH', 'The path to the newly generated ipa file'],
+          ['PKG_OUTPUT_PATH', 'The path to the newly generated pkg file'],
+          ['DSYM_OUTPUT_PATH', 'The path to the dSYM files'],
+          ['XCODEBUILD_ARCHIVE', 'The path to the xcodebuild archive']
+        ]
+      end
+
+      def self.return_value
+        "The absolute path to the generated ipa file"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.available_options
+        require 'gym'
+        Gym::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'build_app(scheme: "MyApp", workspace: "MyApp.xcworkspace")',
+          'build_app(
+            workspace: "MyApp.xcworkspace",
+            configuration: "Debug",
+            scheme: "MyApp",
+            silent: true,
+            clean: true,
+            output_directory: "path/to/dir", # Destination directory. Defaults to current directory.
+            output_name: "my-app.ipa",       # specify the name of the .ipa file to generate (including file extension)
+            sdk: "iOS 11.1"                  # use SDK as the name or path of the base SDK when building the project.
+          )',
+          'gym              # alias for "build_app"',
+          'build_ios_app    # alias for "build_app (only iOS options)"',
+          'build_mac_app    # alias for "build_app (only macOS options)"'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.show_xcode_9_warning
+        return unless Helper.xcode_at_least?("9.0")
+        UI.message("You passed a path to a custom plist file for exporting the binary.")
+        UI.message("Make sure to include information about what provisioning profiles to use with Xcode 9")
+        UI.message("More information: https://docs.fastlane.tools/codesigning/xcode-project/#xcode-9-and-up")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/build_ios_app.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/build_app'
+    class BuildIosAppAction < BuildAppAction
+      # Gym::Options.available_options keys that don't apply to ios apps.
+      REJECT_OPTIONS = [
+        :pkg,
+        :skip_package_pkg,
+        :catalyst_platform,
+        :installer_cert_name
+      ]
+
+      def self.run(params)
+        # Adding reject options back in  so gym has everything it needs
+        params.available_options += Gym::Options.available_options.select do |option|
+          REJECT_OPTIONS.include?(option.key)
+        end
+
+        # Defaulting to ios specific values
+        params[:catalyst_platform] = "ios"
+
+        super(params)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.available_options
+        require 'gym'
+        require 'gym/options'
+
+        Gym::Options.available_options.reject do |option|
+          REJECT_OPTIONS.include?(option.key)
+        end
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+
+      def self.description
+        "Alias for the `build_app` action but only for iOS"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/build_mac_app.rb

@@ -0,0 +1,46 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/build_app'
+    class BuildMacAppAction < BuildAppAction
+      # Gym::Options.available_options keys that don't apply to mac apps.
+      REJECT_OPTIONS = [
+        :ipa,
+        :skip_package_ipa,
+        :catalyst_platform
+      ]
+
+      def self.run(params)
+        # Adding reject options back in  so gym has everything it needs
+        params.available_options += Gym::Options.available_options.select do |option|
+          REJECT_OPTIONS.include?(option.key)
+        end
+
+        # Defaulting to mac specific values
+        params[:catalyst_platform] = "macos"
+
+        super(params)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.available_options
+        require 'gym'
+        require 'gym/options'
+
+        Gym::Options.available_options.reject do |option|
+          REJECT_OPTIONS.include?(option.key)
+        end
+      end
+
+      def self.is_supported?(platform)
+        [:mac].include?(platform)
+      end
+
+      def self.description
+        "Alias for the `build_app` action but only for macOS"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/bundle_install.rb

@@ -0,0 +1,166 @@
+module Fastlane
+  module Actions
+    class BundleInstallAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.run(params)
+        if gemfile_exists?(params)
+          cmd = ['bundle install']
+
+          cmd << "--binstubs #{params[:binstubs]}" if params[:binstubs]
+          cmd << "--clean" if params[:clean]
+          cmd << "--full-index" if params[:full_index]
+          cmd << "--gemfile #{params[:gemfile]}" if params[:gemfile]
+          cmd << "--jobs #{params[:jobs]}" if params[:jobs]
+          cmd << "--local" if params[:local]
+          cmd << "--deployment" if params[:deployment]
+          cmd << "--no-cache" if params[:no_cache]
+          cmd << "--no_prune" if params[:no_prune]
+          cmd << "--path #{params[:path]}" if params[:path]
+          cmd << "--system" if params[:system]
+          cmd << "--quiet" if params[:quiet]
+          cmd << "--retry #{params[:retry]}" if params[:retry]
+          cmd << "--shebang" if params[:shebang]
+          cmd << "--standalone #{params[:standalone]}" if params[:standalone]
+          cmd << "--trust-policy" if params[:trust_policy]
+          cmd << "--without #{params[:without]}" if params[:without]
+          cmd << "--with #{params[:with]}" if params[:with]
+          cmd << "--frozen" if params[:frozen]
+          cmd << "--redownload" if params[:redownload]
+
+          return sh(cmd.join(' '))
+        else
+          UI.message("No Gemfile found")
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.gemfile_exists?(params)
+        possible_gemfiles = ['Gemfile', 'gemfile']
+        possible_gemfiles.insert(0, params[:gemfile]) if params[:gemfile]
+        possible_gemfiles.each do |gemfile|
+          gemfile = File.absolute_path(gemfile)
+          return true if File.exist?(gemfile)
+          UI.message("Gemfile not found at: '#{gemfile}'")
+        end
+        return false
+      end
+
+      def self.description
+        'This action runs `bundle install` (if available)'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.author
+        ["birmacher", "koglinjg"]
+      end
+
+      def self.example_code
+        nil
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :binstubs,
+                                       env_name: "FL_BUNDLE_INSTALL_BINSTUBS",
+                                       description: "Generate bin stubs for bundled gems to ./bin",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       env_name: "FL_BUNDLE_INSTALL_CLEAN",
+                                       description: "Run bundle clean automatically after install",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :full_index,
+                                       env_name: "FL_BUNDLE_INSTALL_FULL_INDEX",
+                                       description: "Use the rubygems modern index instead of the API endpoint",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :gemfile,
+                                       env_name: "FL_BUNDLE_INSTALL_GEMFILE",
+                                       description: "Use the specified gemfile instead of Gemfile",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :jobs,
+                                       env_name: "FL_BUNDLE_INSTALL_JOBS",
+                                       description: "Install gems using parallel workers",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :local,
+                                       env_name: "FL_BUNDLE_INSTALL_LOCAL",
+                                       description: "Do not attempt to fetch gems remotely and use the gem cache instead",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :deployment,
+                                       env_name: "FL_BUNDLE_INSTALL_DEPLOYMENT",
+                                       description: "Install using defaults tuned for deployment and CI environments",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :no_cache,
+                                       env_name: "FL_BUNDLE_INSTALL_NO_CACHE",
+                                       description: "Don't update the existing gem cache",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :no_prune,
+                                       env_name: "FL_BUNDLE_INSTALL_NO_PRUNE",
+                                       description: "Don't remove stale gems from the cache",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_BUNDLE_INSTALL_PATH",
+                                       description: "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :system,
+                                       env_name: "FL_BUNDLE_INSTALL_SYSTEM",
+                                       description: "Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: "FL_BUNDLE_INSTALL_QUIET",
+                                       description: "Only output warnings and errors",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :retry,
+                                       env_name: "FL_BUNDLE_INSTALL_RETRY",
+                                       description: "Retry network and git requests that have failed",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :shebang,
+                                       env_name: "FL_BUNDLE_INSTALL_SHEBANG",
+                                       description: "Specify a different shebang executable name than the default (usually 'ruby')",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :standalone,
+                                       env_name: "FL_BUNDLE_INSTALL_STANDALONE",
+                                       description: "Make a bundle that can work without the Bundler runtime",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :trust_policy,
+                                       env_name: "FL_BUNDLE_INSTALL_TRUST_POLICY",
+                                       description: "Sets level of security when dealing with signed gems. Accepts `LowSecurity`, `MediumSecurity` and `HighSecurity` as values",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :without,
+                                       env_name: "FL_BUNDLE_INSTALL_WITHOUT",
+                                       description: "Exclude gems that are part of the specified named group",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :with,
+                                       env_name: "FL_BUNDLE_INSTALL_WITH",
+                                       description: "Include gems that are part of the specified named group",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :frozen,
+                                       env_name: "FL_BUNDLE_INSTALL_FROZEN",
+                                       description: "Don't allow the Gemfile.lock to be updated after install",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :redownload,
+                                       env_name: "FL_BUNDLE_INSTALL_REDOWNLOAD",
+                                       description: "Force download every gem, even if the required versions are already available locally",
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/capture_android_screenshots.rb

@@ -0,0 +1,63 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SCREENGRAB_OUTPUT_DIRECTORY = :SCREENGRAB_OUTPUT_DIRECTORY
+    end
+
+    class CaptureAndroidScreenshotsAction < Action
+      def self.run(params)
+        require 'screengrab'
+
+        Screengrab.config = params
+        Screengrab.android_environment = Screengrab::AndroidEnvironment.new(params[:android_home],
+                                                                            params[:build_tools_version])
+        Screengrab::DependencyChecker.check(Screengrab.android_environment)
+        Screengrab::Runner.new.run
+
+        Actions.lane_context[SharedValues::SCREENGRAB_OUTPUT_DIRECTORY] = File.expand_path(params[:output_directory])
+
+        true
+      end
+
+      def self.description
+        'Automated localized screenshots of your Android app (via _screengrab_)'
+      end
+
+      def self.available_options
+        require 'screengrab'
+        Screengrab::Options.available_options
+      end
+
+      def self.output
+        [
+          ['SCREENGRAB_OUTPUT_DIRECTORY', 'The path to the output directory']
+        ]
+      end
+
+      def self.author
+        ['asfalcone', 'i2amsam', 'mfurtak']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        [
+          'capture_android_screenshots',
+          'screengrab # alias for "capture_android_screenshots"',
+          'capture_android_screenshots(
+            locales: ["en-US", "fr-FR", "ja-JP"],
+            clear_previous_screenshots: true,
+            app_apk_path: "build/outputs/apk/example-debug.apk",
+            tests_apk_path: "build/outputs/apk/example-debug-androidTest-unaligned.apk"
+          )'
+        ]
+      end
+
+      def self.category
+        :screenshots
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/capture_ios_screenshots.rb

@@ -0,0 +1,61 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SNAPSHOT_SCREENSHOTS_PATH = :SNAPSHOT_SCREENSHOTS_PATH
+    end
+
+    class CaptureIosScreenshotsAction < Action
+      def self.run(params)
+        return nil unless Helper.mac?
+        require 'snapshot'
+
+        Snapshot.config = params
+        Snapshot::DependencyChecker.check_simulators
+        Snapshot::Runner.new.work
+
+        Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] = File.expand_path(params[:output_directory]) # absolute URL
+
+        true
+      end
+
+      def self.description
+        "Generate new localized screenshots on multiple devices (via _snapshot_)"
+      end
+
+      def self.available_options
+        return [] unless Helper.mac?
+        require 'snapshot'
+        Snapshot::Options.available_options
+      end
+
+      def self.output
+        [
+          ['SNAPSHOT_SCREENSHOTS_PATH', 'The path to the screenshots']
+        ]
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'capture_ios_screenshots',
+          'snapshot # alias for "capture_ios_screenshots"',
+          'capture_ios_screenshots(
+            skip_open_summary: true,
+            clean: true
+          )'
+        ]
+      end
+
+      def self.category
+        :screenshots
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/capture_screenshots.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/capture_ios_screenshots'
+    class CaptureScreenshotsAction < CaptureIosScreenshotsAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `capture_ios_screenshots` action"
+      end
+    end
+  end
+end