universal_pipe_handler 0.0.10

data/lib/universal_pipe_handler/cmdlets/starts_with.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/starts_with.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_starts_with
+  #
+  # This method will iterate over our array and return a match.
+  # ========================================================================= # 
+  def self.cmdlet_starts_with(
+      search_term = result?
+    )
+    result = []
+
+    result?.each { |line|
+      result << line.chomp if line.start_with?(search_term) #line[0, search_term.size] == search_term
+    } if result?.is_a? Array
+    set_result(result)
+  end; self.instance_eval { alias starts_with cmdlet_starts_with } # === UniversalPipeHandler.starts_with
+
+end

data/lib/universal_pipe_handler/cmdlets/stat_file.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/stat_file.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  begin
+    require 'stat_file'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_stat_file                      (stat tag)
+  #
+  # Since as of August 2011 we get extended stat info, by tapping into
+  # class StatFile.
+  #
+  # To try this, you can do:
+  #
+  #   assign :main_video | stat file
+  #
+  # ========================================================================= #
+  def self.cmdlet_stat_file(i = result?)
+    if i.is_a? Array
+      i.each {|entry|
+        action_stat_file(entry)
+      }
+    else
+      if i.nil?
+        e 'Please provide a valid argument.'
+        exit
+      end
+      i = i.to_s
+      if File.exist? i.to_s
+        stat_file = StatFile.new(i, :dont_be_verbose)
+        stat_file.stat_file(i)
+        @result = '' if @result.is_a? Array # Reset the result here.
+        @result << stat_file.result
+        file_size    = File.size(i).to_s
+        file_end     = File.extname(i).gsub(/\./,'')
+        n_lines      = 0    # safeguard.
+        n_characters = 0 # safeguard.
+        case file_end
+        when *ARRAY_MULTIMEDIA_FILES # Pass through here - we can't read these file types..
+        else
+          readlines = File.readlines(i)
+          n_lines = readlines.size.to_s
+          n_characters = readlines.join.split(/\s+/).size.to_s
+        end
+        file_size = Colours.slateblue(file_size.to_s)
+        @result << N+'  The file `'+sfile(i.to_s)+'`'+N+'  has '+n_lines.to_s+
+                   ' lines, '+sfancy(n_characters.to_s)+' characters and a '+
+                   'file size of `'+file_size+'`.'
+      else
+        e 'No file could be found at `'+sfancy(i.to_s)+'`.'
+      end
+    end
+  end
+
+end

data/lib/universal_pipe_handler/cmdlets/to_ascii.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/to_ascii.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_to_ascii
+  #
+  # Convert image files to ascii format at once, using the program called
+  # jp2a. Obviously for this to work, jp2a must have been installed.
+  #
+  # Since as of May 2015, we also store in an .ascii file automatically.
+  #
+  # Standalone test, through the pipeshell:
+  #
+  #   random image from :njoy_dir | to ascii
+  #
+  # ========================================================================= #
+  def self.cmdlet_to_ascii
+    cmd = 'jp2a'
+    if result?
+      result?.each { |entry|
+        _ = cmd+' '+entry
+        e _
+        return_value = `#{_}`
+        what = return_value
+        this_file = save_dir?+'ascii_'+
+          File.basename(entry.downcase).tr('.','_')+'.ascii' 
+        write_what_into(what, this_file)
+        set_result(this_file)
+      }
+    end
+  end; self.instance_eval { alias to_ascii cmdlet_to_ascii } # === UniversalPipeHandler.to_ascii
+
+end

data/lib/universal_pipe_handler/cmdlets/to_camel_case.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/to_camel_case.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  require 'fileutils'
+  require 'universal_pipe_handler/toplevel_methods/e.rb'
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_to_camel_case
+  # ========================================================================= #
+  def self.cmdlet_to_camel_case(
+      i = result?
+    )
+    array = []
+    if i.is_a? Array
+      i.each {|inner_entry|
+        base_dir = File.dirname(inner_entry)+'/'
+        if File.exist? inner_entry
+          new_name = File.basename(inner_entry).
+                     split('_').map { |most_inner_entry| most_inner_entry.capitalize }.join
+          new_name = "#{base_dir}#{new_name}"
+          unless File.exist? new_name
+            FileUtils.mv(inner_entry, new_name)
+          end
+          array << new_name
+        end
+      }
+    end
+    set_result(array)
+    return result?
+  end; self.instance_eval { alias to_camel_case cmdlet_to_camel_case } # === UniversalPipeHandler.to_camel_case
+       self.instance_eval { alias camel_case    cmdlet_to_camel_case } # === UniversalPipeHandler.camel_case
+
+end

data/lib/universal_pipe_handler/cmdlets/to_dna.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/to_dna.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_to_dna
+  #
+  # This method will convert the given input to a valid DNA string.
+  # We make use of the project called Bioroebe here.
+  #
+  # To test this, start the pipeshell and do:
+  #
+  #   assign ACCACACCAUUUCCCAUGGGUGUGUGG | to dna
+  #
+  # ========================================================================= #
+  def self.cmdlet_to_dna(i = result?)
+    unless Object.const_defined? :Bioroebe
+      require 'bioroebe'
+    end
+    if Object.const_defined? :Bioroebe
+      _ = Bioroebe.to_dna(i)
+      set_result(_)
+    end
+    return result?
+  end; self.instance_eval { alias to_dna cmdlet_to_dna } # === UniversalPipeHandler.to_dna
+
+end

data/lib/universal_pipe_handler/cmdlets/to_movie.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_to_movie
+  #
+  # This currently is somewhat dysfunct. More accurately, it was never
+  # written.
+  # ========================================================================= #
+  def self.cmdlet_to_movie
+  end
+
+end

data/lib/universal_pipe_handler/cmdlets/to_pdf.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/to_pdf.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === ALSO_OPEN_IN_PDF_VIEWER
+  #
+  # If true we also open it at once.
+  # ========================================================================= #
+  ALSO_OPEN_IN_PDF_VIEWER = true
+
+  # ========================================================================= #
+  # === USE_THIS_PDF_VIEWER
+  # ========================================================================= #
+  USE_THIS_PDF_VIEWER = 'evince' # okular
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_to_pdf
+  #
+  # This currently is somewhat dysfunctional.
+  #
+  # To test this, we could try:
+  #
+  #   cat :main_file | to pdf
+  #
+  # ========================================================================= #
+  def self.cmdlet_to_pdf(
+      text_to_write = result?
+    )
+    font_size  = 18
+    alignment = :left
+    store_here = 'autogenerated_pdf.pdf'
+    text_to_write = text_to_write.join if text_to_write.is_a? Array
+    if text_to_write.count('"') == 2
+      text_to_write.delete!('"')
+    end
+    if text_to_write.include? '\\n'
+      text_to_write.gsub!(/\\n/, "\n")
+    end
+    Prawn::Document.generate(store_here) {
+      font 'Times-Roman'
+      text text_to_write,
+           align: alignment,
+           size:  font_size
+    }
+    set_result(store_here)
+    if ALSO_OPEN_IN_PDF_VIEWER # Open the .pdf next.
+      esystem USE_THIS_PDF_VIEWER+' '+store_here+' &'
+    end
+    return result?
+  end; self.instance_eval { alias to_pdf        cmdlet_to_pdf } # === UniversalPipeHandler.to_pdf
+       self.instance_eval { alias action_to_pdf cmdlet_to_pdf } # === UniversalPipeHandler.action_to_pdf
+
+end

data/lib/universal_pipe_handler/cmdlets/translate.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/cmdlet_translate.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_translate
+  #
+  # This method will try to translate english words.
+  #
+  # To try it, one can do:
+  #
+  #   assign purview | translate
+  #
+  # ========================================================================= #
+  def self.cmdlet_translate(i = result?)
+    if i.is_a? Array
+      i.each {|entry| action_translate(entry) }
+    else
+      i = i.to_s.chomp
+      if Object.const_defined? :AskEnglishWord
+        do_not_show_the_result
+        @result = AskEnglishWord.new(i, :delay => 0).result
+      else
+        location = ENV['SCIENCE'].to_s+'/YAML/DICTIONARIES/english.yml'
+        english_data = YAML.load_file(location)
+        @result = english_data[i]
+      end
+      result?
+    end
+  end; self.instance_eval { alias translate cmdlet_translate } # === UniversalPipeHandler.translate
+
+end

data/lib/universal_pipe_handler/cmdlets/upload_to.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/upload_to.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_upload_to
+  #
+  # The first argument shall be where to upload to. We currently use
+  # the FtpParadise to upload to some remote site.
+  #
+  # To try this, do:
+  #
+  #   assign :main_file | ftp_upload
+  #
+  # ========================================================================= #
+  def self.cmdlet_upload_to(
+      this_target = 'shevegen.square7.ch' # The target should not include leading http:
+    )
+    this = result?
+    where_to = this_target # Where to we shall upload something.
+    FtpParadise.upload(this, where_to)
+    return result?
+  end; self.instance_eval { alias upload_to cmdlet_upload_to } # === UniversalPipeHandler.upload_to
+
+end

data/lib/universal_pipe_handler/cmdlets/word_count.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/word_count.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_word_count
+  #
+  # Count the words here.
+  #
+  # Note that this method will instantly output the results - see the
+  # part of the code that is run in the .each_pair section.
+  # ========================================================================= #
+  def self.cmdlet_word_count
+    pad_n = 80
+    hash = Hash.new(0)
+    result?.join.scan(/\w+\??/) { |word| hash[word] += 1 }
+    @result = hash
+    be_really_verbose_here = true # Hack. For now we will always instantly display the result.
+    if be_really_verbose_here
+      _ = result?.sort_by {|key, value| value }.reverse # Sort by size.
+      _.each { |key, value| # This is now an Array.
+        if Object.const_defined? :Konsole
+          e ('The key `'+mediumaquamarine(key)+'` has been found that '+
+            'many times: ').ljust(pad_n)+orange(value.to_s)
+        else # else use normal module Colours support.
+          e ('The key `'+sfancy(key)+'` has been found that '+
+            'many times: ').ljust(pad_n)+simp(value.to_s)
+        end
+      }
+      set_result nil # Not sure why we set to nil in this case.
+    end
+    do_not_show_the_result
+  end; self.instance_eval { alias word_count cmdlet_word_count } # === UniversalPipeHandler.word_count
+
+end

data/lib/universal_pipe_handler/cmdlets/word_wrap.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/word_wrap.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_word_wrap
+  #
+  # By default, this method will limit the words up towards 80 characters
+  # per given line.
+  #
+  # The first argument to it specifies that 80 characters limit.
+  # ========================================================================= #
+  def self.cmdlet_word_wrap(
+      n_chars_limit = 80
+    )
+    set_result @result.map {|_|
+      _.gsub(/(.{1,#{n_chars_limit}})(\s+|$)/, "\\1\n")
+    }.join if result?
+    return result?
+  end
+
+end

data/lib/universal_pipe_handler/cmdlets/write_to.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/to_pdf.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_write_to                      (write tag)
+  #
+  # This method writes into a text file on the local filesystem.
+  #
+  # It will also respect MACROS such as #APPEND# passed to it.
+  # ========================================================================= #
+  def self.cmdlet_write_to(
+      where_to = result?
+    )
+    require 'save_file'
+    what = result?
+    if where_to.include? '#' # Assume a macro like #APPEND# was given. For this to work, file? must return a non-nil value.
+      where_to = where_to.gsub(/#APPEND#/, file?)
+    end
+    if where_to.end_with? '.csv' # Then we assume this is a .csv file.
+      if what.is_a? Array
+        what.map! {|line|
+          line.join(',')+N
+        }
+      end
+    end
+    if what
+      if what.is_a? Array
+        what = what.join.strip
+      end
+      if File.directory? where_to
+        where_to << '/'+File.basename(what)
+        where_to = rds(where_to)
+      end
+      if File.exist? what
+        e 'Copying '+what+' to `'+sfile(where_to)+'`.' if be_verbose?
+        copy(what, where_to)
+      else
+        e 'Writing into `'+sfile(where_to)+'`.' if be_verbose?
+        SaveFile.write_what_into(what, where_to) # Delegate towards the SaveFile module here.
+      end
+      set_result where_to
+      return result?
+    end
+  end; self.instance_eval { alias write_to cmdlet_write_to } # === UniversalPipeHandler.write_to
+
+end

data/lib/universal_pipe_handler/cmdlets/years.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets/years.rb'
+# =========================================================================== #
+module UniversalPipeHandler
+
+  # ========================================================================= #
+  # === UniversalPipeHandler.cmdlet_years
+  #
+  # We will convert the amount of years into seconds.
+  #
+  # Usage example for the pipeshell:
+  #
+  #   20 years | n_days?
+  #
+  # ========================================================================= #
+  def self.cmdlet_years(i = result?)
+    # ======================================================================= #
+    # Calculate how many seconds there are.
+    # ======================================================================= #
+    n_days = (i.to_f * 365.25).floor # The 0.25 is included because of the leap years.
+    i = ONE_DAY_HAS_N_SECONDS * n_days
+    set_result(i)
+    return result?
+  end; self.instance_eval { alias action_years cmdlet_years } # === UniversalPipeHandler.action_years
+       self.instance_eval { alias action_days? cmdlet_years } # === UniversalPipeHandler.action_days?
+
+end

data/lib/universal_pipe_handler/cmdlets_handler/cmdlets_handler.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === UniversalPipeHandler::CmdletsHandler
+#
+# This class will handle individual cmdlets, that are part of a given
+# pipe-instruction.
+#
+# It must be able to determine whether a pipe follows or whether it
+# does not.
+#
+# Usage example:
+#
+#   UniversalPipeHandlerCmdletsHandler.new(ARGV)
+#
+# =========================================================================== #
+# require 'universal_pipe_handler/cmdlets_handler/cmdlets_handler.rb'
+# UniversalPipeHandlerCmdletsHandler.new(ARGV)
+# =========================================================================== #
+require 'universal_pipe_handler/base/base.rb'
+
+module UniversalPipeHandler
+
+class CmdletsHandler < Base # === UniversalPipeHandler::CmdletsHandler
+
+  require 'universal_pipe_handler/cmdlet/cmdlet.rb'
+
+  begin
+    require 'convert_global_env'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      commandline_arguments = nil,
+      run_already           = true
+    )
+    reset
+    set_commandline_arguments(
+      commandline_arguments
+    )
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @namespace
+    # ======================================================================= #
+    @namespace = NAMESPACE
+    # ======================================================================= #
+    # === @start_dir
+    # ======================================================================= #
+    @start_dir = return_pwd
+  end
+
+  # ========================================================================= #
+  # === assign_pipe
+  # ========================================================================= #
+  def assign_pipe(i)
+    if i.is_a? Array
+      i = i.join(' ')
+    end
+    i.strip!
+    # ======================================================================= #
+    # We do not need '  ' occurrences.
+    # ======================================================================= #
+    i.squeeze!(' ') if i.include? '  '
+    # ======================================================================= #
+    # Always assume that '$' refers to an ENV variable. They will be
+    # converted via the class ConvertGlobalEnv.
+    # ======================================================================= #
+    i = ConvertGlobalEnv.convert(i) if i.include? '$'
+    @pipe = i
+  end; alias set_pipe assign_pipe # === set_pipe
+
+  # ========================================================================= #
+  # === split_into_individual_cmdlets
+  #
+  # This method will assign towards @splitted (an Array).
+  # ========================================================================= #
+  def split_into_individual_cmdlets
+    if @pipe.include? PIPE_TOKEN
+      @splitted = @pipe.split(PIPE_TOKEN)
+    else
+      @splitted = [@pipe]
+    end
+    @splitted.flatten!
+    @splitted.compact!
+  end; alias split_on_pipe_token split_into_individual_cmdlets # === split_on_pipe_token
+       alias split_pipe          split_into_individual_cmdlets # === split_pipe
+
+  # ========================================================================= #
+  # === map_the_splitted_components_onto_individual_cmdlets
+  # ========================================================================= #
+  def map_the_splitted_components_onto_individual_cmdlets
+    @splitted.map! {|line|
+      Cmdlet.new(line, :do_not_run_yet)
+    }
+  end
+
+  # ========================================================================= #
+  # === do_evaluate_the_pipe
+  # ========================================================================= #
+  def do_evaluate_the_pipe
+    @splitted.each {|cmdlet|
+      cmdlet.strip!
+e
+ewarn 'DEBUGGING GOING ON, REMOVE ME AT A LATER TIME: processing pipe '+sfile(cmdlet)+' next.'
+e
+      cmdlet.set_start_dir(@start_dir)
+      cmdlet.do_evaluate
+ewarn 'DEBUGGING GOING ON, REMOVE ME AT A LATER TIME: the result is now:'
+pp result?
+pp result?.class
+e
+    }
+  end; alias process_pipe do_evaluate_the_pipe # === process_pipe
+
+  # ========================================================================= #
+  # === result?
+  # ========================================================================= #
+  def result?
+    UniversalPipeHandler.result?
+  end
+
+  # ========================================================================= #
+  # === ensure_that_the_log_directory_exists
+  # ========================================================================= #
+  def ensure_that_the_log_directory_exists
+    _ = '/home/Temp/universal_pipe_handler/'
+    mkdir(_) unless File.directory? _
+    cd(_)
+pp Dir.pwd
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    _ = commandline_arguments?.join(' ').strip
+    ensure_that_the_log_directory_exists
+    assign_pipe(_)
+    split_into_individual_cmdlets
+    map_the_splitted_components_onto_individual_cmdlets
+    do_evaluate_the_pipe
+  end
+
+  # ========================================================================= #
+  # === UniversalPipeHandler::CmdletsHandler[]
+  # ========================================================================= #
+  def self.[](i = '')
+    new(i)
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude' # Test the project next.
+  e 'Testing various aspects next allowed_actions.rb'
+  e
+  e 'The allowed actions/cmdlets are:'
+  e
+  p UniversalPipeHandler.allowed_actions?
+  e
+  pipe_handler = UniversalPipeHandler::CmdletsHandler.new(ARGV)
+  e
+  e 'Testing the pipe_aliases next (but we will show only 5 entries):'
+  pp pipe_handler.pipe_aliases?.values_at(*PipeHandler.pipe_aliases?.keys.sample(5))
+  e
+  p pipe_handler.pipe_aliases?
+  e
+  e 'Testing the allowed_actions:'
+  e
+  p pipe_handler.allowed_actions?
+  e
+  e 'Testing the predefined_methods next:'
+  p pipe_handler.predefined_methods?
+  p pipe_handler.predefined_methods?.has_key? 'enlarge'
+  e
+  p pipe_handler.pipe_aliases?
+  pipe_handler = UniversalPipeHandler::CmdletsHandler.new('ls | nl')
+end # cmdlets_handler