module EnvironmentInformation

# File lib/environment_information/toplevel_methods/hash.rb, line 42
def self.add_to_hash(a, b)
  b.strip! if b.is_a? String
  if b.nil?
    ::EnvironmentInformation.register_this_component_is_missing(a)
  end
  @hash_available_programs[a] = b
end

# File lib/environment_information/constants/array_tracked_components.rb, line 64
def self.array_tracked_programs
  ARRAY_TRACKED_PROGRAMS
end

# File lib/environment_information/toplevel_methods/autogenerate_all_relevant_methods.rb, line 21
def self.autogenerate_all_relevant_methods(
    i = ARRAY_TRACKED_PROGRAMS+
        ARRAY_XORG_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

# File lib/environment_information/toplevel_methods/cd.rb, line 12
def self.cd(i)
  Dir.chdir(i) if File.directory? i
end

# File lib/environment_information/misc_components/cflags.rb, line 24
def self.cflags?
  version = ENV['CFLAGS'].to_s.strip
  version = '<none>' if version.empty? # Display special status if it is empty.
  version
end

# File lib/environment_information/toplevel_methods/hash.rb, line 55
def self.clear_hash
  @hash_available_programs.clear
end

# File lib/environment_information/toplevel_methods/register_this_component_is_missing.rb, line 28
def self.clear_missing_components
  @array_this_component_is_missing.clear
end

# File lib/environment_information/colours/colours.rb, line 81
def self.colour_for_program_not_found
  @colour_for_program_not_found
end

# File lib/environment_information/colours/colours.rb, line 67
def self.colour_for_the_left_side
  @colour_for_the_left_side
end

# File lib/environment_information/colours/colours.rb, line 74
def self.colour_for_the_right_side
  @colour_for_the_right_side
end

# File lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb, line 75
def self.colourize_and_pad_the_left_side(i)
  left_side = i.to_s.ljust(32) # Pad to the left-hand side.
  if use_colours?
    "  #{Colours.send(::EnvironmentInformation.colour_for_the_left_side,  left_side)}"
  else
    "  #{left_side}"
  end
end

# File lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb, line 50
def self.colourize_and_pad_the_right_side(
    i,
    colour_for_the_right_side = ::EnvironmentInformation.colour_for_the_right_side
  )
  case colour_for_the_right_side
  # ======================================================================= #
  # === :notify_if_missing
  # ======================================================================= #
  when :notify_if_missing
    colour_for_the_right_side = ::EnvironmentInformation.colour_for_the_right_side
    if i.to_s.empty?
      i = '[Not found]'
      colour_for_the_right_side = :orange
    end
  end
  if use_colours?
    Colours.send(colour_for_the_right_side, i)
  else
    i
  end
end

# File lib/environment_information/toplevel_methods/misc.rb, line 61
def self.consider_storing_these_results_into_a_local_file(
    be_verbose = true
  )
  unless @hash_available_programs.empty?
    what = YAML.dump(@hash_available_programs)
    # ===================================================================== #
    # The file will be stored under the temp_directory.
    # ===================================================================== #
    into = ::EnvironmentInformation.return_path_to_the_all_programs_file
    e "#{rev}Storing these #{royalblue(@hash_available_programs.size)} "\
      "#{rev}components into: #{sfile(into)}" if be_verbose
    write_what_into(what, into)
  end
end

# File lib/environment_information/misc_components/cpuinfo.rb, line 25
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 = `nproc --all`.strip
    case n_cores.to_s
    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

# File lib/environment_information/colours/colours.rb, line 105
def self.do_use_colours
  @use_colours = i
end

# File lib/environment_information/toplevel_methods/e.rb, line 13
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.
    # ===================================================================== #
    print "#{i}, "
  else
    puts i
  end
end

# File lib/environment_information/toplevel_methods/e.rb, line 33
def self.ee(
    i = ''
  )
  print "#{i}, "
end

# File lib/environment_information/class/class.rb, line 2572
def self.environment_information?
  ::EnvironmentInformation::EnvironmentInformation.new(:full_be_silent).stringified
end

# File lib/environment_information/constants/file_constants.rb, line 73
def self.file_query_to_use_for_the_individual_components
  "#{PROJECT_BASE_DIRECTORY}yaml/query_to_use_for_the_individual_components.yml"
end

# File lib/environment_information/colours/colours.rb, line 152
def self.forestgreen(
    i = '', use_colours = @use_colours
  )
  return ::Colours.forestgreen(i) if use_colours
  return i
end

# File lib/environment_information/gui/universal_widgets/environment_information/environment_information.rb, line 394
def self.gtk_bindings
   ::EnvironmentInformation::EnvironmentInformation::GUI::Gtk::EnvironmentInformation.new
end

# File lib/environment_information/toplevel_methods/hash.rb, line 34
def self.hash?
  @hash_available_programs
end

# File lib/environment_information/toplevel_methods/internet_is_available.rb, line 12
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

# File lib/environment_information/toplevel_methods/is_on_roebe.rb, line 12
def self.is_on_roebe?
  ENV['IS_ROEBE'].to_i == 1
end

# File lib/environment_information/constants/array_tracked_components.rb, line 197
def self.is_this_component_included?(i)
  array = (
            ARRAY_TRACKED_PROGRAMS +
            ARRAY_XORG_COMPONENTS  +
            ARRAY_TRACKED_NON_PROGRAMS
          )
  array.flatten.include? i.to_sym # Need a Symbol as input.
end

# File lib/environment_information/toplevel_methods/register_this_component_is_missing.rb, line 57
def self.is_this_component_missing?(i)
  !@array_this_component_is_missing.include?(i)
end

# File lib/environment_information/constants/array_tracked_components.rb, line 185
def self.is_this_program_included?(i)
  (
    ARRAY_TRACKED_PROGRAMS +
    ARRAY_XORG_COMPONENTS
  ).flatten.include? i.to_sym # Need a symbol.
end

# File lib/environment_information/constants/array_tracked_components.rb, line 175
def self.lfs_core_programs?
  ARRAY_LFS_CORE_PROGRAMS
end

# File lib/environment_information/colours/colours.rb, line 162
def self.lightseagreen(i = '', use_colours = @use_colours)
  if use_colours
    return ::Colours.lightseagreen(i)
  end
  return i
end

# File lib/environment_information/colours/colours.rb, line 122
def self.lightslategrey(i = '')
  if @use_colours
    return ::Colours.lightslategrey(i)
  end
  return i
end

# File lib/environment_information/constants/file_constants.rb, line 40
def self.load_file_array_tracked_non_programs(
    i = FILE_ARRAY_TRACKED_NON_PROGRAMS
  )
  YAML.load_file(i)
end

# File lib/environment_information/constants/file_constants.rb, line 80
def self.load_file_query_to_use_for_the_individual_components(
    i = FILE_QUERY_TO_USE_FOR_THE_INDIVIDUAL_COMPONENTS
  )
  @query_to_use_for_the_individual_components = YAML.load_file(i)
  return @query_to_use_for_the_individual_components
end

# File lib/environment_information/colours/colours.rb, line 195
def self.mediumaquamarine(
    i           = '',
    use_colours = @use_colours
  )
  if use_colours
    return ::Colours.mediumaquamarine(i)
  end
  return i
end

# File lib/environment_information/colours/colours.rb, line 112
def self.mediumpurple(i = '')
  if @use_colours
    return ::Colours.mediumpurple(i)
  end
  return i
end

# File lib/environment_information/toplevel_methods/menu.rb, line 18
def self.menu(
    i = ARGV
  )
  if i.is_a? Array
    i.each {|entry| menu(entry) }
  else
    case i # case tag
    # ===================================================================== #
    # === envi --replay
    #
    # The replay-functionality can be used to display information
    # quickly, by reading the dataset from a local file.
    # ===================================================================== #
    when /^-?-?replay$/i
      require 'environment_information/toplevel_methods/replay_from_the_stored_file.rb'
      replay_from_the_stored_file
    # ===================================================================== #
    # === envi --version?
    # ===================================================================== #
    when *ARRAY_VERSION
      report_version
    # ===================================================================== #
    # === envi --compare
    # ===================================================================== #
    when *ARRAY_COMPARE_PROGRAM_VERSIONS
      require 'environment_information/toplevel_methods/show_all_available_components.rb'
      ::EnvironmentInformation.show_all_available_components(
        ['--compare-program-versions']
      )
    # ===================================================================== #
    # === envi --gui
    # ===================================================================== #
    when /^-?-?gui$/i,
         /^-?-?gtk$/i,
         /^-?-?start(-|_)?gtk$/i
      start_gtk_component
    else
      require 'environment_information/toplevel_methods/misc.rb'
      EnvironmentInformation.test
    end
  end
end

# File lib/environment_information/toplevel_methods/n_subcommands.rb, line 22
def self.n_subcommands?
  ARRAY_TRACKED_PROGRAMS.size+
  ARRAY_XORG_COMPONENTS.size
end

# File lib/environment_information/misc_components/operating_system.rb, line 25
def self.operating_system
  cmd = 'uname -mo'
  result = `#{cmd}`.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
  result
end

# File lib/environment_information/misc_components/operating_system_bit_type.rb, line 21
def self.operating_system_bit_type_information
  cmd = 'uname -m'
  result = `#{cmd}`.chomp
  result = result.split(' ')[-1] if result.include?(' ')
  result = result.dup if result.frozen?
  case result
  when 'x86_64'
    result << ' (64 bit)'
  end
  result
end

# File lib/environment_information/colours/colours.rb, line 142
def self.pink(
    i = '', use_colours = @use_colours
  )
  return ::Colours.pink(i) if use_colours
  return i
end

# File lib/environment_information/toplevel_methods/prefix_to_use.rb, line 35
def self.prefix?
  @prefix_to_use
end

# File lib/environment_information/project/project.rb, line 23
def self.project_base_directory?
  PROJECT_BASE_DIRECTORY
end

# File lib/environment_information/queries/pkg_config.rb, line 114
def self.query_pkgconfig_version_for(i = :gtk2)
  ::EnvironmentInformation::Queries::PkgConfig.new(i).version?
end

# File lib/environment_information/constants/file_constants.rb, line 90
def self.query_to_use_for_the_individual_components?
  @query_to_use_for_the_individual_components
end

# File lib/environment_information/misc_components/ram.rb, line 17
def self.ram?
  result_in_n_mb = `free -m 2>&1`.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
  result_in_n_mb
end

# File lib/environment_information/toplevel_methods/register_this_component_is_missing.rb, line 38
def self.register_this_component_is_missing(i)
  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_this_component_is_missing.include? i
    @array_this_component_is_missing << i
  end
end

# File lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb, line 30
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 colourize_and_pad_the_left_side("#{key}:")+
        colourize_and_pad_the_right_side(
          value.to_s, :notify_if_missing
        )
    }
  else
    e "No file exists at #{_}."
  end
end

# File lib/environment_information/toplevel_methods/menu.rb, line 64
def self.report_version
  e "#{rev}The version of the EnvironmentInformation project "\
    "in use is: #{simp(VERSION)}#{rev}"
end

# File lib/environment_information/requires/require_the_individual_misc_components.rb, line 17
def self.require_all_individual_misc_components

  # ======================================================================= #
  # Batch-require the components in the misc_components/ directory next:
  # ======================================================================= #
  tracked_non_programs?.each {|this_component|
    require "environment_information/misc_components/#{this_component}.rb"
  }

end

# File lib/environment_information/requires/require_the_toplevel_methods.rb, line 14
def self.require_the_toplevel_methods
  Dir["#{PROJECT_BASE_DIRECTORY}toplevel_methods/*.rb"].each {|this_file|
    require "environment_information/toplevel_methods/#{File.basename(this_file)}"
  }
end

# File lib/environment_information/toplevel_methods/return_alias_to.rb, line 15
def self.return_alias_to(i)
  if i.is_a? Array
    i = i.first
  end
  case i.to_sym
  when :find
    i = :findutils
  when :diff
    i = :diffutils
  when :yacc
    i = :bison
  end
  return i # Always return something.
end

# File lib/environment_information/toplevel_methods/misc.rb, line 263
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

# File lib/environment_information/toplevel_methods/misc.rb, line 308
def self.return_everything
  require 'environment_information/class/class.rb'
  _ = ::EnvironmentInformation::EnvironmentInformation.new(:do_not_run_yet)
  _.disable_colours
  _.be_quiet
  _.menu('--really-everything')
  _.run
  return _.string
end

# File lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb, line 18
def self.return_path_to_the_all_programs_file
  "#{temp_directory?}all_programs.yml"
end

# File lib/environment_information/toplevel_methods/return_pkgconfig_based_programs.rb, line 14
def self.return_pkgconfig_based_programs
  dataset = YAML.load_file(file_query_to_use_for_the_individual_components)
  dataset.select {|key, value|
    # ===================================================================== #
    # The next query will select both :pkgconfig and :"pkg-config".
    # ===================================================================== #
    value.to_s.start_with? 'pkg'
  }.keys
end

# File lib/environment_information/toplevel_methods/return_remote_gtk2_version.rb, line 24
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

# File lib/environment_information/toplevel_methods/remote_url_of_this_program.rb, line 21
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

# File lib/environment_information/toplevel_methods/return_simple_version_based_programs.rb, line 14
def self.return_simple_version_based_programs
  dataset = YAML.load_file(file_query_to_use_for_the_individual_components)
  dataset.select {|key, value|
    # ===================================================================== #
    # The next query will select only for :version entries.
    # ===================================================================== #
    value == :version
  }.keys
end

# File lib/environment_information/toplevel_methods/misc.rb, line 296
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

# File lib/environment_information/toplevel_methods/misc.rb, line 211
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

# File lib/environment_information/toplevel_methods/misc.rb, line 191
def self.return_version_of_busybox
  result = `busybox #{ERROR_LINE}`
  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

# File lib/environment_information/toplevel_methods/misc.rb, line 237
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

# File lib/environment_information/toplevel_methods/return_version_of_this_program.rb, line 56
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

# File lib/environment_information/toplevel_methods/misc.rb, line 144
def self.return_version_of_xrandr
  _ = `xrandr --version #{ERROR_LINE}` # Need to use ERROR_LINE to avoid the code breaking down here.
  if _
    version = _.strip.split("\n")
    if version.is_a?(Array)
      version = version.first.split(' ').last.strip # Assume: "xrandr program version       1.5.1"
      return version
    end
  end
  return nil
end

# File lib/environment_information/toplevel_methods/misc.rb, line 159
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

# File lib/environment_information/colours/colours.rb, line 219
def self.rev
  return ::Colours.rev if @use_colours
  '' # Else return an empty String.
end

# File lib/environment_information/colours/colours.rb, line 182
def self.royalblue(
    i           = '',
    use_colours = @use_colours
  )
  if use_colours
    return ::Colours.royalblue(i)
  end
  return i
end

# File lib/environment_information/misc_components/rubygems_installation_directory.rb, line 25
def self.rubygems_installation_directory(
    prefix_to_use = @prefix_to_use
  )
  result = `#{prefix_to_use}gem env #{ERROR_LINE}` # We need the 2>&1 to check if gem is available.
  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 << '/'
    end unless path_to_the_rubygem_directory.end_with? '/'
    result = path_to_the_rubygem_directory
  else
    result = nil
  end
  result
end

# File lib/environment_information/class/class.rb, line 2552
def self.run(i = ARGV)
  ::EnvironmentInformation::EnvironmentInformation.new(i)
end

# File lib/environment_information/gui/universal_widgets/environment_information/environment_information.rb, line 404
def self.run_gtk
  require 'gtk_paradise/run'
  _ = ::EnvironmentInformation.gtk_bindings
  r = ::Gtk.run
  r << _ # ← Add the widget here.
  r.add_shortcut(1, 'focus(:left)', :alt)
  r.modify_background(:normal, :white)
  r.automatic_title
  r.top_left_then_run
end

# File lib/environment_information/class/class.rb, line 2559
def self.run_the_main_class(i = ARGV, &block)
  ::EnvironmentInformation::EnvironmentInformation.new(i, &block)
end

# File lib/environment_information/constants/array_tracked_components.rb, line 101
def self.science_cluster?
  ARRAY_SCIENCE_CLUSTER
end

# File lib/environment_information/misc_components/screen_resolution.rb, line 22
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"
    if resolution and resolution.include? ':'
      result = resolution.split(':').last.strip.split('pixels').first.strip
    end
  # ======================================================================= #
  # === Else simply assume to be on windows here
  # ======================================================================= #
  else
    result = `wmic desktopmonitor get screenheight,screenwidth #{ERROR_LINE}`
  end
  result
end

# File lib/environment_information/toplevel_methods/prefix_to_use.rb, line 28
def self.set_prefix_to_use(i)
  @prefix_to_use = i.to_s.dup
end

# File lib/environment_information/colours/colours.rb, line 98
def self.set_use_colours(i = true)
  @use_colours = i
end

# File lib/environment_information/colours/sfancy.rb, line 14
def self.sfancy(i = '')
  return ::Colours.sfancy(i) if Object.const_defined? :Colours
  i
end

# File lib/environment_information/colours/colours.rb, line 208
def self.sfile(i = '')
  if @use_colours
    ::Colours.sfile(i)
  else
    i
  end
end

# File lib/environment_information/toplevel_methods/show_all_available_components.rb, line 46
def self.show_all_available_components(
    n_ljust               = 18,
    show_these_components = ARRAY_DEFAULT_PROGRAMS_ON_LINUX+
                            ARRAY_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

# File lib/environment_information/toplevel_methods/misc.rb, line 87
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 << YAML.load_file(FILE_ARRAY_TRACKED_NON_PROGRAMS)
  work_on_these_programs << YAML.load_file(FILE_ARRAY_TRACKED_PROGRAMS)
  work_on_these_programs << YAML.load_file(FILE_ARRAY_TRACKED_XORG_COMPONENTS)
  work_on_these_programs << YAML.load_file(FILE_ARRAY_SCIENCE_CLUSTER)
  work_on_these_programs.flatten!
  work_on_these_programs.uniq!
  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

# File lib/environment_information/toplevel_methods/remote_url_of_this_program.rb, line 37
def self.show_remote_url_of_this_program(i = ARGV)
  puts return_remote_url_of_this_program(i)
end

# File lib/environment_information/toplevel_methods/misc.rb, line 28
def self.silent_run(
    array_load_these_files = [
      FILE_ARRAY_TRACKED_NON_PROGRAMS,
      FILE_ARRAY_TRACKED_PROGRAMS,
      FILE_ARRAY_TRACKED_XORG_COMPONENTS,
      FILE_ARRAY_SCIENCE_CLUSTER
    ]
  ) 
  @hash_available_programs = {} # Clear it every time this method is run.
  work_on_these_programs = []
  array_load_these_files.each {|this_entry|
    work_on_these_programs << YAML.load_file(this_entry)
  }
  work_on_these_programs.flatten.each {|this_program|
    version_of_this_program = ::EnvironmentInformation.return_version_of_this_program(this_program)
    if version_of_this_program
      version_of_this_program = version_of_this_program.to_s
    end
    @hash_available_programs[this_program] = version_of_this_program
  }
  consider_storing_these_results_into_a_local_file(false)
  return @hash_available_programs
end

# File lib/environment_information/colours/simp.rb, line 14
def self.simp(i = '')
  return ::Colours.simp(i) if Object.const_defined? :Colours
  i
end

# File lib/environment_information/toplevel_methods/menu.rb, line 75
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

# File lib/environment_information/www/sinatra_interface.rb, line 204
def self.start_sinatra_interface
  puts 'Trying to start the sinatra-interface of EnvironmentInformation next.'
  ::EnvironmentInformation::Sinatra.run!
end

# File lib/environment_information/colours/colours.rb, line 172
def self.steelblue(i = '')
  if @use_colours
    return ::Colours.steelblue(i)
  end
  return i
end

# File lib/environment_information/constants/temp_directory.rb, line 46
def self.temp_directory?(
    i = @temp_directory
  )
  i.squeeze('/').dup
end

# File lib/environment_information/colours/colours.rb, line 132
def self.tomato(
    i = '', use_colours = @use_colours
  )
  return ::Colours.tomato(i) if use_colours
  return i
end

# File lib/environment_information/constants/array_tracked_components.rb, line 168
def self.tracked_non_programs?
  ARRAY_TRACKED_NON_PROGRAMS
end

# File lib/environment_information/constants/array_tracked_components.rb, line 150
def self.tracked_programs?
  ARRAY_TRACKED_PROGRAMS
end

# File lib/environment_information/colours/colours.rb, line 88
def self.use_colours?
  @use_colours
end

# File lib/environment_information/toplevel_methods/misc.rb, line 16
def self.verbose_truth(i)
  case i
  when /true/
    'Yes.'
  when /false/
    'No.'
  end
end

# File lib/environment_information/toplevel_methods/register_this_component_is_missing.rb, line 21
def self.which_components_are_missing?
  @array_this_component_is_missing
end

# File lib/environment_information/toplevel_methods/write_what_into.rb, line 15
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

# File lib/environment_information/constants/array_tracked_components.rb, line 157
def self.xorg_components?
  ARRAY_XORG_COMPONENTS
end