pfa 1.0.1

data/lib/pfa/img_builder.rb

@@ -0,0 +1,198 @@
+#
+# Module de construction de l'image CVG
+# 
+require_relative 'imagemagick_module'
+require_relative 'any_builder'
+module PFA
+class RelativePFA
+class ImgBuilder < AnyBuilder
+
+  attr_reader :code_image_magick
+
+
+  # Initialisation avant la construction
+  # 
+  # On définit notamment toutes les constants PFA_WIDTH etc.
+  # 
+  def init(**params)
+    params[:as].is_a?(Symbol) || params[:as].is_a?(Hash) || raise(PFAFatalError.new(101))
+    MagickPFA.define_dims_constants(params[:as])
+  end
+
+  def coef_pixels
+    @coef_pixels ||= calc_coefficient_pixels
+  end
+
+
+  ##########################################
+  ### MÉTHODE PRINCIPALE DE CONSTRUCTION ###
+  ##########################################
+  # Construction de l'image du paradigme
+  # 
+  # @param params [Hash]
+  #     :as     La chose à construire, permettant de définir les
+  #             dimensions de l'image et les dimensions principales. 
+  #             Mettre :real_book ou :test pour des dimensions 
+  #             différentes et connu.
+  #             Cf. le fichier any_builder.rb pour voir les valeurs
+  #             possible.
+  # 
+  def build(**params)
+    #
+    # Initialisation de la construction. On doit par exemple fournir
+    # les dimensions à utiliser à l'aide options[:as]
+    #
+    init(**params)
+
+    #
+    # Le PFA doit être défini au minimum et ses données doivent être
+    # valides.
+    # 
+    pfa.valid?
+
+    #
+    #
+    # Détruire l'image si elle existe déjà
+    # 
+    File.delete(image_path) if File.exist?(image_path)
+
+    # 
+    # Construction du code pour Image Magick
+    # (tous les codes seront injectés dans @code_image_magick)
+    # 
+    @code_image_magick = [MagickPFA.code_for_intro]
+
+    #
+    # Les titres des deux PFA
+    # (on peut utiliser n'importe quel noeud pour les afficher)
+    # 
+    @code_image_magick << pfa.exposition.titre_pfa(false)
+    @code_image_magick << pfa.exposition.titre_pfa(true)
+
+    #
+    # Le fond, avec les actes
+    # 
+    actes.each do |acte|
+      # acte.full_code_image_magick
+      # -- Cadre de la partie (acte) --
+      @code_image_magick << acte.act_box_code(true)
+      @code_image_magick << acte.act_box_code(false)
+      # --- Nomde l'acte --
+      @code_image_magick << acte.act_name_code(true)
+      @code_image_magick << acte.act_name_code(false)
+      # --- Horloge de l'acte ---
+      @code_image_magick << acte.horloge_code(false, nil)
+      @code_image_magick << acte.horloge_code(true, nil)
+    end
+
+    # --- Horloges de fin ---
+    # 
+    # @note
+    #   Peu importe le noeud qui est appelé
+    # 
+    @code_image_magick << pfa.denouement.horloge_fin(false)
+    @code_image_magick << pfa.denouement.horloge_fin(true)
+
+
+    # --- IMPRESSION DES AUTRES NOEUDS/SÉQUENCES ---
+    # 
+    # On passe en revue tous les autres éléments du paradigme réel
+    # et s'ils sont imprimable, on les ajoute.
+    @last_abs_left = nil
+    @last_left = nil
+    pfa.data.values.each do |node|
+      next if node.part? # déjà traité
+      next unless node.drawnable? # pas imprimable
+      # -- Mark et nom --
+      @code_image_magick << node.image_magick_code(false, @last_abs_left)
+      @code_image_magick << node.image_magick_code(true, @last_left)
+      # -- Les horloges --
+      @code_image_magick << node.horloge_code(false, @last_abs_left)
+      @code_image_magick << node.horloge_code(true, @last_left)
+      # 
+      # On garde en mémoire les dimensions pour savoir si ça
+      # va manger dessus (overlay)
+      # 
+      @last_abs_left  = node.abs_left + [ MagickPFA::Horloge_Width[node.type]/2, MagickPFA::Label_Width[node.type]/2 ].max
+      @last_left      = node.left     + [ MagickPFA::Horloge_Width[node.type]/2, MagickPFA::Label_Width[node.type]/2 ].max
+    end
+
+
+    #
+    # Chemin d'accès au fichier final
+    # (en le protégeant)
+    # 
+    @code_image_magick << "\"#{image_path.gsub(/ /, "\\ ")}\""
+
+    # 
+    # On transforme le code ImageMagick en ajoutant des retours
+    # de chariot entre chaque section de code
+    # 
+    @code_image_magick = @code_image_magick.join("\n")
+
+    # STDOUT.write "\n\ncmd à la fin =\n++++\n#{cmd}\n+++++\n".orange
+
+    #
+    # Mise de la commande sur une seule ligne
+    # (je ne parviens pas à mettre la commande sur plusieurs lignes,
+    #  même avec la contre-balance…)
+    cmd_finale = @code_image_magick.split("\n").compact.join(" ")
+    
+    
+    # Pour débugger facilement, on met les numéros des lignes
+    
+    cmd_debug = cmd_finale.split("\n").collect.with_index do |line, idx|
+      "#{idx + 1}: #{line.strip}"
+    end.join("\n")
+    # dbg "\n\nCommande finale\n#{cmd_debug}\n".bleu
+
+    #
+    # *** EXÉCUTION DE LA COMMANDE ***
+    # 
+    res_err = `#{cmd_finale} 2>&1`
+
+    unless res_err.nil? || res_err.empty?
+      raise PFAFatalError.new(5001, **{error: res_err})
+    end
+
+    #
+    # L'image doit avoir été créée
+    # 
+    File.exist?(image_path) || raise(PFAFatalError.new(5000, **{path: image_path}))
+    puts "Image #{image_path.inspect} produite avec succès."
+
+  end #/ build
+
+
+
+  # @return \Array<Node> Liste des actes du paradigme
+  # 
+  def actes
+    @actes ||= begin
+      pfa.data.values.select do |node|
+        node.part?
+      end
+    end
+  end
+
+
+  # @return \String Chemin d'accès au fichier de l'image finale
+  def image_path
+    @image_path ||= File.expand_path(File.join('.','pfa.jpg'))
+    # @image_path ||= File.expand_path(File.join('.','pfa.img'))
+  end
+
+  # @private
+
+  # Calcule le coefficiant pixels qui permet de convertir un temps
+  # quelconque en pixels en fonction de la durée du film analysé.
+  # Produira la constant COEF_PIXELS
+  # 
+  def calc_coefficient_pixels
+    (MagickPFA::PFA_WIDTH - MagickPFA::PFA_LEFT_MARGIN - MagickPFA::PFA_RIGHT_MARGIN).to_f / pfa.duration.to_i
+  end
+
+
+end #/class ImgBuilder
+end #/class RelativePFA
+end #/module PFA

data/lib/pfa/node_time.rb

@@ -0,0 +1,188 @@
+#
+# Class PFA::NTime
+# -------------------
+# Pour la gestion des temps dans le paradigme de Field
+# On ne passera plus par la class Time, trop compliquée
+# 
+module PFA
+class NTime
+
+  # \Integer Nombre de secondes pour ce temps
+  attr_reader :secondes
+
+  # \Integer Nombre de secondes du zéro
+  attr_reader :zero_offset
+
+  # On peut initialiser un NTime avec :
+  #   - [Integer]     Des secondes
+  #   - [Time]        Un temps
+  #   - [String]      Une horloge
+  #   - [PFA::NTime]  Une instance PFA::NTime (comme celle-ci)
+  # 
+  # @param \Integer zero_offset   Décalage du temps avec zéro
+  # 
+  def initialize(foo, zero_offset = 0)
+    @zero_offset = zero_offset
+    case foo
+    when Integer    then @secondes = foo
+    when Float      then @secondes = foo.to_i
+    when PFA::NTime then @secondes = foo.to_i
+    when Time       then @secondes = foo.to_i
+    when String     then @secondes = PFA.h2s(foo)
+    else raise PFAFatalError.new(53, {value: "#{foo}", classe:"#{foo.class}"})  
+    end
+    @secondes -= zero_offset
+  end
+
+
+  def as_horloge
+    @to_horloge ||= PFA.s2h(secondes)
+  end
+  alias :to_horloge :as_horloge
+
+  def as_duree
+    @as_duree ||= PFA.s2h(secondes, **{as: :duree})
+  end
+
+  # -- Méthodes de décalage --
+   
+  def calc_offset(abs_time)
+    offset_secondes = (abs_time.to_i - self.to_i).abs
+    @offset     = self.class.new(offset_secondes)
+    @hasoffset  = offset > 30
+  end
+
+  # @return [String] Une horloge qui indique le décalage avec 
+  # la valeur idéale (seulement pour les noeuds relatifs) si ce
+  # décalage existe.
+  # 
+  # @param abs_time [PFA::NTime] Le temps absolu
+  # 
+  def as_horloge_with_offset(abs_time)
+    @as_horloge_with_offset ||= begin
+      if offset?
+        signe   = self > abs_time ? '+' : '-'
+        "#{self.as_horloge} (#{signe}#{offset.as_duree})" 
+      else
+        self.as_horloge
+      end
+    end
+  end
+
+  # @return true s'il y a un décalage trop important avec le 
+  # temps absolu
+  # @noter que cette méthode existe aussi pour le temps absolu
+  def offset?
+    @hasoffset === true
+  end
+
+  def offset_as_horloge(abs_time)
+    @offset_as_horloge ||= begin
+      if @hasoffset
+        signe   = self > abs_time ? '+' : '-'
+        " (#{signe}#{offset.as_duree})" 
+      else
+        " "
+      end
+    end
+  end
+
+  def background_per_offset
+    @background_per_offset ||= begin
+      if offset > 120
+        'gray40' # offset trop grand
+      else
+        'transparent'
+      end
+    end
+  end
+  def foreground_per_offset
+    @foreground_per_offset ||= begin
+      if offset < 60
+        'gray60'
+      elsif offset < 120
+        'gray20'
+      else
+        'white'
+      end
+    end
+  end
+
+  # [PFA::NTime] Décalage entre le temps absolu et le temps réel
+  def offset
+    @offset
+  end
+
+  def to_i
+    @secondes
+  end
+
+  # Retourne la valeur en pixels pour le temps courant (ou la durée)
+  def to_px(pfa)
+    (self.to_i * pfa.img_builder.coef_pixels).to_i
+  end
+
+  # [PFA::NTime] Le temps relatif (à l'écran)
+  def relative
+    @relative ||= NTime.new(secondes + zero_offset, 0)
+  end
+
+  # --- Helpers Methods ---
+
+  # @retour [BashString] Le code pour écrire l'horloge dans une 
+  # image avec ImageMagick pour le noeud +node+
+  # 
+  # @param [PFA::RelativePFA::Node] node Le nœud de l'horloge
+  # @param [Hash] options 
+  #     Plus tard, pourra redéfinir :bg_color et :color
+  # 
+  def as_img_horloge_code(node, **options)
+    for_real = options[:pfa_type] == :real
+    <<~CMD.strip
+    \\(
+    -background #{options[:bg_color]||'transparent'}
+    -stroke #{options[:color]||'gray20'}
+    -fill #{options[:color]||'gray20'}
+    -strokewidth 1
+    -pointsize #{MagickPFA::BASE_FONTSIZE * MagickPFA::HORLOGE_FONT_SIZES[node.type]}
+    -size #{surface}
+    -gravity #{options[:gravity]||'Center'}
+    label:"#{for_real ? self.as_horloge_with_offset(options[:abs_time]) : as_horloge}"
+    -extent #{surface}
+    \\)
+    -gravity northwest
+    -geometry +#{node.send(for_real ? :left : :abs_left) + 24}+#{node.send(for_real ? :top : :abs_top) + 8}
+    -composite
+    CMD
+  end
+
+  def surface
+    @surface ||= "#{MagickPFA::PFA_WIDTH/10}x50"
+  end
+
+  # --- Operation Methods ---
+
+  # Addition
+  # 
+  # @param secondes \PFA::NTime ou \Integer
+  # 
+  def +(secs)
+    secs = secs.to_i if secs.is_a?(PFA::NTime)
+    return PFA::NTime.new(secs + @secondes)
+  end
+
+  def -(secs)
+    secs = secs.to_i if secs.is_a?(PFA::NTime)
+    return PFA::NTime.new(@secondes - secs)
+  end
+
+  def <(nodetime)
+    @secondes < nodetime.to_i
+  end
+
+  def >(nodetime)
+    @secondes > nodetime.to_i
+  end
+
+end #/class NTime
+end #/module PFA

data/lib/pfa/pfa_element_module.rb

@@ -0,0 +1,30 @@
+#
+# Pour ajouter des méthodes communes à RelativePFA::Node et
+# RelativePFA::DataTime
+# 
+module PFAElementModule
+
+  # @return true si c'est une partie (acte)
+  def part?
+    return abs_data[:type] == 'part'
+  end
+
+  # @return true si c'est un élément imprimable (dans le tableau
+  # décrivant le PFA, à ne pas confondre avec le graphique)
+  def printable?
+    return abs_data[:printed] == true
+  end
+
+  # @return true si c'est un élément à dessiner dans le graphique
+  # des deux PFA (idéal et réel)
+  def drawnable?
+    return abs_data[:drawn] == true
+  end
+
+  # Sera redéfini pour RelativePFA::Node, mais pas pour
+  # 
+  def abs_data
+    {type: 'data_time', printed: false} 
+  end
+
+end #/module PFAElementModule

data/lib/pfa/relative_pfa.rb

@@ -0,0 +1,191 @@
+#
+# PFA Relatif, donc celui étudié
+# 
+module PFA
+  # Pour pouvoir faire :
+  #   pfa = PFA.new
+  # 
+  def self.new(data = nil)
+    RelativePFA.new(data)
+  end
+
+  # # Pour obtenir le PFA courant (au mépris de toute loi de Démeter…)
+  # # 
+  # def self.current
+  #   @@current
+  # end
+  # def self.current=(pfa)
+  #   @@current = pfa
+  # end
+
+class RelativePFA
+
+  # [Hash] Les données du Paradigme de Field Augmenté
+  attr_reader :data
+
+  # Instanciation du paradigme
+  # 
+  # @param input_data [Hash|Nil] Données du paradigme fournies à l'instanciation
+  # 
+  def initialize(input_data = nil)
+    @data = {}
+    #
+    # -- Traitement de toutes les données fournies --
+    # 
+    input_data ||= {}
+    input_data.each { |k, v| add(k, v) }
+  end
+
+  def method_missing(method_name, *args, &block)
+    if data.key?(method_name)
+      data[method_name]
+    elsif AbsolutePFA.data[:nodes].key?(method_name)
+      data[method_name]
+    else
+      raise NoMethodError.new(method_name)
+    end
+  end
+
+  # Ajout d'un nœud dans le PFA
+  # 
+  # On utilise pour le faire : pfa.add(key, value). Si c'est un
+  # nœud, la valeur contient {t: '<horloge>', d: "description"}
+  # La clé :t peut-être remplacée par :time ou :start_at
+  # La clé :d peut-être remplacée par :description
+  # 
+  def add(key, value)
+    # puts "-> add(#{key.inspect}, #{value.inspect}::#{value.class})".orange
+    key = key.to_sym
+    if AbsolutePFA.data[:nodes].key?(key)
+      #
+      # Ajout d'un nœud
+      # 
+      # @note
+      #   Un noeud doit toujours être défini par une table contenant
+      #   :t (ou :time) et :d (ou :description)
+      # 
+      #   La donnée doit être valide. On en profite aussi pour bien
+      #   définir le temps.
+      #
+      value = value_valid?(value, key)
+      data.merge!(key => RelativePFA::Node.new(self, key, value))
+
+    elsif AbsolutePFA.data[:times].key?(key)
+      #
+      # Ajout d'une valeur temporelle
+      # 
+      data.merge!(key => DataTime.new(self, key, value))
+    else
+      raise PFAFatalError.new(100, **{key: ":#{key}"})
+    end
+  end
+
+  # Test la pertinence de la définition de la clé +key+ et produit une
+  # erreur éclairante en cas de problème.
+  #
+  def value_valid?(value, key)
+    value.is_a?(Hash) || raise(PFAFatalError.new(219, **{key: key, classe: "#{value.class}"}))
+    value.merge!(t: value[:time]) if value.key?(:time)
+    value.merge!(d: value[:description]) if value.key?(:description)
+    value.key?(:t)    || raise(PFAFatalError.new(221, **{noeud: key, classe: "#{value.class}"}))
+    value[:t] = PFA.time_from(value[:t])
+    value.key?(:d)    || raise(PFAFatalError.new(222, **{noeud: key}))
+    return value
+  end
+
+  # @return true si les données relative du PFA sont valides
+  # 
+  # Donc principalement qu'elles existent et qu'elles soient 
+  # conformes aux attentes.
+  # 
+  # Les données minimales pour construire le PFA sont :
+  #   - le zéro
+  #   - le temps de fin (end_time)
+  #   - l'incident déclencheur
+  #   - le pivot 1
+  #   - le début du développement (developpement_part1)
+  #   - le pivot 2
+  #   - le début du dénouement (denouement)
+  #   - le climax
+  # 
+  def valid?
+    zero                  || raise(PFAFatalError.new(200))
+    end_time              || raise(PFAFatalError.new(201))
+    exposition            || raise(PFAFatalError.new(209))
+    incident_declencheur  || raise(PFAFatalError.new(202))
+    pivot1                || raise(PFAFatalError.new(203))
+    developpement_part1   || raise(PFAFatalError.new(204))
+    developpement_part2   || raise(PFAFatalError.new(208))
+    pivot2                || raise(PFAFatalError.new(205))
+    denouement            || raise(PFAFatalError.new(206))
+    climax                || raise(PFAFatalError.new(207))
+
+    # --- Vérification de la validité des temps ---
+    # 
+    incident_declencheur.start_at > zero  || raise_time_error('zero','incident_declencheur')
+    pivot1.after?(incident_declencheur)   || raise_time_error('incident_declencheur','pivot1')
+    developpement_part1.after?(pivot1)    || raise_time_error('pivot1', 'developpement_part1')
+    if cle_de_voute
+      cle_de_voute.after?(developpement_part1)  || raise_time_error('developpement_part1','cle_de_voute')
+    end
+    pivot2.after?(pivot1)                     || raise_time_error('pivot1', 'pivot2')
+    if developpement_part2
+      if cle_de_voute
+        developpement_part2.after?(cle_de_voute)  || raise_time_error('cle_de_voute', 'developpement_part2')
+      end
+      pivot2.after?(developpement_part2)        || raise_time_error('developpement_part2', 'pivot2')
+    end
+    denouement.after?(pivot2)         || raise_time_error('pivot2','denouement')
+    climax.after?(denouement)         || raise_time_error('denouement','climax')
+    data[:end_time].time > climax.start_at || raise_time_error('end_time','climax', end_time, climax)
+  end
+
+  def raise_time_error(key_before, key_after)
+    h_before = self.send(key_before.to_sym)
+    h_after  = self.send(key_after.to_sym)
+    h_before  = PFA.t2h(h_before) if h_before.is_a?(Time)
+    h_after   = PFA.t2h(h_after)  if h_after.is_a?(Time)
+    h_before  = h_before.horloge  if h_before.is_a?(Node)
+    h_after   = h_after.horloge   if h_after.is_a?(Node)
+    raise PFAFatalError.new(220, **{
+      key_before: key_before, h_before: h_before, 
+      key_after: key_after, h_after: h_after
+    })
+  end
+
+  # --- Volatile Data ---
+
+  def zero      ; data[:zero].time      unless data[:zero].nil?      end
+  def end_time  ; data[:end_time].time  unless data[:end_time].nil?  end
+  def duree
+    @duree ||= PFA::NTime.new(end_time, zero.to_i)
+  end
+  alias :duration :duree
+
+  # Définitions -raccourcis-
+  def zero=(value)      ; add(:zero, value)     end
+  def end_time=(value)  ; add(:end_time, value) end
+
+
+  # --- Helper Methods ---
+
+
+
+
+  # --- Output Methods ---
+
+  def to_html(**params)
+    puts "Je dois apprendre à sortir en HTML".orange
+  end
+
+  def to_img(**params)
+    params.key?(:as) || params.merge!(as: :real_book)
+    img_builder.build(**params)
+  end
+
+  def img_builder
+    @img_builder ||= ImgBuilder.new(self)
+  end
+
+end #/ class RelativePFA
+end #/ module PFA

data/lib/pfa/relative_pfa_datatime.rb

@@ -0,0 +1,27 @@
+require_relative 'pfa_element_module'
+module PFA
+class RelativePFA
+class DataTime
+
+  include PFAElementModule
+
+  attr_reader :pfa, :key
+
+  def initialize(pfa, key, value = nil)
+    @pfa        = pfa
+    @key        = key
+    @raw_value  = value
+  end
+
+  def time
+    @time ||= PFA::NTime.new(@raw_value, 0)
+  end
+  alias :start_at :time
+
+  # Pour la compatibilité quand on boucle sur tous les éléments
+  # des données du paradigme relatif
+  def type; nil end
+
+end #/class DataTime
+end #/class RelativePFA
+end #/module PFA