distorted-jekyll 0.6.0 → 0.7.0

data/lib/distorted-jekyll/media_molecule.rb

@@ -0,0 +1,20 @@
+require 'set'
+require 'distorted/media_molecule'
+
+module Jekyll::DistorteD
+  # Load Jekyll Molecules which will implicitly also load
+  # the Floor Molecules they're based on if they aren't already.
+  @@loaded_molecules rescue begin
+    Dir[File.join(__dir__, 'media_molecule', '*.rb')].each { |molecule| require molecule }
+    @@loaded_molecules = true
+  end
+end
+
+module Cooltrainer::DistorteD
+  # Override default Molecule Set with their Liquid-rendering submolecules.
+  def self.media_molecules
+    Jekyll::DistorteD::Molecule.constants.map { |molecule|
+      Jekyll::DistorteD::Molecule::const_get(molecule)
+    }.to_set
+  end
+end

data/lib/distorted-jekyll/media_molecule/font.rb

@@ -0,0 +1,21 @@
+require 'set'
+
+require 'distorted/media_molecule/font'
+require 'distorted-jekyll/liquid_liquid/picture'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::Font
+
+  include Cooltrainer::DistorteD::Molecule::Font
+  include Jekyll::DistorteD::LiquidLiquid::Picture
+
+  Cooltrainer::DistorteD::IMPLANTATION(:LOWER_WORLD, Cooltrainer::DistorteD::Molecule::Font).each_key { |type|
+    define_method(type.distorted_template_method) { |change|
+      Cooltrainer::ElementalCreation.new(:anchor_inline, change, **{})
+    }
+  }
+
+end

data/lib/distorted-jekyll/media_molecule/image.rb

@@ -0,0 +1,15 @@
+require 'set'
+
+require 'distorted-jekyll/liquid_liquid/picture'
+require 'distorted/media_molecule/image'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::Image
+
+  include Cooltrainer::DistorteD::Molecule::Image
+  include Jekyll::DistorteD::LiquidLiquid::Picture
+
+end

data/lib/distorted-jekyll/media_molecule/never_let_you_down.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+require 'distorted/checking_you_out'
+require 'distorted-jekyll/liquid_liquid'
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::NeverLetYouDown
+
+  FALLBACK_TYPE = CHECKING::YOU::OUT['application/x.distorted.never-let-you-down']
+  LOWER_WORLD = Hash[
+    FALLBACK_TYPE => Hash[
+      :alt => Cooltrainer::Compound.new(:alt, blurb: 'Alternate text to display when this element cannot be rendered.'),
+      :title => Cooltrainer::Compound.new(:title, blurb: 'Extra information about this element — usually displayed as tooltip text.'),
+      :href => Cooltrainer::Compound.new(:href, blurb: 'Hyperlink reference for this element.')
+    ]
+  ]
+  OUTER_LIMITS = Hash[FALLBACK_TYPE => nil]
+
+  define_method(FALLBACK_TYPE.distorted_file_method) { |dest_root, change|
+    copy_file(change.path(dest_root))
+  }
+  define_method(FALLBACK_TYPE.distorted_template_method) { |change|
+    Cooltrainer::ElementalCreation.new(:anchor_inline, change, **{})
+  }
+
+end

data/lib/distorted-jekyll/media_molecule/pdf.rb

@@ -0,0 +1,108 @@
+require 'set'
+
+require 'distorted/media_molecule/pdf'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::PDF
+
+  include Cooltrainer::DistorteD::Molecule::PDF
+
+  # https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/pdf_open_parameters.pdf
+  #
+  # Adobe's PDF Open Parameters documentation sez:
+  # "Individual parameters, together with their values (separated by & or #),
+  # can be no greater then 32 characters in length."
+  # …but then goes on to show some examples (like `comment`)
+  # that are clearly longer than 32 characters.
+  # Dunno. I'll err on the side of giving you a footgun.
+  #
+  # Keep the PDF Open Params in the order they are defined
+  # in the Adobe documentation, since it says they should
+  # be specified in the URL in that same order.
+  #
+  # "You cannot use the reserved characters =, #, and &.
+  # There is no way to escape these special characters."
+  RESERVED_CHARACTERS_FRAGMENT = '[^=#&]+'.freeze
+  FLOAT_INT_FRAGMENT = '[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)'.freeze
+  ZERO_TO_ONE_HUNDRED = /^(([1-9]\d?|1\d{1})([.,]\d{0,1})?|100([.,]0{1})?)$/
+  PDF_OPEN_PARAMS = Array[
+    Cooltrainer::Compound.new(:nameddest, valid: /^#{RESERVED_CHARACTERS_FRAGMENT}$/, blurb: 'Jump to a named destination in the document.'),
+    Cooltrainer::Compound.new(:page, valid: Integer, default: 1, blurb: 'Jump to a numbered page in the document.'),
+    Cooltrainer::Compound.new(:comment, valid: /^#{RESERVED_CHARACTERS_FRAGMENT}$/, blurb: 'Jump to a comment on a given page.'),
+    Cooltrainer::Compound.new(:collab, valid: /^(DAVFDF|FSFDF|DB)@#{RESERVED_CHARACTERS_FRAGMENT}$/, blurb: 'Sets the comment repository to be used to supply and store comments for the document.'),
+    Cooltrainer::Compound.new(:zoom, valid: /^#{FLOAT_INT_FRAGMENT}(,#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT})?$/, blurb: 'Sets the zoom and scroll factors, using float or integer values.'),
+    Cooltrainer::Compound.new(:view, valid: /^Fit(H|V|B|BH|BV(,#{FLOAT_INT_FRAGMENT})?)?$/, default: :Fit, blurb: 'Set the view of the displayed page, using the keyword values defined in the PDF language specification. For more information, see the PDF Reference.'),
+    Cooltrainer::Compound.new(:viewrect, valid: /^#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT}$/, blurb: 'Sets the view rectangle using float or integer values in a coordinate system where 0,0 represents the top left corner of the visible page, regardless of document rotation.'),
+    Cooltrainer::Compound.new(:pagemode, valid: Set[:none, :thumbs, :bookmarks], default: :none, blurb: 'Displays bookmarks or thumbnails.'),
+    Cooltrainer::Compound.new(:scrollbar, valid: Cooltrainer::BOOLEAN_VALUES, default: true, blurb: 'Turns scrollbars on or off.'),
+    Cooltrainer::Compound.new(:search, valid: /^#{RESERVED_CHARACTERS_FRAGMENT}(,\s#{RESERVED_CHARACTERS_FRAGMENT})*$/ , blurb: 'Opens the Search panel and performs a search for any of the words in the specified word list. The first matching word is highlighted in the document.'),
+    Cooltrainer::Compound.new(:toolbar, valid: Cooltrainer::BOOLEAN_VALUES, default: true, blurb: 'Turns the toolbar on or off.'),
+    Cooltrainer::Compound.new(:statusbar, valid: Cooltrainer::BOOLEAN_VALUES, default: true, blurb: 'Turns the status bar on or off.'),
+    Cooltrainer::Compound.new(:messages, valid: Cooltrainer::BOOLEAN_VALUES, default: false, blurb: 'Turns the document message bar on or off.'),
+    Cooltrainer::Compound.new(:navpanes, valid: Cooltrainer::BOOLEAN_VALUES, default: true, blurb: 'Turns the navigation panes and tabs on or off.'),
+    Cooltrainer::Compound.new(:highlight, valid: /^#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT},#{FLOAT_INT_FRAGMENT}$/, blurb: 'Highlights a specified rectangle on the displayed page. Use the `page` command before this command.'),
+    Cooltrainer::Compound.new(:fdf, valid: /^#{RESERVED_CHARACTERS_FRAGMENT}$/, blurb: 'Specifies an FDF file to populate form fields in the PDF file being
+opened.'),
+  ]
+
+  # https://developer.mozilla.org/en-US/docs/Web/HTML/Element/object#Attributes
+  CONTAINER_ATTRIBUTES = Array[
+    Cooltrainer::Compound.new(:alt, valid: String),
+    Cooltrainer::Compound.new(:caption, valid: String),
+    Cooltrainer::Compound.new(:height,  valid: String, default: '100%'.freeze, blurb: '<object> viewer container height.'),
+    Cooltrainer::Compound.new(:width,  valid: String, default: '100%'.freeze, blurb: '<object> viewer container width.'),
+  ]
+
+  OUTER_LIMITS = Hash[
+    CHECKING::YOU::OUT['application/pdf'] => PDF_OPEN_PARAMS.concat(CONTAINER_ATTRIBUTES).reduce(Hash[]) {|aka, compound|
+      aka.tap { |a| a.store(compound.element, compound) }
+    }
+  ]
+
+  # Generate a Hash of our PDF Open Params based on any given to the Liquid tag
+  # and any loaded from the defaults.
+  # https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/pdf_open_parameters.pdf
+  def pdf_open_params
+    PDF_OPEN_PARAMS.reduce(Hash[]) {|params, compound|
+      # Only include those params whose user-given value exists and differs from its default.
+      params.tap { |p|
+        p.store(compound.element, abstract(compound.element)) unless [
+          nil, ''.freeze, compound.default,
+        ].include?(abstract(compound.element))
+      }
+    }
+  end
+
+  # Generate the URL fragment version of the PDF Open Params.
+  # This would be difficult / impossible to construct within Liquid
+  # from the individual variables, so let's just do it out here.
+  def pdf_open_params_url
+    pdf_open_params.map{ |(k,v)|
+      case
+      when k == :search
+        # The PDF Open Params docs specify `search` should be quoted.
+        "#{k}=\"#{v}\""
+      when Cooltrainer::BOOLEAN_VALUES.include?(v)
+        # Convert booleans to the numeric representation Adobe use here.
+        "#{k}=#{v ? 1 : 0}"
+      else
+        "#{k}=#{v}"
+      end
+    }.join('&')
+  end
+
+  # http://joliclic.free.fr/html/object-tag/en/
+  # TODO: iOS treats our <object> like an <img>,
+  # showing only the first page with transparency and stretched to the
+  # size of the container element.
+  # We will need something like PDF.js in an <iframe> to handle this.
+  define_method(CHECKING::YOU::OUT['application/pdf'].distorted_template_method) { |change|
+    Cooltrainer::ElementalCreation.new(:object, change, children: [:embed, :anchor_inline]).tap { |e|
+      e.fragment = pdf_open_params.empty? ? ''.freeze : "##{pdf_open_params_url}"
+    }
+  }
+
+end  # PDF

data/lib/distorted-jekyll/media_molecule/svg.rb

@@ -0,0 +1,20 @@
+require 'set'
+
+require 'distorted/media_molecule/svg'
+require 'distorted-jekyll/liquid_liquid/picture'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::SVG
+
+  include Cooltrainer::DistorteD::Molecule::SVG
+  include Jekyll::DistorteD::LiquidLiquid::Picture
+
+  define_method(
+    CHECKING::YOU::OUT['image/svg+xml'].distorted_template_method,
+    Jekyll::DistorteD::LiquidLiquid::Picture::render_picture_source,
+  )
+
+end

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

@@ -0,0 +1,23 @@
+require 'set'
+
+require 'distorted/media_molecule/text'
+require 'distorted-jekyll/liquid_liquid/picture'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::Text
+
+  include Cooltrainer::DistorteD::Molecule::Text
+  include Jekyll::DistorteD::LiquidLiquid::Picture
+
+  Cooltrainer::DistorteD::IMPLANTATION(:LOWER_WORLD, Cooltrainer::DistorteD::Molecule::Text).each_key { |type|
+    define_method(type.distorted_template_method) { |change|
+      # Remove the destructured empty Hash once we drop Ruby 2.7
+      # so we don't get auto-destructured due to Change#to_hash.
+      Cooltrainer::ElementalCreation.new(:anchor_inline, change, **{})
+    }
+  }
+
+end  # Text

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

@@ -0,0 +1,45 @@
+require 'distorted/media_molecule/video'
+
+
+module Jekyll; end
+module Jekyll::DistorteD; end
+module Jekyll::DistorteD::Molecule; end
+module Jekyll::DistorteD::Molecule::Video
+
+  include Cooltrainer::DistorteD::Molecule::Video
+
+  Cooltrainer::DistorteD::IMPLANTATION(:LOWER_WORLD, Cooltrainer::DistorteD::Molecule::Video).each_key { |type|
+    define_method(type.distorted_template_method) { |change|
+      Cooltrainer::ElementalCreation.new(:video_source, change, parents: Array[:video])
+    }
+  }
+
+  # Override wanted-filenames method from StaticState with one that prevents our generated
+  # video segments from being deleted.
+  # This is still very hacky until I can guarantee/control the number of segments we get.
+  def wanted_files
+    dd_dest = File.join(the_setting_sun(:jekyll, :destination).to_s, @relative_dest)
+    changes.each_with_object(Set[]) { |change, wanted|
+      case change.type
+      # Treat HLS and MPEG-DASH the same, with slightly different naming conventions.
+      # Add their main playlist file, but then also glob any segments that happen to exist.
+      when CHECKING::YOU::OUT['application/dash+xml']
+        hls_dir = File.join(dd_dest, "#{basename}.hls")
+        wanted.add(File.join(hls_dir, "#{basename}.m3u8"))
+        if Dir.exist?(hls_dir)
+          Dir.entries(hls_dir).to_set.subtract(Set["#{basename}.m3u8"]).each { |hls| wanted.add(File.join(hls_dir, hls)) }
+        end
+      when CHECKING::YOU::OUT['application/vnd.apple.mpegurl']
+        dash_dir = File.join(dd_dest, "#{basename}.dash")
+        wanted.add(File.join(dash_dir, "#{basename}.mpd"))
+        if Dir.exist?(dash_dir)
+          Dir.entries(dash_dir).to_set.subtract(Set["#{basename}.mpd"]).each { |dash| wanted.add(File.join(dash_dir, dash)) }
+        end
+      else
+        # Treat any other type (including single-file video types) like normal.
+        wanted.add(change.name)
+      end
+    }
+  end
+
+end  # Video

data/lib/distorted-jekyll/monkey_business/jekyll/cleaner.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'distorted-jekyll/media_molecule'
 
 module Jekyll
   # Handles the cleanup of a site's destination before it is built or re-built.
@@ -49,6 +50,72 @@ module Jekyll
         Jekyll.logger.debug('DistorteD', "Monkey-patched Jekyll::Cleaner#new_files backtrace: #{e.backtrace}")
         the_old_new_thing.bind(self).()
       end
-    end
+    end  # define_method :new_files
+
+
+    # Private: Creates a regular expression from the config's keep_files array
+    #
+    # Examples
+    #   ['.git','.svn'] with site.dest "/myblog/_site" creates
+    #   the following regex: /\A\/myblog\/_site\/(\.git|\/.svn)/
+    #
+    # Returns the regular expression
+    #
+    # Monkey-patch this to protect DistorteD-generated files from destruction
+    # https://jekyllrb.com/docs/configuration/incremental-regeneration/
+    # when running Jekyll in Incremental mode twice in a row.
+    #
+    # The first Incremental build will process our Liquid tags on every post/page
+    # which will add our generated files to Jekyll::Cleaner's :new_files (See above!)
+    # A second build, however, will not re-process any posts/pages that haven't changed.
+    # Our Tags never get initialized, so their previously-generated files now appear
+    # to be spurious and will get purged.
+    #
+    # Work around this by merging Jekyll::Cleaner#keep_file_regex with a second Regexp
+    # based on the :preferred_extension for every MIME::Type DistorteD can output.
+    mr_regular = instance_method(:keep_file_regex)
+    define_method(:keep_file_regex) do
+      begin
+        # We're going to use it either way, so go ahead and get what the :keep_file_regex
+        # would have been in unpatched Jekyll, e.g.:
+        # (?-mix:\A/home/okeeblow/Works/cooltrainer/_site\/(\.git|\.svn))
+        super_regexp = mr_regular.bind(self).()
+
+        # If we aren't in Incremental mode then each Tag will explicitly declare
+        # the files they write, and that's preferrable to this shotgun approach
+        # since the Regexp approach may preserve unwanted files, but "Some unwanted files"
+        # is way nicer than "fifteen minutes rebuilding everything" rofl
+        if site&.incremental?
+          # Discover every supported output MIME::Type based on every loaded MediaMolecule.
+          outer_limits = Cooltrainer::DistorteD::IMPLANTATION(
+            :OUTER_LIMITS,
+            Cooltrainer::DistorteD::media_molecules,
+          ).values.flat_map(&:keys)
+
+          # Build a new Regexp globbing the preferred extension of every Type we support, e.g.:
+          # (?-mix:\A/home/okeeblow/Works/cooltrainer/_site/.*(txt|nfo|v|ppm|pgm|pbm|hdr|png|jpg|webp|tiff|fits|gif|bmp|ttf|svg|pdf|mpd|m3u8|mp4))
+          #
+          # Some Types may have duplicate preferred_extensions, and some might have nil
+          # (e.g. our own application/x.distorted.never-let-you-down), so :uniq and :compact them out.
+          outer_regexp = %r!\A#{Regexp.quote(site.dest)}/.*(#{Regexp.union(outer_limits&.map(&:preferred_extension).uniq.compact).source})!
+
+          # Do the thing.
+          combined_regexp = Regexp.union(outer_regexp, super_regexp)
+          Jekyll.logger.debug(
+            'Protecting DistorteD-generated files from Incremental-mode destruction with new Jekyll::Cleaner#keep_file_regex',
+            combined_regexp.source)
+          return combined_regexp
+        else
+          # Feels like I'm patching nothin' at all… nothin' at all… nothin' at all!
+          return super_regexp
+        end
+      rescue RuntimeError => e
+        Jekyll.logger.warn('DistorteD', "Monkey-patching Jekyll::Cleaner#keep_file_regex failed: #{e.message}")
+        Jekyll.logger.debug('DistorteD', "Monkey-patched Jekyll::Cleaner#keep_file_regex backtrace: #{e.backtrace}")
+        # Bail out by returning what the :keep_file_regex would have been without this patch.
+        mr_regular.bind(self).()
+      end
+    end  # define_method :keep_file_regex
+
   end  # Cleaner
 end  # Jekyll

data/lib/distorted-jekyll/static_state.rb

@@ -14,9 +14,6 @@ module Jekyll::DistorteD; end
 module Jekyll::DistorteD::StaticState
 
 
-  ATTRIBUTES = Set[:title]
-
-
   # Returns the to-be-written path of a single standard StaticFile.
   # The value returned by this method is only the 'main' or 'original'
   # (even if modified somehow) file and does not include the
@@ -36,7 +33,7 @@ module Jekyll::DistorteD::StaticState
   # that should be kept when regenerating the site.
   # This makes DistorteD fast!
   def destinations(dest_root)
-    wanted_files.map{|f| File.join(dest_root, @relative_dest, f)}
+    changes&.flat_map { |change| change.paths(dest_root) }
   end
 
   # HACK HACK HACK
@@ -47,7 +44,7 @@ module Jekyll::DistorteD::StaticState
     # Assume modified for the sake of freshness :)
     modified = true
 
-    site_dest = Jekyll::DistorteD::Floor::config(:destination).to_s
+    site_dest = the_setting_sun(:jekyll, :destination).to_s
     if Dir.exist?(site_dest)
       if Dir.exist?(File.join(site_dest, @relative_dest))
         extant_files = Dir.entries(File.join(site_dest, @relative_dest)).to_set
@@ -85,7 +82,6 @@ module Jekyll::DistorteD::StaticState
   #
   # Returns false if the file was not modified since last time (no-op).
   def write(dest_root)
-    plug
     return false if File.exist?(path) && !modified?
 
     # Create any directories to the depth of the intended destination.
@@ -94,24 +90,26 @@ module Jekyll::DistorteD::StaticState
     # This will be a Set of Hashes each describing the name, type,
     # dimensions, attributes, etc of each output variation we want.
     # Full-size outputs will have the special tag `:full`.
-    files.each { |variation|
-      type = variation&.dig(:type)
-      filename = File.join(dest_root, @relative_dest, variation&.dig(:name) || @name)
-
-      if self.respond_to?(type.distorted_method)
-        Jekyll.logger.debug("DistorteD::#{type.distorted_method}", filename)
-        self.send(type.distorted_method, filename, **variation)
-      elsif extname == ".#{type.preferred_extension}"
+    changes&.each { |change|
+      if self.respond_to?(change.type.distorted_file_method)
+        Jekyll.logger.debug("DistorteD::#{change.type.distorted_file_method}", change.name)
+        # WISHLIST: Remove the empty final positional Hash argument once we require a Ruby version
+        # that will not perform the implicit Change-to-Hash conversion due to Change's
+        # implementation of :to_hash. Ruby 2.7 will complain but still do the conversion,
+        # breaking downstream callers that want a Struct they can call arbitrary key methods on.
+        # https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+        self.send(change.type.distorted_file_method, dest_root, change, **{})
+      elsif extname == ".#{change.type.preferred_extension}"
         Jekyll.logger.debug(@name, <<~RAWCOPY
-            No #{type.distorted_method} method is defined,
-            but the intended output type #{type.to_s} is the same
+            No #{change.type.distorted_file_method} method is defined,
+            but the intended output type #{change.type.to_s} is the same
             as the input type, so I will fall back to copying the raw file.
           RAWCOPY
         )
-        copy_file(filename)
+        copy_file(change.paths(dest_root).first)
       else
-        Jekyll.logger.error(@name, "Missing rendering method #{type.distorted_method}")
-        raise MediaTypeOutputNotImplementedError.new(filename, type, self.class.name)
+        Jekyll.logger.error(@name, "Missing write method #{change.type.distorted_file_method}")
+        raise MediaTypeOutputNotImplementedError.new(change.path(dest_root), type_mars, self.class.name)
       end
     }
   end  # write
@@ -128,11 +126,6 @@ module Jekyll::DistorteD::StaticState
 
   # Basic file properties
 
-  # Filename without the dot-and-extension.
-  def basename
-    File.basename(@name, '.*')
-  end
-
   # Returns the extname /!\ including the dot /!\
   def extname
     File.extname(@name)
@@ -155,46 +148,12 @@ module Jekyll::DistorteD::StaticState
     end
   end
 
-  # Returns a Hash keyed by MIME::Type objects with value as a Set of Hashes
-  # describing the media's output variations to be generated for each Type.
-  def variations
-    changes(abstract(:changes)).map{ |t|
-      [t, outer_limits(abstract(:outer_limits)).map{ |d|
-
-        # Don't change the filename of full-size variations
-        tag = d&.dig(:tag) != :full ? '-'.concat(d&.dig(:tag).to_s) : ''.freeze
-        # Use the original extname for LastResort
-        ext = t == CHECKING::YOU::OUT('application/x.distorted.last-resort') ? File.extname(@name) : t.preferred_extension
-        # Handle LastResort for files that might be a bare name with no extension
-        dot = '.'.freeze unless ext.nil? || ext&.empty?
-
-        d.merge({
-          # e.g. 'SomeImage-medium.jpg` but just `SomeImage.jpg` and not `SomeImage-full.jpg`
-          # for the full-resolution outputs.
-          # The default `.jpeg` preferred_extension is monkey-patched to `.jpg` because lol
-          :name => "#{basename}#{tag}#{dot}#{ext}",
-        })
-
-      }]
-    }.to_h
-  end
-
-  # Returns a flat Set of Hashes that each describe one variant of
-  # media file output that should exist for a given input file.
-  def files
-    filez = Set[]
-    variations.each_pair{ |t,v|
-      # Merge the type in to each variation Hash since we will no longer
-      # have it as the key to this Set in its container Hash.
-      v.each{ |d| filez.add(d.merge({:type => t})) }
-    }
-    filez
-  end
 
   # Returns a Set of just the String filenames we want for this media.
   # This will be used by `modified?` among others.
   def wanted_files
-    files.map{|f| f[:name]}.to_set
+    # Cooltrainer::Change#names returns an Array[String], so we must concat every Change into one.
+    changes.map(&:names).reduce(&:concat).to_set
   end