jekyll-assets 2.1.3 → 2.2.0

data/lib/jekyll/assets/logger.rb

@@ -1,6 +1,8 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
@@ -11,38 +13,50 @@ module Jekyll
         @_log ||= Jekyll.logger
       end
 
+      # ----------------------------------------------------------------------
       # Log Level: 1
+      # ----------------------------------------------------------------------
 
-      def warn(msg = nil, &block)
-        msg = (block_given?? block.call : msg)
-        log.warn(PREFIX, msg)
+      def warn(msg = nil)
+        log.warn(PREFIX,
+          block_given?? yield : msg
+        )
       end
 
+      # ----------------------------------------------------------------------
       # Log Level: 1
+      # ----------------------------------------------------------------------
 
-      def error(msg = nil, &block)
-        msg = (block_given?? block.call : msg)
-        log.error(PREFIX, msg)
+      def error(msg = nil)
+        log.error(PREFIX,
+          block_given?? yield : msg
+        )
       end
 
+      # ----------------------------------------------------------------------
       # Log Level: 2
+      # ----------------------------------------------------------------------
 
-      def info(msg = nil, &block)
-        msg = (block_given?? block.call : msg)
-        log.info(PREFIX, msg)
+      def info(msg = nil)
+        log.info(PREFIX,
+          block_given?? yield : msg
+        )
       end
 
+      # ----------------------------------------------------------------------
       # Log Level: 3
+      # ----------------------------------------------------------------------
 
-      def debug(msg = nil, &block)
-        msg = (block_given?? block.call : msg)
-        log.debug(PREFIX, msg)
+      def debug(msg = nil)
+        log.debug(PREFIX,
+          block_given?? yield : msg
+        )
       end
 
-      #
+      # ----------------------------------------------------------------------
 
       def log_level=(*)
-        raise RuntimeError, "Please set log levels on Jekyll.logger"
+        raise "Please set log levels on Jekyll.logger"
       end
     end
   end

data/lib/jekyll/assets/manifest.rb

@@ -0,0 +1,98 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2012 - 2016 - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Jekyll
+  module Assets
+
+    # ------------------------------------------------------------------------
+    # This is a wholesale rip of Sprockets::Manifest, we only adjust it to
+    # care about whether or not we want to digest, we don't always digest.
+    # ------------------------------------------------------------------------
+
+    class Manifest < Sprockets::Manifest
+      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
+
+          target = \
+          if environment.digest?
+            File.join(dir,
+              asset.digest_path
+            )
+          else
+            File.join(dir,
+              asset.logical_path
+            )
+          end
+
+          if File.exist?(target)
+            logger.debug(
+              "Skipping #{target}, already exists"
+            )
+          else
+            logger.info "Writing #{target}"
+            write_file = Concurrent::Future.execute { asset.write_to target }
+            concurrent_writers << write_file
+          end
+
+          filenames << asset.filename
+          next if environment.skip_gzip?
+          gzip = Utils::Gzip.new(asset)
+          next if gzip.cannot_compress?(
+            environment.mime_types
+          )
+
+          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!
+        )
+
+        save
+        filenames
+      end
+    end
+  end
+end

data/lib/jekyll/assets/patches.rb

@@ -1,8 +1,10 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
-require_relative "patches/jekyll/cleaner"
 require_relative "patches/sprockets/asset"
+require_relative "patches/sprockets/helpers"
 require_relative "patches/jekyll/site"
 require_relative "patches/kernel"

data/lib/jekyll/assets/patches/jekyll/site.rb

@@ -1,7 +1,3 @@
-# Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
-# Encoding: utf-8
-
 module Jekyll
   class Site
     attr_accessor :sprockets

data/lib/jekyll/assets/patches/kernel.rb

@@ -1,20 +1,10 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Kernel
-  def javascript?
-    require "execjs"
-    if block_given?
-      yield
-    end
-  rescue LoadError, ExecJS::RuntimeUnavailable
-    Jekyll.logger.debug("ExecJS or JS Runtime not available." \
-      " Skipping loading of library.")
-  end
-
-  #
-
   def try_require(file)
     require file
     if block_given?
@@ -24,7 +14,7 @@ module Kernel
     return nil
   end
 
-  #
+  # --------------------------------------------------------------------------
 
   def try_require_if_javascript(file)
     ["execjs", file].map(&method(:require))

data/lib/jekyll/assets/patches/sprockets/asset.rb

@@ -1,17 +1,23 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Sprockets
   class Asset
     def liquid_tags
-      metadata[:liquid_tags] ||= Set.new
+      metadata[:liquid_tags] ||= begin
+        Set.new
+      end
     end
 
-    #
+    # ------------------------------------------------------------------------
 
     def data_uri
-      "data:#{content_type};base64,#{Rack::Utils.escape(Base64.encode64(to_s))}"
+      "data:#{content_type};base64,#{Rack::Utils.escape(
+        Base64.encode64(to_s)
+      )}"
     end
   end
 end

data/lib/jekyll/assets/patches/sprockets/helpers.rb

@@ -0,0 +1,31 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2012 - 2016 - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "sprockets/helpers"
+Sprockets::Helpers.instance_methods.reject { |v| v=~ /^(path_to_|assets_environment$)/ }.each do |m|
+  Sprockets::Helpers.send(:define_method, m.to_s.gsub(/_path$/, "_url")) do |*args|
+    %Q(url("#{send(m, *args)}"))
+  end
+end
+
+module Sprockets
+  module Helpers
+    alias_method :_old_ap, :asset_path
+
+    def rcache
+      return @resolver_cache ||= {
+        #
+      }
+    end
+
+    def asset_path(asset, h = {})
+      return unless out = _old_ap(asset)
+      path = environment.find_asset(resolve_without_compat(asset))
+      environment.parent.used.add(path)
+    out
+    end
+  end
+end

data/lib/jekyll/assets/processors.rb

@@ -0,0 +1 @@
+require_relative "processors/liquid"

data/lib/jekyll/assets/processors/less.rb

@@ -0,0 +1,68 @@
+require "less"
+
+module Jekyll
+  module Assets
+    module Processors
+      class LESS
+
+        # --------------------------------------------------------------------
+        # Setup and pull out the context and update the data, shipping it.
+        # --------------------------------------------------------------------
+
+        def self.call(input)
+          data = input[:data]; paths = [input[:load_path]]
+          tree = Less.instance_variable_get(:@loader).require("less/tree")
+          context = input[:environment].context_class.new(input)
+          patch_tree(tree, context)
+
+          paths |= input[:environment].paths
+          paths |= Dir.glob(input[:load_path] + '/*').select(&File.method(:directory?))
+          parser = Less::Parser.new(:paths => paths)
+
+          context.metadata.merge({
+            :data => Less::Parser.new(:paths => paths) \
+              .parse(data).to_css
+          })
+        end
+
+        # --------------------------------------------------------------------
+        # Add the sprockets helpers into the Less environment so people can
+        # use assets from within Less... as they see fit.
+        # --------------------------------------------------------------------
+        # We also make sure to disable their quotes so that we can quote
+        # ourselves if we need to, otherwise we simply just take the values.
+        # --------------------------------------------------------------------
+
+        def self.patch_tree(tree, context)
+          Sprockets::Helpers.instance_methods.reject { |v| v=~ /^(path_to_|assets_environment$)/ }.each do |m|
+            tree.functions[m.to_s.tr("_", "-")] = tree.functions[m.to_s] = lambda do |*args|
+              args.last.tap do |o|
+                o[:quote] = "" # We handle that ourselves, fuck that.
+                o[:value] = context.send(m, args.last.toCSS().gsub(
+                  /^"|"$/, ""
+                ))
+
+                if m.to_s.end_with?("_path")
+                  o[:value] = o[:value].inspect
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# ----------------------------------------------------------------------------
+
+if Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new(4.0)
+  Sprockets.register_mime_type "text/less", :extensions => [".less", ".css.less"]
+  Sprockets.register_transformer("text/less", "test/css",
+    Jekyll::Assets::Processors::LESS
+  )
+else
+  Sprockets.register_engine(
+    ".less", Jekyll::Assets::Processors::LESS
+  )
+end

data/lib/jekyll/assets/processors/liquid.rb

@@ -0,0 +1,46 @@
+module Jekyll
+  module Assets
+    module Processors
+      class Liquid
+        FOR = %W(
+          text/css text/sass text/less application/javascript
+          text/scss text/coffeescript text/javascript).freeze
+        EXT = %W(.liquid .js.liquid .css.liquid .scss.liquid).freeze
+
+        # --------------------------------------------------------------------
+
+        def self.call(context, jekyll = context[:environment].jekyll)
+          if context[:environment].parent.asset_config["features"]["liquid"] || \
+              File.extname(context[:filename]) == ".liquid"
+
+            payload_ = jekyll.site_payload
+            renderer = jekyll.liquid_renderer.file(context[:filename])
+            context[:data] = renderer.parse(context[:data]).render! payload_, \
+              :filters => [Jekyll::Filters],
+              :registers => {
+                :site => jekyll
+              }
+          end
+        end
+      end
+    end
+  end
+end
+
+# ----------------------------------------------------------------------------
+# There might be a few missing, if there is please do let me know.
+# ----------------------------------------------------------------------------
+
+Jekyll::Assets::Processors::Liquid::EXT.each do |ext|
+  Sprockets.register_engine(
+    ext, Jekyll::Assets::Processors::Liquid
+  )
+end
+
+# ----------------------------------------------------------------------------
+
+Jekyll::Assets::Processors::Liquid::FOR.each do |val|
+  Sprockets.register_preprocessor(
+    val, Jekyll::Assets::Processors::Liquid
+  )
+end

data/lib/jekyll/assets/proxies.rb

@@ -0,0 +1 @@
+require_relative "proxies/magick"

data/lib/jekyll/assets/proxies/magick.rb

@@ -0,0 +1,167 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2012 - 2016 - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+try_require "mini_magick" do
+  args = %W(resize quality rotate crop flip gravity)
+  presets = %W(@2x @4x @1/2 @1/3 @2/3 @1/4 @2/4 @3/4
+    @double @quadruple @half @one-third @two-thirds @one-fourth
+      @two-fourths @three-fourths)
+
+  Jekyll::Assets::Env.liquid_proxies.add :magick, :img, *(args + presets) do
+    PRESETS = presets
+    ARGS = args
+
+    class DoubleResizeError < RuntimeError
+      def initialize
+        "Both resize and @*x provided, this is not supported."
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # @see https://github.com/minimagick/minimagick#usage -- All but
+    #   the boolean @ options are provided by Minimagick.
+    # ------------------------------------------------------------------------
+
+    def initialize(asset, opts, args)
+      @path = asset.filename
+      @opts = opts
+      @asset = asset
+      @args = args
+    end
+
+    # ------------------------------------------------------------------------
+
+    def process
+      img = MiniMagick::Image.open(@path)
+      methods = private_methods(true).select { |v| v.to_s.start_with?("magick_") }
+      if img.respond_to?(:combine_options)
+        then img.combine_options do |cmd|
+          methods.each do |method|
+            send(
+              method, img, cmd
+            )
+          end
+        end
+
+      else
+        methods.each do |method|
+          send(
+            method, img, img
+          )
+        end
+      end
+
+      img.write(
+        @path
+      )
+    ensure
+      img.destroy!
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def any_preset?(*keys)
+      @opts.keys.any? do |key|
+        keys.include?(key)
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def preset?
+      (@opts.keys - ARGS.map(&:to_sym)).any?
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_quality(_, cmd)
+      if @opts.key?(:quality)
+        then cmd.quality @opts[:quality]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_resize(_, cmd)
+      raise DoubleResizeError if @opts.key?(:resize) && preset?
+      if @opts.key?(:resize)
+        then cmd.resize @opts[:resize]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_rotate(_, cmd)
+      if @opts.key?(:rotate)
+        then cmd.rotate @opts[:rotate]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_flip(_, cmd)
+      if @opts.key?(:flip)
+        then cmd.flip @opts[:flip]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_crop(_, cmd)
+      if @opts.key?(:crop)
+        then cmd.crop @opts[:crop]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_gravity(_, cmd)
+      if @opts.key?(:gravity)
+        then cmd.gravity @opts[:gravity]
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # I just want you to know, we don't even care if you do multiple
+    # resizes or try to, we don't attempt to even attempt to attempt to care
+    # we expect you to be logical and if you aren't we will comply.
+    # ------------------------------------------------------------------------
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Style/ParallelAssignment
+    # rubocop:disable Metrics/AbcSize
+    # ------------------------------------------------------------------------
+
+    private
+    def magick_preset_resize(img, cmd)
+      return unless preset?
+      width, height = img.width * 4, img.height * 4 if any_preset?(:"4x", :quadruple)
+      width, height = img.width * 2, img.height * 2 if any_preset?(:"2x", :double)
+      width, height = img.width / 2, img.height / 2 if any_preset?(:"1/2", :half)
+      width, height = img.width / 3, img.height / 3 if any_preset?(:"1/3", :"one-third")
+      width, height = img.width / 4, img.height / 4 if any_preset?(:"1/4", :"one-fourth")
+      width, height = img.width / 3 * 2, img.height / 3 * 2 if any_preset?(:"2/3", :"two-thirds")
+      width, height = img.width / 4 * 2, img.height / 4 * 2 if any_preset?(:"2/4", :"two-fourths")
+      width, height = img.width / 4 * 3, img.height / 4 * 3 if any_preset?(:"3/4", :"three-fourths")
+      cmd.resize "#{width}x#{height}"
+    end
+
+    # ------------------------------------------------------------------------
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Style/ParallelAssignment
+    # rubocop:enable Metrics/AbcSize
+    # ------------------------------------------------------------------------
+  end
+end