Class: SalesClicExporter::Document::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/sales_clic_exporter/base.rb

Overview

All formats will inherit from this class

Direct Known Subclasses

Excel, GoogleSpreadsheets

Instance Method Summary collapse

Instance Method Details

#h_table(values, *headers_with_options) ⇒ Object

Ecriture d’un tableau horizontal avec une matrice de valeurs, et les entetes des colones (horizontalement) Le second argument comprend les headers, et les options. Cette syntaxe permet une grande liberté d’écriture car on peut spécifier une liste d’headers comme liste d’arguments, puis en dernier argument un hash d’options

Raises:

  • (ArgumentError) 


77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/sales_clic_exporter/base.rb', line 77

def h_table(values, *headers_with_options)
  raise ArgumentError, "values should be an array" unless values.kind_of?(Array)

  # Extraction du dernier argument
  options = (headers_with_options.last.kind_of?(Hash) && headers_with_options.respond_to?('each'))   ?   headers_with_options.pop   :   {}
  
  # At this point headers_with_options only contains the headers so we rename the variable for readability
  # If the headers were passed as an array then they will be contained in another array, i.e. [['a', 'b', 'c']] so we extract them
  headers = if headers_with_options.size == 1 && headers_with_options.first.kind_of?(Array)
              headers_with_options.first
            else
              headers_with_options
            end

  # Dans la méthode #line on utilise le même mécanisme pour contenir les options dans la liste d'arguments.
  # C'est pour cette raison qu'on réintègre les options dans le header, et qu'on passe le tout en argument
  line(headers << options.merge({:bold => true, :wrap_text => true}))

  # Ajout d'une bordure sous les headers
  # respond_to? ne prend pas en compte les méthodes privée, on utilise à la place
  # private_methods qui renvoie la liste des méthodes privées
  if options[:border_bottom] && self.private_methods.include?('add_bottom_border')
    add_bottom_border(headers)
  end

  # Ligne de démarquation
  newline(6)

  values.each do |array_of_values|
    line(*array_of_values << options)
  end

  self # Pour pouvoir chaîner les méthodes
end

#line(*values) ⇒ Object

Ecriture d’une ligne

Raises:

  • (ArgumentError) 


113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/sales_clic_exporter/base.rb', line 113

def line(*values)
  raise ArgumentError, "values ne peut être vide" if values.empty?

  # Gestion du cas où on passe un tableau plutôt que plusieurs arguments
  # Dans ce cas values = [['a', 'b', 'c']] par exemple, ie. le tableau
  # passé en paramètre se retrouve dans un tableau, dont on ne prend que le
  # premier élément
  if values.kind_of?(Array) && values.size == 1 && values.first.kind_of?(Array)
    values = values.first
  end

  # Options de formattage
  # On prend la dernière valeur du paramètre, si c'est bien un hash
  # On procède de cette manière pour pouvoir toujours utiliser la liste
  # d'arguments, mais sans spécifier d'options vide, qui serait obligatoire à l'appel
  # le cas échéant
  options = values.pop if values.last.kind_of?(Hash) && values.respond_to?('each')

  # Formattage
  style = if options && options[:bold] && options[:wrap_text]
              'bold_wrap'
          elsif options && options[:wrap_text]
              'wrap'
          elsif options && options[:bold]
              'bold'
          else
            nil
          end                

  # Index de cellule spécifié ? (pour démarer la ligne sur la
  # celulle d'index 1 au lieu de 0)
  cell_index = options && options[:index]  ?   options[:index]   :   self.class::Default_cell_index

  write_line(values, cell_index, style)

  increment_row_index

  self # Chainage des méthodes d'écriture
end

#v_table(array_of_values, *headers) ⇒ Object

Ecriture d’un tableau vertical avec une colone d’entetes (verticalement) et une autre colone de valeurs Prend en 2è argument un tableau, ou une suite d’arguments



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/sales_clic_exporter/base.rb', line 23

def v_table(array_of_values, *headers)
  raise "array_of_values should be an array" unless array_of_values.kind_of?(Array)

  # Si on passe un tableau, headers prend comme valeur [valeurs du tableau], ie. il
  # encapsule les valeurs dans un tableau. Dans ce cas, on pend le premier élément
  headers       = headers.first if headers.is_a?(Array) && headers.size == 1 && headers.first.is_a?(Array)
  
  # On forme un zip des deux tableau, cf. la doc de Ruby (Array#zip).
  # La méthode agit comme une transposition (les entetes et les valeurs étant deux vecteurs)
  # sauf que les valeurs absentes DU SECOND TABLEAU (celui en paramètre de #zip)
  # sont remplacées par nil.
  
  # C'est pour cela qu'on va d'abord chercher quel est le tableau le plus petit
  # afin d'avoir l'ordre permettant que les 'trous' soient comblés (il faut que
  # ce tableau plus petit soit en paramètre).
  # Sinon le résultat est tronqué à la première valeur nil trouvée dans le premier tableau
  # Par la suite, on va dans ce cas (si l'ordre change) inverser les résultats
  # afin de ne pas avoir [VALEUR, COLONE] au lieu de [COLONE, VALEUR]
  ary_a         = headers.size < array_of_values.size   ?   array_of_values   :   headers
  ary_b         = headers.size < array_of_values.size   ?   headers           :   array_of_values
  zipped_values = *ary_a.zip(ary_b)

  #Handle the case where array_of_values and headers are Arrays of one unique element
  #In this case, zip does not return an array of array like this [[key,value],[key,value]]
  #But just a simple array [key,value]. In this case, we just write a line
  unless zipped_values.first.is_a? Array
    line(zipped_values).newline
    return self
  end

  zipped_values.each do |array_of_two_values|
    # C'est ici qu'on regarde si l'ordre a été changé
    # auquel cas on inverse les valeurs du tableau
    if headers.size < array_of_values.size
      ary = array_of_two_values.reverse
    else
      ary = array_of_two_values
    end
    line(ary)
  end

  self
end

#write {|_self| ... } ⇒ Object

Méthode de complésance pour écrire dans le document en utilisant un bloc

Yields:

  • (_self)

Yield Parameters:



68
69
70
71
 
# File 'lib/sales_clic_exporter/base.rb', line 68

def write
  yield(self) if block_given?
  self
end