class Extracter::Extracter

Constants

NAMESPACE
#

NAMESPACE

#
SHOW_ONLY_THE_SHORT_NAME_OF_THE_ARCHIVE
#

SHOW_ONLY_THE_SHORT_NAME_OF_THE_ARCHIVE

If this constant is set to true then we will only show the shortened name of the archive in question by default.

#

Public Class Methods

[]( i = ARGV, extract_where_to = Extracter.return_pwd ) click to toggle source
#

Extracter::Extracter[]

#
# File lib/extracter/class/extracter.rb, line 1175
def self.[](
    i = ARGV,
    extract_where_to = Extracter.return_pwd
  )
  new(i, extract_where_to)
end
extract_this( i = ARGV, to = {}, &block ) click to toggle source
#

Extracter::Extracter.extract_this

This method provides a convenient API to extract something to a specified directory, as a class method. It defaults to the current working directory, as that is by far the most convenient way to extract a source tarball/archive.

#
# File lib/extracter/class/extracter.rb, line 1162
def self.extract_this(
    i  = ARGV,
    to = {}, # This may also be a String rather than a Hash.
    &block
  )
  ::Extracter::Extracter.new(ARGV, to, &block)
end
new( commandline_arguments = ARGV, extract_to = nil, run_already = true ) { || ... } click to toggle source
#

initialize

The first argument to this method should be the archive that the user wants to extract. This must be a (locally) existing archive, such as foobar.tar.xz or something similar.

The second argument to this method, called ‘extract_to`, specifies the target location, where this class will extract the archive into, if available. Some keywords and shortcuts exist for this option - for instance, TEMP means $MY_TEMP, which can be set by the user.

Specific usage example in pure Ruby:

x = Extracter.what_to('pry-0.9.9.4.gem', '/home/Temp')
#
# File lib/extracter/class/extracter.rb, line 74
def initialize(
    commandline_arguments = ARGV,
    extract_to            = nil,
    run_already           = true,
    &block
  )
  register_sigint
  reset
  @internal_hash[:run_already] = run_already
  set_commandline_arguments(
    commandline_arguments
  )
  if debug? # Some debug-information in this case.
    opne "The first argument what is:       `#{commandline_arguments}`"
    opne "The second argument where_to is:  `#{extract_to}`"
  end
  case run_already
  # ======================================================================= #
  # === :dont_run_yet
  # ======================================================================= #
  when :dont_run_yet,
       :do_not_run_yet,
       :default
    @internal_hash[:run_already] = false
  end
  set_extract_to(extract_to) if extract_to
  # ======================================================================= #
  # === Handle blocks next
  # ======================================================================= #
  if block_given?
    yielded = yield
    case yielded
    # ===================================================================== #
    # === :be_silent
    # ===================================================================== #
    when :be_silent,
         :be_quiet
      do_be_quiet
    # ===================================================================== #
    # === :dont_run_yet
    # ===================================================================== #
    when :dont_run_yet,
         :do_not_run_yet,
         :default
      @internal_hash[:run_already] = false
    # ===================================================================== #
    # === :show_the_full_name_of_the_archive
    # ===================================================================== #
    when :show_the_full_name_of_the_archive
      do_show_the_full_name_of_the_archive
    end
  end
  run if run_already?
end

Public Instance Methods

check_whether_rar_is_available() click to toggle source
#

check_whether_rar_is_available

We try to find out whether unrar is available.

#
# File lib/extracter/class/extracter.rb, line 801
def check_whether_rar_is_available
  is_available = false
  ENV['PATH'].split(':').each {|entry|
    is_available = true if File.exist? "#{entry}/unrar"
  }
  unless is_available
    opne 'unrar appears to be unavailable. Please install it first.'
  end
end
consider_verbosity_for(i) click to toggle source
#

consider_verbosity_for

#
# File lib/extracter/class/extracter.rb, line 437
def consider_verbosity_for(i)
  i = i.dup
  unless be_verbose?
    case i
    # "tar -xvf" must become "tar -xvf" here.
    when COMMAND_TO_EXTRACT_TAR_XZ_FILES
      i.delete!('v')
    end
  end
  return i
end
determine_default_opn_hash( use_this_hash = { namespace: namespace?, use_colours: use_colours?, show_the_name: show_the_name? } )
determine_the_default_opn_hash( use_this_hash = { namespace: namespace?, use_colours: use_colours?, show_the_name: show_the_name? } )
do_extract_to( i, extract_to = extract_to? )
do_extract_what_to( i, extract_to = extract_to? )
do_not_show_name() click to toggle source
#

do_not_show_name

Tells us whether to use opn() or not.

#
# File lib/extracter/class/extracter.rb, line 792
def do_not_show_name
  @internal_hash[:show_the_name] = false
end
do_show_name() click to toggle source
#

do_show_name

If this method is called then the class here will show the name of the file on the commandline, via opn().

#
# File lib/extracter/class/extracter.rb, line 489
def do_show_name
  @internal_hash[:show_the_name] = true
end
do_show_the_full_name_of_the_archive() click to toggle source
#

do_show_the_full_name_of_the_archive

#
# File lib/extracter/class/extracter.rb, line 690
def do_show_the_full_name_of_the_archive
  @internal_hash[:show_the_full_name_of_the_archive] = true
end
esystem( i, try_to_use_colours = try_to_use_colours? ) click to toggle source
#

esystem (system tag, esystem tag)

#
# File lib/extracter/class/extracter.rb, line 540
def esystem(
    i,
    try_to_use_colours = try_to_use_colours?
  )
  i = i.dup if i.frozen?
  # ======================================================================= #
  # Next, consider appending something onto the commandline.
  # ======================================================================= #
  _ = @internal_hash[:append_this_to_the_commandline]
  unless _.empty?
    if i.include? ' '
      splitted = i.split(' ')
      splitted[0] << " #{_}"
      i = splitted.join(' ')
    else
      i << " #{_}"
    end
  end 
  if run_simulation?
    opne 'As we are running in simulation mode, the following command '
    opne 'is the one that we would have been used if we were to not run '
    opne 'in simulation mode:'
    if be_verbose?
      if try_to_use_colours
        e steelblue(i)
      else
        e i
      end
    end
  else
    if be_verbose?
      if try_to_use_colours
        e steelblue(i)
      else
        e i
      end
    end
    # ===================================================================== #
    # Next, run the sys-command.
    # ===================================================================== #
    begin
      system i
      # =================================================================== #
      # We have to rescue here because unrar might not be available and
      # so on.
      # =================================================================== #
    rescue Exception => error
      e 'An error has happened upon attempting to run this system command:'
      e
      e "  #{i}"
      e
      pp error
      e '-----------'
      pp error.class
      e '-----------'
    end
  end
end
Also aliased as: run_this_system_command
extract_input( array = @internal_hash[:array_work_on_these_files], extract_to = extract_to? )
extract_this_archive( i, extract_to = extract_to? ) click to toggle source
#

extract_this_archive (extract tag)

#
# File lib/extracter/class/extracter.rb, line 883
def extract_this_archive(
    i,
    extract_to = extract_to?
  )
  i = File.absolute_path(i)
  # ======================================================================= #
  # First determine whether we can extract the archive or whether we can
  # not:
  # ======================================================================= #
  unless ::Extracter.is_this_a_valid_archive?(i) or i.end_with?('.pdf')
    opne 'The given input, '+i+', is not a valid archive format.'
    return
  end
  # ======================================================================= #
  # Next handle the situation when we are on Windows:
  # ======================================================================= #
  if ::Extracter.are_we_on_windows?
    # ===================================================================== #
    # On windows we will overrule this completely, for now.
    # ===================================================================== #
    Extract.this_on_windows(i)
    return
  end
  if be_verbose?
    if show_only_the_short_name_of_the_archive?
      name_of_the_archive = File.basename(i)
      opne "#{rev}Extracting `#{sfancy(name_of_the_archive)}#{rev}` "\
           "to `#{sdir(extract_to)}#{rev}`."
    else
      opne "#{rev}Extracting `#{sfancy(i)}` to "\
           "`#{sdir(extract_to)}#{rev}`."               
    end
  end
  unless File.writable? extract_to
    copn; ewarn 'You do not have sufficient permissions to'
    copn; ewarn "modify #{sdir(extract_to)}#{swarn('.')}"
    return
  end
  # ===================================================================== #
  # Next, pad it if it includes a ' ' character or (). This was
  # disabled as of July 2022.
  # ===================================================================== #
  # i = pad(i) if i.include?(' ') or i.include?(')')
  case i # case tag; those listed on top are more important.
  # ===================================================================== #
  # === 7z
  # ===================================================================== #
  when '.7z' # 7z does not accept the -C commandline.
    # _ << '7za e' # <- Deprecated this variant as of 05.06.2020.
    esystem "7z x #{i}"
  # ===================================================================== #
  # === .tar.xz
  #
  # Note that .txz is just .tar.xz. Support for .txz was added here
  # in January of 2012.
  # ===================================================================== #
  when /\.tar\.xz$/i,
       /\.txz$/i,
       /\.xz$/i
    esystem consider_verbosity_for(COMMAND_TO_EXTRACT_TAR_XZ_FILES)+
            ' '+i+padded_extract_to?
  # ===================================================================== #
  # === .rpm
  #
  # This entry point will handle .rpm files.
  # ===================================================================== #
  when /\.rpm$/i
    name_of_the_directory = i.delete_suffix('.rpm')
    mkdir(name_of_the_directory)
    set_extract_to(File.absolute_path(name_of_the_directory))
    cd(name_of_the_directory)
    esystem 'rpm2cpio ../'+File.basename(i)+' | cpio -idmv'
    return # Early return.
  # ===================================================================== #
  # === .tar
  #
  # This entry point is for simple .tar files.
  # ===================================================================== #
  when /\.tar$/i
    esystem COMMAND_TO_EXTRACT_TAR_FILES+' '+i+padded_extract_to?
  # ===================================================================== #
  # === zip
  # ===================================================================== #
  when /.zip$/i,
       /.xpi$/i,
       /.docx$/i,
       /.odt$/i, # .docx and .odt format types can be unpacked with zip too.
       /.apkg$/
    # =================================================================== #
    # 'ar -jxf' # unzip #{what} <-- this should work as well.
    # =================================================================== #
    i = pad(i) if i.include?(' ') or i.include?(')')
    esystem "unzip #{i}"
  # ===================================================================== #
  # === tgz
  #
  # This entry point will also handle ".tar.Z" files.
  # ===================================================================== #
  when /\.?tgz$/i,
       /\.?tar.Z$/i,
       /\.?taz$/i
    esystem COMMAND_TO_EXTRACT_TGZ_FILES+' '+i+padded_extract_to?
  # ===================================================================== #
  # === .tar.bz2
  # ===================================================================== #
  when /\.tar\.bz2$/i,
       /\.tbz$/i
    esystem COMMAND_TO_EXTRACT_TAR_BZ2_FILES+' '+i+padded_extract_to?
  # ===================================================================== #
  # === gz
  # ===================================================================== #
  when /\.?gz$/i,
       /\.?apk$/i
    if i.include? '.tar' # Handle .tar.gz here.
      esystem 'tar -zxvf '+i+padded_extract_to?
    else
      esystem "gunzip #{i}"
    end
  # ===================================================================== #
  # === .bz2
  # ===================================================================== #
  when /\.?bz2$/,
       /\.?tbz2$/
    if i.include? '.tar' # Treat it as a .tar file.
      esystem 'tar -vjxf '+i
    else
      esystem "bunzip2 #{i}"
    end
  # ===================================================================== #
  # === rar
  # ===================================================================== #
  when '.rar'
    check_whether_rar_is_available
    esystem "unrar e #{i}"
  # ===================================================================== #
  # === .zst
  #
  # This entry point is for e. g. "pymol-2.3.0-3-x86_64.pkg.tar.zst".
  # ===================================================================== #
  when '.zst',
       '.tar.zst'
    esystem COMMAND_TO_EXTRACT_ZST_ARCHIVES+' '+i
  # ===================================================================== #
  # === deb
  #
  # We could use dpkg-deb too, such as via "dpkg-deb". But using "ar"
  # seems to be the better choice.
  # ===================================================================== #
  when /\.?deb$/i
    esystem COMMAND_TO_EXTRACT_DEB_FILES+' '+i
  # ===================================================================== #
  # === gem
  #
  # The gem commands needs a specific --target=DIRECTORY option.
  # ===================================================================== #
  when /\.?gem$/i
    esystem GEM_UNPACK_COMMAND+' '+i+" --target=#{extract_to}"
  # ===================================================================== #
  # === lzma
  # ===================================================================== #
  when '.lzma'
    esystem "#{COMMAND_TO_EXTRACT_LZMA_FILES} #{i}"
  # ===================================================================== #
  # === bin
  #
  # This entry point allows the user to handle .bin files. In this
  # context, "handling" means to simply run that file as-is.
  # ===================================================================== #
  when /\.?bin$/i 
    esystem("./#{i}")
  # ===================================================================== #
  # === iso
  # ===================================================================== #
  when /\.?iso$/i
    try_to_extract_this_iso_file(i)
    return
  # ===================================================================== #
  # === img
  #
  # Note that .img in this context refers to squafhs .img files.
  # ===================================================================== #
  when /\.?img$/i,
       /\.?squashfs$/i
    try_to_extract_this_img_file(i)
    return # Must return early in this case.
  # ===================================================================== #
  # === lz
  #
  # This entry point requires lzip to be installed.
  # ===================================================================== #
  when /\.?lz$/i,
       /\.?tar\.?lz$/i
    esystem("#{COMMAND_TO_EXTRACT_LZ_FILES} #{i}#{padded_extract_to?}")
  # ===================================================================== #
  # === mp4
  #
  # If it is a .mp4 file, we delegate to MultimediaParadise.extract_audio.
  #
  # Usage example:
  #
  #   rubyextract foobar.mp4
  #
  # ===================================================================== #
  when /\.?mp4$/i
    begin
      require 'multimedia_paradise/audio/extract_audio/extract_audio.rb'
    rescue LoadError; end
    if Object.const_defined? :MultimediaParadise
      MultimediaParadise.extract_audio(i)
    end
  # ===================================================================== #
  # === ps
  # ===================================================================== #
  when/\.?ps$/i
    esystem 'ps2ascii '+i+padded_extract_to?
  # ===================================================================== #
  # === .jar
  # ===================================================================== #
  when /\.?jar$/i
    esystem COMMAND_TO_EXTRACT_JAR_ARCHIVES+' '+i
  # ===================================================================== #
  # === rpm
  # ===================================================================== #
  when '.rpm'
    esystem "#{COMMAND_TO_EXTRACT_BSDTAR_ARCHIVES} #{i}"
  # ===================================================================== #
  # === sxz
  # ===================================================================== #
  when '.sxz'
    esystem "unsquashfs #{i}"
  # ===================================================================== #
  # === pdf
  #
  # For pdf-files we will tap into the pdf_paradise project, if it
  # is available.
  # ===================================================================== #
  when /\.?pdf$/
    begin
      require 'pdf_paradise/utility_scripts/convert_pdf_to_text.rb'
      _ = PdfParadise::ConvertPdfToText.new(i)
      e _.output_file?
    rescue LoadError => error
      e 'No, not there.'
      pp error # Show the error to the user here.
    end
    return # Must return early in this case.
  else # else tag. We did not find the extension type.
    if File.exist? i
      notify_the_user_that_this_extension_has_not_been_registered_yet(i)
    else
      opne "#{rev}No file exists at `#{sfile(i)}#{rev}`."
    end
  end
end
extract_to( i = :temp_dir )
Alias for: set_extract_to
extract_to=( i = :temp_dir )
Alias for: set_extract_to
extract_to?() click to toggle source
#

extract_to?

Note that this method is guaranteed to return a String.

#
# File lib/extracter/class/extracter.rb, line 830
def extract_to?
  @internal_hash[:extract_to].to_s
end
extract_to_this_location?()
Alias for: extract_to?
extracted_path?()
Alias for: extract_to?
extracted_to?()
Alias for: extract_to?
fail_message_not_registered(i) click to toggle source
#

fail_message_not_registered

Output a fail message when the archive format is not registered.

#
# File lib/extracter/class/extracter.rb, line 507
def fail_message_not_registered(i)
  opne "#{rev}Can not extract `#{sfancy(i)}#{rev}` - it is "\
       "not registered."
end
menu( i = commandline_arguments? ) click to toggle source
#

menu (menu tag)

#
notify_the_user_that_no_input_was_given_but_this_file_was_found( this_file ) click to toggle source
#

notify_the_user_that_no_input_was_given_but_this_file_was_found

#
# File lib/extracter/class/extracter.rb, line 191
def notify_the_user_that_no_input_was_given_but_this_file_was_found(
    this_file
  )
  opne "No input was given to #{sfancy(NAMESPACE)} but a "\
       ".zip file was"
  opne 'found in this directory ('+sdir(return_pwd)+rev+
       '): '+sfancy(this_file)
  opne 'We will use this zip file.'
end
notify_the_user_that_this_extension_has_not_been_registered_yet(i) click to toggle source
#

notify_the_user_that_this_extension_has_not_been_registered_yet

#
# File lib/extracter/class/extracter.rb, line 496
def notify_the_user_that_this_extension_has_not_been_registered_yet(i)
  opne "The archive at `#{i}` is #{tomato('not')}"
  opne "registered as a permissive extension."
  fail_message_not_registered(i)
end
pad( i, with_this_character = "'" ) click to toggle source
#

pad (pad tag)

This method must be able to deal with ‘ ’ as well as with ‘()’.

The second character is the character that will be used for the padding.

#
# File lib/extracter/class/extracter.rb, line 285
def pad(
    i,
    with_this_character = "'"
  )
  if i.include?('(') or i.include?(')')
    i.tr!('(','\(')
    i.tr!(')','\)') if i.include? ')'
    i = pad(i, '"')
  else
    return with_this_character+
           i+
           with_this_character
  end
end
pad_opn_with_n_tokens(n_tokens = nil) click to toggle source
#

pad_opn_with_n_tokens

#
# File lib/extracter/class/extracter.rb, line 840
def pad_opn_with_n_tokens(n_tokens = nil)
  if n_tokens
    determine_default_opn_hash # Update this, just in case.
    main_hash?.update(padding: n_tokens)
  end
end
Also aliased as: set_pad_opn_with_n_tokens
padded_extract_to?() click to toggle source
#

padded_extract_to?

#
# File lib/extracter/class/extracter.rb, line 774
def padded_extract_to?
  " -C #{extract_to?} "
end
prefix_namespace_with(i) click to toggle source
#

prefix_namespace_with

#
# File lib/extracter/class/extracter.rb, line 729
def prefix_namespace_with(i)
  @internal_hash[:namespace] = "#{i}#{@internal_hash[:namespace].dup}"
  update_the_main_hash # Also update the opn-hash here.
end
prepare_the_hash_for_opn( use_this_hash = { namespace: namespace?, use_colours: use_colours?, show_the_name: show_the_name? } ) click to toggle source
#

prepare_the_hash_for_opn

#
# File lib/extracter/class/extracter.rb, line 737
def prepare_the_hash_for_opn(
    use_this_hash = {
      namespace:     namespace?,
      use_colours:   use_colours?,
      show_the_name: show_the_name?
    }
  )
  # ======================================================================= #
  # === :use_this_opn_hash
  # ======================================================================= #
  @internal_hash[:use_this_opn_hash] = use_this_hash
  return @internal_hash[:use_this_opn_hash]
end
report_to_the_user( i, extract_to = extract_to? ) click to toggle source
#

report_to_the_user

This method reports to the user. Usually this is done only via this file here though.

#
# File lib/extracter/class/extracter.rb, line 605
def report_to_the_user(
    i,
    extract_to = extract_to?
  )
  if be_verbose?
    target = extract_to+
             remove_file_extension(File.basename(i))+
             '/'
     opne "#{rev}Finished extracting to `"\
          "#{sdir(target)}#{rev}`." # This is an Array.
  end
end
reset() click to toggle source
#

reset (reset tag)

#
Calls superclass method Extracter::Base#reset
# File lib/extracter/class/extracter.rb, line 132
def reset
  super()
  # ======================================================================= #
  # === :namespace
  #
  # Specify the main namespace to be used. This setting can be modified
  # at "runtime".
  # ======================================================================= #
  @internal_hash[:namespace] = NAMESPACE
  # ======================================================================= #
  # === :array_work_on_these_files
  # ======================================================================= #
  @internal_hash[:array_work_on_these_files] = []
  # ======================================================================= #
  # === :try_to_use_colours
  # ======================================================================= #
  @internal_hash[:try_to_use_colours] = true
  # ======================================================================= #
  # === :append_this_to_the_commandline
  #
  # This variable can always be used to append onto the commandline.
  # That way we can pass additional options to "tar", for instance.
  # ======================================================================= #
  @internal_hash[:append_this_to_the_commandline] = ''.dup
  # ======================================================================= #
  # === :show_the_full_name_of_the_archive
  # ======================================================================= #
  @internal_hash[:show_the_full_name_of_the_archive] = false
  # ======================================================================= #
  # === :show_the_name
  #
  # If this variable is true then the name of the class will be shown
  # on the commandline, via opn().
  # ======================================================================= #
  @internal_hash[:show_the_name] = false
  # ======================================================================= #
  # === :show_only_the_short_name_of_the_archive
  # ======================================================================= #
  @internal_hash[:show_only_the_short_name_of_the_archive] =
    SHOW_ONLY_THE_SHORT_NAME_OF_THE_ARCHIVE
  # ======================================================================= #
  # === :run_simulation
  # ======================================================================= #
  @internal_hash[:run_simulation] = false # ← Whether to run in simulation, or for "real".
  # ======================================================================= #
  # === :extract_to
  # ======================================================================= #
  @internal_hash[:extract_to] = return_pwd
  do_show_name # We will show the name usually.
  prepare_the_hash_for_opn
  # ======================================================================= #
  # === :use_colours
  # ======================================================================= #
  enable_colours
end
run() click to toggle source
#

run (run tag, def tag)

#
# File lib/extracter/class/extracter.rb, line 1143
def run
  menu
  _ = commandline_arguments?
  _.flatten.select {|entry|
    File.file?(entry) or File.directory?(entry)
  }
  set_work_on_these_files(_)
  work_on_the_given_input
end
run_already?() click to toggle source
#

run_already?

#
# File lib/extracter/class/extracter.rb, line 821
def run_already?
  @internal_hash[:run_already]
end
run_simulation=(i) click to toggle source
#

run_simulation=

#
# File lib/extracter/class/extracter.rb, line 424
def run_simulation=(i)
  @internal_hash[:run_simulation] = i
end
run_simulation?() click to toggle source
#

run_simulation?

#
# File lib/extracter/class/extracter.rb, line 431
def run_simulation?
  @internal_hash[:run_simulation]
end
run_this_system_command( i, try_to_use_colours = try_to_use_colours? )
Alias for: esystem
set_colour_for_directories(i) click to toggle source
#

set_colour_for_directories

Set the colour for directories to use.

#
# File lib/extracter/class/extracter.rb, line 783
def set_colour_for_directories(i)
  @internal_hash[:colour_to_use_for_directories] = ::Colours.beautify(i)
end
set_extract_to( i = :temp_dir ) click to toggle source
#

set_extract_to

This is the method that should be used to determine into which directory this class will extract archives into.

Note that this target can be modified from the commandline, if the user wants to do so.

#
# File lib/extracter/class/extracter.rb, line 309
def set_extract_to(
    i = :temp_dir
  )
  if i.is_a?(Hash) and i.empty?
    i = :temp_dir
  end
  if i.is_a? Hash
    # ===================================================================== #
    # === :run_already
    # ===================================================================== #
    if i.has_key? :run_already
      @internal_hash[:run_already] = i.delete(:run_already)
    end
    # ===================================================================== #
    # === :prepend_this_namespace
    # ===================================================================== #
    if i.has_key? :prepend_this_namespace
      prefix_with_this = i.delete(:prepend_this_namespace) # Get rid of it from the Hash as well.
      prefix_namespace_with(prefix_with_this)
    end
    # ===================================================================== #
    # === :use_colours
    # ===================================================================== #
    if i.has_key? :use_colours
      set_use_colours(i.delete(:use_colours))
    end
    # ===================================================================== #
    # === :verbosity
    #
    # Handle how verbose the class shall be.
    # ===================================================================== #
    if i.has_key? :verbosity
      set_be_verbose(i.delete(:verbosity))
    # ===================================================================== #
    # === :be_verbose
    # ===================================================================== #
    elsif i.has_key? :be_verbose
      set_be_verbose(i.delete(:be_verbose))
    end
    # ===================================================================== #
    # === :append_this_to_the_commandline
    # ===================================================================== #
    if i.has_key? :append_this_to_the_commandline
      @internal_hash[:append_this_to_the_commandline] = 
        i.delete(:append_this_to_the_commandline)
    end
    # ===================================================================== #
    # === :use_opn
    # ===================================================================== #
    if i.has_key? :use_opn
      set_use_opn(i.delete(:use_opn))
    end
    # ===================================================================== #
    # === :pad_opn_with_n_tokens
    # ===================================================================== #
    if i.has_key? :pad_opn_with_n_tokens
      set_pad_opn_with_n_tokens(i.delete(:pad_opn_with_n_tokens))
    end
    # ===================================================================== #
    # === :run_simulation
    # ===================================================================== #
    if i.has_key? :run_simulation
      set_run_simulation(i.delete(:run_simulation))
    end
    # ===================================================================== #
    # === :use_colours
    # ===================================================================== #
    if i.has_key? :use_colours
      set_use_colours(i.delete(use_colours))
    end
    # ===================================================================== #
    # === :extract_to
    #
    # This entry point allows the user to specify another extract-to
    # directory. Note that :to is treated the same way as :extract_to.
    #
    # This entry point must come last. The idea is that it will then
    # become the new value for i.
    # ===================================================================== #
    if i.has_key? :extract_to
      i = i.delete(:extract_to)
    # ===================================================================== #
    # === :to
    # ===================================================================== #
    elsif i.has_key? :to
      i = i.delete(:to)
    end
  end
  case i # case tag
  # ======================================================================= #
  # === :default
  # ======================================================================= #
  when :default
    i = return_pwd
  # ======================================================================= #
  # === TEMP
  # ======================================================================= #
  when 'TEMP',
       'MY_TEMP',
       'MYTEMP',
       :temp_dir,
       nil
    i = TEMP_DIR
  end
  i = rds(i)
  i.gsub!(/--to=/,'') if i.include? '--to='
  i = i.to_s.dup # We expect a String most definitely.
  @internal_hash[:extract_to] = i
end
set_extract_to_this_location( i = :temp_dir )
Alias for: set_extract_to
set_input( i = [] )
set_pad_opn_with_n_tokens(n_tokens = nil)
set_run_simulation(i = false) click to toggle source
#

set_run_simulation

This should always default to false, if no other argument has been supplied.

#
# File lib/extracter/class/extracter.rb, line 767
def set_run_simulation(i = false)
  @internal_hash[:run_simulation] = i
end
set_work_on_these_files( i = [] ) click to toggle source
#

set_work_on_these_files

#
# File lib/extracter/class/extracter.rb, line 850
def set_work_on_these_files(
    i = []
  )
  if i.is_a?(Array) and i.empty?
    # ===================================================================== #
    # === Check for .zip files
    #
    # In this case, try to see if the current directory has a .zip
    # file. We will use this in that case.
    # ===================================================================== #
    is_there_a_zip_file = Dir['*.zip']
    unless is_there_a_zip_file.empty?
      use_this_zip_file = is_there_a_zip_file.first
      notify_the_user_that_no_input_was_given_but_this_file_was_found(use_this_zip_file)
      i << use_this_zip_file
    end
    is_there_at_the_least_one_tar_xz_file = Dir['*.tar.xz']
    unless is_there_at_the_least_one_tar_xz_file.empty?
      i << is_there_at_the_least_one_tar_xz_file.first
    end
  end
  i = [i].compact.flatten.map {|entry|
    unless File.exist? entry
      entry = try_to_glob_on(entry)
    end
    entry
  }
  @internal_hash[:array_work_on_these_files] = i
end
Also aliased as: set_input
show_help() click to toggle source
#

show_help (help tag)

This method will show the available - and documented - help options for class Extracter.

To call this method via the commandline try:

extract --help
#
# File lib/extracter/class/extracter.rb, line 705
def show_help
  e
  opne 'How to extract archives, without helper scripts?'
  e
  e '  tar -zxvf foobar.tar.gz                                         # → for .tar.gz'
  e '  tar xvzf foobar.tgz                                             # → for .tgz'
  e '  tar xvfJ foobar.tar.xz                                          # → for .tar.xz'
  e '  tar jxf foobar.tar.bz2                                          # → for .tar.bz2'
  e '  tar -xf foobar.tar.bz2                                          # → for .tbz'
  e '  tar --lzip -xvf zutils-1.5.tar.lz                               # → for .tar.lz'
  e '  unsquashfs foobar-1.2.3.sxz                                     # → for .sxz'
  e '  7z x -so C:\home\x\src\htop\htop-3.0.5.tar.xz | 7z x -si -ttar  # → on windows'
  e
  opne 'Furthermore, there are some commandline options that can'
  opne 'be used for this class (class Extracter).'
  e
  e '  --to=/home/Temp # extract into the '\
    'directory /home/Temp/'
  e
end
show_only_the_short_name_of_the_archive?() click to toggle source
#

show_only_the_short_name_of_the_archive?

#
# File lib/extracter/class/extracter.rb, line 757
def show_only_the_short_name_of_the_archive?
  @internal_hash[:show_only_the_short_name_of_the_archive]
end
show_the_name?() click to toggle source
#

show_the_name?

#
# File lib/extracter/class/extracter.rb, line 814
def show_the_name?
  @internal_hash[:show_the_name]
end
source_package_location()
Alias for: extract_to?
start( i, extract_to = extract_to? )
strip_components( by_n = 1 ) click to toggle source
#

strip_components

The first argument to this method will determine how far “down” tar will strip the components.

#
# File lib/extracter/class/extracter.rb, line 476
def strip_components(
    by_n = 1
  )
  @internal_hash[:append_this_to_the_commandline] <<
    " --strip-components=#{by_n}"
end
try_to_extract_this_img_file(i) click to toggle source
#

try_to_extract_this_img_file

#
# File lib/extracter/class/extracter.rb, line 678
def try_to_extract_this_img_file(i)
  opne 'Handling a squashfs .img file format next:'
  name_without_extension = i.delete_suffix(File.extname(i))
  mkdir(name_without_extension) unless File.directory? name_without_extension
  esystem "mount -o loop -t squashfs #{i} #{name_without_extension}"
  opne 'The content of the extracted (or rather, mounted) archive is:'
  pp Dir["#{name_without_extension}*"]
end
try_to_extract_this_iso_file(i) click to toggle source
#

try_to_extract_this_iso_file

#
# File lib/extracter/class/extracter.rb, line 621
def try_to_extract_this_iso_file(i)
  opne 'Extracting an .iso file is a bit more complicated '\
       'than extracting a .tar.gz tarball'
  opne 'archive. This class will first create a helper '\
       'directory; then mount the .iso there,'
  opne 'then copy the content to the main directory.'
  helper_directory = File.dirname(i)+
                     '/READ_ONLY_DIRECTORY_'+
                     File.basename(
                       i.delete_suffix(File.extname(i))
                     )+
                     '/'
  mkdir(helper_directory) unless File.directory? helper_directory
  esystem 'mount -o loop '+i+' '+helper_directory
  opne 'The helper directory in use is '\
       '`'+sdir(File.absolute_path(helper_directory))+'`.'
  main_directory = File.dirname(i)+
                   '/'+
                   File.basename(
                     i.delete_suffix(File.extname(i))
                   )+
                   '/'
  opne 'Next creating the main directory at `'+sdir(main_directory)+'`.'
  mkdir(main_directory) unless File.directory? main_directory
  opne 'Next copying the content of the helper directory recursively '
  opne 'from `'+sdir(helper_directory)+'`'
  opne 'onto `'+sdir(
    main_directory+File.basename(helper_directory)+'/'
  )+'`.'
  cpr(
    helper_directory,
    main_directory+File.basename(helper_directory)+'/'
  )
  a = main_directory+File.basename(helper_directory)+'/'
  opne 'Relocating the files next from:'
  e
  e "  #{sdir(a)}"
  e
  Dir[a+'*'].each {|entry|
    mv(
      entry,
      main_directory
    )
  }
  # ======================================================================= #
  # And remove the directory:
  # ======================================================================= #
  remove_this_directory(a)
  opne 'The content of the extracted (or rather, mounted) archive is:'
  e
  pp Dir["#{main_directory}*"]
  e
end
try_to_glob_on(i) click to toggle source
#

try_to_glob_on

#
# File lib/extracter/class/extracter.rb, line 452
def try_to_glob_on(i)
  result = Dir["#{i}*"]
  # ======================================================================= #
  # Next, sort this result to put archives on the beginning of the Array.
  # ======================================================================= #
  result = result.partition {|entry| is_archive?(entry) }
  result.flatten!
  unless result.empty?
    # ===================================================================== #
    # Ok, we grab the first entry next.
    # ===================================================================== #
    i = result.first
    opne "#{rev}No result could be found for the given input, "\
         "thus using #{sfancy(i)} #{rev}instead."
  end
  return i
end
update_the_main_hash( use_this_hash = { namespace: namespace?, use_colours: use_colours?, show_the_name: show_the_name? } )
update_the_opn_hash( use_this_hash = { namespace: namespace?, use_colours: use_colours?, show_the_name: show_the_name? } )
work_on_the_given_input( array = @internal_hash[:array_work_on_these_files], extract_to = extract_to? ) click to toggle source
#

work_on_the_given_input

#
# File lib/extracter/class/extracter.rb, line 204
def work_on_the_given_input(
    array      = @internal_hash[:array_work_on_these_files],
    extract_to = extract_to?
  )
  pp array if debug?
  case extract_to
  # ======================================================================= #
  # === :default
  # ======================================================================= #
  when :default,
       nil
    extract_to = extract_to?
  end
  # ======================================================================= #
  # If the user supplied a directory then a random entry will be grabbed
  # from said directory.
  # ======================================================================= #
  if array.is_a?(String) and File.directory?(array)
    array = Dir[rds("#{array}/")+'*'].sample
  end
  if array.empty?
    opne 'No archive (input) was provided. Please provide the file'
    opne 'that is to be extracted.'
  else
    array.each {|this_file|
      # =================================================================== #
      # The next if-clause is for my home setup, for pseudo Symbols:
      # =================================================================== #
      if this_file.is_a?(String) and this_file.start_with?(':')
        _ = '/home/x/src/'
        if File.directory?(_+this_file.delete(':'))
          target = _+this_file.delete(':')+'/*'
          possible_files = Dir[target].select {|entry|
            File.file?(entry)
          }
          unless possible_files.empty?
            this_file = possible_files.first
          end
        end
      end
      # =================================================================== #
      # Create the directory if it does not yet exist.
      # =================================================================== #
      create_directory(extract_to) unless File.directory?(extract_to)
      # =================================================================== #
      # Handle the case when the user did input a number.
      # =================================================================== #
      begin
        if this_file =~ /^\d$/
          this_file = Dir['*'][( this_file.to_i - 1 )] unless File.exist?(this_file)
        end
      rescue ArgumentError => error
        opne 'An error occurred for '+sfancy(this_file)+':'
        pp error
      end
      # =================================================================== #
      # If the user supplied a directory then a random entry will be
      # grabbed from said directory.
      #
      # Usage example:
      #
      #  rubyextracter /home/x/src/htop/
      #
      # =================================================================== #
      if File.directory? this_file
        this_file = Dir[rds("#{this_file}/")+'*'].sample
      end
      extract_this_archive(this_file, extract_to)
      report_to_the_user(this_file, extract_to)
    }
  end
end
Also aliased as: extract_input