sprockets 2.3.2 → 3.0.0

data/lib/sprockets/mime.rb

@@ -1,48 +1,130 @@
-require 'rack/mime'
+require 'sprockets/encoding_utils'
+require 'sprockets/http_utils'
+require 'sprockets/utils'
 
 module Sprockets
   module Mime
-    # Returns a `Hash` of registered mime types registered on the
-    # environment and those part of `Rack::Mime`.
+    include HTTPUtils, Utils
+
+    # Public: Mapping of MIME type Strings to properties Hash.
     #
-    # If an `ext` is given, it will lookup the mime type for that extension.
-    def mime_types(ext = nil)
-      if ext.nil?
-        Rack::Mime::MIME_TYPES.merge(@mime_types)
-      else
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @mime_types[ext] || Rack::Mime::MIME_TYPES[ext]
-      end
+    # 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
 
-    if {}.respond_to?(:key)
-      def extension_for_mime_type(type)
-        mime_types.key(type)
+    # 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
+    # options - Hash
+    #   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, options = {})
+      # Legacy extension argument, will be removed from 4.x
+      if options.is_a?(String)
+        options = { extensions: [options] }
       end
-    else
-      def extension_for_mime_type(type)
-        mime_types.index(type)
+
+      extnames = Array(options[:extensions]).map { |extname|
+        Sprockets::Utils.normalize_extension(extname)
+      }
+
+      charset = options[:charset]
+      charset ||= :default if mime_type.start_with?('text/')
+      charset = EncodingUtils::CHARSET_DETECT[charset] if charset.is_a?(Symbol)
+
+      self.computed_config = {}
+
+      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
 
-    # Register a new mime type.
-    def register_mime_type(mime_type, ext)
-      ext = Sprockets::Utils.normalize_extension(ext)
-      @mime_types[ext] = mime_type
+    # 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
 
-    if defined? Encoding
-      # Returns the correct encoding for a given mime type, while falling
-      # back on the default external encoding, if it exists.
-      def encoding_for_mime_type(type)
-        encoding = Encoding::BINARY if type =~ %r{^(image|audio|video)/}
-        encoding ||= default_external_encoding if respond_to?(:default_external_encoding)
-        encoding
+    # 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
 
-  # Extend Sprockets module to provide global registry
-  extend Mime
-  @mime_types = {}
+    private
+      def extname_map
+        self.computed_config[:_extnames] ||= compute_extname_map
+      end
+
+      def compute_extname_map
+        graph = {}
+
+        ([nil] + pipelines.keys.map(&:to_s)).each do |pipeline|
+          pipeline_extname = ".#{pipeline}" if pipeline
+          ([[nil, nil]] + config[:mime_exts].to_a).each do |format_extname, format_type|
+            4.times do |n|
+              config[:engines].keys.permutation(n).each do |engine_extnames|
+                key = "#{pipeline_extname}#{format_extname}#{engine_extnames.join}"
+                type = format_type || config[:engine_mime_types][engine_extnames.first]
+                graph[key] = {type: type, engines: engine_extnames, pipeline: pipeline}
+              end
+            end
+          end
+        end
+
+        graph
+      end
+  end
 end

data/lib/sprockets/path_dependency_utils.rb

@@ -0,0 +1,85 @@
+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), file_digest_dependency_set(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, file_digest_dependency_set(dir)
+    end
+
+    # Internal: Returns a set of dependencies for a particular path.
+    #
+    # path - String directory path
+    #
+    # Returns a Set of dependency URIs.
+    def file_digest_dependency_set(path)
+      Set.new([build_file_digest_uri(path)])
+    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/lib/sprockets/path_digest_utils.rb

@@ -0,0 +1,47 @@
+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(','))
+      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

data/lib/sprockets/path_utils.rb

@@ -0,0 +1,282 @@
+require 'fileutils'
+
+module Sprockets
+  # Internal: File and path related utilities. Mixed into Environment.
+  #
+  # Probably would be called FileUtils, but that causes namespace annoyances
+  # when code actually wants to reference ::FileUtils.
+  module PathUtils
+    extend self
+
+    # Public: Like `File.stat`.
+    #
+    # path - String file or directory path
+    #
+    # Returns nil if the file does not exist.
+    def stat(path)
+      if File.exist?(path)
+        File.stat(path.to_s)
+      else
+        nil
+      end
+    end
+
+    # Public: Like `File.file?`.
+    #
+    # path - String file path.
+    #
+    # Returns true path exists and is a file.
+    def file?(path)
+      if stat = self.stat(path)
+        stat.file?
+      else
+        false
+      end
+    end
+
+    # Public: Like `File.directory?`.
+    #
+    # path - String file path.
+    #
+    # Returns true path exists and is a directory.
+    def directory?(path)
+      if stat = self.stat(path)
+        stat.directory?
+      else
+        false
+      end
+    end
+
+    # Public: A version of `Dir.entries` that filters out `.` files and `~`
+    # swap files.
+    #
+    # path - String directory path
+    #
+    # Returns an empty `Array` if the directory does not exist.
+    def entries(path)
+      if File.directory?(path)
+        Dir.entries(path, :encoding => Encoding.default_internal).reject! { |entry|
+          entry =~ /^\.|~$|^\#.*\#$/
+        }.sort!
+      else
+        []
+      end
+    end
+
+    # Public: Check if path is absolute or relative.
+    #
+    # path - String path.
+    #
+    # Returns true if path is absolute, otherwise false.
+    if File::ALT_SEPARATOR
+      require 'pathname'
+
+      # On Windows, ALT_SEPARATOR is \
+      # Delegate to Pathname since the logic gets complex.
+      def absolute_path?(path)
+        Pathname.new(path).absolute?
+      end
+    else
+      def absolute_path?(path)
+        path[0] == File::SEPARATOR
+      end
+    end
+
+    if File::ALT_SEPARATOR
+      SEPARATOR_PATTERN = "#{Regexp.quote(File::SEPARATOR)}|#{Regexp.quote(File::ALT_SEPARATOR)}"
+    else
+      SEPARATOR_PATTERN = "#{Regexp.quote(File::SEPARATOR)}"
+    end
+
+    # Public: Check if path is explicitly relative.
+    # Starts with "./" or "../".
+    #
+    # path - String path.
+    #
+    # Returns true if path is relative, otherwise false.
+    def relative_path?(path)
+      path =~ /^\.\.?($|#{SEPARATOR_PATTERN})/ ? true : false
+    end
+
+    # Internal: Get relative path for root path and subpath.
+    #
+    # path    - String path
+    # subpath - String subpath of path
+    #
+    # Returns relative String path if subpath is a subpath of path, or nil if
+    # subpath is outside of path.
+    def split_subpath(path, subpath)
+      return "" if path == subpath
+      path = File.join(path, '')
+      if subpath.start_with?(path)
+        subpath[path.length..-1]
+      else
+        nil
+      end
+    end
+
+    # Internal: Detect root path and base for file in a set of paths.
+    #
+    # paths    - Array of String paths
+    # filename - String path of file expected to be in one of the paths.
+    #
+    # Returns [String root, String path]
+    def paths_split(paths, filename)
+      paths.each do |path|
+        if subpath = split_subpath(path, filename)
+          return path, subpath
+        end
+      end
+      nil
+    end
+
+    # Internal: Get path's extensions.
+    #
+    # path - String
+    #
+    # Returns an Array of String extnames.
+    def path_extnames(path)
+      File.basename(path).scan(/\.[^.]+/)
+    end
+
+    # Internal: Match path extnames against available extensions.
+    #
+    # path       - String
+    # extensions - Hash of String extnames to values
+    #
+    # Returns [String extname, Object value] or nil nothing matched.
+    def match_path_extname(path, extensions)
+      match, key = nil, ""
+      path_extnames(path).reverse_each do |extname|
+        key.prepend(extname)
+        if value = extensions[key]
+          match = [key.dup, value]
+        elsif match
+          break
+        end
+      end
+      match
+    end
+
+    # Internal: Returns all parents for path
+    #
+    # path - String absolute filename or directory
+    # root - String path to stop at (default: system root)
+    #
+    # Returns an Array of String paths.
+    def path_parents(path, root = nil)
+      root = "#{root}#{File::SEPARATOR}" if root
+      parents = []
+
+      loop do
+        parent = File.dirname(path)
+        break if parent == path
+        break if root && !path.start_with?(root)
+        parents << path = parent
+      end
+
+      parents
+    end
+
+    # Internal: Find target basename checking upwards from path.
+    #
+    # basename - String filename: ".sprocketsrc"
+    # path     - String path to start search: "app/assets/javascripts/app.js"
+    # root     - String path to stop at (default: system root)
+    #
+    # Returns String filename or nil.
+    def find_upwards(basename, path, root = nil)
+      path_parents(path, root).each do |dir|
+        filename = File.join(dir, basename)
+        return filename if file?(filename)
+      end
+      nil
+    end
+
+    # Public: Stat all the files under a directory.
+    #
+    # dir - A String directory
+    #
+    # Returns an Enumerator of [path, stat].
+    def stat_directory(dir)
+      return to_enum(__method__, dir) unless block_given?
+
+      self.entries(dir).each do |entry|
+        path = File.join(dir, entry)
+        if stat = self.stat(path)
+          yield path, stat
+        end
+      end
+
+      nil
+    end
+
+    # Public: Recursive stat all the files under a directory.
+    #
+    # dir - A String directory
+    #
+    # Returns an Enumerator of [path, stat].
+    def stat_tree(dir, &block)
+      return to_enum(__method__, dir) unless block_given?
+
+      self.stat_directory(dir) do |path, stat|
+        yield path, stat
+
+        if stat.directory?
+          stat_tree(path, &block)
+        end
+      end
+
+      nil
+    end
+
+    # Public: Recursive stat all the files under a directory in alphabetical
+    # order.
+    #
+    # dir - A String directory
+    #
+    # Returns an Enumerator of [path, stat].
+    def stat_sorted_tree(dir, &block)
+      return to_enum(__method__, dir) unless block_given?
+
+      self.stat_directory(dir).sort_by { |path, stat|
+        stat.directory? ? "#{path}/" : path
+      }.each do |path, stat|
+        yield path, stat
+
+        if stat.directory?
+          stat_sorted_tree(path, &block)
+        end
+      end
+
+      nil
+    end
+
+    # Public: Write to a file atomically. Useful for situations where you
+    # don't want other processes or threads to see half-written files.
+    #
+    #   Utils.atomic_write('important.file') do |file|
+    #     file.write('hello')
+    #   end
+    #
+    # Returns nothing.
+    def atomic_write(filename)
+      dirname, basename = File.split(filename)
+      basename = [
+        basename,
+        Thread.current.object_id,
+        Process.pid,
+        rand(1000000)
+      ].join('.')
+      tmpname = File.join(dirname, basename)
+
+      File.open(tmpname, 'wb+') do |f|
+        yield f
+      end
+
+      FileUtils.mv(tmpname, filename)
+    ensure
+      FileUtils.rm(tmpname) if File.exist?(tmpname)
+    end
+  end
+end

data/lib/sprockets/paths.rb

@@ -0,0 +1,81 @@
+require 'sprockets/path_utils'
+require 'sprockets/utils'
+
+module Sprockets
+  module Paths
+    include PathUtils, Utils
+
+    # Returns `Environment` root.
+    #
+    # All relative paths are expanded with root as its base. To be
+    # useful set this to your applications root directory. (`Rails.root`)
+    def root
+      config[:root]
+    end
+
+    # Internal: Change Environment root.
+    #
+    # Only the initializer should change the root.
+    def root=(path)
+      self.config = hash_reassoc(config, :root) do
+        File.expand_path(path)
+      end
+    end
+    private :root=
+
+    # Returns an `Array` of path `String`s.
+    #
+    # These paths will be used for asset logical path lookups.
+    def paths
+      config[:paths]
+    end
+
+    # Prepend a `path` to the `paths` list.
+    #
+    # Paths at the end of the `Array` have the least priority.
+    def prepend_path(path)
+      self.config = hash_reassoc(config, :paths) do |paths|
+        path = File.expand_path(path, config[:root]).freeze
+        paths.unshift(path)
+      end
+    end
+
+    # Append a `path` to the `paths` list.
+    #
+    # Paths at the beginning of the `Array` have a higher priority.
+    def append_path(path)
+      self.config = hash_reassoc(config, :paths) do |paths|
+        path = File.expand_path(path, config[:root]).freeze
+        paths.push(path)
+      end
+    end
+
+    # Clear all paths and start fresh.
+    #
+    # There is no mechanism for reordering paths, so its best to
+    # completely wipe the paths list and reappend them in the order
+    # you want.
+    def clear_paths
+      self.config = hash_reassoc(config, :paths) do |paths|
+        paths.clear
+      end
+    end
+
+    # Public: Iterate over every file under all load paths.
+    #
+    # Returns Enumerator if no block is given.
+    def each_file
+      return to_enum(__method__) unless block_given?
+
+      paths.each do |root|
+        stat_tree(root).each do |filename, stat|
+          if stat.file?
+            yield filename
+          end
+        end
+      end
+
+      nil
+    end
+  end
+end