clir 0.22.0

data/lib/clir/Table.rb

@@ -0,0 +1,369 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+=begin
+
+  Class Clir::Table
+  -----------------
+  Construction d'une table en console
+
+  Contrairement à Labelizor qui ne construit des tables qu'à 
+  deux colonnes, avec <<< libelle, valeur >>>, cette classe permet
+  de construire des affichages à plusieurs colonnes.
+
+
+  @usage
+
+    # Pour définir la table
+    tb = CLITable.new(
+      colonnes_totaux: {3 => :euros},
+          # On comptera le total de la 3e colonnes et l'on transformera
+          # toutes les valeurs en euros (avec la méthode :€)
+      header: ["TITRE", "NOMBRE", "REDEVANCE"],
+      gutter: 3,
+      align:  {right: [3]}
+          # La 3e colonne sera alignée à droite (sur le '€' ici)
+    )
+
+    # Pour ajouter une ligne
+    tb << [titre, nombre, redevance]
+
+    # Pour l'afficher
+    tb.display
+
+=end
+module Clir
+class Table
+  attr_reader :params
+
+  attr_reader :column_count
+
+  ##
+  # Instanciation
+  # 
+  # @param  params {Hash}
+  # 
+  #         Définition générale de la table.
+  # 
+  #   :colonnes_totaux  {Hash} Table des indices (1-start) des
+  #                     colonnes dont il faut faire la somme.
+  #                     Avec en clé l'indice réel de la colonne et
+  #                     en valeur soit nil pour un nombre normal, 
+  #                     soit :euros pour une somme financière.
+  #                     Si cette donnée est définie, une nouvelle
+  #                     ligne sera ajoutée au bout du tableau avec
+  #                     la somme de cette colonne.
+  # 
+  #   :header   {Array} Entête, nom de chaque colonne. On peut 
+  #             utiliser les retours de chariot pour faire deux
+  #             lignes.
+  #   :gutter   {Integer} Goutière entre chaque colonne. 4 par défaut
+  #   :indent   {Integer} Indentation initiale, en nombre d'espaces
+  # 
+  # 
+  #   :char_separator  {String} La caractère pour faire les lignes
+  #                     horizontales de séparation. Une étoile par
+  #                     défaut.
+  # 
+  # @option params [Hash] :align  Définition de l'alignement dans les colonnes.
+  #                               En clé l'indice 1-start de la colonne, en
+  #                               valeur une valeur parmi :right, :left et :center
+  # @option params [Array|Hash|Integer] :max_widths 
+  #                 Max width for columns. If it's a integer, it's 
+  #                 the max width for each column.
+  #                 If it's an Array, it's the definition of each
+  #                 column in order. For example, [4, 5, 6] means
+  #                 4 signs for the first column, 5 for the second
+  #                 one and 6 for the third column. Columns without
+  #                 max widths must have nil value.
+  #                 If it's a Hash, the key is the column index 
+  #                 (1-start) and the value is the max lenght in
+  #                 signs.
+  #                 
+  def initialize(params = nil)
+    @params = params || {}
+    @lines = []
+    add_header_lines
+  end
+
+  def display
+    #
+    # On définit l'alignement de chaque colonne
+    # 
+    define_colonnes_align
+
+    #
+    # On fait les totaux des colonnes désignées
+    # 
+    formate_cells_totaux unless colonnes_totaux.nil?
+
+    # 
+    # On mesure les largeurs des colonnes
+    # 
+    calc_column_widths
+
+    #
+    # On ajoute une séparation à la toute fin
+    # 
+    add(separation)
+
+    # 
+    # Séparation toujours
+    # 
+    puts "\n\n"
+
+    #
+    # Écriture du titre (if any)
+    # 
+    traite_titre if @params[:title]
+
+    # 
+    # Boucle sur chaque ligne d'entête
+    # 
+    @header_lines.each do |cols|
+      traite_colonnes( cols, is_header = true )
+    end
+    # 
+    # Boucle sur chaque ligne de données
+    # 
+    @lines.each do |cols|
+      traite_colonnes( cols, is_header = false)
+    end
+    puts "\n\n"
+  end
+
+
+  def traite_titre
+    puts "#{indent}#{char_separator} #{params[:title].upcase} #{char_separator}\n#{indent}#{separation}"
+  end
+
+  def traite_colonnes(cols, for_header = false)
+    line = 
+      case cols
+      when Array
+        '  ' + cols.collect.with_index do |col, idx|
+          alignment = for_header ? :ljust : colonne_aligns[idx]
+          col = col.to_s
+          if col.length > @column_widths[idx]
+            col[0...(@column_widths[idx] - 1)] + '…'
+          else
+            col.to_s.send(alignment, @column_widths[idx])
+          end
+        end.join(gutter) + '  '
+      when :separation  then separation
+      when String       then cols
+      end
+    #
+    # Écriture de la ligne
+    # 
+    puts indent + line    
+  end
+
+  def add(ary)
+    @lines << ary
+  end
+  alias :<< :add
+
+  # Building header
+  # 
+  # On part toujours du principe qu'il y a deux lignes, et si
+  # l'une est vide, on n'en met qu'une seule.
+  def add_header_lines
+    @header_lines = []
+    return if params[:header].nil?
+    two_lines = false
+    line1 = []
+    line2 = []
+    params[:header].each do |lib|
+      lib1, lib2 = 
+        if lib.match?("\n")
+          two_lines = true
+          lib.split("\n")
+        else
+          ['', lib]
+        end
+      line1 << lib1
+      line2 << lib2
+    end
+    @column_count = line2.count
+    @header_lines << line1 if two_lines
+    @header_lines << line2
+    @header_lines << :separation
+  end
+
+  def table_width
+    @table_width ||= @column_widths.sum + (gutter_width * (column_count - 1))
+  end
+
+  def separation
+    @separation ||= char_separator * (table_width + 4)
+  end
+
+  def char_separator
+    @char_separator ||= params[:char_separator] || '*'
+  end
+
+  def gutter
+    @gutter ||= ' ' * gutter_width
+  end
+
+  def gutter_width
+    @gutter_width ||= params[:gutter] || 4
+  end
+
+  def indent
+    @indent ||= ' ' * (params[:indent] || 2)
+  end
+
+  def align
+    @align ||= params[:align]
+  end
+
+  def max_widths
+    @max_widths ||= params[:max_widths]
+  end
+
+  def colonnes_totaux
+    @colonnes_totaux ||= params[:colonnes_totaux]
+  end
+
+  # Alignement des colonnes
+  def colonne_aligns
+    @colonne_aligns
+  end
+
+
+  private
+
+    def define_colonnes_align
+      # 
+      # Par défaut tous les colonnes sont alignés à gauche
+      # 
+      @colonne_aligns = Array.new(column_count, :ljust)
+      return if align.nil?
+      align.each do |indice_colonne, alignment|
+
+        @colonne_aligns[indice_colonne - 1] = case alignment
+        when :right   then :rjust
+        when :left    then :ljust
+        when :center  then :cjust
+        end
+      end
+    end
+
+    #
+    # Note : requis avant de compter la largeur des colonnes, car
+    # les totaux peuvent changer la donne
+    # 
+    def formate_cells_totaux
+      #
+      # On fait la ligne de total
+      # 
+      make_totaux_line
+      # 
+      # On formate toutes les valeurs. Car elles ont été données
+      # en nombre (x) et non pas en euros (€(x)) pour pouvoir calcu-
+      # ler les totaux.
+      # 
+      @lines.each do |cols|
+        next unless cols.is_a?(Array)
+        colonnes_totaux.each do |idx, type|
+          real_idx = idx - 1
+          case type
+          when NilClass
+            # Rien à faire
+          when Symbol
+            cols[real_idx] = send(type, cols[real_idx])
+          when Proc
+            cols[real_idx] = type.call(cols[real_idx])
+          else 
+            cols[real_idx] = "#{cols[real_idx]} #{type}"
+          end
+        end
+      end
+
+    end
+
+    # Calc of the column width. Either defined by widthest value or
+    # header, either by max_widths option parameter.
+    # 
+    def calc_column_widths
+      #
+      # Pour collecter les largeurs de colonnes
+      # 
+      @column_widths = Array.new(column_count, 0)
+      # 
+      # Pour savoir si les largeurs maximales sont définies et
+      # prendre les valeurs.
+      # @rappel : les largeurs peuvent être définies par un integer
+      # un Hash ou un Array.
+      # 
+      maxes = case max_widths
+              when Integer 
+                Array.new(column_count, max_widths)
+              when Hash
+                cw = Array.new(column_count, nil)
+                max_widths.each do |idx_col, val|
+                  cw[idx_col - 1] = val
+                end
+                cw
+              when Array
+                max_widths # must be all defined
+              else
+                Array.new(column_count, nil)
+              end
+      # 
+      # Les largeurs de colonne seraient-elles déjà toutes définies ?
+      # 
+      zero_found = false
+      maxes.each do |width|
+        zero_found = true and break if width == 0 || width.nil?
+      end
+      unless zero_found
+        @column_widths = maxes
+        return # fini
+      end
+
+      # 
+      # Boucles sur chaque ligne
+      # 
+      (@header_lines + @lines).each do |cols|
+        next unless cols.is_a?(Array)
+        cols.each_with_index do |col, col_idx|
+          if maxes[col_idx]
+            # 
+            # Si la largeur max est définie pour cette colonne
+            # @note
+            #   Pour le moment, sera répété pour chaque ligne…
+            # 
+            @column_widths[col_idx] = max_widths[col_idx]
+          else
+            # 
+            # S'il faut prendre la plus large colonne
+            # 
+            len = col.to_s.length
+            @column_widths[col_idx] = len if len > @column_widths[col_idx]
+          end
+        end
+      end   
+    end
+
+    def make_totaux_line
+      totaux_line = Array.new(column_count, '')
+      max_index = colonnes_totaux.keys.min
+      totaux_line[max_index - 2] = 'TOTAUX' unless max_index == 1
+      colonnes_totaux.each do |idx, type|
+        totaux_line[idx - 1] = 0
+      end
+      @lines.each do |cols|
+        colonnes_totaux.each do |idx, type|
+          real_idx = idx - 1
+          # puts "totaux_line[real_idx] = #{totaux_line[real_idx].inspect}"
+          # puts "cols[real_idx] = #{cols[real_idx].inspect}:#{cols[real_idx].class}"
+          totaux_line[real_idx] += cols[real_idx].to_i
+        end
+      end
+      add(:separation)
+      add(totaux_line)
+    end
+end #/class Table
+end #/module Clir

data/lib/clir/console_methods.rb

@@ -0,0 +1,42 @@
+=begin
+
+  Console method
+
+=end
+
+# To wach (empty) the console
+def clear
+  # puts "\n" # pour certaines méthodes
+  STDOUT.write "\n\033c"
+end
+
+# Write +str+ at column +column+ and line +line+
+def write_at(str, line, column)
+  msg = "\e[#{line};#{column}H#{str}"
+  if test?
+    puts msg
+  else
+    STDOUT.write msg
+  end
+end
+
+
+# @return column count of the console
+def console_width
+  `tput cols`.strip.to_i
+end
+
+# @return lines count of the console
+def console_height
+  `tput lines`.strip.to_i
+end
+
+# Use 'less' command to display +texte+
+def less(texte)
+  if debug?
+    puts texte
+  else
+    exec "echo \"#{texte.gsub(/\"/,'\\"')}\" | less -r"
+  end
+end
+

data/lib/clir/helpers_methods.rb

@@ -0,0 +1,68 @@
+# --- Helpers pour console ---
+
+##
+# Pour "labeliser" une table de label <> valeur
+# 
+# @param  ary {Array}
+#         Liste des valeurs, sous la forme
+#           [
+#             ['<label>', '<valeur>'[ :couleur|options]],
+#             ['<label>', '<valeur>'[ :couleur|options]],
+#             etc,
+#           ]
+#         Produira :
+#             label   valeur
+#             label   valeur
+#             etc.
+# 
+#         Le 3e paramètre de chaque item peut définir SOIT la couleur
+#         comme un symbole (par exemple :vert), SOIT une table qui
+#         peut contenir :
+#           color:    La couleur à appliquer
+#           detail:   Un texte à ajouter après la valeur (en gris)
+# 
+# @param  params {Hash|Nil}
+#
+#         Paramètres définissant la table à obtenir avec :
+#
+#         :indent       Identation avant le label (soit un nombre
+#                       d'espace soit l'indentation elle-même)
+#         :gutter       Taille (en espace) de la gouttière entre les
+#                       libellés et les valeurs (4 par défaut)
+#         :label_width  Pour forcer la taille des libellés. Sinon,
+#                       elle sera calculée d'après le plus grand
+#                       label.
+def labelize(ary, params = nil)
+  # 
+  # On peut traiter une simple ligne ou un tableau
+  # 
+  ary = [ary] unless ary.is_a?(Array)
+  # 
+  # Les paramètres à appliquer
+  # 
+  params ||= {}
+  params.key?(:gutter) || params.merge!(gutter: 4)
+  params.key?(:label_width) || begin
+    params.merge!(label_width: ary.max { |a,b| a[0].length <=> b[0].length }[0].length + params[:gutter] )
+  end
+  (params.key?(:indent) && params[:indent]) || params.merge!(indent:'')
+  params[:indent] = ' '*params[:indent] if params[:indent].is_a?(Integer)
+  # 
+  # On construit la ligne ou chaque ligne du tableau
+  # 
+  ary.collect do |lib, val, options|
+    params_line = params.dup
+    case options
+    when Symbol then params_line.merge!(color: options) 
+    when Hash   then params_line.merge!(options)
+    end
+    params[:indent] + label_value_line(lib, val, params_line)
+  end.join("\n")
+end
+def label_value_line(label, value, params = nil)
+  str = "#{label.to_s.ljust(params[:label_width])}#{value}"
+  str = str.send(params[:color]) unless params[:color].nil?
+  str = str + ' ' + params[:detail].gris if params[:detail]
+  return str
+end
+

data/lib/clir/state_methods.rb

@@ -0,0 +1,48 @@
+
+
+def verbose?
+  Clir::State.verbose?
+end
+
+def debug?
+  Clir::State.debug?
+end
+
+def test?
+  Clir::State.test?
+end
+
+def help?
+  Clir::State.help?
+end
+
+module Clir
+class State
+class << self 
+
+  def verbose?
+    :TRUE == @__isverbose ||= true_or_false(CLI.options[:verbose] === true)    
+  end
+
+  def debug?
+    :TRUE == @__debugon ||= true_or_false(CLI.options[:debug] === true)
+  end
+
+  def test?
+    :TRUE == @__teston ||= true_or_false((CLI.options[:test]||CLI.options[:tests]) === true || ENV['CLI_TEST'] == 'true' || ENV['CLI_TESTS'] == 'true' || File.exist?(CLI::MARKER_TESTS_FILE))
+  end
+
+  def help?
+    :TRUE == @__helpon ||= true_or_false(CLI.options[:help] === true || ['help','aide'].include?(CLI.main_command))
+  end
+
+  def reset
+    @__isverbose  = nil
+    @__debugon    = nil
+    @__teston     = nil
+    @__helpon     = nil
+  end
+
+end #/<< self
+end #/class State
+end #/module Clir

data/lib/clir/utils_methods.rb

@@ -0,0 +1,57 @@
+# require 'fileutils'
+
+##
+# Require all ruby file deep in folder +dossier+
+# 
+def require_folder(dossier)
+  Dir["#{dossier}/**/*.rb"].each{|m|require(m)}
+end
+
+##
+# Like 'mkdir -p' command
+# 
+def mkdir(pth)
+  FileUtils.mkdir_p(pth)
+  return pth
+end
+alias :mkdir_p :mkdir
+
+
+##
+# To round a number
+# 
+def round(n, decim = 2)
+  r = n.to_f.round(decim)
+  r.to_f == r.to_i ? r.to_i : r.to_f
+end
+
+##
+# To copy in the clipboard
+# 
+def clip(ca, silent = false)
+  `printf "#{ca.gsub(/"/, '\\"').strip}" | pbcopy`
+  silent || puts("\n(“#{ca}“ copié dans le presse-papier)".gris)
+end
+
+##
+# To delete (unlink) folder of file if it exists
+# 
+# @return TRUE if file existed (and have been deleted).
+# 
+def delete_if_exist(pth)
+  if File.exist?(pth)
+    if File.directory?(pth)
+      FileUtils.rm_rf(pth)
+    else
+      File.delete(pth)
+    end
+    return not(File.exist?(pth))
+  else
+    false
+  end
+end
+
+def true_or_false(value)
+  value ? :TRUE : :FALSE
+end
+

data/lib/clir/utils_numbers.rb

@@ -0,0 +1,50 @@
+
+
+
+# @return [String] La valeur exprimée en euro
+# @example
+#   €("12")       # => '12 €'
+#   €("12", true) # => '12.00 €'
+#   €(12.5698)    # => '12.57 €'
+# @param [String|Integer|Float] Number to return as euro value
+def €(value, with_cents = false)
+  if value.is_a?(Integer)
+    "#{value}#{".00" if with_cents} €"
+  elsif value.to_f.to_s != value.to_s
+    raise "Bad value. #{value.inspect} can't be converted to euros."
+  else
+    n, d = value.to_f.round(2).to_s.split('.')
+    d = d.ljust(2,'0')
+    "#{n}.#{d} €"
+  end
+end
+
+# @return [String] Value +value+ as pourcentage
+# 
+# @example
+#   pcent(12)           # => "12 %"
+#   pcent(12, 3)        # => "12.000 %"
+#   pcent(12.436, 1)    # => "12.4 %"
+#   pcent(12.436, true) # => "12.4 %"
+#   pcent(12.436, 2)    # => "12.44 %"
+# 
+# @param value [Integer|String|Float] The value to convert
+# @param with_cents [TrueClass|Integer] Decimal value. If true,
+#         1 decimal is used ("10.1 %")
+# 
+def pcent(value, with_cents = nil)
+  if value.is_a?(Integer)
+    value = value.to_s
+  elsif value == value.to_i.to_s
+    value = value.to_i.to_s
+  elsif value.to_f.to_s != value.to_s
+    raise "Bad value. #{value.inspect}:#{value.class} can't be converted to pourcentage."
+  end
+  with_cents = 1 if with_cents == true
+  if with_cents
+    n, d = value.to_f.round(with_cents).to_s.split('.')
+    d = d.ljust(with_cents,'0')
+    value = "#{n}.#{d}"
+  end
+  "#{value} %"
+end

data/lib/clir/version.rb

@@ -0,0 +1,3 @@
+module Clir
+  VERSION = "0.22.0"
+end

data/lib/clir.rb

@@ -0,0 +1,36 @@
+=begin
+
+  @usage
+
+    ~~~ruby
+    require 'clir'
+    CLI.init
+    ...
+    ~~~
+
+=end
+require 'fileutils'
+require "clir/version"
+require 'clir/String.ext'
+require 'clir/CLI.mod'
+require 'clir/Array.ext'
+require 'clir/Integer.ext'
+require 'clir/Symbol.ext'
+require 'clir/File_extension'
+require 'clir/CSV_extension'
+require 'clir/Config.cls'
+require 'clir/utils_methods'
+require 'clir/utils_numbers'
+require 'clir/Date_utils'
+require 'clir/helpers_methods'
+require 'clir/state_methods'
+require 'clir/console_methods'
+require 'clir/TTY-Prompt.cls'
+require 'clir/Replayer.cls'
+require 'clir/Table'
+require 'clir/Labelizor'
+
+module Clir
+  class Error < StandardError; end
+  # Your code goes here...
+end