jekyll-assets 2.1.3 → 2.2.0

data/lib/jekyll/assets/hooks/jekyll/write.rb

@@ -1,7 +1,11 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 Jekyll::Hooks.register :site, :post_write do |jekyll|
-  jekyll.sprockets.write_all
+  if jekyll.sprockets.asset_config["autowrite"]
+    then jekyll.sprockets.write_all
+  end
 end

data/lib/jekyll/assets/hooks/logger.rb

@@ -1,7 +1,11 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 Jekyll::Assets::Hook.register :env, :init do
-  self.logger = Jekyll::Assets::Logger.new
+  if jekyll.config["verbose"]
+    self.logger = Jekyll::Assets::Logger.new
+  end
 end

data/lib/jekyll/assets/hooks/sources.rb

@@ -1,9 +1,12 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 Jekyll::Assets::Hook.register :env, :init do
   asset_config["sources"] ||= []
+
   asset_config["sources"].each do |path|
     append_path jekyll.in_source_dir(path)
   end

data/lib/jekyll/assets/hooks/sprockets.rb

@@ -1,6 +1,8 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 Jekyll::Assets::Hook.register :env, :init do
   jekyll.sprockets = self

data/lib/jekyll/assets/hooks/version.rb

@@ -1,7 +1,11 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 Jekyll::Assets::Hook.register :env, :init do
-  self.version = Digest::MD5.hexdigest(asset_config.inspect)
+  self.version = Digest::MD5.hexdigest(
+    asset_config.inspect
+  )
 end

data/lib/jekyll/assets/liquid.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

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

@@ -1,6 +1,8 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 require "fastimage"
 
@@ -15,33 +17,46 @@ module Jekyll
           @asset = nil
         end
 
+        # --------------------------------------------------------------------
+
+        def_delegator :asset, :digest_path
         def_delegator :asset, :logical_path
         def_delegator :asset, :content_type, :type
         def_delegator :asset, :content_type
         def_delegator :asset, :filename
 
+        # --------------------------------------------------------------------
+
         def basename
           File.basename(@path)
         end
 
+        # --------------------------------------------------------------------
+
         def width
           if image?
             dimensions.first
           end
         end
 
+        # --------------------------------------------------------------------
+
         def height
           if image?
             dimensions.last
           end
         end
 
+        # --------------------------------------------------------------------
+
         def dimensions
           if image?
             @dimensions ||= FastImage.new(asset.filename).size
           end
         end
 
+        # --------------------------------------------------------------------
+
         private
         def image?
           %W(image/png image/jpeg image/gif).include?(
@@ -49,9 +64,12 @@ module Jekyll
           )
         end
 
+        # --------------------------------------------------------------------
+
         private
         def asset
-          @asset ||= @jekyll.sprockets.find_asset(@path)
+          @asset ||= @jekyll.sprockets.manifest.find(@path) \
+            .first
         end
       end
     end

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

@@ -1,21 +1,17 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
     module Liquid
       module Filters
-        ACCEPTABLE_FILTERS = %W(
-          css
-          image
-          asset_path
-          stylesheet
-          javascript
-          style
-          img
-          js
-        )
+        ACCEPTABLE_FILTERS = [:css, :img, :asset_path, :stylesheet,
+          :javascript, :style, :img, :js]
+
+        # --------------------------------------------------------------------
 
         ACCEPTABLE_FILTERS.each do |val|
           define_method val do |path, args = ""|
@@ -23,9 +19,12 @@ module Jekyll
           end
         end
       end
+
+      #
+
+      ::Liquid::Template.register_filter(
+        Filters
+      )
     end
   end
 end
-
-# Register it with Liquid, good luck from here.
-Liquid::Template.register_filter(Jekyll::Assets::Liquid::Filters)

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

@@ -1,6 +1,8 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012-2015 - MIT License
+# Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 require "fastimage"
 
@@ -14,17 +16,23 @@ module Jekyll
         require_relative "tag/parser"
         attr_reader :args
 
+        # --------------------------------------------------------------------
+
         class << self
           public :new
         end
 
+        # --------------------------------------------------------------------
+
         class AssetNotFoundError < StandardError
           def initialize(asset)
             super "Could not find the asset `#{asset}'"
           end
         end
 
-        #
+        # --------------------------------------------------------------------
+        # Tags that we allow our users to use.
+        # --------------------------------------------------------------------
 
         AcceptableTags = %W(
           img
@@ -39,15 +47,19 @@ module Jekyll
           js
         ).freeze
 
-        #
+        # --------------------------------------------------------------------
+        # The HTML version of every tag that we accept.
+        # --------------------------------------------------------------------
 
         Tags = {
-          "css" => %{<link type="text/css" rel="stylesheet" href="%s"%s>},
-          "js"  => %{<script type="text/javascript" src="%s"%s></script>},
-          "img" => %{<img src="%s"%s>}
+          "css" => %(<link type="text/css" rel="stylesheet" href="%s"%s>),
+          "js"  => %(<script type="text/javascript" src="%s"%s></script>),
+          "img" => %(<img src="%s"%s>)
         }.freeze
 
-        #
+        # --------------------------------------------------------------------
+        # Allows us to normalize tags so we can simplify logic.
+        # --------------------------------------------------------------------
 
         Alias = {
           "image" => "img",
@@ -56,9 +68,10 @@ module Jekyll
           "style" => "css"
         }.freeze
 
-        #
+        # --------------------------------------------------------------------
 
         def initialize(tag, args, tokens)
+          tag = tag.to_s
           @tokens = tokens
           @tag = from_alias(tag)
           @args = Parser.new(args, @tag)
@@ -66,34 +79,39 @@ module Jekyll
           super
         end
 
+        # --------------------------------------------------------------------
         # NOTE: We only attach to the regenerator if you are using digested
         #   assets, otherwise we forego any association with it so that we keep
         #   your builds ultra fast, this is ideal in dev.  Disable digests and
         #   let us process independent so the entire site isn't regenerated
         #   because of a single asset change.
+        # --------------------------------------------------------------------
 
         def render(context)
-          args = @args.parse_liquid(context)
           site = context.registers[:site]
           page = context.registers.fetch(:page, {})
+          args = @args.parse_liquid(context)
           sprockets = site.sprockets
           page = page["path"]
 
           asset = find_asset(args, sprockets)
           add_as_jekyll_dependency(site, sprockets, page, asset)
           process_tag(args, sprockets, asset)
+
         rescue => e
-          capture_and_out_error site, e
+          capture_and_out_error(
+            site, e
+          )
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def from_alias(tag)
           Alias.key?(tag) ? Alias[tag] : tag
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def process_tag(args, sprockets, asset)
@@ -102,34 +120,26 @@ module Jekyll
           build_html(args, sprockets, asset)
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def build_html(args, sprockets, asset, path = get_path(sprockets, asset))
-          if @tag == "asset_path"
-            path
-
-          elsif @tag == "asset" || @tag == "asset_source"
-            asset.to_s
-
-          elsif args.key?(:data) && args[:data].key?(:uri)
-            format(Tags[@tag], asset.data_uri, \
-              args.to_html)
-
-          else
-            format(Tags[@tag], path, \
-              args.to_html)
-          end
+          return path if @tag == "asset_path"
+          return asset.to_s if @tag == "asset" || @tag == "asset_source"
+          return format(Tags[@tag], asset.data_uri, args.to_html) if args.key?(:data) && args[:data].key?(:uri)
+          format(Tags[@tag], path, args.to_html)
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def get_path(sprockets, asset)
-          sprockets.prefix_path(sprockets.digest?? asset.digest_path : asset.logical_path)
+          sprockets.prefix_path(
+            sprockets.digest?? asset.digest_path : asset.logical_path
+          )
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def add_as_jekyll_dependency(site, sprockets, page, asset)
@@ -140,34 +150,84 @@ module Jekyll
           end
         end
 
-        #
+        # --------------------------------------------------------------------
 
         private
         def find_asset(args, sprockets)
-          file = args[:file]
-          sprockets_ = args[:sprockets] ||= {}
-          if !(out = sprockets.find_asset(file, sprockets_))
-            raise AssetNotFoundError, args[:file]
+          out = _find_asset(args[:file],
+            args[:sprockets] ||= {}, sprockets
+          )
+
+          if !out
+            raise(
+              AssetNotFoundError, args[
+                :file
+              ]
+            )
+
           else
             out.liquid_tags << self
-            !args.proxies?? out : ProxiedAsset.new( \
-              out, args, sprockets, self)
+            !args.proxies?? out : ProxiedAsset.new(
+              out, args, sprockets, self
+            )
           end
         end
 
+        # --------------------------------------------------------------------
+
+        private
+        def _find_asset(file, args, sprockets)
+          if args.empty? then sprockets.manifest.find(file).first
+          elsif args.size == 1 && args.key?(:accept)
+            if File.extname(file) == ""
+              file = file + _ext_for(args[
+                :accept
+              ])
+            end
+
+            sprockets.manifest.find(file).find do |asset|
+              asset.content_type == args[
+                :accept
+              ]
+            end
+          else
+            sprockets.find_asset(
+              file, args
+            )
+          end
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def _ext_for(type)
+          out = Sprockets.mime_exts.select do |k, v|
+            v == type
+          end
+
+          out.keys \
+            .first
+        end
+
+        # --------------------------------------------------------------------
         # There is no guarantee that Jekyll will pass on the error for some
         # reason (unless you are just booting up) so we capture that error and
         # always output it, it can lead to some double errors but I would
         # rather there be a double error than no error.
+        # --------------------------------------------------------------------
 
         private
         def capture_and_out_error(site, error)
           if error.is_a?(Sass::SyntaxError)
             file = error.sass_filename.gsub(/#{Regexp.escape(site.source)}\//, "")
-            Jekyll.logger.error(%{Error in #{file}:#{error.sass_line} #{error}})
+            Jekyll.logger.error(%(Error in #{file}:#{error.sass_line} #{
+              error
+            }))
+
           else
-            Jekyll.logger.error \
+            Jekyll.logger.error(
               "", error.to_s
+            )
           end
 
           raise error
@@ -177,6 +237,8 @@ module Jekyll
   end
 end
 
+# ----------------------------------------------------------------------------
+
 Jekyll::Assets::Liquid::Tag::AcceptableTags.each do |tag|
   Liquid::Template.register_tag tag, Jekyll::Assets::Liquid::Tag
 end