fastlane_pricing_fix 2.212.1

data/supply/lib/supply/uploader.rb

@@ -0,0 +1,489 @@
+module Supply
+  # rubocop:disable Metrics/ClassLength
+  class Uploader
+    def perform_upload
+      FastlaneCore::PrintTable.print_values(config: Supply.config, hide_keys: [:issuer], mask_keys: [:json_key_data], title: "Summary for supply #{Fastlane::VERSION}")
+
+      client.begin_edit(package_name: Supply.config[:package_name])
+
+      verify_config!
+
+      apk_version_codes = []
+      apk_version_codes.concat(upload_apks) unless Supply.config[:skip_upload_apk]
+      apk_version_codes.concat(upload_bundles) unless Supply.config[:skip_upload_aab]
+      upload_mapping(apk_version_codes)
+
+      track_to_update = Supply.config[:track]
+
+      apk_version_codes.concat(Supply.config[:version_codes_to_retain]) if Supply.config[:version_codes_to_retain]
+
+      if !apk_version_codes.empty?
+        # Only update tracks if we have version codes
+        # update_track handle setting rollout if needed
+        # Updating a track with empty version codes can completely clear out a track
+        update_track(apk_version_codes)
+      else
+        # Only promote or rollout if we don't have version codes
+        if Supply.config[:track_promote_to]
+          track_to_update = Supply.config[:track_promote_to]
+          promote_track
+        elsif !Supply.config[:rollout].nil? && Supply.config[:track].to_s != ""
+          update_rollout
+        end
+      end
+
+      perform_upload_meta(apk_version_codes, track_to_update)
+
+      if Supply.config[:validate_only]
+        UI.message("Validating all changes with Google Play...")
+        client.validate_current_edit!
+        UI.success("Successfully validated the upload to Google Play")
+      else
+        UI.message("Uploading all changes to Google Play...")
+        client.commit_current_edit!
+        UI.success("Successfully finished the upload to Google Play")
+      end
+    end
+
+    def perform_upload_to_internal_app_sharing
+      download_urls = []
+
+      package_name = Supply.config[:package_name]
+
+      apk_paths = [Supply.config[:apk]] unless (apk_paths = Supply.config[:apk_paths])
+      apk_paths.compact!
+      apk_paths.each do |apk_path|
+        download_url = client.upload_apk_to_internal_app_sharing(package_name, apk_path)
+        download_urls << download_url
+        UI.success("Successfully uploaded APK to Internal App Sharing URL: #{download_url}")
+      end
+
+      aab_paths = [Supply.config[:aab]] unless (aab_paths = Supply.config[:aab_paths])
+      aab_paths.compact!
+      aab_paths.each do |aab_path|
+        download_url = client.upload_bundle_to_internal_app_sharing(package_name, aab_path)
+        download_urls << download_url
+        UI.success("Successfully uploaded AAB to Internal App Sharing URL: #{download_url}")
+      end
+
+      if download_urls.count == 1
+        return download_urls.first
+      else
+        return download_urls
+      end
+    end
+
+    def perform_upload_meta(version_codes, track_name)
+      if (!Supply.config[:skip_upload_metadata] || !Supply.config[:skip_upload_images] || !Supply.config[:skip_upload_changelogs] || !Supply.config[:skip_upload_screenshots]) && metadata_path
+        # Use version code from config if version codes is empty and no nil or empty string
+        version_codes = [Supply.config[:version_code]] if version_codes.empty?
+        version_codes = version_codes.reject do |version_code|
+          version_codes.to_s == ""
+        end
+
+        version_codes.each do |version_code|
+          UI.user_error!("Could not find folder #{metadata_path}") unless File.directory?(metadata_path)
+
+          track, release = fetch_track_and_release!(track_name, version_code)
+          UI.user_error!("Unable to find the requested track - '#{Supply.config[:track]}'") unless track
+          UI.user_error!("Could not find release for version code '#{version_code}' to update changelog") unless release
+
+          release_notes = []
+          all_languages.each do |language|
+            next if language.start_with?('.') # e.g. . or .. or hidden folders
+            UI.message("Preparing to upload for language '#{language}'...")
+
+            listing = client.listing_for_language(language)
+
+            upload_metadata(language, listing) unless Supply.config[:skip_upload_metadata]
+            upload_images(language) unless Supply.config[:skip_upload_images]
+            upload_screenshots(language) unless Supply.config[:skip_upload_screenshots]
+            release_notes << upload_changelog(language, version_code) unless Supply.config[:skip_upload_changelogs]
+          end
+
+          upload_changelogs(release_notes, release, track, track_name) unless release_notes.empty?
+        end
+      end
+    end
+
+    def fetch_track_and_release!(track, version_code, status = nil)
+      tracks = client.tracks(track)
+      return nil, nil if tracks.empty?
+
+      track = tracks.first
+      releases = track.releases
+
+      releases = releases.select { |r| r.status == status } if status
+      releases = releases.select { |r| (r.version_codes || []).map(&:to_s).include?(version_code.to_s) } if version_code
+
+      if releases.size > 1
+        UI.user_error!("More than one release found in this track. Please specify with the :version_code option to select a release.")
+      end
+
+      return track, releases.first
+    end
+
+    def update_rollout
+      track, release = fetch_track_and_release!(Supply.config[:track], Supply.config[:version_code], Supply::ReleaseStatus::IN_PROGRESS)
+      UI.user_error!("Unable to find the requested track - '#{Supply.config[:track]}'") unless track
+      UI.user_error!("Unable to find the requested release on track - '#{Supply.config[:track]}'") unless release
+
+      version_code = release.version_codes.first
+
+      UI.message("Updating #{version_code}'s rollout to '#{Supply.config[:rollout]}' on track '#{Supply.config[:track]}'...")
+
+      if track && release
+        completed = Supply.config[:rollout].to_f == 1
+        release.user_fraction = completed ? nil : Supply.config[:rollout]
+        release.status = Supply::ReleaseStatus::COMPLETED if completed
+
+        # Deleted other version codes if completed because only allowed on completed version in a release
+        track.releases.delete_if { |r| !(r.version_codes || []).map(&:to_s).include?(version_code) } if completed
+      else
+        UI.user_error!("Unable to find version to rollout in track '#{Supply.config[:track]}'")
+      end
+
+      client.update_track(Supply.config[:track], track)
+    end
+
+    def verify_config!
+      unless metadata_path || Supply.config[:apk] || Supply.config[:apk_paths] || Supply.config[:aab] || Supply.config[:aab_paths] || (Supply.config[:track] && Supply.config[:track_promote_to]) || (Supply.config[:track] && Supply.config[:rollout])
+        UI.user_error!("No local metadata, apks, aab, or track to promote were found, make sure to run `fastlane supply init` to setup supply")
+      end
+
+      # Can't upload both at apk and aab at same time
+      # Need to error out users when there both apks and aabs are detected
+      apk_paths = [Supply.config[:apk], Supply.config[:apk_paths]].flatten.compact
+      could_upload_apk = !apk_paths.empty? && !Supply.config[:skip_upload_apk]
+      could_upload_aab = Supply.config[:aab] && !Supply.config[:skip_upload_aab]
+      if could_upload_apk && could_upload_aab
+        UI.user_error!("Cannot provide both apk(s) and aab - use `skip_upload_apk`, `skip_upload_aab`, or  make sure to remove any existing .apk or .aab files that are no longer needed")
+      end
+
+      if Supply.config[:release_status] == Supply::ReleaseStatus::DRAFT && Supply.config[:rollout]
+        UI.user_error!(%(Cannot specify rollout percentage when the release status is set to 'draft'))
+      end
+
+      if Supply.config[:track_promote_release_status] == Supply::ReleaseStatus::DRAFT && Supply.config[:rollout]
+        UI.user_error!(%(Cannot specify rollout percentage when the track promote release status is set to 'draft'))
+      end
+
+      unless Supply.config[:version_codes_to_retain].nil?
+        Supply.config[:version_codes_to_retain] = Supply.config[:version_codes_to_retain].map(&:to_i)
+      end
+    end
+
+    def promote_track
+      track_from = client.tracks(Supply.config[:track]).first
+      unless track_from
+        UI.user_error!("Cannot promote from track '#{Supply.config[:track]}' - track doesn't exist")
+      end
+
+      releases = track_from.releases
+      if Supply.config[:version_code].to_s != ""
+        releases = releases.select do |release|
+          release.version_codes.include?(Supply.config[:version_code].to_s)
+        end
+      else
+        releases = releases.select do |release|
+          release.status == Supply.config[:release_status]
+        end
+      end
+
+      if releases.size == 0
+        UI.user_error!("Track '#{Supply.config[:track]}' doesn't have any releases")
+      elsif releases.size > 1
+        UI.user_error!("Track '#{Supply.config[:track]}' has more than one release - use :version_code to filter the release to promote")
+      end
+
+      release = releases.first
+      track_to = client.tracks(Supply.config[:track_promote_to]).first
+
+      rollout = (Supply.config[:rollout] || 0).to_f
+      if rollout > 0 && rollout < 1
+        release.status = Supply::ReleaseStatus::IN_PROGRESS
+        release.user_fraction = rollout
+      else
+        release.status = Supply.config[:track_promote_release_status]
+        release.user_fraction = nil
+      end
+
+      if track_to
+        # Its okay to set releases to an array containing the newest release
+        # Google Play will keep previous releases there this release is a partial rollout
+        track_to.releases = [release]
+      else
+        track_to = AndroidPublisher::Track.new(
+          track: Supply.config[:track_promote_to],
+          releases: [release]
+        )
+      end
+
+      client.update_track(Supply.config[:track_promote_to], track_to)
+    end
+
+    def upload_changelog(language, version_code)
+      UI.user_error!("Cannot find changelog because no version code given - please specify :version_code") unless version_code
+
+      path = File.join(Supply.config[:metadata_path], language, Supply::CHANGELOGS_FOLDER_NAME, "#{version_code}.txt")
+      changelog_text = ''
+      if File.exist?(path)
+        UI.message("Updating changelog for '#{version_code}' and language '#{language}'...")
+        changelog_text = File.read(path, encoding: 'UTF-8')
+      else
+        default_changelog_path = File.join(Supply.config[:metadata_path], language, Supply::CHANGELOGS_FOLDER_NAME, "default.txt")
+        if File.exist?(default_changelog_path)
+          UI.message("Updating changelog for '#{version_code}' and language '#{language}' to default changelog...")
+          changelog_text = File.read(default_changelog_path, encoding: 'UTF-8')
+        else
+          UI.message("Could not find changelog for '#{version_code}' and language '#{language}' at path #{path}...")
+        end
+      end
+
+      AndroidPublisher::LocalizedText.new(
+        language: language,
+        text: changelog_text
+      )
+    end
+
+    def upload_changelogs(release_notes, release, track, track_name)
+      release.release_notes = release_notes
+      client.upload_changelogs(track, track_name)
+    end
+
+    def upload_metadata(language, listing)
+      Supply::AVAILABLE_METADATA_FIELDS.each do |key|
+        path = File.join(metadata_path, language, "#{key}.txt")
+        listing.send("#{key}=".to_sym, File.read(path, encoding: 'UTF-8')) if File.exist?(path)
+      end
+      begin
+        listing.save
+      rescue Encoding::InvalidByteSequenceError => ex
+        message = (ex.message || '').capitalize
+        UI.user_error!("Metadata must be UTF-8 encoded. #{message}")
+      end
+    end
+
+    def upload_images(language)
+      Supply::IMAGES_TYPES.each do |image_type|
+        search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, image_type) + ".#{IMAGE_FILE_EXTENSIONS}"
+        path = Dir.glob(search, File::FNM_CASEFOLD).last
+        next unless path
+
+        UI.message("Uploading image file #{path}...")
+        client.upload_image(image_path: File.expand_path(path),
+                            image_type: image_type,
+                              language: language)
+      end
+    end
+
+    def upload_screenshots(language)
+      Supply::SCREENSHOT_TYPES.each do |screenshot_type|
+        search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, screenshot_type, "*.#{IMAGE_FILE_EXTENSIONS}")
+        paths = Dir.glob(search, File::FNM_CASEFOLD)
+        next unless paths.count > 0
+
+        client.clear_screenshots(image_type: screenshot_type, language: language)
+
+        paths.sort.each do |path|
+          UI.message("Uploading screenshot #{path}...")
+          client.upload_image(image_path: File.expand_path(path),
+                              image_type: screenshot_type,
+                                language: language)
+        end
+      end
+    end
+
+    def upload_apks
+      apk_paths = [Supply.config[:apk]] unless (apk_paths = Supply.config[:apk_paths])
+      apk_paths.compact!
+
+      apk_version_codes = []
+
+      apk_paths.each do |apk_path|
+        apk_version_codes.push(upload_binary_data(apk_path))
+      end
+
+      return apk_version_codes
+    end
+
+    def upload_mapping(apk_version_codes)
+      mapping_paths = [Supply.config[:mapping]] unless (mapping_paths = Supply.config[:mapping_paths])
+      mapping_paths.product(apk_version_codes).each do |mapping_path, version_code|
+        if mapping_path
+          UI.message("Preparing mapping at path '#{mapping_path}', version code #{version_code} for upload...")
+          client.upload_mapping(mapping_path, version_code)
+        end
+      end
+    end
+
+    def upload_bundles
+      aab_paths = [Supply.config[:aab]] unless (aab_paths = Supply.config[:aab_paths])
+      return [] unless aab_paths
+      aab_paths.compact!
+
+      aab_version_codes = []
+
+      aab_paths.each do |aab_path|
+        UI.message("Preparing aab at path '#{aab_path}' for upload...")
+        bundle_version_code = client.upload_bundle(aab_path)
+        aab_version_codes.push(bundle_version_code)
+      end
+
+      return aab_version_codes
+    end
+
+    private
+
+    ##
+    # Upload binary apk and obb and corresponding change logs with client
+    #
+    # @param [String] apk_path
+    #    Path of the apk file to upload.
+    #
+    # @return [Integer] The apk version code returned after uploading, or nil if there was a problem
+    def upload_binary_data(apk_path)
+      apk_version_code = nil
+
+      if apk_path
+        UI.message("Preparing apk at path '#{apk_path}' for upload...")
+        apk_version_code = client.upload_apk(apk_path)
+        UI.user_error!("Could not upload #{apk_path}") unless apk_version_code
+
+        if Supply.config[:obb_main_references_version] && Supply.config[:obb_main_file_size]
+          update_obb(apk_version_code,
+                     'main',
+                     Supply.config[:obb_main_references_version],
+                     Supply.config[:obb_main_file_size])
+        end
+
+        if Supply.config[:obb_patch_references_version] && Supply.config[:obb_patch_file_size]
+          update_obb(apk_version_code,
+                     'patch',
+                     Supply.config[:obb_patch_references_version],
+                     Supply.config[:obb_patch_file_size])
+        end
+
+        upload_obbs(apk_path, apk_version_code)
+      else
+        UI.message("No apk file found, you can pass the path to your apk using the `apk` option")
+      end
+
+      UI.message("\tVersion Code: #{apk_version_code}")
+      apk_version_code
+    end
+
+    def update_obb(apk_version_code, expansion_file_type, references_version, file_size)
+      UI.message("Updating '#{expansion_file_type}' expansion file from version '#{references_version}'...")
+      client.update_obb(apk_version_code,
+                        expansion_file_type,
+                        references_version,
+                        file_size)
+    end
+
+    def update_track(apk_version_codes)
+      return if apk_version_codes.empty?
+
+      UI.message("Updating track '#{Supply.config[:track]}'...")
+
+      track_release = AndroidPublisher::TrackRelease.new(
+        name: Supply.config[:version_name],
+        status: Supply.config[:release_status],
+        version_codes: apk_version_codes
+      )
+
+      if Supply.config[:rollout]
+        rollout = Supply.config[:rollout].to_f
+        if rollout > 0 && rollout < 1
+          track_release.status = Supply::ReleaseStatus::IN_PROGRESS
+          track_release.user_fraction = rollout
+        end
+      end
+
+      if Supply.config[:in_app_update_priority]
+        track_release.in_app_update_priority = Supply.config[:in_app_update_priority].to_i
+      end
+
+      tracks = client.tracks(Supply.config[:track])
+      track = tracks.first
+      if track
+        # Its okay to set releases to an array containing the newest release
+        # Google Play will keep previous releases there this release is a partial rollout
+        track.releases = [track_release]
+      else
+        track = AndroidPublisher::Track.new(
+          track: Supply.config[:track],
+          releases: [track_release]
+        )
+      end
+
+      client.update_track(Supply.config[:track], track)
+    end
+
+    # returns only language directories from metadata_path
+    def all_languages
+      Dir.entries(metadata_path)
+         .select { |f| File.directory?(File.join(metadata_path, f)) }
+         .reject { |f| f.start_with?('.') }
+         .sort { |x, y| x <=> y }
+    end
+
+    def client
+      @client ||= Client.make_from_config
+    end
+
+    def metadata_path
+      Supply.config[:metadata_path]
+    end
+
+    # searches for obbs in the directory where the apk is located and
+    # upload at most one main and one patch file. Do nothing if it finds
+    # more than one of either of them.
+    def upload_obbs(apk_path, apk_version_code)
+      expansion_paths = find_obbs(apk_path)
+      ['main', 'patch'].each do |type|
+        if expansion_paths[type]
+          upload_obb(expansion_paths[type], type, apk_version_code)
+        end
+      end
+    end
+
+    # @return a map of the obb paths for that apk
+    # keyed by their detected expansion file type
+    # E.g.
+    # { 'main' => 'path/to/main.obb', 'patch' => 'path/to/patch.obb' }
+    def find_obbs(apk_path)
+      search = File.join(File.dirname(apk_path), '*.obb')
+      paths = Dir.glob(search, File::FNM_CASEFOLD)
+      expansion_paths = {}
+      paths.each do |path|
+        type = obb_expansion_file_type(path)
+        next unless type
+        if expansion_paths[type]
+          UI.important("Can only upload one '#{type}' apk expansion. Skipping obb upload entirely.")
+          UI.important("If you'd like this to work differently, please submit an issue.")
+          return {}
+        end
+        expansion_paths[type] = path
+      end
+      expansion_paths
+    end
+
+    def upload_obb(obb_path, expansion_file_type, apk_version_code)
+      UI.message("Uploading obb file #{obb_path}...")
+      client.upload_obb(obb_file_path: obb_path,
+                        apk_version_code: apk_version_code,
+                        expansion_file_type: expansion_file_type)
+    end
+
+    def obb_expansion_file_type(obb_file_path)
+      filename = File.basename(obb_file_path, ".obb")
+      if filename.include?('main')
+        'main'
+      elsif filename.include?('patch')
+        'patch'
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/supply/lib/supply.rb

@@ -0,0 +1,53 @@
+require 'json'
+require 'supply/options'
+require 'supply/client'
+require 'supply/listing'
+require 'supply/apk_listing'
+require 'supply/release_listing'
+require 'supply/uploader'
+require 'supply/languages'
+
+require 'fastlane_core'
+
+module Supply
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+  end
+
+  AVAILABLE_METADATA_FIELDS = %w(title short_description full_description video)
+  IMAGES_TYPES = %w(featureGraphic icon tvBanner) # https://developers.google.com/android-publisher/api-ref/rest/v3/AppImageType
+  SCREENSHOT_TYPES = %w(phoneScreenshots sevenInchScreenshots tenInchScreenshots tvScreenshots wearScreenshots)
+
+  IMAGES_FOLDER_NAME = "images"
+  IMAGE_FILE_EXTENSIONS = "{png,jpg,jpeg}"
+
+  CHANGELOGS_FOLDER_NAME = "changelogs"
+
+  # https://developers.google.com/android-publisher/#publishing
+  module Tracks
+    PRODUCTION = "production"
+    BETA = "beta"
+    ALPHA = "alpha"
+    INTERNAL = "internal"
+
+    DEFAULTS = [PRODUCTION, BETA, ALPHA, INTERNAL]
+    DEFAULT = PRODUCTION
+  end
+
+  # https://developers.google.com/android-publisher/api-ref/edits/tracks
+  module ReleaseStatus
+    COMPLETED = "completed"
+    DRAFT = "draft"
+    HALTED = "halted"
+    IN_PROGRESS = "inProgress"
+
+    ALL = [COMPLETED, DRAFT, HALTED, IN_PROGRESS]
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+  DESCRIPTION = "Command line tool for updating Android apps and their metadata on the Google Play Store".freeze
+end

data/trainer/lib/assets/junit.xml.erb

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<% number_of_tests = 0 %>
+<% number_of_failures = 0 %>
+<% @results.each { |a| number_of_tests += a[:number_of_tests_excluding_retries] } %>
+<% @results.each { |a| number_of_failures += a[:number_of_failures_excluding_retries] } %>
+
+<testsuites tests="<%= number_of_tests %>" failures="<%= number_of_failures %>">
+  <% @results.each do |testsuite| %>
+    <testsuite name=<%= (testsuite[:target_name].nil? ? testsuite[:test_name] : testsuite[:target_name]).encode(:xml => :attr) %> tests="<%= testsuite[:number_of_tests_excluding_retries] %>" failures="<%= testsuite[:number_of_failures_excluding_retries] %>" <% if testsuite[:number_of_skipped] %>skipped="<%= testsuite[:number_of_skipped] %>" <% end %>time="<%= testsuite[:duration] %>">
+      <% unless testsuite[:configuration_name].nil? %>
+        <properties>
+          <property name="Configuration" value="<%= testsuite[:configuration_name] %>"/>
+        </properties>
+      <% end %>
+      <% testsuite[:tests].each do |test| %>
+        <testcase classname=<%= test[:test_group].encode(:xml => :attr) %> name=<%= test[:name].encode(:xml => :attr) %> time="<%= test[:duration] %>">
+          <% (test[:failures] || []).each do |failure| %>
+            <failure message=<%= failure[:failure_message].encode(:xml => :attr) %>>
+            </failure>
+          <% end %>
+          <% if test[:skipped] %>
+            <skipped/>
+          <% end %>
+        </testcase>
+      <% end %>
+    </testsuite>
+  <% end %>
+</testsuites>

data/trainer/lib/trainer/commands_generator.rb

@@ -0,0 +1,51 @@
+require 'commander'
+
+require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
+
+require_relative 'options'
+require_relative 'test_parser'
+
+require_relative 'module'
+
+HighLine.track_eof = false
+
+module Trainer
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :version, Fastlane::VERSION
+      program :description, Trainer::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <trainer@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/KrauseFx/trainer'
+      program :help_formatter, :compact
+
+      global_option('--verbose', 'Shows a more verbose output') { $verbose = true }
+
+      always_trace!
+
+      FastlaneCore::CommanderGenerator.new.generate(Trainer::Options.available_options)
+
+      command :run do |c|
+        c.syntax = 'trainer'
+        c.description = Trainer::DESCRIPTION
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(Trainer::Options.available_options, options.__hash__)
+          FastlaneCore::PrintTable.print_values(config: options, title: "Summary for trainer #{Fastlane::VERSION}") if $verbose
+          Trainer::TestParser.auto_convert(options)
+        end
+      end
+
+      default_command(:run)
+
+      run!
+    end
+  end
+end

data/trainer/lib/trainer/junit_generator.rb

@@ -0,0 +1,31 @@
+require_relative 'module'
+
+module Trainer
+  class JunitGenerator
+    attr_accessor :results
+
+    def initialize(results)
+      self.results = results
+    end
+
+    def generate
+      # JUnit file documentation: http://llg.cubic.org/docs/junit/
+      # And http://nelsonwells.net/2012/09/how-jenkins-ci-parses-and-displays-junit-output/
+      # And http://windyroad.com.au/dl/Open%20Source/JUnit.xsd
+
+      lib_path = Trainer::ROOT
+      xml_path = File.join(lib_path, "lib/assets/junit.xml.erb")
+      xml = ERB.new(File.read(xml_path), trim_mode: '<>').result(binding) # http://www.rrn.dk/rubys-erb-templating-system
+
+      xml = xml.gsub('system_', 'system-').delete("\e") # Jenkins can not parse 'ESC' symbol
+
+      # We have to manually clear empty lines
+      # They may contain white spaces
+      clean_xml = []
+      xml.each_line do |row|
+        clean_xml << row.delete("\n") if row.strip.to_s.length > 0
+      end
+      return clean_xml.join("\n")
+    end
+  end
+end

data/trainer/lib/trainer/module.rb

@@ -0,0 +1,10 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+
+module Trainer
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+  DESCRIPTION = "Convert xcodebuild plist and xcresult files to JUnit reports"
+end