jekyll-assets 2.0.0.pre.beta4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13ef0db8827ce604b6ab6fc5c1272289aa28db82
-  data.tar.gz: 74fa09f72ab1a1a5a5344c45c3d2a9aea781ba46
+  metadata.gz: 03eb71fd5a47c2e0e6751282a641078cf0073323
+  data.tar.gz: fe08b59368965a3972b499351cbe582604d07041
 SHA512:
-  metadata.gz: d9ca925ddb5825511b5b79aebbff142c716b19b3bda9c2a77304d5298901dce0ff171e99cbdcbde4e94c866e94a79f23746924002e604725d6d51438e49502ab
-  data.tar.gz: 1d22a229132e302b9101d074799f81d998f9df9befa85fa0170a02028411e6c30acc02d5980514c5983f5c84bd24a9a8b08398d06def947dbfa9acd83afb4771
+  metadata.gz: ab6aedd38ebadf43e71fecd4548c254afdc7143c45dcc85f32fa2e86b6295a62eab8bcb828546dfb6d97328e07acc16a899fd0cad1d8b01b18ab7d8823717854
+  data.tar.gz: d1b30bbebba9a6cfe9a77a7ef563088e0d168d1d83d83a4b097f9ba46b017f77229c919c98cd592ebcb54a17062529e0af414267e0a1d9317f0d704782d472b1

data/README.md

@@ -43,7 +43,13 @@ assets:
     - "bundle.css"
   digest: true
   sources:
-    - "_assets/folder"
+    - _assets/css
+    - _assets/images
+    - _assets/javascripts
+    - _assets/stylesheets
+    - _assets/fonts
+    - _assets/img
+    - _assets/js
 ```
 
 ### Digesting
@@ -57,13 +63,22 @@ assets:
 * Disable compression by default in development.
 * Enable by default in production.
 
-***You can force digesting with `digest: true` in your `_config.yml`***
 
-## ERB Support
+### Bower (web components support.)
 
-ERB Support is removed in favor of trying to get this included on Github Pages
-eventually (if I can.) Having ERB presents a security risk to Github because it
-would allow you to use Ruby in ways they don't want you to.
+Modify your `.bowerrc` file and add:
+
+```javascript
+{
+  "directory": "_assets/bower"
+}
+```
+
+And then add `_assets/bower` to your sources list and Sprockets will do the
+the rest for you... you can even `//= require bower_asset.js`.  We will even
+compress them for you per normal if Sprockets supports it and allows us to.
+
+***You can force digesting with `digest: true` in your `_config.yml`***
 
 ## Tags
 
@@ -101,6 +116,49 @@ rules for our tags as a specification.
 * `sprockets:accept:<value>`
 * `sprockets:write_to:<value>`
 
+## Liquid Variables in Arguments
+
+You can use Liquid variables inside of your arguments, but you must quote
+them to get them to work, this can be a partial argument quote a full argument
+quote or otherwise, it just must be quoted or escaped.
+
+```liquid
+{% img '{{ image_path }}' %}
+{% img '{{ image_path }}' proxy:key:'{{ value }}' %}
+{% img {{\ image_path\ }} %}
+```
+
+## Getting a list of your assets and basic info from Liquid
+
+We provide all *your* assets as a hash of Liquid Drops so you can get basic
+info that we wish you to have access to without having to prepare the class.
+
+```liquid
+{{ assets["bundle.css"].content_type }} => "text/css"
+{{ assets["images.jpg"].width  }} => 62
+{{ assets["images.jpg"].height }} => 62
+```
+
+The current list of available accessors:
+
+* `logical_path`
+* `content_type` -> `type`
+* `filename`
+* `basename`
+* `width`
+* `height`
+
+If you would like more, please feel free to add a pull request, at this
+time we will reject all pull requests that wish to add any digested paths as
+those are dynamically created when a proxy is ran so we can never predict
+it reliably unless we proxy and that would be a performance problem.
+
+## ERB Support
+
+ERB Support is removed in favor of trying to get this included on Github Pages
+eventually (if I can.) Having ERB presents a security risk to Github because it
+would allow you to use Ruby in ways they don't want you to.
+
 ## Filters
 
 There is a full suite of filters, actually, any tag and any proxy can be a
@@ -122,6 +180,14 @@ Jekyll::Assets::Hook.register :env, :init do
 end
 ```
 
+## Sass Helpers
+
+***Our currently supported helpers are:***
+
+* asset_path
+* image_path
+* font_path
+
 ## Addons
 
 * CSS Auto Prefixer - add "autoprefixer-rails" to your Gemfile.
@@ -143,9 +209,13 @@ that point rather than trying to fight it.***
 * `magick:rotate:<value>`
 * `magick:crop:<value>`
 * `magick:flip:<value>`
-* `magick:half`
-* `magick:2x`
-* `magick:4x`
+* `magick:quadruple`, `magick:4x`
+* `magick:one-third`, `magick:1/3`
+* `magick:three-fourths`, `magick:3/4`
+* `magick:two-fourths`, `magick:2/4`
+* `magick:two-thirds`, `magick:2/3`
+* `magick:one-fourth`, `magick:1/4`
+* `magick:half`, `magick:1/2`
 
 ## Plugins where did they go?
 

data/lib/jekyll-assets.rb

@@ -1 +1,5 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 require "jekyll/assets"

data/lib/jekyll/assets.rb

@@ -1,22 +1,21 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 require "sprockets"
 require "jekyll"
 
-Dir.glob(File.expand_path("hooks/*.rb", __dir__)).map do |file|
-  require file
-end
-
 module Jekyll
   module Assets
-    %W(patches/**/* cached config env hook logger version liquid/*
-         hooks/* addons/{*,**/*}).each do |path|
-      if path !~ /\*/
-        require_relative "assets/#{path}"
-      else
-        Dir.glob(File.expand_path("assets/#{path}.rb", __dir__)). \
-            map do |file|
-          require file
-        end
-      end
-    end
+    require_relative "assets/version"
+    require_relative "assets/patches"
+    require_relative "assets/cached"
+    require_relative "assets/config"
+    require_relative "assets/env"
+    require_relative "assets/hook"
+    require_relative "assets/logger"
+    require_relative "assets/hooks"
+    require_relative "assets/liquid"
+    require_relative "assets/addons"
   end
 end

data/lib/jekyll/assets/addons.rb

@@ -0,0 +1,10 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
+require_relative "addons/compass"
+require_relative "addons/bootstrap"
+require_relative "addons/autoprefixer"
+require_relative "addons/proxies/magick"
+require_relative "addons/font_awesome"
+require_relative "addons/js_es6"

data/lib/jekyll/assets/addons/autoprefixer.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require_if_javascript "autoprefixer-rails" do
   Jekyll::Assets::Hook.register :env, :init do |env|
     AutoprefixerRails.install(env)

data/lib/jekyll/assets/addons/bootstrap.rb

@@ -1 +1,5 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require "bootstrap-sass"

data/lib/jekyll/assets/addons/compass.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require "compass/core" do
   Jekyll::Assets::Hook.register :env, :init do
     Compass::Frameworks::ALL.each do |framework|

data/lib/jekyll/assets/addons/font_awesome.rb

@@ -1 +1,5 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require "font-awesome-sass"

data/lib/jekyll/assets/addons/js_es6.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require_if_javascript "sprockets/es6" do
   if ExecJS.runtime.is_a?(ExecJS::RubyRhinoRuntime)
     Jekyll.logger.warn "ES6 transpiler has trouble with RubyRhino, use Node"

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

@@ -1,22 +1,32 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 try_require "mini_magick" do
-  args = %W(resize quality rotate crop flip @2x @4x @half)
-  Jekyll::Assets::Env.liquid_proxies.add :magick, :img, *args do
+  args = %W(resize quality rotate crop flip)
+  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, Args = presets, 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)
-      @asset, @path, @opts = asset, asset.filename, opts
+    def initialize(asset, opts, args)
+      @path = asset.filename
+      @opts = opts
+      @asset = asset
+      @args = args
     end
 
-    # ---------------------------------------------------------------
+    #
 
     def process
       img = MiniMagick::Image.open(@path)
@@ -31,63 +41,83 @@ try_require "mini_magick" do
       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(img)
       if @opts.has_key?(:quality)
-        img.quality @opts.fetch(:quality)
+        then img.quality @opts[:quality]
       end
     end
 
-    # ---------------------------------------------------------------
+    #
 
     private
     def magick_resize(img)
-      if @opts.has_key?(:resize) && (@opts.has_key?(:"2x") || \
-            @opts.has_key?(:"4x") || @opts.has_key?(:half))
-        raise DoubleResizeError
-
-      elsif @opts.has_key?(:resize)
-        img.resize @opts.fetch(:resize)
+      raise DoubleResizeError if @opts.has_key?(:resize) && preset?
+      if @opts.has_key?(:resize)
+        then img.resize @opts[:resize]
       end
     end
 
-    # ---------------------------------------------------------------
+    #
 
     private
     def magick_rotate(img)
       if @opts.has_key?(:rotate)
-        img.rotate @opts.fetch(:rotate)
+        then img.rotate @opts[:rotate]
       end
     end
 
-    # ---------------------------------------------------------------
+    #
 
     private
     def magick_flip(img)
       if @opts.has_key?(:flip)
-        img.flip @opts.fetch(:flip)
+        then img.flip @opts[:flip]
       end
     end
 
-    # ---------------------------------------------------------------
+    #
 
     private
     def magick_crop(img)
       if @opts.has_key?(:crop)
-        img.crop @opts.fetch(:crop)
+        then img.crop @opts[:crop]
       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.
 
     private
     def magick_preset_resize(img)
-      return unless @opts.has_key?(:"2x") || @opts.has_key?(:"4x") || @opts.has_key?(:half)
-      width, height = img.width * 2, img.height * 2 if @opts.has_key?(:"2x")
-      width, height = img.width * 4, img.height * 4 if @opts.has_key?(:"4x")
-      width, height = img.width / 2, img.height / 2 if @opts.has_key?(:half)
+      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")
       img.resize "#{width}x#{height}"
     end
   end

data/lib/jekyll/assets/cached.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     class Cached < Sprockets::CachedEnvironment

data/lib/jekyll/assets/config.rb

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     module Config
@@ -20,7 +24,7 @@ module Jekyll
         ]
       }
 
-      # -----------------------------------------------------------------------
+      #
 
       Production = Development.merge({
         "digest"    => true,
@@ -30,13 +34,13 @@ module Jekyll
         },
       })
 
-      # -----------------------------------------------------------------------
+      #
 
       def self.defaults
         %W(development test).include?(Jekyll.env) ? Development : Production
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def self.merge(nhash, ohash = defaults)
         ohash.merge(nhash) do |key, oval, nval|

data/lib/jekyll/assets/env.rb

@@ -1,199 +1,160 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     class Env < Sprockets::Environment
       attr_reader :jekyll, :used
 
       class << self
-        attr_accessor :assets_cache, :digest_cache
-        def digest_cache
-          return @digest_cache ||= {}
+        attr_accessor :past
+        def liquid_proxies
+          return Liquid::Tag::Proxies
         end
+      end
 
-        # ---------------------------------------------------------------------
+      #
 
-        def liquid_proxies
-          return Liquid::Tag::Proxies
+      def all_unparsed_assets
+        @unparsed_assets ||= logical_paths.select do |(_, val)|
+          val.start_with?(jekyll.in_source_dir)
         end
       end
 
-      # -----------------------------------------------------------------------
+      #
 
-      def inspect
-        "<#{self.class.name} compress_js=#{compress?("js")} compress_css=#{compress?("css")} asset_path=#{
-          path
-        }>"
+      def to_liquid_payload
+        jekyll.sprockets.all_unparsed_assets.inject({}) do |hsh, (key, val)|
+          hsh[key] = Jekyll::Assets::Liquid::Drop.new(val, jekyll)
+        hsh
+        end
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def initialize(path, jekyll = nil)
         jekyll, path = path, nil if path.is_a?(Jekyll::Site)
         @used, @jekyll = Set.new, jekyll
+
         path ? super(path) : super()
-        Hook.trigger(:env, :init) do |hook|
-          hook.arity > 0 || 0 > hook.arity ? hook.call(self) : instance_eval(&hook)
+        Hook.trigger :env, :init do |hook|
+          hook.arity > 0 || 0 > hook.arity ? hook.call(self) : \
+            instance_eval(&hook)
         end
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def liquid_proxies
         return self.class.liquid_proxies
       end
 
-      # -----------------------------------------------------------------------
       # Make sure a path falls withint our cache dir.
-      # -----------------------------------------------------------------------
 
       def in_cache_dir(*paths)
-        cache_dir = asset_config.fetch("cache", ".asset-cache") || nil
+        cache_dir = asset_config["cache"] || ".asset-cache"
         jekyll.in_source_dir(cache_dir, *paths)
       end
 
-      # -----------------------------------------------------------------------
-      # Whether or not we are writing from the cache.
-      # -----------------------------------------------------------------------
+      # Merged form of `#extra_assets`
 
-      def cached_write?
-        !@used.any?
+      def all_assets
+        Set.new(@used).merge extra_assets
       end
 
-      # -----------------------------------------------------------------------
-      # Merged form of `#extra_assets` and `@used` assets.
-      # -----------------------------------------------------------------------
-
-      def all_assets(cached = false)
-        if !cached
-          then Set.new(@used).merge extra_assets
-          else Set.new(self.class.assets_cache).merge(extra_assets)
-        end
-      end
-
-      # -----------------------------------------------------------------------
       # Assets you tell us you want to always compile, even if you do not
       # use them.  Just like Rails this is probably normally used.
-      # -----------------------------------------------------------------------
 
       def extra_assets
-        each_logical_path(*asset_config.fetch("assets", [])).map do |v|
+        assets = asset_config["assets"] ||= []
+        each_logical_path(*assets).map do |v|
           find_asset v
         end
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def cdn?
-        !dev? && asset_config.has_key?("cdn") && asset_config.fetch("cdn")
+        !dev? && asset_config.has_key?("cdn") && \
+          asset_config["cdn"]
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def baseurl
-        jekyll.config.fetch("baseurl", "")
+        ary = []
+
+        ary << jekyll.config["baseurl"] unless cdn? && asset_config["skip_baseurl_with_cdn"]
+        ary <<  asset_config[ "prefix"] unless cdn? && asset_config[ "skip_prefix_with_cdn"]
+        File.join(*ary.delete_if do |val|
+          val.nil? || val.empty?
+        end)
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def dev?
         %W(development test).include?(Jekyll.env)
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def compress?(what)
-        !!asset_config.fetch("compress").fetch(what, false)
+        !!asset_config["compress"]. \
+          fetch(what, false)
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def asset_config
-        jekyll.config.fetch_or_store("assets", {})
+        jekyll.config["assets"] ||= {}
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def digest?
-        !!asset_config.fetch("digest")
+        !!asset_config["digest"]
       end
 
-      # -----------------------------------------------------------------------
+      # Prefix path prefixes the path with the baseurl and the cdn if it
+      # exists and is in the right mode to use it.  Otherwise it will only use
+      # the baseurl and asset prefix.  All of these can be adjusted.
 
-      def prefix
-        asset_config.fetch("prefix", "")
-      end
+      def prefix_path(path = nil)
+        _baseurl = baseurl
+        cdn = asset_config["cdn"]
+        _path = []
 
-      # -----------------------------------------------------------------------
-      # Prefixes a path with both the #base_url, the prefix and the CDN.
-      # -----------------------------------------------------------------------
-
-      def prefix_path(path = "")
-        prefix  = cdn? && asset_config.fetch( "skip_prefix_with_cdn") ? "" : self. prefix
-        baseurl = cdn? && asset_config.fetch("skip_baseurl_with_cdn") ? "" : self.baseurl
-        path    = [baseurl, prefix, path]
-
-        cdn = asset_config.fetch("cdn") if asset_config.has_key?("cdn")
-        cdn? && cdn ? File.join(cdn, *path).chomp("/") : \
-          File.join(*path).chomp("/")
+        _path << _baseurl unless _baseurl.empty?
+        _path << path unless path.nil?
+        cdn? && cdn ? File.join(cdn, *_path).chomp("/") : \
+          File.join(*_path).chomp("/")
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def cached
         Cached.new(self)
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       def write_all
-        if cached_write?
-          write_cached_assets else write_assets
-        end
-      end
-
-      # -----------------------------------------------------------------------
-
-      private
-      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]
-
-        assets.each do |v|
-          v.write_to as_path v
-        end
-      end
-
-      # -----------------------------------------------------------------------
-
-      private
-      def write_cached_assets(assets = all_assets(true))
-        assets.each do |a|
-          if !a.is_a?(Liquid::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
+        past = self.class.past ||= Set.new
+        (@used.any?? all_assets : past).each do |obj|
+          if past.add(obj) && path = as_path(obj)
+            obj.write_to path
           end
-
-          self.class.digest_cache[a.logical_path] = a.digest
-          a.write_to as_path a
         end
       end
 
-      # -----------------------------------------------------------------------
+      #
 
       private
       def as_path(v)
         path = digest?? v.digest_path : v.logical_path
-        jekyll.in_dest_dir(File.join(prefix, path))
+        jekyll.in_dest_dir(File.join(asset_config[ "prefix"], path))
       end
     end
   end