jekyll-assets 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b48bcbe756753d18e5daab5826fd0d2e5e1c129
-  data.tar.gz: 3291bf13013e12384be82f76ac4f6ff4c37562f5
+  metadata.gz: c1beb6828d5534b96a31042623acb912c13b3e38
+  data.tar.gz: 688fabb88be88681c40954736b663d216f7ad93d
 SHA512:
-  metadata.gz: 2881e933bea8ac977bca0cb95e51f7b09d028c681f1333ef5a8e055594dc35e860887cc70c9c5e10038c5c6bcd21787685b72ad554f8d5577c41ec0e999a9ba4
-  data.tar.gz: bee841e2c8a1be65d76b05bf56949cc57b559bcd3f4c4d1ce75b420ebd66c94c40ea3c54b32d3668a42d45cb74005bf9798c11def68c55428ae39cce6590608a
+  metadata.gz: c085055cc33ff864f394b22d0f98530f8d3d71a871baf01f7dd00d8cc59151c9907e9ce1f65b46d828fb93086fd70d80df1dd80b2115cd6961aebf05e8565f29
+  data.tar.gz: 5b0f8f7cc6bb1010c23be8a2ffb15f744283c2ada9b56ed9010dd5fa7c9407ded47742117e2d8017fd6d415f8e9bd28d6e6937643563cd4ed2c388a7f9947d81

data/README.md

@@ -36,16 +36,26 @@ assets:
   compress:
     css: false | true | default - development: false, production: true
     js: false | true | default - development: false, production: true
+
+  #
+
+  autowrite: true
   cache: false | directory | default: .asset-cache
+  cache_type: memory | filesystem | default: filesystem
   cdn: https://cdn.example.com
   skip_baseurl_with_cdn: false
   skip_prefix_with_cdn: false
   prefix: "/assets"
-  autowrite: true
+  digest: true
+
+  #
+
   assets:
     - "*.png"
     - "bundle.css"
-  digest: true
+
+  #
+
   sources:
     - _assets/css
     - _assets/images
@@ -54,6 +64,9 @@ assets:
     - _assets/fonts
     - _assets/img
     - _assets/js
+
+  #
+
   features:
     liquid: true | false | default: false
     automatic_img_size: true | false | n(fixnum): 2,4,6,8 | default: true

data/lib/jekyll/assets/cached.rb

@@ -1,17 +1,16 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
     class Cached < Sprockets::CachedEnvironment
-      attr_reader :jekyll
-      attr_reader :parent
-
-      # ----------------------------------------------------------------------
+      attr_reader :jekyll, :parent
 
+      # --
+      # @param [Env] env the environment
+      # Initialize a new instance
+      # --
       def initialize(env)
         @parent = env
         @jekyll = env.jekyll
@@ -19,6 +18,10 @@ module Jekyll
         super env
       end
 
+
+      # --
+      # Resolve an asset.
+      # --
       def resolve(*args)
         @resolve_cache[args] ||= super
       end

data/lib/jekyll/assets/config.rb

@@ -1,8 +1,6 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
@@ -13,9 +11,10 @@ module Jekyll
         _assets/javascripts _assets/js
       ).freeze
 
-      # ----------------------------------------------------------------------
+      # --
 
       Development = {
+        "cache_type" => "filesystem",
         "skip_baseurl_with_cdn" => false,
         "skip_prefix_with_cdn"  => false,
         "prefix"    => "/assets",
@@ -35,7 +34,7 @@ module Jekyll
         }
       }.freeze
 
-      # ----------------------------------------------------------------------
+      # --
 
       Production = Development.merge({
         "digest"    => true,
@@ -45,8 +44,10 @@ module Jekyll
         }
       }).freeze
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # @param [Jekyll::Site] jekyll The jekyll instance.
+      # Merge our sources with Jekyll's sources.
+      # --
       def self.merge_sources(jekyll, config) config["sources"] ||= []
         if !config["sources"].grep(/\A\s*_assets\/?\s*\Z/).empty?
           return
@@ -59,7 +60,7 @@ module Jekyll
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def self.defaults
         if %W(development test).include?(Jekyll.env)
@@ -67,7 +68,7 @@ module Jekyll
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def self.merge(new_hash, old_hash = defaults)
         old_hash.merge(new_hash) do |_, old_val, new_val|

data/lib/jekyll/assets/env.rb

@@ -1,58 +1,96 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
     class Env < Sprockets::Environment
-      attr_reader :jekyll, :used
+      attr_accessor :jekyll
 
       class << self
-        attr_accessor :past
+
+        # --
+        # A list of instances for Jekyll and their paths.
+        # This works around Jekyll watch and build booting twice.
+        # @return [Hash]
+        # --
+        def instances
+          return @instances ||= {
+            #
+          }
+        end
+
+        # --
+        # A list of Liquid Proxies.
+        # @return [Set]
+        # --
         def liquid_proxies
           Liquid::Tag::Proxies
         end
 
-        # --------------------------------------------------------------------
+        # --
+        # XXX: Remove this in 3.0, it's unecessary.
+        # Initialize a new instance of ourselves onto Jekyll if not exist.
+        # @param [Jekyll::Site] jekyll the site instance.
+        # --
+        def init(jekyll, key = jekyll.in_source_dir)
+          Jekyll.logger.debug "Creating a new instance of: ", self
+          Jekyll.logger.debug "The old value of Sprockets: ",
+            jekyll.sprockets
+
+          instances[key] = new(
+            jekyll
+          )
 
-        def init(jekyll)
-          new(jekyll)
           jekyll.sprockets.excludes.map(&jekyll.config["exclude"].method(:<<))
           jekyll.config["keep_files"] |= jekyll.sprockets.asset_config["prefix"].gsub(/\A\//, "").to_a
           jekyll.config["exclude"].uniq!
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      # XXX: Remove in 3.0
+      # Used is deprecated, use Manifest#add.
+      # @return [Manifest]
+      # --
+      def used
+        Logger.deprecate "Env#used is deprecated use Manifest#add", jekyll do
+          manifest
+        end
+      end
+
+      # --
       # Disables GZIP.  You should be using your server to do this and even
       # if you don't, there are far better and more efficient algorithms out
       # right now that are in beta.  Try Googling Googles new compression.
-      # ----------------------------------------------------------------------
-
+      # --
       def skip_gzip?
         true
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Builds a list of excludes for Jekyll.
+      # @return [Set]
+      # --
       def excludes
         excludes = Set.new
         excludes << strip_path(in_cache_dir)
         excludes
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Returns all the assets.
+      # --
       def all_unparsed_assets
         @unparsed_assets ||= logical_paths.select do |(_, val)|
           val.start_with?(jekyll.in_source_dir)
         end
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Converts this class into a set of Drops.
+      # @return [Hash]
+      # --
       def to_liquid_payload
         jekyll.sprockets.all_unparsed_assets.each_with_object({}) do |(key, val), hash|
           hash[key] = Jekyll::Assets::Liquid::Drop.new(
@@ -61,70 +99,88 @@ module Jekyll
         end
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Initialize a new instance of this class.
+      # @param [<Anything>] path This is passed upstream, we don't care.
+      # @param [Jekyll::Site] jekyll the Jekyll instances.
+      # XXX: Merge with .init in 3.0
+      # --
       def initialize(path, jekyll = nil)
         (jekyll = path; path = nil) if path.is_a?(Jekyll::Site)
 
         @used = Set.new
-        @jekyll = jekyll
         path ? super(path) : super()
+        @jekyll = jekyll
+
+        # XXX: In 3.0, we need to drop anything to do with instance eval,
+        #   and imply pass the instance, this will make our code cleaner.
+
         Hook.trigger :env, :init do |hook|
           hook.arity > 0 || 0 > hook.arity ? hook.call(self) : instance_eval(
             &hook
           )
         end
-      end
 
-      # ----------------------------------------------------------------------
+        # Make sure that we add extras.
+        extra_assets.each do |asset|
+          manifest.add(
+            asset
+          )
+        end
+      end
 
+      # --
+      # A list of Liquid Proxies.
+      # @return [Set]
+      # --
       def liquid_proxies
         self.class.liquid_proxies
       end
 
-      # ----------------------------------------------------------------------
-      # Make sure a path falls withint our cache dir.
-      # ----------------------------------------------------------------------
-
+      # --
+      # Make a path land inside of our cache directory.
+      # @param [<Anything>] *paths the paths you wish to land.
+      # @return [Pathname/Pathutil]
+      # --
       def in_cache_dir(*paths)
         jekyll.in_source_dir(asset_config["cache"] || ".asset-cache",
           *paths
         )
       end
 
-      # ----------------------------------------------------------------------
-      # Merged form of `#extra_assets`
-      # ----------------------------------------------------------------------
-
+      # --
+      # Deprecated: Use Manifest#to_compile
+      # XXX: Remove in 3.0
+      # --
       def all_assets
-        Set.new(@used).merge(
-          extra_assets
-        )
+        Logger.deprecate "Env#all_assets is deprecated, use Manifest#all", jekyll do
+          manifest.all
+        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
         assets = asset_config["assets"] ||= []
         each_logical_path(*assets).map do |v|
-          find_asset v
+          manifest.find(v).first
         end
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Whether or not we need a CDN.
+      # --
       def cdn?
         !dev? && asset_config.key?("cdn") && \
           asset_config["cdn"]
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      # The BaseURL mixed with Jekyll's own BaseURL.
       # rubocop:disable Style/ExtraSpacing
-      # ----------------------------------------------------------------------
-
+      # --
       def baseurl
         ary = []
 
@@ -136,42 +192,47 @@ module Jekyll
         end)
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      # Whether or not we are in development mode.
       # rubocop:enable Style/ExtraSpacing
-      # ----------------------------------------------------------------------
-
+      # --
       def dev?
         %W(development test).include?(Jekyll.env)
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Whether or not we should compress assets.
+      # --
       def compress?(what)
         !!asset_config["compress"].fetch(
           what, false
         )
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # The asset configuration.
+      # --
       def asset_config
         jekyll.config["assets"] ||= {}
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Whether or not we are digesting.
+      # @return [true,false]
+      # --
       def 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.
-      # ----------------------------------------------------------------------
-
+      # the baseurl and asset prefix.  All of these can be adjusted...
+      # @param [String,Pathname,Pathutil] path the path to prefix.
+      # @return [Pathname,Pathutil,String]
+      # --
       def prefix_path(path = nil)
         cdn = asset_config["cdn"]
         base_url = baseurl
@@ -184,32 +245,42 @@ module Jekyll
         url.chomp("/")
       end
 
-      # ----------------------------------------------------------------------
 
+      # --
+      # Sprockets cached instance.
+      # @return [Cached]
+      # --
       def cached
         return @cached ||= Cached.new(
           self
         )
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # The manifest we use to pull assets.
+      # @return [Manifest]
+      # --
       def manifest
         return @manifest ||= Manifest.new(self, jekyll.in_dest_dir(
           asset_config["prefix"]
         ))
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Write assets with the manifest if they aren't proxied assets.  If
       # they are then we go on to write them ourselves.  We don't necessarily
       # integrate with the manifest that deeply because it's hard.
-      # ----------------------------------------------------------------------
-
+      # --
       def write_all
-        assets = all_assets.partition { |v| v.is_a?(Liquid::Tag::ProxiedAsset) }
-        writeable_assets = assets.last.map(&:dependencies).push(assets.last).reduce(&:|)
-        manifest.compile(writeable_assets.map(&:logical_path))
+        assets = manifest.all.partition { |v| v.is_a?(Liquid::Tag::ProxiedAsset) }
+        manifest.compile(assets.last.map(
+          &:logical_path
+        ))
+
+        # Proxied assets will not compile the normal way since they are
+        # always considered uniq when used, and they supply their own inline
+        # caching, so we always write them individually since they will
+        # never actually show up inside of the manifest.
 
         assets.first.map do |asset|
           asset.write_to(jekyll.in_dest_dir(File.join(asset_config["prefix"],
@@ -218,8 +289,9 @@ module Jekyll
         end
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
+      # Undocumented
+      # --
       private
       def strip_path(path)
         path.sub(jekyll.in_source_dir("/"), "")

data/lib/jekyll/assets/helpers.rb

@@ -15,7 +15,7 @@ module Jekyll
         asset = manifest.find(path).first
 
         if asset
-          parent.used.add(asset)
+          manifest.add(asset)
           parent.prefix_path(
             parent.digest?? asset.digest_path : asset.logical_path
           )

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

@@ -1,17 +1,25 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 Jekyll::Assets::Hook.register :env, :init do
-  cache_dir = asset_config.fetch("cache",
-    ".asset-cache"
+  cache = asset_config.fetch("cache", ".asset-cache")
+  type  = asset_config.fetch("cache_type",
+    "filesystem"
   )
 
-  if cache_dir
-    self.cache = Sprockets::Cache::FileStore.new(
-      jekyll.in_source_dir(cache_dir)
-    )
+  if cache != false && type != "memory"
+    self.cache = begin
+      Sprockets::Cache::FileStore.new(
+        jekyll.in_source_dir(
+          cache
+        )
+      )
+    end
+
+  elsif cache && type == "memory"
+    self.cache = begin
+      Sprockets::Cache::MemoryStore.new
+    end
   end
 end

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

@@ -115,7 +115,7 @@ module Jekyll
 
         private
         def process_tag(args, sprockets, asset)
-          sprockets.used.add(asset) unless @tag == "asset_source"
+          sprockets.manifest.add(asset) unless @tag == "asset_source"
           Defaults.set_defaults_for!(@tag, args ||= {}, asset, sprockets)
           build_html(args, sprockets, asset)
         end

data/lib/jekyll/assets/logger.rb

@@ -9,52 +9,65 @@ module Jekyll
     class Logger
       PREFIX = "Jekyll Assets:"
 
+      class << self
+
+        # --
+        # @param [String] msg the message you wish to send out.
+        # Deprecate a method and warn the user about it.
+        # --
+        def deprecate(msg, instance)
+          filepath = caller[1].split(/\.rb:/).first + ".rb"
+          filepath = Pathutil.new(filepath).relative_path_from(instance.in_source_dir)
+          Jekyll.logger.error("", format("%s: %s", msg.red, filepath))
+          yield if block_given?
+        end
+      end
+
+      # --
+      # @return [Jekyll:Logger]
+      # The logger.
+      # --
       def log
-        @_log ||= Jekyll.logger
+        return @log ||= Jekyll.logger
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Log Level: 1
-      # ----------------------------------------------------------------------
-
+      # --
       def warn(msg = nil)
         log.warn(PREFIX,
           block_given?? yield : msg
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Log Level: 1
-      # ----------------------------------------------------------------------
-
+      # --
       def error(msg = nil)
         log.error(PREFIX,
           block_given?? yield : msg
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Log Level: 2
-      # ----------------------------------------------------------------------
-
+      # --
       def info(msg = nil)
         log.info(PREFIX,
           block_given?? yield : msg
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Log Level: 3
-      # ----------------------------------------------------------------------
-
+      # --
       def debug(msg = nil)
         log.debug(PREFIX,
           block_given?? yield : msg
         )
       end
 
-      # ----------------------------------------------------------------------
-
+      # --
       def log_level=(*)
         raise "Please set log levels on Jekyll.logger"
       end

data/lib/jekyll/assets/manifest.rb

@@ -1,18 +1,40 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
+    class Manifest < Sprockets::Manifest
+      extend Forwardable::Extended
+      rb_delegate :add, {
+        :to => :used
+      }
 
-    # ------------------------------------------------------------------------
-    # 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.
-    # ------------------------------------------------------------------------
+      # --
+      # The assets to be compiled.
+      # @return [Set]
+      # --
+      def used
+        @assets ||= Set.new
+      end
 
-    class Manifest < Sprockets::Manifest
+      # --
+      # All the assets, plus the used.
+      # @return [Set]
+      # --
+      def all
+        @assets | (files.map do |_, v|
+          find(v[
+            "logical_path"
+          ]).first
+        end)
+      end
+
+      # --
+      # This is a wholesale rip of Sprockets::Manifest#compkle, we only
+      # adjust it to care about whether or not we want to digest, we don't
+      # always digest in development.
+      # --
       def compile(*args)
         unless environment
           raise(

data/lib/jekyll/assets/version.rb

@@ -1,11 +1,9 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2012 - 2016 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
-    VERSION="2.2.2"
+    VERSION="2.2.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-assets
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Jordon Bedwell