distorted-jekyll 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1dd519e4d15964873a6184c4f47eebb52d8c58b3ac74707095278cce0cfe51d
-  data.tar.gz: aed8d0eaa3e7d7e18c459add39e6a9136bda7d1408886f4fe514db61f4d77906
+  metadata.gz: 5eaf5c713e61dd6cea6fee1d1cb031b7ec25331e8cdeb9aa79f1ea96c61d94a8
+  data.tar.gz: '068625124864b575107596d9b91761171eecdb76cdaf8f34a66fa37f4d34b69e'
 SHA512:
-  metadata.gz: 510a70a86a7fa6e89880fd6385fb2780e04e2b1a0bd21b2b361eb44fdafa3c05da879802ea8d54d49741cc7a691f877c37491e5774ecd106d0acc86e780d1cab
-  data.tar.gz: '0174925db366f825a2b5fa6d54b9f26bae4b783315bb82f81762cda503376b25ee8718618df688840ef0f1b237bfc4b196b921af9569d50a472fd6012863473a'
+  metadata.gz: 4b55e4771aadea12c70adf95995432b4cff70cf0548b06ae76dcb8a55f11de273531a3f2def6be56de9b7043a9f752a6f7d7cc1f66299475409ac269be80dc77
+  data.tar.gz: 4c152988ef67bd5717429578de241169b13f7ffee38cb255979184e2b3cdf4d551d1b50d9c4472ca98bbb9695d8892f09b0b2d9d0e2a02deeeb1dd54d8415f66

data/lib/distorted-jekyll.rb

@@ -1,6 +1,6 @@
 require 'distorted-jekyll/13th-style'
 require 'distorted-jekyll/blocks'
-require 'distorted-jekyll/injection_of_love'
+require 'distorted-jekyll/md_injection'
 require 'distorted-jekyll/invoker'
 
 

data/lib/distorted-jekyll/_config_default.yml

@@ -21,9 +21,6 @@ standard_image: &standard_image
     height: 1500
     media: "(min-width: 800px)"
 
-standard_text: &standard_text
-  ? image/png
-  ? image/webp
 
 distorted:
 
@@ -63,10 +60,17 @@ distorted:
         ? image/png
         ? image/webp
     text:
-      plain: *standard_text
-      x-nfo: *standard_text
+      plain:
+        ? text/plain
+        ? image/png
+        ? image/webp
+      x-nfo:
+        ? text/x-nfo
+        ? image/png
+        ? image/webp
     font:
       ttf:
+        ? font/ttf
         ? image/png
         ? image/webp
 
@@ -75,5 +79,3 @@ distorted:
       jpeg: *standard_image
       png: *standard_image
       webp: *standard_image
-    font:
-      ttf: *standard_image

data/lib/distorted-jekyll/floor.rb

@@ -1,12 +1,16 @@
-require 'distorted/monkey_business/hash'
 require 'yaml'
 require 'jekyll'
 require 'set'
 
+require 'distorted/monkey_business/hash'
+require 'distorted/checking_you_out'
+
 
 module Jekyll
   module DistorteD
-    class Floor
+    module Floor
+
+      ATTRIBUTES = Set[:lower_world, :changes, :outer_limits]
 
       # Top-level config key (once stringified) for Jekyll and Default YAML.
       CONFIG_ROOT = :distorted
@@ -67,14 +71,17 @@ module Jekyll
         site = kw[:site] || Jekyll.sites.first
         # Get the config, or nil if the queried config path doesn't exist.
         loaded_config = site.config.dig(*search_keys)
-        Jekyll.logger.debug(['_config', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config || 'No data'.freeze)
         if loaded_config.nil?
           # The wanted config key didn't exist in the Site config, so let's
           # try our defaults!
           # This file will always be small enough for a one-shot read.
           default_config = YAML.load(File.read(DEFAULT_CONFIG_PATH))
           loaded_config = default_config.dig(*search_keys)
-        Jekyll.logger.debug(['Default', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config || 'No data'.freeze)
+          unless loaded_config.nil?
+            Jekyll.logger.debug(['Default', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config)
+          end
+        else  # else Jekyll _config is not nil
+          Jekyll.logger.debug(['_config', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config)
         end
         # Was the desired config key found in the Gem defaults?
         if loaded_config.nil?
@@ -143,6 +150,117 @@ module Jekyll
         return dunno
       end
 
+      # Returns a Set of Arrays of search keys to try in config()
+      def search_keys(*keys)
+        # It's likely that we will get a default argument of [nil]
+        # here due to the output of abstract(:whatever) for unset attrs.
+        keys = keys.compact
+        # If a search key path was given, construct one based
+        # on the MIME::Type union Set between the source media
+        # and the plugged MediaMolecule.
+        if keys.empty? or keys.all?{|k| k.nil?}
+          try_keys = type_mars.map{ |t|
+            # Use only the first part of complex sub_types like 'svg+xml'
+            [t.media_type, t.sub_type.split('+').first].compact
+          }
+        else
+          # Or use a user-provided config path.
+          try_keys = Set[keys]
+        end
+      end
+
+      # Loads configuration data telling us how to open certain
+      # types of files.
+      def lower_world(*keys)
+        # Try each set of keys until we find a match
+        for try in search_keys(*keys)
+          tried = Jekyll::DistorteD::Floor::config(
+            Jekyll::DistorteD::Floor::CONFIG_ROOT,
+            :welcome,
+            *try,
+          )
+          # Is the YAML config of the appropriate structure?
+          if tried.is_a?(Hash)
+            # Non-Hashes may not respond to `empty?`
+            unless tried.empty?
+              return tried
+            end
+          end
+        end
+      end
+
+      # Load configuration telling us what media-types to generate
+      # for any given media-type input.
+      def changes(*keys)
+        out = Set[]
+        # `changes` media-type[sub_type] config will contain information about
+        # what variations output format are desired for what input format,
+        # e.g. {:image => {:jpeg => Set['image/jpeg', 'image/webp']}}
+        # It is not automatically implied that the source format is also
+        # an output format!
+        for try in search_keys(*keys)
+          tried = Jekyll::DistorteD::Floor::config(
+            Jekyll::DistorteD::Floor::CONFIG_ROOT,
+            :changes,
+            *try,
+          )
+          if tried.is_a?(Enumerable) and tried.all?{|t| t.is_a?(String)} and not tried.empty?
+            tried.each{ |t|
+              # MIME::Type.new() won't give us a usable Type object:
+              #
+              # irb> MIME::Types['image/svg+xml'].first.preferred_extension
+              # => "svg"
+              # irb> MIME::Type.new('image/svg+xml').preferred_extension
+              # => nil
+              out.merge(CHECKING::YOU::IN(t))
+            }
+          end
+        end
+
+        # If the config didn't give us any MIME::Type changes
+        # then we will just output the same type we loaded.
+        if out.empty?
+          return type_mars
+        else
+          return out
+        end
+      end
+
+      # Loads configuration telling us what variations to generate for any
+      # given type of file, or for an arbitrary key hierarchy.
+      def outer_limits(*keys)
+        out = Set[]
+        # See if any config data exists for each given key hierarchy,
+        # but under the root DistorteD config key.
+        for try in search_keys(*keys)
+          tried = Jekyll::DistorteD::Floor::config(
+            Jekyll::DistorteD::Floor::CONFIG_ROOT,
+            :outer_limits,
+            *try,
+          )
+
+          # Is the YAML config of the appropriate structure?
+          # Merge a shallow copy of it with the Liquid-given attrs.
+          # If we don't take a copy the attrs will be memoized into the config.
+          if tried.is_a?(Enumerable) and tried.all?{|t| t.is_a?(Hash)} and not tried.empty?
+            out.merge(tried.dup.map{ |d| d.merge(@liquid_liquid) })
+          end
+        end
+
+        # We should output something if the config didn't give us anything.
+        # This is kind of a mess right now with redundancies in the call sites
+        # of things like Molecule::Image. I'll come up with a better general-
+        # purpose fallback solution at some point, but for now this will get
+        # non-Image StaticFiles working with no config :)
+        if out.empty?
+          out << {
+            :tag => :full,
+          }
+        end
+
+        return out
+      end
+
     end
   end
 end

data/lib/distorted-jekyll/invoker.rb

@@ -1,11 +1,12 @@
 # Our custom Exceptions
-require 'distorted-jekyll/error_code'
+require 'distorted/error_code'
+
+# MIME::Typer
+require 'distorted/checking_you_out'
 
 # Configuration-loading code
 require 'distorted-jekyll/floor'
-
-# Configuration data manipulations
-require 'distorted-jekyll/molecule/abstract'
+require 'distorted-jekyll/static_state'
 
 # Media-type drivers
 require 'distorted-jekyll/molecule/font'
@@ -14,7 +15,7 @@ require 'distorted-jekyll/molecule/text'
 require 'distorted-jekyll/molecule/pdf'
 require 'distorted-jekyll/molecule/svg'
 require 'distorted-jekyll/molecule/video'
-require 'distorted-jekyll/molecule/last-resort'
+require 'distorted-jekyll/molecule/lastresort'
 
 # Set.to_hash
 require 'distorted/monkey_business/set'
@@ -29,10 +30,6 @@ require 'shellwords'
 # Set is in stdlib but is not in core.
 require 'set'
 
-# MIME Magic 🧙‍♀️
-require 'mime/types'
-require 'ruby-filemagic'
-
 # I mean, this is why we're here, right?
 require 'jekyll'
 
@@ -44,7 +41,8 @@ module Jekyll
       GEM_ROOT = File.dirname(__FILE__).freeze
 
       # Mix in config-loading methods.
-      include Jekyll::DistorteD::Molecule::Abstract
+      include Jekyll::DistorteD::Floor
+      include Jekyll::DistorteD::StaticState
 
       # Enabled media_type drivers. These will be attempted back to front.
       # TODO: Make this configurable.
@@ -57,6 +55,17 @@ module Jekyll
         Jekyll::DistorteD::Molecule::Video,
         Jekyll::DistorteD::Molecule::Image,
       ]
+      # Reduce the above to a Hash of Sets of MediaMolecules-per-Type, keyed by Type.
+      TYPE_MOLECULES = MEDIA_MOLECULES.reduce(
+        Hash.new{|hash, key| hash[key] = Set[]}
+      ) { |types, molecule|
+        if molecule.const_defined?(:LOWER_WORLD)
+          molecule.const_get(:LOWER_WORLD).each { |t|
+            types.update(t => Set[molecule]) { |k,o,n| o.merge(n) }
+          }
+        end
+        types
+      }
 
       # Any any attr value will get a to_sym if shorter than this
       # totally arbitrary length, or if the attr key is in the plugged
@@ -80,10 +89,21 @@ module Jekyll
         # Filename is the only non-keyword argument our tag should ever get.
         # It's spe-shul and gets its own definition outside the attr loop.
         if parsed_arguments.key?(:src)
-          @name = parsed_arguments[:src]
+          @name = parsed_arguments.delete(:src)
         else
-          @name = parsed_arguments[:argv1]
+          @name = parsed_arguments.delete(:argv1)
         end
+        @liquid_liquid = parsed_arguments.select{ |attr, val|
+          not [nil, ''.freeze].include?(val)
+        }.transform_keys { |attr|
+          attr.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY ? attr.to_sym : attr.freeze
+        }.transform_values { |val|
+          if val.respond_to?(:length)
+            val.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY ? val.to_sym : val.freeze
+          else
+            val
+          end
+        }
 
         # If we didn't get one of the two above options there is nothing we
         # can do but bail.
@@ -91,173 +111,46 @@ module Jekyll
           raise "Failed to get a usable filename from #{arguments}"
         end
 
-        # Guess MIME Magic from the filename. For example:
-        # `distorted IIDX-Readers-Unboxing.jpg: [#<MIME::Type: image/jpeg>]`
-        #
-        # Types#type_for can return multiple possibilities for a filename.
-        # For example, an XML file: [application/xml, text/xml].
-        mime = MIME::Types.type_for(@name).to_set
-
-        # We can't proceed without a usable media type.
-        # Look at the actual file iff the filename wasn't enough to guess.
-        unless mime.empty?
-          Jekyll.logger.debug(@tag_name, "Detected #{@name} media types: #{mime}")
-        else
-          # Did we fail to guess any MIME::Types from the given filename?
-          # We're going to have to look at the actual file
-          # (or at least its first four bytes).
-          # `@mime` will be readable/writable in the FileMagic.open block context
-          # since it was already defined in the outer scope.
-          FileMagic.open(:mime) do |fm|
-            # TODO: Support finding files in paths deeper than the Site source.
-            # There's no good way to get the path here of the Markdown file
-            # that included our Tag, so relative paths won't work if given
-            # as just a filename. It should work if supplied like:
-            #   ![The coolest image ever](/2020/04/20/some-post/hahanofileextension)
-            # This limitation is normally not a problem since we can guess
-            # the MIME::Types just based on the filename.
-            # It would be possible to supply the Markdown document's path
-            # as an additional argument to {% distorted %} when converting
-            # Markdown in `injection_of_love`, but I am resisting that
-            # approach because it would make DD's Liquid and Markdown entrypoints
-            # no longer exactly equivalent, and that's not okay with me.
-            test_path = File.join(
-              Jekyll::DistorteD::Floor::config(:source),
-              Jekyll::DistorteD::Floor::config(:collections_dir),
-              @name,
-            )
-            # The second argument makes fm.file return just the simple
-            # MIME::Type String, e.g.:
-            #
-            # irb(main):006:1*   fm.file('/home/okeeblow/IIDX-turntable.svg')
-            # => "image/svg+xml; charset=us-ascii"
-            # irb(main):009:1*   fm.file('/home/okeeblow/IIDX-turntable.svg', true)
-            # => "image/svg"
-            #
-            # However MIME::Types won't take short variants like 'image/svg',
-            # so explicitly have FM return long types and split it ourself
-            # on the semicolon:
-            #
-            # irb(main):038:0> "image/svg+xml; charset=us-ascii".split(';').first
-            # => "image/svg+xml"
-            mime = Set[MIME::Types[fm.file(@name, false).split(';'.freeze).first]]
-          end
+      end
 
-          # Did we still not get a type from FileMagic?
-          unless mime
-            if Jekyll::DistorteD::Floor::config(self.class.const_get(:CONFIG_ROOT), :last_resort)
-              Jekyll.logger.debug(@tag_name, "Falling back to bare <img> for #{@name}")
-              mime = Jekyll::DistorteD::Molecule::LastResort::MIME_TYPES
-            else
-              raise MediaTypeNotFoundError.new(@name)
+      # Returns a Set of DD MIME::Types descriving our file,
+      # optionally falling through to a plain file copy.
+      def type_mars
+        @type_mars ||= begin
+          mime = CHECKING::YOU::OUT(@name)
+          if mime.empty?
+            if Jekyll::DistorteD::Floor::config(Jekyll::DistorteD::Floor::CONFIG_ROOT, :last_resort)
+              mime = Jekyll::DistorteD::Molecule::LastResort::LOWER_WORLD
             end
           end
+          mime
         end
+      end
 
-        # Array of drivers to try auto-plugging. Take a shallow copy first because
-        # these will get popped off the end for plug attempts.
-        media_molecules = MEDIA_MOLECULES.dup
-
-        ## Media Driver Autoplugging
-        #
-        # Take the union of this file's detected MIME::Types and
-        # the supported MEDIA_TYPES declared in each molecule.
-        # Molecules will likely declare their Types with a regex:
-        # https://rdoc.info/gems/mime-types/MIME%2FTypes:[]
-        #
-        #
-        # Still-Image Mime::Types Example:
-        # MIME::Types.type_for('IIDX-Readers-Unboxing.jpg')
-        # => [#<MIME::Type: image/jpeg>]
-        #
-        # Video MIME::Types Example:
-        # MIME::Types.type_for('play.mp4') => [
-        #   #<MIME::Type: application/mp4>,
-        #   #<MIME::Type: audio/mp4>,
-        #   #<MIME::Type: video/mp4>,
-        #   #<MIME::Type: video/vnd.objectvideo>
-        # ]
-        #
-        #
-        # Molecule declared-supported MIME::Types Example:
-        # (huge list)
-        #   MIME_TYPES = MIME::Types[/^#{MEDIA_TYPE}/, :complete => true]
-        #
-        #
-        # Detected & Declared MIME::Types Union Example:
-        # MIME::Types.type_for('play.mp4') & MIME::Types[/^video/, :complete => true]
-        # => [#<MIME::Type: video/mp4>, #<MIME::Type: video/vnd.objectvideo>]
-        #
-        # ^ This non-empty example union means we sould try this driver for this file.
-        #
-        #
-        # Loop until we've found a match or tried all available drivers.
-        loop do
-          # Attempt to plug the last driver in the array of enabled drivers.
-          molecule = media_molecules.pop
-
-          # This will be nil once we've tried them all and run out and are on the last loop.
-          if molecule == nil
-            if Jekyll::DistorteD::Floor::config(self.class.const_get(:CONFIG_ROOT), :last_resort)
-              Jekyll.logger.debug(@tag_name, "Falling back to a bare <img> for #{name}")
-              @mime = Jekyll::DistorteD::Molecule::LastResort::MIME_TYPES
-              molecule = Jekyll::DistorteD::Molecule::LastResort
-            else
-              raise MediaTypeNotImplementedError.new(@name)
-            end
-          end
-
-          Jekyll.logger.debug(@tag_name, "Trying to plug #{@name} into #{molecule}")
-
-          # We found a potentially-compatible driver iff the union set is non-empty.
-          if not (mime & molecule.const_get(:MIME_TYPES)).empty?
-            @mime = mime & molecule.const_get(:MIME_TYPES)
-            Jekyll.logger.debug(@tag_name, "Enabling #{molecule} for #{@name}: #{mime}")
-
-            # Override Invoker's stubs by prepending the driver's methods to our DD instance's singleton class.
-            # https://devalot.com/articles/2008/09/ruby-singleton
-            # `self.singleton_class.extend(molecule)` doesn't work in this context.
-            self.singleton_class.instance_variable_set(:@media_molecule, molecule)
-
-            # Set instance variables for the combined set of HTML element
-            # attributes used for this media_type. The global set is defined in this file
-            # (Invoker), and the media_type-specific set is appended to that during auto-plug.
-            attrs = (self.singleton_class.const_get(:GLOBAL_ATTRS) + molecule.const_get(:ATTRS)).to_hash
-            attrs.each_pair do |attr, val|
-              # An attr supplied to the Liquid tag should override any from the config
-              liquid_val = parsed_arguments&.dig(attr)
-              # nil.to_s is '', so print 'nil' for readability.
-              Jekyll.logger.debug("Liquid #{attr}", liquid_val || 'nil')
-
-              if liquid_val.is_a?(String)
-                # Symbolize String values of any attr that has a Molecule-defined list
-                # of acceptable values, or — completely arbitrarily — any String value
-                # shorter than an arbitrarily-chosen constant.
-                # Otherwise freeze them.
-                if (liquid_val.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY) or
-                    molecule.const_get(:ATTRS_VALUES).key?(attr)
-                  liquid_val = liquid_val&.to_sym
-                elsif liquid_val.length > ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY
-                  # Will be default in Ruby 3.
-                  liquid_val = liquid_val&.freeze
-                end
-              end
-
-              attrs[attr] = liquid_val
-            end
-
-            # Save attrs to our instance as the data source for Molecule::Abstract.attrs.
-            @attrs = attrs
-
-            # Plug the chosen Media Molecule!
-            # Using Module#prepend puts the Molecule's ahead in the ancestor chain
-            # of any defined here, or any defined in an `include`d module.
-            (class <<self; prepend @media_molecule; end)
+      # Return any arguments given by the user to our Liquid tag.
+      # This method name is generic across all DD entrypoints so it can be
+      # referenced from lower layers in the pile.
+      def user_arguments
+        @liquid_liquid || Hash[]
+      end
 
-            # Break out of the `loop`, a.k.a. stop auto-plugging!
-            break
-          end
+      # Decides which MediaMolecule is most appropriate for our file and returns it.
+      def media_molecule
+        available_molecules = TYPE_MOLECULES.keys.to_set & type_mars
+        # TODO: Handle multiple molecules for the same file
+        case available_molecules.length
+        when 0
+          raise MediaTypeNotImplementedError.new(@name)
+        when 1
+          return TYPE_MOLECULES[available_molecules.first].first
+        end
+      end
 
+      def plug
+        unless self.singleton_class.instance_variable_defined?(:@media_molecule)
+          self.singleton_class.instance_variable_set(:@media_molecule, media_molecule)
+          self.singleton_class.prepend(media_molecule)
+          Jekyll.logger.info(@name, "Plugging #{media_molecule}")
         end
       end
 
@@ -265,16 +158,18 @@ module Jekyll
       # https://github.com/jekyll/jekyll/blob/HEAD/lib/jekyll/renderer.rb
       # https://jekyllrb.com/tutorials/orderofinterpretation/
       def render(context)
+        plug
         render_to_output_buffer(context, '')
       end
 
       # A future Liquid version (5.0?) will call this function directly
       # instead of calling render()
       def render_to_output_buffer(context, output)
+        plug
         # Get Jekyll Site object back from tag rendering context registers so we
         # can get configuration data and path information from it and
         # then pass it along to our StaticFile subclass.
-        site = context.registers[:site]
+        @site = context.registers[:site]
 
         # The rendering context's `first` page will be the one that invoked us.
         page_data = context.environments.first['page'.freeze]
@@ -282,12 +177,12 @@ module Jekyll
         #
         # Our subclass' additional args:
         # dest - The String path to the generated `url` folder of the page HTML output
-        base = site.source
+        @base = @site.source
 
         # `relative_path` doesn't seem to always exist, but `path` does? idk.
         # I was testing with `relative_path` only with `_posts`, but it broke
         # when I invoked DD on a _page. Both have `path`.
-        dir = File.dirname(page_data['path'.freeze])
+        @dir = File.dirname(page_data['path'.freeze])
 
         # Every one of Ruby's `File.directory?` / `Pathname.directory?` /
         # `FileTest.directory?` methods actually tests that path on the
@@ -298,67 +193,30 @@ module Jekyll
         # directory (like configured on cooltrainer) or a `.html`
         # (or other extension) like the default Jekyll config.
         # Get the dirname if the url is not a dir itself.
-        @dd_dest = @url = page_data['url'.freeze]
-        unless @dd_dest[-1] == Jekyll::DistorteD::Floor::PATH_SEPARATOR
-          @dd_dest = File.dirname(@dd_dest)
+        @relative_dest = page_data['url'.freeze]
+        unless @relative_dest[-1] == Jekyll::DistorteD::Floor::PATH_SEPARATOR
+          @relative_dest = File.dirname(@relative_dest)
           # Append the trailing slash so we don't have to do it
           # in the Liquid templates.
-          @dd_dest << Jekyll::DistorteD::Floor::PATH_SEPARATOR
+          @relative_dest << Jekyll::DistorteD::Floor::PATH_SEPARATOR
         end
 
-        # Create an instance of the media-appropriate Jekyll::StaticFile subclass.
-        #
-        # StaticFile args:
-        # site        - The Jekyll Site object.
-        # base        - The String path to the Jekyll::Site.source, e.g. /home/okeeblow/Works/cooltrainer
-        # dir         - The String path between <base> and the source file, e.g. _posts/2018-10-15-super-cool-post
-        # name        - The String filename of the original media, e.g. cool.jpg
-        # mime        - The Set of MIME::Types of the original media.
-        # attrs       - The Set of attributes given to our Liquid tag, if any.
-        # dd_dest     - The String path under Site.dest to DD's top-level media output directory.
-        # url         - The URL of the page this tag is on.
-        static_file = self.static_file(
-          site,
-          base,
-          dir,
-          @name,
-          @mime,
-          @attrs,
-          @dd_dest,
-          @url,
-        )
-
         # Add our new file to the list that will be handled
         # by Jekyll's built-in StaticFile generator.
-        # Our StaticFile children implement a write() that invokes DistorteD,
-        # but this lets us avoid writing our own Generator.
-        site.static_files << static_file
-      end
-
-      # Called by a Molecule-specific render() method since they will
-      # all load their Liquid template files in the same way.
-      # Bail out if this is not handled by the module we just mixed in.
-      # Any media Molecule must override this to return an instance of
-      # their media-type-appropriate StaticFile subclass.
-      def static_file(site, base, dir, name, mime, attrs, dd_dest, url)
-        raise MediaTypeNotImplementedError.new(name)
+        @site.static_files << self
+        output
       end
 
       # Generic Liquid template loader that will be used in every MediaMolecule.
       # Callers will call `render(**{:template => vars})` on the Object returned
       # by this method.
       def parse_template(site: nil, name: nil)
-        site = site || Jekyll.sites.first
+        site = site || @site || Jekyll.sites.first
         begin
           # Use a given filename, or detect one based on media-type.
           if name.nil?
-            # Template filename is based on the MEDIA_TYPE and/or SUB_TYPE declared
-            # in the plugged MediaMolecule for the given input file.
-            if self.singleton_class.const_defined?(:SUB_TYPE)
-              name = "#{self.singleton_class.const_get(:SUB_TYPE)}.liquid".freeze
-            else
-              name = "#{self.singleton_class.const_get(:MEDIA_TYPE)}.liquid".freeze
-            end
+            # e.g. Jekyll::DistorteD::Molecule::Image -> 'image.liquid'
+            name = "#{self.singleton_class.instance_variable_get(:@media_molecule).name.gsub(/^.*::/, '').downcase}.liquid".freeze
           elsif not name.include?('.liquid'.freeze)
             # Support filename arguments with and without file extension.
             # The given String might already be frozen, so concatenating
@@ -395,6 +253,7 @@ module Jekyll
         end
       end  # parse_template
 
+
     end
   end
 end