jekyll-assets 2.4.0 → 3.0.0

data/lib/jekyll/assets/manifest.rb

@@ -1,144 +1,33 @@
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
 
-require 'concurrent/future'
+require "sprockets/manifest"
 
 module Jekyll
   module Assets
     class Manifest < Sprockets::Manifest
-      extend Forwardable::Extended
-      rb_delegate :add, {
-        :to => :used
-      }
+      attr_reader :data
 
       # --
-      # The assets to be compiled.
-      # @return [Set]
+      # Works around some weird behavior in Sprockets 3.x that seemd to make
+      # it so that when you use an absolute path, it was automatically a filter
+      # and so you could never find an asset that was dynamically added.
       # --
-      def used
-        return @used ||= Set.new
+      def self.simple_logical_path?(file)
+        super || File.file?(file)
       end
 
       # --
-      # All the assets, plus the used.
-      # @return [Set]
+      # Allows you to add a manifest key for us to keep.
+      # @note the format should be `key: { hashKey: hashVal }` or `key: []`
+      # @note complex keys aren't supported.
+      # @return [Array<String>]
       # --
-      def all
-        used | (files.map do |_, v|
-          find(v["logical_path"]).first if v
-        end).compact
-      end
-
-      # --
-      # This is a wholesale rip of Sprockets::Manifest#compkle, we only
-      # adjust it to care about whether or not we want to digest, we don't
-      # always digest in development.
-      # --
-      def compile(*args)
-        unless environment
-          raise(
-            Error, "manifest requires environment for compilation"
-          )
-        end
-
-        # --
-
-        filenames = []
-        concurrent_compressors = []
-        concurrent_writers = []
-
-        # --
-
-        find(*args) do |asset|
-          files[asset.digest_path] = {
-            "mtime" => asset.mtime.iso8601,
-            "logical_path" => asset.logical_path,
-            "integrity"  => Sprockets::DigestUtils.hexdigest_integrity_uri(asset.hexdigest),
-            "digest" => asset.hexdigest,
-            "size" => asset.bytesize
-          }
-
-          # --
-
-          assets[asset.logical_path] = asset.digest_path
-          alias_logical_path = self.class.compute_alias_logical_path(
-            asset.logical_path
-          )
-
-          # --
-
-          if alias_logical_path
-            assets[alias_logical_path] = asset.digest_path
-          end
-
-          # Unlike upstream, we allow users to disble digesting, this is
-          # where we actually and truthfully only diverge from upstream in
-          # that we disable or enable the digested or logical path.
-
-          target = \
-          if environment.digest?
-            File.join(dir,
-              asset.digest_path
-            )
-          else
-            File.join(dir,
-              asset.logical_path
-            )
-          end
-
-          # --
-
-          if !environment.digest? || !File.exist?(target)
-            logger.info "Writing #{target}"
-            write_file = Concurrent::Future.execute { asset.write_to target }
-            concurrent_writers << write_file
-
-          else
-            logger.debug(
-              "Skipping #{target}, already exists"
-            )
-          end
-
-          # --
-
-          filenames << asset.filename
-          next if environment.skip_gzip?
-          gzip = Utils::Gzip.new(asset)
-          next if gzip.cannot_compress?(
-            environment.mime_types
-          )
-
-          # This is technically ignored usptream, we don't allow our
-          # assets to write `.tar.gz` files by default, however, we leave
-          # this here just incase someobody overrides that method.
-
-          if File.exist?("#{target}.gz")
-            logger.debug(
-              "Skipping #{target}.gz, already exists"
-            )
-          else
-            logger.info "Writing #{target}.gz"
-            concurrent_compressors << Concurrent::Future.execute do
-              write_file.wait! if write_file
-              gzip.compress(
-                target
-              )
-            end
-          end
-        end
-
-        # --
-
-        concurrent_writers.each(&:wait!)
-        concurrent_compressors.each(
-          &:wait!
+      def self.keep_keys
+        @keep_keys ||= %w(
+          assets
         )
-
-        # --
-
-        save
-        filenames
       end
     end
   end

data/lib/jekyll/assets/map.rb

@@ -0,0 +1,57 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require_relative "map/css"
+require_relative "map/javascript"
+require_relative "map/writer"
+require "pathutil"
+
+module Jekyll
+  module Assets
+    module Map
+      NAME = "%s.map"
+      DIR_NAME = "source-maps"
+      DIR = Pathutil.new(DIR_NAME)
+      EXT = ".map"
+
+      # --
+      # @return [String] the map name.
+      # Take the path, and attach the map extension.
+      # @note this just saves logic.
+      # --
+      def self.map_path(env:, asset:)
+        [
+          path({
+            asset: asset,
+            env: env,
+          }),
+          EXT,
+        ].join
+      end
+
+      # --
+      # @note this is used for anything in source-maps.
+      # Strip the filename and return a relative sourcemap path.
+      # @return [Pathutil] the path.
+      # --
+      def self.path(env:, asset:)
+        DIR.join(env.strip_paths(asset.is_a?(Sprockets::Asset) ?
+          asset.filename : asset))
+      end
+
+      # --
+      def self.register_on(instance)
+        return unless instance.asset_config[:source_maps]
+        unless instance.asset_config[:compression]
+          instance.logger.warn "Compression is ignored w/ SourceMaps"
+        end
+
+        # Register everything, so we can get this party started.
+        [Writer, JavaScript, CSS].map { |v| v.register_on(instance) }
+        instance.css_compressor, instance.js_compressor =
+          :source_map, :source_map
+      end
+    end
+  end
+end

data/lib/jekyll/assets/map/css.rb

@@ -0,0 +1,43 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "sprockets"
+
+module Jekyll
+  module Assets
+    module Map
+      class CSS < Sprockets::SassCompressor
+        def call(input)
+          out = super(input)
+          env = input[:environment]
+          asset = env.find_asset!(input[:filename], pipeline: :source)
+          path = asset.filename.sub(env.jekyll.in_source_dir + "/", "")
+          url = Map.map_path(asset: asset, env: env)
+          url = env.prefix_url(url)
+
+          out.update({
+            data: <<~CSS
+              #{out[:data].strip}
+              /*# sourceMappingURL=#{url} */
+              /*# sourceURL=#{path} */
+            CSS
+          })
+        end
+
+        def self.register_on(instance)
+          content_type = "text/css"
+          instance.register_compressor content_type,
+            :source_map, CSS
+        end
+      end
+
+      # --
+      # We load late in some cases.
+      # You can also register it in a Hook.
+      # Globally Register it.
+      # --
+      CSS.register_on(Sprockets)
+    end
+  end
+end

data/lib/jekyll/assets/map/javascript.rb

@@ -0,0 +1,43 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "sprockets"
+
+module Jekyll
+  module Assets
+    module Map
+      class JavaScript < Sprockets::UglifierCompressor
+        def call(input)
+          out = super(input)
+          env = input[:environment]
+          asset = env.find_asset!(input[:filename], pipeline: :source)
+          path = asset.filename.sub(env.jekyll.in_source_dir + "/", "")
+          url = Map.map_path(asset: asset, env: env)
+          url = env.prefix_url(url)
+
+          out.update({
+            data: <<~TXT
+              #{input[:data].strip}
+              //# sourceMappingURL=#{url}
+              //# sourceURL=#{path}
+            TXT
+          })
+        end
+
+        def self.register_on(instance)
+          content_type = "application/javascript"
+          instance.register_compressor(content_type,
+            :source_map, self)
+        end
+      end
+
+      # --
+      # We load late in some cases.
+      # You can also register it in a Hook.
+      # Globally Register it.
+      # --
+      JavaScript.register_on(Sprockets)
+    end
+  end
+end

data/lib/jekyll/assets/map/writer.rb

@@ -0,0 +1,192 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "sprockets"
+require "pathutil"
+
+module Jekyll
+  module Assets
+    module Map
+      class Writer < Sprockets::Exporters::Base
+        alias env environment
+
+        def skip?(_)
+          !env.asset_config[:source_maps] ||
+            !asset.metadata[:map]
+        end
+
+        # --
+        def call
+          clean_file!
+          clean_sources!
+          write_map!
+          write_src!
+        end
+
+        # --
+        # Provides our custom manifest key, full of files.
+        # @note We push everything from the file we are writing to the maps.
+        # @return [Array<String>]
+        # --
+        def files
+          @files ||= begin
+            key = "sourceMapFiles"
+            out = env.manifest.data[key] ||= []
+            unless Manifest.keep_keys.include?(key)
+              Manifest.keep_keys << key
+            end
+
+            out
+          end
+        end
+
+        # --
+        def self.register_on(instance)
+          instance.register_exporter("*/*", self)
+        end
+
+        # --
+        # @return [HashWithIndifferentAccess]
+        # @note do not modify the original map.
+        # Provides a modifible SourceMap
+        # --
+        private
+        def map
+          @map ||= asset.metadata[:map]
+            .with_indifferent_access
+        end
+
+        # --
+        # @return [HashWithIndifferentAccess]
+        # @note this is frozen so you can't modify.
+        # Provides an unmodifiable SourceMap
+        # --
+        private
+        def original_map
+          @original_map ||= asset.metadata[:map]
+            .with_indifferent_access.freeze
+        end
+
+        # --
+        # @note something like _assets/*
+        # Makes sure that the name sits in the asset path.
+        # @return [String]
+        # --
+        private
+        def clean_file!
+          map[:file] = base.join(map[:file]).to_s
+        end
+
+        # --
+        private
+        def clean_sources!
+          if map[:sources]
+            then map[:sources] = map[:sources].map do |v|
+              base.join(strip_src(v))
+            end
+          else
+            map[:sections].each do |v|
+              v[:map][:sources] = v[:map][:sources].map do |vv|
+                base.join(strip_src(vv))
+              end
+            end
+          end
+
+          map
+        end
+
+        # --
+        private
+        def strip_src(path)
+          path = Pathutil.new(path)
+          base = path.basename.gsub(%r!\.source!, "")
+          return path.dirname.join(base).to_s unless path.dirname == "."
+          base.to_s if path.dirname == "."
+        end
+
+        # --
+        # @note we shim this on name.
+        # Privates the base directory in the source.
+        # @return [String]
+        # --
+        private
+        def base
+          Pathutil.new(asset.filename.sub(env.jekyll
+            .in_source_dir + "/", "")).dirname
+        end
+
+        # --
+        # rubocop:disable Layout/BlockEndNewline
+        # rubocop:disable Layout/MultilineBlockLayout
+        # rubocop:disable Style/BlockDelimiters
+        # --
+        private
+        def map_files
+          return original_map[:sources] if original_map.key?(:sources)
+          original_map[:sections].map { |v| v[:map][:sources] \
+            if v.key?(:map) }.flatten.compact
+        end
+
+        # --
+        # rubocop:enable Layout/BlockEndNewline
+        # rubocop:enable Layout/MultilineBlockLayout
+        # rubocop:enable Style/BlockDelimiters
+        # --
+        private
+        def write_map!
+          path = Map.map_path(asset: asset, env: env)
+          write(env.in_dest_dir(path)) do |f|
+            files.push(path)
+            f.write(map.to_json)
+            files.uniq!
+          end
+        end
+
+        # --
+        private
+        def strip_base(asset)
+          return asset if asset.is_a?(Sprockets::Asset)
+          asset.sub(base + "/", "")
+        end
+
+        # --
+        private
+        def write_src!
+          [asset_path, map_files].flatten.compact.uniq.each do |v|
+            v = env.find_asset!(strip_base(v), pipeline: :source)
+            path = map_path(v.filename)
+
+            write(environment.in_dest_dir(path)) do |f|
+              f.write(v.source)
+              files.push(path.to_s)
+                .uniq!
+            end
+          end
+        end
+
+        # --
+        private
+        def asset_path
+          base.join(env.strip_paths(@asset.filename)).to_s
+        end
+
+        # --
+        private
+        def map_path(file)
+          asset = base.join(env.strip_paths(file))
+          Map.path({
+            asset: asset, env: env
+          })
+        end
+      end
+
+      # --
+      # We load late in some cases.
+      # You can also register it in a Hook.
+      # Globally Register it.
+      # --
+      Writer.register_on(Sprockets)
+    end
+  end
+end