rbt 0.13.42 → 0.15.1

data/lib/rbt/lean_prototype/lean_prototype.rb

@@ -0,0 +1,3643 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === RBT::LeanPrototype
+#
+# This file contains code for a "prototype" RBT::Base class.
+#
+# The distinction towards file rbt/base/base.rb is somewhat arbitrary, but
+# the core idea is to keep the file lean_prototype.rb semi-minimal and only
+# put in code that is really important for ALL the classes that subclass
+# from it; whereas for larger classes, they are encouraged to require
+# base.rb instead.
+#
+# If you need to subclass, you should first try to require rbt/base/base.rb
+# instead, because this one also pulls in the file here as well. But if you
+# need only less code in your subclass, and even more importantly so, you
+# need to avoid "circular dependency" warnings, then you can (safely)
+# require and subclass from the file here instead.
+#
+# In fact, this is why the file here was actually created:
+#
+#   I needed a file with some functionality but I could not use base.rb.
+#
+# =========================================================================== #
+# require 'rbt/lean_prototype/lean_prototype.rb'
+# Foobar < RBT::LeanPrototype
+# =========================================================================== #
+module RBT
+
+class LeanPrototype # === RBT::LeanPrototype
+
+  require 'fileutils'
+  require 'rbt/requires/require_colours.rb'
+  require 'rbt/requires/require_the_constants.rb'
+  require 'rbt/requires/require_raw_yaml.rb'
+  require 'rbt/project/project.rb'
+  require 'rbt/colours/colours.rb'
+  require 'rbt/colours/rev_simp_sdir_sfancy_sfile_and_swarn.rb'
+  require 'rbt/constants/constants.rb'
+  require 'rbt/encoding/encoding.rb'
+  require 'rbt/configuration/configuration.rb'
+  require 'rbt/toplevel_methods/archive_related_code.rb'
+  require 'rbt/toplevel_methods/debug.rb'
+  require 'rbt/toplevel_methods/does_include.rb'
+  require 'rbt/toplevel_methods/e_and_esystem.rb'
+  require 'rbt/toplevel_methods/files_and_directories_related_methods.rb'
+  require 'rbt/toplevel_methods/toplevel_methods.rb'
+  require 'rbt/toplevel_methods/remove_file_extension.rb'
+  require 'rbt/toplevel_methods/verbose_truth.rb'
+  require 'rbt/time/time.rb'
+
+  begin
+    # ======================================================================= #
+    # We will always try to require the gem called "program_information",
+    # for convenience. If that does not work then the RBT suite will
+    # try to resume nonetheless. 
+    # ======================================================================= #
+    require 'program_information'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === DAY_NAMES
+  #
+  # The addition of this constant was necessary due to upstream MRI ruby
+  # removing the RFC2822_DAY_NAME constant from time.rb.
+  # ========================================================================= #
+  DAY_NAMES = %w(
+    Sun Mon Tue Wed Thu Fri Sat
+  )
+
+  # ========================================================================= #
+  # === ALL_COLOUR_METHODS
+  # ========================================================================= #
+  ALL_COLOUR_METHODS = ::Colours::HtmlColoursMethods
+
+  # ========================================================================= #
+  # === SILENT_REDIRECTION
+  #
+  # This can simply be appended.
+  # ========================================================================= #
+  SILENT_REDIRECTION = ' > /dev/null'
+
+  # ========================================================================= #
+  # === ee
+  # ========================================================================= #
+  alias ee print
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      i           = ARGV,
+      run_already = true,
+      &block
+    )
+    reset
+    set_commandline_arguments(i)
+    # ======================================================================= #
+    # Next handle blocks given to the class.
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :no_colours
+      # ===================================================================== #
+      when :no_colours
+        disable_colours
+      else
+        # =================================================================== #
+        # === Handle Hash given in blockform
+        # =================================================================== #
+        if yielded.is_a? Hash
+          # ================================================================= #
+          # === :use_colours
+          # ================================================================= #
+          if yielded.has_key? :use_colours
+            _ = yielded.delete :use_colours
+            if _ == false
+              disable_colours
+            end
+          end
+        end
+      end
+    end
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    # ======================================================================= #
+    # === @internal_hash
+    #
+    # This definition for the internal Hash *must* come first.
+    # ======================================================================= #
+    @internal_hash = {}
+    populate_the_internal_hash_with_default_values
+  end
+
+  # ========================================================================= #
+  # === populate_the_internal_hash_with_default_values
+  # ========================================================================= #
+  def populate_the_internal_hash_with_default_values
+    # ======================================================================= #
+    # === :namespace
+    #
+    # We must initialize this variable here so that subclasses can make
+    # use of it from the very beginning.
+    # ======================================================================= #
+    set_the_namespace(
+      { namespace: NAMESPACE }
+    )
+    # ======================================================================= #
+    # === :commandline_arguments
+    # ======================================================================= #
+    @internal_hash[:commandline_arguments] = []
+    # ======================================================================= #
+    # === :be_verbose
+    # ======================================================================= #
+    @internal_hash[:be_verbose] = true
+    # ======================================================================= #
+    # === :use_colours
+    # ======================================================================= #
+    @internal_hash[:use_colours] = RBT.use_colours? # Use the default value for RBT.
+    # ======================================================================= #
+    # === :run_simulation
+    #
+    # This variable will determine whether we run in simulation mode or not.
+    # ======================================================================= #
+    @internal_hash[:run_simulation] = RBT.configuration?.run_simulation
+    # ======================================================================= #
+    # === :use_opn
+    # ======================================================================= #
+    @internal_hash[:use_opn] = true
+    # ======================================================================= #
+    # === :debug
+    # ======================================================================= #
+    @internal_hash[:debug] = RBT.shall_we_debug?
+  end
+
+  # ========================================================================= #
+  # === reset_the_internal_hash
+  # ========================================================================= #
+  def reset_the_internal_hash
+    # ======================================================================= #
+    # === @internal_hash
+    # ======================================================================= #
+    @internal_hash = {}
+  end
+
+  require 'rbt/toplevel_methods/configure_appdir_prefix.rb'
+  # ========================================================================= #
+  # === return_appdir_prefix
+  # ========================================================================= #
+  def return_appdir_prefix(i)
+    return RBT.return_appdir_prefix(i)
+  end; alias return_appdir_prefix_for return_appdir_prefix # === return_appdir_prefix_for
+
+  # ========================================================================= #
+  # === appdir_location_of?
+  #
+  # Give an input of something like 'foo', this method will return a
+  # path such as '/Programs/Foo/Current'.
+  # ========================================================================= #
+  def appdir_location_of?(i)
+    "#{programs_dir?}#{i.capitalize}/Current"
+  end
+
+  # ========================================================================= #
+  # === string_right_arrow?
+  # ========================================================================= #
+  def string_right_arrow?
+    '→'
+  end; alias right_arrow? string_right_arrow? # === right_arrow?
+
+  # ========================================================================= #
+  # === rarrow?
+  # ========================================================================= #
+  def rarrow?
+    cadetblue(string_right_arrow?)
+  end; alias rarrow rarrow? # === rarrow
+
+  # ========================================================================= #
+  # === is_this_a_header?
+  #
+  # This method determines whether the given input argument could be
+  # considered to be a header-file.
+  # ========================================================================= #
+  def is_this_a_header?(i)
+    i.strip.end_with?('.h')
+  end
+
+  # ========================================================================= #
+  # === does_this_file_exist?
+  # ========================================================================= #
+  def does_this_file_exist?(
+      i, prepend_this = nil
+    )
+    ::RBT.does_this_file_exist?(i, prepend_this)
+  end
+
+  # ========================================================================= #
+  # === return_pwd
+  # ========================================================================= #
+  def return_pwd
+    RBT.return_pwd
+  end; alias return_current_pwd return_pwd # === return_current_pwd
+       alias pwd?               return_pwd # === pwd?
+       alias get_pwd            return_pwd # === get_pwd
+
+  # ========================================================================= #
+  # === sdir_return_pwd
+  #
+  # This method will simply colourize the returned String from the
+  # method return_pwd().
+  # ========================================================================= #
+  def sdir_return_pwd
+    sdir(return_pwd)
+  end
+
+  # ========================================================================= #
+  # === report_pwd
+  # ========================================================================= #
+  def report_pwd
+    e "#{rev}The current directory is `#{sdir_return_pwd}#{rev}`."
+  end; alias verbose_report_pwd report_pwd # === verbose_report_pwd
+
+  # ========================================================================= #
+  # === is_this_a_library?
+  #
+  # This method will check whether the given input is assumed to be a
+  # library or whether it is not. If the input ends with .so or .a
+  # then this is considered to be a library, by this method.
+  #
+  # The check inside of the method body will ensure this.
+  # ========================================================================= #
+  def is_this_a_library?(i)
+    (
+      i.strip.end_with?('.so') or
+      i.strip.end_with?('.a')  or
+      i.strip.end_with?('.o')  or
+      i.strip.include?('.so.') # <- For e. g. "libfoo.so.1.2.3"
+    )
+  end
+
+  # ========================================================================= #
+  # === load_dataset_from_this_expanded_cookbook
+  #
+  # This method will attempt to load the dataset from an expanded
+  # cookbook dataset. In order for this to work, the file must
+  # exist locally.
+  # ========================================================================= #
+  def load_dataset_from_this_expanded_cookbook(
+      i, &block
+    )
+    i = i.to_s unless i.is_a? String # We need Strings.
+    if File.file?(i)
+      use_this_file = i.dup
+    else
+      use_this_file = path_to_this_expanded_cookbooks_dataset(i)
+    end
+    if File.exist? use_this_file
+      load_yaml(use_this_file) # Load the .yml file here, if it exists.
+    else
+      no_file_exists_at(use_this_file, &block)
+      return nil
+    end
+  end; alias return_dataset_from_expanded_cookbook         load_dataset_from_this_expanded_cookbook # === return_dataset_from_expanded_cookbook
+       alias return_dataset_from_this_expanded_cookbook    load_dataset_from_this_expanded_cookbook # === return_dataset_from_this_expanded_cookbook
+       alias quickly_obtain_expanded_cookbook_dataset_from load_dataset_from_this_expanded_cookbook # === quickly_obtain_expanded_cookbook_dataset_from
+
+  # ========================================================================= #
+  # === all_libraries?
+  # ========================================================================= #
+  def all_libraries?
+    require 'rbt/toplevel_methods/all_libraries.rb'
+    RBT.all_libraries?
+  end
+
+  # ========================================================================= #
+  # === load_yaml
+  #
+  # This is a slightly slimpler alternative to load .yml files for the
+  # RBT project.
+  # ========================================================================= #
+  def load_yaml(i)
+    YAML.load_file(i)
+  end
+
+  # ========================================================================= #
+  # === remove_comments_from_each_line
+  #
+  # This method will remove each comment from a given line. Assume
+  # multiline input that will have trailing " # foobar" comments
+  # which will be removed.
+  # ========================================================================= #
+  def remove_comments_from_each_line(i)
+    if i.include? ' # '
+      i = i.split(N).map {|line|
+        if line.include? ' # '
+          line = line[0 .. (line.index('#') - 1)]
+          line.strip!
+        end
+        line
+      }.join(N)
+    end
+    i
+  end
+
+  # ========================================================================= #
+  # === load_yaml_file_from_the_cookbook_directory_for_this_program
+  #
+  # This method can be used to load the specific .yml file from the
+  # cookbook directory.
+  # ========================================================================= #
+  def load_yaml_file_from_the_cookbook_directory_for_this_program(i)
+    target_file = "#{RBT.cookbook_directory?}#{i}.yml"
+    load_yaml(target_file)
+  end
+
+  # ========================================================================= #
+  # === try_to_return_a_special_compile_component
+  # ========================================================================= #
+  def try_to_return_a_special_compile_component(i)
+    action(:try_to_return_a_special_compile_component, i)
+  end
+
+  # ========================================================================= #
+  # === is_symlink?
+  # ========================================================================= #
+  def is_symlink?(i)
+    File.symlink?(i)
+  end
+
+  require 'rbt/toplevel_methods/available_programs.rb'
+  # ========================================================================= #
+  # === n_programs_available?
+  # ========================================================================= #
+  def n_programs_available?
+    RBT.n_programs_available?
+  end; alias n_programs_available n_programs_available? # === n_programs_available
+
+  require 'rbt/toplevel_methods/return_location_to_this_programs_yaml_file.rb'
+  # ========================================================================= #
+  # === return_location_to_this_programs_yaml_file
+  #
+  # Easier access-method to determine where the yaml file may be.
+  # ========================================================================= #
+  def return_location_to_this_programs_yaml_file(i)
+    RBT.return_location_to_this_programs_yaml_file(i)
+  end
+
+  # ========================================================================= #
+  # === ensure_main_encoding_for
+  #
+  # The input to this method should be a String object.
+  # ========================================================================= #
+  def ensure_main_encoding_for(
+      i, use_this_encoding = USE_MAIN_ENCODING
+    )
+    unless i.encoding.to_s.include? use_this_encoding
+      i = i.force_encoding(use_this_encoding)
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === is_github_url?
+  #
+  # This method will return true if the main url (url1) is a github url.
+  # ========================================================================= #
+  def is_github_url?(
+      i = url1?
+    )
+    i and (i.start_with?('https://github.com/') or
+           i.start_with?('http://github.com/'))
+  end; alias is_a_github_url? is_github_url? # === is_a_github_url?
+
+  # ========================================================================= #
+  # === get_all_programs                                   (all programs tag)
+  #
+  # Simply returns all programs from the $PROGRAMS directory.
+  # ========================================================================= #
+  def get_all_programs(
+      from = "#{RBT.programs_directory?}*"
+    )
+    Dir[from] # The constant PROGRAMS is set in config.rb. It has a trailing / 
+  end
+
+  # ========================================================================= #
+  # === all_binaries?
+  # ========================================================================= #
+  def all_binaries?
+    require 'rbt/toplevel_methods/all_binaries.rb'
+    RBT.all_binaries?
+  end
+
+  # ========================================================================= #
+  # === remove_symlink
+  #
+  # This method can be used to selectively remove a symlink.
+  # ========================================================================= #
+  def remove_symlink(i)
+    if i.is_a? Array
+      i.each {|entry| remove_symlink(entry) }
+    else
+      if File.symlink?(i) # Check whether we have a symlink here.
+        File.delete(i)
+      end
+    end
+  end; alias remove_this_symlink remove_symlink # === remove_this_symlink
+
+  require 'rbt/toplevel_methods/symlink.rb'
+  # ========================================================================= #
+  # === symlink                                                 (symlink tag)
+  #
+  # Wrapper to symlinking something.
+  #
+  # The first argument should be the existing target.
+  #
+  # The second argument shall be the name of the new location.
+  #
+  # Since as of November 2019, the following syntax is supported as well:
+  #
+  #   symlink(
+  #        from: @target_directory+'lib64',
+  #        to:   @target_directory+'lib'
+  #      )
+  #
+  # ========================================================================= #
+  def symlink(
+      existing,
+      new_location = nil,
+      be_verbose   = true,
+      use_colours  = RBT.use_colours? # Here we need colours/colours.rb
+    )
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :be_quiet
+      # ===================================================================== #
+      when :be_quiet
+        be_verbose = false
+      end
+    end
+    # ======================================================================= #
+    # === Handle Hashes next
+    # ======================================================================= #
+    if existing.is_a? Hash
+      # ===================================================================== #
+      # === :to
+      # ===================================================================== #
+      if existing.has_key?(:to) and new_location.nil?
+        new_location = existing.delete(:to)
+      end
+      # ===================================================================== #
+      # === :from
+      # ===================================================================== #
+      if existing.has_key?(:from)
+        existing = existing.delete(:from)
+      end
+    end
+    ::RBT.symlink(
+      existing,
+      new_location,
+      be_verbose,
+      use_colours
+    )
+  end; alias do_symlink        symlink # === do_symlink
+       alias symlink_file      symlink # === symlink_file
+       alias symlink_this_file symlink # === symlink_this_file
+       alias create_symlink    symlink # === create_symlink
+
+  # ========================================================================= #
+  # === remove_unnecessary_data_from_url
+  #
+  # This method removes some meaningless information that can be found
+  # in some URLs.
+  # ========================================================================= #
+  def remove_unnecessary_data_from_url(i)
+    i = i.first if i.is_a? Array
+    i = i.to_s.dup
+    i = File.basename(i)
+    i.gsub(/download\?file=/,'').
+      sub(/\/download$/,'').
+      sub(/\?download$/,'').
+      gsub(/-fullsrc/,'').
+      gsub(/-source/,'').
+      gsub(/\?use_mirror=dfn/,'').
+      gsub(/\.src/,'').
+      gsub(/-src/,'')
+      # .gsub(/_/,'-') # This here may be controversial, hence it  
+                       # was disabled as of June 2010.
+      # i = remove_file_extension(i)
+      # ^^^ We can not do the above, because program_full_name
+      # must include the archive.
+  end; alias return_program_full_name_from_url remove_unnecessary_data_from_url # === return_program_full_name
+
+  # ========================================================================= #
+  # === run_simulation?
+  #
+  # This method will tell us whether we shall we run in simulation mode or
+  # whether we shall not. The default is false, as in, we will not run in
+  # simulation mode.
+  #
+  # The simulation mode is required to tell the user what we would do,
+  # without actually doing any of these changes. It is a "dry run", a
+  # test run.
+  # ========================================================================= #
+  def run_simulation?
+    @internal_hash[:run_simulation]
+  end; alias run_simulation run_simulation? # === run_simulation
+       alias in_simulation? run_simulation? # === in_simulation?
+
+  # ========================================================================= #
+  # === internal_hash_set_commandline_arguments
+  #
+  # This method will set the commandline arguments.
+  # ========================================================================= #
+  def internal_hash_set_commandline_arguments(
+      i = ARGV
+    )
+    i = [i].flatten.compact
+    if @internal_hash.nil?
+      reset_the_internal_hash # Trying this since as of 10.06.2023.
+    end
+    @internal_hash[:commandline_arguments] = i
+  end; alias set_commandline_arguments internal_hash_set_commandline_arguments # === set_commandline_arguments
+       alias set_input                 internal_hash_set_commandline_arguments # === set_input
+       alias set_commandline           internal_hash_set_commandline_arguments # === set_commandline
+
+  # ========================================================================= #
+  # === prepend_this_commandline_argument
+  # ========================================================================= #
+  def prepend_this_commandline_argument(i)
+    @internal_hash[:commandline_arguments].prepend(i)
+  end
+
+  # ========================================================================= #
+  # === set_first_commandline_argument
+  # ========================================================================= #
+  def set_first_commandline_argument(i)
+    @internal_hash[:commandline_arguments][0] = i
+  end
+
+  # ========================================================================= #
+  # === first_argument?
+  # ========================================================================= #
+  def first_argument?
+    @internal_hash[:commandline_arguments].first
+  end; alias first?                      first_argument? # === first?
+       alias first_commandline_argument? first_argument? # === first_commandline_argument?
+
+  # ========================================================================= #
+  # === remove_this_commandline_argument
+  #
+  # This method can be used to remove a specific argument
+  # from the commandline arguments.
+  # ========================================================================= #
+  def remove_this_commandline_argument(
+      i, from = commandline_arguments?
+    )
+    from.reject! {|line|
+      line =~ /#{Regexp.quote(i)}/
+    }
+  end
+
+  # ========================================================================= #
+  # === clear_commandline_options
+  # ========================================================================= #
+  def clear_commandline_options
+    @internal_hash[:commandline_arguments] = []
+  end; alias clear_commandline_arguments clear_commandline_options # === clear_commandline_arguments
+
+  # ========================================================================= #
+  # === try_to_require_the_extracter_gem
+  # ========================================================================= #
+  def try_to_require_the_extracter_gem
+    begin
+      require 'extracter'
+    rescue LoadError; end
+  end
+
+  # ========================================================================= #
+  # === try_to_require_wget
+  # ========================================================================= #
+  def try_to_require_wget
+    begin
+      require 'wget'
+    rescue LoadError; end
+  end
+
+  # ========================================================================= #
+  # === try_to_require_the_open_gem
+  # ========================================================================= #
+  def try_to_require_the_open_gem
+    begin
+      require 'open'
+    rescue LoadError; end
+  end
+
+  # ========================================================================= #
+  # === try_to_require_the_environment_information_gem
+  # ========================================================================= #
+  def try_to_require_the_environment_information_gem
+    begin
+      require 'environment_information'
+    rescue LoadError; end
+  end
+
+  # ========================================================================= #
+  # === try_to_require_beautiful_url
+  # ========================================================================= #
+  def try_to_require_beautiful_url
+    begin
+      require 'beautiful_url'
+    rescue LoadError; end
+  end
+
+  # ========================================================================= #
+  # === try_to_require_the_xorg_buffer
+  # ========================================================================= #
+  def try_to_require_the_xorg_buffer
+    begin
+      require 'xorg_buffer' # or: require 'xorg_buffer/module'
+    rescue LoadError
+      if RUBY_PLATFORM.include?('linux') and
+        is_on_roebe?
+        puts 'The gem called `xorg_buffer` is unavailable. '\
+             'Consider installing it.'
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === require_the_rbt_aliases
+  # ========================================================================= #
+  def require_the_rbt_aliases
+    require 'rbt/aliases/aliases.rb'
+  end
+
+  # ========================================================================= #
+  # === main_encoding?
+  # ========================================================================= #
+  def main_encoding?
+    USE_THIS_ENCODING
+  end
+
+  # ========================================================================= #
+  # === is_on_windows?
+  # ========================================================================= #
+  def is_on_windows?
+    RBT.is_on_windows?
+  end; alias are_we_on_windows? is_on_windows? # === are_we_on_windows?
+
+  # ========================================================================= #
+  # === registered_cookbook_entries?
+  # ========================================================================= #
+  def registered_cookbook_entries?
+    require 'rbt/constants/constants.rb'
+    RBT.registered_cookbook_entries?
+  end
+
+  # ========================================================================= #
+  # === set_xorg_buffer
+  # ========================================================================= #
+  def set_xorg_buffer(i)
+    ::RBT.set_xorg_buffer(i)
+  end
+
+  # ========================================================================= #
+  # === file_specification_of_registered_cookbook_entries
+  # ========================================================================= #
+  def file_specification_of_registered_cookbook_entries
+    ::RBT.file_specification_of_registered_cookbook_entries
+  end
+
+  # ========================================================================= #
+  # === move_file                                          (move tag, mv tag)
+  #
+  # Move a file via this method here. Use this consistently whenever you
+  # move a file. Could also be done via File.mv().
+  # ========================================================================= #
+  def move_file(
+      this_file, where_to, be_verbose = true
+    )
+    if be_verbose
+      e "#{rev}Moving from #{sfile(this_file)} to #{sfile(where_to)}."
+    end
+    FileUtils.mv(this_file, where_to)
+  end; alias mv               move_file # === mv
+       alias rename_file      move_file # === rename_file
+       alias rename_directory move_file # === rename_directory
+
+  # ========================================================================= #
+  # === allowed_cookbook_entries?
+  #
+  # This method will load the .yml file containing all registered
+  # cookbook entries.
+  # ========================================================================= #
+  def allowed_cookbook_entries?(
+      i = RBT.file_registered_cookbook_entries
+    )
+    YAML.load_file(i) if File.exist? i
+  end
+
+  # ========================================================================= #
+  # === is_make_available?
+  #
+  # This method will attempt to find out whether make is available. It will
+  # do so by checking on the available path of the host ruby.
+  # ========================================================================= #
+  def is_make_available?(
+      path = query_path?
+    )
+    is_make_available = false # By default it is assumed that make is NOT available.
+    if path.include? ':'
+      check_these_directories = path.split(':')
+      check_these_directories.each {|dir|
+        if File.exist?("#{dir}/make")
+          is_make_available = true # Yup, make is available.
+        end
+      }
+    end
+    return is_make_available
+  end
+
+  # ========================================================================= #
+  # === silent_redirection?
+  # ========================================================================= #
+  def silent_redirection?
+    @internal_hash[:silent_redirection]
+  end; alias original_stdout  silent_redirection? # === original_stdout
+       alias original_stdout? silent_redirection? # === original_stdout?
+
+  # ========================================================================= #
+  # === meson_build_file_exists?
+  #
+  # When we check for the file called "meson.build", we must also
+  # keep in mind that we may use a build directory. This is the reason
+  # why the following code uses a variable.
+  # ========================================================================= #
+  def meson_build_file_exists?(
+      at_this_location    = return_pwd,
+      use_build_directory = false
+    )
+    case at_this_location
+    # ======================================================================= #
+    # === :default
+    # ======================================================================= #
+    when :default
+      at_this_location = return_pwd
+    end
+    if File.exist?(at_this_location) and File.file?(at_this_location)
+      return true
+    else
+      # ===================================================================== #
+      # Next check whether we do use a build directory or whether we do not.
+      # ===================================================================== #
+      if use_build_directory
+        # =================================================================== #
+        # Check the directory below the one given next:
+        # =================================================================== #
+        target_file = File.absolute_path("#{at_this_location}../meson.build")
+        check_for_this_file = target_file
+      else
+        check_for_this_file = "#{at_this_location}meson.build"
+      end
+      return File.exist?(check_for_this_file) # Perform the check here.
+    end
+  end; alias meson_file_exists? meson_build_file_exists? # === meson_file_exists?
+
+  # ========================================================================= #
+  # === project_yaml_directory?
+  #
+  # This will return the path to the yaml directory.
+  # ========================================================================= #
+  def project_yaml_directory?
+    RBT.yaml_directory?
+  end; alias rbt_path?         project_yaml_directory? # === rbt_path?
+       alias project_yaml_dir? project_yaml_directory? # === project_yaml_dir?
+       alias yaml_dir?         project_yaml_directory? # === yaml_dir?
+       alias yaml_directory?   project_yaml_directory? # === yaml_directory?
+
+  require 'rbt/toplevel_methods/roebe.rb'
+  # ========================================================================= #
+  # === is_roebe?
+  #
+  # If we are on our local computer, or on another computer.
+  # ========================================================================= #
+  def is_roebe?
+    RBT.is_roebe?
+  end; alias is_on_roebe? is_roebe? # === is_on_roebe?
+       alias on_roebe?    is_roebe? # === on_roebe?
+
+  # ========================================================================= #
+  # === register_sigint
+  # ========================================================================= #
+  def register_sigint(
+      optional_message      = nil,
+      use_this_as_exit_code = 0
+    )
+    Signal.trap('SIGINT') {
+      if optional_message
+        e optional_message
+      end
+      exit(use_this_as_exit_code)
+    }
+  end
+
+  # ========================================================================= #
+  # === does_this_expanded_cookbook_file_exist_for_this_program?
+  #
+  # This method can be used to determine whether an expanded
+  # cookbook dataset exists for a given program at hand.
+  # ========================================================================= #
+  def does_this_expanded_cookbook_file_exist_for_this_program?(i)
+    return File.exist?(path_to_this_expanded_cookbooks_dataset(i))
+  end; alias does_the_expanded_cookbook_file_exist_for_this_program? does_this_expanded_cookbook_file_exist_for_this_program? # === does_the_expanded_cookbook_file_exist_for_this_program?
+       alias expanded_cookbook_file_exists_for?                      does_this_expanded_cookbook_file_exist_for_this_program? # === expanded_cookbook_file_exists_for?
+
+  # ========================================================================= #
+  # === cd_to_the_temp_directory
+  #
+  # This will cd to the temp directory, while being quiet.
+  # ========================================================================= #
+  def cd_to_the_temp_directory(
+      be_verbose = :be_quiet
+    )
+    cd temp_directory?, be_verbose
+  end
+
+  # ========================================================================= #
+  # === cheering_person?
+  #
+  # This is just an ASCII "person" that is presently cheering. It is meant
+  # to indicate success and/or happiness. For instance, if a compilation-run
+  # has succeeded then we may display such a cheering ASCII "person".
+  #
+  # I found this to be cute and neat - and it is also somewhat useful,
+  # as I tend to use the colour gold for this. Thus it is a slight
+  # visual cue, e. g.:
+  #
+  #   e steelblue('All went well!' )+gold(cheering_person?)
+  #
+  # ========================================================================= #
+  def cheering_person?
+    '\o/'
+  end; alias return_cheering_person cheering_person? # === return_cheering_person
+       alias cheering_person        cheering_person? # === cheering_person
+       alias cheerful_person        cheering_person? # === cheerful_person
+       alias cheering_ascii_person  cheering_person? # === cheering_ascii_person
+
+  # ========================================================================= #
+  # === to_unicode
+  #
+  # This method will "convert" into the Unicode-encoding.
+  # ========================================================================= #
+  def to_unicode(i)
+    i.force_encoding(ENCODING_UTF)
+  end
+
+  # ========================================================================= #
+  # === utf_encoding?
+  # ========================================================================= #
+  def utf_encoding?
+    ENCODING_UTF
+  end
+
+  # ========================================================================= #
+  # === infer_the_namespace
+  #
+  # This will assume the true namespace from the inspectable name.
+  # ========================================================================= #
+  def infer_the_namespace
+    _ = inspect.to_s.delete('<')
+    if _.include? ' '
+      _ = _.split(' ').first.delete('#')
+      if _.include? ':'
+        _ = _.split(':')[0 .. -2].reject {|entry| entry.empty? }.join('::')
+      end
+    end
+    set_the_namespace(_) # And assign it here.
+  end
+
+  # ========================================================================= #
+  # === namespace?
+  # ========================================================================= #
+  def namespace?
+    @internal_hash[:namespace]
+  end
+
+  # ========================================================================= #
+  # === set_namespace
+  # ========================================================================= #
+  def set_namespace(i)
+    @internal_hash[:namespace] = i
+  end; alias set_the_namespace set_namespace # === set_the_namespace
+
+  # ========================================================================= #
+  # === add_to_the_commandline_arguments
+  #
+  # Simply append to the commandline options through this method here.
+  # ========================================================================= #
+  def add_to_the_commandline_arguments(i)
+    # ======================================================================= #
+    # First check whether the input is a Hash:
+    # ======================================================================= #
+    if i.is_a? Hash
+      if i.has_key? :commandline_arguments
+        i = i.delete(:commandline_arguments)
+      end
+    end
+    @internal_hash[:commandline_arguments] << i
+    @internal_hash[:commandline_arguments].flatten!
+  end; alias append_to_the_commandline_arguments     add_to_the_commandline_arguments # === append_to_the_commandline_arguments
+       alias append_these_options_to_the_commandline add_to_the_commandline_arguments # === append_these_options_to_the_commandline
+       alias append_to_the_commandline               add_to_the_commandline_arguments # === append_to_the_commandline
+
+  # ========================================================================= #
+  # === return_commandline_arguments_with_leading_hyphens
+  #
+  # This will select all commandline-arguments with leading '--'
+  # characters.
+  # ========================================================================= #
+  def return_commandline_arguments_with_leading_hyphens(
+      i = commandline_arguments?
+    )
+    i.select {|entry|
+      entry and entry.start_with?('--')
+    }
+  end; alias commandline_arguments_containing_leading_hyphens? return_commandline_arguments_with_leading_hyphens # === commandline_arguments_containing_leading_hyphens?
+       alias commandline_arguments_with_leading_hyphens?       return_commandline_arguments_with_leading_hyphens # === commandline_arguments_with_leading_hyphens?
+       alias commandline_arguments_with_hyphens?               return_commandline_arguments_with_leading_hyphens # === commandline_arguments_with_hyphens?
+       alias return_arguments_with_leading_hyphens             return_commandline_arguments_with_leading_hyphens # === return_arguments_with_leading_hyphens
+       alias return_commandline_arguments_with_hyphens         return_commandline_arguments_with_leading_hyphens # === return_commandline_arguments_with_hyphens
+       alias return_entries_with_leading_hyphens               return_commandline_arguments_with_leading_hyphens # === return_entries_with_leading_hyphens
+       alias hyphen_commandline_arguments?                     return_commandline_arguments_with_leading_hyphens # === hyphen_commandline_arguments?
+       alias return_hyphened_commandline_arguments             return_commandline_arguments_with_leading_hyphens # === return_hyphened_commandline_arguments
+       alias hyphen_arguments                                  return_commandline_arguments_with_leading_hyphens # === hyphen_arguments
+       alias hyphened_arguments?                               return_commandline_arguments_with_leading_hyphens # === hyphened_arguments?
+
+  # ========================================================================= #
+  # === first_non_hyphen_argument?
+  # ========================================================================= #
+  def first_non_hyphen_argument?(
+      i = commandline_arguments_without_hyphens?
+    )
+    i.first
+  end; alias return_first_non_hyphen_argument                           first_non_hyphen_argument? # === return_first_non_hyphen_argument
+       alias first_non_hyphened_argument_from_the_commandline_arguments first_non_hyphen_argument? # === first_non_hyphened_argument_from_the_commandline_arguments
+
+  # ========================================================================= #
+  # === remove_this_entry_from_the_commandline_arguments
+  # ========================================================================= #
+  def remove_this_entry_from_the_commandline_arguments(i)
+    commandline_arguments?.reject! {|entry|
+      entry == i
+    }
+  end
+
+  # ========================================================================= #
+  # === commandline_arguments?
+  # ========================================================================= #
+  def commandline_arguments?
+    @internal_hash[:commandline_arguments]
+  end; alias input?                 commandline_arguments? # === input?
+       alias arguments?             commandline_arguments? # === arguments?
+       alias all_arguments?         commandline_arguments? # === all_arguments?
+       alias commandline?           commandline_arguments? # === commandline?
+       alias commandline_options?   commandline_arguments? # === commandline_options?
+       alias commandline            commandline_arguments? # === commandline
+       alias commandline_args?      commandline_arguments? # === commandline_args?
+
+  # ========================================================================= #
+  # === commandline_arguments_without_hyphens?
+  #
+  # As above, but reversed.
+  # ========================================================================= #
+  def commandline_arguments_without_hyphens?(
+      i = commandline_arguments?
+    )
+    i.select {|entry|
+      entry and !entry.start_with?('--')
+    }
+  end; alias reject_entries_starting_with_hyphens commandline_arguments_without_hyphens? # === reject_entries_starting_with_hyphens
+       alias non_hyphen_arguments                 commandline_arguments_without_hyphens? # === non_hyphen_arguments
+       alias non_hyphened_arguments               commandline_arguments_without_hyphens? # === non_hyphened_arguments
+       alias non_hyphened_arguments?              commandline_arguments_without_hyphens? # === non_hyphened_arguments?
+
+  # ========================================================================= #
+  # === debug?
+  # ========================================================================= #
+  def debug?
+    @internal_hash[:debug]
+  end
+
+  # ========================================================================= #
+  # === enable_debug
+  # ========================================================================= #
+  def enable_debug
+    @internal_hash[:debug] = true
+  end
+
+  # ========================================================================= #
+  # === do_not_debug
+  # ========================================================================= #
+  def do_not_debug
+    @internal_hash[:debug] = false
+  end
+
+  require 'rbt/toplevel_methods/cliner.rb'
+  # ========================================================================= #
+  # === cliner
+  # ========================================================================= #
+  def cliner(
+      optional_arguments = nil,
+      use_this_colour    = nil
+    )
+    if block_given?
+      RBT.cliner(optional_arguments, use_this_colour) { yield }
+    else
+      RBT.cliner(optional_arguments, use_this_colour)
+    end
+  end
+
+  # ========================================================================= #
+  # === unicode_cliner
+  # ========================================================================= #
+  def unicode_cliner(
+      a = :default,
+      b = :default,
+      &block
+    )
+    ::RBT.unicode_cliner(a, b, &block)
+  end
+
+  # ========================================================================= #
+  # === unicode_middle_cliner
+  # ========================================================================= #
+  def unicode_middle_cliner(
+      a = :default,
+      b = :default
+    )
+    ::RBT.unicode_cliner(a, b) { :unicode_middle_horizontal_bar }
+  end
+
+  # ========================================================================= #
+  # === packages_directory?
+  # ========================================================================= #
+  def packages_directory?
+    return ::RBT.packages_directory?
+  end
+
+  # ========================================================================= #
+  # === expanded_cookbooks_directory_exists?
+  #
+  # This method will try and check to see if the expanded-cookbooks
+  # directory exists. If this directory exists then this method will
+  # return true; otherwise this method will return false.
+  # ========================================================================= #
+  def expanded_cookbooks_directory_exists?(
+      target = directory_expanded_cookbooks?
+    )
+    return File.directory?(target)
+  end; alias expanded_directory_exists?           expanded_cookbooks_directory_exists? # === expanded_directory_exists?
+       alias directory_expanded_cookbooks_exists? expanded_cookbooks_directory_exists? # === directory_expanded_cookbooks_exists?
+
+  # ========================================================================= #
+  # === cookbook_directory
+  #
+  # This method will return a String such as:
+  #
+  #   /Programs/Ruby/2.5.1/lib/ruby/site_ruby/2.5.0/rbt/yaml/individual_cookbooks/
+  #
+  # ========================================================================= #
+  def cookbook_directory?
+    return RBT.cookbook_directory?
+  end; alias cookbooks_directory             cookbook_directory? # === cookbooks_directory
+       alias cookbooks_directory?            cookbook_directory? # === cookbooks_directory?
+       alias cookbooks_dir?                  cookbook_directory? # === cookbooks_dir?
+       alias cookbook_dir?                   cookbook_directory? # === cookbook_dir?
+       alias cookbook_directory?             cookbook_directory? # === cookbook_directory?
+       alias individual_cookbooks_dir?       cookbook_directory? # === individual_cookbooks_dir?
+       alias individual_cookbooks_directory? cookbook_directory? # === individual_cookbooks_directory?
+
+  # ========================================================================= #
+  # === remove                                                   (remove tag)
+  #
+  # General remove entry-method. If you wish to delete a file or a directory
+  # or a symlink, use this method.
+  # ========================================================================= #
+  def remove(
+      this_target,
+      be_verbose = false
+    )
+    if this_target.is_a? Array
+      this_target.each {|entry| remove(entry, be_verbose) }
+    else
+      # ===================================================================== #
+      # The next check requires a rescue clause, because the file may no
+      # longer exist.
+      # ===================================================================== #
+      begin
+        type = File.ftype(this_target)
+      rescue Errno::ENOENT
+        type = 'missing_entry'
+      end
+      if File.exist? this_target
+        case type # case tag
+        # =================================================================== #
+        # === remove_symlink
+        # =================================================================== #
+        when 'link','missing_entry' # This entry is for symlinks.
+          remove_symlink(this_target)
+        # =================================================================== #
+        # === remove_file
+        # =================================================================== #
+        when 'file'
+          remove_file(this_target, be_verbose)
+        # =================================================================== #
+        # === remove_directory
+        # =================================================================== #
+        when 'directory'
+          remove_directory(this_target)
+        else # This else clause will not be entered, I think.
+          ewarn "Not removing `#{simp(this)}` as \"#{simp(type)}\" is "\
+                "not registered."
+        end
+      else
+        if be_verbose
+          opne swarn('WARNING: file ')+
+               this_target.to_s+
+               swarn(' does not exist.')
+          opne swarn('Thus, it can not be removed.')
+        end
+      end
+    end
+  end; alias delete remove # === delete
+
+  # ========================================================================= #
+  # === sysetc_directory?
+  # ========================================================================= #
+  def sysetc_directory?
+    RBT.sysetc_directory?
+  end; alias etc_dir? sysetc_directory? # === etc_dir?
+
+  # ========================================================================= #
+  # === get_all_directories_from
+  #
+  # This method can be used to obtain all directories from the given
+  # (first) input argument.
+  # ========================================================================= #
+  def get_all_directories_from(
+      here             = return_pwd,
+      return_full_path = false
+    )
+    RBT.get_all_directories_from(here, return_full_path)
+  end; alias get_dir_listing       get_all_directories_from # === get_dir_listing
+       alias get_directory_listing get_all_directories_from # === get_directory_listing
+       alias get_directories_from  get_all_directories_from # === get_directories_from
+       alias get_dir_listing       get_all_directories_from # === get_dir_listing
+
+  # ========================================================================= #
+  # === get_all_files_from
+  # ========================================================================= #
+  def get_all_files_from(i)
+    return RBT.get_all_files_from(i)
+  end; alias get_files_from get_all_files_from # === get_files
+
+  # ========================================================================= #
+  # === to_iso_encoding
+  # ========================================================================= #
+  def to_iso_encoding(i)
+    i.force_encoding(ENCODING_ISO)
+  end
+
+  # ========================================================================= #
+  # === iso_encoding?
+  # ========================================================================= #
+  def iso_encoding?
+    ENCODING_ISO
+  end
+
+  # ========================================================================= #
+  # === return_all_archives_from_this_directory
+  # ========================================================================= #
+  def return_all_archives_from_this_directory(i)
+    RBT.return_all_archives_from_this_directory(i)
+  end
+
+  # ========================================================================= #
+  # === is_file?
+  # ========================================================================= #
+  def is_file?(i)
+    File.file? i
+  end
+
+  # ========================================================================= #
+  # === a_or_an?
+  #
+  # For proper english titles, we can use "a" or "an".
+  # ========================================================================= #
+  def a_or_an?(i)
+    if i.start_with?('a','i','o','u')
+      'an'
+    else
+      'a'
+    end
+  end
+
+  # ========================================================================= #
+  # === pkgconfig_directory?
+  # ========================================================================= #
+  def pkgconfig_directory?
+    return "#{syslib_dir?}pkgconfig/"
+  end
+
+  # ========================================================================= #
+  # === get_files_and_directories_from
+  # ========================================================================= #
+  def get_files_and_directories_from(
+      i = return_pwd
+    )
+    RBT.get_files_and_directories_from(i)
+  end
+
+  # ========================================================================= #
+  # === append_onto_the_internal_hash
+  # ========================================================================= #
+  def append_onto_the_internal_hash(i)
+    @internal_hash.update(i)
+  end; alias append_onto_the_main_hash append_onto_the_internal_hash # === append_onto_the_main_hash
+
+  # ========================================================================= #
+  # === remove_file_extension
+  #
+  # This method will try to remove anything we declare to be an improper
+  # file extension. We do this by delegating towards class
+  # RemoveFileSuffix, an external dependency.
+  # ========================================================================= #
+  def remove_file_extension(
+      i, also_remove_the_basename = true
+    )
+    case also_remove_the_basename
+    when :do_not_strip_anything
+      also_remove_the_basename = false
+    end
+    if also_remove_the_basename
+      i = File.basename(i)
+    end
+    if    i.end_with? '.src'
+      i[-4,4] = ''
+    elsif i.end_with? '-src'
+      i[-4,4] = ''
+    end
+    i = remove_unnecessary_data_from_url(i.to_s.dup)
+    remove_archive_from_the_end(i)
+  end; alias remove_extension                remove_file_extension # === remove_extensions
+       alias remove_file_suffix              remove_file_extension # === remove_file_suffix
+       alias remove_archive_at_the_end       remove_file_extension # === remove_archive_at_the_end
+       alias remove_suffix_from_the_end      remove_file_extension # === remove_suffix_from_the_end
+       alias remove_archive_stuff_at_the_end remove_file_extension # === remove_archive_stuff_at_the_end
+       alias sanitized_without_extension     remove_file_extension # === sanitized_without_extension
+       alias remove_file_extension           remove_file_extension # === remove_file_extension
+
+  require 'rbt/toplevel_methods/verbose_truth.rb'
+  # ========================================================================= #
+  # === verbose_truth
+  #
+  # This will give us back "yes" or "no", in String form.
+  # ========================================================================= #
+  def verbose_truth(i, optional_arguments = nil)
+    RBT.verbose_truth(i, optional_arguments)
+  end; alias vt             verbose_truth # === vt
+       alias verbose_truth? verbose_truth # === verbose_truth?
+
+  # ========================================================================= #
+  # === is_directory?
+  # ========================================================================= #
+  def is_directory?(i)
+    File.directory? i
+  end
+
+  # ========================================================================= #
+  # === remove_parens
+  #
+  # This method will turn something like ('FOO') into 'FOO'
+  # ========================================================================= #
+  def remove_parens(i)
+    i.delete('()')
+  end
+
+  # ========================================================================= #
+  # === yes_or_no
+  #
+  # Return 'Yes.' or 'No.' through this method here.
+  # ========================================================================= #
+  def yes_or_no(
+      i, optional_instructions = nil
+    )
+    case i
+    when true,'true'
+      i = 'Yes.'
+    when false,'false'
+      i = 'No.'
+    end
+    case optional_instructions
+    # ======================================================================= #
+    # === :minimalistic
+    # ======================================================================= #
+    when :minimalistic
+      i = i.downcase.delete('.') if i
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === return_program_name
+  #
+  # This will always return the proper program name. If you need to modify
+  # that name, you must do so on your own.
+  # ========================================================================= #
+  def return_program_name(
+      i, optional_padding = ' '
+    )
+    _ = ''.dup
+    if REPORT_SPECIFIC_PROGRAM_NAME
+      _ << "#{File.basename(i)}:#{optional_padding}"
+    end
+    return _
+  end; alias rpn return_program_name # === rpn
+
+  # ========================================================================= #
+  # === abbreviations?
+  #
+  # Easier getter-method over the available abbreviations.
+  # ========================================================================= #
+  def abbreviations?
+    RBT.hash_aliases_to_the_available_programs?
+  end
+
+  # ========================================================================= #
+  # === absolute_path
+  #
+  # This method will ensure that there is a trailing '/' on the returned
+  # result, if it is a directory.
+  # ========================================================================= #
+  def absolute_path(i)
+    _ = File.absolute_path(i)
+    # ======================================================================= #
+    # Only append if it is a directory.
+    # ======================================================================= #
+    if File.directory?(_) and !_.end_with?('/')
+      _ = _.dup if _.frozen?
+      _ << '/'
+    end
+    return _
+  end
+
+  # ========================================================================= #
+  # === to_bool
+  # ========================================================================= #
+  def to_bool(i)
+    RBT.to_bool(i)
+  end; alias to_boolean to_bool # === to_boolean
+
+  # ========================================================================= #
+  # === file_dirname_retaining_trailing_slash
+  #
+  # This method will invoke File.dirname(), but it will ensure that
+  # the last character of the result returned will be a '/', if the
+  # given input also ended with a '/' token.
+  # ========================================================================= #
+  def file_dirname_retaining_trailing_slash(i)
+    if i.end_with?('/')
+      return "#{File.dirname(i)}/"
+    else
+      return File.dirname(i)
+    end
+  end
+
+  # ========================================================================= #
+  # === read_file_in_default_encoding
+  # ========================================================================= #
+  def read_file_in_default_encoding(
+      i, use_this_encoding = ::RBT.encoding?
+    )
+    if File.exist? i
+      File.read(
+        i, encoding: use_this_encoding
+      )
+    else
+      e "#{rev}Can not read file `#{i}` as it does not exist."
+    end
+  end; alias default_read read_file_in_default_encoding # === default_read
+       alias file_read    read_file_in_default_encoding # === file_read
+       alias read_read    read_file_in_default_encoding # === read_file
+
+  # ========================================================================= #
+  # === all_files_from
+  # ========================================================================= #
+  def all_files_from(this_directory)
+    Dir[rds(this_directory+'/*')].select {|entry| File.file?(entry) }
+  end
+
+  # ========================================================================= #
+  # === touch                                                     (touch tag)
+  #
+  # Use this unified method whenever you wish to create a new file,
+  # like the UNIX "touch" command.
+  # ========================================================================= #
+  def touch(
+      i,
+      be_verbose = false
+    )
+    case be_verbose
+    when :be_verbose
+      be_verbose = true
+    end
+    if be_verbose
+      e "#{rev}Next creating the file `#{sfile(i)}`."
+    end
+    FileUtils.touch(i)
+  end; alias create_file touch # === create_file
+       alias touch_file  touch # === touch_file
+
+  require 'rbt/toplevel_methods/archive_related_code.rb'
+  # ========================================================================= #
+  # === archive_type_of?
+  #
+  # Determine the archive type of the given input, such as '.tar.xz' and
+  # so forth.
+  # ========================================================================= #
+  def archive_type_of?(i)
+    RBT.return_archive_type(i)
+  end; alias return_archive_type    archive_type_of? # === return_archive_type
+       alias archive_type_of        archive_type_of? # === archive_type_of
+       alias archive_type?          archive_type_of? # === archive_type
+       alias determine_archive_type archive_type_of? # === determine_archive_type
+
+  # ========================================================================= #
+  # === is_superuser?
+  # ========================================================================= #
+  def is_superuser?
+    Process.uid == 0
+  end
+
+  # ========================================================================= #
+  # === cd_to_the_log_directory
+  # ========================================================================= #
+  def cd_to_the_log_directory
+    cd log_directory?
+  end
+
+  # ========================================================================= #
+  # === store_into_this_directory?
+  # ========================================================================= #
+  def store_into_this_directory?
+    _ = RBT.store_into_this_directory?
+    ensure_that_this_directory_exists(_) # Make sure that the directory exists.
+    return _
+  end; alias store_where? store_into_this_directory? # === store_where?
+
+  # ========================================================================= #
+  # === internal_hash?
+  # ========================================================================= #
+  def internal_hash?
+    @internal_hash
+  end; alias ihash                        internal_hash? # === ihash
+       alias ihash?                       internal_hash? # === ihash?
+       alias internal_hash                internal_hash? # === internal_hash
+       alias return_default_internal_hash internal_hash? # === return_default_internal_hash
+
+  require 'rbt/toplevel_methods/rds.rb'
+  # ========================================================================= #
+  # === remove_double_slashes                                       (rds tag)
+  #
+  # Replace // with / in a given string.
+  # ========================================================================= #
+  def remove_double_slashes(i)
+    return RBT.rds(i)
+  end; alias rds remove_double_slashes # === rds
+
+  # ========================================================================= #
+  # === word_wrap
+  #
+  # The first argument is the text that will be reformatted.
+  #
+  # The second argument is at which position we will wrap it.
+  # ========================================================================= #
+  def word_wrap(
+      this_text,
+      n_characters_limit = :default # This should be equal to 78.
+    )
+    ::RBT.wrap_at(this_text, n_characters_limit)
+  end; alias wrap_at word_wrap # === wrap_at
+
+  # ========================================================================= #
+  # === readlines
+  #
+  # This is added in the event that we may wish to use a special encoding,
+  # by default, one day.
+  # ========================================================================= #
+  def readlines(i)
+    File.readlines(i)
+  end
+
+  # ========================================================================= #
+  # === readlines_with_proper_encoding
+  #
+  # File.readlines() variant with proper encoding.
+  # ========================================================================= #
+  def readlines_with_proper_encoding(
+      i,
+      use_this_encoding = main_encoding?
+    )
+    File.readlines(
+      i, encoding: use_this_encoding
+    )
+  end; alias default_readlines readlines_with_proper_encoding # === default_readlines
+       alias proper_readlines  readlines_with_proper_encoding # === proper_readlines
+
+  # ========================================================================= #
+  # === esystem_gold
+  #
+  # A variant for esystem(), via the gold colour on the commandline.
+  # ========================================================================= #
+  def esystem_gold(i)
+    e gold(i)
+    system i
+  end
+
+  # ========================================================================= #
+  # === coloured_and_padded_e
+  # ========================================================================= #
+  def coloured_and_padded_e(
+      i,
+      use_colours        = use_colours?,
+      optional_arguments = nil
+    )
+    case use_colours
+    # ======================================================================= #
+    # === :default
+    # ======================================================================= #
+    when :default
+      use_colours = use_colours?
+    end
+    # ======================================================================= #
+    # Next, modify this command if it includes "--prefix=".
+    # In that event we will colourize it a bit; the prefix will
+    # be colourized in another colour.
+    # ======================================================================= #
+    if i and i.include?('--prefix=') and use_colours
+      i = i.dup
+      # ===================================================================== #
+      # === Colourize the prefix, in cornflowerblue().
+      # ===================================================================== #
+      i.sub!(/(--prefix=)(\/.+?)\s/, # See: https://rubular.com/r/Df8OzLqXGd
+        '\1'+
+        cornflowerblue('\2 ')+
+        ::Colours.remove_escape_sequences(
+          teal('')
+        )
+      )
+    end
+    case optional_arguments
+    # ======================================================================= #
+    # === :inner_padding
+    #
+    # Also use inner-padding here.
+    # ======================================================================= #
+    when :inner_padding
+      i = i.dup
+      i.prepend('  ')
+    end
+    e
+    e i, :fancy_colours # or: teal(i)
+    e
+  end
+
+  # ========================================================================= #
+  # === coloured_esystem
+  # ========================================================================= #
+  def coloured_esystem(i)
+    esystem i, :fancy_colours
+  end; alias colourized_esystem coloured_esystem # === colourized_esystem
+
+  # ========================================================================= #
+  # === esystem
+  #
+  # Combine system() with output of the command.at hand.
+  # ========================================================================= #
+  def esystem(
+      i,
+      use_this_colour = nil
+    )
+    RBT.esystem(i, use_this_colour)
+  end
+
+  # ========================================================================= #
+  # === opnerror                                               (opnerror tag)
+  #
+  # This will combine opn() with stderr-output.
+  # ========================================================================= #
+  def opnerror(
+      i,
+      use_this_as_namespace = namespace?
+    )
+    opn(namespace: use_this_as_namespace) if use_opn?
+    stderr i # Use standard-error output.
+  end
+
+  # ========================================================================= #
+  # === directory_expanded_cookbooks?
+  # ========================================================================= #
+  def directory_expanded_cookbooks?
+    RBT.directory_expanded_cookbooks?
+  end; alias directory_expanded_cookbooks          directory_expanded_cookbooks? # === directory_expanded_cookbooks
+       alias base_dir_to_store_expanded_cookbooks? directory_expanded_cookbooks? # === base_dir_to_store_expanded_cookbooks?
+       alias expanded_cookbooks?                   directory_expanded_cookbooks? # === expanded_cookbooks?
+       alias expanded_cookbook_directory?          directory_expanded_cookbooks? # === expanded_cookbook_directory?
+
+  # ========================================================================= #
+  # === set_use_opn
+  # ========================================================================= #
+  def set_use_opn(i = true) # Must remain true by default.
+    @internal_hash[:use_opn] = i
+  end; alias do_use_opn set_use_opn # === do_use_opn
+
+  # ========================================================================= #
+  # === use_opn=
+  # ========================================================================= #
+  def use_opn=(i = true)
+    @internal_hash[:use_opn] = i
+  end
+
+  # ========================================================================= #
+  # === no_opn
+  # ========================================================================= #
+  def no_opn
+    @internal_hash[:use_opn] = false
+  end; alias disable_opn no_opn # === disable_opn
+
+  # ========================================================================= #
+  # === return_opnn
+  # ========================================================================= #
+  def return_opnn(
+      i = nil
+    )
+    hash = {
+      namespace: namespace?, be_verbose: false
+    }
+    if i
+      if i.is_a? String
+        i = { namespace: i }
+      end
+      hash.update(i)
+    end
+    opnn(hash)
+  end
+
+  # ========================================================================= #
+  # === use_opn?
+  # ========================================================================= #
+  def use_opn?
+    @internal_hash[:use_opn]
+  end; alias show_opnn? use_opn? # === show_opnn?
+
+  # ========================================================================= #
+  # === opnesystem
+  # ========================================================================= #
+  def opnesystem(i)
+    opnn; esystem i
+  end
+
+  # ========================================================================= #
+  # === opnn                                                       (opnn tag)
+  #
+  # The abbreviation "opn" stands for "output program name". This also
+  # describes the major functionality of this method - we will try to
+  # display the name of the program that generates a particular output,
+  # so that the user can understand which component may have went wrong.
+  # ========================================================================= #
+  def opnn(
+      i       = namespace?,
+      use_opn = use_opn?,
+      &block
+    )
+    if use_opn
+      if i.is_a? String
+        i = {
+          namespace:   i,
+          use_colours: use_colours?
+        }
+      end
+      RBT.opnn(i, &block) # ← Let that method handle this.
+    end
+  end; alias output_namespace? opnn # === output_namespace?
+
+  # ========================================================================= #
+  # === opnewarn
+  # ========================================================================= #
+  def opnewarn(i)
+    opne swarn(i)
+  end; alias opnwarn opnewarn # === opnwarn
+       alias owarn   opnewarn # === owarn
+
+  # ========================================================================= #
+  # === opnfancy
+  # ========================================================================= #
+  def opnfancy(i = '')
+    opne sfancy(i)
+  end
+
+  # ========================================================================= #
+  # === opncomment
+  # ========================================================================= #
+  def opncomment(i = '')
+    opnn; ecomment i
+  end
+
+  # ========================================================================= #
+  # === write_what_into_via_unicode
+  #
+  # Delegate towards the SaveFile functionality here. 
+  # ========================================================================= #
+  def write_what_into_via_unicode(
+      what, into, permissions_to_use = '755'
+    )
+    RBT.write_what_into_via_unicode(what, into, permissions_to_use)
+  end
+
+  # ========================================================================= #
+  # === cpr
+  #
+  # This method can be used to recursively copy to a target directory.
+  # ========================================================================= #
+  def cpr(
+      from,
+      to = return_pwd
+    )
+    FileUtils.cp_r(from, to)
+  end
+
+  # ========================================================================= #
+  # === write_what_into
+  #
+  # Delegate towards the SaveFile functionality here. 
+  # ========================================================================= #
+  def write_what_into(
+      what, into, permissions_to_use = '755'
+    )
+    RBT.write_what_into(what, into, permissions_to_use)
+  end; alias save_file       write_what_into # === save_file
+       alias save_what_into  write_what_into # === save_what_into
+       alias store_what_into write_what_into # === store_what_into
+       alias save_what_to    write_what_into # === store_what_to
+
+  # ========================================================================= #
+  # === append_what_into
+  # ========================================================================= #
+  def append_what_into(what, into)
+    RBT.append_what_into(what, into)
+  end
+
+  # ========================================================================= #
+  # === remove_file                                              (remove tag)
+  #
+  # Use this method whenever you wish to remove a file.
+  #
+  # The first input argument to this method shall be the file that we wish
+  # to remove. This means the "file path", so the path to the file has to
+  # be provided, such as "/opt/foobar.md". An Array can also be given,
+  # which will lead to batch-removal of the given files at hand.
+  #
+  # The second input argument to this method, called `report_the_action`,
+  # determines whether we will be verbose or whether we will not be
+  # verbose. Verbose here means that we will notify the user what we
+  # are doing or about to do; not verbose means that we will be
+  # silent when we remove the target file.
+  # ========================================================================= #
+  def remove_file(
+      i, report_the_action = false
+    )
+    if i.is_a? Array
+      i.each {|entry| remove_file(entry, report_the_action) }
+    else
+      RBT.remove_file(i, report_the_action)
+    end
+  end; alias delete_file        remove_file # === delete_file
+       alias delete             remove_file # === delete_file
+       alias remove_files       remove_file # === remove_files
+       alias remove_these_files remove_file # === remove_these_files
+
+  # ========================================================================= #
+  # === copy_files                          (copy tag, cp tag, copy file tag)
+  #
+  # Use this if you need to copy a file.
+  # ========================================================================= #
+  def copy_files(
+      from,
+      to            = return_pwd,
+      be_verbose    = false,
+      use_namespace = true,
+      &block
+    )
+    # ======================================================================= #
+    # === Handle blocks first
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      when :be_verbose
+        be_verbose = true
+      end
+    end
+    case be_verbose # case tag
+    when :be_verbose
+      be_verbose = true
+    end
+    case to
+    when '.'
+      to = return_pwd
+    end
+    # ======================================================================= #
+    # The next method is defined in the file 'prototype.rb'.
+    # ======================================================================= #
+    from = sanitize_for_environment_variable(from) if from.include? '$'
+    to   = sanitize_for_environment_variable(to)   if to.include? '$'
+    # ======================================================================= #
+    # Since as of June 2011, we will also automatically create
+    # the base directory should it not yet exist.
+    # ======================================================================= #
+    unless File.exist? File.dirname(to)
+      create_directory(File.dirname(to))
+    end
+    if File.exist? from
+      if be_verbose
+        if use_namespace
+          opne "#{rev}Now copying the file `#{sfile(from)}#{rev}`"
+          opne "to `#{sfile(to)}#{rev}`."
+        else
+          e "#{rev}Now copying the file `#{sfile(from)}#{rev}`"
+          e "to `#{sfile(to)}#{rev}`."
+        end
+      end
+      FileUtils.cp(from, to)
+    else
+      e "#{rev}Can not copy the file `#{sfile(from)}#{rev}` as "\
+        "it does not appear to exist."
+    end
+  end; alias copy_file copy_files # === copy_file
+       alias copy copy_files      # === copy (copy tag)
+       alias cp   copy_files      # === cp
+
+  # ========================================================================= #
+  # === exit_program                                               (exit tag)
+  #
+  # This is a wrapper to exit, that is, to exit a program. Either we
+  # just exit; or we return the special symbol :break
+  #
+  # A few Symbols may be passed as block to this method, indicating
+  # special behaviour. For instance, the Symbol :exit_no_matter_what
+  # shall indicate that this method ought to exit at all times, no
+  # matter what.
+  # ========================================================================= #
+  def exit_program(
+      symbol_exit            = :standalone,
+      optional_message       = nil,
+      use_this_as_exit_value = 0,
+      &block
+    )
+    e optional_message if optional_message
+    # ======================================================================= #
+    # If we give a number, assume this to be the exit code which we will
+    # use for exiting there.
+    # ======================================================================= #
+    if symbol_exit.to_s =~ /\d+/
+      use_this_as_exit_value = symbol_exit.to_i
+    end
+    if block_given?
+      symbol_exit = yield # This variable may now be a Symbol, such as: :exit_no_matter_what
+    end
+    case symbol_exit
+    # ======================================================================= #
+    # === :connected
+    # ======================================================================= #
+    when :connected,
+         :chained,
+         :continue
+      return :break # i.e. when you run it from a shell. Return the Symbol :break.
+    # ======================================================================= #
+    # === :standalone
+    # ======================================================================= #
+    when :standalone, # ← Added because I like to read the symbol :standalone.
+         :may_we_exit,
+         :exit_no_matter_what,
+         :default,
+         'default',
+         'def',
+         true
+      exit(use_this_as_exit_value)
+    else # this is the default, just like with :standalone too
+      exit(use_this_as_exit_value)
+    end
+  end
+
+  # ========================================================================= #
+  # === chop_off_archive
+  #
+  # Remove the trailing part of an archive, for the most part. This isn't
+  # very sophisticated but it "just works" for most cases (TM).
+  # ========================================================================= #
+  def chop_off_archive(i)
+    if i.include? '#' # Chop off at '#' characters.
+      i = i[0 .. (i.index('#') - 1)]
+    end
+    i.sub!(/\.source$/,'') if i.include? 'source'
+    i.sub!(/-stable$/,'')  if i.end_with? '-stable'
+    return RBT.remove_file_extension(i)
+  end
+
+  # ========================================================================= #
+  # === is_an_archive?
+  #
+  # Query-method to determine whether the given input is assumed to be
+  # an archive. An archive is something like "foobar-1.0.tar.xz".
+  # ========================================================================= #
+  def is_an_archive?(i)
+    return RBT.is_an_archive?(i)
+  end; alias is_archive?         is_an_archive? # === is_archive?
+       alias is_this_an_archive? is_an_archive? # === is_this_an_archive?
+
+  # ========================================================================= #
+  # === set_be_silent
+  #
+  # Set whether we will be verbose or whether we will not.
+  # ========================================================================= #
+  def set_be_silent(i = false) # false because we assign to @internal_hash[:be_verbose]
+    @internal_hash[:be_verbose] = i
+  end; alias be_silent             set_be_silent # === be_silent()
+       alias be_quiet              set_be_silent # === be_quiet()
+       alias set_be_quiet          set_be_silent # === set_be_quiet()
+       alias do_not_be_verbose     set_be_silent # === do_not_be_verbose
+       alias set_do_not_be_verbose set_be_silent # === set_do_not_be_verbose
+
+  # ========================================================================= #
+  # === be_verbose?
+  # ========================================================================= #
+  def be_verbose?
+    @internal_hash[:be_verbose]
+  end
+
+  # ========================================================================= #
+  # === be_quiet?
+  # ========================================================================= #
+  def be_quiet?
+    !@internal_hash[:be_verbose]
+  end
+
+  # ========================================================================= #
+  # === set_be_verbose
+  #
+  # By default we will be verbose.
+  # ========================================================================= #
+  def set_be_verbose(i = true)
+    @internal_hash[:be_verbose] = i
+  end; alias be_verbose  set_be_verbose # Not sure if we will keep this here.
+       alias be_verbose= set_be_verbose # === be_verbose=
+
+  # ========================================================================= #
+  # === be_verbose
+  # ========================================================================= #
+  def be_verbose
+    @internal_hash[:be_verbose] = true
+  end
+
+  # ========================================================================= #
+  # === change_directory                                             (cd tag)
+  #
+  # Change into the given directory.
+  #
+  # The second argument to this method can be used to do additional tasks,
+  # such as creating the directory if it does not yet exist.
+  # ========================================================================= #
+  def change_directory(
+      i,
+      optional_arguments = nil
+    )
+    be_verbose = false
+    # ======================================================================= #
+    # First, handle Symbol-keywords given as first argument.
+    # ======================================================================= #
+    case i
+    when :log_directory
+      i = log_directory?
+    end
+    if block_given?
+      yielded = yield
+      case yielded
+      when :be_verbose
+        be_verbose = true
+      end
+    end 
+    # ======================================================================= #
+    # Past this point, the variable `i` ought to be a String.
+    # ======================================================================= #
+    i = i.to_s unless i.is_a? String
+    case optional_arguments
+    # ======================================================================= #
+    # === :be_quiet
+    # ======================================================================= #
+    when :be_quiet,
+         :quiet,
+         :silent,
+         :be_silent,
+         :do_not_report_anything
+        be_verbose = false
+    # ======================================================================= #
+    # === :be_verbose
+    # ======================================================================= #
+    when :be_verbose,
+         true
+      be_verbose = true
+    # ======================================================================= #
+    # === :create_the_directory_if_it_does_not_exist
+    # ======================================================================= #
+    when :create_the_directory_if_it_does_not_exist
+      FileUtils.mkdir_p(i) unless File.directory? i
+    # ======================================================================= #
+    # === :verbose_create_the_directory_if_it_does_not_exist
+    # ======================================================================= #
+    when :verbose_create_the_directory_if_it_does_not_exist,
+         :ensure_that_the_directory_exists
+      unless File.directory? i
+        if be_verbose
+          opne "#{rev}The directory at `#{sdir(i)}#{rev}` does not exist."
+          opne "#{rev}It will be created now."
+        end
+        FileUtils.mkdir_p(i)
+      end
+    end
+    i = i.dup if i.frozen?
+    i << '/' unless i.end_with? '/'
+    i = rds(i) # Added this here as of May 2014.
+    # ======================================================================= #
+    # Perform the cd-action next.
+    # ======================================================================= #
+    if File.directory? i
+      if be_verbose
+        e "#{rev}Changing into the directory `#{sdir(i.to_s)}#{rev}` now."
+      end
+      Dir.chdir(i) if File.directory? i # This is the actual cd-action.
+    end
+  end; alias chdir      change_directory # === chdir
+       alias change_dir change_directory # === change_dir
+       alias cd         change_directory # === cd
+
+  # ========================================================================= #
+  # === ARRAY_KDE_KONSOLE_COLOURS_IN_USE
+  #
+  # Next, we will define the KONSOLE Colours that can be used.
+  # ========================================================================= #
+  ARRAY_KDE_KONSOLE_COLOURS_IN_USE = %w(
+    aliceblue
+    aquamarine
+    blueviolet
+    cadetblue
+    cornflowerblue
+    crimson
+    cyan
+    darkcyan
+    darkgoldenrod
+    darkgreen
+    darkorchid
+    darkseagreen
+    darkslateblue
+    darkturquoise
+    deepskyblue
+    dodgerblue
+    firebrick
+    forestgreen
+    gold
+    gray
+    grey
+    green
+    hotpink
+    khaki
+    lightblue
+    lightseagreen
+    lightgoldenrodyellow
+    lightgreen
+    lightsalmon
+    lightskyblue
+    lightslategray
+    lightsteelblue
+    limegreen
+    mediumaquamarine
+    mediumorchid
+    mediumpurple
+    mediumseagreen
+    mediumslateblue
+    mediumspringgreen
+    mediumturquoise
+    mediumvioletred
+    navajowhite
+    olive
+    olivedrab
+    orange
+    orangebrown
+    orangered
+    orchid
+    palevioletred
+    paleturquoise
+    peru
+    plum
+    powderblue
+    royalblue
+    salmon
+    saddlebrown
+    sandybrown
+    seagreen
+    silver
+    skyblue
+    slateblue
+    slategray
+    springgreen
+    steelblue
+    rosybrown
+    teal
+    tomato
+    turquoise
+    violet
+    yellow
+    yellowgreen
+  )
+
+  # ========================================================================= #
+  # === use_colours?
+  #
+  # Query whether we may use colours or not.
+  # ========================================================================= #
+  def use_colours?
+    @internal_hash[:use_colours]
+  end; alias we_may_use_colours? use_colours? # === we_may_use_colours?
+
+  # ========================================================================= #
+  # === use_colours=
+  # ========================================================================= #
+  def use_colours=(i = true)
+    @internal_hash[:use_colours] = i
+  end
+
+  # ========================================================================= #
+  # === edir
+  # ========================================================================= #
+  def edir(i = return_pwd)
+    e sdir(i)
+  end
+
+  # ========================================================================= #
+  # === simp
+  # ========================================================================= #
+  def simp(i = '', use_colours = use_colours?)
+    return ::RBT.simp(i) if use_colours
+    return i
+  end; alias simportant simp # === simportant
+
+  # ========================================================================= #
+  # === sdir
+  # ========================================================================= #
+  def sdir(i = '')
+    return ::RBT.sdir(i) if use_colours?
+    return i
+  end
+
+  # ========================================================================= #
+  # === sfile
+  # ========================================================================= #
+  def sfile(i = '')
+    return ::RBT.sfile(i) if use_colours?
+    return i
+  end
+
+  # ========================================================================= #
+  # === efancy
+  # ========================================================================= #
+  def efancy(i = '')
+    e sfancy(i)
+  end
+
+  # ========================================================================= #
+  # === sfancy
+  # ========================================================================= #
+  def sfancy(i = '')
+    return ::RBT.sfancy(i) if use_colours?
+    return i
+  end
+ 
+  # ========================================================================= #
+  # === ssym
+  # ========================================================================= #
+  def ssym(i)
+    return RBT.ssym(i) if use_colours?
+    i
+  end
+
+  # ========================================================================= #
+  # === simp
+  # ========================================================================= #
+  def eimp(i)
+    e simp(i)
+  end
+
+  # ========================================================================= #
+  # === colourize_directory_for_system_results
+  #
+  # This method is to colourize directories that are given via system()
+  # or similar calls. In theory, we could use sdir(), but I wanted to
+  # have another colour.
+  # ========================================================================= #
+  def colourize_directory_for_system_results(i)
+    lightslategray(i)
+  end
+
+  # ========================================================================= #
+  # === KDE colours
+  #
+  # Define the KDE colours in use next.
+  # ========================================================================= #
+  ARRAY_KDE_KONSOLE_COLOURS_IN_USE.each {|this_colour|
+    define_method(this_colour.to_sym) {|i = ''|
+      return ::Colours::HtmlColoursMethods.send(this_colour.to_sym, i) if use_colours?
+      i
+    }
+  }
+
+  # ========================================================================= #
+  # === colourize_this_file_path
+  #
+  # This method will colourize a "file path". So for example, if you have
+  # a file path such as "/opt/foo/bar.rb", then this method will colourize
+  # the directory in one colour, and the file itself (bar.rb) in another
+  # colour.
+  #
+  # The whole idea behind this is to be easily able to separate which
+  # part is the directory and which part is the file.
+  #
+  # If no '/' has been given then the input will be returned unmodified.
+  #
+  # The colour for this can be controlled by the input-arguments.
+  # ========================================================================= #
+  def colourize_this_file_path(
+      i,
+      colour1 = :slateblue, # ← This is the colour for the directory.
+      colour2 = :royalblue  # ← This is the colour for the file.
+    )
+    if i.include? '/'
+      if use_colours?
+        dirname  = File.dirname(i)
+        basename = File.basename(i)
+        dirname  = send(colour1, dirname+'/')
+        basename = send(colour2, basename)
+        i = "#{dirname}#{basename}"
+      end
+    end
+    i
+  end
+
+  # ========================================================================= #
+  # === ecrimson
+  #
+  # This is mostly for debug-related output, e. g. colourize something
+  # via the colour red (or rather, crimson) quickly.
+  # ========================================================================= #
+  def ecrimson(i = '')
+    e crimson(i)
+  end
+
+  # ========================================================================= #
+  # === eblue
+  # ========================================================================= #
+  def eblue(i = '')
+    e steelblue(i)
+  end
+
+  # ========================================================================= #
+  # === colourize_this_error
+  #
+  # This method in particular attempts to colourize some errors.
+  # ========================================================================= #
+  def colourize_this_error(i)
+    return darkgoldenrod(i) if use_colours?
+    return i
+  end
+
+  # ========================================================================= #
+  # === colourize_this_warning
+  # ========================================================================= #
+  def colourize_this_warning(i)
+    return firebrick(i) if use_colours?
+    return i
+  end; alias colourize_for_warnings colourize_this_warning # === colourize_for_warnings
+
+  # ========================================================================= #
+  # === swarn
+  # ========================================================================= #
+  def swarn(
+      i = '', use_colours = use_colours?
+    )
+    return ::RBT.swarn(i) if use_colours
+    return i
+  end
+
+  # ========================================================================= #
+  # === ewarn
+  # ========================================================================= #
+  def ewarn(i = '')
+    e swarn(i) # ← This method will already check for use of colours.
+  end
+
+  # ========================================================================= #
+  # === rev                                                         (rev tag)
+  # ========================================================================= #
+  def rev
+    ::RBT.rev(use_colours?)
+  end
+
+  # ========================================================================= #
+  # === remove_trailing_ANSII_escape_code
+  #
+  # This method can be used if you need to get rid of trailing ANSII
+  # escape sequences from a given String.
+  # ========================================================================= #
+  def remove_trailing_ANSII_escape_code(i)
+    if use_colours?
+      i = ::Colours.remove_trailing_ANSII_escape_code(i)
+    end
+    i
+  end
+
+  # ========================================================================= #
+  # === eparse
+  # ========================================================================= #
+  def eparse(i)
+    if use_colours?
+      Colours.eparse(i)
+    else
+      e i
+    end
+  end
+
+  # ========================================================================= #
+  # === etomato
+  # ========================================================================= #
+  def etomato(i)
+    e tomato(i)
+  end
+
+  # ========================================================================= #
+  # === comment
+  # ========================================================================= #
+  def comment(i)
+    Colours.comment(i) # Delegate to class Colours for this.
+  end
+
+  # ========================================================================= #
+  # === chmod
+  # ========================================================================= #
+  def chmod(i)
+    RBT.chmod(i)
+  end
+
+  # ========================================================================= #
+  # === file_compiled_programs?
+  # ========================================================================= #
+  def file_compiled_programs?
+    RBT.file_compiled_programs?
+  end
+
+  # ========================================================================= #
+  # === return_unicode_warning_symbol_or_empty_string
+  # ========================================================================= #
+  def return_unicode_warning_symbol_or_empty_string
+    if Object.const_defined?(:Roebe) and Roebe.respond_to?(:unicode_warning_symbol)
+      Roebe.unicode_warning_symbol
+    else
+      ''
+    end
+  end
+
+  require 'rbt/toplevel_methods/determine_host_architecture.rb'
+  # ========================================================================= #
+  # === host_system?
+  # ========================================================================= #
+  def host_system?
+    RBT.determine_host_architecture
+  end; alias host_architecture?      host_system? # === host_architecture?
+       alias host_achiteture_in_use? host_system? # === host_achiteture_in_use?
+
+  # ========================================================================= #
+  # === available_programs?
+  # ========================================================================= #
+  def available_programs?
+    RBT.available_programs?
+  end; alias all_programs?             available_programs? # === all_programs?
+       alias all_programs              available_programs? # === all_programs
+       alias all_available_programs?   available_programs? # === all_available_programs?
+       alias available_programs        available_programs? # === available_programs
+       alias available_cookbooks?      available_programs? # === available_cookbooks?
+       alias available_cookbooks       available_programs? # === available_cookbooks
+       alias return_available_programs available_programs? # === return_available_programs
+       alias get_cookbooks             available_programs? # === get_cookbooks
+
+  # ========================================================================= #
+  # === n_programs_are_available?
+  # ========================================================================= #
+  def n_programs_are_available?
+    available_programs?.size
+  end
+
+  # ========================================================================= #
+  # === home_dir?
+  # ========================================================================= #
+  def home_dir?
+    rds("#{ENV['HOME']}/") # We ensure here that a trailing '/' is part of the result.
+  end
+
+  require 'rbt/toplevel_methods/gobolinux.rb'
+  # ========================================================================= #
+  # === is_on_gobolinux?
+  #
+  # The method is_on_gobolinux? can be used to query whether the host
+  # system is using GoboLinux (a linux distribution) or whether it
+  # is not.
+  # ========================================================================= #
+  def is_on_gobolinux?
+    RBT.is_on_gobolinux?
+  end; alias are_we_on_gobolinux? is_on_gobolinux? # === are_we_on_gobolinux?
+
+  require 'rbt/toplevel_methods/convert_global_env.rb'
+  # ========================================================================= #
+  # === convert_env_variable
+  #
+  # This method can be used to convert a ENV variable, such as $BLA,
+  # into its corresponding "real" value.
+  # ========================================================================= #
+  def convert_env_variable(i)
+    RBT.convert_global_env(i)
+  end; alias convert_global_env                convert_env_variable # === convert_global_env
+       alias sanitize_for_environment_variable convert_env_variable # === sanitize_for_environment_variable
+
+  # ========================================================================= #
+  # === return_program_name_for_gobolinux_systems
+  #
+  # This method should ideally return the program name for GoboLinux
+  # systems. Right now it does not work, largely because I have not
+  # found out a reliable way to determine the program name on
+  # GoboLinux-like systems.
+  # ========================================================================= #
+  def return_program_name_for_gobolinux_systems(i)
+    return i
+  end
+
+  # ========================================================================= #
+  # === no_directory_exists_at
+  # ========================================================================= #
+  def no_directory_exists_at(i)
+    e "#{rev}No directory exists at `#{sdir(i)}#{rev}`."
+  end
+
+  # ========================================================================= #
+  # === run_simulation
+  #
+  # Setter method for the ivar @run_simulation.
+  #
+  # This way we can run in simulation mode. That way, we won't do any
+  # modifications, we will only assume that certain things be done.
+  # ========================================================================= #
+  def run_simulation=(i = false)
+    @internal_hash[:run_simulation] = i
+  end
+
+  # ========================================================================= #
+  # === find_cookbook_alias_for
+  #
+  # This method depends on the Cookbooks gem.
+  #
+  # It allows us to find the registered alias for a given program, and
+  # thus acts as an "input-sanitizer".
+  # ========================================================================= #
+  def find_cookbook_alias_for(i)
+    RBT.find_cookbook_alias_for(i)
+  end
+
+  # ========================================================================= #
+  # === debug
+  #
+  # Debug functionality here.
+  # ========================================================================= #
+  def debug(i)
+    cliner { ewarn(i) }
+  end
+
+  # ========================================================================= #
+  # === go_to_base_dir
+  #
+  # Simply go to the temp-directory.
+  # ========================================================================= #
+  def go_to_base_dir(
+      be_verbose = true
+    )
+    _ = temp_dir?
+    if be_verbose
+      opne "Changing to `#{sdir(_)}`."
+    end
+    cd(_)
+  end; alias go_to_the_base_directory go_to_base_dir # === go_to_the_base_directory
+
+  # ========================================================================= #
+  # === to_camelcase
+  # ========================================================================= #
+  def to_camelcase(i)
+    i.split('_').map { |_| _.capitalize }.join
+  end
+
+  # ========================================================================= #
+  # === rename
+  # ========================================================================= #
+  def rename(old_name, new_name)
+    if File.exist? old_name
+      begin
+        File.rename(old_name, new_name)
+      rescue Errno::ENOTEMPTY
+        e 'old_name was: '+old_name
+        e 'new_name was: '+new_name
+        e 'Either directory was not empty.'
+        exit
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === no_such_file_exists
+  # ========================================================================= #
+  def no_such_file_exists(
+      i,
+      be_verbose = true,
+      &block
+    )
+    if block_given?
+      yielded = yield
+      case yielded
+      when :be_quiet
+        be_verbose = false
+      end
+    end
+    if be_verbose
+      e "#{rev}No file called `#{sfile(i)}#{rev}` appears to exist."
+    end
+  end; alias no_file_exists_at no_such_file_exists # === no_file_exists_at
+
+  # ========================================================================= #
+  # === remove_archive_from_the_end
+  #  
+  # This method will remove the "archive part" of the given input, such
+  # as by removing ".tar.xz" from the given input argument (which ought
+  # to be a String).
+  # ========================================================================= #
+  def remove_archive_from_the_end(i)
+    RBT.remove_archive_from_the_end(i)
+  end; alias remove_file_archive_at_the_end    remove_archive_from_the_end # === remove_file_archive_at_the_end
+       alias remove_archive_at_the_end         remove_archive_from_the_end # === remove_archive_at_the_end
+       alias remove_archive_stuff_from_the_end remove_archive_from_the_end # === remove_archive_stuff_from_the_end
+       alias remove_file_extension_from        remove_archive_from_the_end # === remove_file_extension_from
+
+  # ========================================================================= #
+  # === file_predefined_installation_instructions?
+  # ========================================================================= #
+  def file_predefined_installation_instructions?
+    RBT.file_predefined_installation_instructions
+  end; alias file_predefined_installation_instructions file_predefined_installation_instructions? # === file_predefined_installation_instructions?
+
+  # ========================================================================= #
+  # === predefined_installation_instructions?
+  # ========================================================================= #
+  def predefined_installation_instructions? 
+    RBT.predefined_installation_instructions?
+  end
+
+  # ========================================================================= #
+  # === capitalize_first_alphabetical_character
+  #
+  # This method will capitalize on the given input, but it will act
+  # on the first alphabetical character. So for example, if we
+  # input a string such as "/programs" then this method will return
+  # "/Programs".
+  # ========================================================================= #
+  def capitalize_first_alphabetical_character(
+      i = '/programs'
+    )
+    new_string = ''.dup
+    capitalized_already = false
+    i.chars.each {|char|
+      if capitalized_already
+      else
+        if char =~ /[a-zA-Z]/
+          char.upcase!
+          capitalized_already = true
+        end
+      end
+      new_string << char
+    }
+    new_string
+  end
+
+  # ========================================================================= #
+  # === ecomment
+  # ========================================================================= #
+  def ecomment(
+      i           = '',
+      use_colours = use_colours?
+    )
+    if use_colours
+      ::Colours.ecomment(i)
+    else
+      e i
+    end
+  end
+
+  # ========================================================================= #
+  # === silently_create_this_directory_if_it_does_not_yet_exist
+  # ========================================================================= #
+  def silently_create_this_directory_if_it_does_not_yet_exist(i)
+    create_directory(i, :be_quiet)
+  end
+
+  # ========================================================================= #
+  # === create_directory                                          (mkdir tag)
+  #
+  # Consistently use this when you want to create a directory
+  # for the RBT-Project.
+  # ========================================================================= #
+  def create_directory(
+      i           = '/Users/Packages/',
+      be_verbose  = :be_quiet,
+      permissions = :default,
+      &block
+    )
+    yielded = nil # Will be filled up if a block is given.
+    unless i.end_with? '/'
+      i = i.dup if i.frozen?
+      i << '/'
+    end
+    # ========================================================================= #
+    # === Handle blocks next
+    # ========================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :be_quiet
+      # ===================================================================== #
+      when :be_quiet
+        be_verbose = false
+      # ===================================================================== #
+      # === :be_verbose
+      # ===================================================================== #
+      when :be_verbose
+        be_verbose = true
+      end
+    end
+    unless File.directory? i
+      if be_verbose.is_a? Hash
+        # =================================================================== #
+        # We have to handle other keys first, in particular the permissions
+        # key:
+        # =================================================================== #
+        if be_verbose.has_key? :permissions
+          permissions = be_verbose.delete(:permissions)
+        end
+        # =================================================================== #
+        # === :be_quiet
+        # =================================================================== #
+        if be_verbose.has_key? :be_quiet
+          be_verbose = be_verbose.delete(:be_quiet)
+        # =================================================================== #
+        # === :verbosity
+        # =================================================================== #
+        elsif be_verbose.has_key? :verbosity
+          be_verbose = be_verbose.delete(:verbosity)
+        end
+      end
+      case be_verbose
+      # ===================================================================== #
+      # === :be_quiet
+      # ===================================================================== #
+      when :be_quiet,
+           :be_silent
+        be_verbose = false
+      end
+      unless File.directory? i
+        if be_verbose
+          opne "#{rev}Creating the directory `#{sdir(i)}#{rev}` now."
+        end
+        RBT.create_directory(
+          i,
+          permissions,
+          :be_quiet,
+          :do_not_use_opn
+        ) { yielded } # ^^^ We are already verbose above, and handle opn on
+          # our own.
+      end
+    end
+  end; alias mkdir                                     create_directory # === mkdir (mkdir tag)
+       alias mkdir_p                                   create_directory # === mkdir_p
+       alias ensure_that_this_directory_exists         create_directory # === ensure_that_this_directory_exists
+       alias create_directory_if_it_does_not_yet_exist create_directory # === create_directory_if_it_does_not_yet_exist
+
+  # ========================================================================= #
+  # === stderr
+  #
+  # This method is used specifically to indicate errors to the user.
+  # ========================================================================= #
+  def stderr(
+      i                 = '',
+      use_puts_or_print = :puts
+    )
+    if use_colours?
+      i = orangered(i)
+    end
+    RBT.stderr(i, use_puts_or_print)
+  end
+
+  # ========================================================================= #
+  # === enable_colours
+  # ========================================================================= #
+  def enable_colours
+    @internal_hash[:use_colours] = true
+  end; alias set_use_colours enable_colours # === set_use_colours
+       alias do_use_colours  enable_colours # === do_use_colours
+
+  # ========================================================================= #
+  # === disable_colours
+  #
+  # Use this method if you wish to disable colours. Invoke it only when
+  # you really do wish to disable the colours.
+  # ========================================================================= #
+  def disable_colours
+    @internal_hash[:use_colours] = false
+  end; alias do_not_use_colours disable_colours # === do_not_use_colours
+       alias disable_colors     disable_colours # === disable_colors
+
+  # ========================================================================= #
+  # === path_to_this_expanded_cookbooks_dataset
+  #
+  # This method shall attempt to return the full path to the expanded
+  # cookbooks directory dataset of a given program.
+  #
+  # For example, if the input to this method is 'htop' then this method
+  # should return 'htop.yml', or rather,
+  # '/home/Temp/rbt/expanded_cookbooks/htop.yml'.
+  # ========================================================================= #
+  def path_to_this_expanded_cookbooks_dataset(i)
+    i = i.to_s.dup
+    i = remove_archive_at_the_end(
+      File.basename(i)
+    )
+    # ======================================================================= #
+    # The next check leads to problems for input such as "0install.yml".
+    # Unfortunately I did not explain why I added the following line,
+    # so I have removed it on 13.09.2019 again.
+    #
+    # If it is to be re-added, it has to be explained why it is there;
+    # and if not, then it is suggested to remove the code eventually.
+    # ======================================================================= #
+    # if i =~ /\d+/
+    #   i = ProgramInformation.return_program_name(i)
+    # end
+    # ======================================================================= #
+    i << '.yml' unless i.end_with? '.yml'
+    "#{directory_expanded_cookbooks?}#{i}"
+  end; alias return_file_to_the_expanded_cookbooks_dataset path_to_this_expanded_cookbooks_dataset # === return_file_to_the_expanded_cookbooks_dataset
+
+  # ========================================================================= #
+  # === programs_directory?
+  # ========================================================================= #
+  def programs_directory?
+    RBT.programs_directory?.dup
+  end; alias appdir_prefix?      programs_directory? # === appdir_prefix?
+       alias program_directory?  programs_directory? # === program_directory?
+       alias programs_dir?       programs_directory? # === programs_dir?
+       alias programs_directory? programs_directory? # === programs_directory?
+       alias program_dir?        programs_directory? # === program_dir?
+
+  # ========================================================================= #
+  # === program_version_of?
+  # ========================================================================= #
+  def program_version_of?(i)
+    if Object.const_defined? :ProgramInformation
+      if i.include?('-')
+        return ProgramInformation.return_program_version(i)
+      end
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === source_base_directory?
+  # ========================================================================= #
+  def source_base_directory?
+    RBT.source_base_directory?
+  end; alias archive_dir?      source_base_directory? # === archive_dir?
+       alias source_directory? source_base_directory? # === source_directory?
+       alias source_directory  source_base_directory? # === source_directory
+       alias source_dir?       source_base_directory? # === source_dir?
+       alias src_dir?          source_base_directory? # === src_dir?
+
+  # ========================================================================= #
+  # === copy_directory
+  #
+  # This method can be used to copy a directory from a certain location
+  # to the specified (second argument) target directory.
+  # ========================================================================= #
+  def copy_directory(
+      from,
+      to         = return_pwd,
+      be_verbose = false
+    )
+    case to
+    # ======================================================================= #
+    # === :be_verbose
+    # ======================================================================= #
+    when :be_verbose
+      to = return_pwd
+      be_verbose = true
+    end
+    case be_verbose
+    when :be_verbose
+      be_verbose = true
+    end
+    if be_verbose
+      e "#{rev}Now copying the directory `#{sdir(from)}#{rev}` "\
+        "to `#{sdir(to)}#{rev}`."
+    end
+    FileUtils.cp_r(from, to)
+  end
+
+  # ========================================================================= #
+  # === months?
+  #
+  # This method will simply return all months in a given year, via their
+  # english names, such as 'May', 'April'.
+  #
+  # This will be returned as an Array.
+  # ========================================================================= #
+  def months?
+    Date::MONTHNAMES.compact
+  end
+
+  # ========================================================================= #
+  # === get_date
+  #
+  # This method will return a String such as "21 Sep 2023".
+  # ========================================================================= #
+  def get_date
+    ::RBT.get_date
+  end
+  
+  # ========================================================================= #
+  # === get_extended_date
+  #
+  # This method will return a String such as "21 September 2023".
+  # ========================================================================= #
+  def get_extended_date
+    ::RBT.get_extended_date
+  end
+
+  # ========================================================================= #
+  # === today?
+  #
+  # This method will return a String such as "21 September 2017".
+  # ========================================================================= #
+  def today?(
+      display_in_long_format = true
+    )
+    if display_in_long_format # This is the default.
+      Time.now.strftime('%d %B %Y') # => "28 December 2018"
+    else
+      Time.now.strftime('%d.%m.%Y') # => "28.12.2018"
+    end
+  end
+
+  # ========================================================================= #
+  # === dd_mmm_yyy
+  #
+  # This method-format is specifically the default for cookbook-files.
+  # ========================================================================= #
+  def dd_mmm_yyy
+    current_day = ::Time.now.strftime('%d') # This will return a string such as "30".
+    return current_day+
+           ' '+
+           Date::MONTHNAMES[Date.today.month][0,3].capitalize+
+           ' '+
+           ::Time.now.strftime('%Y')
+  end
+
+  # ========================================================================= #
+  # === return_utc_time_in_a_format_similar_to_slackware
+  #
+  # Slackware changelog uses a format such as this one here, in a UTC
+  # format:
+  #
+  #   Thu Sep 21 01:23:24 UTC 2017
+  #
+  # ========================================================================= #
+  def return_utc_time_in_a_format_similar_to_slackware
+    return "#{return_weekday_based_on_utc.to_s} "\
+           "#{return_month_based_on_utc.to_s} "\
+           "#{return_day_of_the_month_based_on_utc} "\
+           "#{return_hours_minutes_seconds_based_on_utc}"\
+           " UTC "\
+           "#{return_year_based_on_utc}"
+  end
+
+  # ========================================================================= #
+  # === remove_directory
+  #
+  # Consistently use this method in order to remove one or more directories.
+  #
+  # Note that '/' is always protected though.
+  # ========================================================================= #
+  def remove_directory(
+      this_directory,
+      be_verbose = false,
+      &block
+    )
+    # ======================================================================= #
+    # Handle blocks given to this method next:
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :be_verbose
+      # ===================================================================== #
+      when :be_verbose
+        be_verbose = true
+      end
+    end
+    if this_directory.is_a? Array
+      this_directory.each {|entry| # Recursive call here.
+        remove_directory(entry, be_verbose)
+      }
+    elsif this_directory.is_a? String
+      case be_verbose
+      when :be_verbose
+        be_verbose = true
+      end
+      this_directory = rds(this_directory).strip # Don't want double slashes in it.
+      if File.directory? this_directory
+        case this_directory # case tag
+        # =================================================================== #
+        # / can never be removed through this method here - at the least
+        # this is our intent.
+        # =================================================================== #
+        when '/' # We will never remove '/', ever.
+          e "#{rev}The #{sdir('/')} #{rev}directory can not be removed "\
+            "via this method." # Tiny "safeguard".
+        # =================================================================== #
+        # RBT.temp_directory?
+        # =================================================================== #
+        when RBT.temp_directory?
+          e "#{rev}Will not remove directory `#{sdir(this_directory)}#{rev}`." # Another tiny "safeguard".
+        else
+          if File.exist?(this_directory) and (this_directory.size > 1)
+            if be_verbose
+              e "#{rev}Removing the directory `#{sdir(this_directory)}#{rev}` "\
+                "next."
+            end
+            FileUtils.rm_rf(this_directory) # Finally remove the directory.
+          end
+        end
+      end
+    else
+      e "#{rev}Unknown input: #{this_directory.class}#{rev}"
+    end
+  end; alias remove_dir               remove_directory # === remove_dir (Remove directory)
+       alias remove_these_directories remove_directory # === remove_these_directories
+       alias remove_directories       remove_directory # === remove_directories
+       alias remove_this_directory    remove_directory # === remove_this_directory
+
+  # ========================================================================= #
+  # === read_file                                                  (read tag)
+  #
+  # Use this method whenever you want to read in a file.
+  # ========================================================================= #
+  def read_file(i)
+    File.read(i) if File.exist? i
+  end; alias read_this_file read_file # === read_this_file
+
+  # ========================================================================= #
+  # === read_file_with_default_encoding
+  # ========================================================================= #
+  def read_file_with_default_encoding(i)
+    if File.exist? i
+      File.read(i, encoding: 'UTF-8')
+    else
+      return i
+    end
+  end
+
+  # ========================================================================= #
+  # === return_program_information
+  # ========================================================================= #
+  def return_program_information(i)
+    if Object.const_defined? :ProgramInformation
+      if i.include?('-')
+        i = ProgramInformation.return_real_short_name(i)
+      end
+    end
+    return i
+  end; alias return_program_name return_program_information # === return_program_name
+
+  # ========================================================================= #
+  # === extract_to?
+  # ========================================================================= #
+  def extract_to?(
+      optional_argument = nil
+    )
+    #result = "#{temp_directory?}"
+    result = "#{log_directory?}"
+    if optional_argument
+      result = result.dup
+      _ = remove_archive_from_the_end(
+            File.basename(optional_argument)
+          )
+      _ = return_program_name(_)
+      result << _
+    end
+    return rds("#{result}/")
+  end
+
+  # ========================================================================= #
+  # === log_directory?
+  #
+  # This will return a String such as "/Depot/Temp/rbt/".
+  #
+  # Several aliases exist to this method, such as the commonly used
+  # variant called log_dir?.
+  # ========================================================================= #
+  def log_directory?
+    RBT.log_directory?
+  end; alias rbt_temp_directory? log_directory? # === rbt_temp_directory?
+       alias log_dir?            log_directory? # === log_dir?
+       alias rbt_log_dir         log_directory? # === rbt_log_dir
+       alias rbt_log_dir?        log_directory? # === rbt_log_dir?
+       alias rbt_log_directory?  log_directory? # === rbt_log_directory?
+       alias rbt_temp_dir?       log_directory? # === rbt_temp_dir?
+       alias rbt_logs?           log_directory? # === rbt_logs?
+
+  # ========================================================================= #
+  # === temp_directory?
+  # ========================================================================= #
+  def temp_directory?
+    RBT.temp_directory?
+  end; alias temp_dir? temp_directory? # === temp_dir?
+       alias temp?     temp_directory? # === temp?
+
+  # ========================================================================= #
+  # === project_base_directory?
+  # ========================================================================= #
+  def project_base_directory?
+    RBT.project_base_directory?
+  end; alias project_base_dir? project_base_directory? # === project_base_dir?
+
+  # ========================================================================= #
+  # === system_directory?
+  # ========================================================================= #
+  def system_directory?
+    RBT.system_directory?
+  end
+
+  # ========================================================================= #
+  # === sysbin_directory?
+  # ========================================================================= #
+  def sysbin_directory?
+    RBT.sysbin_directory?
+  end; alias usr_bin? sysbin_directory? # === sysbin_directory?
+
+  # ========================================================================= #
+  # === sysshare_directory?
+  # ========================================================================= #
+  def sysshare_directory?
+    RBT.sysshare_directory?
+  end; alias share_dir? sysshare_directory? # === share_dir?
+
+  # ========================================================================= #
+  # === sysinclude_directory?
+  # ========================================================================= #
+  def sysinclude_directory?
+    RBT.sysinclude_directory?
+  end; alias include_dir? sysinclude_directory? # === include_dir?
+
+  # ========================================================================= #
+  # === syslib_directory?
+  # ========================================================================= #
+  def syslib_directory?
+    RBT.syslib_directory?
+  end; alias lib_dir? syslib_directory? # === lib_dir?
+
+  # ========================================================================= #
+  # === extract_this_archive
+  # ========================================================================= #
+  def extract_this_archive(
+      i,
+      extract_to = return_pwd
+    )
+    if File.exist?(i)
+      try_to_require_the_extracter_gem
+      action(:extract, i, to: extract_to)
+    end
+  end
+
+  require 'rbt/requires/require_actions.rb'
+  # ========================================================================= #
+  # === action                                                   (action tag)
+  #
+  # This method bundles together all "actionable components". It thus ties
+  # options to the user in a convenient manner, without needing to
+  # remember the name of classes or where the code resides at. All
+  # the user has to know is the name of the action itself, and they
+  # are good to go.
+  #
+  # This method is a simpler wrapper over the toplevel RBT.action()
+  # code.
+  # ========================================================================= #
+  def action(
+      action_that_is_desired = nil,
+      optional_argument1     = ARGV, # This is typically the main input to this method.
+      options_hash           = {},
+      &block
+    )
+    unless ::RBT.respond_to? :action
+      require 'rbt/requires/require_actions.rb'
+    end
+    RBT.action(
+      action_that_is_desired,
+      optional_argument1,
+      options_hash,
+      &block
+    )
+  end; alias actions action # === actions
+
+  # ========================================================================= #
+  # === find_this_yaml_file
+  #
+  # This method can be used to find a proper yaml file.
+  #
+  # We will delegate to Cookbooks for this though.
+  #
+  # We will return the absolute path to the .yml file in question.
+  #
+  # Usage example:
+  #
+  #   find_this_yaml_file(:poppler) # => "/home/x/programming/ruby/src/rbt/lib/rbt/yaml/individual_cookbooks/poppler.yml"
+  #
+  # ========================================================================= #
+  def find_this_yaml_file(i = :poppler)
+    i = i.to_s
+    # ======================================================================= #
+    # The next check has to be explicit for File.file? as well, because
+    # a local directory with that name may exist, which we would not
+    # want to have.
+    # ======================================================================= #
+    if File.exist?(i) and File.file?(i)
+      i
+    else
+      RBT.return_location_of_this_yaml_file(i)
+    end
+  end; alias return_yaml_file_for find_this_yaml_file # === return_yaml_file_for
+
+  # ========================================================================= #
+  # === return_weekday_based_on_utc
+  #
+  # This will return e. g. 'Mon' or 'Fri' or something like that.
+  #
+  # It depends on the constant RFC2822_DAY_NAME.
+  # ========================================================================= #
+  def return_weekday_based_on_utc
+    _ = return_utc
+    wday = _.wday
+    return DAY_NAMES[wday]
+  end
+
+  # ========================================================================= #
+  # === return_current_hour_minutes_second
+  #
+  # This method will return the current time, in HH::MM::SS format.
+  # ========================================================================= #
+  def return_current_hour_minutes_second
+    ::Time.now.strftime '%H:%M:%S' # => "16:08:40"
+  end; alias ss_mm_hh return_current_hour_minutes_second # === ss_mm_hh
+       alias hh_mm_ss return_current_hour_minutes_second # === hh_mm_ss
+
+  # ========================================================================= #
+  # === query_path?
+  #
+  # Query the $PATH variable, from within ENV['PATH'].
+  # ========================================================================= #
+  def query_path?
+    ENV['PATH'].dup # .dup-ing it is better in the long run.
+  end
+
+  # ========================================================================= #
+  # === return_utc
+  #
+  # This method will return a Time object that is in UTC format, such
+  # as "2018-12-28 14:09:26 UTC".
+  # ========================================================================= #
+  def return_utc
+    ::Time.now.getutc
+  end
+
+  # ========================================================================= #
+  # === begins_with_a_comment?
+  # ========================================================================= #
+  def begins_with_a_comment?(i)
+    i.start_with? '#'
+  end
+
+  # ========================================================================= #
+  # === remove_newlines
+  #
+  # Get rid of the newlines.
+  # ========================================================================= #
+  def remove_newlines(i)
+    i.delete("\n")
+  end
+
+  # ========================================================================= #
+  # === change_permission                                         (chown tag)
+  #
+  # This simple method can be used to change permissions, by
+  # making use of FileUtils.chown().
+  # ========================================================================= #
+  def change_permission(
+      file                = 'test',
+      use_this_uid_number = '1000'
+    )
+    FileUtils.chown(use_this_uid_number, use_this_uid_number, file) # Hardcoded right now.
+  end; alias chown change_permission # === chown
+
+  require 'rbt/toplevel_methods/editor.rb'
+  # ========================================================================= #
+  # === editor?
+  # ========================================================================= #
+  def editor?
+    RBT.editor?
+  end
+
+  require 'rbt/toplevel_methods/md5sum.rb'
+  # ========================================================================= #
+  # === display_md5sum?
+  # ========================================================================= #
+  def display_md5sum?
+    RBT.display_md5sum?
+  end; alias show_md5sum? display_md5sum? # === show_md5sum?
+
+  # ========================================================================= #
+  # === open_in_editor
+  #
+  # This will open a cookbook .yml file in the editor.
+  # ========================================================================= #
+  def open_in_editor(i)
+    if i.is_a? Array
+      i.each {|entry| open_in_editor(entry) }
+    else
+      i = i.to_s.dup
+      unless i.end_with? '.yml'
+        i << '.yml'
+      end
+      if is_on_roebe?
+        # =================================================================== #
+        # On my home system.
+        # =================================================================== #
+        unless i.start_with?(RUBY_SRC_RBT_COOKBOOKS) or
+               i.include?('/')
+          i.prepend RUBY_SRC_RBT_COOKBOOKS
+        end
+      else
+        unless i.include? individual_cookbooks_dir?
+          i.prepend(individual_cookbooks_dir?)
+        end
+      end
+      esystem "#{editor?} #{i}"
+    end
+  end; alias open_this_file open_in_editor # === open_this_file
+
+  # ========================================================================= #
+  # === does_this_file_exist_and_is_it_a_file?
+  # ========================================================================= #
+  def does_this_file_exist_and_is_it_a_file?(i)
+    ::RBT.does_this_file_exist_and_is_it_a_file?(i)
+  end
+
+  # ========================================================================= #
+  # === open_in_browser
+  # ========================================================================= #
+  def open_in_browser(i = nil)
+    if i
+      begin
+        require 'open'
+        Open.in_browser(i)
+      rescue LoadError; end
+    end
+  end
+
+  # ========================================================================= #
+  # === opnef                                                     (opnef tag)
+  # ========================================================================= #
+  def opnef(i)
+    opn(namespace: namespace?) if use_opn?
+    ee i
+  end
+
+  # ========================================================================= #
+  # === opne                                                       (opne tag)
+  # ========================================================================= #
+  def opne(
+      i       = nil,
+      use_opn = use_opn?
+    )
+    opn(namespace: namespace?) if use_opn
+    e i if i
+  end
+
+  # ========================================================================= #
+  # === opnerev
+  # ========================================================================= #
+  def opnerev(
+      i       = nil,
+      use_opn = use_opn?
+    )
+    opne "#{rev}#{i}", use_opn
+  end; alias orev opnerev # === orev
+
+  # ========================================================================= #
+  # === return_full_time
+  #
+  # This method will return a String such as '21.09.2017, 03:03:09'.
+  # ========================================================================= #
+  def return_full_time
+    "#{return_date}, #{return_current_hour_minutes_second}"
+  end
+
+  # ========================================================================= #
+  # === return_day_of_the_month_based_on_utc
+  # ========================================================================= #
+  def return_day_of_the_month_based_on_utc
+    return_utc.day.to_s
+  end
+
+  # ========================================================================= #
+  # === return_year_based_on_utc
+  # ========================================================================= #
+  def return_year_based_on_utc
+    return_utc.year.to_s
+  end
+
+  # ========================================================================= #
+  # === return_hours_minutes_seconds_based_on_utc
+  # ========================================================================= #
+  def return_hours_minutes_seconds_based_on_utc
+    _ = return_utc
+    _.strftime('%H:%M:%S') 
+  end
+
+  # ========================================================================= #
+  # === return_month_based_on_utc
+  # ========================================================================= #
+  def return_month_based_on_utc
+    Date::MONTHNAMES[return_utc.month]
+  end
+
+  # ========================================================================= #
+  # === current_hour?
+  #
+  # Consistently use this method whenever you wish to return the
+  # current hour.
+  # ========================================================================= #
+  def current_hour?
+    ::Time.now.strftime('%H:%M:%S') # '04:21:14'
+  end; alias return_time current_hour? # === current_hour?
+
+  # ========================================================================= #
+  # === convert_dd_mm_yyyy_to_its_long_variant
+  # ========================================================================= #
+  def convert_dd_mm_yyyy_to_its_long_variant(
+      i = dd_mm_yyyy.to_s
+    )
+    i = i.to_s
+    if i.include? '.'
+      splitted = i.split('.')
+      splitted[1] = return_month_based_on_this_number(splitted[1]).to_s
+      splitted = splitted.join(' ')
+      return splitted
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === return_month_based_on_this_number
+  #
+  # The input to this method should be an Integer, for the month, such
+  # as 1,2,3 and so forth.
+  # ========================================================================= #
+  def return_month_based_on_this_number(i)
+    Date::MONTHNAMES[i.to_i]
+  end
+
+  # ========================================================================= #
+  # === return_date
+  #
+  # This method wil return a date (a day), such as "21.09.2017" or
+  # "03.06.2018" - in other words, the dd.mm.yyyy format.
+  # ========================================================================= #
+  def return_date
+    RBT.return_date
+  end; alias return_current_date return_date # === return_current_date
+       alias return_current_time return_date # === return_current_time
+       alias dd_mm_yyyy          return_date # === dd_mm_yyyyy
+
+  # ========================================================================= #
+  # === is_this_program_included?
+  #
+  # This method will return a Boolean value (true or false).
+  # ========================================================================= #
+  def is_this_program_included?(i)
+    available_programs?.include?(i)
+  end; alias included?                                is_this_program_included? # === included?
+       alias includes?                                is_this_program_included? # === includes?
+       alias program_was_found?                       is_this_program_included? # === program_was_found?
+       alias include?                                 is_this_program_included? # === include?
+       alias is_included?                             is_this_program_included? # === is_included?
+       alias includes_this_program?                   is_this_program_included? # === includes_this_program?
+       alias is_this_program_registered?              is_this_program_included? # === is_this_program_registered?
+       alias is_the_program_included?                 is_this_program_included? # === is_the_program_included?
+       alias does_include?                            is_this_program_included? # === does_include?
+       alias is_this_program_part_of_the_RBT_project? is_this_program_included? # === is_this_program_part_of_the_RBT_project?
+
+  # ========================================================================= #
+  # === does_the_cookbook_include_this_program?
+  # ========================================================================= #
+  def does_the_cookbook_include_this_program?(i)
+    RBT.does_include?(i)
+  end
+
+  # ========================================================================= #
+  # === e                                                             (e tag)
+  #
+  # The second argument can be a Symbol such as :fancy_colours.
+  # ========================================================================= #
+  def e(
+      i                = '',
+      optional_colours = nil,
+      use_colours      = use_colours?
+    )
+    if use_colours
+      case optional_colours
+      # =================================================================== #
+      # === :fancy_colours
+      # =================================================================== #
+      when :fancy_colours
+        optional_colours = :mediumslateblue
+      else
+        puts i
+      end
+      puts "#{::Colours.send(optional_colours, i)}#{rev}" if optional_colours
+    else
+      puts i
+    end
+  end
+
+  # ========================================================================= #
+  # === coloured_and_padded_esystem
+  #
+  # Usage example:
+  #
+  #   coloured_and_padded_esystem('ls', true, nil, :cornflowerblue)
+  #
+  # ========================================================================= #
+  def coloured_and_padded_esystem(
+      i,
+      use_colours             = use_colours?,
+      optional_arguments      = :inner_padding,
+      use_this_primary_colour = :cornflowerblue,
+      &block
+    )
+    # ======================================================================= #
+    # We need to work on a copy, as we use colours, and system() does
+    # not understand ANSI escape sequences - hence the copy next.
+    # ======================================================================= #
+    this_command_will_be_passed_to_system_directly = i.dup
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      # ===================================================================== #
+      # === Handle Symbols first
+      # ===================================================================== #
+      if yielded.is_a? Symbol
+        if ::Colours.is_this_html_colour_included?(yielded)
+          use_colours = true
+          use_this_primary_colour = yielded
+        end
+      end
+    end
+    case use_colours
+    # ======================================================================= #
+    # === :default
+    # ======================================================================= #
+    when :default
+      use_colours = use_colours?
+    end
+    # ======================================================================= #
+    # Next, modify this command if it includes "--prefix=".
+    #
+    # In that event we will colourize it a bit; the prefix will
+    # be colourized in another colour.
+    # ======================================================================= #
+    if i and i.include?('--prefix=') and use_colours
+      i = i.dup
+      # ===================================================================== #
+      # === Colourize the prefix, in cornflowerblue().
+      # ===================================================================== #
+      i.sub!(/(--prefix=)(\/.+?)\s/, # See: https://rubular.com/r/Df8OzLqXGd
+        '\1'+
+        send(use_this_primary_colour, '\2 ')+
+        ::Colours.remove_escape_sequences(
+          teal('')
+        )
+      )
+    end
+    case optional_arguments
+    # ======================================================================= #
+    # === :inner_padding
+    #
+    # Also use inner-padding here.
+    # ======================================================================= #
+    when :inner_padding
+      i = i.dup
+      i.prepend('  ')
+    end
+    e
+    if use_colours and use_this_primary_colour.is_a?(Symbol)
+      e "#{rev}#{::Colours.send(use_this_primary_colour, i)}"
+    else
+      e "#{rev}#{i}", :fancy_colours # or: teal(i)
+    end
+    e
+    system(this_command_will_be_passed_to_system_directly)
+  end; alias colourize_this_important_system_command  coloured_and_padded_esystem # === colourize_this_important_system_command
+       alias ecolourize_this_important_system_command coloured_and_padded_esystem # === ecolourize_this_important_system_command
+       alias colourized_esystem_with_padding          coloured_and_padded_esystem # === colourized_esystem_with_padding
+       alias colourized_and_padded_esystem            coloured_and_padded_esystem # === colourized_and_padded_esystem
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/colours_e_autoinclude.rb'
+  x = RBT::LeanPrototype.new
+  e x.project_yaml_directory?
+  e x.return_weekday_based_on_utc
+  e x.return_utc_time_in_a_format_similar_to_slackware
+  e x.verbose_truth('true')
+  e x.verbose_truth('t')
+  e
+  pp x.allowed_cookbook_entries?
+  e
+  e 'The programs-directory can be found at: '+
+     RBT.programs_dir?
+end # rbtprototype