jekyll-assets 1.0.0 → 2.0.0.pre.beta1

data/lib/jekyll/assets/helpers.rb

@@ -0,0 +1,37 @@
+module Jekyll
+  module Assets
+    module Helpers
+      class << self
+        def has_javascript?
+          require "execjs"
+          if block_given?
+            yield
+          end
+        rescue LoadError, ExecJS::RuntimeUnavailable
+          Jekyll.logger.debug("ExecJS or JS Runtime not available." \
+            " Skipping loading of library.")
+        end
+
+        def try_require(file)
+          require file
+          if block_given?
+            yield
+          end
+        rescue LoadError
+          return nil
+        end
+
+        def try_require_if_javascript?(file)
+          ["execjs", file].map(&method(:require))
+          if block_given?
+            yield
+          end
+        rescue LoadError, ExecJS::RuntimeUnavailable
+          Jekyll.logger.debug("ExecJS, JS Runtime or `#{file}' not available." \
+            " Skipping the loading of libraries.")
+          return
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/assets/hook.rb

@@ -0,0 +1,45 @@
+module Jekyll
+  module Assets
+    class Hook
+      class UnknownHookError < RuntimeError
+        def initialize(base, point)
+          super "Unknown jekyll-assets hook point (#{point}) or base (#{base}) given."
+        end
+      end
+
+      HOOK_POINTS = {
+        :env => [
+          :pre_init, :post_init
+        ]
+      }
+
+      class << self
+        def all
+          @_all ||= {}
+        end
+
+        def trigger(base, point, *args)
+          if all[base][point]
+            then all[base][point].map do |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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+Jekyll::Hooks.register :site, :post_read do |s|
+  Jekyll::Assets::Env.new(s)
+end

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

@@ -0,0 +1,3 @@
+Jekyll::Hooks.register :site, :post_write do |s|
+  s.sprockets.write_all
+end

data/lib/jekyll/assets/logger.rb

@@ -0,0 +1,25 @@
+module Jekyll
+  module Assets
+
+    # TODO: jekyll/jekyll@upstream add support for blocks as messages...
+    # NOTE: This is a temporary class, until we can go upstream and fix
+    #   the little known fact that it doesn't accept a block for a message
+    #   it is passing on.  Until then we are holding this.
+
+    class Logger
+      def instance
+        @logger ||= Jekyll.logger
+      end
+
+      %W(warn error info debug).each do |k|
+        define_method k do |msg = nil, &block|
+          instance.send(k, "Jekyll Assets:", block ? block.call : msg)
+        end
+      end
+
+      def log_level=(*a)
+        raise RuntimeError, "Please set log levels on Jekyll.logger"
+      end
+    end
+  end
+end

data/lib/jekyll/assets/patches/jekyll/cleaner.rb

@@ -0,0 +1,11 @@
+module Jekyll
+  class Cleaner
+    # TODO: jekyll/jekyll@upstream: This method should really have a hook ya.
+    alias_method :_old_obsolete_files, :obsolete_files
+    def obsolete_files
+      _old_obsolete_files.delete_if do |v|
+        v =~ %r!\A#{Regexp.escape(site.in_dest_dir("assets"))}(\/.*)?\Z!
+      end
+    end
+  end
+end

data/lib/jekyll/assets/patches/jekyll/site.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  class Site
+    attr_accessor :sprockets
+  end
+end

data/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

data/lib/jekyll/assets/tag.rb

@@ -1,19 +1,146 @@
-# 3rd-party
-require "liquid"
-
-# internal
-require "jekyll/assets/renderer"
-
 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)
+          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)
-        Renderer.new(context, @markup).send :"render_#{@tag_name}"
+        site = context.registers[: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[tag] || \
+          tag
+      end
+
+      private
+      def process_tag(sprockets, asset)
+        set_img_alt asset if @tag == "img"
+        out = get_path sprockets, asset
+
+        sprockets.used.add(asset)
+
+        if @tag == "asset_path"
+          return out
+
+        elsif @args[:data][:uri]
+          return TAGS[@tag] % [
+            asset.data_uri, @args.to_html
+          ]
+
+        else
+          return TAGS[@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[:html]["alt"]
+          return @args[:html]["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)
+        if !(out = sprockets.find_asset(@args[:file], @args[:sprockets]))
+          raise AssetNotFoundError, @args[:file]
+        else
+          out.liquid_tags << self
+          if !@args.has_proxies?
+            out else ProxiedAsset.new(
+              out, @args, sprockets, self
+            )
+          end
+        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
 
-%w(asset asset_path image javascript stylesheet).each do |tag|
-  Liquid::Template.register_tag tag, Jekyll::Assets::Tag
+%W(js css img image javascript stylesheet style asset_path).each do |t|
+  Liquid::Template.register_tag t, Jekyll::Assets::Tag
 end

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

@@ -0,0 +1,129 @@
+require_relative "proxies"
+require "forwardable"
+
+module Jekyll
+  module Assets
+
+    # 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
+        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[:html].map do |k, v|
+            %Q{ #{k}="#{v}"}
+          end. \
+          join
+        end
+
+        def proxies
+          keys = (args.keys - Proxies.base_keys - [:file, :html])
+          args.select do |k, v|
+            keys.include?(k)
+          end
+        end
+
+        def has_proxies?
+          proxies.any?
+        end
+
+        private
+        def parse_raw
+          @args = from_shellwords.each_with_index.inject(dhash) do |h, (k, i)|
+            if i == 0 then h[:file] = k
+              elsif k =~ /:/ && (k = k.split(/(?<!\\):/)) then parse_col h, k
+              else h[:html][k] = true
+            end
+
+            h
+          end
+        end
+
+        private
+        def parse_col(h, k)
+          k[-1] = k[-1].gsub(/\\:/, ":")
+          if k.size == 3 then as_proxy h, k
+            elsif k.size == 2 then as_bool_or_html h, k
+            else raise UnescapedColonError
+          end
+        end
+
+        private
+        def as_bool_or_html(h, k)
+          key, sub_key = k
+          if Proxies.has?(key, @tag, "@#{sub_key}")
+            h[key.to_sym][sub_key.to_sym] = true
+          else
+            h[:html][key] = k[1]
+          end
+        end
+
+        private
+        def as_proxy(h, k)
+          key, sub_key, value = k
+          if Proxies.has?(key, @tag, sub_key)
+            h[key.to_sym][sub_key.to_sym] = \
+              value
+          elsif Proxies.has?(key)
+            raise UnknownProxyError
+          end
+        end
+
+        private
+        def set_accept
+          if (accept = ACCEPT[@tag]) && !args[:sprockets][:accept]
+            @args[:sprockets][:accept]  =  accept
+          end
+        end
+
+        private
+        def dhash
+          Hash.new do |h, k|
+            h[k] = {}
+          end
+        end
+
+        private
+        def from_shellwords
+          Shellwords.shellwords(@raw_args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require "forwardable"
+
+module Jekyll
+  module Assets
+    class Tag
+      class ProxiedAsset
+        attr_reader :args, :asset, :env
+        extend Forwardable
+
+        def_delegator :@asset, :liquid_tags
+        def_delegator :@asset, :content_type
+        def_delegator :@asset, :filename
+
+        def initialize(asset, args, env, tag)
+          @env = env
+          @asset = asset
+          @args = args
+          @tag = tag
+          cache_file
+          proxy_file
+        end
+
+        def cached?
+          @_cached
+        end
+
+        def source
+          File.binread(
+            filename
+          )
+        end
+
+        def filename
+          env.in_cache_dir(
+            digest_path
+          )
+        end
+
+        def digest
+          Digest::SHA2.hexdigest(
+            args.proxies.to_s
+          )
+        end
+
+        # We always digest a proxied asset so it's uniq based on what
+        # proxies you give us, it would be ignorant to treat it otherwise,
+        # we also make sure they are URL safe by digesting the args.
+
+        def logical_path
+          digest_path
+        end
+
+        def digest_path
+          name = asset.logical_path
+          ext  = File.extname(name)
+          "#{File.basename(name, ext)}-#{digest}#{ext}"
+        end
+
+        def write_to(name)
+          File.binwrite(
+            name, source
+          )
+        end
+
+        private
+        def proxy_file
+          unless cached?
+            args.proxies.each do |k, v|
+              Proxies.get(k).first[:cls].new(self, v).process
+            end
+          end
+        end
+
+        private
+        def cache_file
+          if File.file?(filename)
+            @_cached = true else @_cached = false
+            FileUtils.cp asset.filename, filename
+          end
+        end
+      end
+    end
+  end
+end