pdf_writing_tools 0.0.10 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32f9690ccbc09db00ba94daceb4d34c0f565bb73f3229c3712a00886aa5cce5d
-  data.tar.gz: 41ed383e3b7ee71992f56b7ced2425902f3a51cb947181220a883f1b720a32ea
+  metadata.gz: 8a14c40e1817a741cae4260b4e37b76bbcd86bc8e079414756794eea8ad0f0ce
+  data.tar.gz: fdecb3e874950d20978c58048126d88c2c52c14021925cfaec09b7f702c4c574
 SHA512:
-  metadata.gz: de956cc911e9cf7ee357ccaa4d35354b0c89893aa8522004c992ebb223b17f3dfb864d9e92aeda7160c8cb3838c254ae346c87108d975d11b1787487cf5077e8
-  data.tar.gz: ed74125384c0f30f6e5bfa33520672ae6039cb2cdb05b0be4a6f5250145b02d3e8265332bbc134fc34d8b78d018212c9b386ec26ad803a3a8f2e95ca984fc6e6
+  metadata.gz: 4e8cff4cb4d7cae857f1abbd87a8509ff13ec0ed6b3c04880851cbacaede5057dd2f5222c2fd2bcc9bb0ed485b3d9d67abdfd1c090e38265c0fa35af92c3fcf3
+  data.tar.gz: e1b38b8925c34e2b148e4b32ba3b47ed83d10c69ffc36ea279ff54206b154b173597768ed5d28e0bc51c8943a89a052354a9b3f6750ab266e7f339933cb24f31

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
@@ -32,4 +44,342 @@ module PdfWritingTools
     end
     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
+  # 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
+  # ad altri contenitori.
+  # 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 è 
+  # 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={})
+    t = (t.class == String ? [{text: t}] : t)
+    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
+
+    result = ''
+
+    pdf.canvas do
+      pdf.line_width = 0.5
+
+      # Colore di sfondo della cella
+      pdf.fill_color(background_color)
+
+      # Disegna lo sfondo della cella
+      pdf.fill_rectangle([x, pdf_height - y], w, h)
+
+      pdf.stroke_color border_color
+      pdf.stroke_rectangle([x, pdf_height - y], 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
+
+    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={})
+    font_size        = opts[:font_size] || 10
+    style            = opts[:style] || :normal
+    align            = opts[:align] || :left
+    valign           = opts[:align] || :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 
+  
+    result = 0
+  
+    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
+      # modo da poter disegnare PRIMA lo sfondo
+      b = Prawn::Text::Box.new(
+            t || "",
+            {:at => [x + left_padding, pdf_height - y - top_padding],
+            :width => w - left_padding-right_padding,
+            :size => font_size,
+            :style => style,
+            :overflow => :expand,
+            :document => pdf})
+      
+      # 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)
+  
+      # 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))
+  
+        # ... 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={})
+		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)
+
+			offset += width
+		end
+	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 = {})
+		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)
+
+				if r[:height] > max_cell_height
+					max_cell_height = r[:height]
+				end
+
+					offset += width
+			end
+
+			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)
+
+				# 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
+
+		return new_y
+	end
+
+  def self.check_no_empty_string_presence(string_list)
+		string_list.each do |string_element|
+			if 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,4 +1,43 @@
+# 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.
+# 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 
+# PdfWritingToolsActions.execute_actions, verrà dato il via all'esecuzione delle actions...
+
+# Nella parte PRIVATE di questa classe, inserire solo metodi che eseguano le action
+# ... 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)
+      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" }] }]
@@ -22,64 +61,89 @@ 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:
         {
-          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]
-  end
+  private
 
-  # 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
+        # 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
 
-  # 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)
+      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
-    execute_action(pdf, last_actn_name, data)
-  end
-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
+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,6 +58,7 @@ 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
@@ -67,7 +68,7 @@ module PdfWritingToolsProcess
     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
@@ -79,16 +80,42 @@ module PdfWritingToolsProcess
     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  
   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
+
+
+
   # 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'
       @process_xml_tag_table[xml_obj.name].call(xml_obj, properties)
     when 'br'
       PdfWritingToolsActions.new_line_action
@@ -97,9 +124,21 @@ 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),

metadata

@@ -1,53 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: pdf_writing_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.13
 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: 2023-08-07 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.