jekyll-assets 2.4.0 → 3.0.0

data/Rakefile

@@ -1,4 +1,15 @@
-require "rubocop/rake_task"
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+$stderr = StringIO.new
+require "bundler/setup"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
+$stderr = STDERR
+
+# --
 RSpec::Core::RakeTask.new(:spec)
-task :default => [:spec]
+RuboCop::RakeTask.new(:rubocop) { |t| t.options = %w(--format=e --parallel) }
+Rake::Task[:spec].enhance { Rake::Task[:rubocop].invoke }
+task default: %i(spec rubocop)

data/lib/jekyll/assets.rb

@@ -1,19 +1,23 @@
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
 
-require "sprockets"
-require "extras/all"
 require "pathutil"
 require "jekyll"
 
-requires = [ :liquid,
-  :patches, "", :hooks, :addons,
-  :proxies, :processors]
+# --
+# rubocop:disable Layout/BlockEndNewline
+# rubocop:disable Layout/MultilineBlockLayout
+# rubocop:disable Style/BlockDelimiters
+# --
+def require_all(*globs)
+  path = Pathutil.new("assets").expand_path(__dir__)
+  globs.each { |v| path.glob(v).reject(&:directory?).each do |vv|
+    require vv
+  end }
+end
 
-requires.each do |part|
-  Pathutil.new(__dir__).join('assets', part.to_s)
-    .glob('{*,**/*}.rb').map(&method(
-      :require
-))
+require_relative "assets/env"
+Jekyll::Hooks.register :site, :post_read do |o|
+  Jekyll::Assets::Env.new(o)
 end

data/lib/jekyll/assets/config.rb

@@ -1,80 +1,116 @@
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
 
+require "jekyll"
+require "active_support/hash_with_indifferent_access"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/deep_merge"
+require_relative "hook"
+
 module Jekyll
   module Assets
-    module Config
-      DefaultSources = %W(
-        _assets/css _assets/stylesheets
-        _assets/images _assets/img _assets/fonts
-        _assets/javascripts _assets/js
-      ).freeze
+    class Config < HashWithIndifferentAccess
+      DEVELOPMENT = {
+        digest: false,
+        precompile: [],
+        source_maps: true,
+        destination: "/assets",
+        compression: false,
+        raw_precompile: [],
+        defaults: {},
+        gzip: false,
 
-      # --
+        compressors: {
+          uglifier: {
+            comments: false,
+            harmony:   true,
+          },
+        },
 
-      Development = {
-        "cache_type" => "filesystem",
-        "skip_baseurl_with_cdn" => false,
-        "skip_prefix_with_cdn"  => false,
-        "prefix"    => "/assets",
-        "digest"    => false,
-        "assets"    => [],
-        "autowrite" => true,
+        caching: {
+          path: ".jekyll-cache/assets",
+          enabled: true,
+          type: "file",
+        },
 
-        "compress"  => {
-          "css"     => false,
-          "js"      => false
+        cdn: {
+          baseurl: false,
+          destination: false,
+          url: nil,
         },
 
-        "features" => {
-          "integrity" => false,
-          "automatic_img_alt"  => true,
-          "automatic_img_size" => true,
-          "liquid" => false
-        }
-      }.freeze
+        sources: %w(
+          assets/css
+          assets/fonts
+          assets/images
+          assets/videos
+          assets/audios
+          assets/javascript
+          assets/video
+          assets/audio
+          assets/image
+          assets/img
+          assets/js
 
-      # --
+          _assets/css
+          _assets/fonts
+          _assets/images
+          _assets/videos
+          _assets/audios
+          _assets/javascript
+          _assets/video
+          _assets/audio
+          _assets/image
+          _assets/img
+          _assets/js
+
+          css
+          fonts
+          images
+          videos
+          audios
+          javascript
+          audio
+          video
+          image
+          img
+          js
+        ),
+      }.freeze
 
-      Production = Development.merge({
-        "digest"    => true,
-        "compress"  => {
-          "css"     => true,
-          "js"      => true
-        }
+      PRODUCTION = DEVELOPMENT.deep_merge({
+        source_maps: false,
+        compression: true,
       }).freeze
 
       # --
-      # @param [Jekyll::Site] jekyll The jekyll instance.
-      # Merge our sources with Jekyll's sources.
-      # --
-      def self.merge_sources(jekyll, config) config["sources"] ||= []
-        if !config["sources"].grep(/\A\s*_assets\/?\s*\Z/).empty?
-          return
-
-        else
-          sources = DefaultSources + config["sources"].to_a
-          config["sources"] = Set.new(sources.map do |val|
-            jekyll.in_source_dir(val)
-          end)
-        end
+      def initialize(config)
+        super(self.class.defaults)
+        Hook.trigger(:config, :before_merge) { |h| h.call(self) }
+        deep_merge!(config)
+        merge_sources!
       end
 
       # --
-
+      # @return [HashWithIndifferentAccess]
+      # @note this is useful if you are in safe mode.
+      # The original defaults we have set.
+      # --
       def self.defaults
-        if %W(development test).include?(Jekyll.env)
-          then Development else Production
-        end
+        Jekyll.dev? ? DEVELOPMENT : PRODUCTION
       end
 
       # --
-
-      def self.merge(new_hash, old_hash = defaults)
-        old_hash.merge(new_hash) do |_, old_val, new_val|
-          old_val.is_a?(Hash) && new_val.is_a?(Hash) ? merge(new_val, old_val) : new_val
-        end
+      # Merge our sources with their sources.
+      # @note we don't really allow users to remove our sources.
+      # @return [nil]
+      # --
+      private
+      def merge_sources!
+        ours = self.class.defaults[:sources]
+        theirs = [self[:sources] || []].flatten.compact
+        self[:sources] = theirs | ours
       end
     end
   end

data/lib/jekyll/assets/context.rb

@@ -0,0 +1,32 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require_relative "context"
+require_relative "tag"
+
+# --
+module Jekyll
+  module Assets
+    module Context
+      # --
+      # Allows you to get an asset by it's path.
+      # @note this SASS helper fully supports proxy arguments.
+      # @param [Hash] opts this is unused but necessary.
+      # @param [String] path the path.
+      # @return [String] the path.
+      # --
+      def asset_path(path, _ = {})
+        ctx1 = Liquid::ParseContext.new
+        ctx2 = Liquid::Context.new({}, {}, site: environment.jekyll)
+        Jekyll::Assets::Tag.new("img", "#{path} @path", ctx1)
+          .render(ctx2)
+      end
+    end
+  end
+end
+
+# --
+Jekyll::Assets::Hook.register(:env, :after_init) do
+  context_class.send(:include, Jekyll::Assets::Context)
+end

data/lib/jekyll/assets/default.rb

@@ -0,0 +1,98 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require_relative "extensible"
+require "active_support/hash_with_indifferent_access"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/deep_merge"
+
+module Jekyll
+  module Assets
+    class Default < Extensible
+      # --
+      # @param [String] type the content type.
+      # @param [Hash] args the args from the liquid tag.
+      # Get all of the static defaults.
+      # @return [Hash]
+      # --
+      def self.get(type:, args:)
+        rtn = Default.inherited.select do |o|
+          o.for?({
+            type: type,
+            args: args,
+          })
+        end
+
+        ida = HashWithIndifferentAccess.new
+        rtn.each_with_object(ida) do |v, h|
+          h.deep_merge!(v.static)
+        end
+      end
+
+      # --
+      # Set non-static defaults around the asset.
+      # @param [Hash] args the arguments to work on.
+      # @param [String] type the content type to work with.
+      # @param [Sprockets::Asset] asset the asset.
+      # @param [Env] env the environment.
+      # @return nil
+      # --
+      def self.set(args, asset:, ctx:)
+        set_static(args, asset: asset)
+        rtn = Default.inherited.select do |o|
+          o.for?(type: asset.content_type, args: args)
+        end
+
+        rtn.each do |o|
+          o.new({
+            args: args,
+            asset: asset,
+            ctx: ctx,
+          }).run
+        end
+      end
+
+      # --
+      def self.set_static(args, asset:)
+        get(type: asset.content_type, args: args).each do |k, v|
+          k = k.to_sym
+
+          unless args.key?(k)
+            args[k] = args[k].is_a?(Hash) ?
+              args[k].deep_merge(v) : v
+          end
+        end
+      end
+
+      # --
+      # @param [Hash] hash the defaults.
+      # @note this is used from your inherited class.
+      # Allows you to set static defaults for your defaults.
+      # @return nil
+      # --
+      def self.static(hash = nil)
+        return @static ||= {}.with_indifferent_access if hash.nil?
+        static.deep_merge!(hash)
+      end
+
+      # --
+      # Search for set_* methods and run those setters.
+      # @note this shouldn't be used directly by end-users.
+      # @return nile
+      # --
+      def run
+        methods = self.class.instance_methods - Object.instance_methods
+        methods.grep(%r!^set_!).each do |v|
+          send(v)
+        end
+      end
+
+      # --
+      def config
+        @config ||= @env.asset_config[:defaults][self.class
+          .name.split("::").last.downcase]
+      end
+    end
+  end
+end

data/lib/jekyll/assets/drop.rb

@@ -0,0 +1,62 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "liquid/drop"
+require "forwardable/extended"
+require "fastimage"
+
+module Jekyll
+  module Assets
+    class Drop < Liquid::Drop
+      extend Forwardable::Extended
+      def initialize(path, jekyll:)
+        @path = path
+        @sprockets = jekyll.sprockets
+        @jekyll = jekyll
+        @asset = nil
+      end
+
+      rb_delegate :width,        to: :dimensions, type: :hash
+      rb_delegate :height,       to: :dimensions, type: :hash
+      rb_delegate :basename,     to: :File, args: :@path
+      rb_delegate :content_type, to: :asset
+      rb_delegate :integrity,    to: :asset
+      rb_delegate :filename,     to: :asset
+
+      # --
+      # @todo this needs to move to `_url`
+      # @return [String] the prefixed and digested path.
+      # The digest path.
+      # --
+      def digest_path
+        @sprockets.prefix_url(asset.digest_path)
+      end
+
+      # --
+      # Image dimensions if the asest is an image.
+      # @return [Hash<Integer,Integer>] the dimensions.
+      # @note this can break easily.
+      # --
+      def dimensions
+        @dimensions ||= begin
+          img = FastImage.size(asset.filename.to_s)
+
+          {
+            width:  img.first,
+            height: img.last,
+          }
+        end
+      rescue => e
+        Logger.error e
+      end
+
+      private
+      def asset
+        @asset ||= begin
+          @sprockets.find_asset!(@path)
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/assets/env.rb

@@ -1,340 +1,197 @@
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
 
+require "pathutil"
+require "forwardable/extended"
+require "jekyll/sanity"
+require "sprockets"
+require "jekyll"
+
+require_all "patches/*"
+require_relative "utils"
+require_relative "drop"
+require_relative "version"
+require_relative "filters"
+require_relative "manifest"
+require_relative "config"
+require_relative "logger"
+require_relative "hook"
+require_relative "tag"
+require_relative "url"
+
 module Jekyll
   module Assets
     class Env < Sprockets::Environment
-      attr_accessor :jekyll
-      attr_reader :cache_path
-
-      class << self
-
-        # --
-        # A list of instances for Jekyll and their paths.
-        # This works around Jekyll watch and build booting twice.
-        # @return [Hash]
-        # --
-        def instances
-          return @instances ||= {
-            #
-          }
-        end
-
-        # --
-        # A list of Liquid Proxies.
-        # @return [Set]
-        # --
-        def liquid_proxies
-          Liquid::Tag::Proxies
-        end
+      extend Forwardable::Extended
+      include Utils
 
-        # --
-        # XXX: Remove this in 3.0, it's unecessary.
-        # Initialize a new instance of ourselves onto Jekyll if not exist.
-        # @param [Jekyll::Site] jekyll the site instance.
-        # --
-        def init(jekyll, key = jekyll.in_source_dir)
-          Jekyll.logger.debug "Creating a new instance of: ", self
-          Jekyll.logger.debug "The old value of Sprockets: ",
-            jekyll.sprockets
-
-          instances[key] = new(
-            jekyll
-          )
+      # --
+      attr_reader :manifest
+      attr_reader :asset_config
+      attr_reader :jekyll
 
-          jekyll.sprockets.excludes.map(&jekyll.config["exclude"].method(:<<))
-          jekyll.config["exclude"].uniq!
+      # --
+      def initialize(jekyll = nil)
+        @asset_config = Config.new(jekyll.config["assets"] ||= {})
+        Logger.debug "Callings hooks for env, before_init" do
+          Hook.trigger :env, :before_init do |h|
+            instance_eval(&h)
+          end
         end
-      end
 
-      # --
-      # XXX: Remove in 3.0
-      # Used is deprecated, use Manifest#add.
-      # @return [Manifest]
-      # --
-      def used
-        Logger.deprecate "Env#used is deprecated use Manifest#add", jekyll do
-          manifest
+        super()
+        @jekyll = jekyll
+        @manifest = Manifest.new(self, in_dest_dir)
+        @jekyll.sprockets = self
+        @logger = Logger
+        @cache = nil
+
+        setup_sources!
+        enable_compression!
+        setup_drops!
+        precompile!
+        copy_raw!
+
+        Logger.debug "Calling hooks for env, after_init" do
+          Hook.trigger :env, :after_init do |h|
+            instance_eval(&h)
+          end
         end
       end
 
-      # --
-      # Disables GZIP.  You should be using your server to do this and even
-      # if you don't, there are far better and more efficient algorithms out
-      # right now that are in beta.  Try Googling Googles new compression.
       # --
       def skip_gzip?
-        true
+        !asset_config[:gzip]
       end
 
       # --
-      # Builds a list of excludes for Jekyll.
-      # @return [Set]
+      # @note this is configurable with :caching -> :type
+      # Create a cache, or a null cache (if no caching) for caching.
+      # @note this is configurable with :caching -> :enabled
+      # @return [Sprockets::Cache]
       # --
-      def excludes
-        excludes = Set.new
-        excludes << strip_path(in_cache_dir)
-        excludes
-      end
+      def cache
+        @cache ||= begin
+          type = asset_config[:caching][:type]
+          enbl = asset_config[:caching][:enabled]
+          path = in_cache_dir
 
-      # --
-      # Returns all the assets.
-      # --
-      def all_unparsed_assets
-        @unparsed_assets ||= logical_paths.select do |(_, val)|
-          val.start_with?(jekyll.in_source_dir)
+          out = Sprockets::Cache::MemoryStore.new if enbl && type == "memory"
+          out = Sprockets::Cache::FileStore.new(path) if enbl && type == "file"
+          out = Sprockets::Cache::NullStore.new unless enbl
+          Sprockets::Cache.new(out, Logger)
         end
       end
 
       # --
-      # Converts this class into a set of Drops.
+      # @note this does not find the asset.
+      # Takes all user assets and turns them into a drop.
       # @return [Hash]
       # --
       def to_liquid_payload
-        jekyll.sprockets.all_unparsed_assets.each_with_object({}) do |(key, val), hash|
-          hash[key] = Jekyll::Assets::Liquid::Drop.new(
-            val, jekyll
-          )
-        end
-      end
-
-      # --
-      # Initialize a new instance of this class.
-      # @param [<Anything>] path This is passed upstream, we don't care.
-      # @param [Jekyll::Site] jekyll the Jekyll instances.
-      # XXX: Merge with .init in 3.0
-      # --
-      def initialize(path, jekyll = nil)
-        (jekyll = path; path = nil) if path.is_a?(Jekyll::Site)
-
-        @used = Set.new
-        path ? super(path) : super()
-        @jekyll = jekyll
-
-        # TODO: In Jekyll-Assets 3 this should be fixed up to be a method.
-        @cache_path = asset_config.fetch("cache", ".asset-cache") || ".asset-cache"
-        if File.exist?(cache_path_in_source_dir = jekyll.in_source_dir(@cache_path))
-          @cache_path = cache_path_in_source_dir
-        end
-
-        # XXX: In 3.0, we need to drop anything to do with instance eval,
-        #   and imply pass the instance, this will make our code cleaner.
-
-        Hook.trigger :env, :init do |hook|
-          hook.arity > 0 || 0 > hook.arity ? hook.call(self) : instance_eval(
-            &hook
-          )
-        end
+        each_file.each_with_object({}) do |k, h|
+          skip, path = false, Pathutil.new(strip_paths(k))
+          path.descend do |p|
+            skip = p.start_with?("_")
+            if skip
+              break
+            end
+          end
 
-        # Make sure that we add extras.
-        extra_assets.each do |asset|
-          manifest.add(
-            asset
-          )
+          next if skip
+          h.update({
+            path.to_s => Drop.new(path, {
+              jekyll: jekyll,
+            }),
+          })
         end
       end
 
       # --
-      # A list of Liquid Proxies.
-      # @return [Set]
-      # --
-      def liquid_proxies
-        self.class.liquid_proxies
-      end
-
-      # --
-      # Make a path land inside of our cache directory.
-      # @param [<Anything>] *paths the paths you wish to land.
-      # @return [Pathname/Pathutil]
-      # --
-      def in_cache_dir(*paths)
-        paths.reduce(cache_path) do |base, path|
-          Jekyll.sanitized_path(base, path)
+      def self.old_sprockets?
+        @old_sprockets ||= begin
+          Gem::Version.new(Sprockets::VERSION) < Gem::Version.new("4.0.beta")
         end
       end
 
       # --
-      # Deprecated: Use Manifest#to_compile
-      # XXX: Remove in 3.0
-      # --
-      def all_assets
-        Logger.deprecate "Env#all_assets is deprecated, use Manifest#all", jekyll do
-          manifest.all
-        end
+      private
+      def enable_compression!
+        return unless asset_config[:compression]
+        config = asset_config[:compressors][:uglifier].symbolize_keys
+        self. js_compressor = Sprockets::UglifierCompressor.new(config)
+        self.css_compressor = :scss
       end
 
       # --
-      # Assets you tell us you want to always compile, even if you do not
-      # use them.  Just like Rails this is probably normally used.
-      # --
-      def extra_assets
-        assets = asset_config["assets"] ||= []
-        each_logical_path(*assets).map do |v|
-          manifest.find(v).first
+      def copy_raw!
+        raw_precompiles.each do |v|
+          v[:dst].mkdir_p if v[:dst].extname.empty?
+          v[:dst].parent.mkdir_p unless v[:dst].extname.empty?
+          v[:src].cp(v[:dst])
         end
       end
 
       # --
-      # Whether or not we need a CDN.
-      # --
-      def cdn?
-        !dev? && asset_config.key?("cdn") && \
-          asset_config["cdn"]
-      end
-
-      # --
-      # The BaseURL mixed with Jekyll's own BaseURL.
-      # rubocop:disable Style/ExtraSpacing
-      # --
-      def baseurl
-        ary = []
-
-        ary << jekyll.config["baseurl"] unless cdn? && asset_config["skip_baseurl_with_cdn"]
-        ary <<  asset_config[ "prefix"] unless cdn? && asset_config[ "skip_prefix_with_cdn"]
-
-        File.join(*ary.delete_if do |val|
-          val.nil? || val.empty?
-        end)
-      end
-
-      # --
-      # Whether or not we are in development mode.
-      # rubocop:enable Style/ExtraSpacing
-      # --
-      def dev?
-        %W(development test).include?(Jekyll.env)
-      end
-
-      # --
-      # Whether or not we should compress assets.
-      # --
-      def compress?(what)
-        !!asset_config["compress"].fetch(
-          what, false
-        )
-      end
-
-      # --
-      # The asset configuration.
-      # --
-      def asset_config
-        jekyll.config["assets"] ||= {}
-      end
-
-      # --
-      # Whether or not we are digesting.
-      # @return [true,false]
-      # --
-      def digest?
-        !!asset_config[
-          "digest"
-        ]
-      end
-
-      # --
-      # Prefix path prefixes the path with the baseurl and the cdn if it
-      # exists and is in the right mode to use it.  Otherwise it will only use
-      # the baseurl and asset prefix.  All of these can be adjusted...
-      # @param [String,Pathname,Pathutil] path the path to prefix.
-      # @return [Pathname,Pathutil,String]
-      # --
-      def prefix_path(path = nil)
-        cdn = asset_config["cdn"]
-        base_url = baseurl
-
-        path_ = []
-        path_ << base_url unless base_url.empty?
-        path_ << path unless path.nil?
-
-        url = cdn && cdn?? File.join(cdn, *path_) : File.join(*path_)
-        url.chomp("/")
-      end
-
-
-      # --
-      # Sprockets cached instance.
-      # @return [Cached]
-      # --
-      def cached
-        return @cached ||= Cached.new(
-          self
-        )
-      end
+      private
+      def precompile!
+        assets = asset_config[:precompile]
+        assets.map do |v|
+          v !~ %r!\*! ? manifest.compile(v) : glob_paths(v).each do |sv|
+            manifest.compile(sv)
+          end
+        end
 
-      # --
-      # The manifest we use to pull assets.
-      # @return [Manifest]
-      # --
-      def manifest
-        return @manifest ||= Manifest.new(self, jekyll.in_dest_dir(
-          asset_config["prefix"]
-        ))
+        nil
       end
 
       # --
-      # Write assets with the manifest if they aren't proxied assets.  If
-      # they are then we go on to write them ourselves.  We don't necessarily
-      # integrate with the manifest that deeply because it's hard.
-      # --
-      def write_all
-        assets = manifest.all.to_a.compact
-        if assets.size != manifest.all.size
-          begin
-            Jekyll.logger.error "", "Asset inconsistency, expected " +
-              "#{manifest.all.size}, can only write #{
-                assets.size
-              }"
-          rescue
-            # When a serious error happens in the upstream manifest.
-            Jekyll.logger.error "", "Asset inconsistency, unable to " \
-              "determine the problem, please clear your cache."
+      private
+      def setup_sources!
+        source_dir, cwd = Pathutil.new(jekyll.in_source_dir), Pathutil.cwd
+        asset_config["sources"].each do |v|
+          path = source_dir.join(v).expand_path
+          next unless path.in_path?(cwd)
+          unless paths.include?(path)
+            append_path path
           end
         end
 
-        assets = manifest.all.group_by do |v|
-          v.is_a?(
-            Liquid::Tag::ProxiedAsset
-          )
-        end
-
-        # These are assets that aren't proxied, they returned fals when
-        # they were asked if they belonged to a proxy.
+        paths
+      end
 
-        if assets.key?(false)
-          manifest.compile(assets[false].map(
-            &:logical_path
-          ))
+      # --
+      private
+      def setup_drops!
+        Jekyll::Hooks.register :site, :pre_render do |_, h|
+          h["assets"] = to_liquid_payload
         end
+      end
 
-        # Proxied assets will not compile the normal way since they are
-        # always considered uniq when used, and they supply their own inline
-        # caching, so we always write them individually since they will
-        # never actually show up inside of the manifest.
-
-        if assets.key?(true)
-          unless assets[true].empty?
-            Pathutil.new(in_cache_dir)
-              .mkdir_p
-          end
+      require_all "plugins/*"
+      require_all "plugins/html/defaults/*"
+      require_all "plugins/html/*"
+      require_relative "context"
+      require_relative "writer"
 
-          assets[true].map do |asset|
-            asset.write_to(jekyll.in_dest_dir(File.join(asset_config["prefix"],
-              digest?? asset.digest_path : asset.logical_path
-            )))
-          end
+      require_relative "map" unless old_sprockets?
+      Hook.register :env, :after_init, priority: 3 do
+        unless self.class.old_sprockets?
+          Map.register_on(self)
         end
       end
 
       # --
-      # Undocumented
+      # @see https://github.com/rails/sprockets/pull/523
+      # Registers a few MimeTypes since I don't think
+      #   Sprockets will update before we release, so we
+      #   need them to be available.
       # --
-      private
-      def strip_path(path)
-        path.sub(jekyll.in_source_dir("/"),
-          ""
-        )
-      end
+      Sprockets.register_mime_type "audio/mp4", extensions: %w(.m4a)
+      Sprockets.register_mime_type "audio/ogg", extensions: %w(.ogg .oga)
+      Sprockets.register_mime_type "audio/flac", extensions: %w(.flac)
+      Sprockets.register_mime_type "audio/aac", extensions: %w(.aac)
     end
   end
 end