environment_information 1.4.99

data/lib/environment_information/toplevel_methods/menu.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/menu.rb'
+# =========================================================================== #
+module EnvironmentInformation
+
+  require 'environment_information/toplevel_methods/e.rb'
+  require 'environment_information/version/version.rb'
+  require 'environment_information/colours/colours.rb'
+  require 'environment_information/colours/simp.rb'
+  require 'environment_information/constants/regex.rb'
+
+  # ========================================================================= #
+  # === EnvironmentInformation.menu
+  # ========================================================================= #
+  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
+
+  # ========================================================================= #
+  # === EnvironmentInformation.report_version
+  # ========================================================================= #
+  def self.report_version
+    e "#{rev}The version of the EnvironmentInformation project "\
+      "in use is: #{simp(VERSION)}#{rev}"
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.start_gtk_component
+  #
+  # We have to rescue the code so to notify the user what exactly
+  # may have failed.
+  # ========================================================================= #
+  def self.start_gtk_component
+    begin
+      this_file = 'environment_information/gui/gtk3/environment_information.rb'
+      require this_file
+    rescue LoadError => error
+      e "An error happened - file #{sfile(this_file)} could not be found."
+      pp error
+    end
+    ::EnvironmentInformation.run_gtk
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  EnvironmentInformation.menu(ARGV)
+end # rb menu.rb --version

data/lib/environment_information/toplevel_methods/misc.rb

@@ -0,0 +1,322 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/misc.rb'
+# EnvironmentInformation.return_version_of_mpc
+# =========================================================================== #
+module EnvironmentInformation
+
+  require 'environment_information/constants/misc.rb'
+  require 'environment_information/toplevel_methods/hash.rb'
+  require 'environment_information/toplevel_methods/write_what_into.rb'
+
+  # ========================================================================= #
+  # === Environment.verbose_truth
+  # ========================================================================= #
+  def self.verbose_truth(i)
+    case i
+    when /true/
+      'Yes.'
+    when /false/
+      'No.'
+    end
+  end
+
+  # ========================================================================= #
+  # === Environment.silent_run
+  # ========================================================================= #
+  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; self.instance_eval { alias build_up_and_return_the_main_hash silent_run } # === EnvironmentInformation.build_up_and_return_the_main_hash
+       self.instance_eval { alias initialize_hash                   silent_run } # === EnvironmentInformation.initialize_hash
+       self.instance_eval { alias initialize                        silent_run } # === EnvironmentInformation.initialize
+       self.instance_eval { alias run                               silent_run } # === EnvironmentInformation.run
+
+  # ========================================================================= #
+  # === EnvironmentInformation.consider_storing_these_results_into_a_local_file
+  #
+  # This method will always take the dataset stored in the main Hash when
+  # saving the yaml file at hand.
+  # ========================================================================= #
+  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 these #{royalblue(@hash_available_programs.size)} "\
+        "components into: #{sfile(into)}" if be_verbose
+      write_what_into(what, into)
+    end
+  end; self.instance_eval { alias store_relevant_files consider_storing_these_results_into_a_local_file } # === EnvironmentInformation.store_relevant_files
+
+  # ========================================================================= #
+  # === EnvironmentInformation.show_detailed_information_about_all_available_components
+  #
+  # This method is mostly for testing purposes only; for real use
+  # for the project you should consider making use of
+  # Environment.silent_run instead.
+  #
+  # Do note that this method will always show all available components;
+  # if you need more fine-tuned control then you have to use the
+  # class EnvironmentInformation instead.
+  # ========================================================================= #
+  def self.show_detailed_information_about_all_available_components
+    @hash_available_programs = {} # Clear it every time this method is run. 
+    work_on_these_programs = []
+    work_on_these_programs << 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; self.instance_eval { alias test show_detailed_information_about_all_available_components } # === EnvironmentInformation.test
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_xrandr
+  # ========================================================================= #
+  def self.return_version_of_xrandr
+    _ = `xrandr --version`
+    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
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_xvid
+  # ========================================================================= #
+  def self.return_version_of_xvid(
+      target_file = '/usr/include/xvid.h'
+    )
+    if File.exist?('/System/Index/include/'+File.basename(target_file)) and
+      !File.exist?(target_file) # Custom fix.
+      target_file = '/System/Index/include/'+File.basename(target_file)
+    end
+    if File.exist? target_file
+      dataset = File.readlines(target_file)
+      version = dataset.select {|line|
+        line.include? '  XVID_MAKE_VERSION(' # #define XVID_VERSION             XVID_MAKE_VERSION(1,3,7)
+      }
+      if version.is_a? Array
+        version = version.flatten.first.to_s
+      end
+      version = version.scan( # See:  https://rubular.com/r/4anuroBmb40yzh
+        /XVID_MAKE_VERSION\((\d{0,1},\d{0,1},\d{0,1})/
+        
+      )
+      if version.is_a? Array
+        version = version.flatten.first.to_s
+      end
+      version.tr!(',','.')
+    else
+      version = nil
+    end
+    return version
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_busybox
+  # ========================================================================= #
+  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
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_boost
+  #
+  # This method will either return a String (the version of boost),
+  # or nil if boost was not found.
+  # ========================================================================= #
+  def self.return_version_of_boost
+    target_file = '/usr/include/boost/version.hpp'
+    if File.exist?('/System/Index/include/boost/version.hpp') and
+      !File.exist?(target_file) # Custom fix.
+      target_file = '/System/Index/include/boost/version.hpp'
+    end
+    if File.exist? target_file
+      dataset = File.readlines(target_file)
+      version = dataset.select {|line|
+        line.include? '#define BOOST_LIB_VERSION'
+      }.first.sub(/#define BOOST_LIB_VERSION/,'').
+              strip.delete('"').tr('_','.')
+      if version.count('.') < 2
+        version << '.0'
+      end
+    else
+      version = nil
+    end
+    return version
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_version_of_mpc
+  #
+  # This method will read the version-string from a .h header file.
+  # ========================================================================= #
+  def self.return_version_of_mpc
+    target_file = '/usr/include/mpc.h'
+    if File.exist? target_file
+      dataset = File.read(target_file)
+      use_this_regex = /MPC_VERSION_STRING "([0-9\.]+)"$/
+      dataset = dataset.scan(use_this_regex).flatten
+      version = dataset.first
+      return version
+    else
+      return THE_PROGRAM_WAS_NOT_FOUND
+    end
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_array_of_outdated_programs
+  #
+  # This method will return all programs that are outdated - this
+  # also includes missing programs, so the method name is a slight
+  # misnomer.
+  #
+  # Usage example:
+  #
+  #   EnvironmentInformation.initialize
+  #   array = EnvironmentInformation.return_array_of_outdated_programs
+  #
+  # ========================================================================= #
+  def self.return_array_of_outdated_programs(
+      hash = ::EnvironmentInformation.hash?
+    )
+    forbidden = ::EnvironmentInformation.load_file_array_tracked_non_programs
+    # ======================================================================= #
+    # Now find all entries that are either nil, or have a too low program
+    # version.
+    # ======================================================================= #
+    array = hash.select {|key, value|
+      if value and forbidden.include?(key) # ← we exclude entries here such as "rubygems_installation_dir".
+        false
+      else
+        if value.nil? or value.include?('not found') or
+           !(value =~ /\d+/) # ← check for at the least one number, such as "1".
+          true
+        else
+          false
+        end
+      end
+    }.keys
+    # ======================================================================= #
+    # Next, check these against the local program version:
+    #  local_program_version = key
+    # ======================================================================= #
+    return array
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_the_most_important_info
+  #
+  # This method will just return a String that can be used right away
+  # in, for example, a sinatra application.
+  # ========================================================================= #
+  def self.return_the_most_important_info
+    'Operating system:                '+::EnvironmentInformation.operating_system+'<br>'+
+    'Operating system bit type:       '+::EnvironmentInformation.operating_system_bit_type+'<br>'+
+    'CPU model:                       '+::EnvironmentInformation.cpu_model+'<br>'
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_everything
+  # ========================================================================= #
+  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
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts EnvironmentInformation.return_version_of_mpc
+  puts EnvironmentInformation.return_version_of_boost
+  EnvironmentInformation.test
+end

data/lib/environment_information/toplevel_methods/n_subcommands.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/n_subcommands.rb'
+# =========================================================================== #
+module EnvironmentInformation
+
+  require 'environment_information/constants/array_tracked_components.rb'
+
+  # ========================================================================= #
+  # === EnvironmentInformation.n_subcommands?
+  #
+  # Return how many subcommands are available/registered. These are
+  # the tracked programs; and the xorg-components.
+  #
+  # The non-programs will not be gathered by this method, on purpose; they
+  # are not standalone programs after all.
+  #
+  # As of August 2020, 167 programs were tracked by this gem.
+  # ========================================================================= #
+  def self.n_subcommands?
+    ARRAY_TRACKED_PROGRAMS.size+
+    ARRAY_XORG_COMPONENTS.size
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  pp EnvironmentInformation.n_subcommands?
+end

data/lib/environment_information/toplevel_methods/prefix_to_use.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/prefix_to_use.rb'
+# =========================================================================== #
+module EnvironmentInformation
+
+  # ========================================================================= #
+  # === @prefix_to_use
+  #
+  # This variable can be used to designate another base directory to
+  # be used, such as at /home/Programs/. This allows us to scan
+  # through an AppDir and output the programs found there.
+  #
+  # By default it must be an empty String, as many other files check
+  # on the content of this variable - so only change it if you really
+  # need to use another prefix to use.
+  #
+  # The functionality was specifically added to support versioned
+  # AppDirs on a given computer system.
+  # ========================================================================= #
+  @prefix_to_use = ''.dup
+
+  # ========================================================================= #
+  # === EnvironmentInformation.set_prefix_to_use
+  # ========================================================================= #
+  def self.set_prefix_to_use(i)
+    @prefix_to_use = i.to_s.dup
+  end; self.instance_eval { alias set_prefix set_prefix_to_use } # === EnvironmentInformation.set_prefix
+
+  # ========================================================================= #
+  # === EnvironmentInformation.prefix?
+  # ========================================================================= #
+  def self.prefix?
+    @prefix_to_use
+  end
+
+end

data/lib/environment_information/toplevel_methods/register_this_component_is_missing.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/register_this_component_is_missing.rb'
+# EnvironmentInformation.register_this_component_is_missing
+# =========================================================================== #
+module EnvironmentInformation
+
+  # ========================================================================= #
+  # === @array_this_component_is_missing
+  #
+  # This Array keeps track of all components that are missing on the
+  # given system.
+  # ========================================================================= # 
+  @array_this_component_is_missing = []
+
+  # ========================================================================= #
+  # === EnvironmentInformation.which_components_are_missing?
+  # ========================================================================= # 
+  def self.which_components_are_missing?
+    @array_this_component_is_missing
+  end; self.instance_eval { alias missing_components? which_components_are_missing? } # === EnvironmentInformation.missing_components?
+
+  # ========================================================================= #
+  # === EnvironmentInformation.clear_missing_components
+  # ========================================================================= #
+  def self.clear_missing_components
+    @array_this_component_is_missing.clear
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.register_this_component_is_missing
+  #
+  # The ideal input to this method is a Symbol, so that the Array
+  # stores only missing components that way.
+  # ========================================================================= # 
+  def self.register_this_component_is_missing(i)
+    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
+
+  # ========================================================================= #
+  # === EnvironmentInformation.is_this_component_missing?
+  # ========================================================================= #
+  def self.is_this_component_missing?(i)
+    !@array_this_component_is_missing.include?(i)
+  end
+
+end

data/lib/environment_information/toplevel_methods/remote_url_of_this_program.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/remote_url_of_this_program.rb'
+# =========================================================================== #
+module EnvironmentInformation
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_remote_url_of_this_program
+  #
+  # This method will try to return the remote URL of the given program.
+  #
+  # Note that this functionality depends on the RBT project, which
+  # explains the rescued required statement in the method. While in
+  # theory we could create a stand-alone solution, I don't want to
+  # duplicate code I already wrote for another project, so users
+  # are encouraged to install the rbt gem - it's what I use on my
+  # home system as well.
+  # ========================================================================= #
+  def self.return_remote_url_of_this_program(i = ARGV)
+    if i.is_a? Array
+      i = i.first
+    end
+    begin
+      require 'rbt/utility_scripts/url.rb'
+      i = RBT.return_url1_of_this_program(i)
+    rescue LoadError; end
+    i
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.show_remote_url_of_this_program
+  #
+  # This method will try to show the remote URL of the given program.
+  # ========================================================================= #
+  def self.show_remote_url_of_this_program(i = ARGV)
+    puts return_remote_url_of_this_program(i)
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  EnvironmentInformation.show_remote_url_of_this_program(ARGV)  
+end # rb remote_url_of_this_program.rb glib

data/lib/environment_information/toplevel_methods/replay_from_the_stored_file.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'environment_information/toplevel_methods/replay_from_the_stored_file.rb'
+# EnvironmentInformation.replay_from_the_stored_file
+# EnvironmentInformation.colourize_and_pad_the_left_side
+# =========================================================================== #
+module EnvironmentInformation
+
+  require 'yaml'
+  require 'environment_information/constants/temp_directory.rb'
+  require 'environment_information/colours/colours.rb'
+
+  # ========================================================================= #
+  # === EnvironmentInformation.return_path_to_the_all_programs_file
+  # ========================================================================= #
+  def self.return_path_to_the_all_programs_file
+    "#{temp_directory?}all_programs.yml"
+  end
+
+  # ========================================================================= #
+  # === EnvironmentInformation.replay_from_the_stored_file
+  #
+  # To invoke this method from the commandline, try:
+  #
+  #   envi --replay
+  #
+  # ========================================================================= #
+  def self.replay_from_the_stored_file(
+      _ = return_path_to_the_all_programs_file
+    )
+    if File.exist? _
+      e "Loading from the file #{_}."
+      @hash_available_programs = YAML.load_file(_)
+      @hash_available_programs.each_pair {|key, value|
+        e 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
+
+  # ========================================================================= #
+  # === EnvironmentInformation.colourize_and_pad_the_right_side
+  # ========================================================================= #
+  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; self.instance_eval { alias prepare_right_side colourize_and_pad_the_right_side } # === EnvironmentInformation.prepare_right_side
+
+  # ========================================================================= #
+  # === EnvironmentInformation.colourize_and_pad_the_left_side
+  # ========================================================================= #
+  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; self.instance_eval { alias prepare_left_side colourize_and_pad_the_left_side } # === EnvironmentInformation.prepare_left_side
+
+end