rbt 0.15.1 → 0.16.13

data/lib/rbt/actions/individual_actions/software_manager/logic_related_code.rb

@@ -0,0 +1,2421 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file will contain the most important logic-parts of
+# class SoftwareManager.
+# =========================================================================== #
+# require 'rbt/actions/individual_actions/software_manager/logic_related_code.rb'
+# =========================================================================== #
+require 'rbt/actions/action.rb'
+
+module RBT
+
+class Action
+
+class SoftwareManager < RBT::Action # === RBT::Action::SoftwareManager
+
+  # ========================================================================== #
+  # === try_do_determine_which_programs_have_to_be_installed
+  # ========================================================================== #
+  def try_do_determine_which_programs_have_to_be_installed(
+      first_argument = first_argument?
+    )
+    if first_argument.nil? or first_argument.empty?
+      orev 'Please provide the name of the program that is '\
+           'to be installed.'
+    else
+      _ = first_argument?
+      unless _.start_with?('--')
+        if _.include? '@'
+          # ================================================================== #
+          # In this case we have input such as htop@2.2.3.
+          # If this is the case then we will not do any sanitizing at all.
+          # ================================================================== # 
+        else
+          # ================================================================== #
+          # Now we have to improve on the first argument given. This will try
+          # to use all abbreviations, for instance.
+          # ================================================================== #
+          _ = action(:sanitize_this_program_name, _)
+        end
+        set_install_these_programs(_)
+      end
+    end
+  end
+
+  # ========================================================================== #
+  # === run_traditional_GNU_configure
+  #
+  # This method will ultimately run the "./configure" command, with an
+  # appropriate prefix to be used.
+  # ========================================================================== #
+  def run_traditional_GNU_configure(
+      use_this_configure_command = use_this_configure_command?
+    )
+    _ = ''.dup
+    # ======================================================================== #
+    # First check whether we really want to run the configure script:
+    # ======================================================================== #
+    return unless run_configure_script?
+    if use_this_configure_command.nil?
+      # ====================================================================== #
+      # Add the configure-command that is to be used next, if this is
+      # specified in the cookbook .yml file at hand. For example,
+      # 'bc' requires the command './configure.sh' rather than
+      # 'configure'. 
+      # ====================================================================== #
+      use_this_configure_command = cookbook_dataset_configure_command_to_use?
+    end
+    case use_this_configure_command
+    when /^configure/
+      # ====================================================================== #
+      # The next line exists due to programs such as discount.yml needing
+      # a configure-command like: ./configure.sh
+      # It may no longer be necessary as of March 2024.
+      # ====================================================================== #
+      # _ << '.'
+      _.prepend('./')
+    end
+    # ======================================================================== #
+    # Append the configure-base-directory value next. However had, I am
+    # not sure whether this is correct in April 2021. We'll comment it
+    # out for now; once we know more, we may re-add this again.
+    # ======================================================================== #
+    # _ << configure_base_directory?.dup
+    _ << "#{use_this_configure_command}"
+    # ======================================================================== #
+    # The following _.include? check is valid for e. g. applications
+    # such as "lsof".
+    # ======================================================================== #
+    if do_we_use_any_prefix?
+      use_this_prefix = prefix?.to_s
+      RBT.set_last_prefix_used(use_this_prefix)
+      _ << " --prefix=#{use_this_prefix}".dup unless _.include? './Configure -n linux'
+    end
+    # ======================================================================== #
+    # === Obtain the configure-options next
+    #
+    # The following two checks, wrapped in one if-clause, are necessary,
+    # due to the following two reasons:
+    #
+    #   - The user may not want to append any configure-options in
+    #     the first place. Hence, we must check for this via
+    #     the method use_configure_options?.
+    #
+    #   - Second, the user may also input a command such as "ry sed-4.5",
+    #     and in this case we have to work on an existing file, rather
+    #     than on the dataset in the cookbook-yaml file.
+    #
+    # ======================================================================== #
+    if use_configure_options? and cookbook_dataset?
+      configure_options = configure_options?
+      if configure_options and !configure_options.empty?
+        # ==================================================================== #
+        # Finally, append these additional commands to the
+        # configure-string:
+        # ==================================================================== #
+        _ << " #{configure_options}"
+      end
+    end
+    if use_build_directory?
+      # create_the_build_directory_then_cd_into_it { :be_verbose }
+      _.prepend('.')
+    end
+    # ======================================================================== #
+    # === Honour ccache
+    #
+    # Honour the CCACHE setting, if it has been provided. This must come
+    # after we did the _.prepend('.') call.
+    # ======================================================================== #
+    if use_ccache?
+      # ====================================================================== #
+      # Find out whether ccache is available or whether it is not. If it
+      # is we will use it, while also specifying which compiler to use.
+      # ====================================================================== #
+      if ccache_is_available?
+        if will_gcc_be_used_for_compilation?
+          _.prepend 'CC="ccache gcc" ' # In this case prepend it.
+        end
+      else # It must be available.
+        notify_the_user_that_ccache_is_not_available
+      end
+    end
+    # ======================================================================== #
+    # === Handle the ERROR_LINE next
+    #
+    # Next, we will append the ERROR_LINE, but only if the user has
+    # not overruled this on the commandline.
+    # ======================================================================== #
+    if append_shell_error_code? and !_.include?(ERROR_LINE)
+      _ << " #{ERROR_LINE}"
+    end
+    # ======================================================================== #
+    # The next line is used to turn something like:
+    #
+    #   "/Depot/Temp/rbt/discount-2.2.3a/./configure.sh"
+    #
+    # into:
+    #
+    #   "/Depot/Temp/rbt/discount-2.2.3a/configure.sh"
+    #
+    # ======================================================================== #
+    if _.include?('/./')
+      _.sub!(/\/\.\//, '/')
+    end
+    _ << " #{return_append_this_to_the_configure_options}"
+    _.strip! # Just ensure that there are no trailing ' ' characters.
+    # ======================================================================== #
+    # === Handle strange configuration options involving sysconfdir next
+    #
+    # This must come after we have appended the configure options in use.
+    # ======================================================================== #
+    if use_appdir_prefix? and _.include?('--sysconfdir=/etc')
+      regexp_quoted_old_sysconfdir_prefix = Regexp.quote('--sysconfdir=/etc')
+      rewritten_sysconfdir = '--sysconfdir='+rds(use_which_prefix?.to_s+'/etc')
+      orev 'An '+salmon('AppDir prefix')+rev+' is used, but also "'+
+           royalblue('--sysconfdir=/etc')+rev+'". This is not logical.'
+      orev 'It is now assumed that the --sysconfdir=/etc is meant to target'
+      orev "that #{salmon('AppDir prefix')}#{rev}, so it will be rewritten to"
+      orev "`#{royalblue(rewritten_sysconfdir)}#{rev}`."
+      _.sub!(/#{regexp_quoted_old_sysconfdir_prefix}/, rewritten_sysconfdir)
+    end
+    set_full_configure_command(_.dup.squeeze(' ')) # ← Keep a reference-copy too.
+    colourized_and_padded_esystem(_)
+    # reset_error_map_line_to_a_specific_error # ← Must come before the sys-command.
+    # run_this_system_command_in_a_coloured_and_padded_manner(full_configure_command?) { :also_pad_via_cliner }
+    # run_through_the_registered_problems_registered_errors_and_behaviour_changes
+    # reset_error_map_line_to_a_specific_error
+  end; alias run_the_configure_command run_traditional_GNU_configure # === run_the_configure_command
+       alias run_configure_like_stage  run_traditional_GNU_configure # === run_configure_like_stage
+       alias run_configure             run_traditional_GNU_configure # === run_configure
+       alias run_configure_via_system  run_traditional_GNU_configure # === run_configure_via_system
+
+  # ========================================================================== #
+  # === do_run_GNU_configure_then_make_then_make_install      (configure tag)
+  # ========================================================================== #
+  def do_run_GNU_configure_then_make_then_make_install(
+      use_this_configure_command = use_this_build_system?
+    )
+    if shall_we_run_configure?
+      run_traditional_GNU_configure
+    end
+    run_premake_make_then_make_install
+  end; alias run_configure_then_make_then_make_install do_run_GNU_configure_then_make_then_make_install # === run_configure_then_make_then_make_install
+       alias run_the_configure_command                 do_run_GNU_configure_then_make_then_make_install # === run_the_configure_command
+       alias run_the_gnu_configure_steps               do_run_GNU_configure_then_make_then_make_install # === run_the_gnu_configure_steps
+
+  # ========================================================================== #
+  # === run_cmake_configure_step                                  (cmake tag)
+  #
+  # This method essentially does something like:
+  #
+  #   cmake -DCMAKE_INSTALL_PREFIX=/usr ..
+  #
+  # Then it will perform:
+  #
+  #   - premake
+  #   - make
+  #   - make install
+  #
+  # ========================================================================== #
+  def run_cmake_configure_step(
+      use_this_as_build_directory = use_this_as_build_directory?
+    )
+    # ======================================================================== #
+    # We should check whether cmake exists on the host system or whether
+    # it does not.
+    # ======================================================================== #
+    if cmake_exists?
+      _ = 'cmake'.dup
+      # ====================================================================== #
+      # Add the prefix next, if the user wants to use a prefix at all:
+      # ====================================================================== #
+      if do_we_use_any_prefix? # Check whether the user wants to use a prefix at all.
+        _ << " -DCMAKE_INSTALL_PREFIX=#{prefix?}"
+      end
+      # ====================================================================== #
+      # Obtain the cmake-configure options next and append them:
+      # ====================================================================== #
+      configure_options = cmake_configure_options?
+      if configure_options and !configure_options.empty?
+        _ << " #{configure_options}"
+      end
+      _ << ' .'
+      if use_this_as_build_directory and do_we_use_a_build_directory? # Most cmake-based projects require a build-directory.
+        # create_the_build_directory_then_cd_into_it(use_this_as_build_directory) { :be_verbose }
+        _ << '.'
+      end
+      _.squeeze!(' ')
+      _.strip!
+      # ====================================================================== #
+      # === Check for more than one -DCMAKE_INSTALL_PREFIX entry next
+      #
+      # This should never be the case, so we will do some quality-control
+      # and exit if this is the case so.
+      # ====================================================================== #
+      scanned_result = _.scan(/-DCMAKE_INSTALL_PREFIX=/)
+      if scanned_result.size > 1 # More than one.
+        # ==================================================================== #
+        # In this case, something must be wrong. Notify the user about it.
+        # That way this can be corrected eventually.
+        # ==================================================================== #
+        opnewarn "There are at the least two definitions of "\
+                 "#{royalblue('-DCMAKE_INSTALL_PREFIX=')}"
+        opnewarn "in the .yml file at hand."
+        opnewarn 'At the least one of these entries must be incorrect '\
+                 'and/or superfluous. Consider '
+        opnewarn 'correcting this logic-problem before RBT can '\
+                 'continue.'
+        e
+        e 'See:'
+        e
+        e "  #{sfancy(_)}"
+        e
+        exit_program
+      end
+      # ====================================================================== #
+      # Finally the cmake-command has been built up. We can now push it
+      # towards the general method that handles output.
+      # ====================================================================== #
+      # reset_error_map_line_to_a_specific_error
+      set_full_configure_command(_)
+      cmake_object = action(:run_cmake, :do_not_run_yet) { :colourized_and_padded }
+      cmake_object.set_full_configure_line(_)
+      cmake_object.verbose_run_the_actual_system_command
+    else
+      # ====================================================================== #
+      # The user should be informed that "cmake" could not be found here.
+      # ====================================================================== #
+      notify_the_user_that_cmake_could_not_be_found
+      we_can_not_continue
+    end
+  end; alias run_cmake_command                                  run_cmake_configure_step # === run_cmake_command
+       alias run_cmake_via_action                               run_cmake_configure_step # === run_cmake_via_action
+       alias run_the_cmake_command                              run_cmake_configure_step # === run_the_cmake_command
+       alias run_cmake_then_premake_then_make_then_make_install run_cmake_configure_step # === run_cmake_then_premake_then_make_then_make_install
+       alias do_install_via_cmake                               run_cmake_configure_step # === run_cmake_then_premake_then_make_then_make_install
+
+  # ========================================================================== #
+  # === run_cmake_then_make_then_make_install
+  #
+  # Just a convenience method to run "cmake", then "make" and then
+  # "make install".
+  # ========================================================================== #
+  def run_cmake_then_make_then_make_install
+    run_cmake_configure_step
+    run_premake_then_make_then_make_install
+    # run_make
+    # run_make_install
+    # opne "#{rev}Next running"
+    # run_this_system_command_in_a_coloured_and_padded_manner(cmd) # Using this since as of 28.08.2022.
+    # ======================================================================== #
+    # Now that the cmake, premake, make, make install was run we scan
+    # through the registered problems/errors and act on it, before
+    # resetting the error-line again.
+    # ======================================================================== #
+    # run_through_the_registered_problems_registered_errors_and_behaviour_changes
+    # reset_error_map_line_to_a_specific_error
+  end; alias run_the_cmake_steps run_cmake_then_make_then_make_install # === run_the_cmake_steps
+
+  # ========================================================================== #
+  # === consider_creating_the_build_directory
+  #
+  # This method can create a build directory, that is, a directory which
+  # will keep other generated files and directories inside of it.
+  #
+  # Since as of April 2024, class BuildDirectory will handle this specific
+  # subtask.
+  # ========================================================================== #
+  def consider_creating_the_build_directory
+    build_directory_object?.consider_creating_the_build_directory_and_then_entering_it
+  end; alias consider_handling_build_directory consider_creating_the_build_directory # === consider_creating_the_build_directory
+
+  # ========================================================================== #
+  # === run_meson_configure_step                                  (meson tag)
+  #
+  # This method essentially does something like:
+  #
+  #   meson --prefix=/usr --libdir=/usr/lib BUILD_DIRECTORY
+  #
+  # In order for this to work, we must enter the directory below
+  # the build-directory.
+  # ========================================================================== #
+  def run_meson_configure_step(
+      use_this_as_build_directory = build_directory_object?.use_this_as_build_directory?
+    )
+    # ======================================================================== #
+    # Obtain the configure options for meson next:
+    # ======================================================================== #
+    if is_meson_installed?
+      set_configure_command(:meson) # Keep a back-reference here.
+      # ====================================================================== #
+      # Obtain the meson-configure options next, but only if the user
+      # has allowed us to do so.
+      # ====================================================================== #
+      if use_meson_configure_options?
+        configure_options = meson_configure_options?.to_s.strip
+        if configure_options and !configure_options.empty?
+          # ==================================================================== #
+          # Append the meson-configure options in this case.
+          # ==================================================================== #
+          orev "Making use of the #{royalblue('meson_configure_options')}#{rev}, "\
+               "#{rev}as specified by the corresponding "\
+               "#{slateblue('.yml')} #{rev}file."
+        end
+      else
+        configure_options = nil
+      end
+      # ====================================================================== #
+      # Delegate via the corresponding rbt-action:
+      # ====================================================================== #
+      use_this_prefix = prefix?
+      unless do_we_use_any_prefix?
+        use_this_prefix = nil
+      end
+      configure_options.squeeze!(' ') if configure_options
+      # ====================================================================== #
+      # We must cd one level downwards.
+      # ====================================================================== #
+      if use_build_directory?
+        build_directory_object?.cd_one_level_downwards
+      end
+      result = action(:run_meson_configure_step,
+      {
+        prefix_to_use:               use_this_prefix,
+        configure_options:           configure_options,
+        use_this_as_build_directory: use_this_as_build_directory
+      }) { :colourized_and_padded }
+      set_full_configure_command(result)
+      if use_build_directory?
+        build_directory_object?.cd_to_the_build_directory
+      end
+    else
+      orev "#{steelblue('Meson')}#{rev} is unavailable. Consider installing it."
+    end
+  end; alias run_meson_configure  run_meson_configure_step # === run_meson_configure
+       alias run_meson_via_action run_meson_configure_step # === run_meson_via_action
+
+  # ========================================================================== #
+  # === properly_prepare_the_build_directory
+  #
+  # The build directory has to be prepared anew for every program that 
+  # has to be compiled from source.
+  # ========================================================================== #
+  def properly_prepare_the_build_directory(
+      build_directory_object = build_directory_object?
+    )
+    if do_we_use_a_build_directory?
+      build_directory_object.this_is_the_build_directory = 
+        log_dir?+program_name_and_program_version?+'/'+
+        use_this_as_build_directory?
+    end
+  end
+
+  # ========================================================================== #
+  # === run_the_equivalent_configure_like_stage_for_this_program
+  # ========================================================================== #
+  def run_the_equivalent_configure_like_stage_for_this_program(
+      i = compile_which_program?
+    )
+    orev "The #{lightgreen('configure-like stage')}"\
+         "#{rev} for #{steelblue(i)}#{rev} will be invoked."
+    # ======================================================================== #
+    # Next register that we are compiling a program. This should come
+    # before we consider building the program statically.
+    # ======================================================================== #
+    register_that_this_program_is_currently_being_compiled
+    # ======================================================================== #
+    # We must next determine which configure command is to be used:
+    # ======================================================================== #
+    configure_command_to_use = configure_command_to_use?
+    # ======================================================================== #
+    # Here we have to do a decision: either we make use of the
+    # use_this_build_system specified value, or we have to infer the
+    # build system. Either way we begin this by quering the
+    # use_this_build_system value.
+    # ======================================================================== #
+    use_this_build_system = use_which_build_system? # This will always be a Symbol.
+    case use_this_build_system
+    # ======================================================================== #
+    # === :configure
+    # ======================================================================== #
+    when :configure
+      do_run_GNU_configure_then_make_then_make_install
+    # ======================================================================== #
+    # === :configure_requiring_autoconf_step
+    # ======================================================================== #
+    when :configure_requiring_autoconf_step
+      do_invoke_autoconf
+      run_the_gnu_configure_steps
+    # ======================================================================== #
+    # === waf
+    # ======================================================================== #
+    when :waf
+      run_waf_based_installation
+    # ======================================================================== #
+    # === :cmake
+    # ======================================================================== #
+    when :cmake
+      run_the_cmake_steps
+    # ======================================================================== #
+    # === :ruby
+    # ======================================================================== #
+    when :ruby
+      colourized_and_padded_esystem 'ruby setup.rb'
+    # ======================================================================== #
+    # === :perl
+    #
+    # Invocation example:
+    #
+    #   ry archivezip
+    #
+    # ======================================================================== #
+    when :perl
+      run_the_perl_steps
+    # ======================================================================== #
+    # === :meson
+    # ======================================================================== #
+    when :meson
+      # ====================================================================== #
+      # Since as of 02.10.2018, we try to use ninja here automatically,
+      # if the cookbook_dataset has a dependency on ninja.
+      # ====================================================================== #
+      if dependencies?.include? 'ninja'
+        set_use_this_make_command('ninja')
+      end
+      run_the_meson_steps
+    # ======================================================================== #
+    # === :Python
+    # ======================================================================== #
+    when :Python, :python # Can be capitalized or not.
+      run_python_installation
+    # ======================================================================== #
+    # === :Makefile
+    # ======================================================================== #
+    when :Makefile
+      run_make
+      run_make_install
+    # ======================================================================== #
+    # === :scons
+    # ======================================================================== #
+    when :scons
+      run_scons
+    # ======================================================================== #
+    # === :infer_automatically
+    # ======================================================================== #
+    when :infer_automatically
+      configure_command_to_use = configure_command_to_use?
+      # ====================================================================== #
+      # === This entry tries to handle programs such as "duktape", which
+      #     come with plenty of different "Makefile.*" files, but no
+      #     configure script. This functionality was added on February 2023.
+      # ====================================================================== #
+      if (result = Dir['Makefile.*'].size) > 1
+        orev 'Assuming a Makefile-based program, thus invoking the'
+        orev "command stored in #{steelblue('use_this_make_command:')}"\
+             "#{rev} next"
+        e
+        colourized_and_padded_esystem(use_this_make_command?)
+        e
+      # ====================================================================== #
+      # === Handle GNU configure here
+      # ====================================================================== #
+      elsif File.exist?('configure')
+        do_run_GNU_configure_then_make_then_make_install
+      # ====================================================================== #
+      # === Direct support for a configure command
+      # ====================================================================== #
+      elsif configure_command_to_use and !configure_command_to_use.empty?
+        padded_esystem(configure_command_to_use)
+      # ====================================================================== #
+      # === else handle any other case, as ... well, unhandled.
+      # ====================================================================== #
+      else
+        orev tomato('Unsure what to do with :infer_automatically.')
+        orev tomato('Exiting now, as this case must be handled via code.')
+        exit_program
+      end
+    else
+      orev tomato('Not registered build-system type: ')+
+           steelblue(use_this_build_system.to_sym)
+      orev 'No way to proceed, thus stopping now.'
+      return
+    end
+    # ======================================================================== #
+    # Next, consider performing postinstallation steps:
+    # ======================================================================== #
+    # if ignore_errors_anyway? or successfully_compiled?
+    do_handle_the_post_installation_steps # ← Postinstallation step
+    # end
+    # ======================================================================== #
+    # Next, compare the installed libraries versus the assumed
+    # libraries. This can then be used to updated the dataset.
+    # ======================================================================== #
+  end; alias find_the_corresponding_install_method_and_proceed_from_there run_the_equivalent_configure_like_stage_for_this_program # === find_the_corresponding_install_method_and_proceed_from_there
+       alias run_configure_like_stage                                     run_the_equivalent_configure_like_stage_for_this_program # === run_configure_like_stage
+
+  # ========================================================================== #
+  # === cd_to_the_build_directory
+  #
+  # This method will always delegate towards class BuildDirectory.
+  # ========================================================================== #
+  def cd_to_the_build_directory
+    build_directory_object?.cd_to_the_build_directory
+  end; alias cd_to_the_extracted_directory cd_to_the_build_directory # === cd_to_the_extracted_directory
+
+  # ========================================================================== #
+  # === determine_the_build_system_in_use_and_consider_syncing_this_back_onto_the_cookbook_dataset
+  # ========================================================================== #
+  def determine_the_build_system_in_use_and_consider_syncing_this_back_onto_the_cookbook_dataset
+    _ = build_system?
+    case _
+    # ======================================================================== #
+    # === :infer_automatically
+    # ======================================================================== #
+    when :infer_automatically
+      # ====================================================================== #
+      # In this case we have to guess the build type, before we proceed,
+      # since we have given the path to a file that exists.
+      #
+      # This code was disabled in April 2021. Let's see if we will need
+      # it again one day.
+      #
+      # In September 2022 it was re-enabled.
+      # ====================================================================== #
+      _ = action(:infer_build_system)
+      opne "#{gold('Guessing the build-type next ...')} #{rev}the build "\
+           "type is: #{slateblue(_.to_s)}" # In the past we also displayed a leading ':' here.
+      if _.nil?
+        _ = :inferring_the_build_system_did_not_work
+      else
+        _ = _.to_sym
+      end
+      # ====================================================================== #
+      # The next clause was added in June 2023 - it will force me to add
+      # all missing build-types to the .yml file at hand.
+      # ====================================================================== #
+      if is_on_roebe?
+        opne tomato('Since as of June 2023 the build-system has to be determined')
+        opne tomato('Please modify the .yml file at hand for the ')+
+             tomato('program ')+sfancy(program_name?)+tomato('.')
+        opne tomato('Exiting now.')
+        exit
+      end
+    end
+    cookbook_dataset?.set_build_system(_) # Sync it back here.
+  end
+
+  # ========================================================================== #
+  # === consider_to_run_ldconfig                               (ldconfig tag)
+  #
+  # Run 'ldconfig' here in this method.
+  #
+  # Check whether we are allowed to invoke this method before calling it
+  # however.
+  # ========================================================================== #
+  def consider_to_run_ldconfig
+    return if are_we_on_windows?
+    if continue_after_make_step? # Makes only sense if we are past the make-step.
+      # ====================================================================== #
+      # ruby and python add-ons normally do not require ldconfig,
+      # so we don't have to invoke it.
+      # ====================================================================== #
+      if tags?.include?('ruby') or
+         tags?.include?('python')
+        do_not_run_ldconfig
+      end
+      # ====================================================================== #
+      # Only run it if the config-file tells us to do so and only for
+      # those programs that have to be compiled.
+      #
+      # class RBT::Action::SoftwareManager will, however had, NOT run ldconfig when the
+      # program has failed to install - that is specifically if an
+      # error has occurred.
+      # ====================================================================== #
+      if run_ldconfig? and
+         has_to_be_compiled? and
+         can_we_continue? #and
+        #!a_problem_has_occurred? and # Also check for no problem.
+        #!an_error_has_occurred?
+        # ====================================================================== #
+        # Build up the command to run next.
+        # ====================================================================== #
+        cmd_to_run = 'ldconfig'.dup
+        # ====================================================================== #
+        # We could be verbose, but it is not that useful, so uncomment it.
+        # cmd_to_run << ' -v'
+        # ====================================================================== #
+        # Since as of July 2011, we will be quieter and ignore whether
+        # ldconfig exists or not.
+        # ====================================================================== #
+        cmd_to_run << " #{SHELL_ERROR_CODE}"
+        # ====================================================================== #
+        # Check for superuser privilege next. ldconfig requires the
+        # superuser.
+        # ====================================================================== #
+        if is_superuser?
+          orev "Now running `#{sfancy(cmd_to_run)}#{rev}`." # We output the ldconfig command variant here.
+          system cmd_to_run
+        else
+          orev "You are not the superuser so we will not "\
+               "try to run `#{sfancy(cmd_to_run)}#{rev}`."
+        end
+      end
+    end
+  end; alias consider_running_ldconfig consider_to_run_ldconfig # === consider_running_ldconfig
+
+  # ========================================================================== #
+  # === set_compile_this_program
+  # ========================================================================== #
+  def set_compile_this_program(
+      i = nil
+    )
+    if i
+      # ====================================================================== #
+      # === Handle *
+      #
+      # First we will handle the '*' substring, in any given argument.
+      #
+      # We will show to the user what programs exist that start with
+      # this name.
+      #
+      # To trigger this method, do:
+      #
+      #   ry a*
+      #   ry e*
+      #
+      # ====================================================================== #
+      if i.respond_to?(:include?) and
+         i.include?('*')
+        verbose_find_all_keys_starting_with(i)
+        exit_program
+      end
+      # ====================================================================== #
+      # We need to sanitize the given input a little bit next:
+      # ====================================================================== #
+      i = i.to_s.delete_suffix(
+            File.extname(i)
+          ).delete('-').
+          downcase
+      if i.end_with?(':')
+        i = i.dup if i.frozen?
+        i.chop!
+      end
+      i = i.to_sym
+      # ====================================================================== #
+      # === Check whether the given input is a registered program
+      # ====================================================================== #
+      if is_this_program_part_of_the_RBT_project?(i.to_s)
+      # ====================================================================== #
+      # === else we may have found an alias name
+      # ====================================================================== #
+      elsif make_use_of_the_cookbook_aliases? and
+            cookbook_aliases?.include?(i.to_s)
+        new_name = RBT.find_cookbook_alias_for(i)
+        orev "An alias was found for the given input "+
+             "#{steelblue(i)}#{rev}."
+        orev "This alias will next be used, via the derived "\
+             "name being #{steelblue(new_name)}#{rev}."
+        i = new_name
+      # ====================================================================== #
+      # === else if we can map an input to a registered program
+      # ====================================================================== #
+      elsif (new_name = action(:map_this_input_to_that_registered_program, i)) and
+            (i != new_name) and
+             !new_name.nil?
+        orev "#{steelblue(i)}#{rev} was not found, but another match was found"
+        orev "called #{steelblue(new_name)}#{rev}, which is now used."
+        i = new_name
+      # ====================================================================== #
+      # === else we have found nothing, so report to the user
+      # ====================================================================== #
+      else
+        possible_new_name = action(:filter_for_valid_program_names, i).to_sym
+        unless (possible_new_name == i)
+          orev 'A new, filter-aliased name was found for '+steelblue(i)+rev+','
+          orev 'which will be used. The new name is: '+
+          steelblue(possible_new_name)
+          i = possible_new_name
+        end
+        # ==================================================================== #
+        # Note that the next clause will return and thus break from this
+        # method. Subsequent method calls will not be triggered.
+        # ==================================================================== #
+        if do_we_check_whether_the_program_exists? and
+          !is_this_program_included?(i, :be_quiet)
+          notify_the_user_that_this_program_is_NOT_registered_as_part_of_the_RBT_project(i)
+          i = nil
+          return :the_program_is_not_registered_in_the_rbt_project
+        end unless i.to_s.include?('@')
+      end
+      @internal_hash[:compile_this_program] = i
+    end
+  end; alias set_install_this_program set_compile_this_program # === set_install_this_program
+
+  # ========================================================================== #
+  # === notify_the_user_that_this_program_is_NOT_registered_as_part_of_the_RBT_project
+  # ========================================================================== #
+  def notify_the_user_that_this_program_is_NOT_registered_as_part_of_the_RBT_project(
+      i
+    )
+    orev tomato('Unfortunately the program called ')+
+         steelblue(i)+
+         tomato(' is not')
+    orev tomato('registered as part of the RBT project.')
+    orev tomato('Thus, it could not be found and, subsequently, it can')
+    orev tomato('not be installed or compiled.')
+  end
+
+  # ========================================================================== #
+  # === do_run_ninja_and_then_ninja_install
+  #
+  # This entry point will run "ninja" and then "nina install".
+  # ========================================================================== #
+  def do_run_ninja_and_then_ninja_install
+    if may_we_run_ninja? # Always check first whether we may run ninja.
+      this_file = FILE_BUILD_NINJA
+      if File.exist?(this_file) or
+         File.exist?(File.absolute_path(this_file))
+        # ==================================================================== #
+        # === Run "ninja" next:
+        # ==================================================================== #
+        run_ninja
+        # ==================================================================== #
+        # === Run "ninja install" next:
+        # ==================================================================== #
+        run_ninja_install
+      else # else the file "build.ninja" was not found.
+        orev "No file called #{sfile(this_file)} #{rev}could be "\
+             "found in the directory"
+        orev "#{sdir(return_pwd)}#{rev} - thus, the build tool called"
+        orev "#{orange('ninja')} #{rev}can not be run."
+        # ==================================================================== #
+        # Register this error as well:
+        # ==================================================================== #
+        # error_is :could_not_find_file_called_build_ninja
+      end
+    end
+  end; alias run_ninja     do_run_ninja_and_then_ninja_install # === run_ninja
+       alias ninja_install do_run_ninja_and_then_ninja_install # === ninja_install
+       alias ninjait       do_run_ninja_and_then_ninja_install # === ninjait
+
+  # ========================================================================== #
+  # === run_ninja                                                 (ninja tag)
+  #
+  # This method will simply run "ninja".
+  # ========================================================================== #
+  def run_ninja
+    # reset_error_map_line_to_a_specific_error
+    cd use_this_as_build_directory? if do_we_use_a_build_directory?
+    orev "Proceeding to run the command "+
+         mediumpurple('ninja')+"#{rev} next, from the"
+    orev "working directory #{sdir(return_pwd)}#{rev}:"
+    _ = 'ninja'
+    colourized_and_padded_esystem(_)
+    # run_this_system_command_in_a_coloured_and_padded_manner 'ninja'
+    # run_through_the_registered_problems_registered_errors_and_behaviour_changes
+    # reset_error_map_line_to_a_specific_error
+  end; alias do_run_ninja run_ninja # === do_run_ninja
+
+  # ========================================================================== #
+  # === run_ninja_install                                 (ninja install tag)
+  # ========================================================================== #
+  def run_ninja_install
+    # reset_error_map_line_to_a_specific_error
+    # run_this_system_command_in_a_coloured_and_padded_manner 'ninja install'
+    # run_through_the_registered_problems_registered_errors_and_behaviour_changes
+    # reset_error_map_line_to_a_specific_error
+    cd use_this_as_build_directory?
+    _ = 'ninja install'
+    colourized_and_padded_esystem(_)
+  end; alias do_run_ninja_install run_ninja_install # === do_run_ninja_install
+
+  # ========================================================================== #
+  # === run_the_meson_steps
+  # ========================================================================== #
+  def run_the_meson_steps
+    run_meson_configure_step
+    # ======================================================================== #
+    # Before we can run "ninja" we must cd into the build directory,
+    # if one is to be used.
+    # ======================================================================== #
+    # if use_build_directory?
+    #   cd_to_the_build_directory { :be_verbose }
+    # end
+    do_run_ninja_and_then_ninja_install
+  end; alias do_install_via_meson run_the_meson_steps # === do_install_via_meson
+
+  # ========================================================================== #
+  # === run_python_installation
+  #
+  # You should check whether setup.py exists prior to invoking this
+  # method here.
+  #
+  # You can also pass in another file, such as configure.py. By default,
+  # the method will make use of a file called "setup.py", though.
+  # ========================================================================== #
+  def run_python_installation(
+      i = 'setup.py'
+    )
+    if parameters_to_make?.nil?
+      _ = cookbook_dataset_make_options?
+      if _ and !_.empty?
+        i = _
+      end
+    end
+    i = [i].flatten.compact
+    # ======================================================================== #
+    # We work on an Array here since some make_options entries also
+    # specify an Array.
+    # ======================================================================== #
+    i.each {|do_this_action|
+      case do_this_action
+      when FILE_SETUP_PY # ← This is equivalent to "setup.py".
+        # We could also use RBT::FILE_SETUP_PY.
+        if does_a_python_binary_exist?
+          colourized_and_padded_esystem "python #{do_this_action} configure"
+          colourized_and_padded_esystem "python #{do_this_action} build"
+          colourized_and_padded_esystem "python #{do_this_action} install"
+        else
+          notify_the_user_that_no_binary_python_could_be_found
+        end
+      else
+        run_this_command = "#{do_this_action}".dup
+        if run_this_command.start_with?('python') and !run_this_command.include?('/')
+          # ==================================================================== #
+          # This is valid for a command line such as:
+          #   "python setup.py config"
+          # ==================================================================== #
+          splitted = run_this_command.split(' ')
+          splitted[1].prepend(configure_base_dir?.dup)
+          run_this_command = splitted.join(' ')
+        end
+        unless run_this_command.start_with? 'python'
+          run_this_command.prepend('python ')
+        end
+        if does_a_python_binary_exist?
+          colourized_and_padded_esystem run_this_command
+        else
+          notify_the_user_that_no_binary_python_could_be_found
+        end
+      end
+    }
+    consider_changing_the_tab_title(
+      :clear, :do_rename
+    )
+  end; alias run_python_install   run_python_installation # === run_python_install
+       alias run_the_python_steps run_python_installation # === run_the_python_steps
+
+  # ========================================================================== #
+  # === run_scons
+  #
+  # Invoke this method here only when we wish to use scons in order to
+  # install a program.
+  #
+  # Scons is python-related, which is why it sits here in this file.
+  # ========================================================================== #
+  def run_scons
+    _ = 'scons'.dup
+    if use_build_directory?
+      _.prepend('../')
+    end
+    coloured_and_padded_esystem _
+  end; alias run_scons_based_installation run_scons # === run_scons_based_installation
+
+  # ========================================================================== #
+  # === return_append_this_to_the_configure_options
+  #
+  # This method will always at the least return an empty String.
+  # ========================================================================== #
+  def return_append_this_to_the_configure_options(
+      append_this_to_the_configure_options = append_this_to_the_configure_options?
+    )
+    _ = ''
+    if append_this_to_the_configure_options
+      _ = _.dup if _.frozen?
+      _ << append_this_to_the_configure_options
+    end
+    return _
+  end
+
+  # ========================================================================== #
+  # === remove_extracted_archive
+  #
+  # This method simply removes the extracted archive. If @keep_extracted
+  # was set to true we will not run it, but this is decided in another
+  # method called consider_removing_extracted_archive().
+  #
+  # Note that the invocation of this method must happen last, as otherwise
+  # we may run into problems such as:
+  #
+  #   in `pwd': No such file or directory - getcwd (Errno::ENOENT)
+  #
+  # We can not use the string returned by the method extract_to_this_directory?
+  # because this will refer to the rbt/ base directory.
+  # ========================================================================== #
+  def remove_extracted_archive(
+      where = :build_anew
+    )
+    case where
+    # ======================================================================== #
+    # === :default
+    # ======================================================================== #
+    when :default,
+         :build_anew
+      where = rds(will_be_extracted_towards?)
+    end
+    # === First check for run-in-simulation mode
+    if run_simulation? # Run in simulation mode here.
+      orev sfancy('We run in simulation mode right now. Normally '\
+           'the directory ')
+      orev sdir(where)+sfancy('would next be removed.')
+    elsif is_a_gem_file?
+      # ====================================================================== #
+      # Ruby .gem files are no longer considered "removable" since as of
+      # 17.06.2020.
+      # ====================================================================== #
+    elsif where == log_dir? # Tiny safeguard here.
+      orev "Can not remove #{sdir(log_dir?)}#{rev}."
+    else # ================================================================== #
+         # We must honour the keep_extracted setting. We also will not
+         # remove the log directory.
+         # ==================================================================== #
+      if keep_the_extracted_archive? or (where == RBT.log_directory?)
+        # ==================================================================== #
+        # In this case we do not have to do anything.
+        # ==================================================================== #
+      else
+        orev "Removing the extracted archive at `#{sdir(where)}#{rev}`."
+        unless File.directory? where
+          _ = 'However had, no such directory exists. Perhaps it was'
+          orev _
+          orev 'already removed, or it has never existed.'
+        end
+        # ==================================================================== #
+        # We must check whether the directory exists, before trying to
+        # remove it.
+        # ==================================================================== #
+        if File.directory? where
+          remove_directory(where)
+        else
+          # No directory exists there.
+        end
+      end
+    end
+  end; alias consider_removing_the_extracted_directory remove_extracted_archive # === consider_removing_the_extracted_directory
+       alias consider_removing_the_extracted_archive   remove_extracted_archive # === consider_removing_the_extracted_archive
+       alias consider_removing_extracted_archive       remove_extracted_archive # === consider_removing_extracted_archive
+       alias remove_the_extracted_archive              remove_extracted_archive # === remove_the_extracted_archive
+
+  # ========================================================================== #
+  # === run_make                                                   (make tag)
+  # ========================================================================== #
+  def run_make(
+      parameters_to_make = parameters_to_make?
+    )
+    if run_make? and can_we_continue?
+      _ = 'make -j$(nproc)'.dup # This variant uses the n CPU core variant.
+      _ << " #{parameters_to_make}" unless parameters_to_make.empty?
+      colourized_and_padded_esystem(_)
+    end
+  end; alias run_make_command run_make # === run_make_command
+
+  # ========================================================================== #
+  # === return_default_hash_to_be_passed_into_colour_make
+  #
+  # This method will return a static hash. This can be overruled,
+  # though, by providing an argument (another hash) to this
+  # method.
+  # ========================================================================== #
+  def return_default_hash_to_be_passed_into_colour_make(
+      optional_input = nil
+    )
+    hash = {
+      use_this_make_command:            use_which_make_command?,
+      append_these_options:             parameters_to_make?,
+      run_make:                         run_make?,
+      run_make_install:                 run_make_install?,
+      use_porg:                         use_porg?,
+      program_name_and_program_version: program_name_and_program_version?
+    }
+    if optional_input
+      hash.update(optional_input)
+    end
+    return hash 
+  end
+
+  # ========================================================================== #
+  # === run_make_install                                   (make install tag)
+  #
+  # This method will ultimately default to run:
+  #    make install
+  #
+  # Note that some programs do not use "make install" and instead use
+  # something such as "ninja install".
+  #
+  # The method here thus has to remain somewhat flexible, in order
+  # to install such programs as well.
+  # ========================================================================== #
+  def run_make_install
+    # ======================================================================== #
+    # Do not try to compile via make, if it does not have to be compiled.
+    # ======================================================================== #
+    return unless has_to_be_compiled?
+    return unless can_we_continue?
+    # ======================================================================== #
+    # Next check for pre-make-install sed instructions:
+    # ======================================================================== #
+    unless pre_make_install_sed.empty?
+      pre_make_install_sed.each {|sed_instruction|
+        run_this_sed_instruction(sed_instruction)
+      }
+    end
+    if exit_before_make_install?
+      orev 'Exiting now as instructed before reaching '\
+           'the "'+orange('make install')+rev+'" stage.'
+      exit_program
+    end
+    # ======================================================================== #
+    # === Check whether we may run make install or whether we may not.
+    # ======================================================================== #
+    if run_make_install?
+      # ====================================================================== #
+      # Clear the old buffer keeping track of our errors first:
+      # ====================================================================== #
+      # reset_error_map_line_to_a_specific_error
+      use_this_make_command = use_this_make_command?
+      if use_this_make_install_command?
+        # ==================================================================== #
+        # In this case we will use that make-install command instead.
+        # ==================================================================== #
+        use_this_make_command = use_this_make_install_command?
+      end
+      use_this_make_command = use_this_make_command.dup
+      # ====================================================================== #
+      # Check for porg next:
+      # ====================================================================== #
+      use_porg = false
+      if use_porg? # The user is trying to make use of porg here.
+        if porg_is_available?
+          use_porg = true
+        else
+          # ==================================================================== #
+          # Notify the user that porg is NOT available. We will continue
+          # anyway, though.
+          # ==================================================================== #
+          notify_the_user_that_porg_is_not_available
+        end
+      end
+      _ = "#{use_this_make_command} install"
+      # ====================================================================== #
+      # If the user uses stow then the following clause is entered.
+      # ====================================================================== #
+      opnn
+      if use_stow?
+        RBT.colour_make_install {
+          return_default_hash_to_be_passed_into_colour_make(
+            append: " DESTDIR=/stow/#{compile_which_program?} install",
+            porg:                  use_porg,
+            use_this_make_command: use_this_make_command,
+            pad_the_output:        true,
+            run_make:              false
+          )
+        }
+      else # This is the default variant.
+        RBT.colour_make_install {
+          return_default_hash_to_be_passed_into_colour_make(
+            porg:                  use_porg,
+            use_this_make_command: use_this_make_command,
+            pad_the_output:        true,
+            run_make:              false
+          )
+        }
+      end
+      # run_through_the_registered_problems_registered_errors_and_behaviour_changes
+      # reset_error_map_line_to_a_specific_error
+      # if an_error_has_occurred?
+      #   # =================================================================== #
+      #   # Register that this step led to an error in this case.
+      #   # =================================================================== #
+      #   @internal_hash[:make_install_stage_was_a_success] = false
+      #  end
+      # colourized_and_padded_esystem(_)
+      # ^^^ this should be used in a padded variant.
+    end
+  end; alias run_make_install_command                            run_make_install # === run_make_install_command
+       alias considering_running_make_install_command_via_system run_make_install # === considering_running_make_install_command_via_system
+
+  # ========================================================================== #
+  # === create_the_build_directory
+  # ========================================================================== #
+  def create_the_build_directory(
+      i = DEFAULT_NAME_FOR_THE_BUILD_DIRECTORY
+    )
+    mkdir(i) unless File.directory?(i)
+  end
+
+  # ========================================================================== #
+  # === create_the_build_directory_then_cd_into_it
+  #
+  # Note that we will only cd into the directory if we actually use a
+  # build directory.
+  # ========================================================================== #
+  def create_the_build_directory_then_cd_into_it(
+      i = DEFAULT_NAME_FOR_THE_BUILD_DIRECTORY,
+      &block
+    )
+    if use_build_directory?
+      # ====================================================================== #
+      # === Handle blocks next
+      # ====================================================================== #
+      if block_given?
+        yielded = yield
+        case yielded
+        # ==================================================================== #
+        # === :be_verbose
+        # ==================================================================== #
+        when :be_verbose
+          orev "Changing directory into "\
+               "#{sdir(absolute_path(i))} "\
+               "#{rev}next,"
+          orev "thus honouring the #{steelblue('use-build-directory')} "\
+               "#{rev}setting."
+        end
+      end
+      create_the_build_directory(i)
+      cd i
+    end
+  end; alias create_build_directory_then_cd_into_it create_the_build_directory_then_cd_into_it # === create_build_directory_then_cd_into_it
+
+  # ========================================================================== #
+  # === we_can_not_continue
+  # ========================================================================== #
+  def we_can_not_continue(
+      be_verbose = be_verbose?
+    )
+    case be_verbose
+    when :be_quiet
+      be_verbose = false
+    end
+    if be_verbose
+      orev "The RBT scripts can not continue."
+    end
+    set_can_we_continue(false)
+  end; alias can_not_continue we_can_not_continue # === can_not_continue
+       alias do_not_continue  we_can_not_continue # === do_not_continue
+
+  # ========================================================================== #
+  # === set_can_we_continue
+  # ========================================================================== #
+  def set_can_we_continue(i = false)
+    @internal_hash[:can_we_continue] = i
+  end
+
+  # ========================================================================== #
+  # === set_on_ihash
+  #
+  # The second argument is the dataset that you wish to use.
+  # ========================================================================== #
+  def set_on_ihash(
+      which_key_to_use = :cookbook_dataset,
+      which_dataset_value_to_use
+    )
+    @internal_hash[which_key_to_use] = which_dataset_value_to_use
+  end; alias set_cookbook         set_on_ihash # === set_cookbook
+       alias set_cookbook_dataset set_on_ihash # === set_cookbook_dataset
+
+  # ========================================================================== #
+  # === initialize_a_new_cookbook_for
+  #
+  # The first argument to this method should be the program that the user
+  # wants to wish to compile or install, as a String, such as "php" or
+  # "ruby" or something like that.
+  #
+  # Since as of January 2018, whenever you need an instance from
+  # class RBT::Cookbooks::SanitizeCookbook, this method here
+  # should be used.
+  #
+  # The reason is simple:
+  #
+  # - This method will do all the required invocations needed
+  #   to properly instantiate a new Cookbook instance.
+  #
+  # ========================================================================== #
+  def initialize_a_new_cookbook_for(
+      i                 = install_this_program?,
+      simple_or_complex = simple_or_complex?
+    )
+    # ======================================================================== #
+    # We need to assign the primary cookbook dataset. This will be handled
+    # by class SanitizeCookbook, and will be delegated via RBT.action().
+    # ======================================================================== #
+    cookbook_dataset = action(:cookbook_dataset, i){{
+      make_use_of_aliases_kept_in_the_file_cookbook_aliases: make_use_of_cookbook_aliases?,
+      simple_or_complex:                                     simple_or_complex?
+    }}
+    set_cookbook_dataset(cookbook_dataset) # Use the appropriate setter-method here.
+    # ======================================================================== #
+    # Sync the make command to be used at once.
+    # ======================================================================== #
+    if cookbook_dataset_use_this_make_command?
+      set_use_this_make_command(
+        cookbook_dataset_use_this_make_command?
+      )
+    end
+    return i # Always return the dataset as well here.
+  end; alias load_yaml_dataset_for_this_program                      initialize_a_new_cookbook_for # === load_yaml_dataset_for_this_program
+       alias update_dataset                                          initialize_a_new_cookbook_for # === update_dataset
+       alias ensure_that_the_dataset_exists                          initialize_a_new_cookbook_for # === ensure_that_the_dataset_exists
+       alias ensure_that_the_main_dataset_exists                     initialize_a_new_cookbook_for # === ensure_that_the_main_dataset_exists
+       alias ensure_that_we_have_a_dataset                           initialize_a_new_cookbook_for # === ensure_that_we_have_a_dataset
+       alias ensure_that_the_default_dataset_exists_for_this_program initialize_a_new_cookbook_for # === ensure_that_the_default_dataset_exists_for_this_program
+       alias ensure_dataset_for_this_program                         initialize_a_new_cookbook_for # === ensure_dataset_for_this_program
+       alias ensure_proper_dataset_for                               initialize_a_new_cookbook_for # === ensure_proper_dataset_for
+       alias ensure_that_a_dataset_exists_for_this_program           initialize_a_new_cookbook_for # === ensure_that_a_dataset_exists_for_this_program
+       alias ensure_that_the_dataset_exists_for_this_program         initialize_a_new_cookbook_for # === ensure_that_the_dataset_exists_for_this_program
+       alias ensure_proper_dataset                                   initialize_a_new_cookbook_for # === ensure_proper_dataset
+       alias create_a_new_cookbook_instance                          initialize_a_new_cookbook_for # === create_a_new_cookbook_instance
+       alias determine_the_dataset_for_this_program                  initialize_a_new_cookbook_for # === determine_the_dataset_for_this_program
+       alias determine_cookbook_dataset_for_this_program             initialize_a_new_cookbook_for # === determine_cookbook_dataset_for_this_program
+       alias load_cookbook_dataset_for                               initialize_a_new_cookbook_for # === load_cookbook_dataset_for
+       alias prepare_dataset_for                                     initialize_a_new_cookbook_for # === prepare_dataset_for
+       alias initialize_cookbook_dataset_for                         initialize_a_new_cookbook_for # === initialize_cookbook_dataset_for
+       alias initialize_a_new_cookbook_instance                      initialize_a_new_cookbook_for # === initialize_a_new_cookbook_instance
+       alias initialize_dataset_for_this_program                     initialize_a_new_cookbook_for # === initialize_dataset_for_this_program
+       alias initialize_dataset_for                                  initialize_a_new_cookbook_for # === initialize_dataset_for
+       alias initialize_dataset                                      initialize_a_new_cookbook_for # === initialize_dataset
+       alias initialize_for                                          initialize_a_new_cookbook_for # === initialize_for
+       alias initialize_cookbook_dataset_for                         initialize_a_new_cookbook_for # === initialize_cookbook_dataset_for
+       alias initialize_a_new_cookbook_for                           initialize_a_new_cookbook_for # === initialize_a_new_cookbook_for
+       alias initialize_yaml_dataset                                 initialize_a_new_cookbook_for # === initialize_yaml_dataset
+       alias initialize_cookbook_dataset                             initialize_a_new_cookbook_for # === initialize_cookbook_dataset
+       alias initialize_cookbook_for                                 initialize_a_new_cookbook_for # === initialize_cookbook_for
+       alias instantiate_a_new_cookbook_instance                     initialize_a_new_cookbook_for # === instantiate_a_new_cookbook_instance
+       alias instantiate_a_new_cookbook_for                          initialize_a_new_cookbook_for # === instantiate_a_new_cookbook_for
+       alias instantiate_a_new_cookbook                              initialize_a_new_cookbook_for # === instantiate_a_new_cookbook
+
+  # ========================================================================== #
+  # === consider_running_autoconf_then_run_configure_then_make_then_make_install
+  # ========================================================================== #
+  def consider_running_autoconf_then_run_configure_then_make_then_make_install
+    consider_running_the_pre_configure_steps
+    decide_whether_to_invoke_the_autoconf_command
+    run_configure_then_make_then_make_install
+  end
+
+  # ========================================================================== #
+  # === consider_checking_whether_the_compiled_binaries_are_already_registered
+  # ========================================================================== #
+  def consider_checking_whether_the_compiled_binaries_are_already_registered
+    if is_on_roebe? and # ← Only allow this on roebe-systems.
+       is_app_dir? and
+       has_to_be_compiled? and
+       # compiled_successfully? and
+       !prefix?.include?('Toolchain') # Make /home/Programs/Toolchain exempt from this.
+      locally_existing_executables = Dir["#{prefix?}bin/*"].map {|entry|
+        File.basename(entry)
+      }
+      locally_existing_executables << Dir["#{prefix?}sbin/*"].map {|entry|
+        File.basename(entry)
+      }
+      locally_existing_executables.flatten!
+      locally_existing_executables.uniq!
+      registered_binaries = cookbooks_binaries?
+      # ====================================================================== #
+      # Next compare these entries:
+      # ====================================================================== #
+      locally_existing_executables.each {|entry|
+        if registered_binaries.include? entry
+          # In this case all is fine.
+        else
+          compile_this_program = compile_which_program?
+          # ==================================================================== #
+          # Else it is a not-registered binary, so report it.
+          # ==================================================================== #
+          cliner
+          opne crimson('The entry ')+steelblue(entry)+
+               crimson(' is not a registered')
+          opne crimson('binary for the program ')+
+               royalblue(compile_this_program)+
+               crimson('.')
+          opne olivedrab('^^^ Consider changing this. ^^^')
+          cliner
+          # ==================================================================== #
+          # Since as of 09.12.2019 we will also store this result into a
+          # log file.
+          # ==================================================================== #
+          what = "#{entry} belongs to the program called "\
+                 "#{rarrow?} #{compile_this_program}"
+          into = "#{log_dir?}these_binaries.yml"
+          orev "Storing "+steelblue(entry)+rev+
+               "#{rev} into the file "+
+               sfile(into)+
+               "#{rev} as well."
+          append_what_into("#{what}#{N}", into)
+        end
+      }
+    end
+  end
+
+  # ========================================================================== #
+  # === do_handle_the_post_installation_steps
+  # ========================================================================== #
+  def do_handle_the_post_installation_steps
+    # ======================================================================== #
+    # === (16) Consider symlinking glib-schema files into the /usr/
+    #          hierarchy.
+    #
+    # This should come before we symlink other things, and after the
+    # configure-step.
+    # ======================================================================== #
+    consider_symlinking_glib_schema_files_into_the_usr_share_hierarchy
+    if appdir_prefix? and can_we_continue?
+      # ====================================================================== #
+      # === (18) Prepare SymlinkProgram
+      #
+      # Make our instance of SymlinkProgram behave properly - this should
+      # come before we perform postinstallation actions, and after the
+      # glib schema files were symlinked.
+      # ====================================================================== #
+      prepare_symlink_program_instance
+      _ = appdir_prefix_points_at?
+      orev "Trying to update or create the #{steelblue('Current')}"\
+           "#{rev} symlink next."
+      action(:ToCurrent, _) # Run ToCurrent here.
+      orev 'Trying to symlink various entries from '+steelblue(_)+
+           rev+' next.'
+      if force_symlinks_when_appdir_prefix_is_used?
+        action(:symlink_from_to_current2, _) # Run SymlinkFromToCurrent here.
+      else
+        action(:symlink_from_to_current, _) # Run SymlinkFromToCurrent here.
+      end
+      # Next we do some error-handling:
+      # if has_an_error_occurred? or RBT::Errors::MapLineToASpecificError.all_programs_and_errors?.flatten.any? {|inner_line|
+      #       inner_line.to_s.include?('.h: No such file or directory')
+      #     }
+      #     opne swarn('An error has occurred in the directory ')+
+      #          sdir(return_pwd)+
+      #          swarn('.')
+      #     opne swarn('We will most likely not be able to continue.')
+      #     try_to_give_additional_information_to_the_user_if_the_missing_header_is_registered
+      #     case ignore_errors?
+      #     when true
+      #       # =============================================================== #
+      #       # pass through
+      #       # =============================================================== #
+      #     when :infer # This is the new default.
+      #       we_can_not_continue
+      #     else
+      #       we_can_not_continue
+      #     end
+      #   end
+      # ====================================================================== #
+      # ====================================================================== #
+      # === (19) Check for registered, compiled binaries
+      #
+      # Make sure that the registered binaries are already registered,
+      # if the program has been compiled successfully. This will only
+      # be run on my home setup, though.
+      # ====================================================================== #
+      consider_checking_whether_the_compiled_binaries_are_already_registered
+      consider_comparing_the_installed_libraries_versus_the_assumed_libraries
+      # ====================================================================== #
+      # === (19) Consider running "ldconfig" next
+      # ====================================================================== #
+      consider_running_ldconfig
+      # ====================================================================== #
+      # === (20) Consider storing the configure-options that were used
+      #          into a fancy markdown file
+      #
+      # Note that this will only be done if the configure options are
+      # NOT empty. In other words, the .yml file must have specified
+      # some configure options to be used.
+      # ====================================================================== #
+      if did_we_use_an_appdir_prefix?
+        # ==================================================================== #
+        # And store this into the app-dir prefix, but only if we actually
+        # did use an appdir-prefix.
+        # ==================================================================== #
+        do_store_the_configure_options_that_were_used_into_a_markdown_file
+        # ==================================================================== #
+        # === Handle .gir files since as of 22.02.2020.
+        # ==================================================================== #
+        if has_gir_files? and symlink_gir_files?
+          target_directory = '/usr/share/gir-1.0/'
+          symlink_the_available_gir_files_into_this_target_directory(target_directory)
+        end
+      end
+      # ====================================================================== #
+      # Else a problem or an error may have occurred. We will thus check
+      # for that. The error will be re-set more on the beginning of
+      # this method rather than its end.
+      # ====================================================================== #
+      # check_for_common_problems_and_common_errors
+      # ====================================================================== #
+      # Also register it to the file that keeps track of which
+      # programs were compiled successfully.
+      # ====================================================================== #
+      register_last_compiled_program
+      # ====================================================================== #
+      # === Go back to the temp-directory again
+      #
+      # Return to the temp-directory as starting directory again. This
+      # has to happen because the underlying directory may have been
+      # removed, so weneed to go to a "stable" directory instead.
+      #
+      # The second argument exists so that we are silent about this.
+      # ====================================================================== #
+      change_directory(temp_directory?, :do_not_report_anything)
+    end
+  end; alias consider_performing_postinstallation_actions do_handle_the_post_installation_steps # === consider_performing_postinstallation_actions
+
+  # ========================================================================== #
+  # === try_to_batch_compile_this_stack
+  #
+  # This method can be used to batch-compile several applications.
+  #
+  # Invocation examples:
+  #
+  #   rbt --batch-compile=autotools
+  #   rbt --batch-compile=vid_suite
+  #   rbt --batch-compile=mate
+  #   rbt --batch-compile=kde5_porting_aids
+  #
+  # ========================================================================== #
+  def try_to_batch_compile_this_stack(i)
+    # ======================================================================== #
+    # === Do some sanitizing of the input first.
+    # ======================================================================== #
+    case i
+    # ======================================================================== #
+    # === rbt --batch-compile=phonon
+    # ======================================================================== #
+    when 'phonon',
+         /^kde(_|-)?plasma/
+      i = 'kde5_plasma'
+    # ======================================================================== #
+    # === rbt --batch-compile=kde_apps
+    # ======================================================================== #
+    when /^kde(_|-)?apps/
+      i = 'kde5_applications'
+    # ======================================================================== #
+    # === rbt --batch-compile=protos
+    # ======================================================================== #
+    when 'protos'
+      i = 'xorg_protos'
+    end
+    case i # case tag
+    # ======================================================================== #
+    # === rbt --batch-compile=kde5_porting_aids
+    # ======================================================================== #
+    when /^kde5?(_|-)?porting(_|-)?aids?$/i,
+         /^porting(_|-)?aids?$/i
+      i = return_kde5_porting_aids
+    # ======================================================================== #
+    # === rbt --batch-compile=mate
+    # ======================================================================== #
+    when 'mate',
+         /^mate(-|_)?desktop$/
+      i = RBT.returned_chained_programs_of_the_mate_desktop
+      orev "We will compile all #{sfancy(i.size.to_s)} #{rev}programs "\
+           "of the mate-desktop."
+      orev 'These include:'
+      e; i.each {|entry|
+        e "  - #{sfancy(entry)}"
+      }; e
+    else
+      hash = return_chained_programs
+      i = hash[i]
+    end
+    if i.is_a? String and i.include? ','
+      i = i.split(',').map(&:strip).flatten # Now it should be an Array.
+    end
+    if i.is_a? Array
+      i.map! {|entry| entry.delete('-') }
+    end
+    return i
+  end
+
+  # ========================================================================== #
+  # === create_appdir_skeleton
+  #
+  # This method will create an AppDir skeleton, by delegating towards
+  # class RBT::Action::CreateAppDirSkeleton.new, which is a registered
+  # action.
+  #
+  # We will only do so if the prefix includes the AppDir base directory
+  # though. By default, that base directory would hold the value of
+  # the $PROGRAMS environment variable - at the least on my system,
+  # this defaults to /Programs/. You can change this value if you
+  # modify a yaml file though. That yaml file is called
+  # "programs_dir.yml" and resides in the yaml/configuration/
+  # subdirectory of the RBT project.
+  #
+  # The method accepts one argument, which is either the program name,
+  # or alternatively the full name to the program in question.
+  #
+  # Normally, the program name will be defined in the yaml data object, 
+  # but since you can also overrule this setting in the yaml file,
+  # we need an argument here to allow this too.
+  # ========================================================================== #
+  def create_appdir_skeleton(
+      i                     = return_proper_prefix,
+      uses_an_appdir_prefix = uses_an_appdir_prefix?
+    )
+    if uses_an_appdir_prefix
+      # ====================================================================== #
+      # Check for an AppDir prefix next:
+      # ====================================================================== #
+      i = i.to_s.dup
+      if i.include?(programs_dir?)
+        unless i =~ /\d+/
+          i << program_version?
+        end
+        i << '/' unless i.end_with? '/'
+      end
+      # ====================================================================== #
+      # Next, delegate towards class RBT::CreateAppDirSkeleton. Since as
+      # of 20.01.2020 we will specify which programs should NOT modify
+      # the old symlink, for the new 'Current →' symlink. Otherwise
+      # compilation would fail, e. g. if /usr/bin/make would point to
+      # a not-yet compiled target prefix.
+      # ====================================================================== #
+      _ = action(__method__.to_sym, [i.dup, :dont_run_yet]) {{
+        use_colours: use_colours?,
+        use_opn:     use_opn?,
+        do_not_symlink_these_programs: %i( make gcc binutils ) # ← An exception for these programs.
+      }}
+      _.no_opn unless use_opn?
+      _.run_simulation = run_simulation?
+      _.run
+    end
+  end; alias consider_creating_the_appdir_skeleton create_appdir_skeleton # === consider_creating_the_appdir_skeleton
+       alias consider_creating_appdir_skeleton     create_appdir_skeleton # === consider_creating_appdir_skeleton
+       alias do_create_this_appdir_skeleton        create_appdir_skeleton # === do_create_this_appdir_skeleton
+       alias create_program_skeleton               create_appdir_skeleton # === create_program_skeleton
+       alias create_app_skeleton                   create_appdir_skeleton # === create_app_skeleton
+       alias create_program                        create_appdir_skeleton # === create_program
+       alias rcp                                   create_appdir_skeleton # === rcp (rcp tag)
+
+  # ========================================================================== #
+  # === do_these_logic_steps                                      (logic tag)
+  #
+  # This is a "meta"-method - it bundles different logic-steps together.
+  # ========================================================================== #
+  def do_these_logic_steps(*array)
+    flattened = array.flatten
+    flattened.each {|this_entry|
+      case this_entry
+      # ====================================================================== #
+      # === :consider_applying_a_patch
+      # ====================================================================== #
+      when :consider_applying_a_patch
+        consider_applying_a_patch
+      # ====================================================================== #
+      # === :consider_creating_the_appdir
+      # ====================================================================== #
+      when :consider_creating_the_appdir
+        consider_creating_the_appdir_skeleton
+      else # else assume a method-call as-is.
+        send(this_entry.to_sym)
+      end
+    }
+  end; alias do_this_logic_step do_these_logic_steps # === do_this_logic_step
+
+  # ========================================================================== #
+  # === set_compile_these_programs_then_batch_compile_them
+  #
+  # This method can be used to start batch-compiling several programs
+  # in one go.
+  # ========================================================================== #
+  def set_compile_these_programs_then_batch_compile_them(
+      i, consider_replacing_the_input = :default
+    )
+    set_compile_these_programs(i, consider_replacing_the_input) 
+    batch_compile_these_programs(i)
+  end
+
+  # ========================================================================== #
+  # === set_compile_these_programs
+  #
+  # This variant will always be an Array.
+  # ========================================================================== #
+  def set_compile_these_programs(i)
+    @internal_hash[:compile_these_programs] << [i].flatten.compact
+    @internal_hash[:compile_these_programs].flatten!
+  end
+
+  # ======================================================================= #
+  # === try_to_install_this_program
+  # ======================================================================= #
+  def try_to_install_this_program(
+      i = compile_which_program?
+    )
+    return if i.nil?
+    reset_the_cookbook_dataset # Start from a clean state here, by setting it to nil.
+    do_compile_this_registered_program(i)
+  end; alias do_install_this_program try_to_install_this_program # === do_install_this_program
+
+  # ========================================================================== #
+  # === clear_the_original_cookbook_dataset
+  # ========================================================================== #
+  def clear_the_original_cookbook_dataset
+    set_cookbook_dataset(nil)
+  end
+
+  # ========================================================================== #
+  # === consider_showing_the_flexbox
+  # ========================================================================== #
+  def consider_showing_the_flexbox(
+      compile_this_program = compile_which_program?
+    )
+    show_flexbox(compile_this_program) if show_flexbox?
+  end; alias do_show_the_infobox consider_showing_the_flexbox # === do_show_the_infobox
+       alias infobox_for         consider_showing_the_flexbox # === infobox_for
+
+  # ========================================================================== #
+  # === consider_removing_the_old_extracted_directory_if_it_exists
+  # ========================================================================== #
+  def consider_removing_the_old_extracted_directory_if_it_exists(
+      i = remove_archive_stuff_from_the_end(will_be_extracted_towards?)
+    )
+    i = rds(i) if i.include?('//')
+    # ======================================================================= #
+    # We also check whether the target is or appears to be under the
+    # log-directory that RBT uses.
+    # ======================================================================= #
+    if File.directory?(i) and i.include?(log_dir?) and !(i == '/')
+      if i == log_dir? # The log-directory can not be removed via this method.
+        orev "Can not remove #{sdir(i)}#{rev}."
+      else
+        orev "#{steelblue('Removing')}#{rev}"\
+             " the old, extracted directory at #{sdir(i)}"\
+             "#{rev} next."
+        remove_directory(i)
+      end
+    end
+  end
+
+  # ======================================================================= #
+  # === notify_the_user_as_to_which_program_will_be_compiled_or_installed_next
+  #
+  # Notify the user which program will be compiled/installed next
+  # through this method.
+  # ======================================================================= #
+  def notify_the_user_as_to_which_program_will_be_compiled_or_installed_next(
+      i          = compile_which_program?,
+      local_path = program_path?
+    )
+    orev "The program `#{steelblue(i)}#{rev}` "\
+         "will be #{compile_or_install_string?} #{rev}next, in "\
+         "#{lightgreen(mode?.to_s)} #{rev}mode."
+    orev "The #{steelblue('assumed local path')} #{rev}is:"
+    e
+    e "  #{sfile(local_path)}"
+    e
+    if File.exist? local_path
+      orev "The program called #{steelblue(i)}#{rev} will be extracted next."
+    else
+      orev "The program called #{steelblue(i)}#{rev} will be downloaded first."
+      orev 'If the download is successful then the archive will '\
+           'be extracted next.'
+      orev 'If this fails then it may be easier to download the source'
+      orev 'archive manually.'
+    end
+  end
+
+  # ========================================================================== #
+  # === consider_creating_and_populating_the_pkgconfig_directory
+  # ========================================================================== #
+  def consider_creating_and_populating_the_pkgconfig_directory
+    if uses_an_appdir_prefix?
+      action(:create_and_populate_pkgconfig_directory, appdir_prefix?)
+    end
+  end
+
+  # ========================================================================== #
+  # === do_compile_in_a_non_traditional_way
+  #
+  # We enable Gobolinux-style compilation here, as in AppDir-like
+  # compilation.
+  # ========================================================================== #
+  def do_compile_in_a_non_traditional_way(
+      program_name_and_program_version = program_name_and_program_version?,
+      be_verbose                       = be_verbose?
+    )
+    if cookbook_dataset?.nil?
+      load_cookbook_dataset_for(compile_which_program?)
+    end
+    if can_we_continue?
+      case program_name_and_program_version
+      # ====================================================================== #
+      # === :be_silent
+      # ====================================================================== #
+      when :be_silent,
+           :be_quiet
+        be_verbose = false
+        program_name_and_program_version = program_name_and_program_version?
+      end
+      case be_verbose
+      # ====================================================================== #
+      # === :be_silent
+      # ====================================================================== #
+      when :be_silent,
+           :be_quiet
+        be_verbose = false
+      end
+      if be_verbose
+        orev 'Overruling any potential traditional setting.'
+      end
+      @internal_hash[:counter_called_traditional_or_non_traditional_compilation] += 1
+      # ensure_that_a_cookbook_object_has_been_instantiated
+      _ = prefix_object?.do_use_appdir_prefix_from_this_input(
+            program_name_and_program_version?
+          )
+      # set_user_prefix(:ntrad)
+      @internal_hash[:shall_we_use_an_appdir_prefix] = true
+      set_user_prefix(_.to_s) # The raw-user prefix must be set here as well.
+      set_use_this_prefix(_)
+      orev "Enabling #{steelblue('AppDir prefix')}#{rev}."
+      # enable_non_traditional_compilation(
+      #   program_name_and_program_version
+      # )
+    end
+  end; alias compile_as_appdir                  do_compile_in_a_non_traditional_way # === compile_as_appdir
+       alias set_standalone_compilation         do_compile_in_a_non_traditional_way # === set_standalone_compilation # This is a legacy alias.
+       alias use_non_traditional_prefix         do_compile_in_a_non_traditional_way # === use_non_traditional_prefix
+       alias do_run_via_nontraditional_way      do_compile_in_a_non_traditional_way # === do_run_via_nontraditional_way
+       alias do_use_an_appdir_prefix            do_compile_in_a_non_traditional_way # === do_use_an_appdir_prefix
+       alias ntrad                              do_compile_in_a_non_traditional_way # === ntrad
+
+  # ========================================================================== #
+  # === do_compile_this_registered_program (main tag, real compile tag, compile tag, run tag)
+  #
+  # This method is the main powerhorse of this class. It is used to
+  # compile a (single) registered program. It can be considered as
+  # the primary, general entry-point to this class.
+  #
+  # To not initialize the dataset, use :do_not_initialize_the_dataset
+  # as block-argument.
+  # ========================================================================== #
+  def do_compile_this_registered_program(
+      i,
+      &block
+    )
+    return unless can_we_continue? # This should come first.
+    clear_the_original_cookbook_dataset
+    # ======================================================================== #
+    # Next we have to sanitize the given input a little bit, such as by
+    # getting rid of any '/' character.
+    # ======================================================================== #
+    i = i.to_s.dup # We need a String.
+    i.delete!('_') if i.include? '_'
+    i.delete!('-') if i.include? '-'
+    i = File.basename(i) if i.include? '/'
+    # ======================================================================== #
+    # Next, we will initialize a new cookbook-instance.
+    # ======================================================================== #
+    if block_given? and (yield == :do_not_initialize_the_dataset)
+      # In this case we will not initialize a new cookbook-dataset.
+    else
+      initialize_cookbook_dataset_for(i)
+    end
+    # ======================================================================== #
+    # Next, the user may want to use another program version, so we handle
+    # this case here. This can be tested via:
+    #
+    #  ry glib@2.70.5
+    #
+    # ======================================================================== #
+    if program_version? and cookbook_program_version? and
+      !(program_version == cookbook_program_version?)
+      set_cookbook_program_name(i)
+      set_cookbook_program_version(program_version)
+      prefix_object?.set_program_name(program_name?)
+      prefix_object?.set_program_version(program_version) # Sync the program-version onto the prefix-object here.
+      cookbook_dataset?.update_program_name_and_program_version
+      cookbook_dataset?.determine_the_path
+      if use_appdir_prefix?
+        # Sync the new cookbook-version onto the prefix-object
+        sync_cookbook_dataset_program_version_onto_the_prefix_object
+        prefix_object?.determine_the_prefix_anew
+      end
+    end
+    properly_prepare_the_build_directory
+    # ======================================================================== #
+    # First check if the user wants to ensure a specific licence - this
+    # can only come once the dataset has been initialized:
+    # ======================================================================== #
+    if check_for_this_licence?
+      unless licence? == check_for_this_licence?
+        opne "#{tomato('The licences do not match. ')}#{rev}Expected licence"
+        orev 'was: '+
+             steelblue(RBT.sanitize_this_licence(check_for_this_licence?)
+             )+", specified licence was: #{steelblue(licence?)}"
+        return
+      end
+    end
+    # ======================================================================== #
+    # === Check whether ccache exists
+    #
+    # Query for the use and availability of ccache. This should come
+    # after any special environment was set.
+    # ======================================================================== #
+    if use_ccache? and !is_ccache_available?
+      notify_the_user_that_ccache_is_not_available
+    end
+    # ======================================================================== #
+    # Next we have to determine which compiler we want to use.
+    # ======================================================================== #
+    determine_which_compiler_will_be_used
+    # ======================================================================== #
+    # === (1) Set special environment variables
+    #
+    # Next, ensure that if the cookbooks file at hand is using any special
+    # environment variable, that this will also be used. For example,
+    # the program called "htop" will use these LDFLAGS: -ltinfow,
+    # so this has to be enabled.
+    #
+    # This should come before we will check for ccache. It can also
+    # come before we check for the program path - some environment
+    # variables may influence any further downstream checks, so
+    # let's call it here to be on the safe side.
+    #
+    # This should also come AFTER we possibly downloaded the remote
+    # program.
+    # ======================================================================== #
+    considering_setting_any_special_environment_variable
+    # ======================================================================== #
+    # === (4) Set the CFLAGS next.
+    #
+    # This should come before the source archive is extracted, and before
+    # the infbox is shown. This class will also honour the build_static
+    # variable.
+    #
+    # We will do this only for programs that have to be compiled, though.
+    # ======================================================================== #
+    if has_to_be_compiled?
+      if build_static?
+        # ==================================================================== #
+        # Honour static compilation settings in the ymal file.
+        # ==================================================================== #
+        orev "The yaml file specifies that this program is to "\
+             "be #{steelblue('compiled statically')}#{rev}."
+        orev "Thus, we will use these CFLAGS: "\
+             "#{lightblue(default_cflags?)}"
+        # ==================================================================== #
+        # We also have to scan the configure command string. If that
+        # string contains an instruction such as "--disable-static",
+        # then we will get rid of it, and notify the user. The reason
+        # is that, quite obviously, we can not have conflicting options
+        # passed.
+        #
+        # Note that this may be changed at a later time in the future,
+        # if we decide that only user-supplied options to RBT may change
+        # this behaviour. For now, we simply add a way to check the logic
+        # on it, which is an improvement over the old code which did
+        # not do any logic-checking at all whatsoever.
+        # ==================================================================== #
+        configure_options = configure_options?
+        if configure_options.include? '--disable-static'
+          orev 'The configure option to '+sfancy(compile_which_program?)+
+               " is using the option called #{simp('--disable-static')}."
+          orev "As this #{steelblue('would contradict')} with our goal "\
+               "to enable static compilation,"
+          orev 'this option was replaced with --enable-static, from '\
+               'the configure command string.'
+          cookbook_dataset?.configure_options = configure_options?.sub(
+            /-?-?disable-?static/, '--enable-static'
+          )
+        end
+        set_cflags(:build_static)
+      end
+    end
+    # ======================================================================== #
+    # === (2) Next we will show the infobox, also called Flexbox (flexbox tag, infobox tag)
+    #
+    # This step will show the infobox, also known as flexbox. It has to
+    # happen AFTER the CFLAGS variable was modified, as this box will
+    # also present the current value of the CFLAGS to the user.
+    #
+    # The infobox may show the required dependencies of the given program
+    # at hand, which should always come BEFORE the source-archive is
+    # extracted.
+    #
+    # The configuration file called "always_show_dependencies.yml" will
+    # determine whether the dependencies are shown (by default) or
+    # whether they are not shown (by default).
+    #
+    # Since as of November 2017, the default behaviour here is to no
+    # longer always show the dependencies, as that may be a bit spammy,
+    # by default, so the user has to specifically enable this 
+    # option if he/she wants to have that. On my home system, for
+    # instance, the value is now false.
+    #
+    # In the old code before November 2017, we used to call the method
+    # feedback_dependencies_of_the_program() rather than
+    # show the flexbox at hand.
+    # ======================================================================== #
+    infobox_for(i)
+    prefix_object?.set_program_version(program_version?) # Set the program version here just in case.
+    # ======================================================================== #
+    # Obtain the local program-path next:
+    # ======================================================================== #
+    local_path = cookbook_local_path?
+    # program_path = cookbook_program_path?
+    # ======================================================================== #
+    # Sometimes we must re-write the program path, e. g. if we take
+    # another program version. The following method does that for us.
+    # It no longer works as of 2022, though. May have to reconsider this
+    # approach.
+    # ======================================================================== #
+    # consider_sanitizing_the_program_path
+    # determine_the_configure_base_directory_to_use
+    # ======================================================================== #
+    notify_the_user_as_to_which_program_will_be_compiled_or_installed_next(
+      i,
+      local_path
+    )
+    # ======================================================================== #
+    # === Download the source archive if it is missing locally
+    #
+    # We must check whether the file already exists locally. If not
+    # then this class will have to try to download it.
+    #
+    # This functionality must come before this class attempts to extract
+    # the program, logically.
+    # ======================================================================== #
+    if local_path and !File.exist?(local_path)
+      # ====================================================================== #
+      # === Honour the "do_not_download" settings if it exists.
+      # ====================================================================== #
+      if cookbook_dataset? and cookbook_dataset?.do_not_download?
+        do_not_download
+      else
+        download_program
+        unicode_middle_cliner # Looks better with cliner, I think.
+      end
+    end
+    # ======================================================================== #
+    # === Check whether the source archive exists locally
+    #
+    # Check whether the archive exists. If not then notify the user about
+    # it. This has to happen before we consider removing the old
+    # extracted archive directory, and it has to happen after this
+    # class tried to download the file at hand. The latter step may fail,
+    # such as when no internet connection is available.
+    # ======================================================================== #
+    unless File.exist? local_path
+      opne "#{rev}No archive exists at `#{sfile(local_path)}#{rev}`."
+      opne "#{rev}As it was specified to extract the archive in "\
+           "this case, yet this"
+      opne "archive could #{tomato('NOT')}"\
+            "#{rev} be found at the above reported path, "\
+            "we will exit"
+      opne 'now. You may consider downloading the source archive, should'
+      opne 'it exist remotely.'
+      if is_on_roebe?
+        opne crimson("As we are on a roebe-system we will also "\
+             "show the caller()-stack next:")
+        e
+        pp caller()
+        e
+      end
+      exit_program
+    end
+    # ======================================================================== #
+    # === Check whether the local path exists
+    #
+    # Must check whether this file also exists next:
+    # ======================================================================== #
+    if File.exist? local_path
+      # ====================================================================== #
+      # Ensure that the expanded cookbook .yml file exists. This should
+      # come quite early.
+      # ====================================================================== #
+      if is_on_roebe? and
+        !does_the_expanded_cookbook_file_exist_for_this_program?(i)
+        expand_this_cookbook(i)
+      end
+      # ====================================================================== #
+      # === (3) Consider changing the tab title
+      #
+      # In this case we may be able to install/compile the given program
+      # at hand, so we can rename the terminal.
+      #
+      # Changing the name of the tab title should happen only after the
+      # program name was set.
+      #
+      # Note that when we refer to "tab", we really mean KDE konsole
+      # tabs primarily.
+      #
+      # The old code was:
+      #   
+      #   consider_changing_the_tab_title(use_this_as_tab_title)
+      #
+      # ====================================================================== #
+      if rename_the_terminal?
+        use_this_as_tab_title = return_program_name_then_hyphen_then_the_program_version # :default
+        if check_whether_the_given_input_is_a_file_and_does_exist? and
+          does_this_file_exist_and_is_it_a_file?(i) # This may be the case when the user supplied a path.
+          use_this_as_tab_title = remove_archive_at_the_end(File.basename(i))
+        end
+        action(
+          :rename_konsole_tab,
+          [use_this_as_tab_title, shall_we_rename_the_tab_title?]
+        )
+      end
+      # ====================================================================== #
+      # Also store the prefix that we used on the toplevel namespace.
+      # ====================================================================== #
+      RBT.set_last_prefix_used(use_which_prefix?)
+      # ====================================================================== #
+      # Next, check whether we have to extract the archive at hand.
+      # We do not have to extract .gem files, since "gem" does
+      # this for us.
+      # ====================================================================== #
+      skip_extracting_if_it_is_a_gem_file
+      if is_a_gem_file?(local_path)
+        install_ruby_gem(local_path) # Install this rubygem.
+        return
+      end
+      # ====================================================================== #
+      # === Some error handling comes next
+      #
+      # unless ignore_errors?
+      #   we_can_not_continue if an_error_has_occurred?
+      # end
+      # ====================================================================== #
+      # ====================================================================== #
+      # Find our target directory next:
+      # ====================================================================== #
+      to = "#{extract_to_this_directory?}"\
+           "#{program_name_and_program_version?}"
+      to = rds(to).dup
+      # ====================================================================== #
+      # === (4) Do not extract the archive, before we can continue,
+      #         unless specified by the user
+      # ====================================================================== #
+      unless skip_extracting?
+        # ==================================================================== #
+        # Next, check whether we have to remove the old, extracted directory:
+        # ==================================================================== #
+        return unless can_we_continue? # This should come before we extract anything.
+        orev "Now extracting the archive, at `#{sfile(local_path)}#{rev}`."
+        orev 'The extracted directory will be located at'
+        orev "`#{sfile(to)}#{rev}`,"
+        orev 'if the extraction-step worked properly.'
+        # ==================================================================== #
+        # === (5) Extracting the archive next:
+        # ==================================================================== #
+        extract_what_to(local_path, File.dirname(to))
+        orev lightsalmon('The extraction-step has finished.')
+      end
+      # ====================================================================== #
+      # Next, exit if this was specified that way, that we only wish to
+      # extract the archive at hand.
+      # ====================================================================== #
+      if extract_only?
+        orev steelblue('Exiting now, as instructed.')
+        exit_program
+      end
+      # ====================================================================== #
+      # Ensure that the configure-options are consistent, in regards to
+      # when the user wants to compile something statically.
+      # ====================================================================== #
+      ensure_that_the_configure_options_are_consistent_in_regards_to_static_compilation
+      if File.directory? to # Check whether we can enter the extracted directory next.
+        unless to.end_with?('/')
+          to = to.dup if to.frozen?
+          to << '/'
+        end
+        # ==================================================================== #
+        # Also reset the compiled n-times counter next.
+        # ==================================================================== #
+        reset_compiled_n_times_counter
+        # ==================================================================== #
+        # === (6) Create the AppDir skeleton before cd-ing to the base directory.
+        # ==================================================================== #
+        consider_creating_the_appdir_skeleton
+        orev "Entering the directory at #{sdir(to)}#{rev} now."
+        # ==================================================================== #
+        # Change directory to the extract directory next.
+        # ==================================================================== #
+        cd_to_the_extracted_archive(to)
+        # ==================================================================== #
+        # Honour the configure-base-dir setting if it exists:
+        # ==================================================================== #
+        # ==================================================================== #
+        # Next, change to the extracted directory. We will also have to
+        # honour the configure_base_dir setting.
+        # ==================================================================== #
+        cd_into_this_directory = rds(
+          log_dir?+
+          program_name_and_program_version?+'/'+
+          configure_base_directory?.to_s+'/'
+        )
+        unless configure_base_directory?.empty? or (configure_base_directory? == '/')
+          orev "Entering the #{steelblue('configure-base-directory')}#{rev}"\
+               " at #{sdir(cd_into_this_directory)}#{rev} next."
+        end
+        cd(cd_into_this_directory)
+        report_the_current_working_directory
+        # ==================================================================== #
+        # === (7) Handle patches
+        #
+        # Consider applying a patch next - this should come before the
+        # preinstall action and before the sed-action, but after the
+        # optional start message.
+        # ==================================================================== #
+        consider_applying_a_patch
+        # ==================================================================== #
+        # === (8) Check for sed-action
+        #
+        # Next, we check whether we must apply sed. It must come before any
+        # preinstall-action, and after we have cd-ed to the correct
+        # directory, but before we applied any patches.
+        # This also means after we have extracted the archive at hand.
+        # ==================================================================== #
+        check_for_sed_action
+        # ==================================================================== #
+        # if use_build_directory?
+        #   create_the_build_directory_then_cd_into_it
+        #   ^^^ disabled as of 21.09.2022 - see README.gen for an explanation.
+        # end
+        # ==================================================================== #
+        # ==================================================================== #
+        # === Optional start messages
+        #
+        # Display optional start message here, right before we continue
+        # to the preinstall? stage and other stages.
+        # ==================================================================== #
+        consider_displaying_the_start_message
+        # ==================================================================== #
+        # === (9) Reset any possible error message at this point.
+        # ==================================================================== #
+        RBT.reset_error_message
+        # ==================================================================== #
+        # === (10) Pre-install actions
+        #
+        # Next, the pre-install actions are handled, should they exist.
+        #
+        # These should come after we have checked for sed-related
+        # actions.
+        # ==================================================================== #
+        run_preinstall_actions
+        # ==================================================================== #
+        # === (11) In the following case, the user only wants to install
+        #          the .h header files, so we will do precisely that.
+        # ==================================================================== #
+        if install_only_the_headers?
+          action_install_only_headers
+          exit_program
+        end
+        # ==================================================================== #
+        # === (12) Next, check for pre-configure steps:
+        # ==================================================================== #
+        run_pre_configure_steps_if_requested_to_do_so
+        # ==================================================================== #
+        # === (13) Deciding whether we need to compile statically:
+        # ==================================================================== #
+        decide_whether_to_build_statically
+        # ==================================================================== #
+        # === (14) The (optional) autogen-step
+        #
+        # Consider running "autogen" next.
+        #
+        # This step should come after the archive was already extracted,
+        # and after pre-installation steps were performed - but it should
+        # come BEFORE we invoke "autoconf", logically (the latter one
+        # is an optional step as well, though).
+        # ==================================================================== #
+        decide_whether_to_invoke_autogen # (autogen tag)
+        # ==================================================================== #
+        # === (15) The next method-call must occur AFTER the
+        #          pre-installation steps.
+        # ==================================================================== #
+        decide_whether_to_invoke_the_autoconf_command
+        if do_we_use_a_build_directory?
+          consider_creating_the_build_directory
+          orev 'A build directory is used. The working directory is now'
+          orev sdir(build_directory_object?.path?)+rev+'.'
+        end
+        run_the_equivalent_configure_like_stage_for_this_program(i)
+        unless keep_extracted?
+          # ==================================================================== #
+          # === Remove the extracted archive / directory
+          #
+          # We have to clean-up again, by removing the extracted archive. This
+          # behaviour can be changed by the user, though. Additionally, the
+          # individual .yml file may decide for us whether we will remove the
+          # extracted directory or whether we will keep that directory. User
+          # instructions overrule the settings in the .yml file, though.
+          # ==================================================================== #
+          consider_removing_the_old_extracted_directory_if_it_exists
+        end
+        # ==================================================================== #
+        # Consider stripping the compiled binaries.
+        # ==================================================================== #
+        if had_to_be_compiled?
+          # ==================================================================== #
+          # Next check whether we have to strip the compiled binaries or
+          # whether we do not have to strip them. The checks are done
+          # with the method itself, so we don't have to do any conditional
+          # checks here at this point.
+          # ==================================================================== #
+          do_strip_the_compiled_binaries
+          # ==================================================================== #
+          # Next, we will consider creating and populating the subdirectory
+          # called "lib/pkgconfig/". This may be necessary for programs that
+          # install into "share/pkgconfig/" rather than "lib/pkgconfig".
+          #
+          # This step has to be done before we call the method
+          # consider_symlinking_the_pkgconfig_files().
+          # ==================================================================== #
+          consider_creating_and_populating_the_pkgconfig_directory
+          # ==================================================================== #
+          # If the cookbook file at hand has symlinking_pkgconfig_files
+          # enabled, and if the program is compiled, as AppDir, then we
+          # will symlink .pc iles into /usr/lib/pkgconfig/, if the
+          # latter one exists.
+          #
+          # This should actually be part of the post-installation actions,
+          # but before running ldconfig.
+          # ==================================================================== #
+          consider_symlinking_the_pkgconfig_files
+          # ==================================================================== #
+          # === Handle empty subdirectories
+          #
+          # Next we will consider removing empty subdirectories. This has to
+          # happen here again, after the postinstall step, because the installation
+          # may have failed. The method will also do a more general clean-up
+          # step in the respective AppDir prefix.
+          #
+          # However had, in December 2022 it was realised that some directories
+          # should NOT be removed, even if they are empty - such as temp or
+          # logs directories called during the post-installation step. So
+          # we have to include that as well.
+          # ==================================================================== #
+          consider_removing_empty_subdirectories
+          # ==================================================================== #
+          # Store the time it took to compile the program at hand.
+          # ==================================================================== #
+          store_time_snapshot
+          consider_creating_a_log_file_containing_information_about_the_used_environment_and_time_of_compilation
+          # ==================================================================== #
+          # Report to the user how long it took us to compile/install the program
+          # at hand.
+          # ==================================================================== #
+          consider_reporting_the_time_it_took_to_compile_this_program
+          # ==================================================================== #
+          # Next register the configure-line into the configure "database",
+          # unless a problem or error has occurred.
+          # ==================================================================== #
+          # if no_problem_was_encountered? and
+          #    no_error_was_encountered?
+          # ==================================================================== #
+          # Register the configure-line that was used into the "global"
+          # configure database next - this should come before we symlink
+          # the .pc files:
+          # ==================================================================== #
+          register_configure_line_into_configure_database
+          # ==================================================================== #
+          # Go back into the starting directory again.
+          # ==================================================================== #
+          consider_entering_the_log_directory
+          show_the_everything_is_finished_message
+          # ==================================================================== #
+          # Show success or failure - this should come last.
+          # ==================================================================== #
+          show_success_or_failure_status
+        end
+        # ==================================================================== #
+        # Last but not least, consider changing the tab title, via an
+        # action.
+        # ==================================================================== #
+        action(:rename_konsole_tab, :clear) if rename_the_terminal?
+      else
+        no_directory_was_found_at(to)
+        orev tomato('This means that the extraction-step has not worked properly.')
+        orev tomato('Make sure that the source-archive exists at ')
+        orev sfile(program_path?)+rev+tomato(' locally, and is correct.')
+      end
+    else
+      opnn; no_file_exists_at(local_path)
+    end
+  end; alias compile_this_program               do_compile_this_registered_program # === compile_this_program
+       alias do_compile_this_program            do_compile_this_registered_program # === do_compile_this_program
+       alias do_compile_this_registered_program do_compile_this_registered_program # === do_compile_this_registered_program
+       alias do_install_this_program            do_compile_this_registered_program # === do_install_this_program
+
+  # ========================================================================== #
+  # === do_store_the_configure_options_that_were_used_into_a_markdown_file
+  #
+  # This method is only invoked for an AppDir program. It will store
+  # the configure options, but not the full configure command; for that
+  # another .md file is used.
+  # ========================================================================== #
+  def do_store_the_configure_options_that_were_used_into_a_markdown_file(
+      store_this = 
+        configure_options_based_on_the_build_system_in_use?.dup
+    )
+    if store_this and !store_this.empty?
+      # ====================================================================== #
+      # We will remove some stuff from it before storing:
+      # ====================================================================== #
+      if store_this.include? rbt_temp_dir?
+        store_this.sub!(
+          /#{Regexp.quote(rbt_temp_dir?)}/, ''
+        )
+        _ = program_name_and_program_version?
+        if store_this.include? _
+          store_this.sub!(/#{_}/, '.')
+        end
+      end
+      into = "#{prefix?}Resources/configure_options.md"
+      orev "Storing the configure options that were used "\
+           "into the file:"
+      e
+      e "  #{sfile(into)}"
+      e
+      write_what_into("#{store_this}\n", into)
+    end
+  end
+
+  # ========================================================================== #
+  # === do_install_these_programs
+  #
+  # The logic for this task will be handled internally, on a per-program
+  # basis, through the method try_to_install_this_program().
+  #
+  # The argument to this method should be an Array which holds the
+  # programs that the user wishes to compile. This is normally set
+  # elsewhere in class RBT::Action::SoftwareManager.
+  # ========================================================================== #
+  def do_install_these_programs(
+      i = compile_which_program?
+    )
+    [i].flatten.compact.each {|this_program|
+      try_to_install_this_program(this_program)
+    }
+  end; alias batch_compile_the_programs    do_install_these_programs # === batch_compile_the_programs
+       alias batch_compile_these_programs  do_install_these_programs # === batch_compile_these_programs
+       alias start_to_compile_the_programs do_install_these_programs # === start_to_compile_the_programs
+       alias start_to_compile              do_install_these_programs # === start_to_compile
+       alias do_initiate_batch_compilation do_install_these_programs # === do_initiate_batch_compilation
+       alias do_install_the_programs       do_install_these_programs # === do_install_the_programs
+       alias do_compile_these_programs     do_install_these_programs # === do_compile_these_programs
+       alias compile_this_program_again    do_install_these_programs # === compile_this_program_again
+       alias compile_every_program         do_install_these_programs # === compile_every_program
+
+  # ========================================================================== #
+  # === run_this_system_command_in_a_coloured_and_padded_manner
+  # ========================================================================== #
+  def run_this_system_command_in_a_coloured_and_padded_manner(i)
+e tomato('TODO FIX ME: in run_this_system_command_in_a_coloured_and_padded_manner()')
+e tomato('We should replace this via run_system_or_ioparser_command()') # === run_this_system_command_in_a_coloured_and_padded_manner
+    esystem i
+  end; alias padded_esystem run_this_system_command_in_a_coloured_and_padded_manner # === padded_esystem
+
+end; end; end