standard-procedure-consolidate 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7a086625fa1f07169c2f9eba544538df266fbd83702efeedd13998d1a9e83b3
-  data.tar.gz: f80f0c11aa839c9dba9c4dc41758471ccfc31d7d38159e902e11d48cc8016c82
+  metadata.gz: 39e8b33a8f43ddb4a3bff6ccfb91ee9608d741dc9dff3759ea7c45b1c3cf3d3c
+  data.tar.gz: 71d357d9e60a98f199c7d67ab3f6a0b5ee8999218162fabf43a4fc4283f04a85
 SHA512:
-  metadata.gz: 72b26cbc5f54cc481ad49cbb604338591e27f1a503330372ab41920a05f3cbde4b1d6b6aa4b607b1189fbd8fd5ed30102d9741b8b6cf762c0cb39c900ac19327
-  data.tar.gz: 33ab5fbe36794cf24ca73ce70ec6da8f91cfe5430a438d5794da54bd668e72dd956331401ac983f5d15b7f77d60ef8ac6a3d438e4a0fb6279736c6dd79342931
+  metadata.gz: e68a557b00ecb43feb93cdc9a5c9a4c09edd93f8421206be3372e617809bc9ce01cb9ad4928e6f97f49b6db64fd9a329dd2ff7360d5d7b618ce455d0f080c6b1
+  data.tar.gz: 94417403770d855c0df0d1927b3de00235a668503790e06388de83cadb3b3d2b533f394fab3ddcda5ace164bbe7394810c8ad6b00092eb553552f74fabaa2e5e

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [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
+
 ## [0.3.1] - 2024-11-22
 
 Ensure that the substituted nodes are reinserted correctly into the output document, attempting to restore formatting at the paragraph level (although it does lose formatting at lower levels than this - so-called "run" nodes which represent arbitrary spans of characters within the paragraph).

data/README.md

@@ -32,7 +32,7 @@ Using the ruby library:
 
 ```ruby
 Consolidate::Docx::Merge.open "/path/to/file.docx" do |doc|
-  puts doc.field_names 
+  puts doc.text_field_names 
 
   doc.data first_name: "Alice", product: "Palm Pilot", date: "23rd January 2002", user_name: "Bob"
   doc.write_to "/path/to/merge-file.docx"
@@ -55,6 +55,27 @@ examine /path/to/file.docx verbose
 consolidate /path/to/file.docx /path/to/merge-file.docx first_name=Alice "product=Palm Pilot" "date=23rd January 2022" "user_name=Bob" verbose
 ```
 
+### Embedding images
+
+If any of the merge fields end with `_image` then it is assumed that they represent an image to be substituted into the document.  (At present this is not available on the command line).  
+
+```ruby
+Consolidate::Docx::Merge.open "/path/to/file.docx" do |doc|
+  puts doc.text_field_names 
+  puts doc.image_field_names
+
+  doc.data first_name: "Alice", product: "Palm Pilot", date: "23rd January 2002", user_name: "Bob", header_logo_image: Consolidate::Image.new(name: "logo.png", width: 1024, height: 128, path: "/path/to/logo.png"), promotion_image: Consolidate::Image.new(name: "promotion.jpg", width: 2048, height: 2048, url: "https://myshop.com/promotion.jpg"), local_image: Consolidate::Image.new(name: "local.png", width: 256, height: 256, contents: File.open("/path/to/local.png"))
+  doc.write_to "/path/to/merge-file.docx"
+end 
+```
+
+The `Consolidate::Image` can be used to provide an image in three ways:
+- via a path
+- via a URL
+- via an IO object
+
+Note - if the merge routine detects _any_ image fields within the document, it will attempt to load all image data (triggering file reads or HTTP requests) and it will embed those images into the output .docx file - even if the merge field in question is never used.  
+
 ### History
 
 Originally, this gem was intended to open a Word .docx file, find the mailmerge fields within it and then substitute new values.  

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

@@ -0,0 +1 @@
+778ec8cf89aa2d0932dd9169e3282acb810a898213efdf92b1cd50e9b8bec739142b8e50006bc8223c1a7b58b3ca86f64a9c1809ec8ce27ed7ef715d36e1b4d0

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

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

data/lib/consolidate/docx/image.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "zip"
+require "nokogiri"
+
+module Consolidate
+  module Docx
+    class Image < SimpleDelegator
+      # Path to use when referencing this image from other documents
+      def media_path = "media/#{name}"
+
+      # Path to use when storing this image within the docx
+      def storage_path = "word/#{media_path}"
+
+      # Convert width from pixels to EMU
+      def width = super * emu_per_width_pixel
+
+      # Convert height from pixels to EMU
+      def height = super * emu_per_height_pixel
+
+      # 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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "zip"
+require "nokogiri"
+
+module Consolidate
+  module Docx
+    class ImageReferenceNodeBuilder < Data.define(:field_name, :image, :node_id, :image_number, :document)
+      def call
+        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
+            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
+                  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
+                    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
+                      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
+                    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
+              end
+            end
+          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

@@ -2,69 +2,88 @@
 
 require "zip"
 require "nokogiri"
+require_relative "image_reference_node_builder"
+require_relative "image"
 
 module Consolidate
   module Docx
     class Merge
       def self.open(path, verbose: false, &block)
-        new(path, verbose: verbose, &block)
+        new(path, verbose: verbose, &block).tap do |merge|
+          block&.call merge
+        end
         path
       end
 
-      def initialize(path, verbose: false, &block)
+      def initialize(path, verbose: false)
         @verbose = verbose
-        @output = {}
         @zip = Zip::File.open(path)
         @documents = load_documents
-        block&.call self
+        @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
-        documents = document_names.join(", ")
-        fields = field_names.join(", ")
-        puts "Documents: #{documents}"
-        puts "Merge fields: #{fields}"
+        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
 
       # Read all documents within the docx and extract any merge fields
-      def field_names
-        tag_nodes.collect do |tag_node|
-          field_names_from tag_node
-        end.flatten.compact.uniq
-      end
+      def text_field_names = @text_field_names ||= tag_nodes.collect { |tag_node| text_field_names_from tag_node }.flatten.compact.uniq
+
+      # Read all documents within the docx and extract any image fields
+      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 }
-      end
+      def document_names = @zip.entries.map(&:name)
 
-      # Substitute the data from the merge fields with the values provided
-      def data mapping = {}
-        mapping = mapping.transform_keys(&:to_s)
+      # 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)
         if verbose
-          puts "...substitutions..."
-          mapping.each do |key, value|
-            puts "      #{key} => #{value}"
-          end
+          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
 
-        @documents.each do |name, document|
-          output_document = substitute document.dup, mapping: mapping, document_name: name
+        @images = load_images_and_link_relations
 
-          @output[name] = output_document.serialize save_with: 0
+        @documents.each do |name, document|
+          @output[name] = substitute(document.dup, document_name: name).serialize save_with: 0
         end
       end
 
-      # Write the new document to the given path
       def write_to path
         puts "...writing to #{path}" if verbose
         Zip::File.open(path, Zip::File::CREATE) do |out|
-          zip.each do |entry|
-            out.get_output_stream(entry.name) do |o|
-              o.write(output[entry.name] || zip.read(entry.name))
-            end
+          @output[contents_xml] = @contents_xml.serialize save_with: 0
+
+          @images.each do |field_name, image|
+            puts "...  writing image #{field_name} to #{image.storage_path}" if verbose
+            out.get_output_stream(image.storage_path) { |o| o.write image.contents }
+          end
+
+          @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
         end
       end
@@ -72,81 +91,195 @@ module Consolidate
       private
 
       attr_reader :verbose
-      attr_reader :zip
-      attr_reader :xml
-      attr_reader :documents
-      attr_accessor :output
-      TAG = /\{\{\s*(\S+)\s*\}\}/
+
+      def contents_xml = "[Content_Types].xml"
+
+      # Regex to find merge fields that contain text
+      def text_tag = /\{\{\s*(?!.*_image\b)(\S+)\s*\}\}/i
+
+      # Regex to find merge fields that contain images
+      def image_tag = /\{\{\s*(\S+_image)\s*\}\}/i
+
+      # Regex to find merge fields containing the given field name
+      def tag_for(field_name) = /\{\{\s*#{field_name}\s*\}\}/
+
+      # Find all nodes in all relevant documents that contain a merge field
+      def tag_nodes = @documents.collect { |name, document| tag_nodes_for document }.flatten
+
+      # go through all paragraph nodes of the document
+      # selecting any that contain a merge tag
+      def tag_nodes_for(document) = (document / "//w:p").select { |paragraph| paragraph.content.match(text_tag) || paragraph.content.match(image_tag) }
+
+      # Extract the text field name(s) from the paragraph
+      def text_field_names_from(tag_node) = (matches = tag_node.content.scan(text_tag)).empty? ? nil : matches.flatten.map(&:strip)
+
+      # 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#{relation_number_for(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, 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/)
-          puts "...reading #{entry.name}" if verbose
-          xml = @zip.get_input_stream entry
-          documents[entry.name] = Nokogiri::XML(xml) { |x| x.noent }
+          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
 
-      # Collect all the nodes that contain merge fields
-      def tag_nodes
-        documents.collect do |name, document|
-          tag_nodes_for document
-        end.flatten
+      # Create relation links for each image field and store the image data
+      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
+        image_field_names.each_with_object({}) do |field_name, result|
+          result[field_name] = Consolidate::Docx::Image.new(@mapping[field_name])
+          puts "...   #{field_name} => #{result[field_name].media_path}" if verbose
+        end
       end
 
-      # go through all w:t (Word Text???) nodes of the document
-      # find any nodes that contain "{{"
-      # then find the ancestor node that also includes the ending "}}"
-      # This collection of nodes contains all the merge fields for this document
-      def tag_nodes_for document
-        (document / "//w:p").select do |paragraph|
-          paragraph.content.match(TAG)
+      # 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|
+            # Is this image already referenced in this relationship document?
+            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"
+              relation["Target"] = image.media_path
+            end
+          end
         end
       end
 
-      # Extract the merge field name from the node
-      def field_names_from(tag_node)
-        matches = tag_node.content.scan(TAG)
-        matches.empty? ? nil : matches.flatten.map(&:strip)
+      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|
-          field_names = field_names_from tag_node
-          puts "Original Node for #{field_names} is #{tag_node}" if verbose
+          field_names = text_field_names_from(tag_node) || []
 
-          # Extract the paragraph properties node if it exists
+          # 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
           text = tag_node.content
+
           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
-            text = text.gsub(/{{\s*#{field_name}\s*}}/, field_value)
+            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
 
           # Create a new text node with the substituted text
           text_node = Nokogiri::XML::Node.new("w:t", tag_node.document)
           text_node.content = text
 
-          # Create a new run node to hold the substituted text and the paragraph properties
+          # Create a new run node to hold the run properties and substitute text node
           run_node = Nokogiri::XML::Node.new("w:r", tag_node.document)
-          run_node << run_properties if run_properties
+          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])
+        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"
 
-          puts "TAG NODE FOR #{field_names} IS #{tag_node}" if verbose
+          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]
+              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
+            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]
+          puts ex.backtrace.first
         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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Consolidate
+  class Image
+    attr_reader :name, :width, :height, :aspect_ratio, :dpi
+
+    def initialize name:, width:, height:, path: nil, url: nil, contents: nil
+      @name = name
+      @width = width
+      @height = height
+      @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
+
+    def contents = @contents ||= contents_from_path || contents_from_url
+
+    private def contents_from_path = @path.nil? ? nil : File.read(@path)
+
+    private def contents_from_url = @url.nil? ? nil : URI.open(@url).read # standard:disable Security/Open
+  end
+end

data/lib/consolidate/version.rb

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

data/lib/consolidate.rb

@@ -1,4 +1,5 @@
 module Consolidate
   require_relative "consolidate/version"
+  require_relative "consolidate/image"
   require_relative "consolidate/docx/merge"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-consolidate
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Rahoul Baruah
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-22 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -63,10 +63,15 @@ files:
 - checksums/standard-procedure-consolidate-0.2.0.gem.sha512
 - 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
 - exe/consolidate
 - exe/examine
 - lib/consolidate.rb
+- lib/consolidate/docx/image.rb
+- lib/consolidate/docx/image_reference_node_builder.rb
 - lib/consolidate/docx/merge.rb
+- lib/consolidate/image.rb
 - lib/consolidate/version.rb
 - sig/standard/procedure/consolidate.rbs
 - tmp/.keep
@@ -78,7 +83,7 @@ metadata:
   homepage_uri: https://github.com/standard-procedure/standard-procedure-consolidate
   source_code_uri: https://github.com/standard-procedure/standard-procedure-consolidate
   changelog_uri: https://github.com/standard-procedure/standard-procedure-consolidate/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -94,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.19
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Simple ruby mailmerge for Microsoft Word .docx files.
 test_files: []