standard-procedure-consolidate 0.3.9 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb70b369911ba5aa2dc64c21a460b690b722f947e457f3d3efcacf365577046a
-  data.tar.gz: 010f296150c641bc92be1b7255ae424f43393205baa11384013003fb55f056ba
+  metadata.gz: 0ffce925315399bd4432936d929e995114acc2dea081f3835eb437fe2787f612
+  data.tar.gz: b64ae5181ae92d5e66be79e5861787c3355fe08870dbb4ee3ab8355ef4ce149d
 SHA512:
-  metadata.gz: 824f18d218c9489467cfb62ec7567b5400b7f5e08f477864ed1553dbe0a4a278747002f02ee420c1877c2cb659c5b5f456d1716d4a9ffe4b7a8e825641d9bd26
-  data.tar.gz: f6dabb52a96bea36e61b90fcac99d6aedd2a58090d3ddfe3a84d76b19d1672e969cd6728221b51a9b12e83cf83801481626405ebd89c04632de13dba5c87889f
+  metadata.gz: e56547c32223cf66f807c804cdfff2897f63887729dcf1ff80d51c35a0615115f47b16347b582d58a6ae128c3ecad91a67ca128e0d7c89b6e55a3e88b2d5a6c9
+  data.tar.gz: 4b351ad3a367dd4382abc18e18fbc978095fec92aa8b258a90feb82f2e0a65ffbcca26a8177383d75fab07d711a170b10b541e48c195c4b8b7db0eea2cfd1b26

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.4.1] - 2024-12-18
+
+Replace image merge fields with blanks if the image data is not provided 
+
+# [0.4.0] - 2024-12-16
+
+Image embedding works
+
 # [0.3.9] - 2024-12-4
 
 Image embedding - not fully tested but it seems to work in a few test cases

data/checksums/standard-procedure-consolidate-0.4.0.gem.sha512

@@ -0,0 +1 @@
+58d1597374e775340c60e3e49b9d65437909b482f7be3040fb9fdca5d8d4b4d3020508a9ee01e3521b2c552e1b853d0475335d1ca1c092b4172c1e9ac86df640

data/checksums/standard-procedure-consolidate-0.4.1.gem.sha512

@@ -0,0 +1 @@
+dfd2ec36154a632f86dd8f99a2b85c59ed6048dbb6b8100f84645ea1cf49e3e77ad73b3367ef89d46e055c860f1b1e82c5b0d0d37c969a19c2644a3e42ebbe21

data/lib/consolidate/docx/image.rb

@@ -13,12 +13,20 @@ module Consolidate
       def storage_path = "word/#{media_path}"
 
       # Convert width from pixels to EMU
-      def width = super * EMU_PER_PIXEL
+      def width = super * emu_per_width_pixel
 
       # Convert height from pixels to EMU
-      def height = super * EMU_PER_PIXEL
+      def height = super * emu_per_height_pixel
 
-      EMU_PER_PIXEL = (914400 / 72)
+      # Get the width of this image in EMU up to a maximum page width (also in EMU)
+      def clamped_width(maximum = 7_772_400) = [width, maximum].min
+
+      # Get the height of this image in EMU adjusted for a maximum page width (also in EMU)
+      def clamped_height(maximum = 7_772_400) = (height * clamped_width(maximum).to_f / width.to_f).to_i
+
+      def emu_per_width_pixel = 914_400 / dpi[:x]
+
+      def emu_per_height_pixel = 914_400 / dpi[:y]
     end
   end
 end

data/lib/consolidate/docx/image_reference_node_builder.rb

@@ -5,74 +5,67 @@ require "nokogiri"
 
 module Consolidate
   module Docx
-    class ImageReferenceNodeBuilder < Data.define(:field_name, :image, :node_id, :document)
+    class ImageReferenceNodeBuilder < Data.define(:field_name, :image, :node_id, :image_number, :document)
       def call
-        Nokogiri::XML::Node.new("w:r", document).tap do |run_node|
-          run_node << Nokogiri::XML::Node.new("w:drawing", document).tap do |drawing|
-            drawing << Nokogiri::XML::Node.new("wp:inline", document).tap do |inline|
-              inline << Nokogiri::XML::Node.new("wp:extend", document).tap do |extent|
-                extent["cx"] = image.width.to_s
-                extent["cy"] = image.height.to_s
-              end
-              inline << Nokogiri::XML::Node.new("wp:effectExtent", document).tap do |effect_extent|
-                effect_extent["l"] = "0"
-                effect_extent["t"] = "0"
-                effect_extent["r"] = "0"
-                effect_extent["b"] = "0"
-              end
-              inline << Nokogiri::XML::Node.new("wp:docPr", document).tap do |doc_pr|
-                doc_pr["id"] = node_id
-                doc_pr["name"] = field_name
-              end
-              inline << Nokogiri::XML::Node.new("wp:cNvGraphicFramePr", document) do |c_nv_graphic_frame_pr|
-                c_nv_graphic_frame_pr << Nokogiri::XML::Node.new("a:graphicFrameLocks", document).tap do |graphic_frame_locks|
-                  graphic_frame_locks["xmlns:a"] = "http://schemas.openxmlformats.org/drawingml/2006/main"
-                  graphic_frame_locks["noChangeAspect"] = "1"
-                end
+        Nokogiri::XML::Node.new("w:drawing", document).tap do |drawing|
+          drawing["xmlns:a"] = "http://schemas.openxmlformats.org/drawingml/2006/main"
+          drawing << Nokogiri::XML::Node.new("wp:inline", document).tap do |inline|
+            inline["distT"] = "0"
+            inline["distB"] = "0"
+            inline["distL"] = "0"
+            inline["distR"] = "0"
+            inline << Nokogiri::XML::Node.new("wp:extent", document).tap do |extent|
+              extent["cx"] = image.clamped_width(max_width_from(document))
+              extent["cy"] = image.clamped_height(max_width_from(document))
+            end
+            inline << Nokogiri::XML::Node.new("wp:effectExtent", document).tap do |effect_extent|
+              effect_extent["l"] = "0"
+              effect_extent["t"] = "0"
+              effect_extent["r"] = "0"
+              effect_extent["b"] = "0"
+            end
+            inline << Nokogiri::XML::Node.new("wp:cNvGraphicFramePr", document).tap do |c_nv_graphic_frame_pr|
+              c_nv_graphic_frame_pr << Nokogiri::XML::Node.new("a:graphicFrameLocks", document).tap do |graphic_frame_locks|
+                graphic_frame_locks["noChangeAspect"] = true
               end
-              inline << Nokogiri::XML::Node.new("a:graphic", document).tap do |graphic|
-                graphic["xmlns:a"] = "http://schemas.openxmlformats.org/drawingml/2006/main"
-                graphic << Nokogiri::XML::Node.new("a:graphicData", document).tap do |graphic_data|
-                  graphic_data["uri"] = "http://schemas.openxmlformats.org/drawingml/2006/picture"
-                  graphic_data << Nokogiri::XML::Node.new("pic:pic", document).tap do |pic|
-                    pic["xmlns:pic"] = "http://schemas.openxmlformats.org/drawingml/2006/picture"
-                    pic << Nokogiri::XML::Node.new("pic:nvPicPr", document).tap do |nv_pic_pr|
-                      nv_pic_pr << Nokogiri::XML::Node.new("pic:cNvPr", document).tap do |c_nv_pr|
-                        c_nv_pr["id"] = node_id
-                        c_nv_pr["name"] = field_name
-                      end
-                      nv_pic_pr << Nokogiri::XML::Node.new("pic:cNvPicPr", document).tap do |c_nv_pic_pr|
-                        c_nv_pic_pr << Nokogiri::XML::Node.new("a:picLocks", document).tap do |pic_locks|
-                          pic_locks["noChangeAspect"] = "1"
-                        end
-                      end
+            end
+            inline << Nokogiri::XML::Node.new("a:graphic", document).tap do |graphic|
+              graphic["xmlns:a"] = "http://schemas.openxmlformats.org/drawingml/2006/main"
+              graphic << Nokogiri::XML::Node.new("a:graphicData", document).tap do |graphic_data|
+                graphic_data["uri"] = "http://schemas.openxmlformats.org/drawingml/2006/picture"
+                graphic_data << Nokogiri::XML::Node.new("pic:pic", document).tap do |pic|
+                  pic["xmlns:pic"] = "http://schemas.openxmlformats.org/drawingml/2006/picture"
+                  pic << Nokogiri::XML::Node.new("pic:nvPicPr", document).tap do |nv_pic_pr|
+                    nv_pic_pr << Nokogiri::XML::Node.new("pic:cNvPr", document).tap do |c_nv_pr|
+                      c_nv_pr["id"] = image_number
+                      c_nv_pr["name"] = image.name
+                      c_nv_pr["descr"] = image.name
+                      c_nv_pr["hidden"] = false
+                      c_nv_pr << Nokogiri::XML::Node.new("pic:cNvPicPr", document)
                     end
-                    pic << Nokogiri::XML::Node.new("pic:blipFill", document).tap do |blip_fill|
-                      blip_fill << Nokogiri::XML::Node.new("a:blip", document).tap do |blip|
-                        blip["r:embed"] = node_id
-                        blip["xmlns:r"] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-                        blip << Nokogiri::XML::Node.new("a:extLst", document)
-                      end
-                      blip_fill << Nokogiri::XML::Node.new("a:stretch", document).tap do |stretch|
-                        stretch << Nokogiri::XML::Node.new("a:fillRect", document)
-                      end
+                  end
+                  pic << Nokogiri::XML::Node.new("pic:blipFill", document).tap do |blip_fill|
+                    blip_fill << Nokogiri::XML::Node.new("a:blip", document).tap do |blip|
+                      blip["r:embed"] = node_id
                     end
-                    pic << Nokogiri::XML::Node.new("pic:spPr", document).tap do |sp_pr|
-                      sp_pr << Nokogiri::XML::Node.new("a:xfrm", document).tap do |xfrm|
-                        xfrm << Nokogiri::XML::Node.new("a:off", document).tap do |off|
-                          off["x"] = "0"
-                          off["y"] = "0"
-                        end
-                        xfrm << Nokogiri::XML::Node.new("a:ext", document).tap do |ext|
-                          ext["cx"] = image.width.to_s
-                          ext["cy"] = image.height.to_s
-                        end
+                    blip_fill << Nokogiri::XML::Node.new("a:stretch", document).tap do |stretch|
+                      stretch << Nokogiri::XML::Node.new("a:fillRect", document)
+                    end
+                  end
+                  pic << Nokogiri::XML::Node.new("pic:spPr", document).tap do |sp_pr|
+                    sp_pr << Nokogiri::XML::Node.new("a:xfrm", document).tap do |xfrm|
+                      xfrm << Nokogiri::XML::Node.new("a:off", document).tap do |off|
+                        off["x"] = "0"
+                        off["y"] = "0"
                       end
-                      sp_pr << Nokogiri::XML::Node.new("a:prstGeom", document).tap do |prst_geom|
-                        prst_geom["prst"] = "rect"
-                        prst_geom << Nokogiri::XML::Node.new("a:avLst", document)
+                      xfrm << Nokogiri::XML::Node.new("a:ext", document).tap do |ext|
+                        ext["cx"] = image.clamped_width(max_width_from(document))
+                        ext["cy"] = image.clamped_height(max_width_from(document))
                       end
-                      sp_pr << Nokogiri::XML::Node.new("a:effectLst", document)
+                    end
+                    sp_pr << Nokogiri::XML::Node.new("a:prstGeom", document).tap do |prst_geom|
+                      prst_geom["prst"] = "rect"
+                      prst_geom << Nokogiri::XML::Node.new("a:avLst", document)
                     end
                   end
                 end
@@ -81,6 +74,15 @@ module Consolidate
           end
         end
       end
+
+      DEFAULT_PAGE_WIDTH = 12_240
+      TWENTIETHS_OF_A_POINT_TO_EMU = 635
+      DEFAULT_PAGE_WIDTH_IN_EMU = DEFAULT_PAGE_WIDTH * TWENTIETHS_OF_A_POINT_TO_EMU
+
+      private def max_width_from document
+        page_width = (document.at_xpath("//w:sectPr/w:pgSz/@w:w")&.value || DEFAULT_PAGE_WIDTH).to_i
+        page_width * TWENTIETHS_OF_A_POINT_TO_EMU
+      end
     end
   end
 end

data/lib/consolidate/docx/merge.rb

@@ -20,13 +20,16 @@ module Consolidate
         @zip = Zip::File.open(path)
         @documents = load_documents
         @relations = load_relations
+        @contents_xml = load_and_update_contents_xml
         @output = {}
         @images = {}
+        @mapping = {}
       end
 
       # Helper method to display the contents of the document and the merge fields from the CLI
       def examine
         puts "Documents: #{document_names.join(", ")}"
+        puts "Content documents: #{content_document_names.join(", ")}"
         puts "Merge fields: #{text_field_names.join(", ")}"
         puts "Image fields: #{image_field_names.join(", ")}"
       end
@@ -38,29 +41,48 @@ module Consolidate
       def image_field_names = @image_field_names ||= tag_nodes.collect { |tag_node| image_field_names_from tag_node }.flatten.compact.uniq
 
       # List the documents stored within this docx
-      def document_names = @zip.entries.collect { |entry| entry.name }
+      def document_names = @zip.entries.map(&:name)
+
+      # List the content within this docx
+      def content_document_names = @documents.keys
+
+      # List the field names that are present in the merge data
+      def merge_field_names = @mapping.keys
 
       # Set the merge data and erform the substitution - creating copies of any documents that contain merge tags and replacing the tags with the supplied data
       def data mapping = {}
-        mapping = mapping.transform_keys(&:to_s)
-        puts mapping.keys.select { |field_name| text_field_names.include?(field_name) }.map { |field_name| "#{field_name} => #{mapping[field_name]}" }.join("\n") if verbose
+        @mapping = mapping.transform_keys(&:to_s)
+        if verbose
+          puts "...mapping data"
+          puts @mapping.keys.select { |field_name| text_field_names.include?(field_name) }.map { |field_name| "...   #{field_name} => #{@mapping[field_name]}" }.join("\n")
+        end
 
-        @images = load_images_and_link_relations_from mapping
+        @images = load_images_and_link_relations
 
         @documents.each do |name, document|
-          @output[name] = substitute(document.dup, mapping: mapping, document_name: name).serialize save_with: 0
+          @output[name] = substitute(document.dup, document_name: name).serialize save_with: 0
         end
       end
 
       def write_to path
         puts "...writing to #{path}" if verbose
         Zip::File.open(path, Zip::File::CREATE) do |out|
+          @output[contents_xml] = @contents_xml.serialize save_with: 0
+
           @images.each do |field_name, image|
-            puts "...  writing #{field_name} to #{image.storage_path}" if verbose
+            next if image.nil?
+            puts "...  writing image #{field_name} to #{image.storage_path}" if verbose
             out.get_output_stream(image.storage_path) { |o| o.write image.contents }
           end
 
-          @zip.each do |entry|
+          @relations.each do |relation_name, relations|
+            puts "...  writing relations #{relation_name}" if verbose
+            out.get_output_stream(relation_name) { |o| o.write relations }
+          end
+
+          @zip.reject do |entry|
+            @relations.key? entry.name
+          end.each do |entry|
             puts "...  writing updated document to #{entry.name}" if verbose
             out.get_output_stream(entry.name) { |o| o.write(@output[entry.name] || @relations[entry.name] || @zip.read(entry.name)) }
           end
@@ -71,25 +93,7 @@ module Consolidate
 
       attr_reader :verbose
 
-      def load_documents
-        @zip.entries.each_with_object({}) do |entry, results|
-          next unless entry.name.match?(/word\/(document|header|footer|footnotes|endnotes).?\.xml/)
-          puts "...reading document #{entry.name}" if verbose
-          contents = @zip.get_input_stream entry
-          results[entry.name] = Nokogiri::XML(contents) { |x| x.noent }
-        end
-      end
-
-      def load_relations
-        @zip.entries.each_with_object({}) do |entry, results|
-          next unless entry.name.match?(/word\/_rels\/.*.rels/)
-          puts "...reading relation #{entry.name}" if verbose
-          contents = @zip.get_input_stream entry
-          results[entry.name] = Nokogiri::XML(contents) { |x| x.noent }
-        end
-      ensure
-        @zip.close
-      end
+      def contents_xml = "[Content_Types].xml"
 
       # Regex to find merge fields that contain text
       def text_tag = /\{\{\s*(?!.*_image\b)(\S+)\s*\}\}/i
@@ -113,30 +117,61 @@ module Consolidate
       # Extract the image field name(s) from the paragraph
       def image_field_names_from(tag_node) = (matches = tag_node.content.scan(image_tag)).empty? ? nil : matches.flatten.map(&:strip)
 
+      # Unique number for each image field
+      def relation_number_for(field_name) = @mapping.keys.index(field_name) + 1000
+
       # Identifier to use when linking a merge field to the actual image file contents
       def relation_id_for(field_name) = "rId#{field_name}"
 
+      # Empty elations document for documents that do not already have one
+      def default_relations_document = %(<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>)
+
+      def load_documents
+        @zip.entries.each_with_object({}) do |entry, results|
+          next unless entry.name.match?(/word\/(document|header|footer|footnotes|endnotes).?\.xml/)
+          puts "...reading document #{entry.name}" if verbose
+          contents = @zip.get_input_stream entry
+          results[entry.name] = Nokogiri::XML(contents) { |x| x.noent }
+        end
+      end
+
+      def load_relations
+        @zip.entries.each_with_object({}) do |entry, results|
+          next unless entry.name.match?(/word\/(document|header|footer|footnotes|endnotes).?\.xml/)
+          relation_document = entry.name.gsub("word/", "word/_rels/").gsub(".xml", ".xml.rels")
+          puts "...reading or building relations for #{relation_document}" if verbose
+          contents = @zip.find_entry(relation_document) ? @zip.get_input_stream(relation_document) : default_relations_document
+          results[relation_document] = Nokogiri::XML(contents) { |x| x.noent }
+        end
+      ensure
+        @zip.close
+      end
+
       # Create relation links for each image field and store the image data
-      def load_images_and_link_relations_from mapping
-        load_images_from(mapping).tap do |images|
+      def load_images_and_link_relations
+        load_images.tap do |images|
           link_relations_to images
         end
       end
 
       # Build a mapping of image paths to the image data so that the image data can be stored in the output docx
-      def load_images_from mapping = {}
+      def load_images
         image_field_names.each_with_object({}) do |field_name, result|
-          result[field_name] = Consolidate::Docx::Image.new(mapping[field_name])
+          result[field_name] = @mapping[field_name].nil? ? nil : Consolidate::Docx::Image.new(@mapping[field_name])
+          puts "...   #{field_name} => #{result[field_name]&.media_path}" if verbose
         end
       end
 
       # Update all relation documents to include a relationship for each image field and its stored image path
       def link_relations_to images
         @relations.each do |name, xml|
+          puts "...   linking images in #{name}" if verbose
           images.each do |field_name, image|
+            # Has an actual image file been supplied?
+            next if image.nil? 
             # Is this image already referenced in this relationship document?
-            next unless xml.at_xpath("//Relationship[@Target='#{image.media_path}']").nil?
-            puts "...linking #{field_name} to #{image.media_path}" if verbose
+            next unless xml.at_xpath("//Relationship[@Target=\"#{image.media_path}\"]").nil?
+            puts "...      #{relation_id_for(field_name)} => #{image.media_path}" if verbose
             xml.root << Nokogiri::XML::Node.new("Relationship", xml).tap do |relation|
               relation["Id"] = relation_id_for(field_name)
               relation["Type"] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
@@ -146,32 +181,38 @@ module Consolidate
         end
       end
 
+      def load_and_update_contents_xml
+        puts "...reading and updating #{contents_xml}" if verbose
+        content = @zip.get_input_stream(contents_xml)
+        Nokogiri::XML(content) { |x| x.noent }.tap do |document|
+          add_content_relations_to document
+        end
+      end
+
       # Go through the given document, replacing any merge fields with the values provided
       # and storing the results in a new document
-      def substitute document, document_name:, mapping: {}
+      def substitute document, document_name:
+        puts "...substituting fields in #{document_name}" if verbose && tag_nodes_for(document).any?
+        substitute_text document, document_name: document_name
+        substitute_images document, document_name: document_name
+      end
+
+      def substitute_text document, document_name:
         tag_nodes_for(document).each do |tag_node|
-          text_field_names = text_field_names_from(tag_node) || []
-          image_field_names = image_field_names_from(tag_node) || []
+          field_names = text_field_names_from(tag_node) || []
 
           # Extract the properties (formatting) nodes if they exist
           paragraph_properties = tag_node.search ".//w:pPr"
           run_properties = tag_node.at_xpath ".//w:rPr"
 
-          # Get the current contents, then substitute any text fields, followed by any image fields
+          # Get the current contents, then substitute any text fields
           text = tag_node.content
 
-          text_field_names.each do |field_name|
-            field_value = mapping[field_name].to_s
-            puts "...substituting #{field_name} with #{field_value} in #{document_name}" if verbose
+          field_names.each do |field_name|
+            field_value = @mapping[field_name].to_s
+            puts "...   substituting '#{field_name}' with '#{field_value}'" if verbose
             text = text.gsub(tag_for(field_name), field_value)
           end
-          image_nodes = image_field_names.collect do |field_name|
-            image = @images[field_name]
-            puts "...substituting #{field_name} in #{document_name}" if verbose
-            # Remove the merge tag and create an image reference node to be added to this node
-            text = text.gsub(tag_for(field_name), "")
-            ImageReferenceNodeBuilder.new(field_name: field_name, image: image, node_id: relation_id_for(field_name), document: document).call
-          end
 
           # Create a new text node with the substituted text
           text_node = Nokogiri::XML::Node.new("w:t", tag_node.document)
@@ -182,7 +223,46 @@ module Consolidate
           run_node << run_properties unless run_properties.nil?
           run_node << text_node
           # Add the paragraph properties and the run node to the tag node
-          tag_node.children = Nokogiri::XML::NodeSet.new(document, paragraph_properties.to_a + [run_node] + image_nodes)
+          tag_node.children = Nokogiri::XML::NodeSet.new(document, paragraph_properties.to_a + [run_node])
+        rescue => ex
+          # Have to mangle the exception message otherwise it outputs the entire document
+          puts ex.message.to_s[0..255]
+          puts ex.backtrace.first
+        end
+        document
+      end
+
+      # Go through the given document, replacing any merge fields with the values provided
+      # and storing the results in a new document
+      def substitute_images document, document_name:
+        tag_nodes_for(document).each do |tag_node|
+          field_names = image_field_names_from(tag_node) || []
+          # Extract the properties (formatting) nodes if they exist
+          paragraph_properties = tag_node.search ".//w:pPr"
+          run_properties = tag_node.at_xpath ".//w:rPr"
+
+          pieces = tag_node.content.split(image_tag)
+          # Split the content into pieces - either text or an image merge field
+          # Then replace the text with text nodes or the image merge fields with drawing nodes
+          replacement_nodes = pieces.collect do |piece|
+            field_name = piece.strip
+            if field_names.include? field_name
+              image = @images[field_name]
+              # if no image was provided then insert blank text
+              # otherwise insert a w:drawing node that references the image contents
+              if image.nil? 
+                puts "...   substituting '#{field_name}' with blank as no image was provided" if verbose
+                Nokogiri::XML::Node.new("w:t", document) { |t| t.content = "" }
+              else
+                puts "...   substituting '#{field_name}' with '<#{relation_id_for(field_name)}/>'" if verbose
+                ImageReferenceNodeBuilder.new(field_name: field_name, image: image, node_id: relation_id_for(field_name), image_number: relation_number_for(field_name), document: document).call
+              end
+            else
+              Nokogiri::XML::Node.new("w:t", document) { |t| t.content = piece }
+            end
+          end
+          run_nodes = (replacement_nodes.map { |node| Nokogiri::XML::Node.new("w:r", document) { |run_node| run_node.children = node } } + [run_properties]).compact
+          tag_node.children = Nokogiri::XML::NodeSet.new(document, paragraph_properties.to_a + run_nodes)
         rescue => ex
           # Have to mangle the exception message otherwise it outputs the entire document
           puts ex.message.to_s[0..255]
@@ -190,6 +270,26 @@ module Consolidate
         end
         document
       end
+
+      CONTENT_RELATIONS = {
+        jpeg: "image/jpg",
+        png: "image/png",
+        bmp: "image/bmp",
+        gif: "image/gif",
+        tif: "image/tif",
+        pdf: "application/pdf",
+        mov: "application/movie"
+      }.freeze
+
+      def add_content_relations_to document
+        CONTENT_RELATIONS.each do |file_type, content_type|
+          next unless document.at_xpath("//Default[@Extension=\"#{file_type}\"]").nil?
+          document.root << Nokogiri::XML::Node.new("Default", document).tap do |relation|
+            relation["Extension"] = file_type
+            relation["ContentType"] = content_type
+          end
+        end
+      end
     end
   end
 end

data/lib/consolidate/image.rb

@@ -2,7 +2,7 @@
 
 module Consolidate
   class Image
-    attr_reader :name, :width, :height
+    attr_reader :name, :width, :height, :aspect_ratio, :dpi
 
     def initialize name:, width:, height:, path: nil, url: nil, contents: nil
       @name = name
@@ -11,6 +11,9 @@ module Consolidate
       @path = path
       @url = url
       @contents = contents
+      @aspect_ratio = width.to_f / height.to_f
+      #  TODO: Read this from the contents
+      @dpi = {x: 72, y: 72}
     end
 
     def to_s = name

data/lib/consolidate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Consolidate
-  VERSION = "0.3.9"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-consolidate
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.1
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-04 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -64,6 +64,8 @@ files:
 - checksums/standard-procedure-consolidate-0.3.0.gem.sha512
 - checksums/standard-procedure-consolidate-0.3.1.gem.sha512
 - checksums/standard-procedure-consolidate-0.3.9.gem.sha512
+- checksums/standard-procedure-consolidate-0.4.0.gem.sha512
+- checksums/standard-procedure-consolidate-0.4.1.gem.sha512
 - exe/consolidate
 - exe/examine
 - lib/consolidate.rb