fastlane_pricing_fix 2.212.1

data/fastlane_core/lib/fastlane_core/fastlane_folder.rb

@@ -0,0 +1,72 @@
+require_relative 'ui/ui'
+
+module FastlaneCore
+  class FastlaneFolder
+    FOLDER_NAME = 'fastlane'
+
+    # Path to the fastlane folder containing the Fastfile and other configuration files
+    def self.path
+      value ||= "./#{FOLDER_NAME}/" if File.directory?("./#{FOLDER_NAME}/")
+      value ||= "./.#{FOLDER_NAME}/" if File.directory?("./.#{FOLDER_NAME}/") # hidden folder
+      value ||= "./" if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile.swift') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile.swift') # inside the folder and hidden
+      value ||= "./" if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile') # inside the folder and hidden
+      return value
+    end
+
+    # path to the Swift runner executable if it has been built
+    def self.swift_runner_path
+      return File.join(self.path, 'FastlaneRunner')
+    end
+
+    def self.swift?
+      return false unless self.fastfile_path
+      return self.fastfile_path.downcase.end_with?(".swift")
+    end
+
+    def self.swift_folder_path
+      return File.join(self.path, 'swift')
+    end
+
+    def self.swift_runner_project_path
+      return File.join(self.swift_folder_path, 'FastlaneSwiftRunner', 'FastlaneSwiftRunner.xcodeproj')
+    end
+
+    def self.swift_runner_built?
+      swift_runner_path = self.swift_runner_path
+      if swift_runner_path.nil?
+        return false
+      end
+
+      return File.exist?(swift_runner_path)
+    end
+
+    # Path to the Fastfile inside the fastlane folder. This is nil when none is available
+    def self.fastfile_path
+      return nil if self.path.nil?
+
+      # Check for Swift first, because Swift is #1
+      path = File.join(self.path, 'Fastfile.swift')
+      return path if File.exist?(path)
+
+      path = File.join(self.path, 'Fastfile')
+      return path if File.exist?(path)
+      return nil
+    end
+
+    # Does a fastlane configuration already exist?
+    def self.setup?
+      return false unless self.fastfile_path
+      File.exist?(self.fastfile_path)
+    end
+
+    def self.create_folder!(path = nil)
+      path = File.join(path || '.', FOLDER_NAME)
+      return if File.directory?(path) # directory is already there
+      UI.user_error!("Found a file called 'fastlane' at path '#{path}', please delete it") if File.exist?(path)
+      FileUtils.mkdir_p(path)
+      UI.success("Created new folder '#{path}'.")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/fastlane_pty.rb

@@ -0,0 +1,57 @@
+# Source: Mix of https://github.com/fastlane/fastlane/pull/7202/files,
+# https://github.com/fastlane/fastlane/pull/11384#issuecomment-356084518 and
+# https://github.com/DragonBox/u3d/blob/59e471ad78ac00cb629f479dbe386c5ad2dc5075/lib/u3d_core/command_runner.rb#L88-L96
+
+class StandardError
+  def exit_status
+    return -1
+  end
+end
+
+module FastlaneCore
+  class FastlanePtyError < StandardError
+    attr_reader :exit_status
+    def initialize(e, exit_status)
+      super(e)
+      set_backtrace(e.backtrace) if e
+      @exit_status = exit_status
+    end
+  end
+
+  class FastlanePty
+    def self.spawn(command)
+      require 'pty'
+      PTY.spawn(command) do |command_stdout, command_stdin, pid|
+        begin
+          yield(command_stdout, command_stdin, pid)
+        rescue Errno::EIO
+          # Exception ignored intentionally.
+          # https://stackoverflow.com/questions/10238298/ruby-on-linux-pty-goes-away-without-eof-raises-errnoeio
+          # This is expected on some linux systems, that indicates that the subcommand finished
+          # and we kept trying to read, ignore it
+        ensure
+          begin
+            Process.wait(pid)
+          rescue Errno::ECHILD, PTY::ChildExited
+            # The process might have exited.
+          end
+        end
+      end
+      $?.exitstatus
+    rescue LoadError
+      require 'open3'
+      Open3.popen2e(command) do |command_stdin, command_stdout, p| # note the inversion
+        yield(command_stdout, command_stdin, p.value.pid)
+
+        command_stdin.close
+        command_stdout.close
+        p.value.exitstatus
+      end
+    rescue StandardError => e
+      # Wrapping any error in FastlanePtyError to allow
+      # callers to see and use $?.exitstatus that
+      # would usually get returned
+      raise FastlanePtyError.new(e, $?.exitstatus)
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/feature/feature.rb

@@ -0,0 +1,51 @@
+require_relative '../env'
+
+module FastlaneCore
+  class Feature
+    class << self
+      attr_reader :features
+
+      def register(env_var: nil, description: nil)
+        feature = self.new(description: description, env_var: env_var)
+        @features[feature.env_var] = feature
+      end
+
+      def enabled?(env_var)
+        feature = @features[env_var]
+        return false if feature.nil?
+        return FastlaneCore::Env.truthy?(feature.env_var)
+      end
+
+      def register_class_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.define_singleton_method(symbol) do |*args|
+          if Feature.enabled?(env_var)
+            klass.send(enabled_symbol, *args)
+          else
+            klass.send(disabled_symbol, *args)
+          end
+        end
+      end
+
+      def register_instance_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.send(:define_method, symbol.to_s) do |*args|
+          if Feature.enabled?(env_var)
+            send(enabled_symbol, *args)
+          else
+            send(disabled_symbol, *args)
+          end
+        end
+      end
+    end
+
+    @features = {}
+
+    attr_reader :env_var, :description
+    def initialize(env_var: nil, description: nil)
+      raise "Invalid Feature" if env_var.nil? || description.nil?
+      @env_var = env_var
+      @description = description
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/features.rb

@@ -0,0 +1,4 @@
+require_relative 'feature/feature'
+
+FastlaneCore::Feature.register(env_var: 'FASTLANE_ITUNES_TRANSPORTER_USE_SHELL_SCRIPT',
+                           description: 'Use iTunes Transporter shell script')

data/fastlane_core/lib/fastlane_core/globals.rb

@@ -0,0 +1,27 @@
+module FastlaneCore
+  class Globals
+    def self.captured_output
+      @captured_output ||= ""
+    end
+
+    class << self
+      attr_writer(:captured_output)
+      attr_writer(:capture_output)
+      attr_writer(:verbose)
+    end
+
+    def self.capture_output?
+      return nil unless @capture_output
+      return true
+    end
+
+    def self.captured_output?
+      @capture_output && @captured_output.to_s.length > 0
+    end
+
+    def self.verbose?
+      return nil unless @verbose
+      return true
+    end
+  end
+end