ruby_pptx 0.1.0

data/lib/ruby_pptx/geometry.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/length"
+
+module Pptx
+  # Shared by Point and Size.
+  module Geometry
+    # A coordinate must be a Length or whole EMU; nil is not a position.
+    def self.length(value, name)
+      Length.coerce(value) || raise(ArgumentError, "#{name} is required")
+    end
+  end
+
+  # A position on a slide.
+  #
+  #   Pptx.point(Pptx.inches(1), Pptx.inches(2))
+  #   slide.shapes.add_shape(:rectangle, at: origin + offset, size: box)
+  #
+  # Anywhere this library takes `at:` it has always taken a two-element array,
+  # and it still does. A Point defines `to_ary`, so it destructures exactly as
+  # that array did -- passing one costs nothing and buys named readers,
+  # arithmetic and pattern matching:
+  #
+  #   case shape.position
+  #   in {x:, y:} if x > Pptx.inches(5) then :right_half
+  #   end
+  #
+  # Coordinates are normalised to {Pptx::Length}, so a bare number means EMU,
+  # the same as it does in the array form.
+  Point = Data.define(:x, :y) do
+    # Build from a Point or a two-element array, so callers can accept either.
+    def self.from(value)
+      value.is_a?(Point) ? value : new(*value)
+    end
+
+    def initialize(x:, y:)
+      super(x: Geometry.length(x, :x), y: Geometry.length(y, :y))
+    end
+
+    # Destructuring and splatting, which is what lets a Point stand in for the
+    # `[x, y]` array everywhere this library already unpacks one.
+    def to_ary = [x, y]
+
+    def +(other)
+      other = Point.from(other)
+      Point.new(x: x + other.x, y: y + other.y)
+    end
+
+    def -(other)
+      other = Point.from(other)
+      Point.new(x: x - other.x, y: y - other.y)
+    end
+
+    def to_s = "(#{x.inches.round(3)}in, #{y.inches.round(3)}in)"
+    def inspect = "#<Pptx::Point #{self}>"
+  end
+
+  # The extent of a shape: a width and a height.
+  #
+  # As with {Point}, this stands in for the `[width, height]` array that `size:`
+  # has always taken.
+  Size = Data.define(:width, :height) do
+    def self.from(value)
+      value.is_a?(Size) ? value : new(*value)
+    end
+
+    def initialize(width:, height:)
+      super(width: Geometry.length(width, :width), height: Geometry.length(height, :height))
+    end
+
+    def to_ary = [width, height]
+
+    # Scale both extents, for `size * 2` or `size * 0.5`.
+    def *(factor) = Size.new(width: width * factor, height: height * factor)
+
+    def aspect_ratio = width.emu.to_f / height.emu
+
+    def to_s = "#{width.inches.round(3)}in x #{height.inches.round(3)}in"
+    def inspect = "#<Pptx::Size #{self}>"
+  end
+
+  class << self
+    # @return [Pptx::Point]
+    def point(x, y) = Point.new(x: x, y: y)
+
+    # @return [Pptx::Size]
+    def size(width, height) = Size.new(width: width, height: height)
+  end
+end

data/lib/ruby_pptx/image.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require "digest"
+require "stringio"
+require "ruby_pptx/errors"
+require "ruby_pptx/length"
+require "ruby_pptx/opc/constants"
+
+module Pptx
+  # An image, as a value object over its bytes.
+  #
+  # Format, pixel size and resolution are read straight from the file header.
+  # python-pptx uses Pillow for this; a handful of header formats is a much
+  # smaller thing to carry than an image library, and the specs check the
+  # results against Pillow for every supported format.
+  class Image
+    # Canonical extension per format. The extension of the file the image came
+    # from is ignored: what matters is what the bytes actually are.
+    EXT_FOR_FORMAT = {
+      BMP: "bmp", GIF: "gif", JPEG: "jpg", PNG: "png", TIFF: "tiff", WMF: "wmf",
+      EMF: "emf", SVG: "svg"
+    }.freeze
+
+    # Not in the OPC spec's table; Office writes this for an SVG part.
+    CONTENT_TYPE_SVG = "image/svg+xml"
+
+    CONTENT_TYPE_FOR_EXT = {
+      "bmp" => Opc::CONTENT_TYPE::BMP,
+      "emf" => Opc::CONTENT_TYPE::X_EMF,
+      "gif" => Opc::CONTENT_TYPE::GIF,
+      "jpe" => Opc::CONTENT_TYPE::JPEG,
+      "jpeg" => Opc::CONTENT_TYPE::JPEG,
+      "jpg" => Opc::CONTENT_TYPE::JPEG,
+      "png" => Opc::CONTENT_TYPE::PNG,
+      "tif" => Opc::CONTENT_TYPE::TIFF,
+      "tiff" => Opc::CONTENT_TYPE::TIFF,
+      "wdp" => Opc::CONTENT_TYPE::MS_PHOTO,
+      "wmf" => Opc::CONTENT_TYPE::X_WMF,
+      "svg" => CONTENT_TYPE_SVG
+    }.freeze
+
+    # Resolution assumed when the file does not say.
+    DEFAULT_DPI = 72
+
+    # A dpi outside this range is not believable and is replaced by the default.
+    DPI_RANGE = (1..2048)
+
+    EMU_PER_INCH = 914_400
+
+    attr_reader :blob, :filename
+
+    class << self
+      def from_blob(blob, filename = nil) = new(blob, filename)
+
+      # Load from a path or an IO stream.
+      def from_file(image_file)
+        if image_file.is_a?(String)
+          new(File.binread(image_file), File.basename(image_file))
+        else
+          image_file.rewind if image_file.respond_to?(:rewind)
+          new(image_file.read, nil)
+        end
+      end
+    end
+
+    def initialize(blob, filename = nil)
+      @blob = blob
+      @filename = filename
+    end
+
+    # @return [Symbol] :PNG, :JPEG, :GIF, :BMP, :TIFF or :WMF
+    def format = header.fetch(:format)
+
+    # True for a vector image, which has no pixel size of its own and needs a
+    # raster fallback to be placed in a slide.
+    def vector? = format == :SVG
+
+    # @return [Array(Integer, Integer)] width and height in pixels
+    def size = [header.fetch(:width), header.fetch(:height)]
+
+    def width_px = header.fetch(:width)
+
+    def height_px = header.fetch(:height)
+
+    # @return [Array(Integer, Integer)] horizontal and vertical dots per inch
+    def dpi
+      [normalize_dpi(header[:horz_dpi]), normalize_dpi(header[:vert_dpi])]
+    end
+
+    # The canonical extension for this image's actual format.
+    def ext
+      EXT_FOR_FORMAT.fetch(format) do
+        raise Error, "unsupported image format #{format}"
+      end
+    end
+
+    def content_type = CONTENT_TYPE_FOR_EXT.fetch(ext)
+
+    def sha1 = @sha1 ||= Digest::SHA1.hexdigest(@blob)
+
+    # Native size in EMU, derived from the pixel size and resolution.
+    #
+    # @return [Array(Pptx::Length, Pptx::Length)]
+    def native_size
+      raise Error, "an SVG has no native pixel size; size it from its raster fallback" if vector?
+
+      horz_dpi, vert_dpi = dpi
+      [Length.emu((EMU_PER_INCH * width_px / horz_dpi).to_i),
+       Length.emu((EMU_PER_INCH * height_px / vert_dpi).to_i)]
+    end
+
+    def inspect = "#<Pptx::Image #{format} #{width_px}x#{height_px} #{dpi.join("x")}dpi>"
+
+    private
+
+    def normalize_dpi(value)
+      return DEFAULT_DPI if value.nil?
+
+      rounded = Float(value).round
+      DPI_RANGE.cover?(rounded) ? rounded : DEFAULT_DPI
+    rescue ArgumentError, TypeError
+      DEFAULT_DPI
+    end
+
+    def header
+      @header ||= ImageHeader.parse(@blob)
+    end
+  end
+
+  # Reads format, pixel dimensions and resolution out of an image file header.
+  module ImageHeader
+    PNG_SIGNATURE = "\x89PNG\r\n\x1a\n".b
+    # A pHYs chunk gives pixels per unit; unit 1 is the metre.
+    METRES_PER_INCH = 0.0254
+
+    module_function
+
+    # @return [Hash] {format:, width:, height:, horz_dpi:, vert_dpi:}
+    def parse(blob)
+      blob = blob.b
+      return parse_png(blob) if blob.start_with?(PNG_SIGNATURE)
+      return parse_jpeg(blob) if blob.start_with?("\xFF\xD8".b)
+      return parse_gif(blob) if blob.start_with?("GIF87a".b, "GIF89a".b)
+      return parse_bmp(blob) if blob.start_with?("BM".b)
+      return parse_tiff(blob) if blob.start_with?("II*\x00".b, "MM\x00*".b)
+      return { format: :WMF, width: 0, height: 0 } if blob.start_with?("\xD7\xCD\xC6\x9A".b)
+      return parse_emf(blob) if emf?(blob)
+      return { format: :SVG } if svg?(blob)
+
+      raise Error, "unrecognized image format"
+    end
+
+    # An EMF begins with its header record, type 1, and carries the signature
+    # " EMF" 40 bytes in.
+    #
+    # python-pptx asks Pillow, which reports EMF and WMF alike as "WMF", and so
+    # stores an EMF as `imageN.wmf` with the WMF content type. This names it
+    # for what it is, as PowerPoint does; see PORTING.md.
+    def emf?(blob)
+      blob.bytesize >= 88 && blob.byteslice(0, 4).unpack1("V") == 1 && blob.byteslice(40, 4) == " EMF".b
+    end
+
+    # Size from the header's bounds in device pixels; resolution from how
+    # those pixels relate to the frame, which is in hundredths of a
+    # millimetre. Pillow reads it the same way.
+    def parse_emf(blob)
+      left, top, right, bottom = blob.byteslice(8, 16).unpack("l<4")
+      frame_left, frame_top, frame_right, frame_bottom = blob.byteslice(24, 16).unpack("l<4")
+      width = right - left
+      height = bottom - top
+      { format: :EMF, width: width, height: height,
+        horz_dpi: (width * 2540.0 / (frame_right - frame_left)).round,
+        vert_dpi: (height * 2540.0 / (frame_bottom - frame_top)).round }
+    end
+
+    # An SVG is XML, so it is recognized by its root element rather than by a
+    # magic number. Only the first kilobyte is searched, which covers any
+    # plausible declaration, comment or doctype preamble.
+    def svg?(blob)
+      head = blob.byteslice(0, 1024)
+      head.include?("<svg".b) || (head.include?("<?xml".b) && blob.include?("<svg".b))
+    end
+
+    # PNG is a signature followed by length-prefixed chunks. IHDR carries the
+    # dimensions and is always first; pHYs, if present, carries resolution.
+    def parse_png(blob)
+      result = { format: :PNG }
+      offset = PNG_SIGNATURE.bytesize
+
+      while offset + 8 <= blob.bytesize
+        length = blob.byteslice(offset, 4).unpack1("N")
+        type = blob.byteslice(offset + 4, 4)
+        data = blob.byteslice(offset + 8, length)
+        break if data.nil?
+
+        case type
+        when "IHDR"
+          result[:width], result[:height] = data.unpack("NN")
+        when "pHYs"
+          ppu_x, ppu_y, unit = data.unpack("NNC")
+          if unit == 1
+            result[:horz_dpi] = ppu_x * METRES_PER_INCH
+            result[:vert_dpi] = ppu_y * METRES_PER_INCH
+          end
+        when "IEND"
+          break
+        end
+        offset += 12 + length
+      end
+      result
+    end
+
+    # JPEG is a stream of marker segments. SOFn carries the dimensions; the
+    # JFIF APP0 segment, when present, carries the resolution.
+    def parse_jpeg(blob)
+      result = { format: :JPEG }
+      offset = 2
+
+      while offset + 4 <= blob.bytesize
+        # Markers may be preceded by any number of 0xFF fill bytes.
+        offset += 1 while offset < blob.bytesize && blob.getbyte(offset) == 0xFF
+        marker = blob.getbyte(offset)
+        offset += 1
+        break if marker.nil?
+        # Standalone markers carry no payload.
+        next if (0xD0..0xD9).cover?(marker) || marker == 0x01
+
+        length = blob.byteslice(offset, 2)&.unpack1("n")
+        break if length.nil? || length < 2
+
+        segment = blob.byteslice(offset + 2, length - 2)
+
+        if sof?(marker) && segment && segment.bytesize >= 5
+          _precision, height, width = segment.unpack("Cnn")
+          result[:height] = height
+          result[:width] = width
+        elsif marker == 0xE0 && segment&.start_with?("JFIF\x00".b)
+          apply_jfif_density(result, segment)
+        end
+
+        break if marker == 0xDA # start of scan; image data follows
+
+        offset += length
+      end
+      result
+    end
+
+    # SOF0..SOF15, excluding DHT (C4), JPG (C8) and DAC (CC), which share the
+    # numeric range but are not frame headers.
+    def sof?(marker)
+      (0xC0..0xCF).cover?(marker) && ![0xC4, 0xC8, 0xCC].include?(marker)
+    end
+
+    def apply_jfif_density(result, segment)
+      units, x_density, y_density = segment.byteslice(7, 5).unpack("Cnn")
+      case units
+      when 1 # dots per inch
+        result[:horz_dpi] = x_density
+        result[:vert_dpi] = y_density
+      when 2 # dots per centimetre
+        result[:horz_dpi] = x_density * 2.54
+        result[:vert_dpi] = y_density * 2.54
+      end
+    end
+
+    # GIF carries its dimensions in the logical screen descriptor and has no
+    # notion of resolution.
+    def parse_gif(blob)
+      width, height = blob.byteslice(6, 4).unpack("vv")
+      { format: :GIF, width: width, height: height }
+    end
+
+    # BMP keeps dimensions and pixels-per-metre in its DIB header. Note that
+    # writers generally fill in 3780 ppm rather than leaving it zero, so a BMP
+    # usually reports about 96 dpi rather than the 72 default.
+    def parse_bmp(blob)
+      width, height = blob.byteslice(18, 8).unpack("l<l<")
+      ppm_x, ppm_y = blob.byteslice(38, 8).unpack("l<l<")
+      result = { format: :BMP, width: width, height: height.abs }
+      if ppm_x&.positive? && ppm_y&.positive?
+        result[:horz_dpi] = ppm_x * METRES_PER_INCH
+        result[:vert_dpi] = ppm_y * METRES_PER_INCH
+      end
+      result
+    end
+
+    TIFF_TAGS = { width: 256, height: 257, x_res: 282, y_res: 283, res_unit: 296 }.freeze
+
+    # TIFF stores everything in tagged IFD entries, in either byte order.
+    def parse_tiff(blob)
+      little_endian = blob.start_with?("II".b)
+      long = little_endian ? "V" : "N"
+      short = little_endian ? "v" : "n"
+
+      ifd_offset = blob.byteslice(4, 4).unpack1(long)
+      entry_count = blob.byteslice(ifd_offset, 2).unpack1(short)
+      values = {}
+
+      entry_count.times do |i|
+        entry = blob.byteslice(ifd_offset + 2 + (i * 12), 12)
+        break if entry.nil? || entry.bytesize < 12
+
+        tag = entry.byteslice(0, 2).unpack1(short)
+        type = entry.byteslice(2, 2).unpack1(short)
+        values[tag] = tiff_value(blob, entry, type, long, short)
+      end
+
+      result = {
+        format: :TIFF,
+        width: values[TIFF_TAGS[:width]],
+        height: values[TIFF_TAGS[:height]]
+      }
+      apply_tiff_resolution(result, values)
+      result
+    end
+
+    # A value of four bytes or fewer is stored inline; anything larger, such as
+    # the two longs of a RATIONAL, is stored at an offset.
+    def tiff_value(blob, entry, type, long, short)
+      payload = entry.byteslice(8, 4)
+      case type
+      when 3 then payload.unpack1(short)      # SHORT
+      when 4 then payload.unpack1(long)       # LONG
+      when 5 # RATIONAL
+        offset = payload.unpack1(long)
+        numerator, denominator = blob.byteslice(offset, 8).unpack("#{long}#{long}")
+        denominator.to_i.zero? ? nil : numerator.to_f / denominator
+      end
+    end
+
+    def apply_tiff_resolution(result, values)
+      unit = values[TIFF_TAGS[:res_unit]] || 2
+      x_res = values[TIFF_TAGS[:x_res]]
+      y_res = values[TIFF_TAGS[:y_res]]
+      return if x_res.nil? || y_res.nil?
+
+      case unit
+      when 2 # inch
+        result[:horz_dpi] = x_res
+        result[:vert_dpi] = y_res
+      when 3 # centimetre
+        result[:horz_dpi] = x_res * 2.54
+        result[:vert_dpi] = y_res * 2.54
+      end
+    end
+  end
+end

data/lib/ruby_pptx/length.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/pattern_matching"
+
+module Pptx
+  # A distance, stored canonically in English Metric Units (EMU).
+  #
+  # OOXML expresses nearly every distance in EMU, an integer unit chosen so that
+  # inches, centimetres and points all divide it evenly. `Length` keeps that
+  # integer as the single source of truth and converts on the way out.
+  #
+  #   Pptx::Length.inches(1).emu  #=> 914400
+  #   Pptx::Length.cm(2.54).pt    #=> 72.0
+  #
+  # Instances are immutable, `Comparable`, and compare against bare Integers as
+  # EMU, so `Pptx::Length.inches(1) == 914_400` holds.
+  class Length
+    include Comparable
+    include PatternMatching
+
+    # `in {inches:}` converts on demand, so a pattern can ask in whatever unit
+    # reads best at the point of use.
+    pattern_keys :emu, :inches, :cm, :mm, :pt, :centipoints
+
+    EMUS_PER_INCH       = 914_400
+    EMUS_PER_CENTIPOINT = 127
+    EMUS_PER_CM         = 360_000
+    EMUS_PER_MM         = 36_000
+    EMUS_PER_PT         = 12_700
+
+    class << self
+      # @param emu [Integer] distance in English Metric Units
+      def emu(emu) = new(emu)
+
+      def inches(inches) = new((inches * EMUS_PER_INCH).to_i)
+      def cm(cm)         = new((cm * EMUS_PER_CM).to_i)
+      def mm(mm)         = new((mm * EMUS_PER_MM).to_i)
+      def pt(points)     = new((points * EMUS_PER_PT).to_i)
+
+      # Hundredths of a point (1/7200 inch); the unit PowerPoint stores font
+      # sizes in.
+      def centipoints(centipoints) = new((centipoints * EMUS_PER_CENTIPOINT).to_i)
+
+      # Coerce +value+ to a Length, treating a bare Integer as EMU.
+      #
+      # @return [Length, nil] nil when +value+ is nil
+      def coerce(value)
+        case value
+        when nil     then nil
+        when Length  then value
+        when Integer then new(value)
+        else
+          raise TypeError, "expected Pptx::Length or Integer (EMU), got #{value.class}"
+        end
+      end
+    end
+
+    # @return [Integer] the distance in English Metric Units
+    attr_reader :emu
+
+    def initialize(emu)
+      @emu = Integer(emu)
+      freeze
+    end
+
+    def inches = @emu / EMUS_PER_INCH.to_f
+    def cm     = @emu / EMUS_PER_CM.to_f
+    def mm     = @emu / EMUS_PER_MM.to_f
+    def pt     = @emu / EMUS_PER_PT.to_f
+
+    # @return [Integer] whole hundredths of a point, rounded toward negative infinity
+    def centipoints = @emu / EMUS_PER_CENTIPOINT
+
+    def to_i = @emu
+    alias to_int to_i
+
+    def +(other) = Length.new(@emu + Length.coerce(other).emu)
+    def -(other) = Length.new(@emu - Length.coerce(other).emu)
+    def -@ = Length.new(-@emu)
+
+    # Scaling by a plain number; `length * 2` is twice as long.
+    def *(factor) = Length.new((@emu * factor).to_i)
+
+    # Deliberately no #coerce, so `2 * length` raises rather than working.
+    #
+    # Ruby's coerce protocol cannot see which operator is being applied, so the
+    # pair it returns has to be right for all of them. Returning [self, other]
+    # would make `2 * length` correct but silently turn `2 - length` into
+    # `length - 2` -- the wrong sign. A TypeError the caller can fix by writing
+    # `length * 2` beats an answer that is quietly negative.
+
+    def <=>(other)
+      other = Length.coerce(other) if other.is_a?(Integer)
+      return nil unless other.is_a?(Length)
+
+      @emu <=> other.emu
+    end
+
+    def ==(other) = (self <=> other)&.zero? || false
+    alias eql? ==
+
+    def hash = @emu.hash
+
+    def zero? = @emu.zero?
+
+    def to_s = "#{@emu}emu"
+
+    def inspect = "#<Pptx::Length #{@emu}emu (#{format("%g", inches)}in)>"
+  end
+
+  class << self
+    # Convenience constructors, e.g. `Pptx.inches(1.5)`.
+    def emu(v)         = Length.emu(v)
+    def inches(v)      = Length.inches(v)
+    def cm(v)          = Length.cm(v)
+    def mm(v)          = Length.mm(v)
+    def pt(v)          = Length.pt(v)
+    def centipoints(v) = Length.centipoints(v)
+  end
+end

data/lib/ruby_pptx/media.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "digest"
+require "ruby_pptx/opc/constants"
+
+module Pptx
+  # A video, as a value object over its bytes.
+  #
+  # Unlike an image, a video is not interrogated for its type: the caller says
+  # what it is. Reading container formats to find out would be a project of its
+  # own, and PowerPoint only needs the MIME type recorded correctly.
+  class Video
+    # What PowerPoint accepts when the type is not known. It plays anyway in
+    # practice, which is why python-pptx defaults to it.
+    UNKNOWN_CONTENT_TYPE = Opc::CONTENT_TYPE::VIDEO
+
+    EXT_FOR_CONTENT_TYPE = {
+      Opc::CONTENT_TYPE::ASF => "asf",
+      Opc::CONTENT_TYPE::AVI => "avi",
+      Opc::CONTENT_TYPE::MOV => "mov",
+      Opc::CONTENT_TYPE::MP4 => "mp4",
+      Opc::CONTENT_TYPE::MPG => "mpg",
+      Opc::CONTENT_TYPE::MS_VIDEO => "avi",
+      Opc::CONTENT_TYPE::SWF => "swf",
+      Opc::CONTENT_TYPE::WMV => "wmv",
+      Opc::CONTENT_TYPE::X_MS_VIDEO => "avi"
+    }.freeze
+
+    attr_reader :blob, :content_type
+
+    def self.from_blob(blob, content_type, filename = nil) = new(blob, content_type, filename)
+
+    # Load from a path or an IO stream.
+    def self.from_file(movie_file, content_type)
+      if movie_file.is_a?(String)
+        new(File.binread(movie_file), content_type, File.basename(movie_file))
+      else
+        movie_file.rewind if movie_file.respond_to?(:rewind)
+        new(movie_file.read, content_type, nil)
+      end
+    end
+
+    def initialize(blob, content_type, filename = nil)
+      @blob = blob
+      @content_type = content_type || UNKNOWN_CONTENT_TYPE
+      @source_filename = filename
+    end
+
+    # The extension for the media part: taken from the original filename when
+    # there is one, otherwise derived from the MIME type.
+    def ext
+      return File.extname(@source_filename).delete_prefix(".") if @source_filename
+
+      EXT_FOR_CONTENT_TYPE.fetch(@content_type, "vid")
+    end
+
+    # The name PowerPoint shows for the shape.
+    def filename = @source_filename || "movie.#{ext}"
+
+    def sha1 = @sha1 ||= Digest::SHA1.hexdigest(@blob)
+
+    def inspect = "#<Pptx::Video #{filename} #{@content_type}>"
+  end
+end

data/lib/ruby_pptx/numeric_lengths.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/length"
+
+module Pptx
+  # Numeric sugar: `1.inch`, `2.5.cm`, `18.pt`.
+  #
+  # This module only defines the methods. Two files decide how they reach
+  # Numeric, and they are the whole choice on offer:
+  #
+  #   require "ruby_pptx/refinements"   # then `using Pptx::Lengths` -- this file only
+  #   require "ruby_pptx/core_ext"      # Numeric gains them everywhere, process-wide
+  #
+  # Prefer the refinement. It is scoped to the file that asks for it, so it
+  # cannot surprise another library that happens to share the process.
+  module NumericLengths
+    def emu         = Pptx::Length.emu(self)
+    def inches      = Pptx::Length.inches(self)
+    def cm          = Pptx::Length.cm(self)
+    def mm          = Pptx::Length.mm(self)
+    def pt          = Pptx::Length.pt(self)
+    def centipoints = Pptx::Length.centipoints(self)
+
+    # Spelled out rather than aliased: `import_methods`, which the refinement
+    # uses to share these, cannot carry an alias across.
+    def inch   = inches
+    def points = pt
+    def point  = pt
+  end
+end