pantograph 0.1.0

data/pantograph_core/lib/pantograph_core/helper.rb

@@ -0,0 +1,409 @@
+require 'logger'
+require 'colored'
+require 'tty-spinner'
+require 'pathname'
+
+require_relative 'pantograph_folder'
+require_relative 'ui/ui'
+require_relative 'env'
+
+module PantographCore
+  module Helper
+    # pantograph
+    #
+
+    def self.pantograph_enabled?
+      # This is called from the root context on the first start
+      @enabled ||= !PantographCore::PantographFolder.path.nil?
+    end
+
+    # Checks if pantograph is enabled for this project and returns the folder where the configuration lives
+    def self.pantograph_enabled_folder_path
+      pantograph_enabled? ? PantographCore::PantographFolder.path : '.'
+    end
+
+    # pantograph installation method
+    #
+
+    # @return [boolean] true if executing with bundler (like 'bundle exec pantograph [action]')
+    def self.bundler?
+      # Bundler environment variable
+      ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    # Do we run from a bundled pantograph, which contains Ruby and OpenSSL?
+    # Usually this means the pantograph directory is ~/.pantograph/bin/
+    # We set this value via the environment variable `PANTOGRAPH_SELF_CONTAINED`
+    def self.contained_pantograph?
+      ENV["PANTOGRAPH_SELF_CONTAINED"].to_s == "true" && !self.homebrew?
+    end
+
+    # returns true if pantograph was installed via Homebrew
+    def self.homebrew?
+      ENV["PANTOGRAPH_INSTALLED_VIA_HOMEBREW"].to_s == "true"
+    end
+
+    # returns true if pantograph was installed via RubyGems
+    def self.rubygems?
+      !self.bundler? && !self.contained_pantograph? && !self.homebrew?
+    end
+
+    # environment
+    #
+
+    # @return true if the currently running program is a unit test
+    def self.test?
+      Object.const_defined?("SpecHelper")
+    end
+
+    # @return true if it is enabled to execute external commands
+    def self.sh_enabled?
+      !self.test?
+    end
+
+    # @return [boolean] true if building in a known CI environment
+    def self.ci?
+      # Check for Jenkins, Travis CI, ... environment variables
+      ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'CI', 'APPCENTER_BUILD_ID', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS', 'TF_BUILD', 'GITHUB_ACTION', 'GITHUB_ACTIONS'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    def self.operating_system
+      return "macOS" if RUBY_PLATFORM.downcase.include?("darwin")
+      return "Windows" if RUBY_PLATFORM.downcase.include?("mswin")
+      return "Linux" if RUBY_PLATFORM.downcase.include?("linux")
+      return "Unknown"
+    end
+
+    def self.windows?
+      # taken from: https://stackoverflow.com/a/171011/1945875
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def self.linux?
+      (/linux/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Is the currently running computer a Mac?
+    def self.mac?
+      (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Do we want to disable the colored output?
+    def self.colors_disabled?
+      PantographCore::Env.truthy?("PANTOGRAPH_DISABLE_COLORS")
+    end
+
+    # Does the user use the Mac stock terminal
+    def self.mac_stock_terminal?
+      PantographCore::Env.truthy?("TERM_PROGRAM_VERSION")
+    end
+
+    # Logs base directory
+    def self.buildlog_path
+      return ENV["FL_BUILDLOG_PATH"] || "~/Library/Logs"
+    end
+
+    # Xcode
+    #
+
+    # @return the full path to the Xcode developer tools of the currently
+    #  running system
+    def self.xcode_path
+      return "" unless self.mac?
+
+      if self.xcode_server?
+        # Xcode server always creates a link here
+        xcode_server_xcode_path = "/Library/Developer/XcodeServer/CurrentXcodeSymlink/Contents/Developer"
+        UI.verbose("We're running as XcodeServer, setting path to #{xcode_server_xcode_path}")
+        return xcode_server_xcode_path
+      end
+
+      return `xcode-select -p`.delete("\n") + "/"
+    end
+
+    def self.xcode_server?
+      # XCS is set by Xcode Server
+      return ENV["XCS"].to_i == 1
+    end
+
+    # @return The version of the currently used Xcode installation (e.g. "7.0")
+    def self.xcode_version
+      return nil unless self.mac?
+      return @xcode_version if @xcode_version && @developer_dir == ENV['DEVELOPER_DIR']
+
+      xcodebuild_path = "#{xcode_path}/usr/bin/xcodebuild"
+
+      xcode_build_installed = File.exist?(xcodebuild_path)
+      unless xcode_build_installed
+        UI.verbose("Couldn't find xcodebuild at #{xcodebuild_path}, check that it exists")
+        return nil
+      end
+
+      begin
+        output = `DEVELOPER_DIR='' "#{xcodebuild_path}" -version`
+        @xcode_version = output.split("\n").first.split(' ')[1]
+        @developer_dir = ENV['DEVELOPER_DIR']
+      rescue => ex
+        UI.error(ex)
+        UI.user_error!("Error detecting currently used Xcode installation, please ensure that you have Xcode installed and set it using `sudo xcode-select -s [path]`")
+      end
+      @xcode_version
+    end
+
+    # @return true if Xcode version is higher than 8.3
+    def self.xcode_at_least?(version)
+      PantographCore::UI.user_error!("Unable to locate Xcode. Please make sure to have Xcode installed on your machine") if xcode_version.nil?
+      v = xcode_version
+      Gem::Version.new(v) >= Gem::Version.new(version)
+    end
+
+    # iTMSTransporter
+    #
+
+    def self.transporter_java_executable_path
+      return File.join(self.transporter_java_path, 'bin', 'java')
+    end
+
+    def self.transporter_java_ext_dir
+      return File.join(self.transporter_java_path, 'lib', 'ext')
+    end
+
+    def self.transporter_java_jar_path
+      return File.join(self.itms_path, 'lib', 'itmstransporter-launcher.jar')
+    end
+
+    def self.transporter_user_dir
+      return File.join(self.itms_path, 'bin')
+    end
+
+    def self.transporter_java_path
+      return File.join(self.itms_path, 'java')
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.transporter_path
+      return File.join(self.itms_path, 'bin', 'iTMSTransporter') unless Helper.windows?
+      return File.join(self.itms_path, 'iTMSTransporter')
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.itms_path
+      return ENV["PANTOGRAPH_ITUNES_TRANSPORTER_PATH"] if PantographCore::Env.truthy?("PANTOGRAPH_ITUNES_TRANSPORTER_PATH")
+
+      if self.mac?
+        # First check for manually install iTMSTransporter
+        user_local_itms_path = "/usr/local/itms"
+        return user_local_itms_path if File.exist?(user_local_itms_path)
+
+        # Then check for iTMSTransporter in the Xcode path
+        [
+          "../Applications/Application Loader.app/Contents/MacOS/itms",
+          "../Applications/Application Loader.app/Contents/itms",
+          "../SharedFrameworks/ContentDeliveryServices.framework/Versions/A/itms" # For Xcode 11
+        ].each do |path|
+          result = File.expand_path(File.join(self.xcode_path, path))
+          return result if File.exist?(result)
+        end
+        UI.user_error!("Could not find transporter at #{self.xcode_path}. Please make sure you set the correct path to your Xcode installation.")
+      elsif self.windows?
+        [
+          "C:/Program Files (x86)/itms"
+        ].each do |path|
+          return path if File.exist?(path)
+        end
+        UI.user_error!("Could not find transporter at usual locations. Please use environment variable `PANTOGRAPH_ITUNES_TRANSPORTER_PATH` to specify your installation path.")
+      else
+        # not Mac or Windows
+        return ''
+      end
+    end
+
+    # keychain
+    #
+
+    def self.keychain_path(keychain_name)
+      # Existing code expects that a keychain name will be expanded into a default path to Library/Keychains
+      # in the user's home directory. However, this will not allow the user to pass an absolute path
+      # for the keychain value
+      #
+      # So, if the passed value can't be resolved as a file in Library/Keychains, just use it as-is
+      # as the keychain path.
+      #
+      # We need to expand each path because File.exist? won't handle directories including ~ properly
+      #
+      # We also try to append `-db` at the end of the file path, as with Sierra the default Keychain name
+      # has changed for some users: https://github.com/pantograph/pantograph/issues/5649
+
+      # Remove the ".keychain" at the end of the keychain name
+      name = keychain_name.sub(/\.keychain$/, "")
+
+      possible_locations = [
+        File.join(Dir.home, 'Library', 'Keychains', name),
+        name
+      ].map { |path| File.expand_path(path) }
+
+      # Transforms ["thing"] to ["thing-db", "thing.keychain-db", "thing", "thing.keychain"]
+      keychain_paths = []
+      possible_locations.each do |location|
+        keychain_paths << "#{location}-db"
+        keychain_paths << "#{location}.keychain-db"
+        keychain_paths << location
+        keychain_paths << "#{location}.keychain"
+      end
+
+      keychain_path = keychain_paths.find { |path| File.file?(path) }
+      UI.user_error!("Could not locate the provided keychain. Tried:\n\t#{keychain_paths.join("\n\t")}") unless keychain_path
+      keychain_path
+    end
+
+    # helper methods
+    #
+
+    # Runs a given command using backticks (`)
+    # and prints them out using the UI.command method
+    def self.backticks(command, print: true)
+      UI.command(command) if print
+      result = `#{command}`
+      UI.command_output(result) if print
+      return result
+    end
+
+    # removes ANSI colors from string
+    def self.strip_ansi_colors(str)
+      str.gsub(/\e\[([;\d]+)?m/, '')
+    end
+
+    # Zips directory
+    def self.zip_directory(path, output_path, contents_only: false, overwrite: false, print: true)
+      if overwrite
+        overwrite_command = " && rm -f '#{output_path}'"
+      else
+        overwrite_command = ""
+      end
+
+      if contents_only
+        command = "cd '#{path}'#{overwrite_command} && zip -r '#{output_path}' *"
+      else
+        containing_path = File.expand_path("..", path)
+        contents_path = File.basename(path)
+
+        command = "cd '#{containing_path}'#{overwrite_command} && zip -r '#{output_path}' '#{contents_path}'"
+      end
+
+      UI.command(command) unless print
+      Helper.backticks(command, print: print)
+    end
+
+    # Executes the provided block after adjusting the ENV to have the
+    # provided keys and values set as defined in hash. After the block
+    # completes, restores the ENV to its previous state.
+    def self.with_env_values(hash, &block)
+      old_vals = ENV.select { |k, v| hash.include?(k) }
+      hash.each do |k, v|
+        ENV[k] = hash[k]
+      end
+      yield
+    ensure
+      hash.each do |k, v|
+        ENV.delete(k) unless old_vals.include?(k)
+        ENV[k] = old_vals[k]
+      end
+    end
+
+    # loading indicator
+    #
+
+    def self.should_show_loading_indicator?
+      return false if PantographCore::Env.truthy?("PANTOGRAPH_DISABLE_ANIMATION")
+      return false if Helper.ci?
+      return true
+    end
+
+    # Show/Hide loading indicator
+    def self.show_loading_indicator(text = nil)
+      if self.should_show_loading_indicator?
+        # we set the default here, instead of at the parameters
+        # as we don't want to `UI.message` a rocket that's just there for the loading indicator
+        text ||= "🚀"
+        @require_pantograph_spinner = TTY::Spinner.new("[:spinner] #{text} ", format: :dots)
+        @require_pantograph_spinner.auto_spin
+      else
+        UI.message(text) if text
+      end
+    end
+
+    def self.hide_loading_indicator
+      if self.should_show_loading_indicator? && @require_pantograph_spinner
+        @require_pantograph_spinner.success
+      end
+    end
+
+    # files
+    #
+
+    # checks if a given path is an executable file
+    def self.executable?(cmd_path)
+      # no executable files on Windows, so existing is enough there
+      cmd_path && !File.directory?(cmd_path) && (File.executable?(cmd_path) || (self.windows? && File.exist?(cmd_path)))
+    end
+
+    # checks if given file is a valid json file
+    # base taken from: http://stackoverflow.com/a/26235831/1945875
+    def self.json_file?(filename)
+      return false unless File.exist?(filename)
+      begin
+        JSON.parse(File.read(filename))
+        return true
+      rescue JSON::ParserError
+        return false
+      end
+    end
+
+    # deprecated
+    #
+
+    # Use Helper.test?, Helper.ci?, Helper.mac? or Helper.windows? instead (legacy calls)
+    def self.is_test?
+      self.test?
+    end
+
+    def self.is_ci?
+      ci?
+    end
+
+    def self.is_mac?
+      self.mac?
+    end
+
+    def self.is_windows?
+      self.windows?
+    end
+
+    # <b>DEPRECATED:</b> Use the `ROOT` constant from the appropriate tool module instead
+    # e.g. File.join(Sigh::ROOT, 'lib', 'assets', 'resign.sh')
+    #
+    # Path to the installed gem to load resources (e.g. resign.sh)
+    def self.gem_path(gem_name)
+      UI.deprecated('`Helper.gem_path` is deprecated. Use the `ROOT` constant from the appropriate tool module instead.')
+
+      if !Helper.test? && Gem::Specification.find_all_by_name(gem_name).any?
+        return Gem::Specification.find_by_name(gem_name).gem_dir
+      else
+        return './'
+      end
+    end
+
+    # This method is deprecated, use the `UI` class
+    # https://docs.pantograph.tools/advanced/#user-input-and-output
+    def self.log
+      UI.deprecated("Helper.log is deprecated. Use `UI` class instead")
+      UI.current.log
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/keychain_importer.rb

@@ -0,0 +1,74 @@
+require_relative 'helper'
+require 'open3'
+
+module PantographCore
+  class KeychainImporter
+    def self.import_file(path, keychain_path, keychain_password: "", certificate_password: "", output: PantographCore::Globals.verbose?)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      command = "security import #{path.shellescape} -k '#{keychain_path.shellescape}'"
+      command << " -P #{certificate_password.shellescape}"
+      command << " -T /usr/bin/codesign" # to not be asked for permission when running a tool like `gym` (before Sierra)
+      command << " -T /usr/bin/security"
+      command << " 1> /dev/null" unless output
+
+      UI.command(command) if output
+      Open3.popen3(command) do |stdin, stdout, stderr, thrd|
+        UI.command_output(stdout.read.to_s) if output
+
+        # Set partition list only if success since it can be a time consuming process if a lot of keys are installed
+        if thrd.value.success?
+          set_partition_list(path, keychain_path, keychain_password: keychain_password, output: output)
+        else
+          # Output verbose if file is already installed since not an error otherwise we will show the whole error
+          err = stderr.read.to_s.strip
+          if err.include?("SecKeychainItemImport") && err.include?("The specified item already exists in the keychain")
+            UI.verbose("'#{File.basename(path)}' is already installed on this machine")
+          else
+            UI.error(err)
+          end
+        end
+      end
+    end
+
+    def self.set_partition_list(path, keychain_path, keychain_password: "", output: PantographCore::Globals.verbose?)
+      # When security supports partition lists, also add the partition IDs
+      # See https://openradar.appspot.com/28524119
+      if Helper.backticks('security -h | grep set-key-partition-list', print: false).length > 0
+        command = "security set-key-partition-list"
+        command << " -S apple-tool:,apple:"
+        command << " -k #{keychain_password.to_s.shellescape}"
+        command << " #{keychain_path.shellescape}"
+        command << " 1> /dev/null" # always disable stdout. This can be very verbose, and leak potentially sensitive info
+
+        # Showing loading indicator as this can take some time if a lot of keys installed
+        Helper.show_loading_indicator("Setting key partition list... (this can take a minute if there are a lot of keys installed)")
+
+        UI.command(command) if output
+        Open3.popen3(command) do |stdin, stdout, stderr, thrd|
+          unless thrd.value.success?
+            err = stderr.read.to_s.strip
+
+            # Inform user when no/wrong password was used as its needed to prevent UI permission popup from Xcode when signing
+            if err.include?("SecKeychainItemSetAccessWithPassword")
+              UI.important("")
+              UI.important("Could not configure imported keychain item (certificate) to prevent UI permission popup when code signing\n" \
+                       "Check if you supplied the correct `keychain_password` for keychain: `#{keychain_path}`\n" \
+                       "#{err}")
+              UI.important("")
+              UI.important("Please look at the following docs to see how to set a keychain password:")
+              UI.important(" - https://docs.pantograph.tools/actions/sync_code_signing")
+              UI.important(" - https://docs.pantograph.tools/actions/get_certificates")
+            else
+              UI.error(err)
+            end
+          end
+        end
+
+        # Hiding after Open3 finishes
+        Helper.hide_loading_indicator
+
+      end
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/languages.rb

@@ -0,0 +1,14 @@
+module PantographCore
+  module Languages
+    # These are all the languages which are available to use to upload app metadata and screenshots
+
+    # The old format which was used until August 2015 (good old times)
+    ALL_LANGUAGES_LEGACY = ["da-DK", "de-DE", "el-GR", "en-AU", "en-CA", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "id-ID", "it-IT", "ja-JP", "ko-KR", "ms-MY", "nl-NL", "no-NO", "pt-BR", "pt-PT", "ru-RU", "sv-SE", "th-TH", "tr-TR", "vi-VI", "cmn-Hans", "cmn-Hant"]
+
+    # The new format used from September 2015 on
+    # Updates should also be made to:
+    # - produce/lib/produce/available_default_languages.rb
+    # See pull request for example: https://github.com/pantograph/pantograph/pull/14110
+    ALL_LANGUAGES = ["ar-SA", "ca", "cs", "da", "de-DE", "el", "en-AU", "en-CA", "en-GB", "en-US", "es-ES", "es-MX", "fi", "fr-CA", "fr-FR", "he", "hi", "hr", "hu", "id", "it", "ja", "ko", "ms", "nl-NL", "no", "pl", "pt-BR", "pt-PT", "ro", "ru", "sk", "sv", "th", "tr", "uk", "vi", "zh-Hans", "zh-Hant"]
+  end
+end

data/pantograph_core/lib/pantograph_core/module.rb

@@ -0,0 +1,29 @@
+require 'pantograph/boolean'
+
+require_relative 'analytics/analytics_session'
+
+module PantographCore
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+  Boolean = Pantograph::Boolean
+
+  # Session is used to report usage metrics.
+  # If you opt out, we will not send anything.
+  # You can confirm this by observing how we use the environment variable: PANTOGRAPH_OPT_OUT_USAGE
+  # Specifically, in AnalyticsSession.finalize_session
+  # Learn more at https://docs.pantograph.tools/#metrics
+  def self.session
+    @session ||= AnalyticsSession.new
+  end
+
+  def self.reset_session
+    @session = nil
+  end
+
+  # A directory that's being used to user-wide pantograph configs
+  # This directory is also used for the bundled pantograph
+  def self.pantograph_user_dir
+    path = File.expand_path(File.join(Dir.home, ".pantograph"))
+    FileUtils.mkdir_p(path) unless File.directory?(path)
+    return path
+  end
+end

data/pantograph_core/lib/pantograph_core/pantograph_folder.rb

@@ -0,0 +1,39 @@
+require_relative 'ui/ui'
+
+module PantographCore
+  class PantographFolder
+    FOLDER_NAME = 'pantograph'
+
+    # Path to the pantograph folder containing the Pantfile 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?('Pantfile') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Pantfile') # inside the folder and hidden
+      return value
+    end
+
+    # Path to the Pantfile inside the pantograph folder. This is nil when none is available
+    def self.pantfile_path
+      return nil if self.path.nil?
+
+      path = File.join(self.path, 'Pantfile')
+      return path if File.exist?(path)
+      return nil
+    end
+
+    # Does a pantograph configuration already exist?
+    def self.setup?
+      return false unless self.pantfile_path
+      File.exist?(self.pantfile_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 'pantograph' at path '#{path}', please delete it") if File.exist?(path)
+      FileUtils.mkdir_p(path)
+      UI.success("Created new folder '#{path}'.")
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/pantograph_pty.rb

@@ -0,0 +1,57 @@
+# Source: Mix of https://github.com/pantograph/pantograph/pull/7202/files,
+# https://github.com/pantograph/pantograph/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 PantographCore
+  class PantographPtyError < 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 PantographPty
+    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 PantographPtyError to allow
+      # callers to see and use $?.exitstatus that
+      # would usually get returned
+      raise PantographPtyError.new(e, $?.exitstatus)
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/pkg_file_analyser.rb

@@ -0,0 +1,44 @@
+require 'rexml/document'
+
+require_relative 'helper'
+
+module PantographCore
+  class PkgFileAnalyser
+    def self.fetch_app_identifier(path)
+      xml = self.fetch_distribution_xml_file(path)
+      return xml.elements['installer-gui-script/product'].attributes['id'] if xml
+      return nil
+    end
+
+    # Fetches the app version from the given pkg file.
+    def self.fetch_app_version(path)
+      xml = self.fetch_distribution_xml_file(path)
+      return xml.elements['installer-gui-script/product'].attributes['version'] if xml
+      return nil
+    end
+
+    def self.fetch_distribution_xml_file(path)
+      Dir.mktmpdir do |dir|
+        Helper.backticks("xar -C #{dir.shellescape} -xf #{path.shellescape}")
+
+        Dir.foreach(dir) do |file|
+          next unless file.include?('Distribution')
+
+          begin
+            content = File.open(File.join(dir, file))
+            xml = REXML::Document.new(content)
+
+            if xml.elements['installer-gui-script/product']
+              return xml
+            end
+          rescue => ex
+            UI.error(ex)
+            UI.error("Error parsing *.pkg distribution xml #{File.join(dir, file)}")
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end