clir 0.22.0

data/lib/clir/CLI.mod.rb

@@ -0,0 +1,237 @@
+=begin
+
+  A command line is composed by:
+
+  - app command (for example: 'rake')
+  - main command (main_command): firts element not leading with '-'
+    dans without '=' (for example: 'build' in 'rake build')
+  - options: elements that lead with '-' or '--'
+  - params : elments that contain '=' (key=value pairs)
+  - components: all other elements
+
+  We can get this elments with:
+
+    CLI.main_command
+    CLI.options[:<key>]
+    CLI.option(:key)
+    CLI.params[:<key>]
+    CLI.components[<index>]
+
+  App can define its own short options (to long options) with:
+
+    CLI.set_options_table({short: long, short: long...})
+
+    Note : il faut obligatoirement mettre la version courte (souvent
+    une seule lettre) en Symbol : 
+        CLI.set_options_table({e: :edition})
+
+
+=end
+module CLI
+MARKER_TESTS_FILE = File.expand_path(File.join('.','.MARKER_TESTS'))
+class << self
+
+  ##
+  # First class method
+  # (call it at start-up)
+  # 
+  def init
+    parse(ARGV)
+    Q.init if Q.respond_to?(:init)
+  end
+
+  ##
+  # @return command line options
+  # @options is set while parse method. If it is not set, we
+  # CLI.init first.
+  # 
+  def options
+    defined?(@options) || self.init
+    @options
+  end
+
+  # @return option of key +key+
+  def option(key)
+    options[key.to_sym]
+  end
+
+  ##
+  # @main command (after command name)
+  def main_command
+    defined?(@main_command) || self.init
+    @main_command
+  end
+
+  ##
+  # @return command line parameters
+  # 
+  def params
+    defined?(@params) || self.init
+    @params
+  end
+
+  def param(key)
+    @params[key.to_sym]
+  end
+
+  ##
+  # @return command line components
+  # 'components' are elements of command line that are not options
+  # (with leading '-'), that are not parameters (key=value paire) and
+  # that are not main_command
+  # 
+  def components
+    defined?(@components) || self.init
+    @components
+  end
+
+
+  ##
+  # Command name
+  #
+  # Don't confuse with 'main command' which is the very first
+  # argument in command line
+  #
+  def command_name
+    @command_name ||= begin
+      File.basename($PROGRAM_NAME,File.extname($PROGRAM_NAME))
+    end
+  end
+
+  ##
+  # Main method which parse command line to get:
+  # - main command
+  # - options (leadings with -/--)
+  # - parameters (key=value pairs)
+  # 
+  def parse(argv)
+    argv = argv.split(' ') if argv.is_a?(String)
+    if replay_it?(argv)
+      # 
+      # Replay last command (if unable)
+      # 
+      puts "Je dois apprendre à replayer la commande précédente".jaune
+      puts "Pour ça, je dois enregistrer les inputs précédents.".jaune
+    else
+      # 
+      # Regular run
+      # 
+      reset
+      @raw_command_line = ([command_name]+argv).join(' ')
+      argv.each do |arg|
+        if arg.start_with?('--')
+          arg, val = key_and_value_in(arg[2..-1])
+          @options.merge!(arg.to_sym => val)
+        elsif arg.start_with?('-')
+          arg, val = key_and_value_in(arg[1..-1])
+          arg = long_option_for(arg)
+          @options.merge!(arg.to_sym => val)
+        elsif arg.match?('.=.')
+          key, val = key_and_value_in(arg)
+          @params.merge!(key.to_sym => val)
+        elsif @main_command.nil?
+          @main_command = arg
+        else
+          @components << arg
+        end
+      end
+    end
+  end
+
+  def set_options_table(table)
+    @_app_options_table = table
+  end
+
+  ##
+  # For Replayer, return data
+  def get_command_line_data
+    {
+      raw_command_line: @raw_command_line,
+      command_name:     command_name,
+      main_command:     main_command,
+      components:       components,
+      options:          options,
+      params:           params,
+      table_short2long_options:  table_short2long_options
+    }
+  end
+
+  def set_command_line_data(data)
+    data.each do |k, v| instance_variable_set("@#{k}", v) end
+  end
+
+  # --- Tests Methods ---
+
+  def set_tests_on_with_marker
+    File.write(MARKER_TESTS_FILE, "#{Time.now}")
+  end
+
+  def unset_tests_on_with_marker
+    if File.exist?(MARKER_TESTS_FILE)
+      File.delete(MARKER_TESTS_FILE)
+    else
+      puts "Weirdly, the test marker file (CLI::MARKER_TESTS_FILE) doesn't exist…".rouge
+    end
+  end
+
+
+  private
+
+    def reset
+      @main_command = nil
+      @components   = [] 
+      @options      = {}
+      @params       = {}
+      Clir::State.reset
+      CLI::Replayer.init_for_recording
+      @table_short2long_options = nil
+    end
+
+    ##
+    # @return the long option for +short+
+    # 
+    def long_option_for(short)
+      short = short.to_sym
+      if table_short2long_options.key?(short)
+        table_short2long_options[short] 
+      else
+        short
+      end
+    end
+
+    ##
+    # @return conversion table from short option (pe 'v') to
+    # long option (pe 'verbose').
+    # App can define its own table in CLI.set_options_table
+    def table_short2long_options
+      @table_short2long_options ||= begin
+        {
+          :h  => :help,
+          :q  => :quiet,
+          :v  => :verbose,
+          :x  => :debug,
+        }.merge(app_options_table)
+      end
+    end
+
+    ##
+    # @return the app table of options conversions
+    def app_options_table
+      @_app_options_table ||= {}
+    end
+
+    ##
+    # @return [key, value] in +foo+ if +foo+ contains '='
+    #         [foo, default] otherwise
+    def key_and_value_in(foo, default = true)
+      foo.match?('=') ? foo.split('=') : [foo, default]
+    end
+
+    ##
+    # @return TRUE if replay character is used and only
+    # replay character
+    def replay_it?(argv)
+      argv.count == 1 && argv[0] == ::Config[:replay_character]
+    end
+end #/<< self CLI
+end #/module CLI

data/lib/clir/CSV_extension.rb

@@ -0,0 +1,177 @@
+require 'csv'
+class CSV
+class << self
+
+  # Pour pouvoir tester l'entête dans les tests
+  attr_reader :headers_for_test
+
+  # Lecture d'un fichier CSV à partir de la fin
+  # 
+  # Les arguments sont les mêmes que pour readlines
+  # 
+  # Pour rappel :
+  #   +options+ peut contenir
+  #     :headers    À true, on tient compte des entêtes et on
+  #                 retourne des CSV::Row. Sinon, on retourne une
+  #                 Array simple.
+  #     :headers_converters 
+  #                 Convertisseur pour les noms des colonnes.
+  #                 :downcase ou :symbol
+  #     :converters
+  #                 Liste de convertisseurs pour les données.
+  #                 Principalement :numeric, :date
+  #     :col_sep
+  #                 Séparateur de colonne. Par défaut une virgule.
+  # 
+  def readlines_backward(path, **options, &block)
+
+    options ||= {}
+
+    file = File.new(path)
+    size = File.size(file)
+
+    if size < ( 1 << 16 )
+      return readlines_backward_in_small_file(path, **options, &block)
+    end
+
+    #
+    # Si options[:headers] est true, il faut récupérer la première
+    # ligne et la transformer en entête
+    # 
+    if options[:headers]
+      begin
+        fileh   = File.open(path,'r')
+        header  = fileh.gets.chomp
+      ensure
+        fileh.close
+      end
+      table = CSV.parse(header, **options)
+      headers = table.headers
+      @headers_for_test = headers # pour les tests
+    end
+
+
+    if block_given?
+      #
+      # Les options pour CSV.parse
+      # On garde seulement les convertisseurs de données et on met 
+      # toujours headers à false (puisque c'est seulement la ligne
+      # de données qui sera parser)
+      # 
+      # line_csv_options = {headers:false, converters: options[:converters]}
+      line_csv_options = options
+      #
+      # Avec un bloc fourni, on va lire ligne par ligne en partant
+      # de la fin.
+      # 
+      buffer_size = 10000 # disons que c'est la longueur maximale d'une ligne
+
+      #
+      # On se positionne de la fin - la longueur du tampo dans le
+      # fichier à lire
+      # 
+      file.seek(-buffer_size, IO::SEEK_END)
+      # 
+      # Le tampon courant (il contient tout jusqu'à ce qu'il y ait
+      # au moins une ligne)
+      # 
+      buffer = ""
+      #
+      # On boucle tant qu'on n'interrompt pas (pour le moment)
+      # 
+      # QUESTIONS
+      #   1.  Comment repère-t-on la fin ? En comparant la position
+      #       actuelle du pointeur avec 0 ?
+      #   2.  Comment met-on fin à la recherche (c'est presque la 
+      #       même question)
+      while true
+        #
+        # On lit la longueur du tampon en l'ajoutant à ce qu'on a 
+        # déjà lu ou ce qui reste.
+        # Celui pourra contenir une ou plusieurs lignes, la première
+        # pourra être tronquée
+        # 
+        buffer = file.read(buffer_size) + buffer
+        #
+        # Nombre de lignes
+        # (utile ?)
+        nombre_lignes = buffer.count("\n")
+        # 
+        # On traite les lignes du buffer (en gardant ce qui dépasse)
+        # 
+        if nombre_lignes > 0
+          # puts "Position dans le fichier : #{file.pos}".bleu
+          # puts "Nombre de lignes : #{nombre_lignes}".bleu
+          lines = buffer.split("\n").reverse
+          #
+          # On laisse la dernière ligne, certainement incomplète, dans
+          # le tampon. Elle sera ajoutée à la fin de ce qui précède
+          # 
+          buffer = lines.pop
+          # 
+          # Boucle sur les lignes
+          # 
+          # @note : un break, dans le &block, interrompra la boucle
+          # 
+          lines.each do |line|
+            line = line.chomp
+            line = "#{header}\n#{line}\n" if options[:headers]
+            # puts "line parsée : #{line.inspect}".bleu
+            line_csv = CSV.parse(line, **line_csv_options)
+            # puts "line_csv: #{line_csv.inspect}::#{line_csv.class}".orange
+            yield line_csv[0]
+          end
+        end
+        #
+        # On remonte de deux fois la longueur du tampon. Une fois pour
+        # revenir au point de départ, une fois pour remonter à la
+        # portion suivante, à partir de la position courante, évide-
+        # ment
+        # 
+        new_pos = file.pos - 2 * buffer_size
+        if new_pos < 0
+          file.seek(new_pos)
+        else
+          file.seek(- 2 * buffer_size, IO::SEEK_CUR)
+        end
+        #
+        # Si on se trouve à 0, on doit s'arrêter
+        # 
+        break if file.pos <= 0
+        # puts "Nouvelle position dans le fichier : #{file.pos}".bleu
+      end
+    else
+      #
+      # Sans bloc fourni, on renvoie tout le code du fichier
+      # 
+      # À vos risques et périls
+      # self.readlines(path, **options).to_a.reverse
+      self.foreach(path, **options).reverse
+    end
+
+  end
+  alias :readlines_backwards  :readlines_backward
+  alias :foreach_backward     :readlines_backward
+  alias :foreach_backwards    :readlines_backward
+
+  # Lecture à l'envers dans un petit fichier
+  # 
+  def readlines_backward_in_small_file(path, **options, &block)
+    if block_given?
+      self.foreach(path, **options).reverse_each do |row|
+        yield row
+      end
+      # liste2reverse = []
+      # self.readlines(path, **options).each { |row| liste2reverse << row }
+      # liste2reverse.reverse.each do |row|
+      #   yield row
+      # end
+    else
+      # Lecture toute simple de la table
+      # return self.readlines(path, **options).to_a.reverse
+      return self.foreach(path, **options).reverse
+    end
+  end
+
+end #/<< self class CSV
+end #/class CSV

data/lib/clir/Config.cls.rb

@@ -0,0 +1,25 @@
+=begin
+
+  Pour le moment, on met la configuration comme ça, en dur, mais
+  plus tard on pourra la modifier pour chaque application.
+
+=end
+module Clir
+class Configuration
+
+  def [](key)
+    data[key]    
+  end
+
+  # TODO
+  def data
+    {
+      replay_character: '_'
+    }
+  end
+
+end #/class Configuration
+end #/module CLIR
+
+# Expose outside
+Config = Clir::Configuration.new

data/lib/clir/Date_utils.rb

@@ -0,0 +1,161 @@
+=begin
+  
+  Usefull methods for date & time
+
+  @author: Philippe Perret <philippe.perret@yahoo.fr>
+
+=end
+require 'date'
+
+MOIS = {
+  1 => {court: 'jan', long: 'janvier'},
+  2 => {court: 'fév', long: 'février'},
+  3 => {court: 'mars', long: 'mars'},
+  4 => {court: 'avr', long: 'avril'},
+  5 => {court: 'mai', long: 'mai'},
+  6 => {court: 'juin', long: 'juin'},
+  7 => {court: 'juil', long: 'juillet'},
+  8 => {court: 'aout', long: 'aout'},
+  9 => {court: 'sept', long: 'septembre'},
+  10 => {court: 'oct', long: 'octobre'},
+  11 => {court: 'nov', long: 'novembre'},
+  12 => {court: 'déc', long: 'décembre'}
+}
+
+DAYNAMES = [
+  'Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'
+]
+
+
+# @return [String] Une date formatée avec le moins verbal
+# 
+# @param [Time|Date|NIl] La date. Si non fournie, on prend maintenant
+# @param [Hash] options Les options de formatage
+# @option lenght [Symbol] :court (pour le mois court)
+def human_date(ladate = nil, **options)
+  ladate ||= Time.now
+  options.key?(:length) || options.merge!(length: :long)
+  lemois = MOIS[ladate.month][options[:length]]
+  lemois = "#{lemois}." if options[:length] == :court
+  "#{ladate.day} #{lemois} #{ladate.year}"
+end
+alias :date_humaine :human_date
+
+
+# @return A date for a file, now
+# @example
+#   date_for_file # => "2022-12-14"
+#   date_for_file(nil, true) # => "2022-12-14-23-11"
+def date_for_file(time = nil, with_hour = false, del = '-')
+  time ||= Time.now
+  fmt = "%Y#{del}%m#{del}%d"
+  fmt = "#{fmt}#{del}%H#{del}%M" if with_hour
+  time.strftime(fmt)
+end
+
+# @reçoit une date et la retourne sous la forme "YYYY-MM-DD"
+def ymd(time = nil, delimitor = '-')
+  time ||= Time.now
+  time.strftime("%Y#{delimitor}%m#{delimitor}%d")
+end
+
+
+# @return Date corresponding to +foo+
+# @param [String|Integer|Time|Date] foo
+#           - [Time] Return itself
+#           - [Date] Return itself.to_time
+#           - [String] JJ/MM/AAAA or 'YYYY/MM/DD'
+#           - [Integer] Number of seconds
+# @note
+#   Alias :time_from (more semanticaly correct)
+# 
+def date_from(foo)
+  case foo
+  when Time then foo
+  when Date then foo.to_time
+  when Integer    then Time.at(foo)
+  when String
+    a, b, c = foo.split('/')
+    if c.length == 4
+      Time.new(c.to_i, b.to_i, a.to_i)
+    else
+      Time.new(a.to_i, b.to_i, c.to_i)
+    end
+  else
+    raise "Unable to transform #{foo.inspect} to Time."
+  end
+end
+alias :time_from :date_from
+
+##
+# Formate de date as JJ MM AAAA (or MM JJ AAAA in english)
+# @param {Time} date
+# @param [Hash] options table:
+# @option options [Boolean] :verbal     If true, the format will be "month the day-th etc."
+# @option options [Boolean] :no_time    If true, only day, without time
+# @option options [Boolean] :seconds    If true, add seconds with time
+# @option options [Boolean] :update_format If true, the format is updated. Otherwise, the last format is used for all next date
+# @option options [Boolean] :sentence   If true, on met "le ... à ...."
+# 
+def formate_date(date, options = nil)
+  options ||= {}
+  @last_format = nil if options[:update_format] || options[:template]
+  @last_format ||= begin
+    as_verbal = options[:verbal]||options[:sentence]
+    if options[:template]
+      options[:template]
+    else
+      fmt = []
+      fmt << 'le ' if options[:sentence]
+      if as_verbal
+        forday = date.day == 1 ? '1er' : '%-d'
+        fmt << "#{forday} #{MOIS[date.month][:long]} %Y" 
+      else
+        fmt << '%d %m %Y'
+      end
+      delh = options[:sentence] ? 'à' : '-'
+      unless options[:no_time]
+        fmt << (as_verbal ? " à %H h %M" : " #{delh} %H:%M")
+      end
+      if options[:seconds]
+        fmt << (as_verbal ? ' mn et %S s' : ':%S' )
+      end
+      fmt.join('')
+    end
+  end
+  date.strftime(@last_format)
+end
+
+class Time
+
+  # @return [String] French date with separator
+  # @example
+  #   Time.now.jj_mm_yyyy # => "28/12/2022"
+  # @param separator [String] Separator to use (default: '/')
+  def jj_mm_aaaa(separator = '/')
+    self.strftime(['%d','%m','%Y'].join(separator))
+  end
+
+  # @return [String] English date with separator
+  # @example
+  #   Time.now.mm_dd_yyyy # => "12/28/2022"
+  # 
+  # @param separator [String] Separator to use (default: '/')
+  def mm_dd_yyyy(separator = '/')
+    self.strftime(['%m','%d','%Y'].join(separator))
+  end
+
+end #/class Time
+
+class Integer
+
+  def ago
+    (Time.now - self).mm_dd_yyyy
+  end
+
+end #/class Integer
+
+def ilya(laps, options = nil)
+  options ||= {}
+  (Time.now - laps).jj_mm_aaaa(options[:separator] || '/')
+end