sprockets 2.12.5 → 3.7.2

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,287 @@
+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)
+        entries = Dir.entries(path, :encoding => Encoding.default_internal)
+        entries.reject! { |entry|
+          entry.start_with?(".".freeze) ||
+            (entry.start_with?("#".freeze) && entry.end_with?("#".freeze)) ||
+            entry.end_with?("~".freeze)
+        }
+        entries.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)
+      basename = File.basename(path)
+
+      i = basename.index('.'.freeze)
+      while i && i < basename.length - 1
+        extname = basename[i..-1]
+        if value = extensions[extname]
+          return extname, value
+        end
+
+        i = basename.index('.'.freeze, i+1)
+      end
+
+      nil
+    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
+
+      File.rename(tmpname, filename)
+    ensure
+      File.delete(tmpname) if File.exist?(tmpname)
+    end
+  end
+end

data/lib/sprockets/paths.rb

@@ -1,36 +1,53 @@
+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
-      @trail.root.dup
+      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.
-    #
-    # Note that a copy of the `Array` is returned so mutating will
-    # have no affect on the environment. See `append_path`,
-    # `prepend_path`, and `clear_paths`.
     def paths
-      @trail.paths.dup
+      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)
-      @trail.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)
-      @trail.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.
@@ -39,20 +56,26 @@ module Sprockets
     # completely wipe the paths list and reappend them in the order
     # you want.
     def clear_paths
-      @trail.paths.dup.each { |path| @trail.remove_path(path) }
+      self.config = hash_reassoc(config, :paths) do |paths|
+        paths.clear
+      end
     end
 
-    # Returns an `Array` of extensions.
+    # Public: Iterate over every file under all load paths.
     #
-    # These extensions maybe omitted from logical path searches.
-    #
-    #     # => [".js", ".css", ".coffee", ".sass", ...]
-    #
-    def extensions
-      @trail.extensions.dup
-    end
+    # Returns Enumerator if no block is given.
+    def each_file
+      return to_enum(__method__) unless block_given?
 
-    protected
-      attr_reader :trail
+      paths.each do |root|
+        stat_tree(root).each do |filename, stat|
+          if stat.file?
+            yield filename
+          end
+        end
+      end
+
+      nil
+    end
   end
 end