highway 0.0.1 → 1.0.1

data/lib/highway/steps/library/appstore.rb

@@ -0,0 +1,137 @@
+#
+# appstore.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+
+require "highway/steps/infrastructure"
+
+module Highway
+    module Steps
+      module Library
+
+        class AppStoreStep < Step
+
+          def self.name
+            "appstore"
+          end
+
+          def self.parameters
+            [
+              Parameters::Single.new(
+                name: "app_identifier",
+                required: true,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "build_number",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "force",
+                required: false,
+                default: true,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "metadata_path",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "password",
+                required: true,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "session",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "screenshots_path",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "skip_app_version_update",
+                required: false,
+                default: false,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "skip_binary_upload",
+                required: false,
+                default: false,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "submit_for_review",
+                required: false,
+                default: false,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "team_id",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "team_name",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "username",
+                required: true,
+                type: Types::String.regex(/^\S+@\S+\.\S+$/)
+              )
+            ]
+          end
+
+          def self.run(parameters:, context:, report:)
+
+            username = parameters["username"]
+            password = parameters["password"]
+            session = parameters["session"]
+            app_identifier = parameters["app_identifier"]
+            metadata_path = parameters["metadata_path"]
+            screenshots_path = parameters["screenshots_path"]
+            skip_app_version_update = parameters["skip_app_version_update"]
+            submit_for_review = parameters["submit_for_review"]
+            team_id = parameters["team_id"]
+            team_name = parameters["team_name"]
+            skip_binary_upload = parameters["skip_binary_upload"]
+            force = parameters["force"]
+            build_number = parameters["build_number"]
+
+            env = {
+              "FASTLANE_PASSWORD" => password,
+              "FASTLANE_SESSION" => session
+            }
+
+            context.with_modified_env(env) {
+              context.run_action("upload_to_app_store", options: {
+                username: username,
+                app_identifier: app_identifier,
+                metadata_path: metadata_path,
+                screenshots_path: screenshots_path,
+                skip_app_version_update: skip_app_version_update,
+                submit_for_review: submit_for_review,
+                team_id: team_id,
+                skip_binary_upload: skip_binary_upload,
+                build_number: build_number,
+                team_name: team_name,
+                force: force
+              })
+            }
+  
+          end
+
+        end
+
+      end
+    end
+end

data/lib/highway/steps/library/carthage.rb

@@ -0,0 +1,67 @@
+#
+# carthage.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class CarthageStep < Step
+
+        def self.name
+          "carthage"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "command",
+              required: false,
+              type: Types::Enum.new("bootstrap", "update"),
+              default: "bootstrap",
+            ),
+            Parameters::Single.new(
+              name: "github_token",
+              required: false,
+              type: Types::String.new(),
+            ),
+            Parameters::Single.new(
+              name: "platforms",
+              required: true,
+              type: Types::Set.new(Types::Enum.new("macos", "ios", "tvos", "watchos")),
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+
+          context.assert_executable_available!("carthage")
+
+          command = parameters["command"]
+          token = parameters["github_token"]
+
+          platform_map = {macos: "Mac", ios: "iOS", tvos: "tvOS", watchos: "watchOS"}
+          platform = parameters["platforms"].to_a.map { |p| platform_map[p.to_sym] }.join(",")
+
+          env = {
+            "GITHUB_ACCESS_TOKEN" => token
+          }
+
+          context.with_modified_env(env) {
+            context.run_action("carthage", options: {
+              cache_builds: true,
+              command: command,
+              platform: platform,
+            })
+          }
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/library/cocoapods.rb

@@ -0,0 +1,76 @@
+#
+# cocoapods.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class CocoaPodsStep < Step
+
+        def self.name
+          "cocoapods"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "command",
+              required: false,
+              type: Types::Enum.new("install", "update"),
+              default: "install",
+            ),
+            Parameters::Single.new(
+              name: "update_specs_repo",
+              required: false,
+              type: Types::Enum.new("always", "never", "on-error"),
+              default: "never",
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+
+          context.assert_gem_available!("cocoapods")
+
+          command = parameters["command"]
+          update_specs_repo = parameters["update_specs_repo"]
+
+          repo_update_always = update_specs_repo == "always"
+          repo_update_on_error = update_specs_repo == "on-error"
+
+          if command == "install"
+
+            context.run_action("cocoapods", options: {
+              repo_update: repo_update_always,
+              try_repo_update_on_error: repo_update_on_error,
+              use_bundle_exec: context.should_use_bundle_exec?,
+            })
+
+          elsif command == "update"
+
+            invocation = []
+            invocation << "bundle exec" if context.should_use_bundle_exec?
+            invocation << "pod update"
+            invocation << "--repo-update" if repo_update_always
+
+            context.run_sh(invocation.join(" "), on_error: lambda { |error|
+              if repo_update_on_error
+                context.run_sh((invocation + ["--repo-update"]).join(" "))
+              else
+                context.reporter.fatal!(error)
+              end
+            })
+
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/library/copy_artifacts.rb

@@ -0,0 +1,36 @@
+#
+# copy_artifacts.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+    module Steps
+      module Library
+  
+        class CopyArtifactsStep < Step
+  
+          def self.name
+            "copy_artifacts"
+          end
+  
+          def self.parameters
+            [
+              Parameters::Single.new(
+                name: "path",
+                required: true,
+                type: Types::String.new(),
+              )
+            ]
+          end
+  
+          def self.run(parameters:, context:, report:)
+            FileUtils.copy_entry(context.artifacts_dir, parameters["path"], false, false, false)
+          end
+  
+        end
+  
+      end
+    end
+  end

data/lib/highway/steps/library/lane.rb

@@ -0,0 +1,42 @@
+#
+# lane.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class LaneStep < Step
+
+        def self.name
+          "lane"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "name",
+              required: true,
+              type: Types::String.new(),
+            ),
+            Parameters::Single.new(
+              name: "options",
+              required: false,
+              type: Types::Hash.new(Types::Any.new()),
+              default: {},
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+          context.run_lane(parameters["name"], options: parameters["options"])
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/library/sh.rb

@@ -0,0 +1,36 @@
+#
+# sh.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class ShStep < Step
+
+        def self.name
+          "sh"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "command",
+              required: true,
+              type: Types::String.new(),
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+          context.run_sh(parameters["command"])
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/library/slack.rb

@@ -0,0 +1,381 @@
+#
+# slack.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+require "slack-notifier"
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class SlackStep < Step
+
+        def self.name
+          "slack"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "avatar",
+              required: false,
+              type: Types::AnyOf.new(
+                url: Types::Url.new(),
+                emoji: Types::String.regex(/\:[a-z0-9_-]+\:/),
+              ),
+            ),
+            Parameters::Single.new(
+              name: "channel",
+              required: true,
+              type: Types::String.regex(/#[a-z0-9_-]+/)
+            ),
+            Parameters::Single.new(
+              name: "username",
+              required: false,
+              type: Types::String.new(),
+              default: "Highway",
+            ),
+            Parameters::Single.new(
+              name: "webhook",
+              required: true,
+              type: Types::Url.new(),
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+
+          username = parameters["username"]
+          webhook = parameters["webhook"].to_s
+          avatar_emoji = parameters["avatar"][:value] if parameters["avatar"]&[:tag] == :emoji
+          avatar_url = parameters["avatar"][:value].to_s if parameters["avatar"]&[:tag] == :url
+
+          attachments = [
+            generate_build_attachments(context),
+            generate_tests_attachments(context),
+            generate_deployment_attachments(context),
+          ]
+
+          attachments = attachments.flatten.compact
+
+          attachments.each { |attachment|
+            attachment[:mrkdwn_in] = [:text, :fields]
+            attachment[:fallback] ||= attachment.fetch(:fields, []).reduce([]) { |memo, field| memo + ["#{field[:title]}: #{field[:value]}."] }.join(" ")
+          }
+
+          attachments.each { |attachment|
+            attachment[:fields].each { |field| field[:value] = Slack::Notifier::Util::LinkFormatter.format(field[:value]) }
+            attachment[:fallback] = Slack::Notifier::Util::LinkFormatter.format(attachment[:fallback])
+          }
+
+          notifier = Slack::Notifier.new(webhook)
+
+          notifier.post({
+            username: username,
+            icon_emoji: avatar_emoji,
+            icon_url: avatar_url,
+            attachments: attachments,
+          })
+
+          context.interface.success("Successfully posted a report message on Slack.")
+
+        end
+
+        private
+
+        def self.generate_build_attachments(context)
+
+          # Generate main field containing information about build status
+          # and its identifier.
+
+          main_title = context.reports_any_failed? ? "Build failed" : "Build succeeded"
+
+          if context.env.ci?
+            if context.env.ci_build_number != nil
+              if context.env.ci_build_url != nil
+                main_value = "[#{context.env.ci_build_number}](#{context.env.ci_build_url})"
+              else
+                main_value = "#{context.env.ci_build_number}"
+              end
+            else
+              main_value = "(unknown build)"
+            end
+          else
+            main_value = "(local build)"
+          end
+
+          # Generate duration field, rounding and ceiling it to minutes, if
+          # possible.
+
+          duration_title = "Duration"
+
+          if context.duration_so_far > 60
+            duration_value = "#{(context.duration_so_far.to_f / 60).ceil} minutes"
+          else
+            duration_value = "#{context.duration_so_far} seconds"
+          end
+
+          # Generate pull request field, containing number, title and a URL,
+          # if possible.
+
+          pr_title = "Pull Request"
+
+          if context.env.ci_trigger == :pr && context.env.git_pr_number != nil
+            if context.env.git_pr_url != nil
+              if context.env.git_pr_title != nil
+                pr_value = "[##{context.env.git_pr_number}: #{context.env.git_pr_title}](#{context.env.git_pr_url})"
+              else
+                pr_value = "[##{context.env.git_pr_number}](#{context.env.git_pr_url})"
+              end
+            else
+              if context.env.git_pr_title != nil
+                pr_value = "##{context.env.git_pr_number}: #{context.env.git_pr_title}"
+              else
+                pr_value = "##{context.env.git_pr_number}"
+              end
+            end
+          end
+
+          # Generate commit field, containing hash, message and a URL, if
+          # possible.
+
+          commit_title = "Commit"
+
+          if context.env.git_commit_hash != nil
+            if context.env.git_commit_message != nil
+              commit_value = "#{context.env.git_commit_hash[0,7]}: #{context.env.git_commit_message}"
+            else
+              commit_value = "#{context.env.git_commit_hash}"
+            end
+          end
+
+          # Infer the attachment color.
+
+          attachment_color = context.reports_any_failed? ? "danger" : "good"
+
+          # Assemble the attachment.
+
+          attachment_fields = []
+          attachment_fields << {title: main_title, value: main_value, short: true} if main_value != nil
+          attachment_fields << {title: duration_title, value: duration_value, short: true} if duration_value != nil
+          attachment_fields << {title: pr_title, value: pr_value, short: false} if pr_value != nil
+          attachment_fields << {title: commit_title, value: commit_value, short: false} if commit_value != nil
+
+          {
+            color: attachment_color,
+            fields: attachment_fields,
+          }
+
+        end
+
+        def self.generate_tests_attachments(context)
+
+          # Skip if there are no test reports.
+
+          report = prepare_tests_report(context)
+          return nil unless report != nil
+
+          # Prepare variables.
+
+          result = :error if !report[:errors].empty?
+          result ||= :failure if !report[:failures].empty?
+          result ||= :success
+
+          errors = report[:errors]
+          failures = report[:failures]
+          count = report[:count]
+
+          # Generate main field containing the information about the result and
+          # counts of all, successful and failed tests.
+
+          main_title = case result
+            when :success then "Tests succeeded"
+            when :failure, :error then "Tests failed"
+          end
+
+          main_value = "Executed #{count[:all]} tests: #{count[:succeeded]} succeeded, #{count[:failed]} failed."
+
+          # Generate errors field containing first three error locations and
+          # reasons.
+
+          unless errors.empty?
+
+            errors_title = "Compile errors"
+
+            errors_messages = errors.first(3).map { |error|
+              if error[:location]
+                "```#{error[:location]}: #{error[:reason]}```"
+              else
+                "```#{error[:reason]}```"
+              end
+            }
+
+            errors_value = errors_messages.join("\n")
+            errors_value << "\nand #{errors.count - 3} more..." if errors.count > 3
+
+          end
+
+          # Generate failures field containing first three failure locations and
+          # reasons.
+
+          unless failures.empty?
+
+            failures_title = "Failing test cases"
+
+            failures_messages = failures.first(3).map { |failure|
+              "```#{failure[:location]}: #{failure[:reason]}```"
+            }
+
+            failures_value = failures_messages.join("\n")
+            failures_value << "\nand #{failures.count - 3} more..." if failures.count > 3
+
+          end
+
+          # Generate the fallback value.
+
+          attachment_fallback = case result
+            when :success then "Tests succeeded. #{main_value}"
+            when :failure then "Tests failed. #{main_value}"
+            when :error then "Tests failed. One or more compiler errors occured."
+          end
+
+          # Infer the attachment color.
+
+          attachment_color = case result
+            when :success then "good"
+            when :failure, :error then "danger"
+          end
+
+          # Assemble the attachment.
+
+          attachment_fields = []
+          attachment_fields << {title: main_title, value: main_value, short: false} if main_value != nil
+          attachment_fields << {title: errors_title, value: errors_value, short: false} if errors_value != nil
+          attachment_fields << {title: failures_title, value: failures_value, short: false} if failures_value != nil
+
+          {
+            color: attachment_color,
+            fields: attachment_fields,
+            fallback: attachment_fallback,
+          }
+
+        end
+
+        def self.prepare_tests_report(context)
+
+          return nil if context.test_reports.empty?
+
+          zero_report = {
+            errors: [],
+            failures: [],
+            count: {all: 0, failed: 0, succeeded: 0}
+          }
+
+          merged_results = context.test_reports.map { |report|
+            report[:result]
+          }
+
+          merged_report = context.test_reports.reduce(zero_report) { |memo, report|
+            {
+              errors: memo[:errors] + report[:test][:errors],
+              failures: memo[:failures] + report[:test][:failures],
+              count: {
+                all: memo[:count][:all] + report[:test][:count][:all],
+                failed: memo[:count][:failed] + report[:test][:count][:failed],
+                succeeded: memo[:count][:succeeded] + report[:test][:count][:succeeded],
+              }
+            }
+          }
+
+          merged_report[:result] = merged_results.each_cons(2) { |lhs, rhs|
+            if lhs == :error || rhs == :error
+              :error
+            elsif lhs == :failure || rhs == :failure
+              :failure
+            elsif lhs == :succeess && rhs == :success
+              :success
+            else
+              :failure
+            end
+          }
+
+          merged_report
+
+        end
+
+        def self.generate_deployment_attachments(context)
+
+          # Skip if there are no  deployment reports.
+
+          reports = context.deployment_reports
+          return nil if reports.empty?
+
+          # Map reports into attachments.
+
+          attachments = reports.map { |report|
+            prepare_deployment_attachment(report[:deployment])
+          }
+
+          attachments
+
+        end
+
+        def self.prepare_deployment_attachment(report)
+
+          # Generate main field containing the information about deployment
+          # result and information.
+
+          main_title = "Deployment succeeded"
+
+          package_comps = []
+          package_comps << report[:package][:name]
+          package_comps << report[:package][:version]
+          package_comps << "(#{report[:package][:build]})" if report[:package][:build] != nil
+
+          package_value = package_comps.compact.join(" ").strip
+          package_value = "(unknown package)" if package_value.empty?
+
+          main_value = "Successfully deployed #{package_value} to #{report[:service]}."
+
+          # Generate install button pointing to the installation page.
+
+          install_title = "Install"
+          install_url = report[:urls][:install]
+
+          # Generate manage button pointing to the view page.
+
+          view_title = "View"
+          view_url = report[:urls][:view]
+
+          # Generate the attachment fallback value and color.
+
+          attachment_fallback = "Deployment succeeded. #{main_value}"
+          attachment_color = "good"
+
+          # Assemble the attachment.
+
+          attachment_fields = []
+          attachment_fields << {title: main_title, value: main_value, short: false} if main_value != nil
+
+          attachment_actions = []
+          attachment_actions << {type: "button", style: "primary", text: install_title, url: install_url} if install_url != nil
+          attachment_actions << {type: "button", style: "default", text: view_title, url: view_url} if view_url != nil
+
+          {
+            color: attachment_color,
+            fields: attachment_fields,
+            actions: attachment_actions,
+            fallback: attachment_fallback,
+          }
+
+        end
+
+      end
+
+    end
+  end
+end