sprockets 2.1.0 → 2.2.3

data/lib/sprockets/directive_processor.rb

@@ -126,7 +126,7 @@ module Sprockets
       @directives ||= header.lines.each_with_index.map { |line, index|
         if directive = line[DIRECTIVE_PATTERN, 1]
           name, *args = Shellwords.shellwords(directive)
-          if respond_to?("process_#{name}_directive")
+          if respond_to?("process_#{name}_directive", true)
             [index + 1, name, *args]
           end
         end
@@ -260,7 +260,7 @@ module Sprockets
           root = pathname.dirname.join(path).expand_path
 
           unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_tree argument must be a directory"
+            raise ArgumentError, "require_directory argument must be a directory"
           end
 
           context.depend_on(root)
@@ -340,6 +340,18 @@ module Sprockets
         context.depend_on_asset(path)
       end
 
+      # Allows dependency to be excluded from the asset bundle.
+      #
+      # The `path` must be a valid asset and may or may not already
+      # be part of the bundle. Once stubbed, it is blacklisted and
+      # can't be brought back by any other `require`.
+      #
+      #     //= stub "jquery"
+      #
+      def process_stub_directive(path)
+        context.stub_asset(path)
+      end
+
       # Enable Sprockets 1.x compat mode.
       #
       # Makes it possible to use the same JavaScript source

data/lib/sprockets/environment.rb

@@ -23,6 +23,10 @@ module Sprockets
       self.logger = Logger.new($stderr)
       self.logger.level = Logger::FATAL
 
+      if respond_to?(:default_external_encoding)
+        self.default_external_encoding = Encoding::UTF_8
+      end
+
       # Create a safe `Context` subclass to mutate
       @context_class = Class.new(Context)
 

data/lib/sprockets/index.rb

@@ -14,6 +14,10 @@ module Sprockets
     def initialize(environment)
       @environment = environment
 
+      if environment.respond_to?(:default_external_encoding)
+        @default_external_encoding = environment.default_external_encoding
+      end
+
       # Copy environment attributes
       @logger            = environment.logger
       @context_class     = environment.context_class

data/lib/sprockets/manifest.rb

@@ -0,0 +1,203 @@
+require 'multi_json'
+require 'time'
+
+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 with 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 infomation about the structure.
+  class Manifest
+    attr_reader :environment, :path, :dir
+
+    # Create new Manifest associated with an `environment`. `path` is
+    # a full path to the manifest json file. The file may or may not
+    # already exist. The dirname of the `path` will be used to write
+    # compiled assets to. Otherwise, if the path is a directory, the
+    # filename will default to "manifest.json" in that directory.
+    #
+    #   Manifest.new(environment, "./public/assets/manifest.json")
+    #
+    def initialize(environment, path)
+      @environment = environment
+
+      if File.extname(path) == ""
+        @dir  = File.expand_path(path)
+        @path = File.join(@dir, 'manifest.json')
+      else
+        @path = File.expand_path(path)
+        @dir  = File.dirname(path)
+      end
+
+      data = nil
+
+      begin
+        if File.exist?(@path)
+          data = MultiJson.decode(File.read(@path))
+        end
+      rescue MultiJson::DecodeError => e
+        logger.error "#{@path} is invalid: #{e.class} #{e.message}"
+      end
+
+      @data = data.is_a?(Hash) ? data : {}
+    end
+
+    # 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
+
+    # Compile and write 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)
+      paths = environment.each_logical_path(*args).to_a +
+        args.flatten.select { |fn| Pathname.new(fn).absolute? }
+
+      paths.each do |path|
+        if asset = find_asset(path)
+          files[asset.digest_path] = {
+            'logical_path' => asset.logical_path,
+            'mtime'        => asset.mtime.iso8601,
+            'digest'       => asset.digest
+          }
+          assets[asset.logical_path] = asset.digest_path
+
+          target = File.join(dir, asset.digest_path)
+
+          if File.exist?(target)
+            logger.debug "Skipping #{target}, already exists"
+          else
+            logger.info "Writing #{target}"
+            asset.write_to target
+          end
+
+          save
+          asset
+        end
+      end
+    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)
+      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)
+
+      save
+
+      logger.warn "Removed #{filename}"
+
+      nil
+    end
+
+    # Cleanup old assets in the compile directory. By default it will
+    # keep the latest version plus 2 backups.
+    def clean(keep = 2)
+      self.assets.keys.each do |logical_path|
+        # Get assets sorted by ctime, newest first
+        assets = backups_for(logical_path)
+
+        # Keep the last N backups
+        assets = assets[keep..-1] || []
+
+        # Remove old assets
+        assets.each { |path, _| remove(path) }
+      end
+    end
+
+    # Wipe directive
+    def clobber
+      FileUtils.rm_r(@dir) if File.exist?(@dir)
+      logger.warn "Removed #{@dir}"
+      nil
+    end
+
+    protected
+      # Finds all the backup assets for a logical path. The latest
+      # version is always excluded. The return array is sorted by the
+      # assets mtime in descending order (Newest to oldest).
+      def backups_for(logical_path)
+        files.select { |filename, attrs|
+          # Matching logical paths
+          attrs['logical_path'] == logical_path &&
+            # Excluding whatever asset is the current
+            assets[logical_path] != filename
+        }.sort_by { |filename, attrs|
+          # Sort by timestamp
+          Time.parse(attrs['mtime'])
+        }.reverse
+      end
+
+      # Basic wrapper around Environment#find_asset. Logs compile time.
+      def find_asset(logical_path)
+        asset = nil
+        ms = benchmark do
+          asset = environment.find_asset(logical_path)
+        end
+        logger.warn "Compiled #{logical_path}  (#{ms}ms)"
+        asset
+      end
+
+      # Persist manfiest back to FS
+      def save
+        FileUtils.mkdir_p dir
+        File.open(path, 'w') do |f|
+          f.write MultiJson.encode(@data)
+        end
+      end
+
+    private
+      def logger
+        environment.logger
+      end
+
+      def benchmark
+        start_time = Time.now.to_f
+        yield
+        ((Time.now.to_f - start_time) * 1000).to_i
+      end
+  end
+end

data/lib/sprockets/mime.rb

@@ -30,6 +30,16 @@ module Sprockets
       ext = Sprockets::Utils.normalize_extension(ext)
       @mime_types[ext] = mime_type
     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
+      end
+    end
   end
 
   # Extend Sprockets module to provide global registry

data/lib/sprockets/processed_asset.rb

@@ -94,27 +94,31 @@ module Sprockets
 
     private
       def build_required_assets(environment, context)
-        @required_assets = []
-        required_assets_cache = {}
+        @required_assets = resolve_dependencies(environment, context._required_paths + [pathname.to_s]) -
+          resolve_dependencies(environment, context._stubbed_assets.to_a)
+      end
+
+      def resolve_dependencies(environment, paths)
+        assets = []
+        cache  = {}
 
-        (context._required_paths + [pathname.to_s]).each do |path|
+        paths.each do |path|
           if path == self.pathname.to_s
-            unless required_assets_cache[self]
-              required_assets_cache[self] = true
-              @required_assets << self
+            unless cache[self]
+              cache[self] = true
+              assets << self
             end
           elsif asset = environment.find_asset(path, :bundle => false)
             asset.required_assets.each do |asset_dependency|
-              unless required_assets_cache[asset_dependency]
-                required_assets_cache[asset_dependency] = true
-                @required_assets << asset_dependency
+              unless cache[asset_dependency]
+                cache[asset_dependency] = true
+                assets << asset_dependency
               end
             end
           end
         end
 
-        required_assets_cache.clear
-        required_assets_cache = nil
+        assets
       end
 
       def build_dependency_paths(environment, context)

data/lib/sprockets/server.rb

@@ -25,11 +25,6 @@ module Sprockets
 
       msg = "Served asset #{env['PATH_INFO']} -"
 
-      # URLs containing a `".."` are rejected for security reasons.
-      if forbidden_request?(env)
-        return forbidden_response
-      end
-
       # Mark session as "skipped" so no `Set-Cookie` header is set
       env['rack.session.options'] ||= {}
       env['rack.session.options'][:defer] = true
@@ -43,6 +38,11 @@ module Sprockets
         path = path.sub("-#{fingerprint}", '')
       end
 
+      # URLs containing a `".."` are rejected for security reasons.
+      if forbidden_request?(path)
+        return forbidden_response
+      end
+
       # Look up the asset.
       asset = find_asset(path, :bundle => !body_only?(env))
 
@@ -53,9 +53,8 @@ module Sprockets
         # Return a 404 Not Found
         not_found_response
 
-      # Check request headers `HTTP_IF_MODIFIED_SINCE` and
-      # `HTTP_IF_NONE_MATCH` against the assets mtime and digest
-      elsif not_modified?(asset, env) || etag_match?(asset, env)
+      # Check request headers `HTTP_IF_NONE_MATCH` against the asset digest
+      elsif etag_match?(asset, env)
         logger.info "#{msg} 304 Not Modified (#{time_elapsed.call}ms)"
 
         # Return a 304 Not Modified
@@ -86,12 +85,12 @@ module Sprockets
     end
 
     private
-      def forbidden_request?(env)
+      def forbidden_request?(path)
         # Prevent access to files elsewhere on the file system
         #
         #     http://example.org/assets/../../../etc/passwd
         #
-        env["PATH_INFO"].include?("..")
+        path.include?("..") || Pathname.new(path).absolute?
       end
 
       # Returns a 403 Forbidden response tuple
@@ -174,12 +173,6 @@ module Sprockets
           gsub('/',  '\\\\002f ')
       end
 
-      # Compare the requests `HTTP_IF_MODIFIED_SINCE` against the
-      # assets mtime
-      def not_modified?(asset, env)
-        env["HTTP_IF_MODIFIED_SINCE"] == asset.mtime.httpdate
-      end
-
       # Compare the requests `HTTP_IF_NONE_MATCH` against the assets digest
       def etag_match?(asset, env)
         env["HTTP_IF_NONE_MATCH"] == etag(asset)
@@ -229,7 +222,7 @@ module Sprockets
       #     # => "0aa2105d29558f3eb790d411d7d8fb66"
       #
       def path_fingerprint(path)
-        path[/-([0-9a-f]{7,40})\.[^.]+$/, 1]
+        path[/-([0-9a-f]{7,40})\.[^.]+\z/, 1]
       end
 
       # URI.unescape is deprecated on 1.9. We need to use URI::Parser

data/lib/sprockets/static_asset.rb

@@ -23,6 +23,8 @@ module Sprockets
       # Gzip contents if filename has '.gz'
       options[:compress] ||= File.extname(filename) == '.gz'
 
+      FileUtils.mkdir_p File.dirname(filename)
+
       if options[:compress]
         # Open file and run it through `Zlib`
         pathname.open('rb') do |rd|

data/lib/sprockets/utils.rb

@@ -8,19 +8,21 @@ module Sprockets
       # encoding and we want to avoid syntax errors in other interpreters.
       UTF8_BOM_PATTERN = Regexp.new("\\A\uFEFF".encode('utf-8'))
 
-      def self.read_unicode(pathname)
-        pathname.read.tap do |data|
-          # Eager validate the file's encoding. In most cases we
-          # expect it to be UTF-8 unless `default_external` is set to
-          # something else. An error is usually raised if the file is
-          # saved as UTF-16 when we expected UTF-8.
-          if !data.valid_encoding?
-            raise EncodingError, "#{pathname} has a invalid " +
-              "#{data.encoding} byte sequence"
+      def self.read_unicode(pathname, external_encoding = Encoding.default_external)
+        pathname.open("r:#{external_encoding}") do |f|
+          f.read.tap do |data|
+            # Eager validate the file's encoding. In most cases we
+            # expect it to be UTF-8 unless `default_external` is set to
+            # something else. An error is usually raised if the file is
+            # saved as UTF-16 when we expected UTF-8.
+            if !data.valid_encoding?
+              raise EncodingError, "#{pathname} has a invalid " +
+                "#{data.encoding} byte sequence"
 
-          # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
-          elsif data.encoding.name == "UTF-8" && data =~ UTF8_BOM_PATTERN
-            data.sub!(UTF8_BOM_PATTERN, "")
+            # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
+            elsif data.encoding.name == "UTF-8" && data =~ UTF8_BOM_PATTERN
+              data.sub!(UTF8_BOM_PATTERN, "")
+            end
           end
         end
       end

data/lib/sprockets/version.rb

@@ -1,3 +1,3 @@
 module Sprockets
-  VERSION = "2.1.0"
+  VERSION = "2.2.3"
 end