giga-lite-hub 0.0.1

data/sprockets-4.2.2/lib/sprockets/manifest.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+require 'json'
+require 'time'
+
+require 'concurrent'
+
+require 'sprockets/manifest_utils'
+
+module Sprockets
+  # The Manifest logs the contents of assets compiled to a single directory. It
+  # records basic attributes about the asset for fast lookup without having to
+  # compile. A pointer from each logical path indicates which fingerprinted
+  # asset is the current one.
+  #
+  # The JSON is part of the public API and should be considered stable. This
+  # should make it easy to read from other programming languages and processes
+  # that don't have sprockets loaded. See `#assets` and `#files` for more
+  # information about the structure.
+  class Manifest
+    include ManifestUtils
+
+    attr_reader :environment
+
+    # Create new Manifest associated with an `environment`. `filename` is a full
+    # path to the manifest json file. The file may or may not already exist. The
+    # dirname of the `filename` will be used to write compiled assets to.
+    # Otherwise, if the path is a directory, the filename will default a random
+    # ".sprockets-manifest-*.json" file in that directory.
+    #
+    #   Manifest.new(environment, "./public/assets/manifest.json")
+    #
+    def initialize(*args)
+      if args.first.is_a?(Base) || args.first.nil?
+        @environment = args.shift
+      end
+
+      @directory, @filename = args[0], args[1]
+
+      # Whether the manifest file is using the old manifest-*.json naming convention
+      @legacy_manifest = false
+
+      # Expand paths
+      @directory = File.expand_path(@directory) if @directory
+      @filename  = File.expand_path(@filename) if @filename
+
+      # If filename is given as the second arg
+      if @directory && File.extname(@directory) != ""
+        @directory, @filename = nil, @directory
+      end
+
+      # Default dir to the directory of the filename
+      @directory ||= File.dirname(@filename) if @filename
+
+      # If directory is given w/o filename, pick a random manifest location
+      if @directory && @filename.nil?
+        @filename = find_directory_manifest(@directory, logger)
+      end
+
+      unless @directory && @filename
+        raise ArgumentError, "manifest requires output filename"
+      end
+
+      data = {}
+
+      begin
+        if File.exist?(@filename)
+          data = json_decode(File.read(@filename))
+        end
+      rescue JSON::ParserError => e
+        logger.error "#{@filename} is invalid: #{e.class} #{e.message}"
+      end
+
+      @data = data
+    end
+
+    # Returns String path to manifest.json file.
+    attr_reader :filename
+    alias_method :path, :filename
+
+    attr_reader :directory
+    alias_method :dir, :directory
+
+    # Returns internal assets mapping. Keys are logical paths which
+    # map to the latest fingerprinted filename.
+    #
+    #   Logical path (String): Fingerprint path (String)
+    #
+    #   { "application.js" => "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js",
+    #     "jquery.js"      => "jquery-ae0908555a245f8266f77df5a8edca2e.js" }
+    #
+    def assets
+      @data['assets'] ||= {}
+    end
+
+    # Returns internal file directory listing. Keys are filenames
+    # which map to an attributes array.
+    #
+    #   Fingerprint path (String):
+    #     logical_path: Logical path (String)
+    #     mtime: ISO8601 mtime (String)
+    #     digest: Base64 hex digest (String)
+    #
+    #  { "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js" =>
+    #      { 'logical_path' => "application.js",
+    #        'mtime' => "2011-12-13T21:47:08-06:00",
+    #        'digest' => "2e8e9a7c6b0aafa0c9bdeec90ea30213" } }
+    #
+    def files
+      @data['files'] ||= {}
+    end
+
+    # Public: Find all assets matching pattern set in environment.
+    #
+    # Returns Enumerator of Assets.
+    def find(*args, &block)
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
+      return to_enum(__method__, *args) unless block_given?
+
+      environment = self.environment.cached
+      promises = args.flatten.map do |path|
+        Concurrent::Promise.execute(executor: executor) do
+          environment.find_all_linked_assets(path).to_a
+        end
+      end
+
+      promises.each do |promise|
+        promise.value!.each(&block)
+      end
+
+      nil
+    end
+
+    # Public: Find the source of assets by paths.
+    #
+    # Returns Enumerator of assets file content.
+    def find_sources(*args)
+      return to_enum(__method__, *args) unless block_given?
+
+      if environment
+        find(*args).each do |asset|
+          yield asset.source
+        end
+      else
+        args.each do |path|
+          asset = assets[path]
+          yield File.binread(File.join(dir, asset)) if asset
+        end
+      end
+    end
+
+    # Compile asset to directory. The asset is written to a
+    # fingerprinted filename like
+    # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
+    # also inserted into the manifest file.
+    #
+    #   compile("application.js")
+    #
+    def compile(*args)
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
+      filenames            = []
+      concurrent_exporters = []
+
+      assets_to_export = Concurrent::Array.new
+      find(*args) do |asset|
+        assets_to_export << asset
+      end
+
+      assets_to_export.each do |asset|
+        mtime = Time.now.iso8601
+        files[asset.digest_path] = {
+          'logical_path' => asset.logical_path,
+          'mtime'        => mtime,
+          'size'         => asset.bytesize,
+          'digest'       => asset.hexdigest,
+
+          # Deprecated: Remove beta integrity attribute in next release.
+          # Callers should DigestUtils.hexdigest_integrity_uri to compute the
+          # digest themselves.
+          'integrity'    => DigestUtils.hexdigest_integrity_uri(asset.hexdigest)
+        }
+        assets[asset.logical_path] = asset.digest_path
+
+        filenames << asset.filename
+
+        promise      = nil
+        exporters_for_asset(asset) do |exporter|
+          next if exporter.skip?(logger)
+
+          if promise.nil?
+            promise = Concurrent::Promise.new(executor: executor) { exporter.call }
+            concurrent_exporters << promise.execute
+          else
+            concurrent_exporters << promise.then { exporter.call }
+          end
+        end
+      end
+
+      # make sure all exporters have finished before returning the main thread
+      concurrent_exporters.each(&:wait!)
+      save
+
+      filenames
+    end
+
+    # Removes file from directory and from manifest. `filename` must
+    # be the name with any directory path.
+    #
+    #   manifest.remove("application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js")
+    #
+    def remove(filename)
+      path = File.join(dir, filename)
+      gzip = "#{path}.gz"
+      logical_path = files[filename]['logical_path']
+
+      if assets[logical_path] == filename
+        assets.delete(logical_path)
+      end
+
+      files.delete(filename)
+      FileUtils.rm(path) if File.exist?(path)
+      FileUtils.rm(gzip) if File.exist?(gzip)
+
+      save
+
+      logger.info "Removed #{filename}"
+
+      nil
+    end
+
+    # Cleanup old assets in the compile directory. By default it will
+    # keep the latest version, 2 backups and any created within the past hour.
+    #
+    # Examples
+    #
+    #   To force only 1 backup to be kept, set count=1 and age=0.
+    #
+    #   To only keep files created within the last 10 minutes, set count=0 and
+    #   age=600.
+    #
+    def clean(count = 2, age = 3600)
+      asset_versions = files.group_by { |_, attrs| attrs['logical_path'] }
+
+      asset_versions.each do |logical_path, versions|
+        current = assets[logical_path]
+
+        versions.reject { |path, _|
+          path == current
+        }.sort_by { |_, attrs|
+          # Sort by timestamp
+          Time.parse(attrs['mtime'])
+        }.reverse.each_with_index.drop_while { |(_, attrs), index|
+          _age = [0, Time.now - Time.parse(attrs['mtime'])].max
+          # Keep if under age or within the count limit
+          _age < age || index < count
+        }.each { |(path, _), _|
+           # Remove old assets
+          remove(path)
+        }
+      end
+    end
+
+    # Wipe directive
+    def clobber
+      FileUtils.rm_r(directory) if File.exist?(directory)
+      logger.info "Removed #{directory}"
+      # if we have an environment clear the cache too
+      environment.cache.clear if environment
+      nil
+    end
+
+    # Persist manifest back to FS
+    def save
+      data = json_encode(@data)
+      FileUtils.mkdir_p File.dirname(@filename)
+      PathUtils.atomic_write(@filename) do |f|
+        f.write(data)
+      end
+    end
+
+    private
+
+      # Given an asset, finds all exporters that
+      # match its mime-type.
+      #
+      # Will yield each expoter to the passed in block.
+      #
+      #     array = []
+      #     puts asset.content_type # => "application/javascript"
+      #     exporters_for_asset(asset) do |exporter|
+      #       array << exporter
+      #     end
+      #     # puts array => [Exporters::FileExporter, Exporters::ZlibExporter]
+      def exporters_for_asset(asset)
+        exporters = [Exporters::FileExporter]
+
+        environment.exporters.each do |mime_type, exporter_list|
+          next unless asset.content_type
+          next unless environment.match_mime_type? asset.content_type, mime_type
+          exporter_list.each do |exporter|
+            exporters << exporter
+          end
+        end
+
+        exporters.uniq!
+
+        exporters.each do |exporter|
+          yield exporter.new(asset: asset, environment: environment, directory: dir)
+        end
+      end
+
+      def json_decode(obj)
+        JSON.parse(obj, create_additions: false)
+      end
+
+      def json_encode(obj)
+        JSON.generate(obj)
+      end
+
+      def logger
+        if environment
+          environment.logger
+        else
+          logger = Logger.new($stderr)
+          logger.level = Logger::FATAL
+          logger
+        end
+      end
+
+      def executor
+        @executor ||= environment.export_concurrent ? :fast : :immediate
+      end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/manifest_utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'securerandom'
+require 'logger'
+
+module Sprockets
+  # Public: Manifest utilities.
+  module ManifestUtils
+    extend self
+
+    MANIFEST_RE = /^\.sprockets-manifest-[0-9a-f]{32}.json$/
+
+    # Public: Generate a new random manifest path.
+    #
+    # Manifests are not intended to be accessed publicly, but typically live
+    # alongside public assets for convenience. To avoid being served, the
+    # filename is prefixed with a "." which is usually hidden by web servers
+    # like Apache. To help in other environments that may not control this,
+    # a random hex string is appended to the filename to prevent people from
+    # guessing the location. If directory indexes are enabled on the server,
+    # all bets are off.
+    #
+    # Return String path.
+    def generate_manifest_path
+      ".sprockets-manifest-#{SecureRandom.hex(16)}.json"
+    end
+
+    # Public: Find or pick a new manifest filename for target build directory.
+    #
+    # dirname - String dirname
+    #
+    # Examples
+    #
+    #     find_directory_manifest("/app/public/assets")
+    #     # => "/app/public/assets/.sprockets-manifest-abc123.json"
+    #
+    # Returns String filename.
+    def find_directory_manifest(dirname, logger = Logger.new($stderr))
+      entries = File.directory?(dirname) ? Dir.entries(dirname) : []
+      manifest_entries = entries.select { |e| e =~ MANIFEST_RE }
+      if manifest_entries.length > 1
+        manifest_entries.sort!
+        logger.warn("Found multiple manifests: #{manifest_entries}. Choosing the first alphabetically: #{manifest_entries.first}")
+      end
+      entry = manifest_entries.first || generate_manifest_path
+      File.join(dirname, entry)
+    end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/mime.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require 'sprockets/encoding_utils'
+require 'sprockets/http_utils'
+require 'sprockets/utils'
+
+module Sprockets
+  module Mime
+    include HTTPUtils, Utils
+
+    # Public: Mapping of MIME type Strings to properties Hash.
+    #
+    # key   - MIME Type String
+    # value - Hash
+    #   extensions - Array of extnames
+    #   charset    - Default Encoding or function to detect encoding
+    #
+    # Returns Hash.
+    def mime_types
+      config[:mime_types]
+    end
+
+    # Internal: Mapping of MIME extension Strings to MIME type Strings.
+    #
+    # Used for internal fast lookup purposes.
+    #
+    # Examples:
+    #
+    #   mime_exts['.js'] #=> 'application/javascript'
+    #
+    # key   - MIME extension String
+    # value - MIME Type String
+    #
+    # Returns Hash.
+    def mime_exts
+      config[:mime_exts]
+    end
+
+    # Public: Register a new mime type.
+    #
+    # mime_type  - String MIME Type
+    # extensions - Array of String extnames
+    # charset    - Proc/Method that detects the charset of a file.
+    #              See EncodingUtils.
+    #
+    # Returns nothing.
+    def register_mime_type(mime_type, extensions: [], charset: nil)
+      extnames = Array(extensions)
+
+      charset ||= :default if mime_type.start_with?('text/')
+      charset = EncodingUtils::CHARSET_DETECT[charset] if charset.is_a?(Symbol)
+
+      self.config = hash_reassoc(config, :mime_exts) do |mime_exts|
+        extnames.each do |extname|
+          mime_exts[extname] = mime_type
+        end
+        mime_exts
+      end
+
+      self.config = hash_reassoc(config, :mime_types) do |mime_types|
+        type = { extensions: extnames }
+        type[:charset] = charset if charset
+        mime_types.merge(mime_type => type)
+      end
+    end
+
+    # Internal: Get detecter function for MIME type.
+    #
+    # mime_type - String MIME type
+    #
+    # Returns Proc detector or nil if none is available.
+    def mime_type_charset_detecter(mime_type)
+      if type = config[:mime_types][mime_type]
+        if detect = type[:charset]
+          return detect
+        end
+      end
+    end
+
+    # Public: Read file on disk with MIME type specific encoding.
+    #
+    # filename     - String path
+    # content_type - String MIME type
+    #
+    # Returns String file contents transcoded to UTF-8 or in its external
+    # encoding.
+    def read_file(filename, content_type = nil)
+      data = File.binread(filename)
+
+      if detect = mime_type_charset_detecter(content_type)
+        detect.call(data).encode(Encoding::UTF_8, universal_newline: true)
+      else
+        data
+      end
+    end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/npm.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'json'
+
+module Sprockets
+  module Npm
+    # Internal: Override resolve_alternates to install package.json behavior.
+    #
+    # load_path    - String environment path
+    # logical_path - String path relative to base
+    #
+    # Returns candidate filenames.
+    def resolve_alternates(load_path, logical_path)
+      candidates, deps = super
+
+      dirname = File.join(load_path, logical_path)
+
+      if directory?(dirname)
+        filename = File.join(dirname, 'package.json')
+
+        if self.file?(filename)
+          deps << build_file_digest_uri(filename)
+          read_package_directives(dirname, filename) do |path|
+            if file?(path)
+              candidates << path
+            end
+          end
+        end
+      end
+
+      return candidates, deps
+    end
+
+    # Internal: Read package.json's main and style directives.
+    #
+    # dirname  - String path to component directory.
+    # filename - String path to package.json.
+    #
+    # Returns nothing.
+    def read_package_directives(dirname, filename)
+      package = JSON.parse(File.read(filename), create_additions: false)
+
+      case package['main']
+      when String
+        yield File.expand_path(package['main'], dirname)
+      when nil
+        yield File.expand_path('index.js', dirname)
+      end
+
+      yield File.expand_path(package['style'], dirname) if package['style']
+    end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/path_dependency_utils.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'set'
+require 'sprockets/path_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  # Internal: Related PathUtils helpers that also track all the file system
+  # calls they make for caching purposes. All functions return a standard
+  # return value and a Set of cache dependency URIs that can be used in the
+  # future to see if the returned value should be invalidated from cache.
+  #
+  #     entries_with_dependencies("app/assets/javascripts")
+  #     # => [
+  #     #   ["application.js", "projects.js", "users.js", ...]
+  #     #    #<Set: {"file-digest:/path/to/app/assets/javascripts"}>
+  #     # ]
+  #
+  # The returned dependency set can be passed to resolve_dependencies(deps)
+  # to check if the returned result is still fresh. In this case, entry always
+  # returns a single path, but multiple calls should accumulate dependencies
+  # into a single set thats saved off and checked later.
+  #
+  #     resolve_dependencies(deps)
+  #     # => "\x01\x02\x03"
+  #
+  # Later, resolving the same set again will produce a different hash if
+  # something on the file system has changed.
+  #
+  #     resolve_dependencies(deps)
+  #     # => "\x03\x04\x05"
+  #
+  module PathDependencyUtils
+    include PathUtils
+    include URIUtils
+
+    # Internal: List directory entries and return a set of dependencies that
+    # would invalid the cached return result.
+    #
+    # See PathUtils#entries
+    #
+    # path - String directory path
+    #
+    # Returns an Array of entry names and a Set of dependency URIs.
+    def entries_with_dependencies(path)
+      return entries(path), Set.new([build_file_digest_uri(path)])
+    end
+
+    # Internal: List directory filenames and associated Stats under a
+    # directory.
+    #
+    # See PathUtils#stat_directory
+    #
+    # dir - A String directory
+    #
+    # Returns an Array of filenames and a Set of dependency URIs.
+    def stat_directory_with_dependencies(dir)
+      return stat_directory(dir).to_a, Set.new([build_file_digest_uri(dir)])
+    end
+
+    # Internal: List directory filenames and associated Stats under an entire
+    # directory tree.
+    #
+    # See PathUtils#stat_sorted_tree
+    #
+    # dir - A String directory
+    #
+    # Returns an Array of filenames and a Set of dependency URIs.
+    def stat_sorted_tree_with_dependencies(dir)
+      deps = Set.new([build_file_digest_uri(dir)])
+      results = stat_sorted_tree(dir).map do |path, stat|
+        deps << build_file_digest_uri(path) if stat.directory?
+        [path, stat]
+      end
+      return results, deps
+    end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/path_digest_utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'sprockets/digest_utils'
+require 'sprockets/path_utils'
+
+module Sprockets
+  # Internal: Crossover of path and digest utilities functions.
+  module PathDigestUtils
+    include DigestUtils, PathUtils
+
+    # Internal: Compute digest for file stat.
+    #
+    # path - String filename
+    # stat - File::Stat
+    #
+    # Returns String digest bytes.
+    def stat_digest(path, stat)
+      if stat.directory?
+        # If its a directive, digest the list of filenames
+        digest_class.digest(self.entries(path).join(','.freeze))
+      elsif stat.file?
+        # If its a file, digest the contents
+        digest_class.file(path.to_s).digest
+      else
+        raise TypeError, "stat was not a directory or file: #{stat.ftype}"
+      end
+    end
+
+    # Internal: Compute digest for path.
+    #
+    # path - String filename or directory path.
+    #
+    # Returns String digest bytes or nil.
+    def file_digest(path)
+      if stat = self.stat(path)
+        self.stat_digest(path, stat)
+      end
+    end
+
+    # Internal: Compute digest for a set of paths.
+    #
+    # paths - Array of filename or directory paths.
+    #
+    # Returns String digest bytes.
+    def files_digest(paths)
+      self.digest(paths.map { |path| self.file_digest(path) })
+    end
+  end
+end