module EnvironmentInformation

# File lib/environment_information/toplevel_methods/autogenerate_all_relevant_methods.rb, line 18
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 19
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/misc.rb, line 38
def self.clear_hash
  @hash_available_programs = {}
end

# File lib/environment_information/colours/colours.rb, line 111
def self.colour_for_the_left_side
  :forestgreen
end

# File lib/environment_information/colours/colours.rb, line 118
def self.colour_for_the_right_side
  :steelblue
end

# File lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb, line 42
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 17
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 48
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 = return_path_to_the_all_programs_file
    e "Storing the yaml-file into: #{sfile(into)}" if be_verbose
    write_what_into(what, into)
  end
end

# File lib/environment_information/misc_components/cpuinfo.rb, line 20
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 44
def self.do_use_colours
  @use_colours = i
end

# File lib/environment_information/toplevel_methods/e.rb, line 12
def self.e(i = '')
  puts i
end

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

# File lib/environment_information/gui/gtk/bindings.rb, line 196
def self.gtk_bindings
   ::EnvironmentInformation::EnvironmentInformation::GUI::GtkEnvironmentInformation.new
end

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

# File lib/environment_information/toplevel_methods/register_this_component_is_missing.rb, line 47
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 187
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 177
def self.lfs_core_programs?
  ARRAY_LFS_CORE_PROGRAMS
end

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

# File lib/environment_information/colours/colours.rb, line 51
def self.mediumpurple(i = '')
  if @use_colours
    i = ::Colours.mediumpurple(i)
  end
  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 --version?
    # ===================================================================== #
    when *ARRAY_VERSION
      report_version
    # ===================================================================== #
    # === 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 --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/constants/array_tracked_components.rb, line 169
def self.n_subcommands?
  ARRAY_TRACKED_PROGRAMS.size+
  ARRAY_XORG_COMPONENTS.size
end

# File lib/environment_information/misc_components/operating_system.rb, line 22
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 18
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/toplevel_methods/prefix_to_use.rb, line 35
def self.prefix?
  @prefix_to_use
end

# File lib/environment_information/project/project.rb, line 18
def self.project_base_dir?
  PROJECT_BASE_DIRECTORY
end

# File lib/environment_information/misc_components/ram.rb, line 16
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 28
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 59
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_components.rb, line 17
def self.require_all_individual_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/replay_from_the_stored_file.rb, line 79
def self.return_path_to_the_all_programs_file
  "#{temp_directory?}all_programs.yml"
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:
  # ======================================================================= #
  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 17
def self.return_remote_url_of_this_program(i = ARGV)
  if i.is_a? Array
    i = i.first
  end
  begin
    require 'rbt/utility_scripts/url.rb'
    i = RBT.return_url1_of_this_program(i)
  rescue LoadError; end
  i
end

# File lib/environment_information/toplevel_methods/return_version_of_this_program.rb, line 45
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.
  case this_program.to_s
  when 'diff'
    this_program = 'diffutils'
  when 'yacc'
    this_program = 'bison'
  end
  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
    # ======================================================================= #
    when :pkgconfig
      # =================================================================== #
      # In this case it must be generic.
      # =================================================================== #
      cmd = "pkg-config --modversion #{this_program} #{ERROR_LINE}"
      version = `#{cmd}`
      version = COMMAND_NOT_FOUND if version.include? NOT_FOUND_IN_PKG_CONFIG_SEARCH_PATH
    # ======================================================================= #
    # === :custom_gtk2
    # ======================================================================= #
    when :custom_gtk2
      cmd = "pkg-config --modversion gtk+-2.0 #{ERROR_LINE}"
      version = `#{cmd}`
      version = COMMAND_NOT_FOUND if version.include? NOT_FOUND_IN_PKG_CONFIG_SEARCH_PATH
    # ======================================================================= #
    # === :custom_mpc
    #
    # We rely on the header called mpc.h.
    # ======================================================================= #
    when :custom_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 
      end
    # ======================================================================= #
    # === :custom_boost
    # ======================================================================= #
    when :custom_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
        register_this_component_is_missing(:boost)
      end
    # ======================================================================= #
    # === :version
    #
    # 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: ')+
          Colours.steelblue(cmd)
      end
      # =================================================================== #
      # === Run the system command
      #
      # Next run the system command:
      # =================================================================== #
      _ = `#{cmd}`.strip
      case this_program.to_sym
      when :bison,
           :libtool,
           :gcc,
           :gettext,
           :m4,
           :grep
        _ = _.split(N).first.split(' ').last
      when :screen
        # ================================================================= #
        # Assume a String like this: "Screen version 4.08.00 (GNU) 05-Feb-20"
        # ================================================================= #
        version = _.scan(/version (\d{1}\.?\d{1,2}\.?\d{1})/).flatten.first.to_s.strip
        # ================================================================= #
        # Must still correct the middle part.
        # ================================================================= #
        splitted = version.split('.')
        splitted[1][0,1] = '' # Kill the leading '0'.
        version = splitted.join('.')
        _ = nil
      when :php
        # ================================================================= #
        # This check has to be a bit more sophisticated, so we
        # use scan.
        #
        # Examples:
        #
        #   PHP 5.6.23 (cli) (built: Jun 24 2016 16:19:35)
        #   PHP 7.4.2 (cli) (built: Jan 21 2020 16:57:46) ( NTS )
        #
        # ================================================================= #
        result = _.scan(
          /PHP (\d{1,2}\.?\d{1,2}\.?\d{1,2}) \(cli\)/
        )
        _ = result.flatten.first.strip
      when :ruby
        _ = _.split(' ')[1]
        if _.include? 'p'
          _ = _[0 .. (_.index('p') - 1)]
        end
      end
      # =================================================================== #
      # The program could not be found.
      # =================================================================== #
      if _.include? NO_SUCH_FILE_OR_DIRECTORY
        _ = nil
        version = nil
      # =================================================================== #
      # Assume output like this:
      #
      #   This is perl 5, version 30, subversion 0 (v5.30.0) built for x86_64-linux-thread-multi
      #
      # =================================================================== #
      elsif _.include?('This is perl ')
        use_this_regex = /\(v(\d{1,2}.\d{1,2}.\d{1,2})\)/ # See: https://rubular.com/r/I1z0M5T9oNaVm4
        _ =~ use_this_regex
        _ = $1.to_s.dup
      # =================================================================== #
      # === Handle cmake-related errors
      # =================================================================== #
      elsif _.include?('Could not find CMAKE_ROOT')
        _ = nil
        version = nil
      # =================================================================== #
      # === Handle VIM next
      # =================================================================== #
      elsif _.include?('VIM - Vi IMproved ')
        _ = _.scan(
          /VIM - Vi IMproved (\d{1,2}\.?\d{1,2}) /
        ).flatten.first.to_s.dup
      # =================================================================== #
      # === Handle XZ utils next
      # =================================================================== #
      elsif _.include?('xz (XZ Utils) ')
        _ = _.scan(
          /xz \(XZ Utils\) (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first.to_s
      elsif _.include? 'GNU tar'
        use_this_regex = /tar \(GNU tar\) (\d+\.?\d{2})/
        _ =~ use_this_regex
        _ = $1.to_s.dup
      elsif _.include? 'sed (GNU sed) '
        _ = _.scan(/sed \(GNU sed\) (\d+.\d+)/).flatten.first.to_s
      elsif _.include? N
        _ = _.split(N).first
      end if _
      if _
        _.sub!(/^GNU /,'') if _.start_with? 'GNU '
        _.sub!(/ built on linux-gnu./,'') if _.include? ' built on linux-gnu.'
        if _.include? ', version '
          # =============================================================== #
          # This is specifically for bash.
          #
          # Example:
          #   GNU bash, version 5.0.0(1)-release (x86_64-pc-linux-gnu)
          # =============================================================== #
          version = _.scan(
            /, version (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
          ).flatten.first.strip
          if this_program == :bash
            version.chop!; version.chop! # Ad-hoc workaround.
          end
        elsif _.include? ' Version '
          version = _.scan(/\d{1,2}\.?\d{1,2}\.?\d{1,2}/).flatten.first.to_s
        elsif _.include? ' version '
          version = _.scan(/ version (\d{1,2}\.?\d{1,2}\.?\d{1,2})/).flatten.first.to_s
        else
          if _.include? ', '
            _ = _.split(',').first # Fix entries like: "Awk 5.0.1, API: 2.0"
          end
          # =============================================================== #
          # Assume a String like this, which has to be modified a bit:
          #
          #   "gnuplot 5.2 patchlevel 8"
          #
          # =============================================================== #
          _.sub!(/ patchlevel /,'.') if _.include? ' patchlevel '
          # =============================================================== #
          # Else assume a result such as this:
          #
          #   bison (GNU Bison) 3.5.1
          #
          # =============================================================== #
          if _.include?(' ') and !_.include?(' (') # <- The second case will be for vim.
            version = _.split(' ').last.strip
          # =============================================================== #
          # The next clause is specifically for this:
          #
          #   file-5.38
          #
          # =============================================================== #
          elsif _.include?('-') and !_.include?(' (') 
            version = _.split('-').last.strip
          elsif _.include? ' ('
            # =============================================================== #
            # This must also handle cases such as: "xz (XZ Utils) 5.2.4"
            # =============================================================== #
            version = _.split(' (').last.to_s.strip
          else
            version = _
          end
          # =============================================================== #
          # Next specifically remove 'v' because "node --version" may
          # include that.
          # =============================================================== #
          version.delete!('v') if version.include? 'v'
        end
      end
    else # else tag
      cmd = "#{@prefix_to_use}#{use_this_command} #{ERROR_LINE}"
      first_line = nil
      # =================================================================== #
      # Next, run that system-command:
      # =================================================================== #
      result_of_system_cmd = `#{cmd}`
      if result_of_system_cmd.encoding.to_s == 'US-ASCII'
        result_of_system_cmd = result_of_system_cmd.force_encoding(UTF_ENCODING)
      end
      newline_splitted = result_of_system_cmd.split(N)
      if newline_splitted.first.include? 'hmmpgmd :: search a query against a database'
        newline_splitted.shift
      end
      # =================================================================== #
      # Handle the case where the .pc file could not be found.
      # =================================================================== #
      if result_of_system_cmd.include? NOT_FOUND_IN_PKG_CONFIG_SEARCH_PATH
        first_line = COMMAND_NOT_FOUND
        version = nil
      elsif result_of_system_cmd.include? COMMAND_NOT_FOUND
        first_line = COMMAND_NOT_FOUND
      elsif result_of_system_cmd.include? 'java version "'
        first_line = result_of_system_cmd.scan(
          /java version "(\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first.to_s.strip
      elsif result_of_system_cmd.include? 'KDE Frameworks: '
        first_line = result_of_system_cmd.scan(
          /KDE Frameworks: (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first
      end
      if this_program == :ncurses
        first_line = result_of_system_cmd.split(' ').last.strip
        first_line = first_line.split('.')[0..-2].join('.')
      elsif this_program == :ffmpeg
        first_line = result_of_system_cmd.split(N).first.split(' ')[2]
      elsif result_of_system_cmd.include? 'LLVM version '
        first_line = result_of_system_cmd.scan(
          /LLVM version (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first
      else
        first_line = newline_splitted.first if first_line.nil?
      end
      if first_line
        if first_line.include? '# '
          if first_line.start_with? '# '
            first_line.sub!(/# /,'')
          end
        elsif first_line.include? ' #'
          first_line = first_line[0 .. first_line.index(' #')].strip
        end
      end
      if first_line.include? COMMAND_NOT_FOUND
        version = nil
      elsif first_line.include? 'Version: ImageMagick '
        version = first_line.scan(
          /Version: ImageMagick (\d{1,2}\.?\d{1,2}\.?\d{1,2}-\d{1,2})/
        ).flatten.first.to_s.strip.tr('-','.')
      elsif first_line.include? 'HMMER'
        version = first_line.scan(
          /HMMER (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first.to_s.strip
      # === "XTerm(353)"
      elsif first_line.include?('(') and first_line.include?(')')
        version = first_line.split('(').last.delete(')')
      elsif first_line.include? ' Version '
        version = first_line.scan(
          / Version (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first.to_s.strip
      elsif first_line.include? ' version '
        version = first_line.scan(
          / version (\d{1,2}\.?\d{1,2}\.?\d{1,2})/
        ).flatten.first.to_s.strip
      else
        version = first_line
        if version.include? ' '
          version = version.split(' ').last
        end
        version.strip!
      end
      if version
        if version.include?('/')
          # =============================================================== #
          # Assume input such as:
          #
          #   nginx version: nginx/1.16.1
          #
          # =============================================================== #
          version = version.split('/').last.strip
        end
        if version.include? ' '
          version = version.split(' ').last # Always assume the last part in this case.
        end
      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
  if version and version.include? 'n'
    version = version.dup if version.frozen?
    version.delete!('n') # Ad-hoc fix for "node --version".
  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/colours/colours.rb, line 102
def self.rev
  ::Colours.rev
end

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

# File lib/environment_information/misc_components/rubygems_installation_directory.rb, line 22
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/gui/gtk/bindings.rb, line 206
def self.run_gtk
  x = ::EnvironmentInformation.gtk_bindings
  r = Gtk.run(
     ::EnvironmentInformation::EnvironmentInformation::GUI::GtkEnvironmentInformation.width,
     ::EnvironmentInformation::EnvironmentInformation::GUI::GtkEnvironmentInformation.height,
     :tabble,
     'Environment Information',2 
  )
  r << x # ← Add the widget here.
  r.add_shortcut(1, 'focus(:left)', :alt)
  r.modify_bg(
    Gtk::STATE_NORMAL, Gdk::Color.parse('grey')
  )
  r.top_left_then_run
end

# File lib/environment_information/class/initialize.rb, line 163
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 89
def self.science_cluster?
  ARRAY_SCIENCE_CLUSTER
end

# File lib/environment_information/misc_components/screen_resolution.rb, line 21
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`
  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 37
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 91
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 41
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 _
    # ===================================================================== #
    # === --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
    # ===================================================================== #
    # === --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
    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)
    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 = return_remote_gtk2_version
        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 97
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 33
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 65
def self.silent_run
  @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.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/gtk/bindings.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 71
def self.steelblue(i = '')
  if @use_colours
    i = ::Colours.steelblue(i)
  end
  i
end

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

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

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

# File lib/environment_information/colours/colours.rb, line 27
def self.use_colours?
  @use_colours
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 13
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 145
def self.xorg_components?
  ARRAY_XORG_COMPONENTS
end