highway 0.0.1 → 1.0.1

data/lib/highway/main.rb

@@ -0,0 +1,173 @@
+#
+# main.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+
+require "highway/compiler/suite"
+require "highway/environment"
+require "highway/interface"
+require "highway/runtime/context"
+require "highway/runtime/runner"
+require "highway/steps/registry"
+
+module Highway
+
+  # This class is a main entry point to Highway.
+  class Main
+
+    public
+
+    # Initialize an instance.
+    #
+    # @param entrypoint [Symbol] The entry point.
+    # @param path [String] Path to the configuration file.
+    # @param preset [String] Preset to run.
+    # @param fastlane_runner [Fastlane::Runner] The fastlane runner.
+    # @param fastlane_lane_context [Hash] The fastlane lane context.
+    def initialize(entrypoint:, path:, preset:, fastlane_runner:, fastlane_lane_context:)
+      @entrypoint = entrypoint
+      @path = path
+      @preset = preset
+      @fastlane_runner = fastlane_runner
+      @fastlane_lane_context = fastlane_lane_context
+    end
+
+    # Run Highway.
+    #
+    # @return [Void]
+    def run()
+
+      # Always run Highway in the root directory of the project. This should
+      # standardize the legacy directory behavior described here:
+      # https://docs.fastlane.tools/advanced/fastlane/#directory-behavior.
+
+      Dir.chdir(running_dir) do
+
+        # Print the header, similar to Fastlane's "driving the lane".
+
+        interface.success("Driving the Highway preset '#{@preset}' 🏎")
+
+        # Construct a steps registry and load steps from the default library
+        # by requiring files in `highway/steps/library` and registering all
+        # classes that inherit from `Highway::Steps::Step`.
+
+        registry = Steps::Registry.new_and_load_default_library()
+
+        # Set up the compiler and compile Highway configuration file into the
+        # build manifest. See `highway/compiler/parse`, `highway/compiler/analyze`
+        # and `highway/compiler/build` for more information.
+
+        compiler = Compiler::Suite.new(
+          registry: registry,
+          interface: interface,
+        )
+
+        manifest = compiler.compile(
+          path: File.expand_path(@path, running_dir),
+          preset: @preset,
+        )
+
+        # At this point the compilation is done. Now, construct the runtime
+        # context, set up the runner and run the compiled build manifest.
+
+        context = Runtime::Context.new(
+          fastlane_runner: @fastlane_runner,
+          fastlane_lane_context: @fastlane_lane_context,
+          env: env,
+          interface: interface,
+        )
+
+        runner = Runtime::Runner.new(
+          manifest: manifest,
+          context: context,
+          interface: interface,
+        )
+
+        runner.run()
+
+        # We can safely print the success summary message because fatal errors
+        # will be catched by the rescue block below.
+
+        @interface.whitespace()
+        @interface.success("Wubba lubba dub dub, Highway preset '#{@preset}' has succeeded!")
+
+      end
+
+    rescue StandardError => error
+
+      # Unless the error contains any message we should print it right now but
+      # as an error so that we can still control the output.
+
+      interface.error(error) unless error.message.empty?
+
+      # We should take care of the unnecessary printing of Fastlane lane
+      # context but only if we're running from lane entry point (otherwise we
+      # could affect other actions and fallback lanes user has set up).
+      #
+      # So, if we're running from lane entry point, we should clear the lane
+      # context before raising a fatal error. If we're in verbose mode, we
+      # should additionally print it before cleaning.
+
+      if @entrypoint == :lane
+        report_fastlane_lane_context() if env.verbose?
+        clear_fastlane_lane_context()
+      end
+
+      # Now we throw a fatal error that tells Fastlane to abort.
+
+      interface.whitespace()
+      interface.fatal!("Highway preset '#{@preset}' has failed with one or more errors. Please examine the above log.")
+
+    end
+
+    private
+
+    # The environment instance.
+    #
+    # @return [Highway::Environment]
+    def env
+      @env ||= Environment.new()
+    end
+
+    # The interface instance.
+    #
+    # @return [Highway::Interface]
+    def interface
+      @interface ||= Interface.new()
+    end
+
+    # The running directory to be used.
+    #
+    # @return [Path]
+    def running_dir
+      File.expand_path(File.join(FastlaneCore::FastlaneFolder.path, ".."))
+    end
+
+    # Report Fastlane lane context as a table.
+    #
+    # @return [Void]
+    def report_fastlane_lane_context()
+
+      lane_context_rows = @fastlane_lane_context.collect do |key, content|
+        [key, content.to_s]
+      end
+
+      interface.table(
+        title: "Fastlane Context".yellow,
+        rows: lane_context_rows
+      )
+
+    end
+
+    # Clear all values in Fastlane lane context.
+    #
+    # @return [Void]
+    def clear_fastlane_lane_context()
+      @fastlane_lane_context.clear()
+    end
+
+  end
+
+end

data/lib/highway/runtime/context.rb

@@ -0,0 +1,229 @@
+#
+# context.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+
+require "highway/utilities"
+
+module Highway
+  module Runtime
+
+    # This class is responsible for maintaining runtime context between step
+    # invocations, allowing steps to access runtimes of both Fastlane and
+    # Highway.
+    class Context
+
+      public
+
+      # Initialize an instance.
+      #
+      # @param fastlane_runner [Fastlane::Runner] The Fastlane runner.
+      # @param fastlane_lane_context [Hash] The Fastlane lane context.
+      # @param env [Highway::Runtime::Environment] The runtime environment.
+      # @param reporter [Highway::Interface] The interface.
+      def initialize(fastlane_runner:, fastlane_lane_context:, env:, interface:)
+        @fastlane_runner = fastlane_runner
+        @fastlane_lane_context = fastlane_lane_context
+        @env = env
+        @interface = interface
+        @reports = Array.new()
+      end
+
+      # @!group Context and environment
+
+      # The environment of the runtime context.
+      #
+      # @return [Highway::Runtime::Environment]
+      attr_reader :env
+
+      # The Fastlane lane context.
+      #
+      # @return [Hash]
+      attr_reader :fastlane_lane_context
+
+      # The interface.
+      #
+      # @return [Highway::Interface]
+      attr_reader :interface
+
+      # The path to directory containing artifacts.
+      #
+      # @return [String]
+      def artifacts_dir
+        File.join(File.expand_path(FastlaneCore::FastlaneFolder.path), "highway")
+      end
+
+      # Execute the given block in the scope of overridden ENV variables. After
+      # that, old values will be restored.
+      #
+      # @param new_env [Hash] ENV variables to override.
+      # @param &block [Proc] A block to execute.
+      def with_modified_env(new_env, &block)
+
+        old_env = Utilities::hash_map(new_env.keys) { |name|
+          [name, ENV[name]]
+        }
+
+        new_env.each_pair { |name, value|
+          ENV[name] = value
+        }
+
+        block.call()
+
+        old_env.each_pair { |name, value|
+          ENV[name] = value
+        }
+
+      end
+
+      # @!group Reports
+
+      # All reports in the runtime context.
+      #
+      # @return [Array<Highway::Runtime::Report>]
+      attr_reader :reports
+
+      # Add a runtime report to the context.
+      #
+      # @param report [Highway::Runtime::Report] The report.
+      #
+      # @return [Void]
+      def add_report(report)
+        @reports << report
+      end
+
+      # Whether any of the previous reports failed.
+      #
+      # @return [Boolean]
+      def reports_any_failed?
+        @reports.any? { |report| report.result == :failure }
+      end
+
+      # Total duration of all previous reports.
+      #
+      # @return [Numeric]
+      def duration_so_far
+        @reports.reduce(0) { |memo, report| memo + report.duration }
+      end
+
+      # Reports containing information about tests.
+      #
+      # @return [Array<Highway::Runtime::Report>]
+      def test_reports
+        @reports.select { |report| report[:test] != nil }
+      end
+
+      # Reports containing information about archives.
+      #
+      # @return [Array<Highway::Runtime::Report>]
+      def archive_reports
+        @reports.select { |report| report[:archive] != nil }
+      end
+
+      # Reports containing information about deployments.
+      #
+      # @return [Array<Highway::Runtime::Report>]
+      def deployment_reports
+        @reports.select { |report| report[:deployment] != nil }
+      end
+
+      # @!group Assertions
+
+      # Assert that a gem with specified name is available.
+      #
+      # @param name [String] Name of the gem.
+      def assert_gem_available!(name)
+        Fastlane::Actions.verify_gem!(name)
+      end
+
+      # Assert that an executable with specified name is available.
+      #
+      # @param name [String] Name of executable.
+      def assert_executable_available!(name)
+        unless FastlaneCore::CommandExecutor.which(name) != nil
+          @interface.fatal!("Required executable '#{name}' could not be found. Make sure it's installed.")
+        end
+      end
+
+      # @!group Interfacing with Fastlane
+
+      # Run a Fastlane lane.
+      #
+      # @param name [String, Symbol] Name of the lane.
+      # @param options [Hash] Options passed to the lane.
+      def run_lane(name, options:)
+
+        unless contains_lane?(name)
+          @interface.fatal!("Can't execute lane '#{name}' because it doesn't exist.")
+        end
+
+        unless !contains_action?(name)
+          @interface.fatal!("Can't execute lane '#{name}' because an action with the same name exists.")
+        end
+
+        run_lane_or_action(name, options)
+
+      end
+
+      # Run a Fastlane action.
+      #
+      # @param name [String, Symbol] Name of the action.
+      # @param options [Hash] Options passed to the action.
+      def run_action(name, options:)
+
+        unless contains_action?(name)
+          @interface.fatal!("Can't execute action '#{name}' because it doesn't exist.")
+        end
+
+        unless !contains_lane?(name)
+          @interface.fatal!("Can't execute action '#{name}' because a lane with the same name exists.")
+        end
+
+        run_lane_or_action(name, options)
+
+      end
+
+      # @!group Interfacing with shell
+
+      # Whether `bundle exec` is available and should be used if possible.
+      #
+      # @return [Boolean]
+      def should_use_bundle_exec?
+        return File.exist?("Gemfile")
+      end
+
+      # Run a shell command.
+      #
+      # @param command [String, Array] A shell command.
+      # @param bundle_exec [Boolean] Whether to use `bundle exec` if possible.
+      # @param silent [Boolean] Whether to run the command silently.
+      # @param on_error [Proc] Called if command exits with a non-zero code.
+      def run_sh(command, bundle_exec: false, silent: false, rescue_error: nil)
+        command = ["bundle exec", command].flatten if bundle_exec && should_use_bundle_exec?
+        Fastlane::Actions.sh(command, log: !silent, error_callback: rescue_error)
+      end
+
+      private
+
+      def contains_lane?(lane_name)
+        lane = @fastlane_runner.lanes.fetch(nil, {}).fetch(lane_name.to_sym, nil)
+        lane != nil
+      end
+
+      def contains_action?(action_name)
+        action = @fastlane_runner.class_reference_from_action_name(action_name.to_sym)
+        action ||= @fastlane_runner.class_reference_from_action_alias(action_name.to_sym)
+        action != nil
+      end
+
+      def run_lane_or_action(name, args)
+        symbolicated_args = Utilities::hash_map(args || {}) { |key, value| [key.to_sym, value] }
+        @fastlane_runner.trigger_action_by_name(name.to_sym, Dir.pwd, true, *[symbolicated_args])
+      end
+
+    end
+
+  end
+end

data/lib/highway/runtime/report.rb

@@ -0,0 +1,80 @@
+#
+# report.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Runtime
+
+    # This class represents a report of running a step during runtime. It
+    # contains metrics (such as status and duration) as well as metadata set by
+    # steps themselves.
+    class Report
+
+      # Initialize an instance.
+      #
+      # @param invocation [Highway::Compiler::Build::Output::Invocation] The invocation.
+      # @param artifacts_dir [Path] Dir in which to prepare artifacts.
+      def initialize(invocation:, artifacts_dir:)
+        @invocation = invocation
+        @artifacts_dir = artifacts_dir
+        @data = Hash.new()
+      end
+
+      # The invocation.
+      #
+      # @return [Highway::Compiler::Build::Output::Invocation]
+      attr_accessor :invocation
+
+      # Result of the step, one of: `:success`, `:failure`, `:skip`.
+      #
+      # @return [Symbol]
+      attr_accessor :result
+
+      # An error that the step failed with, if any.
+      #
+      # @return [FastlaneCore::Interface::FastlaneException, nil]
+      attr_accessor :error
+
+      # Duration of the step, in seconds.
+      #
+      # @return [Numeric]
+      attr_accessor :duration
+
+      # The custom data in the report.
+      #
+      # @return [Hash]
+      attr_reader :data
+
+      # Get custom data value for given key.
+      #
+      # @param key [String] A key.
+      #
+      # @return [Object, nil]
+      def [](key)
+        @data[key]
+      end
+
+      # Set custom data value for given key.
+      #
+      # @param key [String] A key.
+      # @param value [Object, nil] A value.
+      #
+      # @return [Void]
+      def []=(key, value)
+        @data[key] = value
+      end
+
+      # Prepare an artifact file with a given name and return its path.
+      #
+      # @param name [String] An artifact file name.
+      #
+      # @return [String]
+      def prepare_artifact(name)
+        File.join(@artifacts_dir, "#{invocation.identifier}-#{name}")
+      end
+
+    end
+
+  end
+end