mathias234
843466549a
All checks were successful
CI Pipeline / build (pull_request) Successful in 13s
274 lines
8.8 KiB
Ruby
274 lines
8.8 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module Notare
|
|
module Xml
|
|
class DocumentXml
|
|
NAMESPACES = {
|
|
"xmlns:w" => "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
|
|
"xmlns:r" => "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
|
|
"xmlns:wp" => "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
|
|
"xmlns:a" => "http://schemas.openxmlformats.org/drawingml/2006/main",
|
|
"xmlns:pic" => "http://schemas.openxmlformats.org/drawingml/2006/picture"
|
|
}.freeze
|
|
|
|
def initialize(nodes)
|
|
@nodes = nodes
|
|
end
|
|
|
|
def to_xml
|
|
builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
|
|
xml.document(NAMESPACES) do
|
|
xml.parent.namespace = xml.parent.namespace_definitions.find { |ns| ns.prefix == "w" }
|
|
xml["w"].body do
|
|
@nodes.each { |node| render_node(xml, node) }
|
|
end
|
|
end
|
|
end
|
|
builder.to_xml
|
|
end
|
|
|
|
private
|
|
|
|
def render_node(xml, node)
|
|
case node
|
|
when Nodes::Paragraph
|
|
render_paragraph(xml, node)
|
|
when Nodes::List
|
|
render_list(xml, node)
|
|
when Nodes::Table
|
|
render_table(xml, node)
|
|
when Nodes::Break
|
|
render_page_break(xml, node)
|
|
end
|
|
end
|
|
|
|
def render_page_break(xml, _node)
|
|
xml["w"].p do
|
|
xml["w"].r do
|
|
xml["w"].br("w:type" => "page")
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_paragraph(xml, para)
|
|
xml["w"].p do
|
|
if para.style
|
|
xml["w"].pPr do
|
|
xml["w"].pStyle("w:val" => para.style.style_id)
|
|
end
|
|
end
|
|
para.runs.each { |run| render_run(xml, run) }
|
|
end
|
|
end
|
|
|
|
def render_list(xml, list)
|
|
list.items.each { |item| render_list_item(xml, item) }
|
|
end
|
|
|
|
def render_list_item(xml, item)
|
|
xml["w"].p do
|
|
xml["w"].pPr do
|
|
xml["w"].numPr do
|
|
xml["w"].ilvl("w:val" => item.level.to_s)
|
|
xml["w"].numId("w:val" => item.num_id.to_s)
|
|
end
|
|
end
|
|
item.runs.each { |run| render_run(xml, run) }
|
|
end
|
|
end
|
|
|
|
def render_run(xml, run)
|
|
case run
|
|
when Nodes::Image
|
|
render_image(xml, run)
|
|
when Nodes::Break
|
|
render_break(xml, run)
|
|
when Nodes::Hyperlink
|
|
render_hyperlink(xml, run)
|
|
when Nodes::Run
|
|
render_text_run(xml, run)
|
|
end
|
|
end
|
|
|
|
def render_hyperlink(xml, hyperlink)
|
|
xml["w"].hyperlink("r:id" => hyperlink.rid) do
|
|
hyperlink.runs.each { |run| render_run(xml, run) }
|
|
end
|
|
end
|
|
|
|
def render_break(xml, break_node)
|
|
xml["w"].r do
|
|
if break_node.page?
|
|
xml["w"].br("w:type" => "page")
|
|
else
|
|
xml["w"].br
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_text_run(xml, run)
|
|
xml["w"].r do
|
|
if run.bold || run.italic || run.underline || run.strike || run.highlight || run.color || run.style
|
|
xml["w"].rPr do
|
|
xml["w"].rStyle("w:val" => run.style.style_id) if run.style
|
|
xml["w"].b if run.bold
|
|
xml["w"].i if run.italic
|
|
xml["w"].u("w:val" => "single") if run.underline
|
|
xml["w"].strike if run.strike
|
|
xml["w"].highlight("w:val" => run.highlight) if run.highlight
|
|
xml["w"].color("w:val" => run.color) if run.color
|
|
end
|
|
end
|
|
xml["w"].t(run.text, "xml:space" => "preserve")
|
|
end
|
|
end
|
|
|
|
def render_image(xml, image)
|
|
xml["w"].r do
|
|
xml["w"].drawing do
|
|
xml["wp"].inline(distT: "0", distB: "0", distL: "0", distR: "0") do
|
|
xml["wp"].extent(cx: image.width_emu.to_s, cy: image.height_emu.to_s)
|
|
xml["wp"].docPr(id: image.doc_pr_id.to_s, name: image.filename)
|
|
xml["wp"].cNvGraphicFramePr do
|
|
xml["a"].graphicFrameLocks(noChangeAspect: "1")
|
|
end
|
|
xml["a"].graphic do
|
|
xml["a"].graphicData(uri: "http://schemas.openxmlformats.org/drawingml/2006/picture") do
|
|
xml["pic"].pic do
|
|
xml["pic"].nvPicPr do
|
|
xml["pic"].cNvPr(id: "0", name: image.filename)
|
|
xml["pic"].cNvPicPr
|
|
end
|
|
xml["pic"].blipFill do
|
|
xml["a"].blip("r:embed" => image.rid)
|
|
xml["a"].stretch do
|
|
xml["a"].fillRect
|
|
end
|
|
end
|
|
xml["pic"].spPr do
|
|
xml["a"].xfrm do
|
|
xml["a"].off(x: "0", y: "0")
|
|
xml["a"].ext(cx: image.width_emu.to_s, cy: image.height_emu.to_s)
|
|
end
|
|
xml["a"].prstGeom(prst: "rect") do
|
|
xml["a"].avLst
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_table(xml, table)
|
|
column_widths = compute_column_widths(table)
|
|
|
|
xml["w"].tbl do
|
|
xml["w"].tblPr do
|
|
render_table_width(xml, column_widths)
|
|
render_table_layout(xml, table.layout)
|
|
if table.style
|
|
xml["w"].tblStyle("w:val" => table.style.style_id)
|
|
else
|
|
xml["w"].tblBorders do
|
|
%w[top left bottom right insideH insideV].each do |border|
|
|
xml["w"].send(border, "w:val" => "single", "w:sz" => "4", "w:space" => "0", "w:color" => "000000")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
render_table_grid(xml, column_widths)
|
|
table.rows.each { |row| render_table_row(xml, row, column_widths) }
|
|
end
|
|
end
|
|
|
|
def compute_column_widths(table)
|
|
if table.columns
|
|
table.columns.map { |c| WidthParser.parse(c) }
|
|
elsif table.layout == :auto
|
|
first_row = table.rows.first
|
|
cell_count = first_row&.cells&.size || 1
|
|
Array.new(cell_count) { WidthParser::ParsedWidth.new(value: 0, type: "auto") }
|
|
else
|
|
infer_widths_from_first_row(table)
|
|
end
|
|
end
|
|
|
|
def infer_widths_from_first_row(table)
|
|
first_row = table.rows.first
|
|
return [WidthParser::ParsedWidth.new(value: 5000, type: "pct")] unless first_row
|
|
|
|
cells = first_row.cells
|
|
has_explicit_widths = cells.any?(&:width)
|
|
|
|
if has_explicit_widths
|
|
cells.map do |cell|
|
|
cell.width ? WidthParser.parse(cell.width) : WidthParser::ParsedWidth.new(value: 0, type: "auto")
|
|
end
|
|
else
|
|
col_width = 5000 / cells.size
|
|
cells.map { WidthParser::ParsedWidth.new(value: col_width, type: "pct") }
|
|
end
|
|
end
|
|
|
|
def render_table_width(xml, column_widths)
|
|
if column_widths.all? { |w| w.type == "pct" }
|
|
total = column_widths.sum(&:value)
|
|
xml["w"].tblW("w:w" => total.to_s, "w:type" => "pct")
|
|
elsif column_widths.all? { |w| w.type == "dxa" }
|
|
total = column_widths.sum(&:value)
|
|
xml["w"].tblW("w:w" => total.to_s, "w:type" => "dxa")
|
|
else
|
|
xml["w"].tblW("w:w" => "0", "w:type" => "auto")
|
|
end
|
|
end
|
|
|
|
def render_table_layout(xml, layout)
|
|
return unless layout
|
|
|
|
layout_type = layout == :auto ? "autofit" : "fixed"
|
|
xml["w"].tblLayout("w:type" => layout_type)
|
|
end
|
|
|
|
def render_table_grid(xml, column_widths)
|
|
xml["w"].tblGrid do
|
|
column_widths.each do |width|
|
|
grid_width = case width.type
|
|
when "pct" then pct_to_approximate_dxa(width.value)
|
|
when "auto" then 1440 # Default 1 inch for auto columns
|
|
else width.value
|
|
end
|
|
xml["w"].gridCol("w:w" => grid_width.to_s)
|
|
end
|
|
end
|
|
end
|
|
|
|
# Convert percentage (in fiftieths) to approximate twips
|
|
# Assumes 6.5 inch content width = 9360 twips
|
|
def pct_to_approximate_dxa(pct_value)
|
|
(pct_value * 9360 / 5000.0).to_i
|
|
end
|
|
|
|
def render_table_row(xml, row, column_widths)
|
|
xml["w"].tr do
|
|
row.cells.each_with_index { |cell, idx| render_table_cell(xml, cell, column_widths[idx]) }
|
|
end
|
|
end
|
|
|
|
def render_table_cell(xml, cell, column_width)
|
|
width = column_width || WidthParser::ParsedWidth.new(value: 0, type: "auto")
|
|
xml["w"].tc do
|
|
xml["w"].tcPr do
|
|
xml["w"].tcW("w:w" => width.value.to_s, "w:type" => width.type)
|
|
end
|
|
xml["w"].p do
|
|
cell.runs.each { |run| render_run(xml, run) }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|