fastlane-plugin-waldo 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f32ec479ee63b1ab4f8927cb26ee7b49562c5ea8
-  data.tar.gz: 42c8849320d5ff492788e542866c71b45a9b3773
+SHA256:
+  metadata.gz: 930bf4de096a32ef717f5f4e9a488cf85e13ec1a8c58058ace10ebf583948302
+  data.tar.gz: 1d044beebccaaf38e426370990f046fd3fbc59d08d657bccfa8321cf757fa733
 SHA512:
-  metadata.gz: 49ea9aef680aa191a35d3b3a6a0bdf2f9ce809ffc4ce69e373e2b0d8ca2462547b1a806a92ca0669528a3c9ff4c565251f81d688ebb8c1ec6592339368d0a361
-  data.tar.gz: 2bd510d3f86f923f9ac982b26e90032e678f4aaed3bff69f4f9413c3f628cdaca7c2c4898224dbaf0cf31382d23465b482b9097637354b8a17465537f79762e4
+  metadata.gz: df074478d0982a2851bc5d2e936859d5843735002dfb505bd12c60a3e5db091618894db725d0734a23540b4106ff254134534b42e2a3f003301429bd4fd52cb2
+  data.tar.gz: 533d8fae7a307686e93af2908bc11d3e858f8b6f8cd7ef1136e97851873e425103bf7a85015ce455989685147d7222075289cfe82e724fa8e3762bf54e61e2c9

data/lib/fastlane/plugin/waldo/actions/waldo_action.rb

@@ -2,34 +2,26 @@ module Fastlane
   module Actions
     class WaldoAction < Action
       def self.run(params)
-        params.values   # validate all inputs
+        mparams = Helper::WaldoHelper.filter_parameters(params)
 
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+        return unless Helper::WaldoHelper.validate_parameters(mparams)
 
-        if platform == :android
-          UI.error("You must pass an APK path to the Waldo action") and return unless params[:apk_path]
-        elsif platform == :ios || platform.nil?
-          UI.error("You must pass an IPA or app path to the Waldo action") and return unless params[:ipa_path] || params[:app_path]
-        end
-
-        UI.error("You must pass an upload token to the Waldo action") and return unless params[:upload_token]
-
-        FastlaneCore::PrintTable.print_values(config: params,
+        FastlaneCore::PrintTable.print_values(config: mparams,
                                               title: "Summary for waldo #{Fastlane::Waldo::VERSION.to_s}")
 
-        Helper::WaldoHelper.upload_build(params)
+        Helper::WaldoHelper.upload_build
+        Helper::WaldoHelper.upload_symbols
       end
 
       def self.authors
-        ["eBardX"]
+        ['eBardX']
       end
 
       def self.available_options
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-
-        if platform == :android
-          apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
-        elsif platform == :ios || platform.nil?
+        case Helper::WaldoHelper.get_platform
+        when :android
+          apk_path_default = Dir["*.apk"].last || Dir[File.join('app', 'build', 'outputs', 'apk', 'app-release.apk')].last
+        when :ios
           app_path_default = Dir["*.app"].sort_by { |x| File.mtime(x) }.last
           ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
         end
@@ -37,50 +29,45 @@ module Fastlane
         [
           # iOS-specific
           FastlaneCore::ConfigItem.new(key: :app_path,
-                                       env_name: "WALDO_APP_PATH",
-                                       description: "Path to your app file",
+                                       env_name: 'WALDO_APP_PATH',
+                                       description: 'Path to your app file',
                                        default_value: app_path_default,
                                        default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find app file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :ipa_path,
-                                       env_name: "WALDO_IPA_PATH",
-                                       description: "Path to your IPA file (optional if you use the _gym_ or _xcodebuild_ action)",
+                                       env_name: 'WALDO_IPA_PATH',
+                                       description: 'Path to your IPA file (optional if you use the _gym_ or _xcodebuild_ action)',
                                        default_value: Actions.lane_context[Actions::SharedValues::IPA_OUTPUT_PATH] || ipa_path_default,
                                        default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :dsym_path,
+                                       env_name: 'WALDO_DSYM_PATH',
+                                       description: 'Path to your dSYM file(s)',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :include_symbols,
+                                       env_name: 'WALDO_INCLUDE_SYMBOLS',
+                                       description: 'Include symbols in upload if true',
                                        optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find IPA file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       default_value: false,
+                                       is_string: false),
           # Android-specific
           FastlaneCore::ConfigItem.new(key: :apk_path,
-                                       env_name: "WALDO_APK_PATH",
-                                       description: "Path to your APK file (optional if you use the _gradle_ action)",
+                                       env_name: 'WALDO_APK_PATH',
+                                       description: 'Path to your APK file (optional if you use the _gradle_ action)',
                                        default_value: Actions.lane_context[Actions::SharedValues::GRADLE_APK_OUTPUT_PATH] || apk_path_default,
                                        default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find APK file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           # General
           FastlaneCore::ConfigItem.new(key: :upload_token,
-                                       env_name: "WALDO_UPLOAD_TOKEN",
-                                       description: "Waldo upload token",
+                                       env_name: 'WALDO_UPLOAD_TOKEN',
+                                       description: 'Waldo upload token',
                                        optional: true,
-                                       sensitive: true,
-                                       verify_block: proc do |value|
-                                         UI.error("No upload token for Waldo given, pass using `upload_token: 'value'`") unless value && !value.empty?
-                                       end),
+                                       sensitive: true),
           FastlaneCore::ConfigItem.new(key: :variant_name,
-                                       env_name: "WALDO_VARIANT_NAME",
-                                       description: "Waldo variant name",
+                                       env_name: 'WALDO_VARIANT_NAME',
+                                       description: 'Waldo variant name',
                                        optional: true,
-                                       sensitive: true,
-                                       verify_block: proc do |value|
-                                         UI.error("No variant name for Waldo given, pass using `variant_name: 'value'`") unless value && !value.empty?
-                                       end)
+                                       sensitive: true)
         ]
       end
 
@@ -89,27 +76,27 @@ module Fastlane
       end
 
       def self.description
-        "Upload a new build to [Waldo](https://www.waldo.io)"
+        'Upload a new build to [Waldo](https://www.waldo.io)'
       end
 
       def self.example_code
         [
           'waldo',
-          'waldo(
-            upload_token: "..."
-          )',
-          'waldo(
-            apk_path: "./YourApp.apk",
-            upload_token: "..."
-          )',
-          'waldo(
-            ipa_path: "./YourApp.ipa",
-            upload_token: "..."
-          )',
-          'waldo(
-            app_path: "./YourApp.app",
-            upload_token: "..."
-          )'
+          "waldo(
+            upload_token: '...'
+          )",
+          "waldo(
+            apk_path: './YourApp.apk',
+            upload_token: '...'
+          )",
+          "waldo(
+            ipa_path: './YourApp.ipa',
+            upload_token: '...'
+          )",
+          "waldo(
+            app_path: './YourApp.app',
+            upload_token: '...'
+          )"
         ]
       end
 

data/lib/fastlane/plugin/waldo/helper/waldo_helper.rb

@@ -1,65 +1,229 @@
+require 'base64'
+require 'json'
 require 'net/http'
 
 module Fastlane
   module Helper
     class WaldoHelper
-      def self.upload_build(params)
-        UI.success('Uploading the build to Waldo. This could take a while…')
+      def self.convert_commit(sha)
+        puts "Entering convert_commit(#{sha})"
 
-        begin
-          variant_name = params[:variant_name] || Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
-          uri_string = 'https://api.waldo.io/versions'
+        prefix = 'remotes/origin/'
+        pfxlen = prefix.length
 
-          uri_string += "?variantName=#{variant_name}" if variant_name
+        full_name = get_git_commit_name(sha)
 
-          uri = URI(uri_string)
+        if full_name.start_with?(prefix)
+          abbr_name = full_name[pfxlen..-1]
+        else
+          abbr_name = "local:#{full_name}"
+        end
 
-          request = build_request(uri, params)
+        %("#{sha[0..7]}-#{abbr_name}")
+      end
 
-          dump_request(request) if FastlaneCore::Globals.verbose?
+      def self.dump_request(request)
+        len = request.body ? request.body.length : 0
 
-          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
-            http.read_timeout = 120   # 2 minutes
+        puts "Request: #{request.method} #{request.path} (#{len} bytes)"
 
-            parse_response(http.request(request))
-          end
-        rescue Net::ReadTimeout
-          UI.error("Upload to Waldo timed out!")
-        rescue => exc
-          UI.error("Something went wrong uploading to Waldo: #{exc.inspect.to_s}")
-        ensure
-          request.body_stream.close if request && request.body_stream
+        request.each_capitalized do |key, value|
+          puts "  #{key}: #{value}"
         end
+
+        puts '-------'
       end
 
-      def self.build_request(uri, params)
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      def self.dump_response(response)
+        puts "Response: #{response.code} #{response.message} (#{response.body.length} bytes)"
+
+        response.each_capitalized do |key, value|
+          puts "  #{key}: #{value}"
+        end
+
+        puts "#{response.body}"
+      end
+
+      def self.filter_parameters(in_params)
+        out_params = {}
+
+        apk_path = in_params[:apk_path]
+        app_path = in_params[:app_path]
+        dsym_path = in_params[:dsym_path]
+        include_symbols = in_params[:include_symbols]
+        ipa_path = in_params[:ipa_path]
+        upload_token = in_params[:upload_token]
+        variant_name = in_params[:variant_name]
+
+        apk_path.gsub!("\\ ", ' ') if apk_path
+        app_path.gsub!("\\ ", ' ') if app_path
+        dsym_path.gsub!("\\ ", ' ') if dsym_path
+        ipa_path.gsub!("\\ ", ' ') if ipa_path
+
+        out_params[:apk_path] = apk_path if apk_path
+
+        if app_path && ipa_path
+          if !File.exist?(app_path)
+            out_params[:ipa_path] = ipa_path
+
+            app_path = nil
+          elsif !File.exist?(ipa_path)
+            out_params[:app_path] = app_path
 
-        if platform == :android
-          body_path = params[:apk_path]
-          flavor = "Android"
-        elsif platform == :ios || platform.nil?
-          if params[:app_path]
-            app_dir_path = File.dirname(params[:app_path])
-            app_name = File.basename(params[:app_path])
-            body_path = File.join(Dir.tmpdir, "#{app_name}.zip")
+            ipa_path = nil
+          elsif File.mtime(app_path) < File.mtime(ipa_path)
+            out_params[:ipa_path] = ipa_path
 
-            Actions.sh(%(cd "#{app_dir_path}" && zip -qry "#{body_path}" "#{app_name}"))
+            app_path = nil
           else
-            body_path = params[:ipa_path]
+            out_params[:app_path] = app_path
+
+            ipa_path = nil
+          end
+        else
+          out_params[:app_path] = app_path if app_path
+          out_params[:ipa_path] = ipa_path if ipa_path
+        end
+
+        if app_path
+            if include_symbols
+                if !dsym_path
+                    tmp_path = "#{app_path}.dSYM.zip"
+                    dsym_path = tmp_path if File.exist?(tmp_path)
+                end
+
+                if !dsym_path
+                    tmp_path = "#{app_path}.dSYM"
+                    dsym_path = tmp_path if File.exist?(tmp_path)
+                end
+            end
+
+            out_params[:dsym_path] = dsym_path if dsym_path
+        else
+            out_params[:dsym_path] = dsym_path if dsym_path && ipa_path
+        end
+
+        out_params[:upload_token] = upload_token if upload_token && !upload_token.empty?
+        out_params[:variant_name] = variant_name if variant_name
+
+        out_params
+      end
+
+      def self.get_authorization
+        "Upload-Token #{@upload_token}"
+      end
+
+      def self.get_flavor
+        case get_platform
+        when :android
+          "Android"
+        when :ios
+          "iOS"
+        else
+          "unknown"
+        end
+      end
+
+      def self.get_git_commit_name(sha)
+        cmd = %(git name-rev --exclude='tags/*' --name-only "#{sha}")
+
+        puts "Calling: #{cmd}" if FastlaneCore::Globals.verbose?
+
+        result = Actions.sh(cmd, log: false).chomp
+
+        puts "#{cmd} => #{result}" if FastlaneCore::Globals.verbose?
+
+        result
+      end
+
+      def self.get_git_commits
+        cmd = %(git log --format=%H -50)
+
+        result = Actions.sh(cmd, log: false).chomp
+
+        puts "#{cmd} => #{result}" if FastlaneCore::Globals.verbose?
+
+        result.split(' ')
+      end
+
+      def self.get_history
+        history = get_git_commits
+
+        return '' unless !history.empty?
+
+        history = history.map { |sha| convert_commit(sha) }
+
+        Base64.strict_encode64("[#{history.join(',')}]")
+      end
+
+      def self.get_platform
+        Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] || :ios
+      end
+
+      def self.get_user_agent
+        "Waldo fastlane/#{get_flavor} v#{Fastlane::Waldo::VERSION}"
+      end
+
+      def self.handle_error(message)
+        UI.error(message)
+
+        UI.error('No token for error report upload to Waldo!') unless @upload_token
+
+        upload_error(message) if @upload_token
+      end
+
+      def self.has_git_command?
+        cmd = %(which git)
+
+        result = Actions.sh(cmd, log: false).chomp
+
+        puts "#{cmd} => #{result}" if FastlaneCore::Globals.verbose?
+
+        !result.empty?
+      end
+
+      def self.is_git_repository?
+        cmd = %(git rev-parse)
+
+        result = true
+
+        Actions.sh(cmd,
+                   log: false,
+                   error_callback: ->(ignore) { result = false }
+                  ).chomp
+
+        puts "#{cmd} => #{result}" if FastlaneCore::Globals.verbose?
+
+        result
+      end
+
+      def self.make_build_request(uri)
+        if @apk_path
+          body_path = @apk_path
+        elsif @ipa_path
+          body_path = @ipa_path
+        else
+          app_basename = File.basename(@app_path)
+          app_dirname = File.dirname(@app_path)
+
+          body_path = File.join(Dir.tmpdir, "#{app_basename}.zip")
+
+          unless zip(src_path: app_basename,
+                     zip_path: body_path,
+                     cd_path: app_dirname)
+            return nil
           end
-          flavor = "iOS"
         end
 
         request = Net::HTTP::Post.new(uri.request_uri)
 
-        request['Authorization'] = "Upload-Token #{params[:upload_token]}"
+        request['Authorization'] = get_authorization
         request['Transfer-Encoding'] = 'chunked'
-        request['User-Agent'] = "Waldo fastlane/#{flavor} v#{Fastlane::Waldo::VERSION}"
+        request['User-Agent'] = get_user_agent
 
         request.body_stream = WaldoReadIO.new(body_path)
 
-        if params[:app_path]
+        if @app_path
           request.content_type = 'application/zip'
         else
           request.content_type = 'application/octet-stream'
@@ -68,39 +232,324 @@ module Fastlane
         request
       end
 
-      def self.dump_request(request)
-        len = request.body ? request.body.length : 0
+      def self.make_build_uri
+        if !has_git_command?
+          history_error = "noGitCommandFound"
+        elsif !is_git_repository?
+          history_error = "notGitRepository"
+        else
+          history = get_history
+        end
 
-        puts "Request: #{request.method} #{request.path} (#{len} bytes)"
+        query = ''
 
-        request.each_capitalized do |key, value|
-          puts "  #{key}: #{value}"
+        if history
+          query += "&history=#{history}"
+        elsif history_error
+          query += "&historyError=#{history_error}"
         end
 
-        puts "-------"
+        query += "&variantName=#{@variant_name}" if @variant_name
+
+        uri_string = 'https://api.waldo.io/versions'
+
+        uri_string += "?#{query[1..-1]}" if !query.empty?
+
+        URI(uri_string)
       end
 
-      def self.dump_response(response)
-        puts "Response: #{response.code} #{response.message} (#{response.body.length} bytes)"
+      def self.make_error_request(uri, message)
+        request = Net::HTTP::Post.new(uri.request_uri)
 
-        response.each_capitalized do |key, value|
-          puts "  #{key}: #{value}"
+        request['Authorization'] = get_authorization
+        request['User-Agent'] = get_user_agent
+
+        request.body = { "message": message }.to_json
+        request.content_type = 'application/json'
+
+        request
+      end
+
+      def self.make_error_uri
+          uri_string = 'https://api.waldo.io/uploadError'
+
+          URI(uri_string)
+      end
+
+      def self.make_symbols_request(uri)
+        if File.file?(@dsym_path)
+          body_path = @dsym_path
+        else
+          dsym_basename = File.basename(@dsym_path)
+          dsym_dirname = File.dirname(@dsym_path)
+
+          body_path = File.join(Dir.tmpdir, "#{dsym_basename}.zip")
+
+          unless zip(src_path: dsym_basename,
+                     zip_path: body_path,
+                     cd_path: dsym_dirname)
+            return nil
+          end
         end
 
-        puts "#{response.body}"
+        request = Net::HTTP::Post.new(uri.request_uri)
+
+        request['Authorization'] = get_authorization
+        request['Transfer-Encoding'] = 'chunked'
+        request['User-Agent'] = get_user_agent
+
+        request.body_stream = WaldoReadIO.new(body_path)
+        request.content_type = 'application/zip'
+
+        request
+      end
+
+      def self.make_symbols_uri
+          uri_string = 'https://api.waldo.io/versions/'
+
+          uri_string += @build_upload_id
+          uri_string += '/symbols'
+
+          URI(uri_string)
       end
 
-      def self.parse_response(response)
+      def self.parse_build_response(response)
         dump_response(response) if FastlaneCore::Globals.verbose?
 
         case response.code.to_i
         when 200..299
           UI.success('Build successfully uploaded to Waldo!')
         when 401
-          UI.error("Upload token is invalid or missing!")
+          handle_error('Token is invalid or missing for build upload to Waldo!')
+        else
+          handle_error("Build failed to upload to Waldo: #{response.code} #{response.message}")
+        end
+
+        result = JSON.parse(response.body)
+
+        @build_upload_id = result["id"]
+      end
+
+      def self.parse_error_response(response)
+        dump_response(response) if FastlaneCore::Globals.verbose?
+
+        case response.code.to_i
+        when 200..299
+          UI.success('Error report successfully uploaded to Waldo!')
+        when 401
+          UI.error('Token is invalid or missing for error report upload to Waldo!')
+        else
+          UI.error("Error report failed to upload to Waldo: #{response.code} #{response.message}")
+        end
+      end
+
+      def self.parse_symbols_response(response)
+        dump_response(response) if FastlaneCore::Globals.verbose?
+
+        case response.code.to_i
+        when 200..299
+          UI.success('Symbols successfully uploaded to Waldo!')
+        when 401
+          UI.error('Token is invalid or missing for symbols upload to Waldo!')
+        else
+          UI.error("Symbols failed to upload to Waldo: #{response.code} #{response.message}")
+        end
+      end
+
+      def self.upload_build
+        begin
+          @variant_name ||= Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
+
+          uri = make_build_uri
+
+          request = make_build_request(uri)
+
+          return unless request
+
+          UI.success('Uploading build to Waldo')
+
+          dump_request(request) if FastlaneCore::Globals.verbose?
+
+          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+            http.read_timeout = 120 # 2 minutes
+
+            parse_build_response(http.request(request))
+          end
+        rescue Net::ReadTimeout => exc
+          handle_error('Build upload to Waldo timed out!')
+        rescue => exc
+          handle_error("Something went wrong uploading build to Waldo: #{exc.inspect.to_s}")
+        ensure
+          request.body_stream.close if request && request.body_stream
+        end
+      end
+
+      def self.upload_error(message)
+        begin
+          uri = make_error_uri
+
+          request = make_error_request(uri, message)
+
+          UI.error('Uploading error report to Waldo')
+
+          dump_request(request) if FastlaneCore::Globals.verbose?
+
+          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+            http.read_timeout = 30  # seconds
+
+            parse_error_response(http.request(request))
+          end
+        rescue Net::ReadTimeout => exc
+          UI.error('Error report upload to Waldo timed out!')
+        rescue => exc
+          UI.error("Something went wrong uploading error report to Waldo: #{exc.inspect.to_s}")
+        end
+      end
+
+      def self.upload_symbols
+        begin
+          return unless @dsym_path
+
+          uri = make_symbols_uri
+
+          request = make_symbols_request(uri)
+
+          return unless request
+
+          UI.success('Uploading symbols to Waldo')
+
+          dump_request(request) if FastlaneCore::Globals.verbose?
+
+          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+            http.read_timeout = 120 # 2 minutes
+
+            parse_symbols_response(http.request(request))
+          end
+        rescue Net::ReadTimeout => exc
+          handle_error('Symbols upload to Waldo timed out!')
+        rescue => exc
+          handle_error("Something went wrong uploading symbols to Waldo: #{exc.inspect.to_s}")
+        ensure
+          request.body_stream.close if request && request.body_stream
+        end
+      end
+
+      def self.validate_parameters(params)
+        @apk_path = params[:apk_path]
+        @app_path = params[:app_path]
+        @dsym_path = params[:dsym_path]
+        @ipa_path = params[:ipa_path]
+        @upload_token = params[:upload_token]
+        @variant_name = params[:variant_name]
+
+        unless @upload_token
+          handle_error('You must pass a nonempty upload token to the Waldo action')
+
+          return false
+        end
+
+        case get_platform
+        when :android
+          unless @apk_path
+            handle_error('You must pass an APK path to the Waldo action')
+
+            return false
+          end
+
+          unless File.exist?(@apk_path)
+            handle_error("Unable to find APK at path '#{@apk_path.to_s}'")
+
+            return false
+          end
+
+          unless File.file?(@apk_path) && File.readable?(@apk_path)
+            handle_error("Unable to read APK at path '#{@apk_path.to_s}'")
+
+            return false
+          end
+        when :ios
+          unless @app_path || @ipa_path
+            handle_error('You must pass an IPA or app path to the Waldo action')
+
+            return false
+          end
+
+          if @app_path
+            unless File.exist?(@app_path)
+              handle_error("Unable to find app at path '#{@app_path.to_s}'")
+
+              return false
+            end
+
+            unless File.directory?(@app_path) && File.readable?(@app_path)
+              handle_error("Unable to read app at path '#{@app_path.to_s}'")
+
+              return false
+            end
+          elsif @ipa_path
+            unless File.exist?(@ipa_path)
+              handle_error("Unable to find IPA at path '#{@ipa_path.to_s}'")
+
+              return false
+            end
+
+            unless File.file?(@ipa_path) && File.readable?(@ipa_path)
+              handle_error("Unable to read IPA at path '#{@ipa_path.to_s}'")
+
+              return false
+            end
+          end
+
+          if @dsym_path
+            unless File.exist?(@dsym_path)
+              handle_error("Unable to find symbols at path '#{@dsym_path.to_s}'")
+
+              return false
+            end
+
+            unless (File.directory?(@dsym_path) || File.file?(@dsym_path)) && File.readable?(@dsym_path)
+              handle_error("Unable to read symbols at path '#{@dsym_path.to_s}'")
+
+              return false
+            end
+          end
         else
-          UI.error("Build failed to upload to Waldo: #{response.code} #{response.message}")
+            handle_error("Unsupported platform: '#{get_platform.to_s}'")
+
+            return false
+        end
+
+        if @variant_name && @variant_name.empty?
+          handle_error('Empty variant name for Waldo given')
+
+          return false
+        end
+
+        return true
+      end
+
+      def self.zip(src_path:, zip_path:, cd_path:)
+        unless FastlaneCore::CommandExecutor.which('zip')
+            handle_error("Command not found: 'zip'")
+
+            return false
         end
+
+        FileUtils.cd(cd_path) do
+          cmd = %(zip -qry "#{zip_path}" "#{src_path}")
+
+          result = Actions.sh(cmd, log: false)
+
+          puts "#{cmd} => #{result}" if FastlaneCore::Globals.verbose?
+
+          unless result.empty?
+            handle_error("Unable to zip folder at path '#{src_path.to_s}' into '#{zip_path.to_s}'")
+
+            return false
+          end
+        end
+
+        return true
       end
     end
 

data/lib/fastlane/plugin/waldo/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Waldo
-    VERSION = "1.2.0"
+    VERSION = "1.6.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-waldo
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - J. G. Pusey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-30 00:00:00.000000000 Z
+date: 2020-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Upload build to Waldo