universal_pipe_handler 0.0.10

data/lib/universal_pipe_handler/cmdlet/cmdlet.rb

@@ -0,0 +1,287 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === UniversalPipeHandler::Cmdlet
+#
+# This class will evaluate a single cmdlet instruction.
+#
+# What is a cmdlet?
+#
+# A cmdlet, also known as a commandlet, is an individual pipe-element
+# such as the two commandlets ls and nl in the following pipe
+# instruction:
+#
+#   'ls | nl'
+#
+# Usage example for class Cmdlet:
+#
+#   UniversalPipeHandler::Cmdlet.new(ARGV)
+#
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlet/cmdlet.rb'
+# =========================================================================== #
+require 'universal_pipe_handler/base/base.rb'
+
+module UniversalPipeHandler
+
+class Cmdlet < Base # === UniversalPipeHandler::Cmdlet
+
+  require 'universal_pipe_handler/toplevel_methods/misc.rb'
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      commandline_arguments = ARGV,
+      run_already           = true
+    )
+    reset
+    # ======================================================================= #
+    # Must ensure that it is an Array at all times:
+    # ======================================================================= #
+    commandline_arguments = [commandline_arguments].flatten.compact
+    set_commandline_arguments(
+      commandline_arguments
+    )
+    set_content(commandline_arguments.first)
+    case run_already
+    # ======================================================================= #
+    # === :do_not_run_yet
+    # ======================================================================= #
+    when :do_not_run_yet
+      run_already = false
+    end
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @namespace
+    # ======================================================================= #
+    @namespace = NAMESPACE
+    # ======================================================================= #
+    # === @internal_hash
+    # ======================================================================= #
+    @internal_hash = {}
+    # ======================================================================= #
+    # === :valid_action
+    #
+    # This will be true if the action is valid.
+    # ======================================================================= #
+    @internal_hash[:valid_action] = false
+    # ======================================================================= #
+    # === :content
+    # ======================================================================= #
+    @internal_hash[:content] = nil
+    # ======================================================================= #
+    # === :may_we_exit
+    # ======================================================================= #
+    @internal_hash[:may_we_exit] = true
+    set_start_dir
+    # ======================================================================= #
+    # === :pipe_aliases
+    # ======================================================================= #
+    @internal_hash[:pipe_aliases] = YAML.load_file(
+      UniversalPipeHandler.file_pipe_aliases
+    )
+  end
+
+  # ========================================================================= #
+  # === set_content
+  # ========================================================================= #
+  def set_content(i)
+    i = i.join(' ') if i.is_a? Array
+    @internal_hash[:content] = i.dup
+    # sanitize_content
+  end
+
+  # ========================================================================= #
+  # === strip!
+  # ========================================================================= #
+  def strip!
+    @internal_hash[:content].strip! if @internal_hash[:content]
+  end
+
+  # ========================================================================= #
+  # === content?
+  # ========================================================================= #
+  def content?
+    @internal_hash[:content]
+  end; alias content content? # === content
+       alias string? content? # === string?
+       alias input?  content? # === input?
+
+  # ========================================================================= #
+  # === to_s
+  # ========================================================================= #
+  def to_s
+    @internal_hash[:content].to_s
+  end
+
+  # ========================================================================= #
+  # === pipe_aliases?
+  # ========================================================================= #
+  def pipe_aliases?
+    @internal_hash[:pipe_aliases]
+  end
+
+  # ========================================================================= #
+  # === may_we_exit?
+  # ========================================================================= #
+  def may_we_exit?
+    @internal_hash[:may_we_exit]
+  end
+
+  # ========================================================================= #
+  # === result?
+  # ========================================================================= #
+  def result?
+    ::UniversalPipeHandler.result?
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    try_to_find_an_alias
+    evaluate_the_content
+  end
+
+  # ========================================================================= #
+  # === set_start_dir
+  # ========================================================================= #
+  def set_start_dir(i = return_pwd)
+    @internal_hash[:start_dir] = i
+  end
+
+  # ========================================================================= #
+  # === start_dir?
+  # ========================================================================= #
+  def start_dir?
+    @internal_hash[:start_dir]
+  end
+
+  # ========================================================================= #
+  # === set_result
+  # ========================================================================= #
+  def set_result(i)
+    ::UniversalPipeHandler.set_result(i)
+  end
+
+  # ========================================================================= #
+  # === try_to_find_an_alias
+  #
+  # We try to find an alias here.
+  # ========================================================================= #
+  def try_to_find_an_alias
+    input_may_include_an_alias = false
+    first_command = content?.split(' ')
+    if pipe_aliases?.keys.include? first_command
+      # ===================================================================== #
+      # In this case, we don't need to do any replacement, because the
+      # key is already registered.
+      # ===================================================================== #
+    else # else try to find an alias.
+      # ===================================================================== #
+      # Grab the possible results next:
+      # ===================================================================== #
+      result = pipe_aliases?.keys.select { |entry|
+        content?.include? entry
+      }
+      # ===================================================================== #
+      # Next sort it by size so we get the highest entry first:
+      # ===================================================================== #
+      result = result.sort_by(&:length).reverse
+      # ===================================================================== #
+      # Result may now be something like this Array here:
+      #
+      #   ["read file", "read"]
+      #
+      # ===================================================================== #
+      input_may_include_an_alias = true unless result.empty?
+      if input_may_include_an_alias
+        # =================================================================== #
+        # We grab the first entry.
+        # =================================================================== #
+        first = result.first
+        the_alias = pipe_aliases?[first]
+        content?.gsub!(/#{first}/,the_alias)
+      else # else we don't have an alias. Pass through then.
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === evaluate_the_content
+  #
+  # Here we must fetch the toplevel method. 
+  # ========================================================================= #
+  def evaluate_the_content(
+      content = content?
+    )
+    _ = content.dup
+    if _.include? ' '
+      _ = _.split(' ').first
+    end
+    ::UniversalPipeHandler.set_working_directory(start_dir?)
+    _ = return_alias_to_this_cmdlet_or_leave_it_unmodified(_)
+    name_of_the_method = 'cmdlet_'+_.to_s
+    unless UniversalPipeHandler.respond_to?(name_of_the_method.to_sym)
+      # Require all toplevel methods next:
+      require 'universal_pipe_handler/requires/do_require_the_individual_cmdlet_files.rb'
+      UniversalPipeHandler.do_require_the_individual_cmdlet_files
+    end
+    _result = ::UniversalPipeHandler.send(name_of_the_method.to_sym)
+    if _result.is_a? Array
+      set_result(_result)
+    end
+  end; alias do_evaluate evaluate_the_content # === do_evaluate
+
+  # ========================================================================= #
+  # === return_alias_to_this_cmdlet_or_leave_it_unmodified
+  # ========================================================================= #
+  def return_alias_to_this_cmdlet_or_leave_it_unmodified(
+      i, pipe_aliases = pipe_aliases?
+    )
+    if pipe_aliases.has_key? i
+      i = pipe_aliases[i]
+    end
+    return i 
+  end
+
+  # ========================================================================= #
+  # === UniversalPipeHandler::Cmdlet[]
+  # ========================================================================= #
+  def self.[](i = '', optional_argument = nil)
+    new(i).data?
+  end
+  
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude'
+  # ========================================================================= #
+  # === test
+  # ========================================================================= #
+  def test(i = ARGV)
+    e 'In the method test: '+skyblue(
+      UniversalPipeHandler::Cmdlet.new(i) {{ may_we_exit: false }}
+    )
+  end
+  # ========================================================================= #
+  # Note that we will test the various formats not here but in the
+  # file test/testing_sanitize_pipe.rb instead.
+  # ========================================================================= #
+  test 'ls'
+  #test 'cat /home/x/programming/ruby/src/universal_pipe_handler/README.md'
+end # cmdlet

data/lib/universal_pipe_handler/cmdlets/add.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/add.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_add
+  # ========================================================================= #
+  def self.cmdlet_add(i = result?)
+  end; self.instance_eval { alias add cmdlet_add } # === UniversalPipeHandler.add
+
+end

data/lib/universal_pipe_handler/cmdlets/add_audio.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/add_audio.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_add_audio
+  # ========================================================================= #
+  def self.cmdlet_add_audio(i = result?)
+    audio_to_add_audio = i
+    video_file  = result?
+    output_file = 'new_'+video_file 
+    _ = 'ffmpeg -vcodec copy -acodec copy -i '+audio_to_add_audio+' -i '+video_file+' '+output_file
+    run_sys_cmd _
+    set_result(output_file)
+    result?
+  end; self.instance_eval { alias add_audio cmdlet_add_audio } # === UniversalPipeHandler.add_audio
+
+end

data/lib/universal_pipe_handler/cmdlets/all.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/all.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_all
+  #
+  # This action attempts to obtain "all".
+  #  
+  # The very first argument (or the first member of the Array, when i is
+  # an Array) is the pattern which we will use to match against.
+  # ========================================================================= #
+  def self.cmdlet_all(i)
+    _ = action_get_all_files
+    if i.is_a? Array
+      i.pop if i.last == 'files' # Discard "files" entry if it is the last entry.
+    end
+    if i.is_a? Array
+      i = i.first
+    end
+
+    case i
+    when 'files'
+    else
+      match_to_these_file_endings = i 
+      _.reject! {|entry| entry !~ /#{match_to_these_file_endings}$/ }
+    end
+
+    set_result(_)
+    return result?
+  end; self.instance_eval { alias all cmdlet_all } # === UniversalPipeHandler.all
+
+end

data/lib/universal_pipe_handler/cmdlets/any.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/any.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_any                             (any tag)
+  #
+  # Fetch any single file.
+  # ========================================================================= #
+  def self.cmdlet_any(i = 'avi')
+    to_match_against = i
+    _ = action_get_all_files
+    _.reject! {|file| file !~ /#{to_match_against}$/ }
+    if ! _.empty?
+      _ = _.sample # Return the first element.
+    end
+    set_result( _)
+    return result?
+  end; self.instance_eval { alias any cmdlet_any } # === UniversalPipeHandler.any
+
+end

data/lib/universal_pipe_handler/cmdlets/ascii_video.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/ascii_video.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_ascii_video
+  #
+  # Play a video through the aalib. We may however had also default to
+  # libcaca, which I am trying since March 2015.
+  # ========================================================================= #
+  def self.cmdlet_ascii_video(
+      i        = result?,
+      play_how = :libcaca
+    )
+    i = i.first if i.is_a? Array
+    case play_how
+    when :libcaca
+      _ = "mplayer -vo caca #{i}"
+    else # Default to allib then.
+      _ = "mplayer -vo aa #{i}"
+    end
+    esystem(_)
+    set_result
+  end; self.instance_eval { alias ascii_video cmdlet_ascii_video } # === UniversalPipeHandler.ascii_video
+
+end

data/lib/universal_pipe_handler/cmdlets/assign.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/assign.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_assign
+  #
+  # Simply assign something here.
+  # ========================================================================= #
+  def self.cmdlet_assign(i)
+    if i =~ /^\d+$/ # User did input a number only.
+      i = Dir['*'][i.to_i - 1]
+    end unless File.exist? i
+    i = sanitize_url(i) if i.start_with? ':' # assume it is a special keyword.
+    set_file(i)   # We also keep track of the file here.
+    set_result(i) # This is our assignment-method for the @result variable.
+    return result?
+  end; self.instance_eval { alias assign cmdlet_assign } # === UniversalPipeHandler.assign
+
+end

data/lib/universal_pipe_handler/cmdlets/capture_screen.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/capture_screen.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_capture_screen
+  #
+  # Make a screencast with this method. The argument it accepts will break
+  # after n seconds, if given. Otherwise endless.
+  #
+  # A typical example for this would look like:
+  #
+  #   ffmpeg -t 00:00:02 -f x11grab -y -r 12 -s 800x600 -i :0.0+480,200 -vcodec ffv1 -sameq out.avi
+  #
+  # ========================================================================= #
+  def self.cmdlet_capture_screen(
+      optional_how_many_seconds = nil
+    )
+    # output_file = '$MY_TEMP/GRABBED_X11_screencast.mov'
+    output_file = 'captured_screencast-'+return_date+'_'+get_time(':')+'.avi'
+    set_file(output_file) # Now we can use @file.
+    capture_screen = CaptureScreen.new :dont_run_yet
+    capture_screen.overwrite_if_the_file_already_exists
+    capture_screen.framerate 25
+    capture_screen.size '1280x720'
+    # capture_screen.size '1024x800'
+    # capture_screen.size '800x600'
+    capture_screen.vcodec 'ffv1'
+    capture_screen.sameq
+    capture_screen.no_threads
+    capture_screen.store_here = file?
+    if optional_how_many_seconds
+      twenty_four = TwentyfourHoursNotation.new
+      # Must convert the seconds into the long-variant. This is done
+      # By the TwentyfourHoursNotation class.
+      capture_screen.set_duration( twenty_four.simple_format(optional_how_many_seconds) )
+    end
+    capture_screen.run
+    set_result(file?)
+  end; self.instance_eval { alias capture_screen cmdlet_capture_screen } # === UniversalPipeHandler.capture_screen
+
+end

data/lib/universal_pipe_handler/cmdlets/colourize.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/colourize.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_colourize
+  #
+  # This instruction handles colourization; the method can be used
+  # specifically to colourize the given input.
+  #
+  # Before September 2012 we used an internal class for this, however
+  # since as of September 2012 we will prefer to use CodeRay instead,
+  # and optionally fallback to the Colourize class in the event
+  # that CodeRay is unavailable.
+  # ========================================================================= #
+  def self.cmdlet_colourize(i = result?)
+    # If Coderay is available, use that.
+    if Object.const_defined? :CodeRay
+      if i.is_a? Array
+        i = i.join # Won't need to join with newlines here.
+      end
+      _ = CodeRay.scan(i, :ruby).term # This will become a String.
+    else # Else use the project-internal Colourize class, which resides under addons/colours.rb.  
+      _ = Colourize.new(i) # bl $PIPE_HANDLER/addons/colourize.rb
+      _ = _.string
+    end
+    set_result(_) # Better keep it in array form.
+    return result?
+  end; self.instance_eval { alias colourize cmdlet_colourize } # === UniversalPipeHandler.colourize
+
+end

data/lib/universal_pipe_handler/cmdlets/convert_to.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/convert_to.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_convert_to
+  #
+  # This could in principle convert between different formats.
+  # ========================================================================= #
+  def self.cmdlet_convert_to(which_format)
+    case which_format
+    when 'wav'
+      set_result(MultimediaParadise.mp3_to_wav(@target_file))
+    end
+  end; self.instance_eval { alias convert_to cmdlet_convert_to } # === UniversalPipeHandler.convert_to
+
+end

data/lib/universal_pipe_handler/cmdlets/convert_to_images.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/convert_to_images.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_convert_to_images
+  #
+  # This action converts a video file to images.
+  # ========================================================================= #
+  def self.cmdlet_convert_to_images(i = result?)
+  end; self.instance_eval { alias convert_to_images cmdlet_convert_to_images } # === UniversalPipeHandler.convert_to_images
+
+end

data/lib/universal_pipe_handler/cmdlets/convert_to_mp3.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/convert_to_mp3.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_convert_to_mp3
+  #
+  # This will convert into .mp3. If the input file already is a .mp3 file
+  # then we won't have to do a conversion.
+  # ========================================================================= #
+  def self.cmdlet_convert_to_mp3
+    e 'Now converting all found audio files to .wav format.'
+    set_result result?.map { |entry|
+      if entry.include? '.ogg'
+        MultimediaParadise::MultimediaConversions.ogg_to_mp3(entry)
+      elsif entry.include? '.wav'
+        MultimediaParadise::MultimediaConversions.wav_to_mp3(entry)
+      else
+        entry
+      end
+    }
+  end; self.instance_eval { alias convert_to_mp3 cmdlet_convert_to_mp3 } # === UniversalPipeHandler.convert_to_mp3
+
+end

data/lib/universal_pipe_handler/cmdlets/convert_to_wav.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/convert_to_wav.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_convert_to_wav
+  # ========================================================================= #
+  def self.cmdlet_convert_to_wav
+    e 'Now converting all found audio files to .wav format.' if be_verbose?
+    result?.each { |entry| MultimediaParadise.mp3_to_wav(entry) }
+  end; self.instance_eval { alias convert_to_wav cmdlet_convert_to_wav } # === UniversalPipeHandler.convert_to_wav
+
+end

data/lib/universal_pipe_handler/cmdlets/copy_directories.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/copy_directories.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_copy_directories
+  #
+  # This method will simply copy directories. We tap into the method
+  # return_directories() which is defined in shared.rb
+  # ========================================================================= #
+  def self.cmdlet_copy_directories(
+      i = result?
+    )
+    @we_want_to_copy_something = true
+    set_result(return_directories)
+    return result?
+  end; self.instance_eval { alias copy_directories cmdlet_copy_directories } # === UniversalPipeHandler.copy_directories
+
+end

data/lib/universal_pipe_handler/cmdlets/count_character.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/count_character.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_count_character
+  #
+  # Count how many occurences we can find of a specific character.
+  #
+  # That character should be passed to this method.
+  # ========================================================================= #
+  def self.cmdlet_count_character(
+      this_char = :all
+    )
+    _ = result? # Work on a copy of @result here.
+    case this_char
+    when :all
+      _ = _.size
+    else
+      _ = _.join if _.is_a? Array
+      _ = _.scan(/#{this_char}/).size
+    end
+    set_result(_)
+    return result?
+  end; self.instance_eval { alias count_character cmdlet_count_character } # === UniversalPipeHandler.count_character
+
+end