Class: PFA::RelativePFA

Inherits:
Object
  • Object
show all
Defined in:
lib/pfa/relative_pfa.rb,
lib/pfa/any_builder.rb,
lib/pfa/img_builder.rb,
lib/pfa/table_builder.rb,
lib/pfa/relative_pfa_node.rb,
lib/pfa/relative_pfa_datatime.rb

Overview

# 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

Defined Under Namespace

Classes: AnyBuilder, DataTime, ImgBuilder, Node, TableBuilder

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(input_data = nil) ⇒ RelativePFA

Instanciation du paradigme

Parameters:

  • input_data (Hash|Nil) (defaults to: nil) —

    Données du paradigme fournies à l’instanciation



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/pfa/relative_pfa.rb', line 35

def initialize(input_data = nil)
  @data = {}
  #
  # -- Traitement de toutes les données fournies --
  # 
  input_data ||= {}
  @pfa_id = input_data.delete(:pfa_id) # indice éventuel du PFA

  input_data.each { |k, v| add(k, v) }
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object 



46
47
48
49
50
51
52
53
54
 
# File 'lib/pfa/relative_pfa.rb', line 46

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

Instance Attribute Details

#data ⇒ Object (readonly)

Hash

Les données du Paradigme de Field Augmenté



24
25
26
 
# File 'lib/pfa/relative_pfa.rb', line 24

def data
  @data
end

#pfa_id ⇒ Object (readonly) Also known as: id

Integer

Indice éventuel du PFA (quand il y en a plusieurs dans

un film)



28
29
30
 
# File 'lib/pfa/relative_pfa.rb', line 28

def pfa_id
  @pfa_id
end

Instance Method Details

#add(key, value) ⇒ Object

Note:

Je crois que maintenant value est toujours un [Hash] définis- sant les données de la clé.

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 ‘<horloge>’, d: “description” et peut-être la clé :pfa_id qui définit l’index du PFA à utiliser

La clé :t peut-être remplacée par :time ou :start_at La clé :d peut-être remplacée par :description



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/pfa/relative_pfa.rb', line 69

def add(key, value)
  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

#duree ⇒ Object Also known as: duration 



184
185
186
 
# File 'lib/pfa/relative_pfa.rb', line 184

def duree
  @duree ||= PFA::NTime.new(end_time, zero.to_i)
end

#end_time ⇒ Object 



183
 
# File 'lib/pfa/relative_pfa.rb', line 183

def end_time  ; data[:end_time].time  unless data[:end_time].nil?  end

#end_time=(value) ⇒ Object 



191
 
# File 'lib/pfa/relative_pfa.rb', line 191

def end_time=(value)  ; add(:end_time, value) end

#img_builder ⇒ Object 



211
212
213
 
# File 'lib/pfa/relative_pfa.rb', line 211

def img_builder
  @img_builder ||= ImgBuilder.new(self)
end

#node(node_key) ⇒ Object 



95
96
97
 
# File 'lib/pfa/relative_pfa.rb', line 95

def node(node_key)
  data[node_key]
end

#node?(node_key) ⇒ Boolean

Returns true si le paradigme définit le noeud de clé node_key.

Returns:

  • (Boolean) —

    true si le paradigme définit le noeud de clé node_key



103
104
105
 
# File 'lib/pfa/relative_pfa.rb', line 103

def node?(node_key)
  data.key?(node_key.to_sym)
end

#print_full_table_in_pdf(pdf, **options) ⇒ Object 



12
13
14
 
# File 'lib/pfa/table_builder.rb', line 12

def print_full_table_in_pdf(pdf, **options)
  table_builder.build(pdf, **options)
end

#raise_time_error(key_before, key_after) ⇒ Object

Raises:



167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/pfa/relative_pfa.rb', line 167

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

#table_builder ⇒ Object 



15
16
17
 
# File 'lib/pfa/table_builder.rb', line 15

def table_builder
  @table_builder ||= TableBuilder.new(self)
end

#to_html(**params) ⇒ Object

— Output Methods —



202
203
204
 
# File 'lib/pfa/relative_pfa.rb', line 202

def to_html(**params)
  puts "Je dois apprendre à sortir en HTML".orange
end

#to_img(**params) ⇒ Object 



206
207
208
209
 
# File 'lib/pfa/relative_pfa.rb', line 206

def to_img(**params)
  params.key?(:as) || params.merge!(as: :real_book)
  img_builder.build(**params)
end

#valid? ⇒ Boolean

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

Returns:

  • (Boolean) —

    true si les données relative du PFA sont valides



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/pfa/relative_pfa.rb', line 135

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

#value_valid?(value, key) ⇒ Boolean

Test la pertinence de la définition de la clé key et produit une erreur éclairante en cas de problème.

Returns:

  • (Boolean) 


110
111
112
113
114
115
116
117
118
 
# File 'lib/pfa/relative_pfa.rb', line 110

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

#zero ⇒ Object

— Volatile Data —



182
 
# File 'lib/pfa/relative_pfa.rb', line 182

def zero      ; data[:zero].time      unless data[:zero].nil?      end

#zero=(value) ⇒ Object

Définitions -raccourcis-



190
 
# File 'lib/pfa/relative_pfa.rb', line 190

def zero=(value)      ; add(:zero, value)     end