class Jekyll::PathManager


for performance reasons.
Therefore, employ this class only for situations where caching the result is necessary
regenerating. The results are frozen to deter mutation of the cached string.
However, the caches are never flushed so that they can be used even when a site is
call using **the same arguments**. Caching the result means reduced memory usage.
This class exists because ‘File.join` allocates an Array and returns a new String on every
NOTE:
A singleton class that caches frozen instances of path strings returned from its methods.

def join(base, item)

Returns a frozen string.

Reassigns `nil`, empty strings and empty arrays to a frozen empty string beforehand.
Wraps `File.join` to cache the frozen result. 
def join(base, item)
  base = "" if base.nil? || base.empty?
  item = "" if item.nil? || item.empty?
  @join ||= {}
  @join[base] ||= {}
  @join[base][item] ||= File.join(base, item).freeze
end

def sanitize_and_join(base_directory, questionable_path) 

def sanitize_and_join(base_directory, questionable_path)
  clean_path = if questionable_path.start_with?("~")
                 questionable_path.dup.insert(0, "/")
               else
                 questionable_path
               end
  clean_path = File.expand_path(clean_path, "/")
  return clean_path if clean_path.eql?(base_directory)
  # remove any remaining extra leading slashes not stripped away by calling
  # `File.expand_path` above.
  clean_path.squeeze!("/")
  return clean_path if clean_path.start_with?(slashed_dir_cache(base_directory))
  clean_path.sub!(%r!\A\w:/!, "/")
  join(base_directory, clean_path)
end

def sanitized_path(base_directory, questionable_path)

Returns a frozen string.

and prepends the questionable path with the base directory if false.
Ensures the questionable path is prefixed with the base directory 
def sanitized_path(base_directory, questionable_path)
  @sanitized_path ||= {}
  @sanitized_path[base_directory] ||= {}
  @sanitized_path[base_directory][questionable_path] ||= if questionable_path.nil?
                                                           base_directory.freeze
                                                         else
                                                           sanitize_and_join(
                                                             base_directory, questionable_path
                                                           ).freeze
                                                         end
end

def slashed_dir_cache(base_directory) 

def slashed_dir_cache(base_directory)
  @slashed_dir_cache ||= {}
  @slashed_dir_cache[base_directory] ||= base_directory.sub(%r!\z!, "/")
end