environment_information 1.4.124 → 1.5.5

data/lib/environment_information/toplevel_methods/toplevel_methods.rb

@@ -0,0 +1,2258 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/toplevel_methods.rb'
+# EnvironmentInformation.return_simple_version_based_programs
+# EnvironmentInformation.return_version_of_this_program(:ccache)
+# EnvironmentInformation.return_pkgconfig_based_programs
+# EnvironmentInformation.return_version_of_mpc
+# =========================================================================== #
+module EnvironmentInformation
+
+  require 'yaml'
+  require 'environment_information/constants/constants.rb'
+
+  begin
+    require 'rbt/requires/swift_version.rb'
+  rescue LoadError; end
+
+  begin
+    require 'rbt/toplevel_methods/url.rb'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === @hash_available_programs
+  #
+  # This hash stores the available programs.
+  #
+  # We need to use a Hash, rather than an Array, because we may save
+  # the result into a file, such as a yaml file. It is then more
+  # convenient to have the names of the program appear on the left
+  # side directoy, and the version on the right side.
+  #
+  # This Hash will hold the program name on the left side, and the
+  # program version on the right side. A nil value on the right
+  # side indicates that this program is NOT installed - which
+  # makes this the default value.
+  # ========================================================================= #
+  @hash_available_programs = {}
+
+  # ========================================================================= #
+  # === EnvironmentInformation.hash?
+  #
+  # This method will return the Hash of all available programs.
+  # ========================================================================= #
+  def self.hash?
+    @hash_available_programs
+  end; self.instance_eval { alias hash                     hash? } # === EnvironmentInformation.hash
+       self.instance_eval { alias dataset?                 hash? } # === EnvironmentInformation.dataset?
+       self.instance_eval { alias hash_available_programs? hash? } # === EnvironmentInformation.hash_available_programs?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.e
+  # ========================================================================== #
+  def self.e(
+      i    = '',
+      hash = {}
+    )
+    if hash and
+       hash.has_key?(:display_everything_in_short_format) and
+       hash[:display_everything_in_short_format]
+      # ===================================================================== #
+      # Display the results in a single line in this case, separated
+      # via ',' tokens.
+      # ===================================================================== #
+      print "#{i}, "
+    else # This variant here is the default.
+      puts i
+    end
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.add_to_hash
+  #
+  # a refers to left; b refers to right.
+  # ========================================================================= #
+  def self.add_to_hash(a, b)
+    b.strip! if b.is_a?(String) and !b.frozen?
+    if b.nil? # Here we did not provide a value for b.
+      ::EnvironmentInformation.register_this_component_is_missing(a)
+    end
+    @hash_available_programs[a] = b
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.clear_hash
+  #
+  # This method can be used to clear the main (toplevel) Hash.
+  # ========================================================================= #
+  def self.clear_hash
+    @hash_available_programs.clear
+  end; self.instance_eval { alias clear_toplevel_hash clear_hash } # === EnvironmentInformation.clear_toplevel_hash
+       self.instance_eval { alias clear_main_hash     clear_hash } # === EnvironmentInformation.clear_main_hash
+
+  # ========================================================================== #
+  # === @debug
+  #
+  # This variable can be used to control whether we debug the project
+  # or not. It should be false by default (and upon re-destribution of
+  # the project to other users).
+  # ========================================================================== #
+  @debug = false
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_the_most_important_info
+  #
+  # This method will just return a String that can be used right away
+  # in, for example, a sinatra application or a RoR application.
+  # ========================================================================== #
+  def self.return_the_most_important_info
+    "Operating system:                "+
+    "#{::EnvironmentInformation.operating_system}<br>"+
+    "Operating system bit type:       "+
+    "#{::EnvironmentInformation.operating_system_bit_type}<br>"+
+    "CPU model:                       "+
+    "#{::EnvironmentInformation.cpu_model}<br>"
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.n_subcommands?
+  #
+  # Return how many subcommands are available/registered. These are
+  # the tracked programs; and the xorg-components.
+  #
+  # The non-programs will not be gathered by this method, on purpose; they
+  # are not standalone programs after all.
+  #
+  # As of August 2020, 167 programs were tracked by this gem.
+  #
+  # As of March 2024, 256 components were tracked by this gem, so about
+  # 250 programs, give or take.
+  # ========================================================================== #
+  def self.n_subcommands?
+    ARRAY_TRACKED_PROGRAMS.size
+  end
+
+  # ========================================================================== #
+  # === @prefix_to_use
+  #
+  # This variable can be used to designate another base directory to
+  # be used, such as at /home/Programs/ or opt. This allows us to scan
+  # through an AppDir and output the programs found there.
+  #
+  # By default it must be an empty String, as many other files check
+  # on the content of this variable - so only change it if you really
+  # need to use another prefix to use.
+  #
+  # The functionality was specifically added to support versioned
+  # AppDirs on a given computer system.
+  # ========================================================================== #
+  @prefix_to_use = ''.dup
+
+  # ========================================================================== #
+  # === EnvironmentInformation.set_prefix_to_use
+  # ========================================================================== #
+  def self.set_prefix_to_use(i)
+    @prefix_to_use = i.to_s.dup
+  end; self.instance_eval { alias set_prefix set_prefix_to_use } # === EnvironmentInformation.set_prefix
+
+  # ========================================================================== #
+  # === EnvironmentInformation.prefix?
+  # ========================================================================== #
+  def self.prefix?
+    @prefix_to_use
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_doubleconversion
+  # ========================================================================== #
+  def self.return_version_of_doubleconversion(
+      target_file = '/usr/lib/cmake/double-conversion/double-conversionConfigVersion.cmake'
+    )
+    if File.exist? target_file
+      dataset = File.read(target_file)
+      result  = dataset.scan(
+                  /PACKAGE_VERSION "(.+)"/
+                ).flatten.first.to_s
+      return result
+    else
+      return nil
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_boost
+  #
+  # This method will either return a String (the version of boost),
+  # or nil if boost was not found.
+  # ========================================================================== #
+  def self.return_version_of_boost
+    target_file = '/usr/include/boost/version.hpp'
+    if File.exist?('/System/Index/include/boost/version.hpp') and
+      !File.exist?(target_file) # Custom fix.
+      target_file = '/System/Index/include/boost/version.hpp'
+    end
+    if File.exist? target_file
+      dataset = File.readlines(target_file)
+      version = dataset.select {|line|
+        line.include? '#define BOOST_LIB_VERSION'
+      }.first.sub(/#define BOOST_LIB_VERSION/,'').
+              strip.delete('"').tr('_','.')
+      if version.count('.') < 2
+        version << '.0'
+      end
+    else
+      version = nil
+    end
+    return version
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_xvid
+  # ========================================================================== #
+  def self.return_version_of_xvid(
+      target_file = '/usr/include/xvid.h'
+    )
+    if File.exist?('/System/Index/include/'+File.basename(target_file)) and
+      !File.exist?(target_file) # Custom fix.
+      target_file = '/System/Index/include/'+File.basename(target_file)
+    end
+    if File.exist? target_file
+      dataset = File.readlines(target_file)
+      version = dataset.select {|line|
+        line.include? '  XVID_MAKE_VERSION(' # #define XVID_VERSION             XVID_MAKE_VERSION(1,3,7)
+      }
+      if version.is_a? Array
+        version = version.flatten.first.to_s
+      end
+      version = version.scan( # See:  https://rubular.com/r/4anuroBmb40yzh
+        /XVID_MAKE_VERSION\((\d{0,1},\d{0,1},\d{0,1})/
+      )
+      if version.is_a? Array
+        version = version.flatten.first.to_s
+      end
+      version.tr!(',','.')
+    else
+      version = nil
+    end
+    return version
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.is_this_program_included?
+  #
+  # This will include the two Arrays ARRAY_TRACKED_PROGRAMS and
+  # ARRAY_XORG_COMPONENTS, but it will NOT include ARRAY_TRACKED_NON_PROGRAMS.
+  # ========================================================================== #
+  def self.is_this_program_included?(i)
+    (
+      ARRAY_TRACKED_PROGRAMS
+    ).flatten.include? i.to_sym # Need a symbol.
+  end; self.instance_eval { alias is_this_a_registered_program? is_this_program_included? } # === ::EnvironmentInformation.is_this_a_registered_program?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.cd                                    (cd tag)
+  # ========================================================================== #
+  def self.cd(i)
+    Dir.chdir(i) if File.directory? i
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.is_on_roebe?
+  # ========================================================================== #
+  def self.is_on_roebe?
+    ENV['IS_ROEBE'].to_i == 1
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.show_all_available_components
+  #
+  # This method will quickly and easily show all available (registered)
+  # components. If you need more fine-tuning when you wish to display
+  # the main dataset at hand, then you should use other methods that
+  # are also a bit more complex. This method here is really just a
+  # fast version-display overview.
+  #
+  # The second argument to this method contains the programs that we
+  # wish to display through this method.
+  # ========================================================================= #
+  def self.show_all_available_components(
+      n_ljust               = 18,
+      show_these_components = tracked_programs?,
+      use_colours           = use_colours?
+    )
+    clear_main_hash
+    if show_these_components.is_a? Array
+      show_these_components.flatten!
+    end
+    # ======================================================================= #
+    # The next variable determines whether we will also compare the
+    # program versions.
+    # ======================================================================= #
+    compare_program_versions = false
+    default_nljust_value = 30 # ← Detemine default padding.
+    if n_ljust.is_a?(Array) and n_ljust.empty?
+      n_ljust = default_nljust_value # Use the default value in this case.
+    end
+    # ======================================================================= #
+    # First we will treat n_ljust as a commandline-flag if it is a String
+    # and additionally begins with "--".
+    # ======================================================================= #
+    if n_ljust.is_a?(Array) and n_ljust.first.start_with?('--')
+      _ = n_ljust.first
+      case _
+      # ===================================================================== #
+      # === --help
+      #
+      # Invocation example:
+      #
+      #   showcomponents --help
+      #
+      # ===================================================================== #
+      when /^-?-?help$/i
+        e 'The following options are available for bin/fast_envi (fenvi):'
+        e
+        e '   --xorg                        # show only the xorg-components'
+        e '   --compare-to-program-versions # also compare the program versions'
+        e
+        exit
+      # ===================================================================== #
+      # === --compare-to-program-versions
+      #
+      # To invoke this, try:
+      #
+      #   show_components --compare
+      #   envi --compare-version
+      #
+      # ===================================================================== #
+      when *ARRAY_COMPARE_PROGRAM_VERSIONS
+        compare_program_versions = true
+        n_ljust = default_nljust_value
+      # ===================================================================== #
+      # === --xorg
+      # ===================================================================== #
+      when /^-?-?xorg$/i
+        show_these_components = ::EnvironmentInformation.xorg_components?
+        n_ljust = default_nljust_value
+      end
+    end
+    e
+    uniq = show_these_components.uniq
+    uniq.sort.each {|this_program|
+      use_this_name_for_send = "return_version_of_#{this_program}"
+      # ===================================================================== #
+      # Next, add the name of the program at hand, onto the left hand side:
+      # ===================================================================== #
+      result = this_program.to_s.ljust(n_ljust)
+      if use_colours
+        result = ::EnvironmentInformation.colourize_and_pad_the_left_side(result)
+      end
+      # ===================================================================== #
+      # Some components may not be installed on the user's computer system,
+      # which we have to keep in mind in the following code. This is
+      # why we will first apply the .send(), before checking whether
+      # the program at hand is actually missing or not.
+      # ===================================================================== #
+      result_of_send = send(use_this_name_for_send)
+      if result_of_send
+        result_of_send = result_of_send.dup if result_of_send.frozen?
+        result_of_send.strip!
+      end
+      @hash_available_programs[this_program.to_sym] = result_of_send.to_s
+      right_component = ''.dup
+      if @array_this_component_is_missing.include?(this_program.to_sym)
+        right_component << "not installed (or otherwise not found)".ljust(12)
+      else
+        right_component << result_of_send.ljust(12) if result_of_send
+      end
+      if use_colours
+        # =================================================================== #
+        # We will distinguish between components that have been found and
+        # components that have not been found.
+        # =================================================================== #
+        if right_component.include?('not installed')
+          right_component = ::Colours.send(:mediumslateblue, right_component)
+        else
+          right_component = ::Colours.send(colour_for_the_right_side, right_component)
+        end
+      end
+      result = result.dup if result.frozen?
+      result << right_component
+      if compare_program_versions
+        if is_this_program_included?(this_program)
+          registered_local_version = RBT.swift_return_version_of_this_program(this_program.to_sym).to_s.dup
+          if registered_local_version.include? 'v'
+            # =============================================================== #
+            # Modify entries such as 'v12.15.0' into '12.15.0'.
+            # =============================================================== #
+            registered_local_version.delete!('v')
+          end
+          case this_program.to_s
+          when 'gtk2'
+            registered_local_version = query_pkgconfig_version_for(:gtk2)
+          else
+            if result_of_send.nil?
+              # ^^^ This is missing, then, so it will be ignored.
+            elsif registered_local_version <= result_of_send 
+              # This is ok.
+            else
+              result << 
+                royalblue(
+                  "\n    "\
+                  "^^^ This could be updated; the version in "\
+                  "RBT is: #{mediumpurple(registered_local_version)}"
+                )
+            end
+          end
+        end
+      end
+      # ===================================================================== #
+      # Finally display our findings to the end user.
+      # ===================================================================== #
+      e result
+    }
+    e
+    if is_on_roebe? # And store it on my home system too.
+      ::EnvironmentInformation.store_relevant_files
+    end
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.replay_from_the_stored_file
+  #
+  # To invoke this method from the commandline, try:
+  #
+  #   envi --replay
+  #
+  # ========================================================================= #
+  def self.replay_from_the_stored_file(
+      _ = return_path_to_the_all_programs_file
+    )
+    if File.exist? _
+      e "Loading from the file #{_}."
+      @hash_available_programs = YAML.load_file(_)
+      @hash_available_programs.each_pair {|key, value|
+        e "#{key}:"+value.to_s
+      }
+    else
+      e "No file exists at #{_}."
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.ee
+  #
+  # This is simply a wrapper over print, as well as adding a ', ' to that.
+  # ========================================================================== #
+  def self.ee(
+      i = ''
+    )
+    print "#{i}, "
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.internet_is_available?
+  # ========================================================================== #
+  def self.internet_is_available?
+    require 'resolv'
+      dns_resolver = Resolv::DNS.new
+    begin
+      # ====================================================================== #
+      # The first domain name ever. Will probably not be removed.
+      # ====================================================================== #
+      dns_resolver.getaddress('symbolics.com')
+      return true
+    rescue Resolv::ResolvError => _error
+      return false
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_alias_to
+  #
+  # This method will return some abbreviations to programs.
+  # ========================================================================== #
+  def self.return_alias_to(i)
+    if i.is_a? Array
+      i = i.first
+    end
+    case i.to_sym
+    # ======================================================================== #
+    # === :find
+    # ======================================================================== #
+    when :find
+      i = :findutils
+    # ======================================================================== #
+    # === :diff
+    # ======================================================================== #
+    when :diff
+      i = :diffutils
+    # ======================================================================== #
+    # === :yacc
+    # ======================================================================== #
+    when :yacc
+      i = :bison
+    end
+    return i # Always return something.
+  end
+
+  # ========================================================================== #
+  # === Environment.verbose_truth
+  # ========================================================================== #
+  def self.verbose_truth(i)
+    case i
+    when /true/
+      'Yes.'
+    when /false/
+      'No.'
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.load_file_query_to_use_for_the_individual_components
+  # ========================================================================== #
+  def self.load_file_query_to_use_for_the_individual_components(
+      i = ::EnvironmentInformation.project_base_directory?+
+          'yaml/query_to_use_for_all_components.yml' # FILE_QUERY_TO_USE_FOR_THE_INDIVIDUAL_COMPONENTS
+    )
+    if File.exist? i
+      return YAML.load_file(i)
+    else
+      return {}
+    end
+  end; self.instance_eval { alias all_the_queries                  load_file_query_to_use_for_the_individual_components } # === EnvironmentInformation.all_the_queries
+       self.instance_eval { alias query_to_use_for_all_components  load_file_query_to_use_for_the_individual_components } # === EnvironmentInformation.query_to_use_for_all_components
+       self.instance_eval { alias query_to_use_for_all_components? load_file_query_to_use_for_the_individual_components } # === EnvironmentInformation.query_to_use_for_all_components?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_remote_gtk2_version
+  #
+  # This method can be used to obtain the latest gtk2-version, from a
+  # remote URL.
+  #
+  # The reason why this was necessary is because the RBT project may not
+  # always keep the latest gtk2 version, since gtk3 (and so forth) is more
+  # recent. Since we may still have to find out which gtk2 version is the
+  # most recent, we need a method to do so - which is precisely what this
+  # method here is doing.
+  # ========================================================================== #
+  def self.return_remote_gtk2_version
+    # ======================================================================= #
+    # We will use a hardcoded URL pointing towards gtk2:
+    # ======================================================================= #
+    remote_url = 'https://ftp.gnome.org/pub/GNOME/sources/gtk+/2.24/?C=M;O=D'
+    require 'open-uri'
+    newest_version = ''
+    # ======================================================================= #
+    # We will next try to obtain the remote dataset, but this would
+    # fail if we have no www-connection, so we must rescue this step.
+    # ======================================================================= #
+    if internet_is_available?
+      begin
+        dataset = URI.open(remote_url).read
+        use_this_regex =
+          /<a href="gtk\+\-(\d.\d\d.\d\d).tar.xz"><img src=/
+        scanned = dataset.scan(use_this_regex).flatten
+        newest_version = scanned.first
+      rescue SocketError => error
+        puts "It seems as if we have no working internet "\
+             "connection (#{sfancy(error.class)})"
+      end
+    end
+    return newest_version.strip # ← And return it here.
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.is_this_component_included?
+  #
+  # This is a more extensive check than .is_this_program_included?()
+  # ========================================================================== #
+  def self.is_this_component_included?(i)
+    array = tracked_components?
+    array.flatten.include? i.to_sym # Need a Symbol as input.
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.lfs_core_programs?
+  # ========================================================================== #
+  def self.lfs_core_programs?
+    ARRAY_LFS_CORE_PROGRAMS
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_busybox        (busybox tag)
+  # ========================================================================== #
+  def self.return_version_of_busybox(
+      i = "busybox #{ERROR_LINE}"
+    )
+    result = ::EnvironmentInformation.return_very_silent_system_output_from(i)
+    if result and result.is_a?(String) and result.include?("\n")
+      first_line = result.split("\n").first
+      if first_line.include? ' v'
+        # "BusyBox v1.32.0 (2020-11-08 04:41:56 Etc) multi-call binary.\n"
+        use_this_regex = /v(\d{0,1}.\d{0,2}.\d{0,1})/ # See: https://rubular.com/r/MpnFXlalLCXXGI
+        result = first_line.scan(use_this_regex).flatten.first.to_s
+        return result
+      end
+    end
+    return nil
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_xrandr
+  # ========================================================================== #
+  def self.return_version_of_xrandr(
+      i = 'xrandr --version'
+    )
+    result = ::EnvironmentInformation.return_very_silent_system_output_from(i)
+    if result
+      version = result.strip.split("\n")
+      if version.is_a?(Array)
+        version = version.first.split(' ').last.strip # Assume: "xrandr program version       1.5.1"
+        # or: result = splitted.first.sub(/xrandr program version/,'')
+        return version.strip
+      end
+    end
+    return nil
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.cflags?                           (cflags tag)
+  #
+  # The following is equivalent to the value stored in the variable
+  # $CFLAGS, which on unix-like systems may be obtained by issuing
+  # the following command:
+  #
+  #     echo $CFLAGS
+  #
+  # The output may be like this:
+  #
+  #   -O2 -fPIC -fno-strict-overflow -Wno-error
+  #
+  # ========================================================================== #
+  def self.cflags?
+    _ = ENV['CFLAGS'].to_s.strip
+    _ = '<none>' if _.empty? # Display special status if it is empty.
+    return _
+  end; self.instance_eval { alias return_version_of_cflags cflags? } # === EnvironmentInformation.return_version_of_cflags
+       self.instance_eval { alias cflags                   cflags? } # === EnvironmentInformation.cflags
+       self.instance_eval { alias cflags_in_use?           cflags? } # === EnvironmentInformation.cflags_in_use?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.rubygems_installation_directory
+  #
+  # This method will return the path to the rubygems installation
+  # directory, if possible (if it exists).
+  #
+  # As this ought to be a directory, we will ensure that a trailing '/'
+  # token is returned.
+  #
+  # This method may return a String such as "/root/.gem/".
+  # ========================================================================== #
+  def self.rubygems_installation_directory(
+      prefix_to_use = @prefix_to_use
+    )
+    result = silent_sys_command("#{prefix_to_use}gem env")
+    unless result.include? 'not found'
+      # ===================================================================== #
+      # Apply a regex next.
+      # ===================================================================== #
+      path_to_the_rubygem_directory = result.to_s.scan(
+        /INSTALLATION DIRECTORY: (.+)/ # Obtain the proper match here.
+      ).flatten.first.to_s
+      if File.directory? path_to_the_rubygem_directory
+        path_to_the_rubygem_directory << '/' # Append the trailing '/' here.
+      end unless path_to_the_rubygem_directory.end_with? '/'
+      result = path_to_the_rubygem_directory
+    else
+      result = nil
+    end
+    return result
+  end; self.instance_eval { alias add_rubygems_installation_directory_information   rubygems_installation_directory } # === EnvironmentInformation.add_rubygems_installation_directory_information
+       self.instance_eval { alias add_rubygem_directory_information                 rubygems_installation_directory } # === EnvironmentInformation.add_rubygem_directory_information
+       self.instance_eval { alias append_rubygem_installation_directory             rubygems_installation_directory } # === EnvironmentInformation.append_rubygem_installation_directory
+       self.instance_eval { alias return_version_of_rubygems_installation_directory rubygems_installation_directory } # === EnvironmentInformation.return_version_of_rubygems_installation_directory
+       self.instance_eval { alias rubygems_installation_directory?                  rubygems_installation_directory } # === EnvironmentInformation.rubygems_installation_directory?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.screen_resolution                 (screen tag)
+  #
+  # This method will typically make use of xdpyinfo first, as it also
+  # works in a .cgi environment. For non-cgi environments, on linux,
+  # we could use xrandr, which is a bit more elegant.
+  #
+  # On success, the method here will return a String such as "1920x1080".
+  # ========================================================================== #
+  def self.screen_resolution
+    result = '(unknown)' # This is the default return-value, then.
+    # ======================================================================= #
+    # === Check for linux as host OS first
+    # ======================================================================= #
+    if RUBY_PLATFORM.downcase.include? 'linux'
+      # ================================================================= #
+      # We have to be careful as xdpyinfo may not be installed on the
+      # given computer system.
+      # ================================================================= #
+      # resolution = `xdpyinfo #{ERROR_LINE}`.scan(/dimensions:.+$/).first # The error here may be: "xdpyinfo:  unable to open display"
+      resolution = silent_sys_command('xdpyinfo').scan(/dimensions:.+$/).first # The error here may be: "xdpyinfo:  unable to open display"
+      if resolution and resolution.include? ':'
+        result = resolution.split(':').last.strip.split('pixels').first.strip # Or split on: /(\d{1,5}x\d{1,4})/
+      end
+    # ======================================================================= #
+    # === Else simply assume the computer to run windows here
+    # ======================================================================= #
+    else
+      result = `wmic desktopmonitor get screenheight,screenwidth #{ERROR_LINE}`
+    end
+    return result
+  end; self.instance_eval { alias screen_resolution?                  screen_resolution } # === EnvironmentInformation.screen_resolution?
+       self.instance_eval { alias return_version_of_screen_resolution screen_resolution } # === EnvironmentInformation.return_version_of_screen_resolution
+
+  # ========================================================================== #
+  # === EnvironmentInformation.ram?                                 (ram tag)
+  #
+  # This method will determine how much RAM the given computer host has.
+  #
+  # The result will be given in n MB.
+  #
+  # Alternatively we could use /proc/meminfo and look for 'MemTotal:'.
+  # ========================================================================== #
+  def self.ram?
+    result_in_n_mb = silent_sys_command('free -m').split("\n")[1]
+    if result_in_n_mb and result_in_n_mb.include?(' ')
+      result_in_n_mb = result_in_n_mb.split(' ')[1]
+    end
+    return result_in_n_mb
+  end; self.instance_eval { alias return_version_of_ram ram? } # === EnvironmentInformation.return_version_of_ram
+       self.instance_eval { alias ram                   ram? } # === EnvironmentInformation.ram
+
+  # ========================================================================== #
+  # === EnvironmentInformation.operating_system                      (os tag)
+  #
+  # This method is also known as "bit type".
+  #
+  # The return value of this method may be a String such as this one here:
+  #
+  #   "GNU/Linux"
+  #
+  # This is then further modified a bit to drop the "GNU/" part
+  # specifically.
+  #
+  # An alternative to "uname -mo" would be "uname -a".
+  # ========================================================================== #
+  def self.operating_system(
+      i = 'uname -mo'
+    )
+    result = silent_sys_command(i).chomp
+    if result.start_with? 'GNU'
+      # ====================================================================== #
+      # The next part removes 'GNU/' specifically. It is a simpler name
+      # than "GNU Linux" and variants, just as "BSD" is simpler than
+      # e. g. "FreeBSD". You can reason that it may be "less accurate",
+      # but it makes the notification-part of this gem simpler.
+      # ====================================================================== #
+      result.sub!(/^GNU\//,'') # Experimental as of Sep 2019.
+    end
+    if result.include? ' '
+      result = result.split(' ').last
+    end
+    return result
+  end; self.instance_eval { alias operating_system?                         operating_system } # === EnvironmentInformation.operating_system?
+       self.instance_eval { alias operating_system_information?             operating_system } # === EnvironmentInformation.operating_system_information
+       self.instance_eval { alias add_operating_system_information          operating_system } # === EnvironmentInformation.add_operating_system_information
+       self.instance_eval { alias append_operating_system_in_use            operating_system } # === EnvironmentInformation.append_operating_system_in_use
+       self.instance_eval { alias add_os_information                        operating_system } # === EnvironmentInformation.add_os_information
+       self.instance_eval { alias operating_system_in_use?                  operating_system } # === EnvironmentInformation.operating_system_in_use?
+       self.instance_eval { alias return_version_of_operating_system        operating_system } # === EnvironmentInformation.return_version_of_operating_system
+       self.instance_eval { alias return_version_of_operating_system_in_use operating_system } # === EnvironmentInformation.return_version_of_operating_system_in_use
+
+  # ========================================================================== #
+  # === EnvironmentInformation.operating_system_bit_type_information (bit tag, bit type tag)
+  #
+  # This method will return the bit type in use, as a String, such as "x86_64"
+  # or "x86_64 (64 bit)" specifically. The reason why this method appends
+  # ' (64 bit)' is mostly so that the user can quickly see whether a computer
+  # is on 32 bit or on 64 bit.
+  # ========================================================================== #
+  def self.operating_system_bit_type_information
+    result = silent_sys_command('uname -m')
+    result.chomp!
+    result = result.split(' ')[-1] if result.include?(' ')
+    result = result.dup if result.frozen?
+    case result
+    when 'x86_64'
+      result << ' (64 bit)'
+    end
+    return result
+  end; self.instance_eval { alias bit_type?                                   operating_system_bit_type_information } # === EnvironmentInformation.bit_type?
+       self.instance_eval { alias return_version_of_operating_system_bit_type operating_system_bit_type_information } # === EnvironmentInformation.return_version_of_operating_system_bit_type
+       self.instance_eval { alias add_bit_type_information                    operating_system_bit_type_information } # === EnvironmentInformation.add_bit_type_information
+       self.instance_eval { alias add_operating_system_bit_type               operating_system_bit_type_information } # === EnvironmentInformation.add_operating_system_bit_type
+       self.instance_eval { alias operating_system_bit_type?                  operating_system_bit_type_information } # === EnvironmentInformation.operating_system_bit_type?
+       self.instance_eval { alias operating_system_bit_type                   operating_system_bit_type_information } # === EnvironmentInformation.operating_system_bit_type
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_mpc
+  #
+  # This method will read the version-string from a .h header file.
+  # ========================================================================== #
+  def self.return_version_of_mpc
+    target_file = '/usr/include/mpc.h'
+    if File.exist? target_file
+      dataset = File.read(target_file)
+      use_this_regex = /MPC_VERSION_STRING "([0-9\.]+)"$/
+      dataset = dataset.scan(use_this_regex).flatten
+      version = dataset.first
+      return version
+    else
+      return THE_PROGRAM_WAS_NOT_FOUND
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_remote_url_of_this_program
+  #
+  # This method will try to return the remote URL of the given program.
+  #
+  # Note that this functionality depends on the RBT project, which
+  # explains the rescued required statement in the method. While in
+  # theory we could create a stand-alone solution, I don't want to
+  # duplicate code I already wrote for another project, so users
+  # are encouraged to install the rbt gem - it's what I use on my
+  # home system as well.
+  # ========================================================================== #
+  def self.return_remote_url_of_this_program(i = ARGV)
+    if i.is_a? Array
+      i = i.first
+    end
+    begin
+      require 'rbt/cookbooks/url/url.rb'
+      i = RBT.return_url1_of_this_program(i)
+    rescue LoadError; end
+    i
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.show_remote_url_of_this_program
+  #
+  # This method will try to show the remote URL of the given program.
+  # ========================================================================== #
+  def self.show_remote_url_of_this_program(i = ARGV)
+    puts return_remote_url_of_this_program(i)
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.cpuinfo?                         (cpuinfo tag)
+  #
+  # This method currently relies on /proc/cpuinfo, thus favouring
+  # Linux-based systems.
+  #
+  # The output will be similar to this:
+  #
+  #   AMD A8-7600 Radeon R7, 10 Compute Cores 4C+6G, 4 cores
+  #
+  # It will become the display part of "CPU Model", so this method is
+  # also known as the "cpu model".
+  # ========================================================================== #
+  def self.cpuinfo?
+    result = '/proc/cpuinfo'
+    if File.exist? result
+      readlines = File.readlines(result)
+      _ = readlines.grep(/model name/).first.chomp
+      splitted = _.split(':')
+      _ = splitted[1].strip # => "model name\t: AMD Sempron(tm) 145 Processor"
+      # ====================================================================== #
+      # Next, add the amount of cores. We use "nproc" for this but "lscpu"
+      # also contains this information. The following regex could be used
+      # for lscpu:
+      #
+      #   Core\(s\) per socket:    (.+)
+      #
+      # Ok, we use lscpu for now.
+      # ====================================================================== #
+      n_cores = silent_sys_command('nproc --all').to_s.strip
+      case n_cores
+      when '1'
+        n_cores << ' core'  # Singular.
+      else
+        n_cores << ' cores' # Plural then.
+      end
+      _ << ", #{n_cores}" unless n_cores.empty?
+      result = _
+    else
+      result = nil
+    end
+    result
+  end; self.instance_eval { alias append_operating_system_cpuinfo cpuinfo? } # === EnvironmentInformation.append_operating_system_cpuinfo
+       self.instance_eval { alias cpu_model                       cpuinfo? } # === EnvironmentInformation.cpu_model
+       self.instance_eval { alias cpu_model?                      cpuinfo? } # === EnvironmentInformation.cpu_model?
+       self.instance_eval { alias return_version_of_cpuinfo       cpuinfo? } # === EnvironmentInformation.return_version_of_cpuinfo
+       self.instance_eval { alias cpuinfo                         cpuinfo? } # === EnvironmentInformation.cpuinfo
+
+  # ========================================================================== #
+  # === EnvironmentInformation.write_what_into
+  # ========================================================================== #
+  def self.write_what_into(
+      what,
+      into
+    )
+    what = what.join("\n") if what.is_a? Array
+    File.open(into, 'w+') {|entry| entry.write(what) }
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.query_pkgconfig_version_for
+  #
+  # This toplevel-method can be used to query infromation stored in
+  # .pc files, done via the pkg-config utility.
+  #
+  # The input-argument to this method should be the name of the
+  # program at hand; and that program should be registered in the
+  # corresponding.yml file. The query will then use "pkg-config",
+  # which in turn queries the local .pc file for the version. So
+  # the local .pc file must be available, as otherwise this
+  # method will not find the necessary information.
+  # ========================================================================== #
+  def self.query_pkgconfig_version_for(
+      i = :gtk2
+    )
+    result = silent_sys_command("pkg-config --modversion #{i}")
+    if result.include? 'was not found in the pkg-config search pa'
+      result = NOT_FOUND
+    end
+    return result
+  end
+
+  # ========================================================================== #
+  # === @array_missing_components
+  #
+  # This Array will keep track of all components that are missing on the
+  # given system.
+  # ========================================================================== #
+  @array_missing_components = []
+
+  # ========================================================================== #
+  # === EnvironmentInformation.clear_array_missing_components
+  # ========================================================================== #
+  def self.clear_array_missing_components
+    @array_missing_components
+  end; self.instance_eval { alias clear_missing_components clear_array_missing_components } # === EnvironmentInformation.clear_missing_components
+
+  # ========================================================================== #
+  # === EnvironmentInformation.register_this_component_is_missing
+  #
+  # The ideal input to this method is a Symbol, so that the Array
+  # stores only missing components that way.
+  # ========================================================================== # 
+  def self.register_this_component_is_missing(i)
+    # ======================================================================== #
+    # First check if we have a Symbol as input:
+    # ======================================================================== #
+    if i.is_a? Symbol
+      copy = i.to_s
+      if copy.include?('_')
+        i = copy.split('_').last.to_sym
+      end
+    end
+    i = i.to_sym unless i.is_a? Symbol
+    # ======================================================================== #
+    # Do not register the same missing component twice:
+    # ======================================================================== #
+    unless @array_missing_components.include? i
+      @array_missing_components << i
+    end
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.is_this_component_missing?
+  # ========================================================================== #
+  def self.is_this_component_missing?(i)
+    !@array_missing_components.include?(i)
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_pkgconfig_based_programs
+  #
+  # This method will return all programs that are handled by pkgconfig.
+  #
+  # In March 2024, 150 programs depended on pkg-config (.pc files).
+  # ========================================================================== #
+  def self.return_pkgconfig_based_programs(
+      this_file = ::EnvironmentInformation.file_query_to_use_for_the_individual_components
+    )
+    dataset = YAML.load_file(this_file)
+    return dataset.select {|key, value|
+      # ====================================================================== #
+      # The next query will select both :pkgconfig and :"pkg-config".
+      # ====================================================================== #
+      value.to_s.start_with? 'pkg'
+    }.keys
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.autogenerate_all_relevant_methods
+  #
+  # By default this method will scan for all tracked programs, and
+  # for the xorg-components.
+  # ========================================================================= #
+  def self.autogenerate_all_relevant_methods(
+      i = tracked_components?
+    )
+    i.flatten!
+    # ======================================================================= #
+    # Add some aliases which will be defined next.
+    # ======================================================================= #
+    hash_aliases = {
+      atk:   :libatk,   # === EnvironmentInformation.return_version_of_libatk
+      pcre2: :libpcre2, # === EnvironmentInformation.return_version_of_libpcre2
+      pcre:  :libpcre,  # === EnvironmentInformation.return_version_of_libpcre
+      zlib:  :libzlib   # === EnvironmentInformation.return_version_of_libzlib
+    }
+    # ======================================================================= #
+    # Iterate over our Array next:
+    # ======================================================================= #
+    i.each {|this_program|
+      case this_program
+      when :kde
+        this_program = :kde_frameworks
+      end
+      self.class.instance_eval {
+        # =================================================================== #
+        # To test this method, try to do:
+        #
+        #   EnvironmentInformation.return_version_of_valgrind # => "3.15.0"
+        #
+        # =================================================================== #
+        this_method = "return_version_of_#{this_program}"
+        define_method(this_method) {
+          return_version_of_this_program(this_program)
+        }
+        if hash_aliases.has_key?(this_program)
+          # ================================================================= #
+          # To test this, try:
+          #
+          #   EnvironmentInformation.return_version_of_libzlib
+          #
+          # ================================================================= #
+          use_this_as_the_alias_target = "return_version_of_#{hash_aliases[this_program]}"
+          define_method(use_this_as_the_alias_target) {
+            return_version_of_this_program(this_program)
+          }
+        end
+      }
+    }
+  end
+
+  # autogenerate_all_relevant_methods # ← And call it at once. No longer as of 2024.
+
+  # ========================================================================== #
+  # And add a few more aliases. This list may have to be revisited again at
+  # a later time.
+  # ========================================================================== #
+  # self.instance_eval { alias add_xz_information                                         return_version_of_xz }             # === EnvironmentInformation.add_xz_information
+  # self.instance_eval { alias append_xz_version                                          return_version_of_xz }             # === EnvironmentInformation.append_xz_version
+  # self.instance_eval { alias return_version_of_sed?                                     return_version_of_sed }            # === EnvironmentInformation.return_version_of_sed?
+  # self.instance_eval { alias return_version_of_makeinfo                                 return_version_of_texinfo }        # === EnvironmentInformation.return_version_of_makeinfo
+  # self.instance_eval { alias xfsprogs?                                                  return_version_of_xfsprogs }       # === EnvironmentInformation.xfsprogs?
+  # self.instance_eval { alias add_xfsprogs_information                                   return_version_of_xfsprogs }       # === EnvironmentInformation.add_xfsprogs_information
+  # self.instance_eval { alias return_version_of_lftp?                                    return_version_of_lftp }           # === EnvironmentInformation.return_version_of_lftp?
+  # self.instance_eval { alias add_llvm_information                                       return_version_of_llvm }           # === EnvironmentInformation.add_llvm_information
+  # self.instance_eval { alias append_llvm_version                                        return_version_of_llvm }           # === EnvironmentInformation.append_llvm_version
+  # self.instance_eval { alias add_mpc_information                                        return_version_of_mpc }            # === EnvironmentInformation.add_mpc_information
+  # self.instance_eval { alias append_mpc_version                                         return_version_of_mpc }            # === EnvironmentInformation.append_mpc_version
+  # self.instance_eval { alias try_to_show_re2c_version                                   return_version_of_re2c }           # === EnvironmentInformation.try_to_show_re2c_version
+  # self.instance_eval { alias append_re2c_version                                        return_version_of_re2c }           # === EnvironmentInformation.append_nasm_version
+  # self.instance_eval { alias return_version_of_pkg_config                               return_version_of_pkgconfig }      # === EnvironmentInformation.return_version_of_pkg_config
+  # self.instance_eval { alias add_readline_information                                   return_version_of_readline }       # === EnvironmentInformation.add_readline_information
+  # self.instance_eval { alias append_readline_version                                    return_version_of_readline }       # === EnvironmentInformation.add_readline_information
+  # self.instance_eval { alias return_version_of_liblibtasn1                              return_version_of_libtasn1 }       # === EnvironmentInformation.return_version_of_liblibtasn1
+  # self.instance_eval { alias return_version_of_liblibtasn                               return_version_of_libtasn1 }       # === EnvironmentInformation.return_version_of_liblibtasn
+  # self.instance_eval { alias return_version_of_grep?                                    return_version_of_grep }           # === EnvironmentInformation.return_version_of_grep?
+  # self.instance_eval { alias return_version_of_intltool?                                return_version_of_intltool }       # === EnvironmentInformation.return_version_of_intltool?
+  # self.instance_eval { alias glib?                                                      return_version_of_glib }           # === EnvironmentInformation.glib?
+  # self.instance_eval { alias add_gmp_information                                        return_version_of_gmp }            # === EnvironmentInformation.add_gmp_information
+  # self.instance_eval { alias append_gmp_version                                         return_version_of_gmp }            # === EnvironmentInformation.append_gmp_version
+  # self.instance_eval { alias kernel                                                     return_version_of_linux }          # === EnvironmentInformation.kernel
+  # self.instance_eval { alias linux_kernel                                               return_version_of_linux }          # === EnvironmentInformation.linux_kernel
+  # self.instance_eval { alias linux_kernel?                                              return_version_of_linux }          # === EnvironmentInformation.linux_kernel?
+  # self.instance_eval { alias return_information_about_the_component_called_linux_kernel return_version_of_linux }          # === EnvironmentInformation.return_information_about_the_component_called_linux_kernel
+  # self.instance_eval { alias append_kernel_version                                      return_version_of_linux }          # === EnvironmentInformation.append_kernel_version
+  # self.instance_eval { alias add_kernel_information                                     return_version_of_linux }          # === EnvironmentInformation.add_kernel_information
+  # self.instance_eval { alias return_version_of_linux_kernel                             return_version_of_linux }          # === EnvironmentInformation.return_version_of_linux_kernel
+  # self.instance_eval { alias return_version_of_linux_kernel?                            return_version_of_linux }          # === EnvironmentInformation.return_version_of_linux_kernel?
+  # self.instance_eval { alias boost?                                                     return_version_of_boost }          # === EnvironmentInformation.boost?
+  # self.instance_eval { alias return_version_of_boost?                                   return_version_of_boost }          # === EnvironmentInformation.return_version_of_boost?
+  # self.instance_eval { alias return_version_of_find                                     return_version_of_findutils }      # === EnvironmentInformation.return_version_of_find
+  # self.instance_eval { alias findutils?                                                 return_version_of_findutils }      # === EnvironmentInformation.findutils?
+  # self.instance_eval { alias awk?                                                       return_version_of_gawk }           # === EnvironmentInformation.awk?
+  # self.instance_eval { alias gawk?                                                      return_version_of_gawk }           # === EnvironmentInformation.gawk?
+  # self.instance_eval { alias return_information_about_the_component_called_awk          return_version_of_gawk }           # === EnvironmentInformation.return_information_about_the_component_called_awk
+  # self.instance_eval { alias return_version_of_awk?                                     return_version_of_gawk }           # === EnvironmentInformation.return_version_of_awk?
+  # self.instance_eval { alias return_version_of_awk                                      return_version_of_gawk }           # === EnvironmentInformation.return_version_of_awk
+  # self.instance_eval { alias append_gdkpixbuf_version                                   return_version_of_gdkpixbuf }      # === EnvironmentInformation.append_gdkpixbuf_version
+  # self.instance_eval { alias glibc?                                                     return_version_of_glibc }          # === EnvironmentInformation.glibc?
+  # self.instance_eval { alias glibc_version?                                             return_version_of_glibc }          # === EnvironmentInformation.glibc_version?
+  # self.instance_eval { alias return_version_of_glibc?                                   return_version_of_glibc }          # === EnvironmentInformation.return_version_of_glibc?
+  # self.instance_eval { alias ruby?                                                      return_version_of_ruby }           # === EnvironmentInformation.ruby?
+  # self.instance_eval { alias return_information_about_the_component_called_ruby         return_version_of_ruby }           # === EnvironmentInformation.return_information_about_the_component_called_ruby
+  # self.instance_eval { alias return_version_of_ruby?                                    return_version_of_ruby }           # === EnvironmentInformation.return_version_of_ruby?
+  # self.instance_eval { alias binutils?                                                  return_version_of_binutils }       # === EnvironmentInformation.binutils?
+  # self.instance_eval { alias return_version_of_binutils?                                return_version_of_binutils }       # === EnvironmentInformation.return_version_of_binutils?
+  # self.instance_eval { alias bison?                                                     return_version_of_bison }          # === EnvironmentInformation.bison?
+  # self.instance_eval { alias return_version_of_bison?                                   return_version_of_bison }          # === EnvironmentInformation.return_version_of_bison?
+  # self.instance_eval { alias return_version_of_flex?                                    return_version_of_flex }           # === EnvironmentInformation.return_version_of_flex?
+  # self.instance_eval { alias return_version_of_freetype2                                return_version_of_freetype }       # === EnvironmentInformation.return_version_of_freetype2
+  # self.instance_eval { alias evince?                                                    return_version_of_evince }         # === EnvironmentInformation.evince?
+  # self.instance_eval { alias return_version_of_evince?                                  return_version_of_evince }         # === EnvironmentInformation.return_version_of_evince?
+  # self.instance_eval { alias gcc?                                                       return_version_of_gcc }            # === EnvironmentInformation.gcc?
+  # self.instance_eval { alias return_information_about_the_component_called_gcc          return_version_of_gcc }            # === EnvironmentInformation.return_information_about_the_component_called_gcc
+  # self.instance_eval { alias return_version_of_gcc?                                     return_version_of_gcc }            # === EnvironmentInformation.return_version_of_gcc?
+  # self.instance_eval { alias return_version_of_R                                        return_version_of_r }              # === EnvironmentInformation.return_version_of_R
+  # self.instance_eval { alias coreutils?                                                 return_version_of_coreutils }      # === EnvironmentInformation.coreutils?
+  # self.instance_eval { alias return_version_of_coreutils?                               return_version_of_coreutils }      # === EnvironmentInformation.return_version_of_coreutils
+  # self.instance_eval { alias return_version_of_diffutils?                               return_version_of_diffutils }      # === EnvironmentInformation.return_version_of_diffutils?
+  # self.instance_eval { alias return_version_of_libexempi                                return_version_of_exempi }         # === EnvironmentInformation.return_version_of_libexempi
+  # self.instance_eval { alias return_version_of_gpg                                      return_version_of_gnupg }          # === EnvironmentInformation.return_version_of_gpg
+  # self.instance_eval { alias return_version_of_gnupg?                                   return_version_of_gnupg }          # === EnvironmentInformation.return_version_of_gnupg?
+  # self.instance_eval { alias return_version_of_bzip                                     return_version_of_bzip2 }          # === EnvironmentInformation.return_version_of_bzip
+  # self.instance_eval { alias return_version_of_llvm                                     return_version_of_clang }          # === EnvironmentInformation.return_version_of_llvm
+  # self.instance_eval { alias return_clang_version                                       return_version_of_clang }          # === EnvironmentInformation.return_clang_version
+  # self.instance_eval { alias kde5?                                                      return_version_of_kde_frameworks } # === EnvironmentInformation.kde5?
+  # self.instance_eval { alias add_kde5_information                                       return_version_of_kde_frameworks } # === EnvironmentInformation.add_kde5_information
+  # self.instance_eval { alias add_kde_information                                        return_version_of_kde_frameworks } # === EnvironmentInformation.add_kde_information
+  # self.instance_eval { alias return_information_about_the_component_called_rubygems     return_version_of_rubygems }       # === EnvironmentInformation.return_information_about_the_component_called_rubygems
+  # self.instance_eval { alias rubygems?                                                  return_version_of_rubygems }       # === EnvironmentInformation.rubygems?
+  # self.instance_eval { alias return_version_of_rubygems?                                return_version_of_rubygems }       # === EnvironmentInformation.return_version_of_rubygems?
+  # self.instance_eval { alias gtk3?                                                      return_version_of_gtk3 }           # === EnvironmentInformation.gtk3?
+  # self.instance_eval { alias gtk2?                                                      return_version_of_gtk2 }           # === EnvironmentInformation.gtk2?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.start_gtk_component
+  #
+  # We have to rescue the code so to notify the user what exactly
+  # may have failed.
+  # ========================================================================== #
+  def self.start_gtk_component
+    begin
+      this_file = 'environment_information/gui/gtk3/environment_information.rb'
+      require this_file
+    rescue LoadError => error
+      e "An error happened - file #{sfile(this_file)} could not be found."
+      pp error
+    end
+    ::EnvironmentInformation.run_gtk
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_this_program
+  #
+  # This is the general method that will return the version of a particular
+  # program at hand.
+  #
+  # The method must be able to deal with using pkg-config, but also
+  # querying some program's version via --version, via the commandline,
+  # Furthermore, some programs may require an ad-hoc fix.
+  # ========================================================================= #
+  def self.return_version_of_this_program(
+      this_program,
+      prefix_to_use = @prefix_to_use
+    )
+    prefix_to_use = prefix_to_use.dup if prefix_to_use
+    version = nil # ← This is the default.
+    if this_program.is_a? Array
+      this_program = this_program.flatten.first
+    end
+    # ======================================================================= #
+    # Next define a few aliases.
+    # ======================================================================= #
+    this_program = ::EnvironmentInformation.return_alias_to(this_program)
+    if ARRAY_TRACKED_NON_PROGRAMS.include? this_program
+      return ::EnvironmentInformation.send(this_program)
+    elsif @query_to_use_for_the_individual_components.has_key? this_program.to_sym
+      use_this_command = @query_to_use_for_the_individual_components[this_program.to_sym]
+      case use_this_command
+      # ===================================================================== #
+      # === :mate_desktop
+      #
+      # This entry is special.
+      # ===================================================================== #
+      when :mate_desktop
+        return RBT.return_mate_desktop_version_array
+      # ===================================================================== #
+      # === :pkgconfig
+      #
+      # An invocation example for this would be:
+      #
+      #   x = EnvironmentInformation.return_version_of_this_program(:check) # => "0.15.2"
+      #
+      # ===================================================================== #
+      when :pkgconfig
+        version = ::EnvironmentInformation::Queries::PkgConfig.new(this_program).version?
+      # ===================================================================== #
+      # === :custom_gtk2
+      # ===================================================================== #
+      when :custom_gtk2
+        version = ::EnvironmentInformation::Queries::PkgConfig.new('gtk+-2.0').version?
+      # ===================================================================== #
+      # === :custom_mpc
+      #
+      # We rely on the header called mpc.h.
+      # ===================================================================== #
+      when :custom_mpc
+        version = ::EnvironmentInformation.return_version_of_mpc
+      # ===================================================================== #
+      # === :custom_boost
+      # ===================================================================== #
+      when :custom_boost
+        version = ::EnvironmentInformation.return_version_of_boost
+        if version.nil?
+          register_this_component_is_missing(:boost)
+        end
+      # ===================================================================== #
+      # === :version                                            (version tag)
+      #
+      # This entry point is typically for "program_name --version"
+      # entries. Some of them require custom modifications.
+      # ===================================================================== #
+      when :version
+        # =================================================================== #
+        # Next enable support for AppDir layout, where programs will
+        # ultimately reside in the same directory.
+        # =================================================================== #
+        unless prefix_to_use.empty?
+          prefix_to_use << "#{this_program.to_s.capitalize}/Current/bin/"
+        end
+        cmd = "#{prefix_to_use}#{this_program} --version #{ERROR_LINE}"
+        if @debug
+          e Colours.crimson('DEBUG for the prefix-value in use: ')+
+            Colours.steelblue(cmd)
+        end
+        version = ::EnvironmentInformation::Queries::SimpleVersion.new(this_program) {{
+          prefix_to_use: prefix_to_use
+        }}.version?
+      # ===================================================================== #
+      # Next we will handle special programs, such as "swig -v" and similar.
+      # This is done by class ComplexVersion since as of 29.08.2020.
+      # ===================================================================== #
+      else # else tag
+        if use_this_command.start_with?('pkg-config')
+          version = ::EnvironmentInformation::Queries::PkgConfig.new(this_program).version?
+        else
+          cmd = "#{@prefix_to_use}#{use_this_command} #{ERROR_LINE}"
+          version = ::EnvironmentInformation::Queries::ComplexVersion.new(this_program) {{
+            prefix_to_use: prefix_to_use
+          }}.version?
+        end
+      end
+    else
+      e 'Not registered any key for the program: '+this_program.to_s
+      e 'This is currently not allowed - please add this missing information.'
+      exit
+    end
+    result = version
+    if result
+      unless result.include? COMMAND_NOT_FOUND
+        result = result.dup if result.frozen?
+        result.strip!
+      end
+    end
+    if result and (result == 'found' or result == 'foud')
+      register_this_component_is_missing(this_program)
+    elsif result and result.include?(COMMAND_NOT_FOUND)
+      register_this_component_is_missing(this_program)
+    # ======================================================================= #
+    # Check whether pkg-config is available or not.
+    # ======================================================================= #
+    elsif result and (
+            result.include?(PKGCONFIG_COMMAND_NOT_FOUND) or
+            result.include?(NO_SUCH_FILE_OR_DIRECTORY)
+          )
+      register_this_component_is_missing(this_program)
+    elsif result.nil?
+      register_this_component_is_missing(this_program)
+    end
+    return result
+  end; self.instance_eval { alias version_for? return_version_of_this_program } # === EnvironmentInformation,version_for?
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_version_of_this_program
+  #
+  # This method will try to use --version first.
+  #
+  # This will typically use the main binary at hand, which we thus expect
+  # to respond to --version.
+  #
+  # Note that the method will also handle input that can NOT be generated
+  # via --version. This is usually called a "complex" version query, as
+  # far as the environment_information gem is concerned.
+  #
+  # Usage example:
+  #
+  #   EnvironmentInformation.return_version_of_this_program(:ccache)
+  #
+  # ========================================================================== #
+  def self.return_version_of_this_program(
+      i,
+      &block
+    )
+    prefix_to_use = ''.dup
+    i = i.to_sym
+    # ======================================================================== #
+    # === Handle blocks given to this method next
+    # ======================================================================== #
+    if block_given?
+      yielded = yield
+      if yielded.is_a? Hash
+        # ======================================================================== #
+        # === :prefix_to_use
+        # ======================================================================== #
+        if yielded.has_key? :prefix_to_use
+          prefix_to_use << yielded.delete(:prefix_to_use)
+        end
+      end
+    end
+    # ======================================================================== #
+    # The next variable will store the Hash containing all individual
+    # queries for the registered programs.
+    #
+    # For instance:
+    #
+    #    :busybox=>:custom_busybox, :bzip2=>:"bzip2recover --version",
+    #    :cairo=>:pkgconfig, :ccache=>:version, :check=>:pkgconfig,
+    #    :clang=>:version, :clutter=>:"pkg-config --modversion clutter-1.0",
+    #    :lighttpd=>:version   # and so forth
+    #
+    # ======================================================================== #
+    # _ = ::EnvironmentInformation.query_to_use_for_the_individual_components?
+    _ = ::EnvironmentInformation.load_file_query_to_use_for_the_individual_components.transform_keys {|entry|
+      entry.to_sym
+    }
+    if _.nil?
+      _ = ::EnvironmentInformation.load_file_query_to_use_for_the_individual_components
+    end
+    if _.has_key?(i) # Check whether the program is registered.
+      result = _[i]
+      case result.to_sym
+      # ====================================================================== #
+      # === :version
+      #
+      # This is the simplest entry point; we will try the commandline flag
+      # "--version" here. If you have to use "-v" then use :short_version
+      # instead.
+      # ====================================================================== #
+      when :version
+        program_version = silent_sys_command("#{prefix_to_use}#{i} --version").strip
+      # ====================================================================== #
+      # === :short_version
+      # ====================================================================== #
+      when :short_version,
+           :simple_version
+        program_version = silent_sys_command("#{prefix_to_use}#{i} -v").strip
+      # ====================================================================== #
+      # === :custom_busybox
+      # ====================================================================== #
+      when :custom_busybox
+        program_version = ::EnvironmentInformation.return_version_of_busybox
+      # ====================================================================== #
+      # === :custom_xrandr
+      # ====================================================================== #
+      when :custom_xrandr
+        program_version = ::EnvironmentInformation.return_version_of_xrandr
+      # ====================================================================== #
+      # === :custom_xvid
+      # ====================================================================== #
+      when :custom_xvid
+        program_version = ::EnvironmentInformation.return_version_of_xvid
+      # ====================================================================== #
+      # === :custom_boost
+      # ====================================================================== #
+      when :custom_boost
+        program_version = ::EnvironmentInformation.return_version_of_boost
+      # ====================================================================== #
+      # === :custom_mpc
+      # ====================================================================== #
+      when :custom_mpc
+        program_version = ::EnvironmentInformation.return_version_of_mpc
+      end
+      if program_version.include?('not found') # First check whether it was found or not.
+        program_version = ::EnvironmentInformation::NOT_FOUND
+      else
+        if program_version.include? N
+          program_version = program_version.split(N).first
+        end
+        if program_version.include? '--'
+          program_version.gsub!(/--/,'') # For strace specifically.
+        end
+        program_version = sanitize_this_program_version(program_version)
+        # ======================================================================== #
+        # Next handle cases such as the following two examples:
+        #
+        #   "ffmpeg version 4.3.1 Copyright (c) 2000-2020 the FFmpeg developers"
+        #   "openjdk version \"14.0.2\" 2020-07-14"
+        #   "ffmpeg version n5.1.2 Copyright (c) 2000-2022 the FFmpeg developers"
+        #
+        # ======================================================================== #
+        if program_version.include? ' version '
+          program_version = program_version.scan(
+            / version n?"?(\d{0,2}\.\d{1,2}\.?\d{0,2})"?/ # See: See: https://rubular.com/r/39cIQqXin2oco0
+          ).flatten.first.to_s.strip
+        end
+        # ======================================================================== #
+        # Next come format-entries such as:
+        # 
+        #   "lighttpd/1.4.71 - a light and fast webserver"
+        #
+        # This may fail, though - see vim:
+        #
+        #   "VIM - Vi IMproved 9.0 (2022 Jun 28, compiled Mar 15 2024 11:08:54)"
+        #
+        # ======================================================================== #
+        if program_version.include? ' - '
+          unless this_program.to_s.include?('vim')
+            program_version = program_version.split(' - ').first.to_s
+          end
+        end
+        # ======================================================================== #
+        # Next we will specifically handle vim:
+        # ======================================================================== #
+        if program_version =~ / (\d{1,2}\.\d{1,2}) \(/
+          program_version = $1.to_s.dup
+        end
+        if program_version.include?('[') and program_version.include?(']')
+          program_version.gsub!(/\[.+\]/, '')
+        end
+        program_version.strip!
+        if program_version.start_with? "#{i} "
+          # For example: "ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]"
+          program_version.sub!(/#{i} /, '')
+        elsif program_version.start_with? "#{i.upcase} "
+          # For example: "NASM version 2.15.04 compiled on Aug 27 2020"
+          program_version.sub!(/#{i.upcase} /, '')
+        end
+        # ======================================================================== #
+        # The next check for "Version" should come after we eliminated
+        # the leading program name.
+        # ======================================================================== #
+        if program_version.include? 'Version '
+          program_version = program_version.scan(
+                               /Version (\d{0,2}\.?\d{0,2}\.\d{0,2})/
+                             ).flatten.first.to_s.dup
+        elsif program_version.include? 'version '
+          # This here should work for most programs, save for perl.
+          program_version = program_version.scan(
+                               /version (\d{0,2}\.?\d{0,2}\.\d{0,2})/
+                             ).flatten.first.to_s.dup
+        end
+        if program_version.include? ' patchlevel '
+          # ================================================================== #
+          # Gnuplot has this specifically: "5.4 patchlevel 0"
+          # ================================================================== #
+          program_version = program_version.sub(/ patchlevel /,'.').strip
+        end
+        # ======================================================================== #
+        # Next we kill everything inside (). This may sometimes be 
+        # problematic, which is why this check comes quite late.
+        # ======================================================================== #
+        if program_version.include?('(') and program_version.include?(')')
+          program_version.gsub!(/\(.+\)/, '')
+        end
+        # ======================================================================== #
+        # Handle: "IceWM 1.8.0, Copyright 1997-2003 Marko Macek, 2001 Mathias Hasselmann."
+        # ======================================================================== #
+        if program_version.include?(',')
+          program_version = program_version.split(',').first
+        end
+        if program_version.include?('/')
+          # ================================================================== #
+          # Assume something like "lighttpd/1.4.71".
+          # ================================================================== #
+          program_version = program_version.split('/').last
+        end
+        # ======================================================================== #
+        # Next, if a '-' is included, we split it and use the last part.
+        # This handles cases such as "valgrind-3.16.0".
+        # ======================================================================== #
+        if program_version.include?('-')
+          program_version = program_version.split('-').last
+        end
+        # ======================================================================== #
+        # Last but not least, for "node" specifically.
+        # ======================================================================== #
+        if program_version.start_with? 'v'
+          program_version[0,1] = ''
+        end
+        # ======================================================================== #
+        # Handle cases such as: "nginx/1.18.0"
+        # ======================================================================== #
+        if program_version.include? '/'
+          program_version = program_version.split('/').last.strip
+        end 
+        if program_version.include? COMMAND_NOT_FOUND
+          program_version = nil
+        elsif program_version.include? ' '
+          # ================================================================== #
+          # Assume input such as: "GNU ld (GNU Binutils) 2.35"
+          # ================================================================== #
+          program_version = program_version.split(' ').last
+        end
+      end
+      return program_version.strip
+    end
+  end; self.instance_eval { alias return_version_of return_version_of_this_program } #  === EnvironmentInformation.return_version_of
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_simple_version_based_programs
+  #
+  # This method will return an Array, consisting of all files that
+  # can be queried via a simple --version query, via the commandline.
+  # ========================================================================== #
+  def self.return_simple_version_based_programs(
+      i = file_query_to_use_for_the_individual_components
+    )
+    dataset = YAML.load_file(i)
+    dataset.select {|key, value|
+      value = value.to_sym
+      # ===================================================================== #
+      # The next query will select only for :version entries.
+      # ===================================================================== #
+      value == :version
+    }.keys
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.array_missing_components?
+  # ========================================================================== #
+  def self.array_missing_components?
+    @array_missing_components
+  end; self.instance_eval { alias missing_components?           array_missing_components? } # === EnvironmentInformation.missing_components?
+       self.instance_eval { alias which_components_are_missing? array_missing_components? } # === EnvironmentInformation.which_components_are_missing?
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_path_to_all_programs_file
+  # ========================================================================= #
+  def self.return_path_to_all_programs_file
+    "#{temp_directory?}environment_information.yml"
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.show_detailed_information_about_all_available_components
+  #
+  # This method is mostly for testing purposes only; for real use
+  # for the project you should consider making use of
+  # Environment.silent_run instead.
+  #
+  # Do note that this method will always show all available components;
+  # if you need more fine-tuned control then you have to use the
+  # class EnvironmentInformation instead.
+  # ========================================================================= #
+  def self.show_detailed_information_about_all_available_components
+    @hash_available_programs = {} # Clear it every time this method is run. 
+    work_on_these_programs = []
+    work_on_these_programs << tracked_components?
+    e
+    work_on_these_programs.each {|this_program|
+      version_of_this_program = ::EnvironmentInformation.return_version_of_this_program(this_program)
+      # ===================================================================== #
+      # Do a little sanitizing next:
+      # ===================================================================== #
+      case this_program.to_s
+      when 'kde_frameworks'
+        this_program = 'KDE Frameworks'.to_sym
+      end
+      left_side = colourize_and_pad_the_left_side(this_program)
+      case version_of_this_program
+      when COMMAND_NOT_FOUND,
+           ''
+        version_of_this_program = nil
+        colour_for_the_right_side = :orange
+      else
+        colour_for_the_right_side = :notify_if_missing
+      end
+      # ===================================================================== #
+      # Next register this program into the main hash.
+      # ===================================================================== #
+      @hash_available_programs[this_program] = version_of_this_program
+      right_side = colourize_and_pad_the_right_side(
+        version_of_this_program,
+        colour_for_the_right_side
+      )
+      e "  #{left_side} #{right_side}"
+    }
+    e
+    # ======================================================================= #
+    # Report missing programs.
+    # ======================================================================= #
+    _ = missing_components?
+    unless _.empty?
+      e 'The following components were not found:'
+      e
+      _.each {|this_component|
+        e lightseagreen("  #{this_component}")
+      }
+      e
+    end
+    consider_storing_these_results_into_a_local_file
+  end; self.instance_eval { alias test show_detailed_information_about_all_available_components } # === EnvironmentInformation.test
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_array_of_outdated_programs
+  #
+  # This method will return all programs that are outdated - this
+  # also includes missing programs, so the method name is a slight
+  # misnomer.
+  #
+  # Usage example:
+  #
+  #   EnvironmentInformation.initialize
+  #   array = EnvironmentInformation.return_array_of_outdated_programs
+  #
+  # ========================================================================= #
+  def self.return_array_of_outdated_programs(
+      hash = ::EnvironmentInformation.hash?
+    )
+    forbidden = ::EnvironmentInformation.load_file_array_tracked_non_programs
+    # ======================================================================= #
+    # Now find all entries that are either nil, or have a too low program
+    # version.
+    # ======================================================================= #
+    array = hash.select {|key, value|
+      if value and forbidden.include?(key) # ← we exclude entries here such as "rubygems_installation_dir".
+        false
+      else
+        if value.nil? or value.include?('not found') or
+           !(value =~ /\d+/) # ← check for at the least one number, such as "1".
+          true
+        else
+          false
+        end
+      end
+    }.keys
+    # ======================================================================= #
+    # Next, check these against the local program version:
+    #  local_program_version = key
+    # ======================================================================= #
+    return array
+  end
+
+  # ========================================================================= #
+  # === Environment.silent_run
+  # ========================================================================= #
+  def self.silent_run
+    _ = ::EnvironmentInformation.new { :do_not_run_yet }
+    _.be_silent
+    _.run
+    return _.hash?
+  end; self.instance_eval { alias build_up_and_return_the_main_hash silent_run } # === EnvironmentInformation.build_up_and_return_the_main_hash
+       self.instance_eval { alias initialize_hash                   silent_run } # === EnvironmentInformation.initialize_hash
+       self.instance_eval { alias initialize                        silent_run } # === EnvironmentInformation.initialize
+       self.instance_eval { alias run                               silent_run } # === EnvironmentInformation.run
+
+  # ========================================================================== #
+  # === EnvironmentInformation.store_this_hash_into_a_local_file
+  #
+  # This method will always take the dataset stored in the main Hash when
+  # saving the yaml file at hand.
+  #
+  # The file will be stored under the temp_directory.
+  #
+  # This variant is silent by default.
+  # ========================================================================== #
+  def self.store_this_hash_into_a_local_file(
+      hash       = hash_available_programs?,
+      this_file  = return_path_to_all_programs_file,
+      be_verbose = false
+    )
+    unless hash.empty?
+      what = YAML.dump(hash)
+      e "#{rev}Storing these #{royalblue(hash.size)} "\
+        "#{rev}components into: #{sfile(this_file)}" if be_verbose
+      ::EnvironmentInformation.write_what_into(what, this_file)
+    end
+  end; self.instance_eval { alias consider_storing_these_results_into_a_local_file store_this_hash_into_a_local_file } # === EnvironmentInformation.consider_storing_these_results_into_a_local_file
+       self.instance_eval { alias store_relevant_files                             store_this_hash_into_a_local_file } # === EnvironmentInformation.store_relevant_files
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_everything
+  # ========================================================================= #
+  def self.return_everything
+    require 'environment_information/main_class/main_class.rb'
+    _ = ::EnvironmentInformation.new(:do_not_run_yet)
+    _.disable_colours
+    _.be_quiet
+    _.menu('--really-everything')
+    _.run
+    return _.string
+  end
+
+  # ========================================================================== #
+  # === EnvironmentInformation.sanitize_this_version_string     (sanitize tag)
+  # ========================================================================== #
+  def self.sanitize_this_version_string(
+      i = nil
+    )
+    return if i.nil?
+    if i.frozen?
+      i = i.dup
+    end
+    # ======================================================================== #
+    # === Handle ccache next:
+    # ======================================================================== #
+    if i.include? 'ccache version ' # Example: ccache version 4.8.2
+      i = i.scan(/ccache version (\d{1,2}\.\d{1,2}\.\d{1,2})/).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle strace next:
+    # ======================================================================== #
+    if i.include? 'strace -- version '
+      i = i.split('strace -- version ').last
+    end
+    # ======================================================================== #
+    # === Handle glslang next
+    #
+    # We must handle e. g. 'Glslang Version: 11:14.0.0'
+    # ======================================================================== #
+    if i.include?('Glslang Version') and i.include?(':')# e. g. for glslang.
+      i = i.split("\n").first if i.include? "\n"
+      i = i.split(':').last.to_s.strip
+    end
+    # ======================================================================== #
+    # === HMMER: we handle hmmer next here
+    # ======================================================================== #
+    if i.include? '# HMMER ' # ← Specifically for "hammer", e. g. 'HMMER 3.4 (Aug 2023); http://hmmer.org/'
+      i = i.scan(
+        /# HMMER (\d{0,2}\.\d{0,2}\.?\d{0,2})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle xstdcmap next:
+    # ======================================================================== #
+    if i.include? 'xstdcmap '
+      i = i.split('xstdcmap').last.strip
+    end
+    # ======================================================================== #
+    # === Handle qpdf next:
+    # ======================================================================== #
+    if i.include? 'qpdf version '
+      i = i.split('qpdf version ').last.strip
+    end
+    # ======================================================================== #
+    # === Handle Swig next:
+    # ======================================================================== #
+    if i.include? 'SWIG Version'
+      i = i.scan(
+        /SWIG Version (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle Screen next
+    #
+    # For: Screen version 4.09.01 (GNU) 20-Aug-23
+    # ======================================================================== #
+    if i.include? 'Screen version'
+      i = i.scan(
+        /Screen version (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle valgrind next:
+    # ======================================================================== #
+    if i.include? 'valgrind-'
+      i = i.split('-').last
+    end
+    # ======================================================================== #
+    # === Handle gimp next:
+    #
+    # The String may look like this: 'GNU Image Manipulation Program version 2.10.36' 
+    # ======================================================================== #
+    if i.include?('GNU Image Manipulation')
+      i = i.scan(
+        /GNU Image Manipulation Program version (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle IceWM here.
+    #
+    # The specific substring is:
+    #
+    #   "IceWM 3.4.7, Copyright 1997-2012 Marko Macek, 2001 Mathias Hasselmann."
+    #
+    # ======================================================================== #
+    if i.include? 'IceWM '
+      i = i.scan(
+        /IceWM (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle 'KDE Frameworks: 5.73.0'
+    # ======================================================================== #
+    if i.include? 'KDE Frameworks: '
+      i = i.scan(
+        /KDE Frameworks: (\d{0,2}\.\d{0,3}\.\d{0,2})/ # Must match e. g. "KDE Frameworks: 5.115.0".
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle 'lighttpd' next
+    # ======================================================================== #
+    if i.include? '- a light and fast webserver'
+      i = i.split('- a light and fast webserver').first
+      i = i.split('/').last if i.include?('/')
+    end
+    # ======================================================================== #
+    # === Handle flatpak next:
+    # ======================================================================== #
+    if i.include? 'Flatpak '
+      i = i.split('Flatpak ').last
+    end
+    # ======================================================================== #
+    # === Handle xinput next:
+    # ======================================================================== #
+    if i.include? 'xinput version '
+      i = i.split(' ').last
+    end
+    # ======================================================================== #
+    # === Handle vim next
+    # ======================================================================== #
+    if i.include? 'IMproved ' # For Vim.
+      i = i.scan(
+        /VIM - Vi IMproved (\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle xfs next:
+    # ======================================================================== #
+    if i.include? 'xfs_info'
+      i.sub!(/xfs_info/,'')
+    end
+    # ======================================================================== #
+    # === Handle rsync next:
+    # ======================================================================== #
+    if i.include? 'rsync  version '
+      i = i.split('rsync  version ').last
+      i = i.split(' ').first if i.include?(' ')
+    end
+    # ======================================================================== #
+    # === Handle clang next:
+    # ======================================================================== #
+    if i.include? 'clang version ' # clang version 18.1.2
+      i = i.split('clang version ').last.strip
+    end
+    # ======================================================================== #
+    # === Handle git next:
+    # ======================================================================== #
+    if i.include? 'git version ' # git version
+      i = i.split('git version ').last
+    end
+    # ======================================================================== #
+    # === Handle gnuplot next:
+    # ======================================================================== #
+    if i.include? 'gnuplot ' # gnuplot version
+      i = i.split('gnuplot ').last
+    end
+    # ======================================================================== #
+    # === Handle gperf next:
+    # ======================================================================== #
+    if i.include? 'gperf ' # gperf version
+      i = i.split('gperf ').last
+    end
+    # ======================================================================== #
+    # === Handle re2c next:
+    # ======================================================================== #
+    if i.include? 're2c '
+      i = i.split('re2c ').last
+    end
+    # ======================================================================== #
+    # === Handle plzip next:
+    # ======================================================================== #
+    if i.include? 'plzip '
+      i = i.split('plzip ').last
+    end
+    # ======================================================================== #
+    # === Handle PHP next:
+    # ======================================================================== #
+    if i.include? 'PHP '
+      i = i.scan(
+        /PHP (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle dhcpcd next:
+    # ======================================================================== #
+    if i.include? 'dhcpcd '
+      i = i.split('dhcpcd ').last
+    end
+    # ======================================================================== #
+    # === Handle bubblewrap next:
+    # ======================================================================== #
+    if i.include? 'bubblewrap '
+      i = i.split('bubblewrap ').last
+    end
+    # ======================================================================== #
+    # === Handle cmake next:
+    # ======================================================================== #
+    if i.include? 'cmake version '
+      i = i.split('cmake version ').last
+    elsif i.include? 'cmake '
+      i = i.split('cmake ').last
+    end
+    # ======================================================================== #
+    # === Handle flex next:
+    # ======================================================================== #
+    if i.include? 'flex '
+      i = i.split('flex ').last
+    end
+    # ======================================================================== #
+    # === Handle file next:
+    # ======================================================================== #
+    if i.include? 'file-'
+      i = i.split('file-').last
+    end
+    # ======================================================================== #
+    # === Handle gzip next:
+    # ======================================================================== #
+    if i.include? 'gzip '
+      i = i.split('gzip ')[1]
+    end
+    # ======================================================================== #
+    # === Handle groff next:
+    # ======================================================================== #
+    if i.include? 'groff '
+      i = i.split('groff ')[1]
+      if i.include? 'version'
+        i = i.split('version').last.strip
+      end
+    end
+    # ======================================================================== #
+    # === Handle ethtool next:
+    # ======================================================================== #
+    if i.include? 'ethtool '
+      i = i.split('ethtool ')[1]
+    end
+    # ======================================================================== #
+    # === Handle tmux next:
+    # ======================================================================== #
+    if i.include? 'tmux '
+      i = i.split('tmux').last.strip
+    end
+    # ======================================================================== #
+    # === Handle sysstag next:
+    # ======================================================================== #
+    if i.include? 'sysstat version '
+      i = i.split('sysstat version').last.to_s.strip
+    end
+    # ======================================================================== #
+    # === Handle samtools next:
+    # ======================================================================== #
+    if i.include? 'samtools '
+      i = i.split('samtools ').last.to_s.strip
+    end
+    # ======================================================================== #
+    # === Handle the Linux kernel next
+    # ======================================================================== #
+    if i.start_with?('Linux ')
+      i = i.scan(
+        /(\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle the xz-utils next:
+    # ======================================================================== #
+    if i.include? 'xz (XZ Utils)'
+      i = i.split('xz (XZ Utils)').last
+    end
+    # ======================================================================== #
+    # === Handle xterm next:
+    # ======================================================================== #
+    if i.include? 'XTerm('
+      i = i.split('XTerm(').last.delete(')')
+    end
+    # ======================================================================== #
+    # === Handle gnuplot:
+    # ======================================================================== #
+    if i.include? ' patchlevel'
+      i = i.split('patchlevel').first
+    end
+    # ======================================================================== #
+    # === Handle patch next:
+    # ======================================================================== #
+    if i.include? 'GNU patch '
+      i = i.split('GNU patch ').last
+    end
+    # ======================================================================== #
+    # === Handle simple-scan:
+    # ======================================================================== #
+    if i.include? 'simple-scan '
+      i = i.split('simple-scan').last
+    end
+    # ======================================================================== #
+    # === Handle ffmpeg next:
+    # ======================================================================== #
+    if i.include? 'ffmpeg version'
+      # ffmpeg version N-114276-g7f4b8d2f5e Copyright (c) 2000-2024 the FFmpeg developers
+      i = i.scan(/ffmpeg version (.+) /).flatten.first.to_s
+      i = i.split(' ').first if i.include? ' '
+      if i.include? '-'
+        i = i.scan(
+          /-(\d{5,6})-/
+        ).flatten.first.to_s
+      end
+    end
+    # ======================================================================== #
+    # === Handle GCC next:
+    #
+    # The String we are looking for is like:
+    #
+    #   "gcc version: 14.0.1 20240326 (experimental)"
+    #
+    # ======================================================================== #
+    if i.include?('gcc (GCC)') or i.include?('gcc version')
+      first_line = i.split("\n").first
+      i = first_line.split('gcc (GCC) ').last.strip
+      if i.include? ' '
+        i = i.split(' ').first
+      end
+    end
+    # ======================================================================== #
+    # === Handle Lynx next
+    # ======================================================================== #
+    if i.include? 'Lynx Version ' # Lynx Version 2.9.0 (15 Jan 2024)
+      i = i.scan(
+        /Lynx Version (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === openjdk
+    # ======================================================================== #
+    if i.include? 'openjdk'
+      i = i.scan(/openjdk version "(\d{1,2}\.\d{1,2}\.\d{1,2})"/).flatten.first
+    end
+    # ======================================================================== #
+    # if i.include? 'GNOME Document Viewer'
+    #   i.sub!(/GNOME Document Viewer/,'') # For evince specifically.
+    # end
+    # ======================================================================== #
+    if i.include? 'GNU'
+      i.gsub!(/GNU/,'')
+    end
+    # ======================================================================== #
+    # === Handle ruby 'ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]'
+    # ======================================================================== #
+    if i.include? 'ruby '
+      i = i.scan(
+        /^ruby (\d{1,1}\.\d{1,1}\.\d{1,1})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle 'ncurses 6.2.20200212' aka ncurses
+    # ======================================================================== #
+    if i.include? 'ncurses '
+      i = i.scan(
+        /ncurses (\d{1,1}\.\d{1,1})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle Imagemagick: 'Version: ImageMagick 7.0.10-28'
+    # ======================================================================== #
+    if i.include? 'Version: ImageMagick '
+      i = i.scan(
+        /Version: ImageMagick (\d{0,2}\.\d{0,2}\.\d{0,2}-\d{0,2})/
+      ).flatten.first.to_s.tr('-','.')
+    end
+    # ======================================================================== #
+    # === Handle Qt next:
+    # ======================================================================== #
+    if i.include? 'uic ' # uic 5.15.12
+      i = i.split('uic ').last
+    elsif i.include? 'Using Qt version' # Using Qt version 6.6.3 in
+      i = i.scan(
+        /Using Qt version (\d{1,2}\.\d{1,2}\.\d{1,2})/
+      ).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle perl next:
+    # ======================================================================== #
+    if i.include?('This is perl') and i.include?('(v') # "This is perl 5, version 38, subversion 2 (v5.38.2) built for x86_64-linux",
+      # ====================================================================== #
+      # Alternatively we could use this regex:
+      #
+      #   /\(v(\d{0,2}\.?\d{0,2}\.\d{0,2})\)/
+      #
+      # ====================================================================== #
+      i = i.scan(
+        /\((v\d{1,2}\.\d{1,2}\.\d{1,2})\)/
+      ).flatten.first.to_s.dup
+    end
+    # ======================================================================== #
+    # === Handle awk next:
+    # ======================================================================== #
+    if i.include? 'Awk '
+      i = i.scan(/Awk (\d{1,2}\.\d{1,2}\.\d{1,2})/).flatten.first
+    end
+    # ======================================================================== #
+    # === Handle patchelf '0.12.20200827.8d3a16e'
+    #
+    # This can also include output such as "patchelf 0.14.3".
+    # ======================================================================== #
+    if i.include? 'patchelf '
+      i = i.scan(
+        /^patchelf (\d{1,1}\.\d{1,2}\.?\d{0,2})/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Work on NASM next:
+    # ======================================================================== #
+    if i.include? 'NASM ' # "NASM version 2.16.01 compiled on Mar 23 2024"
+      scanned = i.scan(
+        /NASM\s*version\s*(\d{1,2}\.\d{1,2}\.\d{1,2})/
+      )
+      i = scanned.flatten.first.to_s.strip
+    end
+    # ======================================================================== #
+    # === Handle bzip2 next:
+    # ======================================================================== #
+    if i.include? 'bzip2, a block'
+      i = i.scan(
+        /Version (\d{1,2}\.\d{1,2}\.\d{1,2}),/
+      ).flatten.first.to_s
+    end
+    # ======================================================================== #
+    # === Handle emacs next:
+    # ======================================================================== #
+    if i.include? 'Emacs '
+      i.sub!(/Emacs/,'')
+    end
+    # ======================================================================== #
+    # === bzip2recover
+    # ======================================================================== #
+    if i.include? 'extracts blocks from damag'
+       i = i.scan(
+        /bzip2recover (\d{0,2}\.\d{0,2}\.\d{0,2}): extracts blocks from damaged .bz2 files/
+      ).flatten.first.to_s.dup
+    end
+    # ======================================================================== #
+    # === Handle Python next:
+    # ======================================================================== #
+    if i.include? 'Python ' # Python 3.11.7
+      i.sub!(/Python /,'')
+    end
+    # ======================================================================== #
+    # === Remove "built on linux-gnu":
+    # ======================================================================== #
+    if i.include? ' built on linux-gnu.'
+      i.gsub!(/ built on linux-gnu\./, '') # Fixing wget specifically.
+    end
+    # ======================================================================== #
+    # === Remove 'Wget' substring:
+    # ======================================================================== #
+    if i.include? 'Wget'
+      i.sub!(/Wget/,'')
+      i.strip!
+    end
+    if i.include? 'built on'
+      i = i.split(/built on/).first
+    end
+    # ======================================================================== #
+    # === Handle "Midnight Commander" next:
+    # ======================================================================== #
+    if i.include? 'Midnight Commander'
+      i.gsub!(/Midnight Commander/, '')
+    end
+    # ======================================================================== #
+    # === Eliminate '.git'
+    # ======================================================================== #
+    if i.include? '.git'
+      i.sub!(/\.git/,'')
+    end 
+    # ======================================================================== #
+    # === Remove the substring 'GNU' next; this should come fairly late:
+    # ======================================================================== #
+    if i.include? 'GNU'
+      i.sub!(/GNU/,'')
+    end
+    # ======================================================================== #
+    # === For rsync specifically
+    # ======================================================================== #
+    if i.include? 'protocol version'
+      i = i.split('protocol version').first
+    end
+    # ======================================================================== #
+    # === Remove '#'
+    # ======================================================================== #
+    if i.include? ' #' # Handle "uname -a" aka Linux darkstar.example.net 5.4.50 #1 SMP
+      i = i.split(' #').first.strip 
+    end
+    if i.start_with? 'v'
+      i = i.dup
+      i[0,1] = ''
+    end
+    return i
+  end; self.instance_eval { alias sanitize_this_program_version sanitize_this_version_string } # === EnvironmentInformation.sanitize_this_program_version 
+
+  # ========================================================================== #
+  # === EnvironmentInformation.return_very_silent_system_output_from (query tag)
+  # ========================================================================== #
+  def self.return_very_silent_system_output_from(
+      use_this_query
+    )
+    @original_stderr = $stderr.clone
+    $stderr.reopen('/dev/null', 'w')
+    result = `#{use_this_query} 2>&1`
+    $stderr.reopen(@original_stderr)
+    return result
+  end; self.instance_eval { alias silent_sys_command return_very_silent_system_output_from } # === EnvironmentInformation.silent_sys_command
+       self.instance_eval { alias default_query      return_very_silent_system_output_from } # === EnvironmentInformation.default_query
+       self.instance_eval { alias silent_query       return_very_silent_system_output_from } # === EnvironmentInformation.silent_query
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  # e EnvironmentInformation.n_subcommands?.to_s+' components are tracked.'
+  # e EnvironmentInformation.internet_is_available?
+  # EnvironmentInformation.e('Hello world!')
+  # e EnvironmentInformation.return_remote_gtk2_version
+  # EnvironmentInformation.write_what_into(ARGV, 'test_this.md')
+  # Next test .simple_version()
+  seek_this_program = :bison # :gnuplot # :lftp
+  _ = EnvironmentInformation.return_version_of(seek_this_program)
+  e _
+  # ========================================================================== #
+  # Next we test various individual components, stored in an Array:
+  # ========================================================================== #
+  array = %i(
+    mpc
+    gtk2
+    linux
+    binutils
+    boost
+    coreutils
+    diffutils
+    ffmpeg
+    findutils
+    java
+    imagemagick
+    kde_frameworks
+    llvm
+    ncurses
+    nginx
+    qt
+    rubygems
+    sharutils
+    sysstat
+    swig
+    texinfo
+    tmux
+    xfsprogs
+    xterm
+    hmmer
+    viennarna
+    xstdcmap
+  )
+  array.each {|entry|
+    _ = EnvironmentInformation.version_of(entry)
+    e _
+  }
+  e EnvironmentInformation.return_version_of_mpc
+  e EnvironmentInformation.return_version_of_boost
+  EnvironmentInformation.test
+end # showcomponents --compare