jekyll-assets 2.4.0 → 3.0.0

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

@@ -1,244 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-require "fastimage"
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag < ::Liquid::Tag
-        require_relative "tag/proxies"
-        require_relative "tag/proxied_asset"
-        require_relative "tag/defaults"
-        require_relative "tag/parser"
-        attr_reader :args
-
-        # --------------------------------------------------------------------
-
-        class << self
-          public :new
-        end
-
-        # --------------------------------------------------------------------
-
-        class AssetNotFoundError < StandardError
-          def initialize(asset)
-            super "Could not find the asset `#{asset}'"
-          end
-        end
-
-        # --------------------------------------------------------------------
-        # Tags that we allow our users to use.
-        # --------------------------------------------------------------------
-
-        AcceptableTags = %W(
-          img
-          image
-          javascript
-          asset_source
-          stylesheet
-          asset_path
-          style
-          asset
-          css
-          js
-        ).freeze
-
-        # --------------------------------------------------------------------
-        # The HTML version of every tag that we accept.
-        # --------------------------------------------------------------------
-
-        Tags = {
-          "css" => %(<link type="text/css" rel="stylesheet" href="%s"%s>),
-          "js"  => %(<script type="text/javascript" src="%s"%s></script>),
-          "img" => %(<img src="%s"%s>)
-        }.freeze
-
-        # --------------------------------------------------------------------
-        # Allows us to normalize tags so we can simplify logic.
-        # --------------------------------------------------------------------
-
-        Alias = {
-          "image" => "img",
-          "stylesheet" => "css",
-          "javascript" => "js",
-          "style" => "css"
-        }.freeze
-
-        # --------------------------------------------------------------------
-
-        def initialize(tag, args, tokens)
-          tag = tag.to_s
-          @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[:site]
-          page = context.registers.fetch(:page, {})
-          args = @args.parse_liquid(context)
-          sprockets = site.sprockets
-          page = page["path"]
-
-          asset = find_asset(args, sprockets)
-          add_as_jekyll_dependency(site, sprockets, page, asset)
-          process_tag(args, sprockets, asset)
-
-        rescue => e
-          capture_and_out_error(
-            site, e
-          )
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def from_alias(tag)
-          Alias.key?(tag) ? Alias[tag] : tag
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def process_tag(args, sprockets, asset)
-          sprockets.manifest.add(asset) unless @tag == "asset_source"
-          Defaults.set_defaults_for!(@tag, args ||= {}, asset, sprockets)
-          build_html(args, sprockets, asset)
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def build_html(args, sprockets, asset, path = get_path(sprockets, asset))
-          return path if @tag == "asset_path"
-          return asset.to_s if @tag == "asset" || @tag == "asset_source"
-          data = args.key?(:data) && args[:data].key?(:uri) ? asset.data_uri : path
-          format(Tags[@tag], data, args.to_html)
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def get_path(sprockets, asset)
-          sprockets.prefix_path(
-            sprockets.digest?? asset.digest_path : asset.logical_path
-          )
-        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(args, sprockets)
-          out = _find_asset(args[:file],
-            args[:sprockets] ||= {}, sprockets
-          )
-
-          if !out
-            raise(
-              AssetNotFoundError, args[
-                :file
-              ]
-            )
-
-          else
-            out.liquid_tags << self
-            !args.proxies?? out : ProxiedAsset.new(
-              out, args, sprockets, self
-            )
-          end
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def _find_asset(file, args, sprockets)
-          if args.empty? then sprockets.manifest.find(file).first
-          elsif args.size == 1 && args.key?(:accept)
-            if File.extname(file) == ""
-              file = file + _ext_for(args[
-                :accept
-              ])
-            end
-
-            sprockets.manifest.find(file).find do |asset|
-              asset.content_type == args[
-                :accept
-              ]
-            end
-          else
-            sprockets.find_asset(
-              file, args
-            )
-          end
-        end
-
-        # --------------------------------------------------------------------
-
-        private
-        def _ext_for(type)
-          out = Sprockets.mime_exts.select do |k, v|
-            v == type
-          end
-
-          out.keys \
-            .first
-        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(%(Error in #{file}:#{error.sass_line} #{
-              error
-            }))
-
-          else
-            Jekyll.logger.error(
-              "", error.to_s
-            )
-          end
-
-          raise error
-        end
-      end
-    end
-  end
-end
-
-# ----------------------------------------------------------------------------
-
-Jekyll::Assets::Liquid::Tag::AcceptableTags.each do |tag|
-  Liquid::Template.register_tag tag, Jekyll::Assets::Liquid::Tag
-end

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

@@ -1,27 +0,0 @@
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag
-        module Defaults
-          require_relative "defaults/image"
-          require_relative "defaults/sha"
-
-          # --
-          # TODO: In 3.0 env needs to be enforced, right now it's not
-          #   because it's maintain 2.0 API.
-          # --
-          module_function
-          def set_defaults_for!(tag, args, asset, env = nil)
-            constants.select { |const| const_get(const).for?(tag) }.each do |const|
-              const_get(const).new(args, asset, env).set!
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag
-        module Defaults
-          class Image
-            def self.for?(tag)
-              tag == "img" || tag == "image"
-            end
-
-            # ----------------------------------------------------------------
-            # TODO: In 3.0 env needs to be enforced if this is not changed,
-            #   for now it's not enforced to maintain the 2.0 API.
-            # ----------------------------------------------------------------
-
-            def initialize(args, asset, env = nil)
-              @args = args
-              @asset = asset
-              @env = env
-            end
-
-            # ----------------------------------------------------------------
-
-            def set!
-              set_img_dimensions
-              set_img_alt
-            end
-
-            # ----------------------------------------------------------------
-            # TODO: 3.0 - Remove the `!@env`
-            # ----------------------------------------------------------------
-
-            private
-            def set_img_alt
-              if !@env || @env.asset_config["features"]["automatic_img_alt"]
-                @args[:html] ||= {}
-                unless @args[:html].key?("alt")
-                  @args[:html]["alt"] = @asset.logical_path
-                end
-              end
-            end
-
-            # ----------------------------------------------------------------
-            # TODO: 3.0 - Remove the `!@env`
-            # ----------------------------------------------------------------
-
-            private
-            def set_img_dimensions
-              resize_image = @env.asset_config["features"]["automatic_img_size"]
-
-              if !@env || resize_image
-                dimensions = FastImage.size(@asset.filename.to_s)
-                return unless dimensions
-                @args[:html] ||= {}
-
-                if resize_image =~ /^\d+$/
-                  width  = (dimensions.first / resize_image.to_f).floor
-                  height = (dimensions. last / resize_image.to_f).floor
-
-                else
-                  width  = dimensions.first
-                  height = dimensions. last
-                end
-
-
-                @args[:html][ "width"] ||= width
-                @args[:html]["height"] ||= height
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag
-        module Defaults
-          class Sha
-
-            # --
-            # What we plan to accept for.
-            # --
-            def self.for?(tag)
-              return tag == "css" || tag == "js"
-            end
-
-            # --
-            # Initialize a new instance.
-            # --
-            def initialize(args, asset, env)
-              @args = args
-              @asset = asset
-              @env = env
-            end
-
-            # --
-            # Run the defaults.
-            # --
-            def set!
-              set_integrity
-            end
-
-            # --
-            # Set the integrity attribute.
-            # @return [nil]
-            # --
-            def set_integrity
-              digest = Sprockets::DigestUtils.integrity_uri(
-                Digest::SHA384.digest(
-                  @asset.to_s
-                )
-              )
-
-              @args.args[:html] ||= {}
-              if @env.asset_config["features"]["integrity"]
-                @args.args[:html]["integrity"] = digest
-                @args.args[:html]["crossorigin"] = "anonymous" \
-                  unless @args.args[:html]["crossorigin"]
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,202 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-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, :each
-          def_delegator :@args, :key?
-          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
-              super "Unescaped double colon argument."
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          class UnknownProxyError < StandardError
-            def initialize
-              super "Unknown proxy argument."
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          def initialize(args, tag, processed: false, raw_args: nil)
-            if processed && raw_args
-              @args = args
-              @raw_args = raw_args
-              @tag = tag
-
-            elsif processed && !raw_args
-              raise ArgumentError, "You must provide raw_args if you pre-process." \
-                "Please provide the raw args."
-
-            else
-              @tag = tag
-              @raw_args = args
-              parse_raw
-              set_accept
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          def parse_liquid(context)
-            return self unless context.is_a?(Object::Liquid::Context)
-            liquid = context.registers[:site].liquid_renderer.file("(jekyll:assets)")
-            out = parse_hash_liquid(to_h, liquid, context)
-            self.class.new(out, @tag, {
-              :raw_args => @raw_args,
-              :processed => true
-            })
-          end
-
-          # ------------------------------------------------------------------
-
-          def to_html
-            (self[:html] || {}).map do |key, val|
-              val == true || val == "true" ? " #{key}" : %( #{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 proxies?
-            proxies.any?
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def parse_hash_liquid(hash_, liquid, context)
-            hash_.each_with_object({}) do |(key, val), hash|
-              val = liquid.parse(val).render(context) if val.is_a?(String)
-              val = parse_hash_liquid(val, liquid, context) if val.is_a?(Hash)
-              hash[key] = val
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def parse_raw
-            @args = from_shellwords.each_with_index.each_with_object({}) do |(key, index), hash|
-              if index == 0 then hash.store(:file, key)
-              elsif key =~ /:/ && (key = key.split(/(?<!\\):/))
-                parse_col hash, key
-
-              else
-                (hash[:html] ||= {})[key] = true
-              end
-
-              hash
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def parse_col(hash, key)
-            key.push(key.delete_at(-1).gsub(/\\:/, ":"))
-            return as_proxy hash, key if key.size == 3
-            return as_bool_or_html hash, key if key.size == 2 || key.size == 1
-            raise UnescapedColonError
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def as_bool_or_html(hash, key)
-            okey = key
-            key, sub_key = key
-            if Proxies.has?(key, @tag, "@#{sub_key}")
-              (hash[key.to_sym] ||= {})[sub_key.to_sym] = true
-            else
-              (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[key.to_sym] ||= {})[sub_key.to_sym] = \
-                val
-
-            elsif Proxies.has?(key)
-              raise UnknownProxyError
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def set_accept
-            if ACCEPT.key?(@tag) && (!@args.key?(:sprockets) || \
-                  !@args[:sprockets].key?(:accept))
-
-              (@args[:sprockets] ||= {})[:accept] = \
-                ACCEPT[@tag]
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def from_shellwords
-            Shellwords.shellwords(@raw_args)
-          end
-        end
-      end
-    end
-  end
-end