fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/helper/dotenv_helper.rb

@@ -0,0 +1,50 @@
+module Fastlane
+  module Helper
+    class DotenvHelper
+      # @param env_cl_param [String] an optional list of dotenv environment names separated by commas, without space
+      def self.load_dot_env(env_cl_param)
+        base_path = find_dotenv_directory
+
+        return unless base_path
+
+        load_dot_envs_from(env_cl_param, base_path)
+      end
+
+      # finds the first directory of [fastlane, its parent] containing dotenv files
+      def self.find_dotenv_directory
+        path = FastlaneCore::FastlaneFolder.path
+        search_paths = [path]
+        search_paths << path + "/.." unless path.nil?
+        search_paths.compact!
+        search_paths.find do |dir|
+          Dir.glob(File.join(dir, '*.env*'), File::FNM_DOTMATCH).count > 0
+        end
+      end
+
+      # loads the dotenvs. First the .env and .env.default and
+      # then override with all speficied extra environments
+      def self.load_dot_envs_from(env_cl_param, base_path)
+        require 'dotenv'
+
+        # Making sure the default '.env' and '.env.default' get loaded
+        env_file = File.join(base_path, '.env')
+        env_default_file = File.join(base_path, '.env.default')
+        Dotenv.load(env_file, env_default_file)
+
+        return unless env_cl_param
+
+        Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::ENVIRONMENT] = env_cl_param
+
+        # multiple envs?
+        envs = env_cl_param.split(",")
+
+        # Loads .env file for the environment(s) passed in through options
+        envs.each do |env|
+          env_file = File.join(base_path, ".env.#{env}")
+          UI.success("Loading from '#{env_file}'")
+          Dotenv.overload(env_file)
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/gem_helper.rb

@@ -0,0 +1,26 @@
+module Fastlane
+  module Actions
+    # will make sure a gem is installed. If it's not an appropriate error message is shown
+    # this will *not* 'require' the gem
+    def self.verify_gem!(gem_name)
+      begin
+        FastlaneRequire.install_gem_if_needed(gem_name: gem_name, require_gem: false)
+        # We don't import this by default, as it's not always the same
+        # also e.g. cocoapods is just required and not imported
+      rescue Gem::LoadError
+        UI.error("Could not find gem '#{gem_name}'")
+        UI.error("")
+        UI.error("If you installed fastlane using `gem install fastlane` run")
+        UI.command("gem install #{gem_name}")
+        UI.error("to install the missing gem")
+        UI.error("")
+        UI.error("If you use a Gemfile add this to your Gemfile:")
+        UI.important("  gem '#{gem_name}'")
+        UI.error("and run `bundle install`")
+
+        UI.user_error!("You have to install the `#{gem_name}` gem on this machine") unless Helper.test?
+      end
+      true
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/git_helper.rb

@@ -0,0 +1,166 @@
+module Fastlane
+  module Actions
+    GIT_MERGE_COMMIT_FILTERING_OPTIONS = [:include_merges, :exclude_merges, :only_include_merges].freeze
+
+    module SharedValues
+      GIT_BRANCH_ENV_VARS = %w(GIT_BRANCH BRANCH_NAME TRAVIS_BRANCH BITRISE_GIT_BRANCH CI_BUILD_REF_NAME CI_COMMIT_REF_NAME WERCKER_GIT_BRANCH BUILDKITE_BRANCH APPCENTER_BRANCH CIRCLE_BRANCH).reject do |branch|
+        # Removing because tests break on CircleCI
+        Helper.test? && branch == "CIRCLE_BRANCH"
+      end.freeze
+    end
+
+    def self.git_log_between(pretty_format, from, to, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << "#{from}...#{to}"
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      # "*command" syntax expands "command" array into variable arguments, which
+      # will then be individually shell-escaped by Actions.sh.
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.git_log_last_commits(pretty_format, commit_count, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << '-n' << commit_count.to_s
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_hash(tag_match_pattern = nil)
+      tag_pattern_param = tag_match_pattern ? "=#{tag_match_pattern}" : ''
+      Actions.sh('git', 'rev-list', "--tags#{tag_pattern_param}", '--max-count=1').chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_name(match_lightweight = true, tag_match_pattern = nil)
+      hash = last_git_tag_hash(tag_match_pattern)
+      # If hash is nil (command fails), "git describe" command below will still
+      # run and provide some output, although it's definitely not going to be
+      # anything reasonably expected. Bail out early.
+      return unless hash
+
+      command = %w(git describe)
+      command << '--tags' if match_lightweight
+      command << hash
+      command << '--match' if tag_match_pattern
+      command << tag_match_pattern if tag_match_pattern
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_commit_dict
+      return nil if last_git_commit_formatted_with('%an').nil?
+
+      {
+          author: last_git_commit_formatted_with('%an'),
+          author_email: last_git_commit_formatted_with('%ae'),
+          message: last_git_commit_formatted_with('%B'),
+          commit_hash: last_git_commit_formatted_with('%H'),
+          abbreviated_commit_hash: last_git_commit_formatted_with('%h')
+      }
+    end
+
+    # Gets the last git commit information formatted into a String by the provided
+    # pretty format String. See the git-log documentation for valid format placeholders
+    def self.last_git_commit_formatted_with(pretty_format, date_format = nil)
+      command = %w(git log -1)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    # @deprecated Use <tt>git_author_email</tt> instead
+    # Get the author email of the last git commit
+    # <b>DEPRECATED:</b> Use <tt>git_author_email</tt> instead.
+    def self.git_author
+      UI.deprecated('`git_author` is deprecated. Please use `git_author_email` instead.')
+      git_author_email
+    end
+
+    # Get the author email of the last git commit
+    def self.git_author_email
+      s = last_git_commit_formatted_with('%ae')
+      return s if s.to_s.length > 0
+      return nil
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    # <b>DEPRECATED:</b> Use <tt>last_git_commit_message</tt> instead.
+    def self.last_git_commit
+      UI.important('`last_git_commit` is deprecated. Please use `last_git_commit_message` instead.')
+      last_git_commit_message
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    def self.last_git_commit_message
+      s = (last_git_commit_formatted_with('%B') || "").strip
+      return s if s.to_s.length > 0
+      nil
+    end
+
+    # Get the hash of the last commit
+    def self.last_git_commit_hash(short)
+      format_specifier = short ? '%h' : '%H'
+      string = last_git_commit_formatted_with(format_specifier).to_s
+      return string unless string.empty?
+      return nil
+    end
+
+    # Returns the current git branch, or "HEAD" if it's not checked out to any branch
+    # Can be replaced using the environment variable `GIT_BRANCH`
+    def self.git_branch
+      env_name = SharedValues::GIT_BRANCH_ENV_VARS.find { |env_var| FastlaneCore::Env.truthy?(env_var) }
+      ENV.fetch(env_name.to_s) do
+        self.git_branch_name_using_HEAD
+      end
+    end
+
+    # Returns the checked out git branch name or "HEAD" if you're in detached HEAD state
+    def self.git_branch_name_using_HEAD
+      # Rescues if not a git repo or no commits in a git repo
+      Actions.sh("git rev-parse --abbrev-ref HEAD", log: false).chomp
+    rescue => err
+      UI.verbose("Error getting git branch: #{err.message}")
+      nil
+    end
+
+    # Returns the default git remote branch name
+    def self.git_remote_branch_name(remote_name)
+      # Rescues if not a git repo or no remote repo
+      if remote_name
+        Actions.sh("git remote show #{remote_name} | grep 'HEAD branch' | sed 's/.*: //'", log: false).chomp
+      else
+        # Query git for the current remote head
+        Actions.sh("variable=$(git remote) && git remote show $variable | grep 'HEAD branch' | sed 's/.*: //'", log: false).chomp
+      end
+    rescue => err
+      UI.verbose("Error getting git default remote branch: #{err.message}")
+      nil
+    end
+
+    private_class_method
+    def self.git_log_merge_commit_filtering_option(merge_commit_filtering)
+      case merge_commit_filtering
+      when :exclude_merges
+        "--no-merges"
+      when :only_include_merges
+        "--merges"
+      when :include_merges
+        nil
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/gradle_helper.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  module Helper
+    class GradleTask
+      attr_accessor :title
+
+      attr_accessor :description
+
+      def initialize(title: nil, description: nil)
+        self.title = title
+        self.description = description
+      end
+    end
+
+    class GradleHelper
+      # Path to the gradle script
+      attr_accessor :gradle_path
+
+      # Read-only path to the shell-escaped gradle script, suitable for use in shell commands
+      attr_reader :escaped_gradle_path
+
+      # All the available tasks
+      attr_accessor :tasks
+
+      def initialize(gradle_path: nil)
+        self.gradle_path = gradle_path
+      end
+
+      # Run a certain action
+      def trigger(task: nil, flags: nil, serial: nil, print_command: true, print_command_output: true)
+        android_serial = (serial != "") ? "ANDROID_SERIAL=#{serial}" : nil
+        command = [android_serial, escaped_gradle_path, task, flags].compact.join(" ")
+        Action.sh(command, print_command: print_command, print_command_output: print_command_output)
+      end
+
+      def task_available?(task)
+        load_all_tasks
+        return tasks.collect(&:title).include?(task)
+      end
+
+      def gradle_path=(gradle_path)
+        @gradle_path = gradle_path
+        @escaped_gradle_path = gradle_path.shellescape
+      end
+
+      private
+
+      def load_all_tasks
+        self.tasks = []
+
+        command = [escaped_gradle_path, "tasks", "--console=plain"].join(" ")
+        output = Action.sh(command, print_command: false, print_command_output: false)
+        output.split("\n").each do |line|
+          if (result = line.match(/(\w+)\s\-\s([\w\s]+)/))
+            self.tasks << GradleTask.new(title: result[1], description: result[2])
+          end
+        end
+
+        self.tasks
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/lane_helper.rb

@@ -0,0 +1,13 @@
+module Fastlane
+  module Helper
+    class LaneHelper
+      def self.current_platform
+        return Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::PLATFORM_NAME]
+      end
+
+      def self.current_lane
+        return Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::LANE_NAME]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/podspec_helper.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Helper
+    class PodspecHelper
+      attr_accessor :path
+      attr_accessor :podspec_content
+      attr_accessor :version_regex
+      attr_accessor :version_match
+      attr_accessor :version_value
+
+      def initialize(path = nil, require_variable_prefix = true)
+        version_var_name = 'version'
+        variable_prefix = require_variable_prefix ? /\w\./ : //
+        @version_regex = /^(?<begin>[^#]*#{variable_prefix}#{version_var_name}\s*=\s*['"])(?<value>(?<major>[0-9]+)(\.(?<minor>[0-9]+))?(\.(?<patch>[0-9]+))?(?<appendix>(\.[0-9]+)*)?(-(?<prerelease>(.+)))?)(?<end>['"])/i
+
+        return unless (path || '').length > 0
+        UI.user_error!("Could not find podspec file at path '#{path}'") unless File.exist?(path)
+
+        @path = File.expand_path(path)
+        podspec_content = File.read(path)
+
+        parse(podspec_content)
+      end
+
+      def parse(podspec_content)
+        @podspec_content = podspec_content
+        @version_match = @version_regex.match(@podspec_content)
+        UI.user_error!("Could not find version in podspec content '#{@podspec_content}'") if @version_match.nil?
+        @version_value = @version_match[:value]
+      end
+
+      def bump_version(bump_type)
+        UI.user_error!("Do not support bump of 'appendix', please use `update_version_appendix(appendix)` instead") if bump_type == 'appendix'
+
+        major = version_match[:major].to_i
+        minor = version_match[:minor].to_i || 0
+        patch = version_match[:patch].to_i || 0
+
+        case bump_type
+        when 'patch'
+          patch += 1
+        when 'minor'
+          minor += 1
+          patch = 0
+        when 'major'
+          major += 1
+          minor = 0
+          patch = 0
+        end
+
+        @version_value = "#{major}.#{minor}.#{patch}"
+      end
+
+      def update_version_appendix(appendix = nil)
+        new_appendix = appendix || @version_value[:appendix]
+        return if new_appendix.nil?
+
+        new_appendix = new_appendix.sub(".", "") if new_appendix.start_with?(".")
+        major = version_match[:major].to_i
+        minor = version_match[:minor].to_i || 0
+        patch = version_match[:patch].to_i || 0
+
+        @version_value = "#{major}.#{minor}.#{patch}.#{new_appendix}"
+      end
+
+      def update_podspec(version = nil)
+        new_version = version || @version_value
+        updated_podspec_content = @podspec_content.gsub(@version_regex, "#{@version_match[:begin]}#{new_version}#{@version_match[:end]}")
+
+        File.open(@path, "w") { |file| file.puts(updated_podspec_content) } unless Helper.test?
+
+        updated_podspec_content
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/s3_client_helper.rb

@@ -0,0 +1,78 @@
+require 'aws-sdk-s3'
+
+module Fastlane
+  module Helper
+    class S3ClientHelper
+      attr_reader :access_key
+      attr_reader :region
+
+      def initialize(access_key: nil, secret_access_key: nil, region: nil, s3_client: nil)
+        @access_key = access_key
+        @secret_access_key = secret_access_key
+        @region = region
+
+        @client = s3_client
+      end
+
+      def list_buckets
+        return client.list_buckets
+      end
+
+      def upload_file(bucket_name, file_name, file_data, acl)
+        bucket = find_bucket!(bucket_name)
+        details = {
+          acl: acl,
+          key: file_name,
+          body: file_data
+        }
+        obj = bucket.put_object(details)
+
+        # When you enable versioning on a S3 bucket,
+        # writing to an object will create an object version
+        # instead of replacing the existing object.
+        # http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/S3/ObjectVersion.html
+        if obj.kind_of?(Aws::S3::ObjectVersion)
+          obj = obj.object
+        end
+
+        # Return public url
+        obj.public_url.to_s
+      end
+
+      def delete_file(bucket_name, file_name)
+        bucket = find_bucket!(bucket_name)
+        file = bucket.object(file_name)
+        file.delete
+      end
+
+      def find_bucket!(bucket_name)
+        bucket = Aws::S3::Bucket.new(bucket_name, client: client)
+        raise "Bucket '#{bucket_name}' not found" unless bucket.exists?
+
+        return bucket
+      end
+
+      private
+
+      attr_reader :secret_access_key
+
+      def client
+        @client ||= Aws::S3::Client.new(
+          {
+            region: region,
+            credentials: create_credentials
+          }.compact
+        )
+      end
+
+      def create_credentials
+        return nil if access_key.to_s.empty? || secret_access_key.to_s.empty?
+
+        Aws::Credentials.new(
+          access_key,
+          secret_access_key
+        )
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/sh_helper.rb

@@ -0,0 +1,134 @@
+require "open3"
+
+module Fastlane
+  module Actions
+    # Execute a shell command
+    # This method will output the string and execute it
+    # Just an alias for sh_no_action
+    # When running this in tests, it will return the actual command instead of executing it
+    # @param log [Boolean] should fastlane print out the executed command
+    # @param error_callback [Block] a callback invoked with the command output if there is a non-zero exit status
+    def self.sh(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    def self.sh_no_action(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    # @param command The command to be executed (variadic)
+    # @param print_command [Boolean] Should we print the command that's being executed
+    # @param print_command_output [Boolean] Should we print the command output during execution
+    # @param error_callback [Block] A block that's called if the command exits with a non-zero status
+    # @yield [status, result, cmd] The return status of the command, all output from the command and an equivalent shell command
+    # @yieldparam [Process::Status] status A Process::Status indicating the status of the completed command
+    # @yieldparam [String] result The complete output to stdout and stderr of the completed command
+    # @yieldparam [String] cmd A shell command equivalent to the arguments passed
+    # rubocop: disable Metrics/PerceivedComplexity
+    def self.sh_control_output(*command, print_command: true, print_command_output: true, error_callback: nil)
+      print_command = print_command_output = true if $troubleshoot
+      # Set the encoding first, the user might have set it wrong
+      previous_encoding = [Encoding.default_external, Encoding.default_internal]
+      Encoding.default_external = Encoding::UTF_8
+      Encoding.default_internal = Encoding::UTF_8
+
+      # Workaround to support previous Fastlane syntax.
+      # This has some limitations. For example, it requires the caller to shell escape
+      # everything because of usages like ["ls -la", "/tmp"] instead of ["ls", "-la", "/tmp"].
+      command = [command.first.join(" ")] if command.length == 1 && command.first.kind_of?(Array)
+
+      shell_command = shell_command_from_args(*command)
+      UI.command(shell_command) if print_command
+
+      result = ''
+      exit_status = nil
+      if Helper.sh_enabled?
+        # The argument list is passed directly to Open3.popen2e, which
+        # handles the variadic argument list in the same way as Kernel#spawn.
+        # (http://ruby-doc.org/core-2.4.2/Kernel.html#method-i-spawn) or
+        # Process.spawn (http://ruby-doc.org/core-2.4.2/Process.html#method-c-spawn).
+        #
+        # sh "ls -la /Applications/Xcode\ 7.3.1.app"
+        # sh "ls", "-la", "/Applications/Xcode 7.3.1.app"
+        # sh({ "FOO" => "Hello" }, "echo $FOO")
+        Open3.popen2e(*command) do |stdin, io, thread|
+          io.sync = true
+          io.each do |line|
+            UI.command_output(line.strip) if print_command_output
+            result << line
+          end
+          exit_status = thread.value
+        end
+
+        # Checking Process::Status#exitstatus instead of #success? makes for more
+        # testable code. (Tests mock exitstatus only.) This is also consistent
+        # with previous implementations of sh and... probably portable to all
+        # relevant platforms.
+        if exit_status.exitstatus != 0
+          message = if print_command
+                      "Exit status of command '#{shell_command}' was #{exit_status.exitstatus} instead of 0."
+                    else
+                      "Shell command exited with exit status #{exit_status.exitstatus} instead of 0."
+                    end
+          message += "\n#{result}" if print_command_output
+
+          if error_callback || block_given?
+            UI.error(message)
+            # block notified below, on success or failure
+            error_callback && error_callback.call(result)
+          else
+            UI.shell_error!(message)
+          end
+        end
+      else
+        result << shell_command # only for the tests
+      end
+
+      if block_given?
+        # Avoid yielding nil in tests. $? will be meaningless, but calls to
+        # it will not crash. There is no Process::Status.new. The alternative
+        # is to move this inside the sh_enabled? check and not yield in tests.
+        return yield(exit_status || $?, result, shell_command)
+      end
+      result
+    rescue => ex
+      raise ex
+    ensure
+      Encoding.default_external = previous_encoding.first
+      Encoding.default_internal = previous_encoding.last
+    end
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    # Used to produce a shell command string from a list of arguments that may
+    # be passed to methods such as Kernel#system, Kernel#spawn and Open3.popen2e
+    # in order to print the command to the terminal. The same *args are passed
+    # directly to a system call (Open3.popen2e). This interpretation is not
+    # used when executing a command.
+    #
+    # @param args Any number of arguments used to construct a command
+    # @raise [ArgumentError] If no arguments passed
+    # @return [String] A shell command representing the arguments passed in
+    def self.shell_command_from_args(*args)
+      raise ArgumentError, "sh requires at least one argument" unless args.count > 0
+
+      command = ""
+
+      # Optional initial environment Hash
+      if args.first.kind_of?(Hash)
+        command = args.shift.map { |k, v| "#{k}=#{v.shellescape}" }.join(" ") + " "
+      end
+
+      # Support [ "/usr/local/bin/foo", "foo" ], "-x", ...
+      if args.first.kind_of?(Array)
+        command += args.shift.first.shellescape + " " + args.shelljoin
+        command.chomp!(" ")
+      elsif args.count == 1 && args.first.kind_of?(String)
+        command += args.first
+      else
+        command += args.shelljoin
+      end
+
+      command
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcodebuild_formatter_helper.rb

@@ -0,0 +1,9 @@
+module Fastlane
+  module Helper
+    class XcodebuildFormatterHelper
+      def self.xcbeautify_installed?
+        return `which xcbeautify`.include?("xcbeautify")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcodeproj_helper.rb

@@ -0,0 +1,12 @@
+module Fastlane
+  module Helper
+    class XcodeprojHelper
+      DEPENDENCY_MANAGER_DIRS = ['Pods', 'Carthage'].freeze
+
+      def self.find(dir)
+        xcodeproj_paths = Dir[File.expand_path(File.join(dir, '**/*.xcodeproj'))]
+        xcodeproj_paths.reject { |path| %r{/(#{DEPENDENCY_MANAGER_DIRS.join('|')})/.*.xcodeproj} =~ path }
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcodes_helper.rb

@@ -0,0 +1,28 @@
+module Fastlane
+  module Helper
+    class XcodesHelper
+      def self.read_xcode_version_file
+        xcode_version_paths = Dir.glob(".xcode-version")
+
+        if xcode_version_paths.first
+          return File.read(xcode_version_paths.first).strip
+        end
+
+        return nil
+      end
+
+      def self.find_xcodes_binary_path
+        `which xcodes`.strip
+      end
+
+      module Verify
+        def self.requirement(req)
+          UI.user_error!("Version must be specified") if req.nil? || req.to_s.strip.size == 0
+          Gem::Requirement.new(req.to_s)
+        rescue Gem::Requirement::BadRequirementError
+          UI.user_error!("The requirement '#{req}' is not a valid RubyGems style requirement")
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcversion_helper.rb

@@ -0,0 +1,16 @@
+module Fastlane
+  module Helper
+    class XcversionHelper
+      def self.find_xcode(req)
+        req = Gem::Requirement.new(req.to_s)
+
+        require 'xcode/install'
+        installer = XcodeInstall::Installer.new
+        installed = installer.installed_versions.reverse
+        installed.detect do |xcode|
+          req.satisfied_by?(Gem::Version.new(xcode.version))
+        end
+      end
+    end
+  end
+end