jekyll-assets 2.0.0.pre.beta4 → 2.0.0

data/lib/jekyll/assets/hook.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     class Hook
@@ -25,37 +29,40 @@ module Jekyll
         @_all ||= {}
       end
 
-      # ---------------------------------------------------------------------
       # Trigger a hook, giving an optional block where we pass you the,
       # proc we got and then you can do as you please (such as instance eval)
       # but if you do not give us one then we simply pass the args.
-      # ---------------------------------------------------------------------
 
       def self.trigger(base, _point, *args, &block)
         raise ArgumentError, "Do not give args with a block" if args.size > 0 && block_given?
-        if all.has_key?(base) && all.fetch(base).has_key?(_point)
+        if all.has_key?(base) && all[base].has_key?(_point)
           Set.new.merge(point(base, _point, :early)).merge(point(base, _point)).map do |v|
             block_given?? block.call(v) : v.call(*args)
           end
         end
       end
 
-      # ---------------------------------------------------------------------
+      #
 
       def self.point(base, point, _when = :late)
-        point = all.fetch(base).fetch(point, nil) || all.fetch(base).store(point, {
-          :late => Set.new, :early => Set.new })
-        point.fetch(_when)
+        point = all[base][point] ||= {
+           :late => Set.new,
+          :early => Set.new
+        }
+
+        point[_when]
       end
 
-      # ---------------------------------------------------------------------
+      #
 
       def self.register(base, point, _when = :late, &block)
         raise UnknownHookError.new(base: base) unless HookPoints.has_key?(base)
-        point = HookAliases.fetch(base).fetch(point) if HookAliases.fetch(base, {}).has_key?(point)
-        raise UnknownHookError.new(point: point) unless HookPoints.fetch(base).include?(point)
-        all.fetch(base, nil) || all.store(base, {})
-        point(base, point, _when).add(block)
+        point = HookAliases[base][point] if  HookAliases.fetch(base, {}).has_key?(point)
+        raise UnknownHookError.new(point: point) unless HookPoints[base].include?(point)
+        all[base] ||= {}
+
+        point(base, point, _when). \
+          add(block)
       end
     end
   end

data/lib/jekyll/assets/hooks.rb

@@ -0,0 +1,19 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+require_relative "hooks/jekyll/initialize"
+require_relative "hooks/jekyll/write_assets"
+require_relative "hooks/jekyll/asset_drops"
+require_relative "hooks/jekyll/ignore"
+
+require_relative "hooks/compression"
+require_relative "hooks/configuration"
+require_relative "hooks/context_patches"
+require_relative "hooks/disable_erb"
+require_relative "hooks/helpers"
+require_relative "hooks/logger"
+require_relative "hooks/sources"
+require_relative "hooks/sprockets"
+require_relative "hooks/version"
+require_relative "hooks/cache"

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init do
   if (cache_dir = asset_config.fetch("cache", ".asset-cache"))
     self.cache = Sprockets::Cache::FileStore.new(jekyll.in_source_dir(cache_dir))

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init do
   if compress?("css")
     self.css_compressor = :sass

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init, :early do
   jekyll.config.store("assets", Jekyll::Assets::Config.merge(asset_config))
 end

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

@@ -1,8 +1,13 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init do
   context_class.class_eval do
     alias_method :_old_asset_path, :asset_path
     def asset_path(asset, opts = {})
       out = _old_asset_path asset
+
       return unless out
       path = environment.find_asset(resolve(asset))
       environment.parent.used.add(path)

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init, :early do
   self.config = hash_reassoc(config, :engines) do |hash|
     hash.delete(".erb")

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 require "sprockets/helpers"
 
 Jekyll::Assets::Hook.register :env, :init do

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

@@ -0,0 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+Jekyll::Hooks.register :site, :pre_render do |jekyll, payload|
+  payload["assets"] ||= jekyll.sprockets.to_liquid_payload
+end

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

@@ -0,0 +1,9 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+Jekyll::Hooks.register :site, :after_reset do |jekyll|
+  unless jekyll.config["exclude"].grep(/\A\.asset\-cache\/?/)
+    jekyll.config["exclude"].push(".asset-cache/")
+  end
+end

data/lib/jekyll/{hooks → assets/hooks/jekyll}/initialize.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Hooks.register :site, :post_read do |jekyll|
   Jekyll::Assets::Env.new(jekyll)
 end

data/lib/jekyll/{hooks → assets/hooks/jekyll}/write_assets.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Hooks.register :site, :post_write do |jekyll|
   jekyll.sprockets.write_all
 end

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init do
   self.logger = Jekyll::Assets::Logger.new
 end

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

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

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

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

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 Jekyll::Assets::Hook.register :env, :init do
-  self.version = Digest::MD5.hexdigest(jekyll.config.fetch("assets", {}).inspect)
+  self.version = Digest::MD5.hexdigest(asset_config.inspect)
 end

data/lib/jekyll/assets/liquid.rb

@@ -0,0 +1,13 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+module Jekyll
+  module Assets
+    module Liquid
+      require_relative "liquid/drop"
+      require_relative "liquid/filters"
+      require_relative "liquid/tag"
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+require "fastimage"
+
+module Jekyll
+  module Assets
+    module Liquid
+      class Drop < ::Liquid::Drop
+        extend Forwardable
+        def initialize(path, jekyll)
+          @path = path
+          @jekyll = jekyll
+          @asset = nil
+        end
+
+        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?
+          %(image/png image/jpeg image/gif).include?(
+            asset.content_type
+          )
+        end
+
+        private
+        def asset
+          return @asset ||= @jekyll.sprockets.find_asset(@path)
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,23 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     module Liquid
       module Filters
-        %W(js css img image javascript stylesheet style asset_path).each do |val|
+        AcceptableFilters = %W(
+          css
+          image
+          asset_path
+          stylesheet
+          javascript
+          style
+          img
+          js
+        )
+
+        AcceptableFilters.each do |val|
           define_method val do |path, args = ""|
             Tag.send(:new, val, "#{path} #{args}", "").render(@context)
           end

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

@@ -1,18 +1,46 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+require "fastimage"
+
 module Jekyll
   module Assets
     module Liquid
       class Tag < ::Liquid::Tag
+        require_relative "tag/proxies"
         require_relative "tag/proxied_asset"
+        require_relative "tag/defaults"
         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
 
-        # ---------------------------------------------------------------------
+        #
+
+        AcceptableTags = %W(
+          img
+          image
+          javascript
+          asset_source
+          stylesheet
+          asset_path
+          style
+          asset
+          css
+          js
+        )
+
+        #
 
         Tags = {
           "css" => %Q{<link type="text/css" rel="stylesheet" href="%s"%s>},
@@ -20,7 +48,7 @@ module Jekyll
           "img" => %Q{<img src="%s"%s>}
         }
 
-        # ---------------------------------------------------------------------
+        #
 
         Alias = {
           "image" => "img",
@@ -29,7 +57,7 @@ module Jekyll
           "style" => "css"
         }
 
-        # ---------------------------------------------------------------------
+        #
 
         def initialize(tag, args, tokens)
           @tokens = tokens
@@ -39,18 +67,18 @@ 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)
-          site = context.registers.fetch(:site)
-          page = context.registers.fetch(:page, {}).fetch("path", nil)
+          @args.parse_liquid!(context)
+          site = context.registers[:site]
+          page = context.registers.fetch(:page, {})
           sprockets = site.sprockets
+          page = page["path"]
 
           asset = find_asset(sprockets)
           add_as_jekyll_dependency(site, sprockets, page, asset)
@@ -60,55 +88,53 @@ module Jekyll
             site, e
         end
 
-        # ---------------------------------------------------------------------
+        #
 
         private
         def from_alias(tag)
-          Alias.has_key?(tag) ? Alias.fetch(tag) : tag
+          Alias.has_key?(tag) ? Alias[tag] : tag
         end
 
-        # ---------------------------------------------------------------------
+        #
 
         private
         def process_tag(sprockets, asset)
           sprockets.used.add(asset) unless @tag == "asset_source"
-          set_img_alt asset if @tag == "img"
-          out = get_path sprockets, asset
+          Defaults.set_defaults_for!(@tag, @args ||= {}, asset)
+          build_html(sprockets, asset)
+        end
+
+        #
+
+        private
+        def build_html(sprockets, asset, path = get_path(sprockets, asset))
           if @tag == "asset_path"
-            return out
+            return path
 
           elsif @tag == "asset" || @tag == "asset_source"
             return asset.to_s
 
-          elsif @args.has_key?(:data) && @args.fetch(:data).has_key?(:uri)
-            return Tags.fetch(@tag) % [
+          elsif @args.has_key?(:data) && @args[:data].has_key?(:uri)
+            return Tags[@tag] % [
               asset.data_uri, @args.to_html
             ]
 
           else
-            return Tags.fetch(@tag) % [
-              out, @args.to_html
+            return Tags[@tag] % [
+              path, @args.to_html
             ]
           end
         end
 
-        # ---------------------------------------------------------------------
+        #
 
         private
         def get_path(sprockets, asset)
-          sprockets.prefix_path(sprockets.digest?? asset.digest_path : asset.logical_path)
-        end
-
-        # ---------------------------------------------------------------------
-
-        private
-        def set_img_alt(asset)
-          if !@args.has_key?(:html) || !@args.fetch(:html).has_key?("alt")
-            @args.fetch_or_store(:html, {}).store("alt", asset.logical_path)
-          end
+          sprockets.prefix_path(sprockets.digest?? asset.digest_path : \
+            asset.logical_path)
         end
 
-        # ---------------------------------------------------------------------
+        #
 
         private
         def add_as_jekyll_dependency(site, sprockets, page, asset)
@@ -119,26 +145,24 @@ module Jekyll
           end
         end
 
-        # ---------------------------------------------------------------------
+        #
 
         private
         def find_asset(sprockets)
-          file, _sprockets = @args.fetch(:file), @args.fetch(:sprockets, {})
+          file, _sprockets = @args[:file], @args[:sprockets] ||= {}
           if !(out = sprockets.find_asset(file, _sprockets))
-            raise AssetNotFoundError, @args.fetch(:file)
+            raise AssetNotFoundError, @args[:file]
           else
             out.liquid_tags << self
-            !args.has_proxies?? out : ProxiedAsset.new(out, \
-              @args, sprockets, self)
+            !args.has_proxies?? out : ProxiedAsset.new( \
+              out, @args, sprockets, self)
           end
         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)
@@ -157,6 +181,6 @@ module Jekyll
   end
 end
 
-%W(js css img image javascript stylesheet style asset_path asset_source asset).each do |tag|
+Jekyll::Assets::Liquid::Tag::AcceptableTags.each do |tag|
   Liquid::Template.register_tag tag, Jekyll::Assets::Liquid::Tag
 end