clir 0.22.0

data/lib/clir/File_extension.rb

@@ -0,0 +1,127 @@
+class File
+
+  # @return +nline+ last lines of +path+ file without loading the
+  # whole content.
+  # 
+  def self.tail(path, nlines)
+    file = open(path, "r")
+    buff = 512
+    line_count = 0
+    # nlines += 1 # to get the last one
+    file.seek(0, IO::SEEK_END)
+
+    offset = file.pos # start at the end
+
+    while nlines > line_count && offset > 0
+      to_read = if (offset - buff) < 0
+                  offset
+                else
+                  buff
+                end
+
+      file.seek(offset - to_read)
+      data = file.read(to_read)
+
+      data.reverse.each_char do |c|
+        if line_count > nlines
+          offset += 1
+          break
+        end
+        offset -= 1
+        if c == "\n"
+          line_count += 1
+        end
+      end
+    end
+
+    file.seek(offset)
+    data = file.read.strip
+  ensure
+    file.close
+  end
+
+  # def self.readlines_backward(path, &block)
+  #   # 
+  #   # Si le fichier n'est pas trop gros, on le lit à l'envers
+  #   # en le chargeant.
+  #   # 
+  #   if File.size(File.new(path)) < ( 1 << 16 ) 
+  #     self.readlines(path).reverse.each do |line|
+  #       yield line
+  #     end
+  #     return
+  #   end
+
+  #   #
+  #   # Pour un gros fichier
+  #   # 
+
+  #   # TODO ON POURRAIT METTRE UN BUFFER MOINS GRAND POUR NE PAS
+  #   # AVOIR DE TROP NOMBREUSES LIGNES EN MÊME TEMPS
+  #   tail_buf_length = 1 << 16 # 65000 et quelques
+  #   file = File.new(path)
+
+  #   file.seek(-tail_buf_length,IO::SEEK_END)
+  #   out   = ""
+  #   count = 0
+  #   while count <= n # TODO C'EST CETTE BOUCLE QU'IL FAUT DÉVELOPPER JUSQU'EN HAUT
+  #     buf     =  file.read( tail_buf_length )
+  #     count   += buf.count("\n")
+  #     out     += buf
+  #     # 2 * since the pointer is a the end , of the previous iteration
+  #     file.seek(2 * -tail_buf_length,IO::SEEK_CUR)
+  #   end
+  #   # TODO : IL FAUT S'Y PRENDRE MIEUX QUE ÇA POUR TOUT LIRE 
+  #   # CAR MAINTENANT +n+ N'EST PLUS LE NOMBRE DE LIGNES DONNÉES EN
+  #   # ARGUMENT DE LA MÉTHODE tail ORIGINALE
+  #   out.split("\n")[-n..-1].each do |line|
+  #     yield line
+  #   end
+  # end
+
+  # @return les +n+ dernières lignes d'un fichier
+  def tail_lines(n)
+    return [] if n < 1
+    if File.size(self) < ( 1 << 16 ) 
+      tail_buf_length = File.size(self)
+      return self.readlines.reverse[0..n-1]
+    else 
+      tail_buf_length = 1 << 16
+    end
+    self.seek(-tail_buf_length,IO::SEEK_END)
+    out   = ""
+    count = 0
+    while count <= n
+      buf     =  self.read( tail_buf_length )
+      count   += buf.count("\n")
+      out     += buf
+      # 2 * since the pointer is a the end , of the previous iteration
+      self.seek(2 * -tail_buf_length,IO::SEEK_CUR)
+    end
+    return out.split("\n")[-n..-1]
+  end
+
+
+
+  # @return [String] the affix's file, i.e. the name without the
+  # extension.
+  # 
+  # @example
+  #   File.affix("myfile.ext") => "myfile"
+  #   File.affix("pth/to/myfile.ext") => "myfile"
+  def self.affix(path)
+    File.basename(path,File.extname(path))
+  end
+
+  ##
+  # Add +code+ to file at +fpath+
+  # 
+  def self.append(fpath, code)
+    begin
+      open(fpath,'a') { |f| f.write(code) }
+    rescue ENOENT
+      raise "Folder #{File.dirname(fpath)} doesn't exist. Unable to write #{fpath} file."
+    end
+  end
+
+end

data/lib/clir/Integer.ext.rb

@@ -0,0 +1,43 @@
+class Integer
+
+  # @return TRUE if self is inside +ary+ or has key self
+  # @param ary {Range|Array|Hash}
+  def in?(ary)
+    case ary
+    when Array, Range
+      ary.include?(self)
+    when Hash
+      ary.key?(self)
+    else
+      raise "Integer#in? waits for a Array, an Hash or a Range. Given: #{ary.class}."
+    end
+  end
+
+  def semaine
+    self * 7  * 3600 * 24
+  end
+  alias :semaines   :semaine
+  alias :week       :semaine
+  alias :weeks      :semaine
+
+  # For 4.jours / 4.days
+  def jour
+    self * 3600 * 24
+  end
+  alias :jours  :jour
+  alias :day    :jour
+  alias :days   :jour
+
+  def heure
+    self * 3600
+  end
+  alias :heures :heure
+  alias :hour   :heure
+  alias :hours  :heure
+
+  def minute
+    self * 60
+  end
+  alias :minutes :minute
+
+end 

data/lib/clir/Labelizor.rb

@@ -0,0 +1,231 @@
+# encoding: UTF-8
+=begin
+
+  Pour simplifier l'affichage de table à la console.
+
+  @usage
+
+    t = Labelizor.new(<params>)
+
+    t.w "<label>", "<valeur>", <options>
+    ...
+
+    t.display # puts 
+
+  NOTES
+  =====
+    Il y a des options très pratiques comme la propriété :if qui
+    permet de n'écrire la ligne que si la condition est vraie. Ça
+    permet de ne pas avoir d'identation dans la définition de la
+    table.
+    Au lieu de :
+    
+      t.w "Mon label", "Ma valeur"
+      if cest_vrai
+        t.w "Autre label", "Autre valeur"
+      end
+
+    … on utilisera :
+
+      t.w "Mon label", "Ma valeur"
+      t.w "Autre label", "Autre valeur", if:cest_vrai
+
+=end
+
+class Labelizor
+  attr_reader :lines
+  attr_reader :config
+  #
+  # @param  params {Hash|Nil}
+  #   :titre        Le titre à donné au tableau
+  #   :titre_color  Couleur à appliquer (bleu par défaut)
+  #   :separator    le sépateur, en général une espace mais peut être
+  #                 aussi un point
+  #   :delimitor_size   {Integer} La longueur par défaut d'une
+  #                 ligne délimitant les données.
+  #                 On peut définir la longueur d'une ligne à la
+  #                 volée avec le 2e paramètres : t.w(:delimitor, 20)
+  #   :delimitor_char  {String} Caractère utilisé pour le délimiteur
+  #                 Par défaut, un signe '='
+  #   :gutter       {Integer} La largeur de la gouttière (4 par défaut)
+  #   :indentation  {Integer} Nombre d'espace en indentation (2 par
+  #                 defaut)
+  #   :selectable   {Boolean} Si true, l'instance rajoute des numéros
+  #                 à chaque item et permet à la fin d'en choisir
+  #                 un :  value = Labelizor#display
+  # 
+  def initialize(params = nil)
+    defaultize_config(params)
+    reset
+  end
+  def defaultize_config(config)
+    @config = config || {}
+    @config.key?(:gutter)           || @config.merge!(gutter: 4)
+    @config.key?(:indentation)      || @config.merge!(indentation: 2)
+    @config.key?(:separator)        || @config.merge!(separator: ' ')
+    @config.key?(:delimitor_size)   || @config.merge!(delimitor_size: nil)
+    @config.key?(:delimitor_char)   || @config.merge!(delimitor_char: '=')
+    @config.key?(:title_delimitor)  || @config.merge!(title_delimitor: '*')
+    @config.key?(:delimitor_color)  || @config.merge!(delimitor_color: nil)
+    @config.key?(:titre_color)      || @config.merge!(titre_color: :bleu)
+  end
+  #
+  # Pour écrire dans la table
+  # 
+  # @param  label {String}
+  #     Le label. Certaines valeurs spéciales peuvent être utilisées
+  #     comme :delimitor (la longueur sera celle définie en second
+  #     argument ou celle définie par défaut)
+  # @param  value {Any}
+  #     La valeur à afficher à droite du label.
+  # @param  params {Hash}
+  #     Les paramètres à appliquer. C'est là que la méthode prend
+  #     tout son sens.
+  #     Les valeurs définies peuvent être :
+  #       :color    {Symbol} La méthode de couleur (p.e. :vert)
+  #       :if       On n'affiche la ligne que si la valeur est true
+  # 
+  def w(label, value = nil, params = nil)
+    params ||= {}
+    return if params.key?(:if) && !params[:if]
+    # 
+    # Traitement de valeur de +label+ spéciales
+    # 
+    case label
+    when :titre, :title
+      value = "\n#{value}\n#{'-'*value.length}"
+      add_line [:titre, value, params]
+    when :delimitor
+      params.merge!(color: delimitor_color) unless params.key?(:color)
+      add_line([:delimitor, value, params])
+    else
+      add_line([label || '', value || '', params])
+    end
+  end
+  alias :<< :w
+
+  def reset
+    @label_width = nil
+    @lines = [] # pour se servir encore de l'instance
+    @indent = nil
+    @values = [] # pour selectable
+  end
+
+  def add_line(dline)
+    #
+    # Si c'est une table "sélectionnable", il faut ajouter des
+    # index pour choisir la valeur
+    # 
+    if selectable?
+      @values << dline[1].freeze
+      dline[0] = "#{@values.count.to_s.rjust(3)}. #{dline[0]}"
+    end
+    # 
+    # Ajout de la ligne
+    # 
+    @lines << dline
+  end
+  # 
+  # Méthode pour afficher la table
+  def display
+    puts "\n"
+    # 
+    # Écriture du titre (if any)
+    #
+    if @config[:titre]
+      sep = @config[:title_delimitor] * (@config[:titre].length + 2)
+      titre = ("#{indent + sep}\n#{indent + ' ' + @config[:titre]}\n#{indent + sep}")
+      titre = titre.send(@config[:titre_color]) unless config[:titre_color].nil?
+      puts titre
+    end
+    puts "\n"
+    #
+    # Écriture des lignes
+    # 
+    lines.each do |lab, val, params|
+      case lab
+      when :titre then lab, val = [val,'']
+      when :delimitor
+        lab = delimitor_char * delimitor_size(val)
+        val = nil
+      else
+        lab = "#{lab} ".ljust(label_width - 2, config[:separator])
+      end
+      str = lab + ' ' + formate_value(val, params)
+      str = str.send(params[:color]) if params[:color]
+      idt = indent(params)
+      str = idt + str.split("\n").join("\n#{idt}")
+      puts str
+    end
+    puts "\n\n"
+    if selectable?
+      wait_for_item_chosen
+    end
+    reset
+  end
+  alias :flush :display
+
+  def wait_for_item_chosen
+    choix = nil
+    nombre_choix = @values.count
+    puts "\n"
+    while choix.nil?
+      STDOUT.write("\rMémoriser : ")
+      choix = STDIN.getch.to_i
+      if choix > 0 && choix <= nombre_choix
+        break
+      else
+        STDOUT.write "\r                   #{choix} n'est pas compris entre 1 et #{nombre_choix}.".rouge
+        choix = nil
+      end
+    end
+    STDOUT.write("\r"+' '*80)
+    clip @values[choix.to_i - 1]
+    puts "\n\n"    
+  end
+
+  def delimitor_color
+    @delimitor_color ||= config[:delimitor_color]
+  end
+  def delimitor_size(value = nil)
+    return value unless value.nil?
+    @delimitor_size ||= config[:delimitor_size] || (label_width - 1)
+  end
+  def delimitor_char
+    @delimitor_char || config[:delimitor_char]
+  end
+
+  def indent(params = {})
+    @indent ||= ' ' * config[:indentation]
+    case params[:indent]
+    when 0        then ''
+    when nil      then @indent
+    when Integer  then @indent + ' ' * params[:indent]
+    when String   then @indent + params[:indent]
+    end
+  end
+  #
+  # Formater la valeur en fonction des paramètres
+  # 
+  def formate_value(val, params)
+    return '' if val.nil?
+    val = €(val)            if params[:euros]
+    val = formate_date(val) if params[:date]
+    return val.to_s
+  end
+  #
+  # Calcul de la longueur du label
+  # 
+  def label_width
+    @label_width ||= begin
+      maxw = 0; @lines.each do |dline|
+        labl = dline[0].length
+        maxw = labl if labl > maxw
+      end;maxw + config[:gutter]
+    end
+  end
+
+  def selectable?
+    :TRUE == @isselectable ||= true_or_false(@config[:selectable] == true)
+  end
+end

data/lib/clir/Replayer.cls.rb

@@ -0,0 +1,90 @@
+module CLI
+class Replayer
+class << self
+
+  attr_reader :ison
+
+  ##
+  # When the command is not replayed (ie not '_'), CLI initialize
+  # the recordings of inputs
+  # 
+  def init_for_recording
+    @inputs = []
+  end
+
+  ##
+  # @return true if replayer is running
+  # (note : it's running when CLI.main_command is '_')
+  # 
+  def on?
+    :TRUE == ison
+  end
+
+  ##
+  # Start running replayer (with '_' main command)
+  def start
+    @ison = replayable? ? :TRUE : :FALSE
+  end
+
+  def get_input
+    @inputs.pop 
+  end
+
+  ##
+  # Add a {Any} input value (a Hash, a string, an object, etc.)
+  def add_input(input)
+    @inputs << input
+  end
+
+  ##
+  # @return last inputs for the same command.
+  # Use 'get_input' to get the input in order with 'pop'
+  def inputs
+    @inputs ||= begin
+      replayable? || raise('Can’t load inputs values: this command is not replayable.')
+      data[:inputs].reverse
+    end
+  end
+
+  ##
+  # Save inputs at the end of the script
+  def save
+    table_replay = {
+      inputs:       inputs,
+      data:         CLI::get_command_line_data
+    }
+    File.write(last_command_file, Marshal.dump(table_replay))
+  end
+
+  def data
+    @data ||= begin
+      load.tap do |table|
+        CLI.set_command_line_data(table[:data])
+      end
+    end
+  end
+
+  def load
+    Marshal.load(last_command_file)
+  end
+
+  ##
+  # @return TRUE if there is a replayable command
+  # Note: it's a replayable command if it exists a
+  # '.<app>_lastcommand' file in current folder
+  def replayable?
+    File.exist?(last_command_file(CLI.command_name))
+  end
+
+  def last_command_file(command_name = nil)
+    command_name ||= CLI.command_name
+    File.join(commands_folder_path, command_name)
+  end
+
+  def commands_folder_path
+    @commands_folder_path ||= mkdir(File.join(ENV["HOME"] || ENV["USERPROFILE"],'.chir_last_commands'))
+  end
+
+end #/<< self class Replayer
+end #/class Replayer
+end #/module CLI