module Jekyll::Assets::Utils

Public Class Methods

activate(gem) { || ... } click to toggle source

# File lib/jekyll/assets/utils.rb, line 25
def self.activate(gem)
  spec = Gem::Specification
  return unless spec.find_all_by_name(gem)&.any? || \
      spec.find_by_path(gem)&.any?

  require gem
  if block_given?
    yield
  end

  true
end
html(*a) click to toggle source

# File lib/jekyll/assets/utils.rb, line 47
def self.html(*a)
  Nokogiri::HTML.parse(*a) do |c|
    c.options = Nokogiri::XML::ParseOptions::NONET | \
      Nokogiri::XML::ParseOptions::NOENT
  end
end
html_fragment(*a) click to toggle source

# File lib/jekyll/assets/utils.rb, line 39
def self.html_fragment(*a)
  Nokogiri::HTML.fragment(*a) do |c|
    c.options = Nokogiri::XML::ParseOptions::NONET | \
      Nokogiri::XML::ParseOptions::NOENT
  end
end
javascript?() { || ... } click to toggle source

– @yield a blockof code if the require works out. Either require exec.js, and the file or move along. @param [String] file the file to require. @return [nil] –

# File lib/jekyll/assets/utils.rb, line 333
def self.javascript?
  activate "execjs" do
    if block_given?
      yield
    end
  end
rescue ExecJS::RuntimeUnavailable
  false
end
new_uglifier?() click to toggle source

# File lib/jekyll/assets/utils.rb, line 15
def self.new_uglifier?
  require "uglifier"
  modern_supported_version = "4.0.0"
  Gem::Version.new(Uglifier::VERSION) >= Gem::Version
    .new(modern_supported_version)
rescue LoadError
  return true
end
old_sprockets?() click to toggle source
# File lib/jekyll/assets/utils.rb, line 8
def self.old_sprockets?
  @old_sprockets ||= begin
    Gem::Version.new(Sprockets::VERSION) < Gem::Version.new("4.0.beta")
  end
end
xml(*a) click to toggle source

# File lib/jekyll/assets/utils.rb, line 55
def self.xml(*a)
  Nokogiri::XML.parse(*a) do |c|
    c.options = Nokogiri::XML::ParseOptions::NONET
  end
end

Public Instance Methods

external?(args) click to toggle source

– @param [String,Sprockets::Asset] url Tells you if a url… or asset is external. @return [nil,true,false] –

# File lib/jekyll/assets/utils.rb, line 156
def external?(args)
  return true  if args.is_a?(Url)
  return false if args.is_a?(Sprockets::Asset)
  return args =~ %r!^(https?:)?//! if args.is_a?(String)
  return args[:external] if args.key?(:external)
  args[:argv1] !~ %r!^(?\!(https?:)?//)!
end
external_asset(url, args:) click to toggle source

– @param [String] url @return [Sprockets::Asset] Wraps around an external url and so it can be wrapped into

the rest of Jekyll-Assets with little trouble.

# File lib/jekyll/assets/utils.rb, line 136
def external_asset(url, args:)
  if args[:asset]&.key?(:type)
    url_asset(url, {
      type: args[:asset][:type],
    })

  else
    _, type = Sprockets.match_path_extname(url, Sprockets.mime_exts)
    logger.debug "no type for #{url}, assuming image/*" unless type
    url_asset(url, {
      type: type || "image/jpeg",
    })
  end
end
find_assets_by_glob(glob) click to toggle source

# File lib/jekyll/assets/utils.rb, line 92
def find_assets_by_glob(glob)
  glob_paths(glob).map do |v|
    find_asset!(v.to_s)
  end
end
glob_paths(glob) click to toggle source

# File lib/jekyll/assets/utils.rb, line 99
def glob_paths(glob)
  out = []

  paths.each do |sv|
    sv = Pathutil.new(sv)

    if sv.directory?
      out.concat(sv.glob(glob).to_a)
    end
  end

  out
end
in_cache_dir(*paths) click to toggle source

– Lands your path inside of the cache directory. @note configurable with `caching: { path: “dir_name”` } @return [String] –

# File lib/jekyll/assets/utils.rb, line 214
def in_cache_dir(*paths)
  path = Pathutil.pwd.join(strip_slashes(asset_config[:caching][:path]))
  Pathutil.new(paths.reduce(path.to_s) do |b, p|
    Jekyll.sanitized_path(b, p)
  end)
end
in_dest_dir(*paths) click to toggle source

– @note this is configurable with `:destination` Lands your path inside of the destination directory. @param [Array<String>] paths the paths. @return [String] –

# File lib/jekyll/assets/utils.rb, line 227
def in_dest_dir(*paths)
  destination = strip_slashes(asset_config[:destination])

  paths.unshift(destination)
  paths = paths.flatten.compact
  Pathutil.new(jekyll
    .in_dest_dir(*paths))
end
make_https(url) click to toggle source

– @param [String] url the url. Make a url a proper url, and an https url. @return [String] –

# File lib/jekyll/assets/utils.rb, line 294
def make_https(url)
  return if url.nil? || url == ""
  url.gsub(%r!(https?:)?//!,
    "https://")
end
manifest_files(env) click to toggle source

– Get all the manifest files. @note this includes dynamic keys, like SourceMaps. rubocop:disable Metrics/AbcSize @return [Array<String>] –

# File lib/jekyll/assets/utils.rb, line 307
def manifest_files(env)
  manifest = env.manifest.data.values_at(*Manifest.keep_keys).map(&:to_a)
  out = manifest.flatten.each_with_object([]) do |v, a|
    path = Pathutil.new(env.in_dest_dir(v))
    a << path.to_s + ".gz" if path.exist? && !env.skip_gzip?
    a << path.to_s if path.exist?
    v = Pathutil.new(v)

    next if v.dirname == "."
    v.dirname.descend.each do |vv|
      vv = env.in_dest_dir(vv)
      unless a.include?(vv)
        a << vv
      end
    end
  end

  out
end
parse_liquid(obj, ctx:) click to toggle source

– @param [String,Hash<>,Array<>] obj the liquid to parse. Parses the Liquid that's being passed, with Jekyll's context. rubocop:disable Lint/LiteralAsCondition @return [String] –

# File lib/jekyll/assets/utils.rb, line 170
def parse_liquid(obj, ctx:)
  case true
  when obj.is_a?(Hash) || obj.is_a?(Liquid::Tag::Parser)
    obj.each_key.with_object(obj) do |k, o|
      o[k] = parse_liquid(o[k], {
        ctx: ctx,
      })
    end
  when obj.is_a?(Array)
    obj.map do |v|
      parse_liquid(v, {
        ctx: ctx,
      })
    end
  when obj.is_a?(String)
    k = Digest::SHA256.hexdigest(obj)[0, 6]
    ctx.registers[:site].liquid_renderer.file("(asset:var:#{k})")
      .parse(obj).render!(ctx)
  else
    obj
  end
end
prefix_url(user_path = nil) click to toggle source

– @param [String] the path. @note this should only be used for urls rubocop:disable Metrics/CyclomaticComplexity rubocop:disable Metrics/PerceivedComplexity rubocop:disable Metrics/AbcSize Builds a url path for HTML. @return [String] –

# File lib/jekyll/assets/utils.rb, line 245
def prefix_url(user_path = nil)
  dest = strip_slashes(asset_config[:destination])
  cdn = make_https(strip_slashes(asset_config[:cdn][:url]))
  base = strip_slashes(jekyll.config["baseurl"])
  cfg = asset_config

  path = []
  path << cdn  if Jekyll.production? && cdn
  path << base if Jekyll.dev? || !cdn || (cdn && cfg[:cdn][:baseurl])
  path << dest if Jekyll.dev? || !cdn || (cdn && cfg[:cdn][:destination])
  path << user_path unless user_path.nil? || user_path == ""

  path = File.join(path.flatten.compact)
  return path if cdn && Jekyll.production?
  "/" + path
end
raw_precompiles() click to toggle source

# File lib/jekyll/assets/utils.rb, line 62
def raw_precompiles
  asset_config[:raw_precompile].each_with_object([]) do |v, a|
    if v.is_a?(Hash)
      dst, src = in_dest_dir.join(v[:dst]).tap(&:mkdir_p), v[:src]
      glob_paths(src).each do |sv|
        a << {
          src: sv,
          full_dst: dst.join(sv.basename),
          dst: dst,
        }
      end
    else
      glob_paths(v).each do |p|
        next unless p

        dst = strip_paths(p)
        dst = in_dest_dir(dst)
        dst.parent.mkdir_p

        a << {
          src: p,
          full_dst: dst,
          dst: dst,
        }
      end
    end
  end
end
strip_paths(path) click to toggle source

– @param [String] path the path to strip. Strips most source paths from the given path path. rubocop:enable Lint/LiteralAsCondition @return [String] –

# File lib/jekyll/assets/utils.rb, line 199
def strip_paths(path)
  paths.map do |v|
    if path.start_with?(v)
      return path.sub(v + "/", "")
    end
  end

  path
end
strip_secondary_content_type(str) click to toggle source

– param [String] the content type Strips the secondary content from type. rubocop:enable Metrics/PerceivedComplexity rubocop:enable Metrics/CyclomaticComplexity rubocop:enable Metrics/AbcSize @return [String] –

# File lib/jekyll/assets/utils.rb, line 271
def strip_secondary_content_type(str)
  str = str.split("/")
  raise ArgumentError, "#{str.join('/')} is invalid." if str.size > 2
  File.join(str[0], str[1].rpartition(%r!\+!).last)
end
strip_slashes(path) click to toggle source

– @param [String] path the path. Strip the start and end slashes in a path. @return [String] –

# File lib/jekyll/assets/utils.rb, line 283
def strip_slashes(path)
  return if path.nil? || path == ""
  path.gsub(%r!^/|/$!, "")
end
url_asset(url, type:) click to toggle source

# File lib/jekyll/assets/utils.rb, line 114
def url_asset(url, type:)
  name = File.basename(url)

  Url.new(*[Utils.old_sprockets? ? self : nil, {
    name: name,
    filename: url,
    content_type: type,
    load_path: File.dirname(url),
    id: Digest::SHA256.hexdigest(url),
    logical_path: name,
    metadata: {},
    source: "",
    uri: url,
  }].compact)
end