pdf_writing_tools 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a14c40e1817a741cae4260b4e37b76bbcd86bc8e079414756794eea8ad0f0ce
-  data.tar.gz: fdecb3e874950d20978c58048126d88c2c52c14021925cfaec09b7f702c4c574
+  metadata.gz: abc0c5dd8900c730c7f016b794bafa2da0fd3bb107e381f62289517c64c3d7ad
+  data.tar.gz: e73fe29e7dc36b1c743709bfa1d18e4af47775b740960b895346f07f10484810
 SHA512:
-  metadata.gz: 4e8cff4cb4d7cae857f1abbd87a8509ff13ec0ed6b3c04880851cbacaede5057dd2f5222c2fd2bcc9bb0ed485b3d9d67abdfd1c090e38265c0fa35af92c3fcf3
-  data.tar.gz: e1b38b8925c34e2b148e4b32ba3b47ed83d10c69ffc36ea279ff54206b154b173597768ed5d28e0bc51c8943a89a052354a9b3f6750ab266e7f339933cb24f31
+  metadata.gz: ce5ef7db92f5d41bd438f3d6119b6761c1b96dd248f6fa5a712c898af3a2827cdad2e3b097d40c10ab0b9f61185d80675805458af4ae8423d6ddc40a7739bca9
+  data.tar.gz: d4ce2bef3b3eef7f8b2919f4dfb6a40ff95b4fc75520777e7aed312b5cc9c82095a42f46ceeef62e242d5c2e24af5fe4950b290916d7884d5bf9af8759b078f4

data/lib/pdf_writing_tools.rb

@@ -14,16 +14,16 @@ module PdfWritingTools
   # span
   # Altri tag non in elenco, vengono ignorati o causano errore
   # Il tag <nothtml> ha lo scopo di sottolineare, che questo markup language non è html, anche
-  # se programmando, cerco di renderlo il più simile possibile all'html. 
-  
+  # se programmando, cerco di renderlo il più simile possibile all'html.
+
   # L'oggetto xml, viene letto ricorsivamente. Si crea una lista, contenente
   # dei dizionari. Ciascun dizionario contiene:
-  # Il nome di un'azione: :action_name 
+  # Il nome di un'azione: :action_name
   # Una lista "data", contenente un dizionario con al suo interno le specifiche
   # da dare a prawn, per "disegnare" del testo o per disegnare un'immagine
   #
   # Le p
- 
+
   def self.draw_xml_object(pdf, xml_object)
     # Ottengo una lista di azioni, ciascuna delle quali, quando eseguita,
     # permette di disegnare una parte del documento xml all'interno del pdf
@@ -42,7 +42,7 @@ module PdfWritingTools
         actions_list += PdfWritingToolsProcess.process_xml_obj(child, [])
       end
     end
-    actions_list
+    actions_list + PdfWritingToolsActions.tr_action + PdfWritingToolsActions.tr_action + actions_list + actions_list
   end
 
 
@@ -55,11 +55,11 @@ module PdfWritingTools
   # x e y, indicano rispettivamente le coordinate x e y del vertice in alto a
   # sinistra del box.
   # Il vertice è relativo al margine superiore del pdf, contrariamente a quanto
-  # accade quando si utilizzano le primitive prawn (dove il margine di riferimento è 
+  # accade quando si utilizzano le primitive prawn (dove il margine di riferimento è
   # quello basso della pagina).
   # Bisogna pertanto prestare attenzione quando si dovessero mischiare primitive prawn
   # con queste funzioni.
-  def self.draw_cell_fixed_height(pdf, x, y, w, h, t, opts={})
+  def self.draw_cell_fixed_height(pdf, x, y, w, h, t, opts={}, auto_y=false, no_background=false)
     t = (t.class == String ? [{text: t}] : t)
     font_size = opts[:font_size] || 10
     style = opts[:style] || :normal
@@ -76,6 +76,8 @@ module PdfWritingTools
     pdf_width = opts[:pdf_width] || 21.cm
 
     result = ''
+    y_pos1 = auto_y ? pdf.cursor : (pdf_height - y)
+    y_pos2 = auto_y ? pdf.cursor - top_padding : (pdf_height - y - top_padding)
 
     pdf.canvas do
       pdf.line_width = 0.5
@@ -84,35 +86,21 @@ module PdfWritingTools
       pdf.fill_color(background_color)
 
       # Disegna lo sfondo della cella
-      pdf.fill_rectangle([x, pdf_height - y], w, h)
+      if no_background
+      else
+        pdf.fill_rectangle([x, y_pos1], w, h)
+      end
 
       pdf.stroke_color border_color
-      pdf.stroke_rectangle([x, pdf_height - y], w, h)
+      pdf.stroke_rectangle([x, y_pos1], w, h)
 
       # Colore del testo nella cella
       pdf.fill_color(font_color)
-      # Disegno il testo contenuto nella cella
-      if false
-        result = pdf.text_box(
-          t,
-          at: [x + left_padding, pdf_height - y - top_padding],
-          width: w - left_padding - right_padding,
-          height: h - top_padding - bottom_padding,
-          size: font_size,
-          style: style,
-          align: align,
-          valign: valign
-        )
-      end
-
-      if true
-        at = [x + left_padding, pdf_height - y - top_padding]
-        width = w - left_padding - right_padding
-        height = h - top_padding - bottom_padding + 1.cm
-
-        pdf.formatted_text_box(t, width: width, height: height, at: at)
-      end
 
+      at = [x + left_padding, y_pos2]
+      width = w - left_padding - right_padding
+      height = h - top_padding - bottom_padding + 1.cm
+      result = pdf.formatted_text_box(t, width: width, height: height, at: at, size: font_size, style: style, align: align, valign: valign)
     end
 
     result
@@ -124,64 +112,79 @@ module PdfWritingTools
   # della funzione).
   # Produce un dizionario, con l'altezza della cella disegnata ed eventuale testo non disegnato
   # (es. nel caso di sopraggiunto fine pagina).
-  # Il campo draw_simulation, serve ad evitare che la cella venga realmente disegnata nel pdf. 
+  # Il campo draw_simulation, serve ad evitare che la cella venga realmente disegnata nel pdf.
   # In questo modo, posso ottenere l'altezza, eventuale testo "avanzato" e prendere decisioni  che
-  # non dipendano da un'unica cella, ma da un gruppo di celle, come ad esempio quando devo 
-  # disegnare la riga di una tabella che essendo composta da più celle, ha un altezza 
+  # non dipendano da un'unica cella, ma da un gruppo di celle, come ad esempio quando devo
+  # disegnare la riga di una tabella che essendo composta da più celle, ha un altezza
   # che dipende dall'altezza massima delle celle "autoridimensionanti" che la compongono.
-	def self.draw_cell_auto_height(pdf, draw_simulation, x, y, w, t, opts={})
+	def self.draw_cell_auto_height(pdf, draw_simulation, x, y, w, t, opts={}, auto_y=false, no_background=false)
     font_size        = opts[:font_size] || 10
     style            = opts[:style] || :normal
     align            = opts[:align] || :left
-    valign           = opts[:align] || :top
+    valign           = opts[:valign] || :top
     font_color       = opts[:font_color] || "000000"
     border_color     = opts[:border_color] || "000000"
     background_color = opts[:background_color] || "FFFFFF"
-    left_padding     = opts[:left_padding] || 5
-    right_padding    = opts[:right_padding] || 5
-    top_padding      = opts[:top_padding] || 5
-    bottom_padding   = opts[:bottom_padding] || 5
-    pdf_height       = opts[:pdf_height] || 297.mm 
-    pdf_width        = opts[:pdf_width] || 21.cm 
-  
+    left_padding     = opts[:left_padding] || 5#
+    right_padding    = opts[:right_padding] || 5#
+    top_padding      = opts[:top_padding] || 5#
+    bottom_padding   = opts[:bottom_padding] || 5#
+    pdf_height       = opts[:pdf_height] || 297.mm #
+    pdf_width        = opts[:pdf_width] || 21.cm #
+
+    t = (t.class == String ? [{text: t, size: font_size, color: font_color}] : t)
+
+
+
     result = 0
-  
+    y_pos1 = auto_y ? (pdf.cursor - top_padding) : (pdf_height - y - top_padding)
+    y_pos2 = auto_y ? pdf.cursor : (pdf_height - y)
+
     pdf.canvas do
-      # Non utilizzo l'helper (pdf.text_box), in quanto scriverebbe direttamente nel pdf
-      # ma io ho bisogno di conoscere l'altezza del box di testo, prima di scriverlo, in
+      # Non utilizzo l'helper (pdf.formatted_text_box), in quanto scriverebbe direttamente nel pdf
+      # ma io ho bisogno di conoscere l'altezza del box di testo formattato, prima di scriverlo, in
       # modo da poter disegnare PRIMA lo sfondo
-      b = Prawn::Text::Box.new(
-            t || "",
-            {:at => [x + left_padding, pdf_height - y - top_padding],
+
+
+      b = Prawn::Text::Formatted::Box.new(
+            t,
+            {:at => [x + left_padding, y_pos1 ],
             :width => w - left_padding-right_padding,
             :size => font_size,
             :style => style,
             :overflow => :expand,
-            :document => pdf})
-      
+            :document => pdf,
+            :align => align,
+            :valign => valign}) #valign ha un comportamento da indagare, mi fa uscire il testo fuori dal box
+
       # Effettuo il render, ma in modalità "prova" (dry_run = true), così posso conoscere quale sarà
       # l'altezza del box prima di disegnarlo
-    
+
       text_overflow = b.render(:dry_run => true)
-  
+      #text_overflow = text_overflow[:text] #### Temporaneo
+
       # Altezza del box, non ancora disegnato
       h = b.height
-  
+
       if not draw_simulation
         # Se non sono in simulazione...
         # ... ora che conosco quale sarà l'altezza del box di testo, posso disegnare lo sfondo
         pdf.fill_color(background_color) # colore dello sfondo
         pdf.stroke_color(border_color)   # Colore del bordo
-        
-        pdf.fill_and_stroke_rectangle([x,pdf_height-y], (w + left_padding + right_padding), (h+top_padding+bottom_padding))
-  
+
+
+
+        if no_background
+        else
+          pdf.fill_and_stroke_rectangle([x, y_pos2], (w + left_padding + right_padding), (h+top_padding+bottom_padding))
+        end
         # ... e infine, sopra lo sfondo disegno il testo
         pdf.fill_color(font_color) # colore del testo
-        text_overflow = b.render() 
+        text_overflow = b.render()
 
         # text_overflow è l'eventuale testo avanzato
       end
-  
+
       # La cella potrebbe non riuscire ad espandersi a sufficienza (troppo vicina al
       # fine pagine, quindi può essere che del testo "avanzi" )
       result = {height: h + top_padding + bottom_padding, overflow: text_overflow}
@@ -191,7 +194,7 @@ module PdfWritingTools
   end
 
 
-  def self.draw_row_fixed_height(pdf, x, y, widths, height, texts, opts={})
+  def self.draw_row_fixed_height(pdf, x, y, widths, height, texts, opts={}, auto_y=false)
 		font_sizes        = opts[:font_sizes] || [10]
 		styles            = opts[:styles] || [:normal]
 		alignments        = opts[:alignments] || [:left]
@@ -202,7 +205,7 @@ module PdfWritingTools
 		paddings          = opts[:paddings] || [{left_padding: 5, right_padding: 5, top_padding: 5, bottom_padding: 5}]
 		pdf_height        = opts[:pdf_height] || 297.mm
 		pdf_width         = opts[:pdf_width] || 21.cm
-	
+
 		offset = 0
 
 		widths.each_with_index do |width, i|
@@ -231,14 +234,15 @@ module PdfWritingTools
       cell_opts[:pdf_width] = 21.cm
       cell_opts[:pdf_height] = 297.mm
 
-			draw_cell_fixed_height( pdf, x+offset, y, width, height, texts[i], cell_opts)
+			draw_cell_fixed_height( pdf, x+offset, y, width, height, texts[i], cell_opts, auto_y)
 
 			offset += width
 		end
+    pdf.cursor = pdf.cursor - height
 	end
 
-  	# Produce la y su pdf, dove disegnare la prossima riga
-	def self.draw_row_auto_height(pdf, draw_simulation, x, y, widths, texts, opts = {})
+  # Produce la y su pdf, dove disegnare la prossima riga
+	def self.draw_row_auto_height(pdf, draw_simulation, x, y, widths, texts, opts = {}, auto_y)
 		font_sizes        = opts[:font_sizes] || [10]
 		styles            = opts[:styles] || [:normal]
 		alignments        = opts[:alignments] || [:left]
@@ -290,7 +294,7 @@ module PdfWritingTools
         cell_opts[:pdf_height] = 297.mm
         cell_opts[:pdf_weigth] = 21.cm
 
-				r = draw_cell_auto_height(pdf, draw_simulation = true, x+offset, y, width, texts[i], cell_opts)
+				r = draw_cell_auto_height(pdf, draw_simulation = true, x+offset, y, width, texts[i], cell_opts, auto_y)
 
 				if r[:height] > max_cell_height
 					max_cell_height = r[:height]
@@ -299,6 +303,8 @@ module PdfWritingTools
 					offset += width
 			end
 
+      # Non voglio che la riga ecceda il margine di pagina, quindi se così fosse
+      # ricalcolo l'altezza di riga per non superare tale margine
 			if y + max_cell_height > pdf_height - pdf_margin_bottom
 				max_cell_height = pdf_height - pdf_margin_bottom - y
 			end
@@ -334,7 +340,7 @@ module PdfWritingTools
 
 				# ...disegno le celle vere e proprie ad altezza fissa, con l'altezza
 				# ricavata dal passo precedente.
-				r = draw_cell_fixed_height(pdf, x+offset, y, width, max_cell_height, texts[i], opts)
+				r = draw_cell_fixed_height(pdf, x+offset, y, width, max_cell_height, texts[i], opts, auto_y)
 
 				# Gli eventuali "testi residui" (es. raggiunto fine pagina) li raccolgo
 				# nel seguente array
@@ -357,19 +363,24 @@ module PdfWritingTools
 			end
 		end
 
+    pdf.cursor = pdf_height - new_y
+
 		return new_y
 	end
 
+  # Se tutte le stringhe nella lista sono "" (stringa vuota) produce false
+  # altrimenti produce true.
   def self.check_no_empty_string_presence(string_list)
-		string_list.each do |string_element|
-			if string_element != ""
+    string_list.each do |string_element|
+			if string_element != "" and string_element != []
 				return true
 			end
 		end
+
 		return false
 	end
 
-  # Dato il percorso file_path, genera un documento xml, a cui sono stati rimossi gli 
+  # Dato il percorso file_path, genera un documento xml, a cui sono stati rimossi gli
   # a capo e gli spazi multipli
   def self.get_cleaned_xml_from_file(file_path)
     text = File.read(file_path)
@@ -380,6 +391,6 @@ module PdfWritingTools
     # Rimuove le spaziature multiple sostituendole con uno spazio
     text = text.gsub(/\s+/, ' ')
 
-    Nokogiri::XML(text)    
+    Nokogiri::XML(text)
   end
 end

data/lib/pdf_writing_tools_actions.rb

@@ -1,26 +1,28 @@
-# Questo modulo, si occupa di 
+# Questo modulo, si occupa di
 
 
 # Le action, definiscono, cosa deve essere fatto (scritto, colorato, disegnato) nel pdf
 # La forma di una action è una coppia (nome_action, dati_per_la_action)
 # L'esecuzione di una action consiste nel realizzare la action usando i dati ad essa associati
-# Quando l'oggetto xml che rappresenta il mio documento pdf da realizzare viene processato, 
-# viene creata una catena (lista) di action. 
-# Alcune action consecutive, possono essere "fuse" tra loro in un'unica action, così da 
-# efficientare il processo di scrittura del file pdf.
+# Quando l'oggetto xml che rappresenta il mio documento pdf da realizzare viene processato,
+# viene creata una catena (lista) di action.
+# Alcune action consecutive, possono essere "fuse" tra loro in un'unica action, così da
+# efficientare il processo di scrittura del file pdf (eseguire singolarmente le action di
+# scrittura testo ad esempio, rallenta molto la scrittura del pdf).
 # Ogni singola action, viene poi eseguita, utilizzando le funzioni di prawn.
 
-# Nella parte PUBLIC di questa classe, inserire solo metodi che generino action
-# La classe PdfWritingToolsProcess, userà i metodi pubblic di questa classe per generare 
-# una list di action. Fornendo la lista di actions al metodo 
+# Nella parte PUBLIC di questa classe, inserire solo metodi che generino action (ma non le eseguono)
+# La classe PdfWritingToolsProcess, userà i metodi pubblic di questa classe per generare
+# una list di action. Fornendo la lista di actions al metodo
 # PdfWritingToolsActions.execute_actions, verrà dato il via all'esecuzione delle actions...
 
-# Nella parte PRIVATE di questa classe, inserire solo metodi che eseguano le action
+# Nella parte PRIVATE di questa classe, inserire solo metodi che eseguano le action (
+# ossia che realizzino la scrittura del pdf)
 # ... le singole actions, verrano eseguite tramite i metodi privati di questa classe
 
 module PdfWritingToolsActions
   # Esegue le azioni, andando a concatenare quelle "contigue" nella lista,
-  # che riguardano la scrittura di testo. 
+  # che riguardano la scrittura di testo.
   # La lista actions, in sostanza comprende più azioni. Quelle contigue che riguardano
   # la scrittura di testo, non vanno eseguite singolarmente, ma devono essere "fuse"
   # e poi eseguite. Le action che riguardano la "scrittura" di un immagine invece, non
@@ -31,6 +33,8 @@ module PdfWritingToolsActions
         last_actn_name, data = text_action(pdf, action, last_actn_name, data)
       elsif action[:action_name] == :draw_image
         last_actn_name, data = img_action(pdf, action, last_actn_name, data)
+      elsif action[:action_name] == :draw_tr
+        last_actn_name, data = draw_tr(pdf, action, last_actn_name, data)
       end
     end
 
@@ -43,6 +47,8 @@ module PdfWritingToolsActions
     [{ action_name: :draw_formatted_text, data: [{ text: "\n" }] }]
   end
 
+  # Per "atomic_text" si intende testo che non contiene ulteriore "struttura"
+  # pesudo html
   def self.atomic_text_action(atomic_text)
     [{ action_name: :draw_formatted_text, data: [{ text: atomic_text }] }]
   end
@@ -66,7 +72,8 @@ module PdfWritingToolsActions
   def self.bullet_action
     [
       {
-        action_name: :draw_image, data:
+        action_name: :draw_image,
+        data:
         {
           url: File.expand_path("../../assets/bullet.png", __FILE__)
           # Pallino
@@ -75,8 +82,79 @@ module PdfWritingToolsActions
     ]
   end
 
+  def self.tr_action(xml_obj=nil, widths=nil)
+    text = "<tr><td>Uno</td><td>Due</td><td>Tre</td><td>Quattro</td></tr>"
+    widths = [2.cm, 2.cm, 3.cm, 4.cm]
+    xml_obj = Nokogiri::XML(text)
+    [
+      {
+        action_name: :draw_tr,
+        data:
+        {
+          xml_obj: xml_obj,
+          widths: widths
+        }
+      }
+    ]
+  end
+
+
+
   private
 
+  # Funzione di Prawn che devo capir bene come utilizzare per la generazione
+  # delle tabelle
+
+  ####### FORMATTED TEXT BOX (formatted_text_box)
+  # formatted_text_box
+  # https://prawnpdf.org/docs/0.11.1/Prawn/Text/Formatted.html
+
+  # Accetta due parametri: un array di dizionari e (facoltativo) un dizionario di opzioni
+
+  # ARRAY DI DIZIONARI
+  # Ciascun dizionario, contiene il testo da disegnare e informazioni su come
+  # formattarlo.
+
+  # DIZIONARIO DI OPZIONI
+
+  # Come disegnare testo formattato
+  # Posso usare due metodi
+
+    # (entrambi i metodi alla fine, forniscono informazioni sull'altezza del BOX
+    # disegnato e sul testo eventualmente non disegnato)
+
+    ##### METODO 1 - In un'unica fase
+    # Utilizzo una funzione di convenienza che disegna immediatamente nel pdf:
+    # formatted_text_box
+
+    ##### METODO 2 - In due fasi
+    # - Genero un oggetto con gli stessi parametri di formatted_text_box:
+    #       oggetto = Prawn::Text::Formatted.new(array_di_dizionari, dizionario_di_opzioni)
+    # - Eseguo il rendering dell'oggetto
+    #       formatted_text_not_rendered_or_overflow = oggetto.render(:dry_run => false)
+    #       oggetto.height # altezza del box
+    #
+    # :dry_run true o false, mi permette di scrivere nel pdf o simulare la scrittura
+    # così da avere informazioni sulla dimensione del box da disegnare senza disegnarlo
+    # effettivamente. Perché?
+    # Supponiamo di dover disegnare la riga di una tabella, dove ciascuna cella
+    # della riga, contenga del testo formattato. Le celle della riga possono avere
+    # larghezze differenti, ma devono avere tutte la stessa altezza... ma quale
+    # altezza? Se definisco un'altezza fissa, c'è la possibilità che testo in
+    # eccesso all'interno di una cella venga tagliato, oppure che ci sia troppo
+    # spazio non utilizzato in tutte le celle (il che è visivamente brutto).
+    # Se utilizzo l'autoridimensionamento del formatted_text_box, offerto da prawn,
+    # avrò ciascuna cella con un altezza differente... Utilizzando invece la
+    # "simulazione", prima disegno (in modalità simulata :dry_run => true) la
+    # riga delle tabella con celle ad altezza autoridimensionata, in questo modo
+    # posso capire qual'è l'altezza di cella massima e se una di queste celle
+    # provoca un salto pagina (nel disegno di box autoridimensionati, l'Altezza
+    # del box, non eccede il salto pagina ed il testo che non può essere disegnato
+    # a causa del salto pagina, mi viene restituito dalla funzione di rendering).
+    # Successivamente disegno la riga vera e propria,
+    # questa volta, indicando un'altezza fissa per ciascuna cella (l'altezza massima
+    # di cella ottenuta nella simulazione).
+
     # Esegue un'azione, andando a scrivere del testo nel PDF, oppure un'immagine
     def self.execute_action(pdf, action_name, data)
       if action_name == :draw_formatted_text
@@ -85,50 +163,55 @@ module PdfWritingToolsActions
         # Il testo disegnato dopo un immagine, non appare allineato. Per questo
         # motivo, disegno l'immagine un' po' prima di dove è previsto (spostando il cursore)
         # per poi ripristinare la posizione originaria del cursore.
-  
+
         # L'operazione di cui sopra, non va eseguita a fondo pagina, altrimenti,
         # il salto pagina automatico crea problemi sulla realizzazione del pdf,
         # quindi...
-  
+
         # Se la posizione del cursore (misurata, dal fondo margine di pagina)
         # è inferiore ad un cm, mi sposto direttamente sulla nuova pagina..
         if pdf.cursor <= 1.cm
           pdf.start_new_page
         end
-  
+
         current_cursor_position = pdf.cursor
         # Anticipo il disegno dell'immagine spostando il cursore di n unità verso
         # l'alto
         n = 0
         pdf.move_cursor_to(current_cursor_position - n)
-  
+
         # Disegno l'immagine (al momento questo metodo disegna solo il "bullet" degli elenchi)
         pdf.image(data[:url], height: 6, width: 6)
-  
+
         # Ripristino la posizione originaria del cursore, in modo che il testo
         # sia allineato all'immagine preceente
         pdf.move_cursor_to(current_cursor_position)
-      elsif action_name == :draw_rectangle
+      elsif action_name == :draw_tr
+        xml_obj = data[:xml_obj]
+        widths = data[:widths]
 
+        current_cursor_position = 297.mm - pdf.cursor
+
+        PdfWritingTools::draw_row_auto_height(pdf, false, 2.cm, current_cursor_position, widths, ["uno", "due", "tre", "quattro"], opts = {}, true)
       end
     end
-  
+
     # Esegue last_action, oppure concatena i dati di action e di last_action
     # action: azione "corrente"
     # last_action_name: nome dell'azione che precede l'azione corrente
     # data: dati dell'azione che precede l'azione corrente
     def self.text_action(pdf, action, last_action_name, data)
       if last_action_name.nil?
-        # Prima azione della lista (last_action_name = nil), quindi per ora 
+        # Prima azione della lista (last_action_name = nil), quindi per ora
         # nessun concatenamento di dati
         data = action[:data]
       elsif last_action_name == :draw_formatted_text
         # La action attuale richiede di "disegnare" testo formattato, come l'ultima azione
-        # quindi, concateno i dati di questa action, con quelli dell'ultima action 
+        # quindi, concateno i dati di questa action, con quelli dell'ultima action
         data += action[:data]
       else
         # La action attuale, differisce dall'ultima, quindi eseguo l'ultima action (che sarà
-        # un'immagine visto che quella attuale è il disegno di testo) e produco i dati di 
+        # un'immagine visto che quella attuale è il disegno di testo) e produco i dati di
         # quella corrente
         execute_action(pdf, last_action_name, data)
         data = action[:data]
@@ -136,7 +219,7 @@ module PdfWritingToolsActions
 
       [:draw_formatted_text, data]
     end
-    
+
     # Mentre la "scrittura/disegno" del testo, puo' essere "concatenato", nel caso
     # delle immagini no. Una action sull' immagine pertanto, interrompe la
     # possibilita' di concatenare i data delle action di testo. Quindi, eseguo
@@ -146,4 +229,10 @@ module PdfWritingToolsActions
       execute_action(pdf, last_action_name, data) unless last_action_name.nil?
       [:draw_image, action[:data]]
     end
-end
+
+
+    def self.draw_tr(pdf, action, last_action_name, data)
+      execute_action(pdf, last_action_name, data) unless last_action_name.nil?
+      [:draw_tr, action[:data]]
+    end
+end

data/lib/pdf_writing_tools_process.rb

@@ -58,17 +58,17 @@ module PdfWritingToolsProcess
   # lista indicato da li
   def self.process_xml_tag_li(xml_obj, _properties, idx=nil)
     actions_list = []
-    
+
     xml_obj.children.each do |child|
       actions_list += process_xml_obj(child, [])
     end
-    
+
     if idx
       PdfWritingToolsActions.new_line_action + PdfWritingToolsActions.atomic_text_action(idx) + PdfWritingToolsActions.indent_action(4) + actions_list
-    else 
+    else
       PdfWritingToolsActions.new_line_action + PdfWritingToolsActions.bullet_action + PdfWritingToolsActions.indent_action(4) + actions_list
     end
-  end  
+  end
 
   # Produce le "actions" che permettono di disegnare nel PDF, il contenuto
   # del tag p
@@ -77,24 +77,26 @@ module PdfWritingToolsProcess
     xml_obj.children.each do |child|
       actions_list += process_xml_obj(child, properties)
     end
+
     PdfWritingToolsActions.new_line_action + actions_list
   end
 
-  # Al momento assumo che h1 contenga solo testo, poi eventualmente 
+  # Al momento assumo che h1 contenga solo testo, poi eventualmente
   # renderla ricorsiva permettendo a h1 di contenere altri tag.
   # Sebbene l'xml che sto processando non sia vero html, voglio cercare di dargli
-  # il più possibile lo stesso comportamento. All'interno di h1, possono essere 
+  # il più possibile lo stesso comportamento. All'interno di h1, possono essere
   # presenti solo elementi inline. Al momento non controllo questa cosa, quindi preferisco
   # tagliare la testa al toro, assumento che h1 contenga solo testo.
   def self.process_xml_tag_h1(xml_obj, properties)
     actions_list = process_xml_text(xml_obj.child, [:bold], 16, true)
-    PdfWritingToolsActions.new_line_action + actions_list + PdfWritingToolsActions.new_line_action * 2  
+
+    PdfWritingToolsActions.new_line_action + actions_list + PdfWritingToolsActions.new_line_action * 2
   end
 
-  # Al momento assumo che span contenga solo testo, poi eventualmente 
+  # Al momento assumo che span contenga solo testo, poi eventualmente
   # renderla ricorsiva permettendo a span di contenere altri tag.
   # Sebbene l'xml che sto processando non sia vero html, voglio cercare di dargli
-  # il più possibile lo stesso comportamento. All'interno di span, possono essere 
+  # il più possibile lo stesso comportamento. All'interno di span, possono essere
   # presenti solo elementi inline. Al momento non controllo questa cosa, quindi preferisco
   # tagliare la testa al toro, assumento che span contenga solo testo.
   def self.process_xml_tag_span(xml_obj, properties)
@@ -103,7 +105,7 @@ module PdfWritingToolsProcess
     color = "#000000"
 
     if span_styles_attributes.has_key?("color")
-      color = span_styles_attributes["color"]    
+      color = span_styles_attributes["color"]
     end
 
     actions_list = process_xml_text(xml_obj.child, properties, size=12, upcase=false, color)
@@ -111,11 +113,30 @@ module PdfWritingToolsProcess
 
 
 
+  def self.process_xml_tag_table(xml_obj, properties)
+    # Processo i figli della tabella che devono essere due
+    # thead
+    # tbody
+    xml_obj.children.each do |child|
+    end
+
+    p xml_obj[:width]
+    p 20.cm / 7.0
+    []
+  end
+
+
+  def self.process_xml_tag_tr(xml_obj, properties)
+
+
+  end
+
+
   # Produce le actions necessarie per disegnare nel PDF un determinato
   # "tag"
   def self.process_xml_obj(xml_obj, properties, attributes={})
     case xml_obj.name
-    when 'text', 'b', 'i', 'ul', 'li', 'p', 'h1', 'ol', 'span'
+    when 'text', 'b', 'i', 'ul', 'li', 'p', 'h1', 'ol', 'span', 'table'
       @process_xml_tag_table[xml_obj.name].call(xml_obj, properties)
     when 'br'
       PdfWritingToolsActions.new_line_action
@@ -126,13 +147,13 @@ module PdfWritingToolsProcess
 
   def self.string_to_attributes(s)
     result = {}
-    
+
     s.split(";").each do |el|
       e = el.split(":")
-      result[e[0]] = e[1]    
+      result[e[0]] = e[1]
     end
-  
-    result  
+
+    result
   end
 
   @process_xml_tag_table =
@@ -145,6 +166,8 @@ module PdfWritingToolsProcess
     'ol' => method(:process_xml_tag_ol),
     'li' => method(:process_xml_tag_li),
     'p' => method(:process_xml_tag_p),
-    'h1' => method(:process_xml_tag_h1)
+    'h1' => method(:process_xml_tag_h1),
+    'table' => method(:process_xml_tag_table),
+    'tr' => method(:process_xml_tag_tr)
   }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pdf_writing_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - JSalvo1978
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-07 00:00:00.000000000 Z
+date: 2024-01-05 00:00:00.000000000 Z
 dependencies: []
 description: Plugin for write pdf in a simplified manner, using prawn as backend
 email: