jekyll-assets 2.4.0 → 3.0.0

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

@@ -1,166 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-require "forwardable"
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag
-        class ProxiedAsset
-          attr_reader :args, :asset, :env
-          extend Forwardable
-
-          # ------------------------------------------------------------------
-
-          attr_reader :content_type
-
-          def_delegator :@asset, :liquid_tags
-          def_delegator :@asset, :source_filename
-          def_delegator :@asset, :mtime
-
-          # ------------------------------------------------------------------
-
-          def initialize(asset, args, env, tag)
-            @env = env
-            @asset = asset.dup
-            @args = args
-            @tag = tag
-            @path = Pathutil.new(asset.logical_path)
-            @content_type = asset.content_type
-
-            cache_file
-            proxy_file
-          end
-
-          # ------------------------------------------------------------------
-
-          def integrity
-            Sprockets::DigestUtils.integrity_uri(
-              digest
-            )
-          end
-
-          # ------------------------------------------------------------------
-
-          def cached?
-            @_cached
-          end
-
-          # ------------------------------------------------------------------
-
-          def write_to(name)
-            FileUtils.mkdir_p File.dirname(name)
-            Sprockets::PathUtils.atomic_write(name) do |f|
-              f.write source
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          def source
-            filename.binread
-          end
-
-          # ------------------------------------------------------------------
-
-          def filename
-            Pathutil.new(
-              env.in_cache_dir(digest_path)
-            )
-          end
-
-          # ------------------------------------------------------------------
-
-          def digest
-            Digest::SHA2.hexdigest(
-              args.proxies.to_s
-            )
-          end
-
-          # ------------------------------------------------------------------
-
-          def content_type=(type)
-            return if @content_type == type
-
-            @path = @path.sub_ext(_ext_for(type))
-            @content_type = type
-          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
-            "#{@path.sub_ext ""}-#{digest}#{@path.extname}"
-          end
-
-          # --------------------------------------------------------------------
-
-          private
-          def _mime_for(ext)
-            Sprockets.mime_exts[
-              ext
-            ]
-          end
-
-          # --------------------------------------------------------------------
-
-          private
-          def _ext_for(type)
-            Sprockets.mime_types[type][:extensions].first
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def proxy_file
-            unless cached?
-              args.proxies.each do |key, val|
-                old_type = content_type
-                old_filename = filename
-                Proxies.get(key).first[:class].new(self, val, @args).process
-                old_filename.rm if old_type != content_type
-              end
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def find_cached
-            glob = filename.dirname.glob(filename.basename.sub_ext('.*'))
-            @_cached = filename.dirname.directory? && !glob.first.nil?
-            if @_cached
-              self.content_type = _mime_for(File.extname(glob.first))
-            end
-
-            @_cached
-          end
-
-          # ------------------------------------------------------------------
-
-          private
-          def cache_file
-            return true if @_cached || find_cached
-
-            filename.dirname.mkdir_p
-            Pathutil.new(asset.filename).cp filename
-            true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-module Jekyll
-  module Assets
-    module Liquid
-      class Tag
-        module Proxies
-          def self.add_by_class(class_, name, tag, *args)
-            proc_ = proc { |v| [v.to_s, v, v.to_sym] }
-            all << {
-              :name => proc_.call(name).uniq,
-              :args => [args].flatten.map(&proc_).flatten.uniq,
-              :tags => [ tag].flatten.map(&proc_).flatten.uniq,
-              :class  => class_
-            }
-
-            all
-          end
-
-          # ------------------------------------------------------------------
-
-          def self.add(name, tag, *args, &block)
-            if tag.is_a?(Array)
-              return tag.each do |v|
-                klass = generate_class(name, v, &block)
-                add_by_class(*klass,
-                  *args
-                )
-              end
-            end
-
-            klass = generate_class(name, tag, &block)
-            add_by_class(*klass,
-              *args
-            )
-          end
-
-          # ------------------------------------------------------------------
-
-          def self.keys
-            all.select { |val| !val[:class].is_a?(Symbol) }.map do |val|
-              val[:name]
-            end.flatten
-          end
-
-          # ------------------------------------------------------------------
-
-          def self.base_keys
-            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 then 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[:name].include?(name)
-              end
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          def self.get_by_name_and_tag_and_arg(name, tag, arg)
-            all.select do |val|
-              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[:name].include?(name) && (val[:tags].include?(:all) || val[:tags] \
-                .include?(tag))
-            end
-          end
-
-          # ------------------------------------------------------------------
-
-          def self.all
-            @_all ||= Set.new
-          end
-
-          # ------------------------------------------------------------------
-
-          private_class_method
-          def self.generate_class(name, tag, &block)
-            class_ = const_set(random_name, Class.new)
-            class_.class_eval(&block)
-            return class_, name, tag
-          end
-
-          # ------------------------------------------------------------------
-
-          private_class_method
-          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, %W(
-            accept write_to
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module JekyllAssetsPatchesJekyllCleaner
-  def obsolete_files
-    super.delete_if do |v|
-      v.start_with?(site.in_dest_dir(
-        site.sprockets.prefix_path
-      ))
-    end
-  end
-end
-
-module Jekyll
-  class Cleaner
-    prepend JekyllAssetsPatchesJekyllCleaner
-  end
-end

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

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

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

@@ -1,29 +0,0 @@
-# ----------------------------------------------------------------------------
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-# ----------------------------------------------------------------------------
-
-module Kernel
-  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

data/lib/jekyll/assets/patches/sprockets/asset.rb

@@ -1,28 +0,0 @@
-# Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
-# Encoding: utf-8
-
-module Sprockets
-  class Asset
-
-    # --
-    # List all the liquid tags this asset used.
-    # --
-    def liquid_tags
-      metadata[:liquid_tags] ||= begin
-        Set.new
-      end
-    end
-
-
-    # --
-    # Pull out the data uri.
-    # @return [String]
-    # --
-    def data_uri
-      "data:#{content_type};base64,#{Rack::Utils.escape(
-        Base64.encode64(to_s)
-      )}"
-    end
-  end
-end

data/lib/jekyll/assets/processors/less.rb

@@ -1,70 +0,0 @@
-try_require_if_javascript "less" do
-  module Jekyll
-    module Assets
-      module Processors
-        class LESS
-
-          # --------------------------------------------------------------------
-          # Setup and pull out the context and update the data, shipping it.
-          # --------------------------------------------------------------------
-
-          def self.call(input)
-            data = input[:data]; paths = [input[:load_path]]
-            tree = Less.instance_variable_get(:@loader).require("less/tree")
-            context = input[:environment].context_class.new(input)
-            patch_tree(tree, context)
-
-            paths |= input[:environment].paths
-            paths |= Dir.glob(input[:load_path] + '/*').select(&File.method(:directory?))
-            parser = Less::Parser.new(:paths => paths)
-
-            context.metadata.merge({
-              :data => Less::Parser.new(:paths => paths) \
-                .parse(data).to_css
-            })
-          end
-
-          # --------------------------------------------------------------------
-          # Add the sprockets helpers into the Less environment so people can
-          # use assets from within Less... as they see fit.
-          # --------------------------------------------------------------------
-          # We also make sure to disable their quotes so that we can quote
-          # ourselves if we need to, otherwise we simply just take the values.
-          # --------------------------------------------------------------------
-
-          def self.patch_tree(tree, context)
-            Helpers.instance_methods.each do |m|
-              tree.functions[m.to_s.tr("_", "-")] = tree.functions[m.to_s] = lambda do |*args|
-                args.last.tap do |o|
-                  o[:quote] = ""
-                  o[:value] = context.send(m, args.last.toCSS().gsub(
-                    /^"|"$/, ""
-                  ))
-
-                  if m.to_s.end_with?("_path")
-                    o[:value] = o[:value].inspect
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  # ----------------------------------------------------------------------------
-
-  if Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new(4.0)
-    Sprockets.register_mime_type "text/less", :extensions => [".less", ".css.less"]
-    Sprockets.register_transformer("text/less", "test/css",
-      Jekyll::Assets::Processors::LESS
-    )
-  else
-    Sprockets.register_engine(
-      ".less", Jekyll::Assets::Processors::LESS, {
-        :silence_deprecation => true
-      }
-    )
-  end
-end