distorted-floor 0.7.0

data/lib/distorted-floor/media_molecule/text.rb

@@ -0,0 +1,247 @@
+require 'set'
+
+require 'ffi-icu'  # Text file charset detection
+
+require 'distorted-floor/monkey_business/encoding'
+require 'distorted-floor/monkey_business/string'  # String#map
+require 'distorted-floor/modular_technology/pango'
+require 'distorted-floor/modular_technology/ttfunk'
+require 'distorted-floor/modular_technology/vips/save'
+
+require 'distorted-floor/checking_you_out'
+using ::DistorteD::CHECKING::YOU::OUT
+
+
+module Cooltrainer; end
+module Cooltrainer::DistorteD; end
+module Cooltrainer::DistorteD::Molecule; end
+module Cooltrainer::DistorteD::Molecule::Text
+
+  #TODO: Generate separate images per-size to stop text being blurry from resizing.
+
+  include Cooltrainer::DistorteD::Technology::TTFunk
+  include Cooltrainer::DistorteD::Technology::Pango
+  include Cooltrainer::DistorteD::Technology::Vips::Save
+
+  # Track supported fonts by codepage.
+  # Avoid renaming these from the original archives / websites.
+  # Try not to go nuts here bloating the size of our Gem for a
+  # very niche feature, but I want to ensure good coverage too.
+  #
+  # Treat codepage 8859 documents as codepage 1252 to avoid breaking smart-
+  # quotes and other printable chars in 1252 that are control chars in 8859.
+  # https://encoding.spec.whatwg.org/#names-and-labels
+  #
+  # Numeric key for UTF-8 is codepage 65001 like Win32:
+  # https://docs.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
+  FONT_FILENAME = {
+    :anonpro => 'Anonymous Pro.ttf'.freeze,
+    :anonpro_b => 'Anonymous Pro B.ttf'.freeze,
+    :anonpro_bi => 'Anonymous Pro BI.ttf'.freeze,
+    :anonpro_i => 'Anonymous Pro I.ttf'.freeze,
+    :lessperfectdosvga => 'LessPerfectDOSVGA.ttf'.freeze,
+    :moreperfectdisvga => 'MorePerfectDOSVGA.ttf'.freeze,
+    :perfectdosvgawin => 'Perfect DOS VGA 437 Win.ttf'.freeze,
+    :mona => 'mona.ttf'.freeze,
+    :perfectdosvga => 'Perfect DOS VGA 437.ttf'.freeze,
+    :profont => 'ProFontWindows.ttf'.freeze,
+    :profont_b => 'ProFontWindows-Bold.ttf'.freeze,
+  }
+  # Certain fonts are more suitable for certain codepages,
+  # so track each codepage's available fonts…
+  CODEPAGE_FONT = {
+    65001 => [
+      :anonpro,
+      :anonpro_b,
+      :anonpro_bi,
+      :anonpro_i,
+    ],
+    1252 => [
+      :lessperfectdosvga,
+      :moreperfectdosvga,
+      :perfectdosvgawin,
+    ],
+    932 => [
+      :mona,
+    ],
+    850 => [
+      :profont,
+      :profont_b,
+    ],
+    437 => [
+      :perfectdosvga,
+    ],
+  }
+  # TODO: Figure out what to do here. ProFont isn't suitable for many (most?) Encodings,
+  # but the gem would be way way too big if I tried to include coverage for everything.
+  # Using system fonts is probably the solution, but I need to be able to get a path to them for VIPS.
+  CODEPAGE_FONT.default = Array[:profont, :profont_b]
+  # …as well as the inverse, the numeric codepage for each font:
+  FONT_CODEPAGE = self::CODEPAGE_FONT.each_with_object(Hash.new([])) { |(key, values), memo|
+    values.each { |value| memo[value] = key }
+  }
+
+
+  LOWER_WORLD = {
+    ::CHECKING::YOU::OUT::from_ietf_media_type('text/plain') => nil,
+    ::CHECKING::YOU::OUT::from_ietf_media_type('text/x-nfo') => nil,
+  }.transform_values { |v| Hash[
+    :encoding => Cooltrainer::Compound.new(:encoding, valid: Encoding, blurb: 'Character encoding used in this document. (default: automatically detect)', default: nil),
+  ]}
+  OUTER_LIMITS = {
+    ::CHECKING::YOU::OUT::from_ietf_media_type('text/plain') => nil,
+    ::CHECKING::YOU::OUT::from_ietf_media_type('text/x-nfo') => nil,
+  }.merge(
+    Cooltrainer::DistorteD::Technology::Vips::Save::OUTER_LIMITS.dup.transform_values{ |v| Hash[
+      :spacing => Cooltrainer::Compound.new(:spacing, blurb: 'Document-wide character spacing style.', valid: Set[:monospace, :proportional]),
+      :dpi => Cooltrainer::Compound.new(:dpi, blurb: 'Dots per inch for text rendering.', valid: Integer, default: 144),
+      :font => Cooltrainer::Compound.new(:font, blurb: 'Font to use for text rendering.', valid: self::FONT_FILENAME.keys.to_set),
+    ]}
+  )
+
+  self::LOWER_WORLD.keys.each { |t|
+    define_method(t.distorted_file_method) { |dest_root, change|
+      p change.paths(dest_root)
+      copy_file(change.paths(dest_root).first)
+    }
+  }
+
+
+  # Return a Pango Markup escaped version of the document.
+  def to_pango
+    # https://developer.gnome.org/glib/stable/glib-Simple-XML-Subset-Parser.html#g-markup-escape-text
+    escaped = text_file_utf8_content.map{ |c|
+      g_markup_escape_char(c)
+    }
+    if font_spacing == :monospace
+      "<tt>" << escaped << "</tt>"
+    else
+      escaped
+    end
+  end
+
+  protected
+
+  # Returns a boolean guess of whether our document uses box-drawing characters of a given Encoding.
+  def oobe?(encoding)
+    # Re-interpret our raw source file's bytes as the given Encoding,
+    # then take the codepoints seven at a time and see if any of those
+    # septagrams consist of all box-drawing characters of our given Encoding.
+    text_file_content.force_encoding(encoding).each_codepoint.each_cons(7).map{ |septagram|
+      septagram.uniq.length == 1 and Encoding::OOBE.fetch(encoding, nil)&.include?(septagram.first)
+    }.select(&TrueClass.method(:===)).length >= 1
+  end
+
+  def text_file_content
+    # VIPS makes us provide the text content as a single variable,
+    # so we may as well just one-shot File.read() it into memory.
+    # https://kunststube.net/encoding/
+    @text_file_content ||= File.read(path)
+  end
+
+  def text_file_utf8_content
+    # https://ruby-doc.org/core/Encoding/Converter.html#method-c-new
+    @text_file_utf8_content ||= text_file_encoding == Encoding::UTF_8 ?
+      text_file_content :
+      Encoding::Converter.new(
+        text_file_encoding,
+        Encoding::UTF_8,
+        undef: :replace,
+        invalid: :replace,
+      ).convert(text_file_content)
+  end
+
+  def text_file_encoding
+    # It's not easy or even possible in some cases to tell the "true" codepage
+    # we should use for any given text document, but using character detection
+    # is worth a shot if the user gave us nothing.
+    #
+    # FFI-ICU::CharDet returns a Struct, e.g.:
+    #   #<struct ICU::CharDet::Detector::Match name="ISO-8859-1", confidence=19, language="en">
+    @text_file_encoding ||= begin
+      Encoding::find(ICU::CharDet.detect(text_file_content).name).yield_self { |detected|
+        # Fix files with ASCII/ANSI art (like NFOs) from being detected as ISO-8859-1
+        # when they should be IBM437 to display properly.
+        [
+          type_mars.include?(::CHECKING::YOU::OUT::from_ietf_media_type('text/x-nfo')),  # Only certain souce file types.
+          detected == Encoding::ISO_8859_1,  # Only if ICU detects ISO-8859-1.
+          oobe?(Encoding::IBM437),  # Does this look like IBM437 based on box-drawing characters?
+        ].all? ? Encoding::IBM437 : detected
+      }
+    rescue ArgumentError
+      # Raised by Encoding::find if we give it an unknown Encoding name.
+      Encoding::UTF_8
+    end
+  end
+
+  def vips_font
+    # Set the shorthand Symbol key for our chosen font.
+    CODEPAGE_FONT[text_file_encoding&.code_page].first
+  end
+
+  def to_vips_image(change)
+    # Load font metadata directly from the file so we don't have to
+    # duplicate it here to feed to Vips/Pango.
+    #
+    # irb(main)> font_meta.name.font_name
+    # => ["Perfect DOS VGA 437", "\x00P\x00e\x00r\x00f\x00e\x00c\x00t\x00 \x00D\x00O\x00S\x00 \x00V\x00G\x00A\x00 \x004\x003\x007"]
+    # irb(main)> font_meta.name.font_family
+    # => ["Perfect DOS VGA 437", "\x00P\x00e\x00r\x00f\x00e\x00c\x00t\x00 \x00D\x00O\x00S\x00 \x00V\x00G\x00A\x00 \x004\x003\x007"]
+    # irb(main)> font_meta.name.font_subfamily
+    # => ["Regular", "\x00R\x00e\x00g\x00u\x00l\x00a\x00r"]
+    # irb(main)> font_meta.name.postscript_name
+    # => "PerfectDOSVGA437"
+    # irb(main)> font_meta.line_gap
+    # => 0
+
+    # It would be gross to pass this through so many methods in this mostly-untouched-since-0.5 code,
+    # so just stick these directly into the instance variables used for memoization.
+    unless change.encoding.nil?
+      # TODO: Turning the String arguments into an Encoding should be a centralized thing
+      # of some sort, probably in Cooltrainer::Compound.
+      @text_file_encoding = change.encoding.is_a?(Encoding) ? change.encoding : Encoding::find(change.encoding)
+    end
+
+    # https://libvips.github.io/libvips/API/current/libvips-create.html#vips-text
+    Vips::Image.text(
+      # This string must be well-escaped Pango Markup:
+      # https://developer.gnome.org/pango/stable/pango-Markup.html
+      # However the official function for escaping text is
+      # not implemented in Ruby GLib, so we have to do it ourselves.
+      to_pango,
+      **{
+        # String absolute path to TTF
+        :fontfile => font_path,
+        # It's not enough to just specify the TTF path;
+        # we must also specify a font family, subfamily, and size.
+        :font => "#{font_name} 16",
+        # Space between lines (in Points).
+        :spacing => to_ttfunk.line_gap,
+        :justify => true,  # Requires libvips 8.8
+        :dpi => change.dpi&.to_i,
+      },
+    )
+  end
+
+  # Return the String absolute path to the TTF file
+  def font_path
+    File.join(
+      Cooltrainer::DistorteD::GEM_ROOT,  # DistorteD-Floor
+      'font'.freeze,
+      font_codepage.to_s,
+      font_filename,
+    )
+  end
+
+  # Returns the numeric representation of the codepage
+  # covered by our font.
+  def font_codepage
+    FONT_CODEPAGE.dig(vips_font).to_s
+  end
+
+  # Returns the basename (with file extension) of our font.
+  def font_filename
+    FONT_FILENAME.dig(vips_font)
+  end
+
+end  # Text

data/lib/distorted-floor/media_molecule/video.rb

@@ -0,0 +1,21 @@
+require 'set'
+require 'distorted-floor/monkey_business/set'
+
+require 'distorted-floor/checking_you_out'
+using ::DistorteD::CHECKING::YOU::OUT
+
+require 'distorted-floor/modular_technology/gstreamer'
+
+
+module Cooltrainer; end
+module Cooltrainer::DistorteD; end
+module Cooltrainer::DistorteD::Molecule; end
+module Cooltrainer::DistorteD::Molecule::Video
+
+  LOWER_WORLD = {
+    ::CHECKING::YOU::OUT::from_ietf_media_type('video/mp4') => nil,
+  }
+
+  include Cooltrainer::DistorteD::Technology::GStreamer
+
+end  # Video

data/lib/distorted-floor/media_molecule.rb

@@ -0,0 +1,58 @@
+require 'set'
+
+module Cooltrainer; end
+module Cooltrainer::DistorteD
+
+  # Discover DistorteD MediaMolecules bundled with this Gem
+  # TODO: and any installed as separate Gems.
+  @@loaded_molecules rescue begin
+    Dir[File.join(__dir__, 'media_molecule', '*.rb')].each { |molecule| require molecule }
+    @@loaded_molecules = true
+  end
+
+  # Returns a Set[Module] of our discovered MediaMolecules.
+  def self.media_molecules
+    Cooltrainer::DistorteD::Molecule.constants.map { |molecule|
+      Cooltrainer::DistorteD::Molecule::const_get(molecule)
+    }.to_set
+  end
+
+  # Reusable IMPLANTATION Hash key, since instances of the same Struct subclass are equal:
+  # irb> Pair = Struct.new(:uno, :dos)
+  # irb> lol = Pair.new(:a, 1)
+  # irb> rofl = Pair.new(:a, 1)
+  # irb> lol === rofl
+  # => true
+  KEY = Struct.new(:molecule, :constant, :inherit) do
+    # Descend into ancestor Modules by default.
+    def initialize(molecule, constant, inherit = true); super(molecule, constant, inherit); end
+    def inspect; "#{molecule}#{'∫'.freeze if inherit}::#{constant}"; end
+  end
+
+  # Check and create attribute-memoizing Hash whose default_proc will fetch
+  # and collate the data for a given KEY.
+  @@implantation rescue begin
+    @@implantation = Hash.new { |piles, key| 
+      # Optionally limit search to top-level Module like `:const_defined?` with `inherit`
+      piles[key] = Set[key.molecule].merge(key.inherit ? key.molecule.ancestors : []).each_with_object(Hash.new) { |mod, pile|
+        mod.const_get(key.constant).each { |target, elements|
+          pile.update(target => elements) { |_key, existing, new| existing.merge(new) }
+        } rescue nil 
+      }
+    }
+  end
+
+  # Generic entry-point for attribute-collation of a given constant
+  # over a given Molecule or Enumerable of Molecules.
+  def self.IMPLANTATION(constant, corpus = self.media_molecules)
+    (corpus.is_a?(Enumerable) ? corpus : Array[corpus]).map { |molecule|
+      KEY.new(molecule, constant)
+    }.each_with_object(Hash[]) { |key, piles|
+      # Hash#slice doesn't trigger the default_proc, so access each directly.
+      piles.store(key, @@implantation[key])
+    }.yield_self { |piles|
+      # Return just the data when we were given a single Molecule to search.
+      corpus.is_a?(Enumerable) ? piles : piles.shift[1]
+    }
+  end
+end

data/lib/distorted-floor/modular_technology/gstreamer.rb

@@ -0,0 +1,175 @@
+require 'set'
+
+require 'distorted-floor/checking_you_out'
+using ::DistorteD::CHECKING::YOU::OUT
+
+require('xross-the-xoul/version') unless defined?(::XROSS::THE::Version::TripleCounter)
+GST_MINIMUM_VER = ::XROSS::THE::Version::TripleCounter.new(1, 18, 0)
+
+begin
+  require 'gst'
+  GST_AVAILABLE_VER = ::XROSS::THE::Version::TripleCounter.new(*(Gst.version))
+  unless GST_AVAILABLE_VER >= GST_MINIMUM_VER
+    raise LoadError.new(
+      "DistorteD needs GStreamer #{GST_MINIMUM_VER}, but the available version is '#{Gst.version_string}'"
+    )
+  end
+rescue LoadError => le
+  raise unless le.message =~ /libgst/
+
+  # Multiple OS help
+  help = <<~INSTALL
+
+  Please install the GStreamer library for your system, version #{GST_MINIMUM_VER} or later.
+  INSTALL
+
+  # Re-raise with install message
+  raise $!, "#{help}\n#{$!}", $!.backtrace
+end
+
+
+module Cooltrainer; end
+module Cooltrainer::DistorteD; end
+module Cooltrainer::DistorteD::Technology; end
+module Cooltrainer::DistorteD::Technology::GStreamer
+
+  OUTER_LIMITS = Set[
+    'application/dash+xml',
+    'application/vnd.apple.mpegurl',
+    'video/mp4',
+  ].map(&::CHECKING::YOU::OUT::method(:from_ietf_media_type))
+
+
+  def write_video_mp4(dest_root, change)
+    copy_file(change.paths(dest_root).first)
+  end
+
+  def write_application_dash_xml(dest, *a, **k)
+    begin
+      segment_dest = File.join(File.dirname(dest), "#{basename}.dash", '/')
+      #segment_dest = segment_dest.sub("#{@base}/", '')
+      FileUtils.mkdir_p(segment_dest)
+      Jekyll.logger.debug(@tag_name, "Re-muxing #{path} to #{segment_dest}")
+
+      # https://gstreamer.freedesktop.org/documentation/tools/gst-launch.html?gi-language=c#pipeline-description
+      # TODO: Convert this from parse_launch() pipeline notation to Element objects
+      # TODO: Get source video duration/resolution/etc and use it to compute a
+      #  value for `target-duration`.
+      # TODO: Also support urldecodebin for remote media.
+      pipeline, error = Gst.parse_launch("dashsink name=mux  filesrc name=src ! decodebin name=demux ! audioconvert ! avenc_aac ! mux.audio_0 demux. ! videoconvert ! x264enc ! mux.video_0")
+
+      if pipeline.nil?
+        Jekyll.logger.error(@tag_name, "Parse error: #{error.message}")
+        return false
+      end
+
+      filesrc = pipeline.get_by_name('src')
+      filesrc.location = path
+
+      mux = pipeline.get_by_name('mux')
+      mux.mpd_filename = File.basename(dest)
+      mux.target_duration = 3
+      #mux.segment_tpl_path = "#{segment_dest}/#{basename}%05d.mp4"
+      mux.mpd_root_path = segment_dest
+      Jekyll.logger.warn('MPD ROOT PATH', mux.get_property('mpd-root-path'))
+
+      # typedef enum
+      # {
+      #   GST_DASH_SINK_MUXER_TS = 0,
+      #   GST_DASH_SINK_MUXER_MP4 = 1,
+      # } GstDashSinkMuxerType;
+      mux.muxer = 1
+
+      pipeline.play
+
+      # Play until End Of Stream
+      event_loop(pipeline)
+
+      pipeline.stop
+
+    rescue Gst::ParseError::NoSuchElement
+      raise
+    end
+  end
+
+  def write_application_vnd_apple_mpegurl(dest, *a, **k)
+    begin
+      orig_dest = dest
+      orig_path = path
+
+      FileUtils.mkdir_p(File.dirname(orig_dest))
+
+      hls_dest = File.join(File.dirname(orig_dest), basename + '.hls')
+      FileUtils.mkdir_p(hls_dest)
+      Jekyll.logger.debug(@tag_name, "Re-muxing #{orig_path} to #{hls_dest}.")
+
+      #FileUtils.rm(orig_dest) if File.exist?(orig_dest)
+      if not File.file?(orig_dest)
+        FileUtils.cp(orig_path, orig_dest)
+      end
+
+      # https://gstreamer.freedesktop.org/documentation/tools/gst-launch.html?gi-language=c#pipeline-description
+      # TODO: Convert this from parse_launch() pipeline notation to Element objects
+      # TODO: Get source video duration/resolution/etc and use it to compute a
+      #  value for `target-duration`.
+      # TODO: Also support urldecodebin for remote media.
+      pipeline, error = Gst.parse_launch("filesrc name=src ! decodebin name=demux ! videoconvert ! x264enc ! queue2 ! h264parse ! queue2 ! mux.video hlssink2 name=mux max-files=0 playlist-length=0 target-duration=2 demux. ! audioconvert ! faac ! queue2 ! mux.audio")
+
+      if pipeline.nil?
+        Jekyll.logger.error(@tag_name, "Parse error: #{error.message}")
+        return false
+      end
+
+      filesrc = pipeline.get_by_name('src')
+      filesrc.location = orig_path
+
+      hls_playlist = "#{hls_dest}/#{basename}.m3u8"
+      hls = pipeline.get_by_name('mux')
+      hls.location = "#{hls_dest}/#{basename}%05d.ts"
+      hls.playlist_location = hls_playlist
+
+      # TODO: config option for absolute vs relative segment URIs in the playlist.
+      #hls.playlist_root = @url
+
+      # TODO: dashsink support once there is a stable GStreamer release including it:
+      # https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/merge_requests/704
+
+      pipeline.play
+
+      # Play until End Of Stream
+      event_loop(pipeline)
+
+      pipeline.stop
+
+      # HACK HACK HACK: Replace X-ALLOW-CACHE line in playlist with YES.
+      # This property does not seem to be exposed to the outside of hlssink:
+      # https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/tree/ext/hls/gsthlssink.c
+      text = File.read(hls_playlist)
+      File.write(hls_playlist, text.gsub(/^#EXT-X-ALLOW-CACHE:NO$/, '#EXT-X-ALLOW-CACHE:YES'))
+    rescue Gst::ParseError::NoSuchElement
+      raise
+    end
+  end
+
+  def event_loop(pipeline)
+    running = true
+    bus = pipeline.bus
+
+    while running
+      message = bus.poll(Gst::MessageType::ANY, -1)
+
+      case message.type
+      when Gst::MessageType::EOS
+        running = false
+      when Gst::MessageType::WARNING
+        warning, _debug = message.parse_warning
+        Jekyll.logger.warning(@tag_name, warning)
+      when Gst::MessageType::ERROR
+        error, _debug = message.parse_error
+        Jekyll.logger.error(@tag_name, error)
+        running = false
+      end
+    end
+  end
+
+end

data/lib/distorted-floor/modular_technology/pango.rb

@@ -0,0 +1,90 @@
+module Cooltrainer
+  module DistorteD
+    module Technology
+      module Pango
+
+        # Escape text as necessary for Pango Markup, which is what Vips::Image.text()
+        # expects for its argv. This code should be in GLib but is unimplemented in Ruby's:
+        #
+        # https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3ALabel#Markup+%28styled+text%29
+        # "The markup passed to Gtk::Label#set_markup() must be valid; for example,
+        # literal </>/& characters must be escaped as &lt;, &gt;, and &amp;.
+        # If you pass text obtained from the user, file, or a network to
+        # Gtk::Label#set_markup(), you'll want to escape it
+        # with GLib::Markup.escape_text?(not implemented yet)."
+        #
+        # Base my own implementation on the original C version found in gmarkup:
+        # https://gitlab.gnome.org/GNOME/glib/-/blob/master/glib/gmarkup.c
+        def g_markup_escape_text(text)
+          text.map{ |c| g_markup_escape_char(c) }
+        end
+
+        # Returns a Pango-escaped Carriage Return.
+        # Use this for linebreaking Pango Markup output.
+        def cr
+          g_markup_escape_char(0x0D)
+        end
+
+        # Returns a Pango-escapped Line Feed.
+        # This isn't used/needed for anything with Pango
+        # but it felt weird to include CR and not LF lmao
+        def lf
+          g_markup_escape_char(0x0A)
+        end
+
+        # Returns a Pango'escaped CRLF pair.
+        # Also not needed for anything.
+        def crlf
+          cr << lf
+        end
+
+        # "Modified UTF-8" uses a normally-illegal byte sequence
+        # to encode the NULL character so 0x00 can exclusively
+        # be a string terminator.
+        def overlong_null
+          [0xC0, 0x80].pack('C*').force_encoding('UTF-8')
+        end
+
+        # The char-by-char actual function used by g_markup_escape_text
+        def g_markup_escape_char(c)
+          # I think a fully-working version of this function would
+          # be as simple as `sprintf('&#x%x;', c.ord)` ALL THE THINGS,
+          # but I want to copy the structure of the C implementation
+          # as closely as possible, which means using the named escape
+          # sequences for common characters and separating the
+          # Latin-1 Supplement range from the other
+          # the Unicode control characters (> 0x7f) even though three's no
+          # need to in Ruby.
+          case c.ord
+          when '&'.ord
+            '&amp;'
+          when '<'.ord
+            '&lt;'
+          when '>'.ord
+            '&gt;'
+          when '\''.ord
+            '&apos;'
+          when '"'.ord
+            '&quot;'
+          when 0x1..0x8, 0xb..0xc, 0xe..0x1f, 0x7f
+            sprintf('&#x%x;', c.ord)
+          when 0x80..0x84, 0x86..0x9f
+            # The original C implementation separates this range
+            # from the above range due to its need to handle the
+            # UTF control character bytes with gunichar:
+            # https://wiki.tcl-lang.org/page/UTF%2D8+bit+by+bit
+            # https://www.fileformat.info/info/unicode/utf8.htm
+            # Ruby has already done this for us here :)
+            sprintf('&#x%x;', c.ord)
+          when 0x0 # what's this…?
+            # Avoid a `ArgumentError: string contains null byte`
+            # by not printing one :)
+          else
+            c
+          end
+        end
+
+      end  # Pango
+    end  # Tech
+  end  # DistorteD
+end  # Cooltrainer

data/lib/distorted-floor/modular_technology/ttfunk.rb

@@ -0,0 +1,48 @@
+require 'ttfunk'
+
+module Cooltrainer; end
+module Cooltrainer::DistorteD; end
+module Cooltrainer::DistorteD::Technology; end
+module Cooltrainer::DistorteD::Technology::TTFunk
+
+  def to_ttfunk
+    # TODO: Check that src exists, because TTFunk won't and will just
+    # give us an unusable object instead.
+    @ttfunk_file ||= TTFunk::File.open(font_path)
+  end
+
+  # Returns a boolean for whether or not this font is monospaced.
+  # true == monospace
+  # false == proportional
+  def font_spacing
+    # Monospace fonts will (read: should) have the same width
+    # for every glyph, so we can tell a monospace font by
+    # checking if a deduplicated widths table has size == 1:
+    # irb(main)> font.horizontal_metrics.widths.count
+    # => 256
+    # irb(main)> font.horizontal_metrics.widths.uniq.compact.length
+    # => 1
+    to_ttfunk.horizontal_metrics.widths.uniq.compact.length == 1 ? :monospace : :proportional
+  end
+
+  # Returns the Family and Subfamily as one string suitable for libvips
+  def font_name
+    "#{to_ttfunk.name.font_family.first.encode('UTF-8')} #{to_ttfunk.name.font_subfamily.first.encode('UTF-8')}"
+  end
+
+  # Returns the Pango-Markup-encoded UTF-8 String version + revision of the font
+  def font_version
+    g_markup_escape_text(to_ttfunk.name&.version&.first&.encode('UTF-8').to_s)
+  end
+
+  # Returns the Pango-Markup-encoded UTF-8 String font file description
+  def font_description
+    g_markup_escape_text(to_ttfunk.name&.description&.first&.encode('UTF-8').to_s)
+  end
+
+  # Returns the Pango-Markup-encoded UTF-8 String copyright information of the font
+  def font_copyright
+    g_markup_escape_text(to_ttfunk.name&.copyright&.first&.encode('UTF-8').to_s)
+  end
+
+end