jekyll-assets 2.0.0.pre.beta4 → 2.0.0

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

@@ -0,0 +1,18 @@
+module Jekyll
+  module Assets
+    module Liquid
+      class Tag
+        module Defaults
+          require_relative "defaults/image"
+
+          module_function
+          def set_defaults_for!(tag, args, asset)
+            constants.select { |const| const_get(const).is_for?(tag) }.each do |const|
+              const_get(const).new(args, asset).set!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Jekyll
+  module Assets
+    module Liquid
+      class Tag
+        module Defaults
+          class Image
+            def self.is_for?(tag)
+              tag == "img" || tag == "image"
+            end
+
+            #
+
+            def initialize(args, asset)
+              @asset = asset
+              @args  =  args
+            end
+
+            #
+
+            def set!
+              set_img_dimensions
+              set_img_alt
+            end
+
+            #
+
+            private
+            def set_img_alt
+              @args[:html] ||= {}
+              if !@args[:html].has_key?("alt")
+                then @args[:html]["alt"] = @asset.logical_path
+              end
+            end
+
+            #
+
+            private
+            def set_img_dimensions
+              dimensions = FastImage.new(@asset.filename).size
+              return unless dimensions
+              @args[:html] ||= {}
+
+              @args[:html][ "width"] ||= dimensions.first
+              @args[:html]["height"] ||= dimensions. last
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 require_relative "proxies"
 require "forwardable"
 
@@ -5,7 +9,6 @@ module Jekyll
   module Assets
     module Liquid
 
-      # -----------------------------------------------------------------------
       # Examples:
       #   - {% tag value argument:value %}
       #   - {% tag value "argument:value" %}
@@ -13,27 +16,27 @@ module Jekyll
       #   - {% 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, :each
           def_delegator :@args, :has_key?
-          def_delegator :@args, :fetch_or_store
           def_delegator :@args, :fetch
           def_delegator :@args, :store
+          def_delegator :@args, :to_h
+          def_delegator :@args, :[]=
           def_delegator :@args, :[]
 
-          # -------------------------------------------------------------------
+          #
 
           Accept = {
             "css" => "text/css", "js" => "application/javascript"
           }
 
-          # -------------------------------------------------------------------
+          #
 
           class UnescapedColonError < StandardError
             def initialize
@@ -41,7 +44,7 @@ module Jekyll
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           class UnknownProxyError < StandardError
             def initialize
@@ -49,7 +52,7 @@ module Jekyll
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def initialize(args, tag)
             @raw_args, @tags = args, tag
@@ -58,7 +61,14 @@ module Jekyll
             set_accept
           end
 
-          # -------------------------------------------------------------------
+          #
+
+          def parse_liquid!(context)
+            return @args unless context.is_a?(::Liquid::Context)
+            @args = _parse_liquid(@args, context)
+          end
+
+          #
 
           def to_html
             @args.fetch(:html, {}).map do |key, val|
@@ -67,7 +77,7 @@ module Jekyll
             join
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def proxies
             keys = (args.keys - Proxies.base_keys - [:file, :html])
@@ -76,13 +86,13 @@ module Jekyll
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def has_proxies?
             proxies.any?
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def parse_raw
@@ -92,15 +102,15 @@ module Jekyll
                 parse_col hash, key
 
               else
-                hash.fetch_or_store(:html, {}). \
-                  store(key, true)
+                (hash[:html] ||= {})[key] = \
+                  true
               end
 
               hash
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def parse_col(hash, key)
@@ -111,51 +121,69 @@ module Jekyll
             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)
+              (hash[key.to_sym] ||= {})[sub_key.to_sym] = true
             else
-              hash.fetch_or_store(:html, {}). \
-                store(key, okey.fetch(1))
+              (hash[:html] ||= {})[key] = \
+                okey[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)
+              (hash[key.to_sym] ||= {})[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[:sprockets].has_key?(:accept))
 
-              @args.fetch_or_store(:sprockets, {}). \
-                store(:accept, Accept.fetch(@tag))
+              (@args[:sprockets] ||= {})[:accept] = \
+                Accept[@tag]
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def from_shellwords
             Shellwords.shellwords(@raw_args)
           end
+
+          #
+
+          def _parse_liquid(hash, context)
+            lqd = context.registers[:site].liquid_renderer. \
+              file(raw_args)
+
+            hash.inject({}) do |hsh, (key, val)|
+              if val.is_a?(Hash) || val.is_a?(String)
+                val = val.is_a?(Hash) ? _parse_liquid(val, context) : \
+                  lqd.parse(val).render!(context)
+              end
+
+              hsh.update(
+                key => val
+              )
+            end
+          end
         end
       end
     end

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 require "forwardable"
 
 module Jekyll
@@ -9,8 +13,8 @@ module Jekyll
           extend Forwardable
 
           def_delegator :@asset, :liquid_tags
+          def_delegator :@asset, :filename, :source_filename
           def_delegator :@asset, :content_type
-          def_delegator :@asset, :filename
 
           def initialize(asset, args, env, tag)
             @env = env
@@ -22,41 +26,39 @@ module Jekyll
             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)
@@ -65,24 +67,24 @@ module Jekyll
             }"
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def write_to(name)
             File.binwrite(name, source)
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def proxy_file
             unless cached?
               args.proxies.each do |key, val|
-                Proxies.get(key).first.fetch(:class).new(self, val).process
+                Proxies.get(key).first[:class].new(self, val, @args).process
               end
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def cache_file

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

@@ -1,3 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012-2015 - MIT License
+# Encoding: utf-8
+
 module Jekyll
   module Assets
     module Liquid
@@ -17,82 +21,84 @@ module Jekyll
           all
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.add(name, tag, *args, &block)
             add_by_class(*generate_class(name, tag, &block), *args)
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.keys
-            all.select { |val| !val.fetch(:class).is_a?(Symbol) }.map do |v|
-              v[:name]
+            all.select { |val| !val[:class].is_a?(Symbol) }.map do |val|
+              val[:name]
             end. \
             flatten
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.base_keys
-            all.select { |val| val.fetch(:class).is_a?(Symbol) }.map do |v|
-              v[:name]
+            all.select { |val| val[:class].is_a?(Symbol) }.map do |val|
+              val[:name]
             end. \
             flatten
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.has?(name, tag = nil, arg = nil)
             get(name, tag, arg).any?
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.get(name, tag = nil, arg = nil)
             if name && tag && arg
               get_by_name_and_tag_and_arg(
                 name, tag, arg
               )
+
             elsif name && tag
               get_by_name_and_tag(
                 name, tag
               )
+
             else
               all.select do |val|
-                val.fetch(:name).include?(name)
+                val[:name].include?(name)
               end
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.get_by_name_and_tag_and_arg(name, tag, arg)
             all.select do |val|
-              (val.fetch(:name).include?(name))   && \
-              (val.fetch(:tags).include?(:all)    || \
-                  val.fetch(:tags).include?(tag)) && \
-              (val.fetch(:args).include?( arg))
+              (val[:name].include?(name))   && \
+              (val[:tags].include?(:all)    || \
+                  val[:tags].include?(tag)) && \
+              (val[:args].include?( arg))
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.get_by_name_and_tag(name, tag)
             all.select do |val|
-              (val.fetch(:name).include?(name))   &&
-              (val.fetch(:tags).include?(:all)    || \
-                  val.fetch(:tags).include?(tag))
+              (val[:name].include?(name))   &&
+              (val[:tags].include?(:all)    || \
+                  val[:tags].include?(tag))
             end
           end
 
-          # -------------------------------------------------------------------
+          #
 
           def self.all
             @_all ||= Set.new
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def self.generate_class(name, tag, &block)
@@ -101,15 +107,13 @@ module Jekyll
             return _class, name, tag
           end
 
-          # -------------------------------------------------------------------
+          #
 
           private
           def self.random_name
             (0...12).map { ("a".."z").to_a.values_at(rand(26)) }.join.capitalize
           end
 
-          # -------------------------------------------------------------------
-
           # TODO: Put in a better place.
           add_by_class :internal, :data, :all, ["@uri"]
           add_by_class :internal, :sprockets, :all, [