jekyll-assets 2.0.0.pre.beta2 → 2.0.0.pre.beta3

data/lib/jekyll/assets/hook.rb

@@ -2,43 +2,60 @@ module Jekyll
   module Assets
     class Hook
       class UnknownHookError < RuntimeError
-        def initialize(base, point)
-          super "Unknown jekyll-assets hook point (#{point}) or base (#{base}) given."
+        def initialize(base: nil, point: nil)
+          return super "Unknown hook  base '#{base}'" if base
+          return super "Unknown hook point '#{point}' given."
         end
       end
 
-      HOOK_POINTS = {
+      HookAliases = {
+        :env => {
+          :post_init => :init,
+           :pre_init => :init
+        }
+      }
+
+      HookPoints = {
         :env => [
-          :pre_init, :post_init
+          :init
         ]
       }
 
-      class << self
-        def all
-          @_all ||= {}
-        end
+      def self.all
+        @_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 trigger(base, point, *args)
-          if all[base][point]
-            then all[base][point].map do |v|
-              v.call(*args)
-            end
+      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)
+          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 point(base, point)
-          all[base][point] ||= Set.new
-        end
+      # ---------------------------------------------------------------------
 
-        def register(base, point, &block)
-          if HOOK_POINTS.has_key?(base) && HOOK_POINTS[base].include?(point)
-             all[base] ||= {}
-             point(base, point) << \
-              block
-          else
-            raise UnknownHookError.new(base, point)
-          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)
+      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)
       end
     end
   end

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

@@ -0,0 +1,5 @@
+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))
+  end
+end

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

@@ -0,0 +1,11 @@
+Jekyll::Assets::Hook.register :env, :init do
+  if compress?("css")
+    self.css_compressor = :sass
+  end
+
+  if compress?("js")
+    try_require "uglifier" do
+      self.js_compressor = :uglify
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,12 @@
+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)
+    out
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+Jekyll::Assets::Hook.register :env, :init, :early do
+  self.config = hash_reassoc(config, :engines) do |hash|
+    hash.delete(".erb")
+    hash
+  end
+end

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

@@ -0,0 +1,8 @@
+require "sprockets/helpers"
+
+Jekyll::Assets::Hook.register :env, :init do
+  Sprockets::Helpers.configure do |config|
+    config.prefix = prefix_path
+    config.digest =     digest?
+  end
+end

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

@@ -0,0 +1,3 @@
+Jekyll::Assets::Hook.register :env, :init do
+  self.logger = Jekyll::Assets::Logger.new
+end

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

@@ -0,0 +1,5 @@
+Jekyll::Assets::Hook.register :env, :init do
+  asset_config.fetch("sources", []).each do |path|
+    append_path jekyll.in_source_dir(path)
+  end
+end

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

@@ -0,0 +1,3 @@
+Jekyll::Assets::Hook.register :env, :init do
+  jekyll.sprockets = self
+end

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

@@ -0,0 +1,3 @@
+Jekyll::Assets::Hook.register :env, :init do
+  self.version = Digest::MD5.hexdigest(jekyll.config.fetch("assets", {}).inspect)
+end

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

@@ -0,0 +1,16 @@
+module Jekyll
+  module Assets
+    module Liquid
+      module Filters
+        %W(js css img image javascript stylesheet style asset_path).each do |val|
+          define_method val do |path, args = ""|
+            Tag.send(:new, val, "#{path} #{args}", "").render(@context)
+          end
+        end
+      end
+    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

@@ -0,0 +1,162 @@
+module Jekyll
+  module Assets
+    module Liquid
+      class Tag < ::Liquid::Tag
+        require_relative "tag/proxied_asset"
+        require_relative "tag/parser"
+        attr_reader :args
+
+        class AssetNotFoundError < StandardError
+          def initialize(asset)
+            super "Could not find the asset `#{asset}'"
+          end
+        end
+
+        # ---------------------------------------------------------------------
+
+        Tags = {
+          "css" => %Q{<link type="text/css" rel="stylesheet" href="%s"%s>},
+          "js"  => %Q{<script type="text/javascript" src="%s"%s></script>},
+          "img" => %Q{<img src="%s"%s>}
+        }
+
+        # ---------------------------------------------------------------------
+
+        Alias = {
+          "image" => "img",
+          "stylesheet" => "css",
+          "javascript" => "js",
+          "style" => "css"
+        }
+
+        # ---------------------------------------------------------------------
+
+        def initialize(tag, args, tokens)
+          @tokens = tokens
+          @tag = from_alias(tag)
+          @args = Parser.new(args, @tag)
+          @og_tag = tag
+          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)
+          sprockets = site.sprockets
+
+          asset = find_asset(sprockets)
+          add_as_jekyll_dependency(site, sprockets, page, asset)
+          process_tag(sprockets, asset)
+        rescue => e
+          capture_and_out_error \
+            site, e
+        end
+
+        # ---------------------------------------------------------------------
+
+        private
+        def from_alias(tag)
+          Alias.has_key?(tag) ? Alias.fetch(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
+          if @tag == "asset_path"
+            return out
+
+          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) % [
+              asset.data_uri, @args.to_html
+            ]
+
+          else
+            return Tags.fetch(@tag) % [
+              out, @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
+        end
+
+        # ---------------------------------------------------------------------
+
+        private
+        def add_as_jekyll_dependency(site, sprockets, page, asset)
+          if page && sprockets.digest?
+            site.regenerator.add_dependency(
+              site.in_source_dir(page), site.in_source_dir(asset.logical_path)
+            )
+          end
+        end
+
+        # ---------------------------------------------------------------------
+
+        private
+        def find_asset(sprockets)
+          file, _sprockets = @args.fetch(:file), @args.fetch(:sprockets, {})
+          if !(out = sprockets.find_asset(file, _sprockets))
+            raise AssetNotFoundError, @args.fetch(:file)
+          else
+            out.liquid_tags << 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)
+          if error.is_a?(Sass::SyntaxError)
+            file = error.sass_filename.gsub(/#{Regexp.escape(site.source)}\//, "")
+            Jekyll.logger.error(%Q{Error in #{file}:#{error.sass_line}  #{error}})
+          else
+            Jekyll.logger.error \
+              "", error.to_s
+          end
+
+          raise error
+        end
+      end
+    end
+  end
+end
+
+%W(js css img image javascript stylesheet style asset_path asset_source asset).each do |tag|
+  Liquid::Template.register_tag tag, Jekyll::Assets::Liquid::Tag
+end

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

@@ -0,0 +1,163 @@
+require_relative "proxies"
+require "forwardable"
+
+module Jekyll
+  module Assets
+    module Liquid
+
+      # -----------------------------------------------------------------------
+      # Examples:
+      #   - {% tag value argument:value %}
+      #   - {% tag value "argument:value" %}
+      #   - {% tag value argument:"I have spaces" %}
+      #   - {% tag value argument:value\:with\:colon %}
+      #   - {% tag value argument:"I can even escape \\: here too!" %}
+      #   - {% tag value proxy:key:value %}
+      # -----------------------------------------------------------------------
+
+      class Tag
+        class Parser
+          attr_reader :args, :raw_args
+          extend Forwardable
+
+          def_delegator :@args, :to_h
+          def_delegator :@args, :has_key?
+          def_delegator :@args, :fetch_or_store
+          def_delegator :@args, :fetch
+          def_delegator :@args, :store
+          def_delegator :@args, :[]
+
+          # -------------------------------------------------------------------
+
+          Accept = {
+            "css" => "text/css", "js" => "application/javascript"
+          }
+
+          # -------------------------------------------------------------------
+
+          class UnescapedColonError < StandardError
+            def initialize
+              super "Unescaped double colon argument."
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          class UnknownProxyError < StandardError
+            def initialize
+              super "Unknown proxy argument."
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          def initialize(args, tag)
+            @raw_args, @tags = args, tag
+            @tag = tag
+            parse_raw
+            set_accept
+          end
+
+          # -------------------------------------------------------------------
+
+          def to_html
+            @args.fetch(:html, {}).map do |key, val|
+              %Q{ #{key}="#{val}"}
+            end. \
+            join
+          end
+
+          # -------------------------------------------------------------------
+
+          def proxies
+            keys = (args.keys - Proxies.base_keys - [:file, :html])
+            args.select do |key, _|
+              keys.include?(key)
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          def has_proxies?
+            proxies.any?
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def parse_raw
+            @args = from_shellwords.each_with_index.inject({}) do |hash, (key, index)|
+              if index == 0 then hash.store(:file, key)
+              elsif key =~ /:/ && (key = key.split(/(?<!\\):/))
+                parse_col hash, key
+
+              else
+                hash.fetch_or_store(:html, {}). \
+                  store(key, true)
+              end
+
+              hash
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def parse_col(hash, key)
+            key.push(key.delete_at(-1).gsub(/\\:/, ":"))
+            if key.size == 3 then as_proxy hash, key
+              elsif key.size == 2 then as_bool_or_html hash, key
+              else raise UnescapedColonError
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def as_bool_or_html(hash, key)
+            okey = key; key, sub_key = key
+            if Proxies.has?(key, @tag, "@#{sub_key}")
+              hash.fetch_or_store(key.to_sym, {}). \
+                store(sub_key.to_sym, true)
+            else
+              hash.fetch_or_store(:html, {}). \
+                store(key, okey.fetch(1))
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def as_proxy(hash, key)
+            key, sub_key, val = key
+            if Proxies.has?(key, @tag, sub_key)
+              hash.fetch_or_store(key.to_sym, {}). \
+                store(sub_key.to_sym, val)
+            elsif Proxies.has?(key)
+              raise UnknownProxyError
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def set_accept
+            if Accept.has_key?(@tag) && (!@args.has_key?(:sprockets) || \
+                !@args.fetch(:sprockets).has_Key?(:accept))
+
+              @args.fetch_or_store(:sprockets, {}). \
+                store(:accept, Accept.fetch(@tag))
+            end
+          end
+
+          # -------------------------------------------------------------------
+
+          private
+          def from_shellwords
+            Shellwords.shellwords(@raw_args)
+          end
+        end
+      end
+    end
+  end
+end