easycompile 1.0.9

data/lib/easycompile/base/misc.rb

@@ -0,0 +1,1157 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'easycompile/base/misc.rb'
+# =========================================================================== #
+require 'easycompile/constants/array_possible_archives.rb'
+require 'easycompile/base/change_directory.rb'
+require 'easycompile/base/colours.rb'
+require 'easycompile/base/cmake.rb'
+require 'easycompile/base/commandline_arguments.rb'
+require 'easycompile/base/help.rb'
+require 'easycompile/base/opn.rb'
+require 'easycompile/base/process_the_input.rb'
+require 'easycompile/base/remove.rb'
+
+module Easycompile
+
+class Base
+
+  begin
+    require 'program_information'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === return_pwd
+  # ========================================================================= #
+  def return_pwd
+    ("#{Dir.pwd}/").squeeze '/'
+  end
+
+  # ========================================================================= #
+  # === set_find_this_program
+  #
+  # This will store e. g. "php", so that we can designate to work on
+  # a particular program, and pass this information to external
+  # programs if necessary.
+  # ========================================================================= #
+  def set_find_this_program(i)
+    @find_this_program = i
+  end
+
+  # ========================================================================= #
+  # === rds
+  # ========================================================================= #
+  def rds(i)
+    i.squeeze('/')
+  end
+
+  # ========================================================================= #
+  # === find_this_program?
+  # ========================================================================= #
+  def find_this_program?
+    @find_this_program
+  end; alias find_which_program? find_this_program? # === find_which_program?
+
+  # ========================================================================= #
+  # === run_rinstall2
+  # ========================================================================= #
+  def run_rinstall2
+    copy_setup_rb
+    internal_system 'ruby setup.rb config'
+    internal_system 'ruby setup.rb setup'
+    internal_system 'ruby setup.rb install'
+    internal_system 'rm setup.rb'
+    internal_system 'rm InstalledFiles'
+    internal_system 'rm .config'
+  end
+
+  # ========================================================================= #
+  # === prefix?
+  # ========================================================================= #
+  def prefix?
+    @prefix
+  end
+
+  # ========================================================================= #
+  # === set_this_build_dir
+  # ========================================================================= #
+  def set_this_build_dir(i = :pwd)
+    case i
+    when :pwd
+      i = return_pwd
+    end
+    i = i.to_s
+    unless i.include? '/'
+      i = File.absolute_path(i)
+    end
+    unless i.end_with? '/'
+      i = i.dup if i.frozen?
+      i << '/'
+    end
+    @build_directory_is_stored_here = i
+  end; alias set_build_directory set_this_build_dir # === set_build_directory
+
+  # ========================================================================= #
+  # === run_perl_installation
+  # ========================================================================= #
+  def run_perl_installation
+    _ 'perl Makefile.PL'
+  end
+
+  # ========================================================================= #
+  # === copy_setup_rb
+  # ========================================================================= #
+  def copy_setup_rb
+    FileUtils.cp(LOCATION_OF_SETUP_RB, return_pwd)
+  end
+
+  # ========================================================================= #
+  # === temp_dir?
+  # ========================================================================= #
+  def temp_dir?
+    ::Easycompile.temp_dir?
+  end
+
+  # ========================================================================= #
+  # === filename
+  # ========================================================================= #
+  def filename
+    return File.basename(__FILE__)+':'
+  end; alias filename? filename # === filename?
+
+  # ========================================================================= #
+  # === find_partial_match_for
+  # ========================================================================= #
+  def find_partial_match_for(i)
+    possible_matches = Dir["#{i}*"]
+    return_value = false
+    return_value = true unless possible_matches.empty?
+    return [return_value, possible_matches] # Returns an Array.
+  end
+
+  # ========================================================================= #
+  # === Easycompile::Base.version?
+  # ========================================================================= #
+  def self.version?
+    Easycompile.version?
+  end
+
+  # ========================================================================= #
+  # === temp_directory?
+  # ========================================================================= #
+  def temp_directory?
+    @temp_directory
+  end
+
+  # ========================================================================== #
+  # === open_this_file
+  # ========================================================================== #
+  def open_this_file(this_file = self.class::THIS_FILE)
+    esystem "bluefish #{this_file}"
+  end
+
+  # ========================================================================= #
+  # === do_not_create_a_build_directory
+  #
+  # Use this method if you do not wish to create a build directory.
+  # ========================================================================= #
+  def do_not_create_a_build_directory
+    @shall_we_create_a_build_directory = false
+  end
+
+  # ========================================================================= #
+  # === skip_make_install?
+  # ========================================================================= #
+  def skip_make_install?
+    @skip_make_install
+  end
+
+  # ========================================================================= #
+  # === set_start_dir
+  # ========================================================================= #
+  def set_start_dir(i = return_pwd)
+    i.squeeze! '/'
+    @start_dir = i # This is not @base_dir.
+  end
+
+  # ========================================================================= #
+  # === start_dir?
+  # ========================================================================= #
+  def start_dir?
+    @start_dir
+  end
+
+  # ========================================================================= #
+  # === empty_dir?
+  # ========================================================================= #
+  def empty_dir?(i)
+    Dir["#{i}/*"].empty?
+  end
+
+  # ========================================================================= #
+  # === set_extract_to_this_directory
+  # ========================================================================= #
+  def set_extract_to_this_directory(i = :default)
+    case i
+    # ======================================================================= #
+    # === :default
+    # ======================================================================= #
+    when :default,
+         nil
+      i = temp_dir?
+    end
+    i = i.to_s.dup
+    unless i.end_with? '/'
+      i = i.dup if i.frozen?
+      i << '/'
+    end
+    # ======================================================================= #
+    # === Handle blocks given to this method next:
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :be_verbose
+      # ===================================================================== #
+      when :be_verbose
+        e "#{rev}Using the directory #{sdir(i)} as temp-directory next."
+        e '(The archive at hand will be extracted to this directory.)'
+      end
+    end
+    @extract_to_this_directory = i
+  end; alias set_extract_to set_extract_to_this_directory # === set_extract_to
+
+  # ========================================================================= #
+  # === extract_to_this_directory?
+  # ========================================================================= #
+  def extract_to_this_directory?
+    @extract_to_this_directory
+  end; alias extract_to? extract_to_this_directory? # === extract_to?
+
+  # ========================================================================= #
+  # === shall_we_create_a_build_directory?
+  # ========================================================================= #
+  def shall_we_create_a_build_directory?
+    @shall_we_create_a_build_directory
+  end
+
+  # ========================================================================= #
+  # === set_name_of_build_directory
+  # ========================================================================= #
+  def set_name_of_build_directory(
+      i = :default
+    )
+    case i
+    # ======================================================================= #
+    # === :load_the_yaml_file
+    # ======================================================================= #
+    when :load_the_yaml_file,
+         :default
+      i = YAML.load_file(FILE_NAME_OF_THE_BUILD_DIRECTORY)
+    end
+    i = i.dup if i.frozen?
+    i << '/' unless i.end_with? '/'
+    @name_of_build_directory = i
+  end
+
+  # ========================================================================= #
+  # === name_of_build_directory?
+  #
+  # This method will return the name of the BUILD/ directory. For now
+  # this is static but perhaps one day we may wish to change this,
+  # in order to make it more dynamic.
+  # ========================================================================= #
+  def name_of_build_directory?
+    @name_of_build_directory
+  end; alias name_for_build_dir?          name_of_build_directory? # === name_for_build_dir?
+       alias name_of_the_build_directory? name_of_build_directory? # === name_of_the_build_directory?
+
+  # ========================================================================= #
+  # === continue_past_configure_stage?
+  # ========================================================================= #
+  def continue_past_configure_stage?
+    @continue_past_configure_stage
+  end
+
+  # ========================================================================= #
+  # === do_make_use_of_a_build_directory
+  # ========================================================================= #
+  def do_make_use_of_a_build_directory
+    @shall_we_create_a_build_directory = true
+  end
+
+  # ========================================================================= #
+  # === are_we_on_gobolinux?
+  # ========================================================================= #
+  def are_we_on_gobolinux?
+    ENV['IS_ON_GOBOLINUX'].to_s == '1'
+  end
+
+  # ========================================================================= #
+  # === set_original_input
+  #
+  # This method will keep track of the "original" input.
+  # ========================================================================= #
+  def set_original_input(i)
+    @original_input = i
+  end
+
+  # ========================================================================= #
+  # === original_input?
+  # ========================================================================= #
+  def original_input?
+    @original_input
+  end
+
+  # ========================================================================= #
+  # === mkdir                                                     (mkdir tag)
+  # ========================================================================= #
+  def mkdir(i)
+    FileUtils.mkdir_p(i)
+  end
+
+  # ========================================================================= #
+  # === can_not_continue
+  #
+  # Set @continue_past_configure_stage to false, so tha we won't continue.
+  # ========================================================================= #
+  def can_not_continue
+    @continue_past_configure_stage = false
+  end
+
+  # ========================================================================= #
+  # === continue_after_extracting?
+  # ========================================================================= #
+  def continue_after_extracting?
+    @continue_after_extracting
+  end
+
+  # ========================================================================= #
+  # === do_compile_with_dependencies
+  # ========================================================================= #
+  def do_compile_with_dependencies
+    opn_namespace; e 'We will compile the dependencies first.'
+    @compile_with_dependencies = true
+  end
+
+  # ========================================================================= #
+  # === enable_skip_make_install
+  # ========================================================================= #
+  def enable_skip_make_install
+    show_namespace; e 'We will skip running the "make install" step.'
+    @skip_make_install = true
+  end
+
+  # ========================================================================= #
+  # === skip_extracting?
+  # ========================================================================= #
+  def skip_extracting?
+    @skip_extracting
+  end
+
+  # ========================================================================= #
+  # === skip_extracting
+  # ========================================================================= #
+  def skip_extracting
+    show_namespace; e 'We will not extract.'
+    @skip_extracting = true
+  end
+
+  # ========================================================================= #
+  # === do_not_continue
+  #
+  # This method does not output anything to the user, on purpose.
+  # ========================================================================= #
+  def do_not_continue
+    @continue_after_extracting = false
+  end
+
+  # ========================================================================= #
+  # === do_not_compile
+  # ========================================================================= #
+  def do_not_compile
+    show_namespace; e 'We will not compile after extracting the source archive.'
+    do_not_continue
+  end
+
+  # ========================================================================= #
+  # === is_archive?
+  #
+  # Return true if the given input is an archive.
+  # ========================================================================= #
+  def is_archive?(i)
+    ::Easycompile.is_archive?(i)
+  end; alias is_an_archive? is_archive? # === is_an_archive?
+
+  # ========================================================================= #
+  # === consider_symlinking_appdir
+  #
+  # Use this method to consider symlinking into the AppDir hierarchy.
+  #
+  # We use class SymlinkProgram for this, from the RBT project. However
+  # had, when we are on GoboLinux, we will instead use the GoboLinux
+  # program called SymlinkProgram.
+  # ========================================================================= #
+  def consider_symlinking_appdir
+    _ = rds(prefix?+'/')
+    opn :namespace => NAMESPACE
+    e 'Next attempting to symlink at '+sdir(_)
+    if are_we_on_gobolinux?
+      cmd = 'SymlinkProgram '+_
+      esystem cmd
+    else
+      begin
+        require 'rbt/requires/require_symlink_this_program.rb'
+      rescue LoadError; end
+      if Object.const_defined?('RBT') and
+         RBT.const_defined?(SymlinkFromToCurrent)
+        RBT::SymlinkFromToCurrent.new(_)
+      end
+    end 
+  end
+
+  # ========================================================================= #
+  # === enter_extracted_directory
+  #
+  # We use this method to enter the extracted directory.
+  # ========================================================================= #
+  def enter_extracted_directory(i = @original_input)
+    i = remove_extension_from(i)
+    if File.directory? i
+      _ = i
+    else
+      _ = "#{@temp_directory}#{get_program_name(i)}"
+    end
+    i = i.dup
+    _ << '/' unless _.end_with? '/'
+    if Dir.exist? _ # Only inform the user that we cd if that directory exists.
+      show_namespace; e "Now entering the directory `#{sdir(_)}`."
+      cd _
+    end
+  end
+
+  # ========================================================================= #
+  # === set_program_version
+  # ========================================================================= #
+  def set_program_version(i)
+    @program_version = i
+  end
+  
+  # ========================================================================= #
+  # === set_base_dir
+  # ========================================================================= # 
+  def set_base_dir(i = return_pwd)
+    i = i.squeeze('/')
+    @base_dir = i
+  end
+
+  # ========================================================================= #
+  # === base_dir`
+  # ========================================================================= #
+  def base_dir?
+    @base_dir
+  end
+
+  # ========================================================================= #
+  # === program_version?
+  # ========================================================================= #
+  def program_version?
+    @program_version
+  end; alias version? program_version? # === version?
+
+  # ========================================================================= #
+  # === attempt_to_find_a_valid_file
+  #
+  # This method will attempt to sanitize incomplete entries such as
+  # "nettle-2.7" towards "nettle-2.7.tar.xz".
+  #
+  # When we pass something such as "htop.yml" and this file does not
+  # exist in the current directory, then we will attempt to find it
+  # in another directory.
+  # ========================================================================= #
+  def attempt_to_find_a_valid_file(i)
+    if i.is_a? Array
+      i.map! {|entry|
+        unless File.exist? entry
+          entry = File.basename(entry)
+          if entry.include?('.yml') or entry.end_with?('.')
+            entry = INDIVIDUAL_COOKBOOKS+entry
+            yaml_dataset = get_dataset_from(entry)
+            entry = yaml_dataset['program_path']
+            set_program_version(yaml_dataset['program_version'])
+          else
+            # Then we try a glob.
+            _ = Dir["#{entry}*"]
+            entry = _.first unless _.empty?
+          end
+        end
+        entry
+      }
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === set_hash
+  # ========================================================================= #
+  def set_hash(i = {})
+    if i.is_a? Hash
+      if i.has_key? :extract_to
+        set_extract_to(i[:extract_to])
+      end
+      if i.has_key? :program_version
+        set_version(i[:program_version])
+      end
+      if i.has_key? :prefix
+        set_prefix(i[:prefix])
+      end
+      if i.has_key? :appdir_layout
+        set_prefix(i[:appdir_layout])
+      elsif i.has_key? :usr_prefix
+        set_prefix(i[:usr_prefix])
+      end
+    end
+    @hash = i
+  end
+
+  # ========================================================================= #
+  # === program_name?
+  # ========================================================================= #
+  def program_name?
+    @program_name
+  end
+
+  # ========================================================================= #
+  # === consider_creating_a_build_directory
+  #
+  # Here we will consider whether we will create a build directory or
+  # whether we will not do so.
+  #
+  # If such a directory already exists then we do not need to create a
+  # new directory.
+  # ========================================================================= #
+  def consider_creating_a_build_directory(
+      where = return_pwd
+    )
+    if shall_we_create_a_build_directory?
+      _ = name_of_build_directory?
+      if File.exist? _
+        show_namespace
+        e "We will use the already existing build directory "\
+          "called `#{sdir(_)}`."
+        set_build_directory(_)
+      else
+        @base_dir = rds(where)
+        set_this_build_dir(File.absolute_path(_))
+        show_namespace
+        e 'We will create a build directory next called `'+sdir(_)+'` '\
+          '(Full target will be: '+@build_directory_is_stored_here+').'
+        # =================================================================== #
+        # Keep track of where the build directory is.
+        # =================================================================== #
+        mkdir @build_directory_is_stored_here # Creating the build directory finally.
+      end
+      # ===================================================================== #
+      # Next, we will enter that BUILD directory.
+      # ===================================================================== #
+      cd @build_directory_is_stored_here
+      show_namespace
+      # ===================================================================== #
+      # Notify the user that we have cd-ed already.
+      # ===================================================================== #
+      e 'Now entering the directory '+
+         sdir(@build_directory_is_stored_here)+'.'
+    end
+  end
+
+  # ========================================================================= #
+  # === compile_these_programs?
+  #
+  # This method will return on which input-files we will be working
+  # on, that is our target-programs.
+  # ========================================================================= #
+  def compile_these_programs?
+    @compile_these_programs
+  end; alias files? compile_these_programs? # === files?
+       alias file?  compile_these_programs? # === file?
+
+  # ========================================================================= #
+  # === add_this_archive                                            (add tag)
+  # ========================================================================= #
+  def add_this_archive(i)
+    if i
+      @compile_these_programs << i
+      @compile_these_programs.flatten!
+      @compile_these_programs.compact!
+    end
+  end; alias add_to_commandline_arguments add_this_archive # === add_to_commandline_arguments
+       alias set_files                    add_this_archive # === set_files
+       alias add_these_files              add_this_archive # === add_these_files
+       alias add                          add_this_archive # === add
+
+  # ========================================================================= #
+  # === check_for_dependencies
+  # ========================================================================= #
+  def check_for_dependencies
+    # ======================================================================= #
+    # Next, add dependencies. To try this, do:
+    #
+    #   ecompile metacity.yml wdeps
+    #
+    # ======================================================================= #
+    if @compile_with_dependencies
+      dependencies = get_dataset_from(@original_input)['required_deps_on']
+      dependencies.map! {|entry|
+        entry = entry.dup if entry.frozen?
+        entry << '.yml'
+      }
+      add(dependencies)
+    end
+  end
+
+  require 'extracter'
+  # ========================================================================= #
+  # === try_to_extract
+  #
+  # Use this method here to extract a given archive.
+  # ========================================================================= #
+  def try_to_extract(
+      this_archive, extract_to = extract_to?
+    )
+    if this_archive.is_a? Array # Obtain only the first element in this case.
+      this_archive = this_archive.first
+    end
+    cd start_dir?
+    if File.exist? this_archive.to_s
+      # ===================================================================== #
+      # In this case, we will assume that an valid archive was given to us.
+      # ===================================================================== #
+      unless skip_extracting?
+        show_namespace; e "Now trying to extract `#{sfancy(this_archive)}`."
+        @extracter = Extracter.what_to(this_archive, extract_to)
+        return remove_archive_at_the_end(
+          extract_to+
+          File.basename(this_archive)
+        )
+      else
+        nil
+      end
+    elsif File.exist? base_dir?+this_archive
+      unless skip_extracting?
+        @extracter = Extracter.what_to(base_dir?+this_archive, extract_to)
+      end 
+    else
+      # ===================================================================== #
+      # The file does not exist here at this point. Thus, we will
+      # do some further checks.
+      # ===================================================================== #
+      if this_archive =~ /^\d+$/ # Ok, user inputted a number alone, check first.
+        this_archive = Dir['*'].sort[ this_archive.to_i - 1 ]
+        if File.exist? this_archive
+          @extracter = Extracter.what_to(this_archive, extract_to)
+        end
+      elsif find_partial_match_for(this_archive).first # Ok, user could input a partial number and a string, like: "baobab-3.9"
+        matched = find_partial_match_for(i)[1]
+        consider_extracting_this_archive(matched)
+      else # Ok, it indeed does not exist.
+        show_namespace; e 'File `'+sfile(this_archive)+'` does '+
+                          'not exist. We thus can not continue.'
+        show_namespace; e 'We will not continue as a consequence.'
+        do_not_continue
+        return nil
+      end
+    end
+  end; alias extract_archive                  try_to_extract # === extract_archive
+       alias extract                          try_to_extract # === extract
+       alias consider_extracting_this_archive try_to_extract # === consider_extracting_this_archive
+
+  # ========================================================================= #
+  # === set_compile_these_programs
+  #
+  # This method specifies which programs this class will compile.
+  # ========================================================================= #
+  def set_compile_these_programs(i)
+    i = [i].flatten.compact
+    i.map! {|entry|
+      # ======================================================================= #
+      # The file in question may not exist, for instance if it is a remote URL
+      # link. In that case we enter here.
+      # ======================================================================= #
+      unless File.exist? entry
+        case entry # case tag
+        when 'ALL','A' # simply get all.
+          entry = Dir['*'].reject {|inner_entry| File.directory? inner_entry }
+        when /LAST/,/LAT/ # Special instruction.
+          entry = File.readlines(LAST_DOWNLOADED_FILE).first
+        else # Try a (silent) glob here if the file does not exist.
+          if entry.include?('http') # Assume this to be a remote file.
+            esystem "wget #{entry}"
+            entry = File.basename(entry)
+          else
+            glob = Dir["#{entry}*"]
+            entry = glob.first unless glob.empty?
+          end
+        end
+      end
+      entry
+    }
+    @compile_these_programs = i
+  end
+
+  # ========================================================================= #
+  # === consider_removing_the_archive
+  # ========================================================================= #
+  def consider_removing_the_archive(
+      i = @build_directory_is_stored_here
+    )
+    if remove_all_after_compile?
+      if i.responds_to? :each
+        i.each {|entry|
+          remove_directory(entry)
+        }
+      else
+        i = i.to_s
+        if shall_we_create_a_build_directory?
+          if File.exist?(i) and empty_dir?(i)
+            # =============================================================== #
+            # Ok, we found an empty build-directory. Since it is empty,
+            # we can safely remove it.
+            # =============================================================== #
+            remove_directory(i)
+          end
+        end
+      end
+    end
+  end; alias consider_removing_this_archive         consider_removing_the_archive # === consider_removing_this_archive
+       alias consider_purging_empty_build_directory consider_removing_the_archive # === consider_purging_empty_build_directory
+
+  # ========================================================================= #
+  # === run_configure                                         (configure tag)
+  #
+  # This method runs the classical configure command with a specific
+  # prefix. It is equivalent to just run "./configure".
+  # ========================================================================= #
+  def run_configure
+    if shall_we_create_a_build_directory?
+      @prefix_to_base_directory << '../'
+    end
+    # ======================================================================= #
+    # === Check for Rakefile
+    # ======================================================================= #
+    if File.exist?(@prefix_to_base_directory+'Rakefile')
+      run_rinstall2
+    # ======================================================================= #
+    # === Check for cmake-file
+    #
+    # Here we will run cmake.
+    # ======================================================================= #
+    elsif File.exist?("#{@prefix_to_base_directory}#{cmake_file?}")
+      run_cmake_command
+    # ======================================================================= #
+    # === Check for setup.py file
+    #
+    # Note that a file called setup.py may exist, but the program itself
+    # may still require a "configure" invocation. This is the case with
+    # the official source archive for Python.
+    # ======================================================================= #
+    elsif File.exist?(@prefix_to_base_directory+'setup.py')
+      run_python_installation
+    # ======================================================================= #
+    # === Check for Makefile.PL
+    # ======================================================================= #
+    elsif File.exist?(@prefix_to_base_directory+'Makefile.PL')
+      run_perl_installation
+    # ======================================================================= #
+    # === Check for build.sh file
+    #
+    # This was disabled on 20.06.2020 as it was not working for the
+    # program called "make". At a later time this may have to be
+    # re-enabled again, but for now it has to stay disabled.
+    # ======================================================================= #
+    # elsif File.exist? @prefix_to_base_directory+'build.sh'
+    #   run_build_sh
+    # ======================================================================= #
+    # === Run the configure command next
+    # ======================================================================= #
+    elsif File.exist? @prefix_to_base_directory+'configure'
+      simply_run_the_configure_command
+    # ======================================================================= #
+    # === Check for ruby .gem files next
+    # ======================================================================= #
+    elsif (@original_input =~ /\.gem$/)
+      install_this_gem(@original_input)
+      exit
+    # ======================================================================= #
+    # === Check whether 'meson.build' exists
+    # ======================================================================= #
+    elsif does_a_meson_build_file_exist?
+      compile_as_meson_based_project
+      exit
+    else # The default, that is - we will run ./configure here.
+      show_namespace; e 'We could not find a configure script, no cmake'
+      show_namespace; e 'file and we also could not find various other '
+      show_namespace; e 'files. We will now assume that configure may'
+      show_namespace; e 'still work, and thus run, but be aware that'
+      show_namespace; e 'this may fail.'
+      simply_run_the_configure_command
+    end
+  end; alias run_configure_command                    run_configure # === run_configure_command
+       alias run_configure_command_or_another_command run_configure # === run_configure_command_or_another_command
+       alias run_configure_or_cmake                   run_configure # === run_configure_command_or_another_command
+
+  # ========================================================================= #
+  # === simply_run_the_configure_command
+  # ========================================================================= #
+  def simply_run_the_configure_command
+    _  = ''.dup # ← Buildup the command.
+    _ << '.' if shall_we_create_a_build_directory?
+    _ << "./configure --prefix=#{prefix?}"
+    # ======================================================================= #
+    # === Check for etended configure options next
+    # ======================================================================= #
+    if @try_to_use_extended_configure_options
+      begin
+        require 'rbt/requires/require_show_configuration_options.rb'
+      rescue LoadError; end
+      if RBT.respond_to? :return_configuration_options_for?
+        _ << " #{RBT.return_configuration_options_for?(find_which_program?)}"
+      end
+    end
+    begin
+      # This part invokes the actual "./configure" run.
+      esystem(_) # Also show the ./configure command we will use.
+    rescue Errno::ENOENT
+      show_namespace
+      e 'An error happened - the configure-file could not be found. '\
+        'The faulty line was:'
+      show_namespace
+      e "  #{simp(_)}"
+      show_namespace
+      e "It was issued from the directory: #{sdir(return_pwd)}"
+      if return_pwd.include? name_for_build_dir?
+        set_this_build_dir(:pwd)
+      end
+      can_not_continue # We can not continue past the configure-step.
+      # ======================================================================= #
+      # Do "make distclean" here.
+      # ======================================================================= #
+      if _.include?('configure: error: source directory already configured') or
+         _.include?('source directory already configured; run "make distclean"')
+        @base_dir = return_pwd
+        cd '..'
+        make_distclean
+        cd @base_dir
+        run_configure_command
+      end if _
+    end
+  end
+
+  # ========================================================================= #
+  # === try_to_compile_or_install_this_program
+  # ========================================================================= #
+  def try_to_compile_or_install_this_program(this_archive)
+    if is_a_gem?(this_archive)
+      e "#{rev}Now installing the gem at #{sfile(this_archive)}."
+      install_this_gem(this_archive)
+    else
+      extracted_to = try_to_extract(this_archive)
+      if continue_after_extracting?
+        if File.directory? extracted_to
+          enter_extracted_directory(extracted_to)
+          consider_creating_a_build_directory
+          run_configure_make_and_make_install
+        end
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === return_to_start_directory_again
+  # ========================================================================= #
+  def return_to_start_directory_again
+    cd start_dir?
+  end
+
+  # ========================================================================= #
+  # === is_the_cookbook_class_available?
+  # ========================================================================= #
+  def is_the_cookbook_class_available?
+    Object.const_defined?(:RBT) and
+    RBT.const_defined?(:Cookbooks) and
+    RBT::Cookbooks.const_defined?(:Cookbook)
+  end
+
+  # ========================================================================= #
+  # === get_dataset_from
+  # ========================================================================= #
+  def get_dataset_from(i)
+    if !Object.const_defined?(:RBT) and !RBT.const_defined?(:Cookbooks)
+      begin
+        require 'rbt/requires/require_the_cookbook_class.rb'
+      rescue LoadError; end
+    end
+    i.chop! if i.end_with? '.'
+    if is_the_cookbook_class_available?
+      i = RBT::Cookbooks::SanitizeCookbook.new(i).dataset?
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === run_make_command_or_equivalent                             (make tag)
+  #
+  # This method will either run "make", or another command.
+  #
+  # For now we assume the alternative is via cmake. Please note that
+  # the command "make install" usually follows the "make" command.
+  # ========================================================================= #
+  def run_make_command_or_equivalent
+    show_namespace; e 'Running "make" in '+sdir(return_pwd)+' next.'
+    if File.exist? 'Makefile'
+      esystem 'make' if continue_past_configure_stage?
+    else # Else assume cmake.
+      esystem 'make' if continue_past_configure_stage?
+    end
+  end; alias run_make_command run_make_command_or_equivalent # === run_make_command
+       alias run_make         run_make_command_or_equivalent # === run_make
+
+  # ========================================================================= #
+  # === is_an_appdir?
+  #
+  # Return true if this is an appdir-based program.
+  # ========================================================================= #
+  def is_an_appdir?
+    @hash.has_key?(:prefix) and @hash[:prefix] == :appdir
+  end
+
+  # ========================================================================= #
+  # === determine_which_programs_to_compile
+  # ========================================================================= #
+  def determine_which_programs_to_compile
+    if @commandline_arguments.empty?
+      # ===================================================================== #
+      # If we did not input anything then use all archives from the
+      # current working directory.
+      # ===================================================================== #
+      _ = Dir['*'].select {|entry| is_an_archive?(entry) }
+    else
+      if @commandline_arguments.any? {|entry| entry.end_with? '.yml' }
+        # =================================================================== #
+        # Handle .yml files here.
+        # =================================================================== #
+        @commandline_arguments = replace_all_yaml_files(@commandline_arguments)
+      end
+      _ = @commandline_arguments.select {|entry| File.exist?(entry) }
+    end
+    set_compile_these_programs(_)
+  end
+
+  # ========================================================================= #
+  # === replace_all_yaml_files
+  # ========================================================================= #
+  def replace_all_yaml_files(i = @commandline_arguments)
+    i.map {|entry|
+      if entry.end_with?('.yml')
+        begin
+          require 'rbt/requires/require_the_cookbook_class.rb'
+          entry = return_yaml_file(entry)
+        rescue LoadError; end
+      end
+      entry
+    }
+  end
+
+  # ========================================================================= #
+  # === return_yaml_file
+  # ========================================================================= #
+  def return_yaml_file(i)
+    begin
+      require 'rbt/requires/require_the_cookbook_class.rb'
+      i = RBT::Cookbooks::SanitizeCookbook.new(i).program_path?
+    rescue LoadError; end
+    return i
+  end
+
+  # ========================================================================= #
+  # === get_program_name
+  #
+  # Obtain the program name here.
+  # ========================================================================= #
+  def get_program_name(i = @original_input)
+    if i.include? ' '
+      i = i.split(' ').first
+    end
+    program_name = remove_file_suffix(File.basename(i))
+    return program_name
+  end
+
+  # ========================================================================= #
+  # === set_program_name
+  #
+  # Note that this method can make use of ProgramInformation.
+  # ========================================================================= #
+  def set_program_name(i = nil)
+    i = i.first if i.is_a? Array
+    if i
+      i = get_program_name(i)
+      # ===================================================================== #
+      # Next, we need to obtain the real program name, without the
+      # version. We used the following line for this in the past:
+      #   _ = _.split('-').first if _.include? '-'
+      # However had, as of 08.08.2015, we will instead use ProgramInformation.
+      # ===================================================================== #
+      i = ProgramInformation.return_name(i) # .first() will return the right name.
+    end
+    @program_name = i
+  end
+
+  # ========================================================================= #
+  # === use_the_home_directory_as_prefix
+  # ========================================================================= #
+  def use_the_home_directory_as_prefix
+    set_prefix(:home_directory)
+  end
+
+  # ========================================================================= #
+  # === run_build_sh
+  #
+  # Run sh build.sh
+  # ========================================================================= #
+  def run_build_sh
+    _ = "#{@prefix_to_base_directory}sh build.sh"
+    esystem _
+  end
+
+  # ========================================================================= #
+  # === make_distclean
+  # ========================================================================= #
+  def make_distclean
+    esystem 'make distclean'
+  end
+
+  # ========================================================================= #
+  # === run_make_install_command
+  #
+  # This will run "make install".
+  # ========================================================================= #
+  def run_make_install_command
+    esystem 'make install' unless skip_make_install?
+  end
+
+  # ========================================================================= #
+  # === run_configure_make_and_make_install
+  # ========================================================================= #
+  def run_configure_make_and_make_install
+    run_configure_command_or_another_command
+    if continue_past_configure_stage?
+      run_make_command_or_equivalent
+      run_make_install_command
+    end
+  end; alias run_configure_then_make_then_make_install run_configure_make_and_make_install # === run_configure_then_make_then_make_install
+
+  # ========================================================================= #
+  # === run_make_then_make_install
+  # ========================================================================= #
+  def run_make_then_make_install
+    run_make_command_or_equivalent
+    run_make_install_command
+  end
+
+  # ========================================================================= #
+  # === run_python_installation                                  (python tag)
+  #
+  # This method will additionally check for a file called 'configure'. 
+  # ========================================================================= #
+  def run_python_installation
+    if File.exist?("#{@prefix_to_base_directory}configure")
+      simply_run_the_configure_command
+      run_make_then_make_install
+    else
+      _ 'python setup.py configure'
+      _ 'python setup.py build'
+      _ 'python setup.py install'
+    end
+  end
+
+  # ========================================================================= #
+  # === set_prefix
+  #
+  # Set the prefix here. By default the prefix will be /usr, but some
+  # programs, in particular app-dir like programs, will default to
+  # a prefix such as /Programs/Gimp/2.5.2.
+  # ========================================================================= #
+  def set_prefix(
+      i = '/usr'
+    )
+    if i.is_a? Symbol # This may be triggered via :appdir, for instance.
+      case i
+      # ===================================================================== #
+      # === :home_directory
+      # ===================================================================== #
+      when :home_directory,
+           :home_dir,
+           :home
+        i = ENV['HOME'].to_s
+      end
+      i = i.to_s # Work on a String here.
+      i = remove_file_suffix(i)
+      # ===================================================================== #
+      # Simply assemble the prefix now, based on the capitalized variant
+      # of the program name, and then the version.
+      # For this to work, program_name? and program_version? must have
+      # been already defined.
+      # ===================================================================== #
+      # if program_name?.nil? and program_version?.nil?
+      #   # In this case, we must first define these two entries.
+      #   # This has not yet happened - stub.
+      # end
+      case i
+      when /usr(_|-)?prefix/
+        i = '/usr/'
+      # ===================================================================== #
+      # === appdir
+      # ===================================================================== #
+      when 'appdir',
+           'app'
+        # =================================================================== #
+        # We will first check on the original input. If that original
+        # input was an existing file, in form of an archive, then
+        # we may make use of ProgramInformation to change the
+        # version of the program at hand.
+        # =================================================================== #
+        if @original_input and
+           File.exist?(@original_input) and
+           File.file?(@original_input) and
+           is_archive?(@original_input)
+          # ================================================================= #
+          # Ok, in this case, we will make use of ProgramInformation.
+          # ================================================================= #
+          _ = remove_archive_at_the_end(
+            File.basename(
+              @original_input
+            )
+          )
+          set_program_name(_)
+          set_program_version(
+            ProgramInformation.return_version(@original_input)
+          )
+        end
+        # =================================================================== #
+        # Build up the full appdir-prefix next:
+        # =================================================================== #
+        i = "#{::Easycompile.programs_directory?}"\
+            "#{program_name?.to_s.capitalize.delete('-')}"\
+            "/#{program_version?}"
+      end
+    end
+    if i.is_a? String # We can do this because the next step is rds().
+      i = i.dup if i.frozen?
+      i = rds("#{i}/")
+    end
+    @prefix = i
+  end; alias set_prefix_for_this_program set_prefix # === set_prefix_for_this_program
+
+end; end