pdf_writing_tools 0.0.11 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45529182709a12f3e41c914f9cdd36583589ca618570fe2f7b8fcdae6fe24305
-  data.tar.gz: a594ff7382a41a60c07f540d4d77656be8221b6d2429d52e8237593bfa86d742
+  metadata.gz: abc0c5dd8900c730c7f016b794bafa2da0fd3bb107e381f62289517c64c3d7ad
+  data.tar.gz: e73fe29e7dc36b1c743709bfa1d18e4af47775b740960b895346f07f10484810
 SHA512:
-  metadata.gz: 597f10537e24f2b42318e5471a8ddd0222bd16789c044fbd6a47aeb0ab8b226557f534cd84c9104dffbdf460dd53df5f136faef3801d28c9d1ee8e58f5f2dc82
-  data.tar.gz: 4c6dd9d236317f5d65e51c8557e4dd1d93ae301aa856fea195d45090c07829c4457e85f6fbd4a11509ad5a87acd969ee82f93ce451d201e6ea24aa4eb2ac6954
+  metadata.gz: ce5ef7db92f5d41bd438f3d6119b6761c1b96dd248f6fa5a712c898af3a2827cdad2e3b097d40c10ab0b9f61185d80675805458af4ae8423d6ddc40a7739bca9
+  data.tar.gz: d4ce2bef3b3eef7f8b2919f4dfb6a40ff95b4fc75520777e7aed312b5cc9c82095a42f46ceeef62e242d5c2e24af5fe4950b290916d7884d5bf9af8759b078f4

data/lib/pdf_writing_tools.rb

@@ -11,7 +11,19 @@ module PdfWritingTools
   # li  (elemento di lista non ordinata)
   # b   (grassetto)
   # i   (italico)
+  # 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.
+
+  # L'oggetto xml, viene letto ricorsivamente. Si crea una lista, contenente
+  # dei dizionari. Ciascun dizionario contiene:
+  # 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
@@ -30,24 +42,25 @@ 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
 
 
-    ######## Disegna una cella di dimensioni fissate, nella data posizione. ######
-  #   E' Possibile indicare il colore del bordo, dello sfondo, del font e della
+  ######## Disegna una cella di dimensioni fissate, nella data posizione. ######
+  # E' Possibile indicare il colore del bordo, dello sfondo, del font e della
   # relativa dimensione (oltre a tutta un'altra serie di parametri (opts), vedere prima
   # parte della funzione)
-  #   La cella, viene disegnata "globalmente", rispetto al pdf, ossia NON relativamente
+  # La cella, viene disegnata "globalmente", rispetto al pdf, ossia NON relativamente
   # ad altri contenitori.
-  #   x e y, indicano rispettivamente le coordinate x e y del vertice in alto a
+  # 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 è 
+  # Il vertice è relativo al margine superiore del pdf, contrariamente a quanto
+  # accade quando si utilizzano le primitive prawn (dove il margine di riferimento è
   # quello basso della pagina).
-  #   Bisogna pertanto prestare attenzione quando si mischiano primitive prawn
+  # 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
     align = opts[:align] || :left
@@ -63,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
@@ -71,26 +86,311 @@ 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
-      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
-      )
+
+      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
   end
+
+  # Disegna una cella di altezza variabile nella data posizione, in funzione del contenuto.
+	# E' possibile indicare il colore del bordo, dello sfondo della cella e del font e della
+	# relativa dimensione del testo ivi contenuto (oltre ad altri parametri, vedi prima parte
+  # 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.
+  # 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
+  # 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={}, auto_y=false, no_background=false)
+    font_size        = opts[:font_size] || 10
+    style            = opts[:style] || :normal
+    align            = opts[:align] || :left
+    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 #
+
+    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.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::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,
+            :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
+
+
+
+        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 è 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}
+    end
+
+    result
+  end
+
+
+  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]
+		valignments       = opts[:valignments] || [:top]
+		font_colors       = opts[:font_colors] || ["000000"]
+		border_colors     = opts[:border_colors] || ["000000"]
+		background_colors = opts[:background_colors] || ["FFFFFF"]
+		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|
+			font_size = font_sizes[i] || font_sizes[0]
+			style = styles[i] || styles[0]
+			align = alignments[i] || alignments[0]
+			valign =  valignments[i] || valignments[0]
+			font_color = font_colors[i] || font_colors[0]
+			border_color = border_colors[i] || border_colors[0]
+			background_color = background_colors[i] || background_colors[0]
+			padding = paddings[i] || paddings[0]
+
+      cell_opts = {}
+
+      cell_opts[:font_size] = font_size
+      cell_opts[:style] = style
+      cell_opts[:align] = align
+      cell_opts[:valign] = valign
+      cell_opts[:font_color] = font_color
+      cell_opts[:border_color] = border_color
+      cell_opts[:background_color] = background_color
+      cell_opts[:left_padding] = padding[:left_padding]
+      cell_opts[:right_padding] = padding[:right_padding]
+      cell_opts[:top_padding] = padding[:top_padding]
+      cell_opts[:bottom_padding] = padding[:bottom_padding]
+      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, 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 = {}, auto_y)
+		font_sizes        = opts[:font_sizes] || [10]
+		styles            = opts[:styles] || [:normal]
+		alignments        = opts[:alignments] || [:left]
+		valignments       = opts[:valignments] || [:top]
+		font_colors       = opts[:font_colors] || ["000000"]
+		border_colors     = opts[:border_colors] || ["000000"]
+		background_colors = opts[:background_colors] || ["FFFFFF"]
+		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
+		pdf_margin_top    = opts[:pdf_margin_top] || 2.cm
+		pdf_margin_bottom = opts[:pdf_margin_bottom] || 2.cm
+		pdf_margin_left   = opts[:pdf_margin_left] || 2.cm
+		pdf_margin_right  = opts[:pdf_margin_right] || 2.cm
+
+		new_y = pdf_margin_top
+
+		loop do
+
+			max_cell_height = 0
+
+			# 1 - Cerco l'altezza della riga
+			# Per prima cosa, simulo il disegno delle varie celle che compongono la riga.
+			# In questo modo, posso sapere quale sarà la massima altezza raggiunta da una
+			# cella, ossia l'altezza che deve avere la riga
+			offset = 0
+			widths.each_with_index do |width, i|
+				font_size = font_sizes[i] || font_sizes[0]
+				style = styles[i] || styles[0]
+				align = alignments[i] || alignments[0]
+				valign =  valignments[i] || valignments[0]
+				font_color = font_colors[i] || font_colors[0]
+				border_color = border_colors[i] || border_colors[0]
+				background_color = background_colors[i] || background_colors[0]
+				padding = paddings[i] || paddings[0]
+
+        cell_opts = {}
+        cell_opts[:font_size] = font_size
+        cell_opts[:style] = style
+        cell_opts[:align] = align
+        cell_opts[:valign] = valign
+        cell_opts[:font_color] = font_color
+        cell_opts[:border_color] = border_color
+        cell_opts[:background_color] = background_color
+        cell_opts[:left_padding] = padding[:left_padding]
+        cell_opts[:right_padding] = padding[:right_padding]
+        cell_opts[:top_padding] = padding[:top_padding]
+        cell_opts[:bottom_padding] = padding[:bottom_padding]
+        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, auto_y)
+
+				if r[:height] > max_cell_height
+					max_cell_height = r[:height]
+				end
+
+					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
+
+			# A seguito della simulazione, ho ottenuto l'altezza di riga...
+			# ... ora passo al disegno vero e proprie delle celle...
+			offset = 0
+			rtexts = []
+			widths.each_with_index do |width, i|
+				font_size = font_sizes[i] || font_sizes[0]
+				style = styles[i] || styles[0]
+				align = alignments[i] || alignments[0]
+				valign =  valignments[i] || valignments[0]
+				font_color = font_colors[i] || font_colors[0]
+				border_color = border_colors[i] || border_colors[0]
+				background_color = background_colors[i] || background_colors[0]
+				padding = paddings[i] || paddings[0]
+
+        cell_opts = {}
+        cell_opts[:font_size] = font_size
+        cell_opts[:style] = style
+        cell_opts[:align] = align
+        cell_opts[:valign] = valign
+        cell_opts[:font_color] = font_color
+        cell_opts[:border_color] = border_color
+        cell_opts[:background_color] = background_color
+        cell_opts[:left_padding] = padding[:left_padding]
+        cell_opts[:right_padding] = padding[:right_padding]
+        cell_opts[:top_padding] = padding[:top_padding]
+        cell_opts[:bottom_padding] = padding[:bottom_padding]
+        cell_opts[:pdf_height] = 297.mm
+        cell_opts[:pdf_weigth] = 21.cm
+
+				# ...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, auto_y)
+
+				# Gli eventuali "testi residui" (es. raggiunto fine pagina) li raccolgo
+				# nel seguente array
+				rtexts << r
+
+				offset += width
+			end
+
+			texts = rtexts
+
+			# Se nei testi residui, sono presenti solo stringhe vuote, posso uscire dal
+			# loop, altrimenti, devo cambiare pagina e disegnare una nuova riga con i
+			# testi rimanenti
+			if !check_no_empty_string_presence(texts)
+				new_y = y + max_cell_height
+				break
+			else
+				pdf.start_new_page
+				y = pdf_margin_top # Posiziono il cursore ad inizio della nuova pagina
+			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 != "" 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
+  # a capo e gli spazi multipli
+  def self.get_cleaned_xml_from_file(file_path)
+    text = File.read(file_path)
+
+    # Rimuove gli a capo e le tabulazioni sostituendoli con uno spazio
+    text = text.gsub(/\n|\t/, ' ')
+
+    # Rimuove le spaziature multiple sostituendole con uno spazio
+    text = text.gsub(/\s+/, ' ')
+
+    Nokogiri::XML(text)
+  end
 end

data/lib/pdf_writing_tools_actions.rb

@@ -1,9 +1,54 @@
+# 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 (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 (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 (
+# 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.
+  # 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
+  # possono essere fuse, pertanto vanno eseguite singolarmente
+  def self.execute_actions(pdf, actions, last_actn_name, data)
+    actions.each do |action|
+      if action[:action_name] == :draw_formatted_text
+        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
+
+    # Disegno l'ultima action della lista
+    execute_action(pdf, last_actn_name, data)
+  end
+
   # Questa action contiene istruzioni per disegnare un "a capo" nel PDF
   def self.new_line_action
     [{ 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
@@ -22,64 +67,172 @@ module PdfWritingToolsActions
   end
 
   # Questa action, contiene istruzioni per disegnare un "bullet", ossia
-  # un oggetto grafico, tipo un segno di spunta accanto all'elemnto di
+  # un oggetto grafico, tipo un segno di spunta accanto all'elemento di
   # una lista
   def self.bullet_action
     [
       {
-        action_name: :draw_image, data:
+        action_name: :draw_image,
+        data:
         {
-          url: 'public/bullet.png' # Pallino
+          url: File.expand_path("../../assets/bullet.png", __FILE__)
+          # Pallino
         }
       }
     ]
   end
 
-  # Esegue last_action, oppure concatena i dati di action e di last_action
-  def self.text_action(pdf, action, last_action_name, data)
-    if last_action_name.nil?
-      data = action[:data]
-    elsif last_action_name == :draw_formatted_text
-      data += action[:data]
-    else
-      execute_action(pdf, last_action_name, data)
-      data = action[:data]
-    end
-    [:draw_formatted_text, data]
+  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
 
-  # Mentre la "scrittura/disegno" del testo, puo' essere "concatenato", nel caso
-  # delle immagini no. Una action sulla immagine, pertanto interrompe la
-  # possibilita' di concatenare i data delle action di testo. Pertanto, eseguo
-  # in ogni caso last_action, a meno che last_action non sia nil (ossia action
-  # e' la prima azione della lista)
-  def self.img_action(pdf, action, last_action_name, data)
-    execute_action(pdf, last_action_name, data) unless last_action_name.nil?
-    [:draw_image, action[:data]]
-  end
 
-  # 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
-      pdf.formatted_text(data, align: :left)
-    elsif action_name == :draw_image
-      current_cursor_position = pdf.cursor
-      pdf.move_cursor_to(current_cursor_position - 3)
-      pdf.image(data[:url], height: 6, width: 6)
-      pdf.move_cursor_to(current_cursor_position)
+
+  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
+        pdf.formatted_text(data, align: :left)
+      elsif action_name == :draw_image
+        # 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_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
-  end
 
-  # Esegue le azioni, andando a concatenare quelle "contigue" nella lista,
-  # che riguardano la scrittura di testo
-  def self.execute_actions(pdf, actions, last_actn_name, data)
-    actions.each do |action|
-      if action[:action_name] == :draw_formatted_text
-        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)
+    # 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
+        # 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
+        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
+        # quella corrente
+        execute_action(pdf, last_action_name, data)
+        data = action[:data]
       end
+
+      [: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
+    # in ogni caso last_action, a meno che last_action non sia nil (ossia action
+    # e' la prima azione della lista)
+    def self.img_action(pdf, action, last_action_name, data)
+      execute_action(pdf, last_action_name, data) unless last_action_name.nil?
+      [:draw_image, action[:data]]
+    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
-    execute_action(pdf, last_actn_name, data)
-  end
 end

data/lib/pdf_writing_tools_process.rb

@@ -23,8 +23,8 @@ module PdfWritingToolsProcess
 
   # Produce la "action" che permette di disegnare nel pdf, il testo con le
   # proprieta' specificate in proprerties
-  def self.process_xml_text(xml_obj, properties, size = 12, upcase = false)
-    data = { text: (upcase ? xml_obj.text.upcase : xml_obj.text) + ' ', styles: properties, size: size }
+  def self.process_xml_text(xml_obj, properties, size = 12, upcase = false, color = "#000000")
+    data = { text: (upcase ? xml_obj.text.upcase : xml_obj.text) + ' ', styles: properties, size: size, color: color[1..-1] }
     [{ action_name: :draw_formatted_text, data: [data] }]
   end
 
@@ -58,13 +58,14 @@ 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
@@ -76,19 +77,66 @@ 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
+  # 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
+  # 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
+  # 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
+  # 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)
+    span_styles_attributes = string_to_attributes(xml_obj[:style])
+
+    color = "#000000"
+
+    if span_styles_attributes.has_key?("color")
+      color = span_styles_attributes["color"]
+    end
+
+    actions_list = process_xml_text(xml_obj.child, properties, size=12, upcase=false, color)
+  end
+
+
+
+  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)
+  def self.process_xml_obj(xml_obj, properties, attributes={})
     case xml_obj.name
-    when 'text', 'b', 'i', 'ul', 'li', 'p', 'h1', 'ol'
+    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
@@ -97,15 +145,29 @@ module PdfWritingToolsProcess
     end
   end
 
+  def self.string_to_attributes(s)
+    result = {}
+
+    s.split(";").each do |el|
+      e = el.split(":")
+      result[e[0]] = e[1]
+    end
+
+    result
+  end
+
   @process_xml_tag_table =
   {
     'text' => method(:process_xml_text),
+    'span' => method(:process_xml_tag_span),
     'b' => method(:process_xml_tag_b),
     'i' => method(:process_xml_tag_i),
     'ul' => method(:process_xml_tag_ul),
     '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,53 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: pdf_writing_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.14
 platform: ruby
 authors:
 - JSalvo1978
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-28 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 4.2.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 4.2.8
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Plugin for pdf writing
+date: 2024-01-05 00:00:00.000000000 Z
+dependencies: []
+description: Plugin for write pdf in a simplified manner, using prawn as backend
 email:
 - gianmario.salvetti@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT-LICENSE
-- README.rdoc
 - Rakefile
+- assets/bullet.png
 - lib/pdf_writing_tools.rb
 - lib/pdf_writing_tools/green-check-mark-sign-addition-icon-vector-13230189.jpg
 - lib/pdf_writing_tools/version.rb
@@ -96,6 +67,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- assets
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright 2018 Gianmario Salvetti
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,3 +0,0 @@
-= PdfWritingTools
-
-This project rocks and uses MIT-LICENSE.