jekyll-assets 2.4.0 → 3.0.0

data/lib/jekyll/assets/plugins/magick.rb

@@ -0,0 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+Jekyll::Assets::Utils.try_require "mini_magick" do
+  require_relative "proxy/magick"
+end

data/lib/jekyll/assets/plugins/optim.rb

@@ -0,0 +1,7 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+Jekyll::Assets::Utils.try_require "image_optim" do
+  require_relative "proxy/optim"
+end

data/lib/jekyll/assets/plugins/prefixer.rb

@@ -0,0 +1,28 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "jekyll/assets"
+
+Jekyll::Assets::Utils.javascript? do
+  Jekyll::Assets::Utils.try_require "autoprefixer-rails" do
+    Jekyll::Assets::Hook.register :config, :before_merge do |c|
+      c.deep_merge!({
+        plugins: {
+          css: {
+            autoprefixer: {
+              # Your config here.
+            },
+          },
+        },
+      })
+    end
+
+    Jekyll::Assets::Hook.register :env, :after_init do
+      config = asset_config[:plugins][:css][:autoprefixer]
+      AutoprefixerRails.install(self, jekyll.safe ? config : {
+        # Your configuration here.
+      })
+    end
+  end
+end

data/lib/jekyll/assets/plugins/proxy/magick.rb

@@ -0,0 +1,131 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "jekyll/assets"
+
+module Jekyll
+  module Assets
+    module Plugins
+      class MiniMagick < Proxy
+        arg_keys :magick
+        content_types "image/webp"
+        content_types "image/jpeg"
+        content_types "image/svg+xml"
+        content_types "image/tiff"
+        content_types "image/bmp"
+        content_types "image/gif"
+        content_types "image/png"
+
+        class SameType < StandardError
+          def initialize(type)
+            "Trying to convert #{type} to #{type} won't work."
+          end
+        end
+
+        def process
+          img = ::MiniMagick::Image.open(@file)
+          magick_format(img) if @args[:magick][:format]
+          img.combine_options do |c|
+            runners.each do |m|
+              method(m).arity == 2 ? send(m, img, c) : send(m, c)
+            end
+          end
+
+          img.write(@file)
+          @file
+        ensure
+          img&.destroy!
+        end
+
+        def runners
+          private_methods(true).select do |v|
+            v =~ %r!^magick_! && v != :magick_format
+          end
+        end
+
+        private
+        def magick_format(img)
+          exts = @env.mime_exts.select do |k, v|
+            k == @args[:magick][:format] || v == @args[:magick][:format]
+          end
+
+          if exts.first
+            ext, type = exts.first
+            new_ = @file.sub_ext(ext)
+            raise SameType, type if type == asset.content_type
+            img.format(ext.sub(".", ""))
+            @file.cp(new_)
+            @file.rm
+            @file =
+              new_
+          end
+
+          img.write(@file)
+        end
+
+        private
+        def magick_compress(cmd)
+          if @args[:magick].key?(:compress)
+            cmd.compress @args[:magick][:compress]
+          end
+        end
+
+        private
+        def magick_quality(cmd)
+          if @args[:magick].key?(:quality)
+            cmd.quality @args[:magick][:quality]
+          end
+        end
+
+        private
+        def magick_resize(cmd)
+          if @args[:magick].key?(:resize)
+            cmd.resize @args[:magick][:resize]
+          end
+        end
+
+        private
+        def magick_rotate(cmd)
+          if @args[:magick].key?(:rotate)
+            cmd.rotate @args[:magick][:rotate]
+          end
+        end
+
+        private
+        def magick_flip(cmd)
+          if @args[:magick].key?(:flip)
+            cmd.flip @args[:magick][:flip]
+          end
+        end
+
+        private
+        def magick_crop(cmd)
+          if @args[:magick].key?(:crop)
+            cmd.crop @args[:magick][:crop]
+          end
+        end
+
+        private
+        def magick_gravity(cmd)
+          if @args[:magick].key?(:gravity)
+            cmd.gravity @args[:magick][:gravity]
+          end
+        end
+
+        private
+        def magick_strip(cmd)
+          cmd.strip
+        end
+
+        private
+        def magick_preset_resize(img, cmd)
+          # rubocop:disable Metrics/LineLength
+          width, height = img.width * 2, img.height * 2 if @args[:magick].key?(:double)
+          width, height = img.width / 2, img.height / 2 if @args[:magick].key?(:half)
+          cmd.resize "#{width}x#{height}" if width && height
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/assets/plugins/proxy/optim.rb

@@ -0,0 +1,64 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "jekyll/assets"
+
+module Jekyll
+  module Assets
+    module Plugins
+      class ImageOptim < Proxy
+        arg_keys :optim
+        content_types "image/webp"
+        content_types "image/jpeg"
+        content_types "image/svg+xml"
+        content_types "image/tiff"
+        content_types "image/bmp"
+        content_types "image/gif"
+        content_types "image/png"
+
+        class UnknownPresetError < RuntimeError
+          def initialize(name)
+            "Unknown image_optim preset `#{name}'"
+          end
+        end
+
+        class MultiplePredefinedPresetsSpecified < RuntimeError
+          def initialize
+            super "Specifying multiple pre-defined presets " \
+              "at the same time is not supported"
+          end
+        end
+
+        def process
+          optimc = @env.asset_config[:plugins][:img][:optim]
+          preset = @args[:optim].keys
+          if preset.count > 1
+            raise MultiplePredefinedPresetsSpecified
+          end
+
+          preset = preset.first
+          # rubocop:disable Metrics/LineLength
+          raise UnknownPreset, preset if preset != :default && !optimc.key?(preset)
+          oc = optimc[preset] unless preset == :default
+          optim = ::ImageOptim.new(oc || {})
+          optim.optimize_image!(@file)
+          @file
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/LineLength
+Jekyll::Assets::Hook.register :config, :before_merge do |c|
+  c.deep_merge!({
+    plugins: {
+      img: {
+        optim: {
+          # Your config here.
+        },
+      },
+    },
+  })
+end

data/lib/jekyll/assets/plugins/searcher.rb

@@ -0,0 +1,72 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "pathutil"
+require_relative "../utils"
+require "jekyll/assets"
+require "jekyll"
+
+module Jekyll
+  module Assets
+    module Plugins
+      # --
+      # Searches for `<img>` that have `<img asset>` or
+      # `<img asset="args">` and runs them through the asset
+      # system.  This allows you to use real assets inside
+      # of your Markdown pre-convert.
+      # --
+      class Searcher
+        def initialize(doc)
+          @doc = doc
+        end
+
+        # --
+        def run
+          html.search("img[@asset]").each do |v|
+            raise ArgumentError, "src is empty" unless v[:src]
+            args = "#{v.delete('src')&.value} #{v.delete('asset')&.value}"
+            pctx = ::Liquid::ParseContext.new
+
+            attrs = v.attributes.keys
+            args, = Tag.new("asset", args, pctx).render_raw(ctx)
+            args.to_h(html: true).each do |k, vv|
+              unless attrs.include?(k.to_s)
+                v.set_attribute(k, vv)
+              end
+            end
+          end
+
+          out = html.to_html
+          @doc.output = out
+        end
+
+        # --
+        private
+        def ctx
+          ::Liquid::Context.new({}, {}, {
+            site: @doc.site,
+          })
+        end
+
+        # --
+        private
+        def html
+          @html ||= begin
+            out = @doc.output
+            # @see https://github.com/sparklemotion/nokogiri/issues/553
+            good, buggy = Encoding::UTF_8, Encoding::ASCII_8BIT
+            out = out.encode good if out.encoding == buggy
+            Nokogiri::HTML.send((@doc.output.strip
+              .start_with?("<!DOCTYPE ") ? :parse :
+                :fragment), out)
+          end
+        end
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register [:pages, :documents, :posts], :post_render do |d|
+  Jekyll::Assets::Plugins::Searcher.new(d).run
+end

data/lib/jekyll/assets/proxy.rb

@@ -0,0 +1,109 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "pathutil"
+require_relative "extensible"
+require_relative "hook"
+require "digest"
+
+module Jekyll
+  module Assets
+    class Proxy < Extensible
+      attr_reader :file
+      DIG = Digest::SHA256
+      DIR = "proxied"
+
+      class Deleted < StandardError
+        def initialize(obj)
+          super "#{obj} violated a contract and " \
+            "deleted your proxy file"
+        end
+      end
+
+      # --
+      # @param [Hash] args the args.
+      # @param [Sprockets::Asset] asset the asset.
+      # @param [String] type the assets content_type
+      # @param [Env] env the environment.
+      # Run all your proxies on assets.
+      # @return [Sprockets::Asset]
+      # --
+      def self.proxy(asset, args:, ctx:)
+        proxies = Proxy.inherited.select do |o|
+          o.for?(type: asset.content_type, args: args)
+        end
+
+        return asset if proxies.empty?
+        env = ctx.registers[:site].sprockets
+        file = copy(asset, args: args, ctx: ctx)
+        cache = file.basename.sub_ext("").to_s
+
+        env.cache.fetch(cache) do
+          proxies.each do |o|
+            obj = o.new(file, {
+              args: args,
+              asset: asset,
+              ctx: ctx,
+            })
+
+            o = obj.process
+            file = o if o.is_a?(Pathutil) && file != o
+            raise Deleted, o unless file.exist?
+          end
+
+          true
+        end
+
+        env.find_asset!(file)
+      end
+
+      # --
+      # Copy the asset to the proxied directory.
+      # @note this is done so we do not directly alter.
+      # @param [Sprockets::Asset] asset the current asset.
+      # @param [Env] env the environment.
+      # @param [Hash] args the args.
+      # @return [Pathutil]
+      # --
+      def self.copy(asset, ctx:, args:)
+        env = ctx.registers[:site].sprockets
+        raw = args.instance_variable_get(:@raw)
+        key = DIG.hexdigest(raw)[0, 6]
+
+        path = env.in_cache_dir(DIR)
+        extname = File.extname(args[:argv1])
+        out = Pathutil.new(path).join(key).sub_ext(extname)
+        out.dirname.mkdir_p unless out.dirname.exist?
+        Pathutil.new(asset.filename).cp(out)
+
+        out
+      end
+
+      # --
+      # @return [Symbol] the argument key.
+      # Allows you to tell the proxier which args are yours.
+      # @note we will not run your proxy if the argkey doen't match.
+      # @param [Symbol] key the key.
+      # --
+      def self.args_key(key = nil)
+        unless key.nil?
+          @key =
+            key
+        end
+
+        @key
+      end
+
+      # --
+      def initialize(file, **kwd)
+        super(**kwd)
+        @file = file
+      end
+    end
+  end
+end
+
+Jekyll::Assets::Hook.register :env, :after_init do
+  append_path(in_cache_dir(Jekyll::Assets::Proxy::DIR))
+end

data/lib/jekyll/assets/tag.rb

@@ -0,0 +1,176 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require "fastimage"
+require_relative "html"
+require "liquid/tag/parser"
+require "active_support/hash_with_indifferent_access"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/deep_merge"
+require_relative "default"
+require_relative "proxy"
+require "nokogiri"
+
+module Jekyll
+  module Assets
+    class Tag < Liquid::Tag
+      class << self
+        public :new
+      end
+
+      # --
+      class MixedArg < StandardError
+        def initialize(arg, mixed)
+          super "cannot use #{arg} w/ #{mixed}"
+        end
+      end
+
+      # --
+      class InvalidExternal < StandardError
+        def initialize(arg)
+          super "cannot use `#{arg}' with external url's"
+        end
+      end
+
+      # --
+      attr_reader :name
+      attr_reader :tokens
+      attr_reader :args
+      attr_reader :tag
+
+      # --
+      def initialize(tag, args, tokens)
+        @tag = tag.to_sym
+        @args = Liquid::Tag::Parser.new(args)
+        @tokens = tokens
+        @og_args = args
+        super
+      end
+
+      # --
+      def render_raw(ctx)
+        env  = ctx.registers[:site].sprockets
+        args = env.parse_liquid(@args, ctx: ctx)
+        raise Sprockets::FileNotFound, "UNKNOWN" unless args.key?(:argv1)
+        asset = external(ctx, args: args) if env.external?(args)
+        asset ||= internal(ctx)
+        [args, asset]
+      end
+
+      # --
+      # @return [String]
+      # rubocop:disable Metrics/AbcSize
+      # Render the tag, run the proxies, set the defaults.
+      # @note Defaults are ran twice just incase the content type
+      #   changes, at that point there might be something that
+      #   has to change in the new content.
+      # --
+      def render(ctx)
+        env = ctx.registers[:site].sprockets
+
+        args, asset = render_raw(ctx)
+        env.logger.debug args&.to_h(html: false).inspect
+        return_or_build(ctx, args: args, asset: asset) do
+          HTML.build({
+            args: args,
+            asset: asset,
+            ctx: ctx,
+          })
+        end
+      # --
+      rescue ExecJS::RuntimeError => e
+        env.logger.error e.message
+        env.logger.efile @args[:argv1]
+        raise ExecJS::RuntimeError, \
+          "JS Error"
+      # --
+      # @note you can --trace to get this same info
+      # Handle errors that Sass ships because Jekyll finds
+      # error handling hard, and makes it even harder, so we
+      # need to ship debug info to the user, or they'll
+      # never get it. That's not very good.
+      # --
+      rescue Sass::SyntaxError => e
+        env.logger.error e.message
+        env.logger.efile env.strip_paths(e.backtrace.first)
+        raise Sass::SyntaxError, "Sass Error"
+      end
+
+      # --
+      def return_or_build(ctx, args:, asset:)
+        methods.grep(%r!^on_(?\!or_build$)!).each do |m|
+          out = send(m, args, ctx: ctx, asset: asset)
+          if out
+            return out
+          end
+        end
+
+        yield
+      end
+
+      # --
+      # Returns the path to the asset.
+      # @example {% asset img.png @path %}
+      # @return [String]
+      # --
+      def on_path(args, ctx:, asset:)
+        env = ctx.registers[:site].sprockets
+
+        return unless args[:path]
+        raise InvalidExternal, "@path" if env.external?(args)
+        env.prefix_url(asset.digest_path)
+      end
+
+      # --
+      # Returns the data uri of an object.
+      # @example {% asset img.png @data-url %}
+      # @example {% asset img.png @data_uri %}
+      # @return [String]
+      # --
+      def on_data(args, ctx:, asset:)
+        env = ctx.registers[:site].sprockets
+
+        return unless args[:data]
+        raise InvalidExternal "@data" if env.external?(args)
+        asset.data_uri
+      end
+
+      # --
+      # @param [Liquid::Context] ctx
+      # Set's up an external url using `Url`
+      # @return [Url]
+      # --
+      def external(ctx, args:)
+        env = ctx.registers[:site].sprockets
+        out = env.external_asset(args[:argv1], args: args)
+        Default.set(args, ctx: ctx, asset: out)
+
+        out
+      end
+
+      # --
+      # @param [Liquid::Context] ctx
+      # Set's up an internal asset using `Sprockets::Asset`
+      # @return [Sprockets::Asset]
+      # --
+      def internal(ctx)
+        env = ctx.registers[:site].sprockets
+        original = env.find_asset!(args[:argv1])
+        Default.set(args, ctx: ctx, asset: original)
+        out = Proxy.proxy(original, args: args, ctx: ctx)
+        env.manifest.compile(out.logical_path)
+
+        Default.set(args, {
+          ctx: ctx, asset: out
+        })
+
+        out
+      end
+    end
+  end
+end
+
+# --
+
+Liquid::Template.register_tag "asset", Jekyll::Assets::Tag