Introducing proxies and re-introducing image manipulation.

Fixes #160: Use {% img name.ext magick:crop:value %}
Fixes #149: Use {% img name.ext magick:2x %} also 4x, half.
Insur #159: Use a hash of the proxies for the image path.
Fixes #150: Simply because the new syntax is solidified.

This patch introduces the concept of proxies, so that tags can have
proxies that manipulate data, the base included proxy is a magick filter
that allows you to adjust and manipulate your image but any number of
filters can be used.

Because an image can be filtered any number of times each proxy that
changes an image will trigger a new hash resulting in an entirely uniq
image but if you use an image with a filter 20 times it should in theory
continue to cache it and only run the proxies once and hold that cache
until you either change the proxy attributes or clear the cache.

Author: envygeeks

.rspec

@@ -1 +1 @@
---color --fail-fast
+--color

README.md

@@ -82,7 +82,6 @@ the ground rules for our tags as a specification.
 * `magick:2x` - Tells us to write a double width/height image.
 * `magick:4x` - Tells us to write a quadruple width/height image.
 * `magick:half` - Tells us to shrink the image to half.
-* `magick:quality` - Allows you to set image quality.
 
 ## Hooks
 

lib/jekyll/assets.rb

@@ -1,17 +1,16 @@
-require_relative "assets/helpers"
-require_relative "assets/hook"
 require "sprockets"
 require "sprockets/helpers"
 require "jekyll"
 
 require_relative "assets/hook"
-Dir[File.expand_path("../assets/extras/*.rb", __FILE__)].each do |f|
-  require f
-end
+require_relative "assets/helpers"
+require_relative "assets/extras/es6"
+require_relative "assets/extras/helpers"
+require_relative "assets/extras/prefix"
 
 require_relative "assets/env"
-require_relative "assets/whitelist"
 require_relative "assets/patches/jekyll/cleaner"
+require_relative "assets/patches/sprockets/asset"
 require_relative "assets/patches/jekyll/site"
 
 require_relative "assets/hooks/post_read"

lib/jekyll/assets/cached.rb

@@ -1,18 +1,10 @@
 module Jekyll
   module Assets
-
-    # Creates:
-    #   * `#parent` - Leading back to the original Jekyll::Assets::Env instance.
-    #   * `#jekyll` - Leading back to the `Jekyll::Site` instance.
-    #
-    # The reason we add these is because sometimes we might need access to
-    # the configuration or even to find another asset tied to a cached asset
-    # so we can verify, find... etc, etc, etc.
-
     class Cached < Sprockets::CachedEnvironment
       attr_reader :jekyll, :parent
       def initialize(env)
-        @parent, @jekyll = env, env.jekyll
+        @parent = env
+        @jekyll = env.jekyll
         super env
       end
     end

lib/jekyll/assets/configuration.rb

@@ -27,22 +27,19 @@ module Configuration
         },
       })
 
-      # Merges the users configuration with the default configuration so
-      # that there is always some form of stable configuration for you to tap
-      # into.  This is merged into `#asset_config`.
+      def self.defaults
+        %W(development test).include?(Jekyll.env) ? DEVELOPMENT : PRODUCTION
+      end
 
-      def self.merge(merge_into, config = nil)
-        config ||= %(development test).include?(Jekyll.env) ? DEVELOPMENT : PRODUCTION
+      def self.merge(merge_into, config = self.defaults)
         merge_into = merge_into.dup
+        config.each_with_object(merge_into) do |(k, v), h|
+          if !h.has_key?(k) || (v.is_a?(Hash) && !h[k])
+            h[k] = v
 
-        config.each_with_object(merge_into) do |(key, value), hash|
-          if !hash.has_key?(key) || (value.is_a?(Hash) && !hash[key])
-            hash[key] = \
-              value
-
-          elsif value.is_a?(Hash)
-            hash[key] = merge hash[key], \
-              value
+          elsif v.is_a?(Hash)
+            h[k] = merge h[k], \
+              v
           end
         end
 

lib/jekyll/assets/context.rb

@@ -9,10 +9,8 @@ def patch(what)
         what.class_eval do
           alias_method :_old_asset_path, :asset_path
           def asset_path(asset, opts = {})
-            out = _old_asset_path asset, opts = {}
-            unless out
-              return
-            end
+            out = _old_asset_path asset
+            return unless out
 
             environment.parent.used.add(environment.find_asset \
               resolve(asset))

lib/jekyll/assets/env.rb

@@ -27,6 +27,13 @@ def initialize(path, jekyll = nil)
         jekyll.sprockets = self
       end
 
+      def in_cache_dir(*paths)
+        cache_dir = asset_config.fetch("cache", ".asset-cache") || nil
+        jekyll.in_source_dir(
+          cache_dir, *paths
+        )
+      end
+
       def cached_write?
         !@used.any?
       end
@@ -57,60 +64,25 @@ def prefix_path(path = nil)
           return File.join(cdn, prefix) if !path
           File.join(cdn, prefix, path)
         else
-          return  prefix if !path
-          File.join(
-            prefix, path
-          )
+          return prefix if !path
+          File.join(prefix, path)
         end
       end
 
-      # See: `Cached`
-
       def cached
         Cached.new(self)
       end
 
-      # See: `write_cached_assets`
-      # See: `write_assets`
-
       def write_all
         if cached_write?
           then write_cached_assets else write_assets
         end
       end
 
-      # Merge the defaults with your configuration so that there is always
-      # some state and so that there need not be any configuration provided
-      # by the user, this allows you to just accept our defaults while
-      # changing only the things that you want changed.
-
-      private
-      def merge_config(config = nil, merge_into = asset_config)
-        config ||= dev?? Configuration::DEVELOPMENT : Configuration::PRODUCTION
-        config.each_with_object(merge_into) do |(k, v), h|
-          if !h.has_key?(k)
-            h[k] = \
-              v
-
-          elsif v.is_a?(Hash)
-            h[k] = merge_config(
-              v, h[k]
-            )
-          end
-        end
-
-
-        merge_into
-      end
-
-      # If we have used assets then we are working with a brand new
-      # build and a brand new set of assets, so we reset the asset_cache
-      # and digest_cache and write everything fresh from the start.
-
       private
-      def write_assets(assets = self.all_used_assets)
-        self.class.assets_cache = Set.new(assets)
-        self.class.digest_cache = Hash[Set.new(assets).map do |a|
+      def write_assets(assets = self.all_assets)
+        self.class.assets_cache = assets
+        self.class.digest_cache = Hash[assets.map do |a|
           [a.logical_path, a.digest]
         end]
 
@@ -120,11 +92,21 @@ def write_assets(assets = self.all_used_assets)
       end
 
       private
-      def write_cached_assets
-        all_assets(true).each do |a|
-          viejo = self.class.digest_cache[a.logical_path]
-          nuevo = find_asset(a.logical_path).digest
-          next if nuevo == viejo
+      def write_cached_assets(assets = all_assets(true))
+        assets.each do |a|
+          if !a.is_a?(Tag::ProxiedAsset)
+            viejo = self.class.digest_cache[a.logical_path]
+            nuevo = find_asset(a.logical_path).digest
+            path  = as_path a
+
+            if nuevo == viejo && File.file?(path)
+              next
+            end
+          else
+            if File.file?(a.logical_path)
+              next
+            end
+          end
 
           self.class.digest_cache[a.logical_path] = a.digest
           a.write_to as_path a

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

@@ -0,0 +1,13 @@
+module Sprockets
+  class Asset
+    def data_uri
+      "data:#{content_type};base64,#{Rack::Utils.escape \
+        Base64.encode64(to_s)}"
+    end
+
+    def liquid_tags
+      metadata[:liquid_tags] ||= \
+        Set.new
+    end
+  end
+end

lib/jekyll/assets/tag.rb

@@ -1,7 +1,13 @@
 module Jekyll
   module Assets
+
+    # TODO: Somewhere in here we need to designate the proxy as an asset
+    #   so that the env does not need to be aware of anything.
+
     class Tag < Liquid::Tag
+      require_relative "tag/proxied_asset"
       require_relative "tag/parser"
+      attr_reader :args
 
       class AssetNotFoundError < StandardError
         def initialize(asset)
@@ -23,8 +29,10 @@ def initialize(asset)
       }
 
       def initialize(tag, args, tokens)
-        @tokens, @tag, @og_tag, @url_options = tokens, from_alias(tag), tag, {}
+        @tokens = tokens
+        @tag = from_alias(tag)
         @args = Parser.new(args, @tag)
+        @og_tag = tag
         super
       end
 
@@ -63,7 +71,7 @@ def process_tag(sprockets, asset)
 
         elsif @args[:data][:uri]
           return TAGS[@tag] % [
-            data_uri(asset), @args.to_html
+            asset.data_uri, @args.to_html
           ]
 
         else
@@ -76,8 +84,9 @@ def process_tag(sprockets, asset)
 
       private
       def get_path(sprockets, asset)
-        asset_path = sprockets.digest?? asset.digest_path : asset.logical_path
-        sprockets.prefix_path(asset_path)
+        sprockets.prefix_path(
+          sprockets.digest?? asset.digest_path : asset.logical_path
+        )
       end
 
       private
@@ -87,12 +96,6 @@ def set_img_alt(asset)
         end
       end
 
-      private
-      def data_uri(asset)
-        data = Rack::Utils.escape(Base64.encode64(asset.to_s))
-        "data:#{asset.content_type};base64,#{data}"
-      end
-
       private
       def add_as_jekyll_dependency(site, sprockets, page, asset)
         if page && sprockets.digest?
@@ -105,11 +108,15 @@ def add_as_jekyll_dependency(site, sprockets, page, asset)
       private
       def find_asset(sprockets)
         if !(out = sprockets.find_asset(@args[:file], @args[:sprockets]))
-          raise AssetNotFoundError, @args[:file] else out.metadata[:tag] = \
-            @args
+          raise AssetNotFoundError, @args[:file]
+        else
+          out.liquid_tags << self
+          if !@args.has_proxies?
+            out else ProxiedAsset.new(
+              out, @args, sprockets, self
+            )
+          end
         end
-
-        out
       end
 
       # There is no guarantee that Jekyll will pass on the error for