sprockets 2.2.3 → 2.12.3

data/lib/sprockets/bundled_asset.rb

@@ -13,20 +13,19 @@ module Sprockets
     def initialize(environment, logical_path, pathname)
       super(environment, logical_path, pathname)
 
-      @processed_asset = environment.find_asset(pathname, :bundle => false)
-      @required_assets = @processed_asset.required_assets
-
-      @source = ""
+      @processed_asset  = environment.find_asset(pathname, :bundle => false)
+      @required_assets  = @processed_asset.required_assets
+      @dependency_paths = @processed_asset.dependency_paths
 
       # Explode Asset into parts and gather the dependency bodies
-      to_a.each { |dependency| @source << dependency.to_s }
+      @source = to_a.map { |dependency| dependency.to_s }.join
 
       # Run bundle processors on concatenated source
       context = environment.context_class.new(environment, logical_path, pathname)
       @source = context.evaluate(pathname, :data => @source,
                   :processors => environment.bundle_processors(content_type))
 
-      @mtime  = to_a.map(&:mtime).max
+      @mtime  = (to_a + @dependency_paths).map(&:mtime).max
       @length = Rack::Utils.bytesize(source)
       @digest = environment.digest.update(source).hexdigest
     end

data/lib/sprockets/caching.rb

@@ -2,6 +2,45 @@ module Sprockets
   # `Caching` is an internal mixin whose public methods are exposed on
   # the `Environment` and `Index` classes.
   module Caching
+    # Low level cache getter for `key`. Checks a number of supported
+    # cache interfaces.
+    def cache_get(key)
+      # `Cache#get(key)` for Memcache
+      if cache.respond_to?(:get)
+        cache.get(key)
+
+      # `Cache#[key]` so `Hash` can be used
+      elsif cache.respond_to?(:[])
+        cache[key]
+
+      # `Cache#read(key)` for `ActiveSupport::Cache` support
+      elsif cache.respond_to?(:read)
+        cache.read(key)
+
+      else
+        nil
+      end
+    end
+
+    # Low level cache setter for `key`. Checks a number of supported
+    # cache interfaces.
+    def cache_set(key, value)
+      # `Cache#set(key, value)` for Memcache
+      if cache.respond_to?(:set)
+        cache.set(key, value)
+
+      # `Cache#[key]=value` so `Hash` can be used
+      elsif cache.respond_to?(:[]=)
+        cache[key] = value
+
+      # `Cache#write(key, value)` for `ActiveSupport::Cache` support
+      elsif cache.respond_to?(:write)
+        cache.write(key, value)
+      end
+
+      value
+    end
+
     protected
       # Cache helper method. Takes a `path` argument which maybe a
       # logical path or fully expanded path. The `&block` is passed
@@ -53,44 +92,5 @@ module Sprockets
         cache_set(expand_cache_key(key), hash)
         hash
       end
-
-      # Low level cache getter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_get(key)
-        # `Cache#get(key)` for Memcache
-        if cache.respond_to?(:get)
-          cache.get(key)
-
-        # `Cache#[key]` so `Hash` can be used
-        elsif cache.respond_to?(:[])
-          cache[key]
-
-        # `Cache#read(key)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:read)
-          cache.read(key)
-
-        else
-          nil
-        end
-      end
-
-      # Low level cache setter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_set(key, value)
-        # `Cache#set(key, value)` for Memcache
-        if cache.respond_to?(:set)
-          cache.set(key, value)
-
-        # `Cache#[key]=value` so `Hash` can be used
-        elsif cache.respond_to?(:[]=)
-          cache[key] = value
-
-        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:write)
-          cache.write(key, value)
-        end
-
-        value
-      end
   end
 end

data/lib/sprockets/closure_compressor.rb

@@ -0,0 +1,22 @@
+require 'tilt'
+
+module Sprockets
+  class ClosureCompressor < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def self.engine_initialized?
+      defined?(::Closure::Compiler)
+    end
+
+    def initialize_engine
+      require_template_library 'closure-compiler'
+    end
+
+    def prepare
+    end
+
+    def evaluate(context, locals, &block)
+      Closure::Compiler.new.compile(data)
+    end
+  end
+end

data/lib/sprockets/compressing.rb

@@ -0,0 +1,73 @@
+module Sprockets
+  # `Compressing` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `Index` classes.
+  module Compressing
+    def compressors
+      deep_copy_hash(@compressors)
+    end
+
+    def register_compressor(mime_type, sym, klass)
+      @compressors[mime_type][sym] = klass
+    end
+
+    # Return CSS compressor or nil if none is set
+    def css_compressor
+      @css_compressor if defined? @css_compressor
+    end
+
+    # Assign a compressor to run on `text/css` assets.
+    #
+    # The compressor object must respond to `compress`.
+    def css_compressor=(compressor)
+      unregister_bundle_processor 'text/css', css_compressor if css_compressor
+      @css_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        compressor = compressors['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      end
+
+      if compressor.respond_to?(:compress)
+        klass = Class.new(Processor) do
+          @name = "css_compressor"
+          @processor = proc { |context, data| compressor.compress(data) }
+        end
+        @css_compressor = :css_compressor
+      else
+        @css_compressor = klass = compressor
+      end
+
+      register_bundle_processor 'text/css', klass
+    end
+
+    # Return JS compressor or nil if none is set
+    def js_compressor
+      @js_compressor if defined? @js_compressor
+    end
+
+    # Assign a compressor to run on `application/javascript` assets.
+    #
+    # The compressor object must respond to `compress`.
+    def js_compressor=(compressor)
+      unregister_bundle_processor 'application/javascript', js_compressor if js_compressor
+      @js_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        compressor = compressors['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      end
+
+      if compressor.respond_to?(:compress)
+        klass = Class.new(Processor) do
+          @name = "js_compressor"
+          @processor = proc { |context, data| compressor.compress(data) }
+        end
+        @js_compressor = :js_compressor
+      else
+        @js_compressor = klass = compressor
+      end
+
+      register_bundle_processor 'application/javascript', klass
+    end
+  end
+end

data/lib/sprockets/context.rb

@@ -53,7 +53,7 @@ module Sprockets
     #     # => 'application'
     #
     def logical_path
-      @logical_path[/^([^.]+)/, 0]
+      @logical_path.chomp(File.extname(@logical_path))
     end
 
     # Returns content type of file
@@ -81,7 +81,11 @@ module Sprockets
       attributes = environment.attributes_for(pathname)
 
       if pathname.absolute?
-        pathname
+        if environment.stat(pathname)
+          pathname
+        else
+          raise FileNotFound, "couldn't find file '#{pathname}'"
+        end
 
       elsif content_type = options[:content_type]
         content_type = self.content_type if content_type == :self
@@ -101,7 +105,7 @@ module Sprockets
 
         raise FileNotFound, "couldn't find file '#{path}'"
       else
-        environment.resolve(path, :base_path => self.pathname.dirname, &block)
+        environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
       end
     end
 
@@ -217,6 +221,56 @@ module Sprockets
       "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
     end
 
+    # Expands logical path to full url to asset.
+    #
+    # NOTE: This helper is currently not implemented and should be
+    # customized by the application. Though, in the future, some
+    # basics implemention may be provided with different methods that
+    # are required to be overridden.
+    def asset_path(path, options = {})
+      message = <<-EOS
+Custom asset_path helper is not implemented
+
+Extend your environment context with a custom method.
+
+    environment.context_class.class_eval do
+      def asset_path(path, options = {})
+      end
+    end
+      EOS
+      raise NotImplementedError, message
+    end
+
+    # Expand logical image asset path.
+    def image_path(path)
+      asset_path(path, :type => :image)
+    end
+
+    # Expand logical video asset path.
+    def video_path(path)
+      asset_path(path, :type => :video)
+    end
+
+    # Expand logical audio asset path.
+    def audio_path(path)
+      asset_path(path, :type => :audio)
+    end
+
+    # Expand logical font asset path.
+    def font_path(path)
+      asset_path(path, :type => :font)
+    end
+
+    # Expand logical javascript asset path.
+    def javascript_path(path)
+      asset_path(path, :type => :javascript)
+    end
+
+    # Expand logical stylesheet asset path.
+    def stylesheet_path(path)
+      asset_path(path, :type => :stylesheet)
+    end
+
     private
       # Annotates exception backtrace with the original template that
       # the exception was raised in.

data/lib/sprockets/directive_processor.rb

@@ -65,7 +65,7 @@ module Sprockets
     #     //= require "foo"
     #
     DIRECTIVE_PATTERN = /
-      ^ [\W]* = \s* (\w+.*?) (\*\/)? $
+      ^ \W* = \s* (\w+.*?) (\*\/)? $
     /x
 
     attr_reader :pathname
@@ -92,6 +92,8 @@ module Sprockets
       @context = context
 
       @result = ""
+      @result.force_encoding(body.encoding) if body.respond_to?(:encoding)
+
       @has_written_body = false
 
       process_directives

data/lib/sprockets/engines.rb

@@ -28,12 +28,12 @@ module Sprockets
   #     Sprockets.register_engine '.sass', SassTemplate
   #
   module Engines
-    # Returns an `Array` of `Engine`s registered on the
-    # `Environment`. If an `ext` argument is supplied, the `Engine`
-    # register under that extension will be returned.
+    # Returns a `Hash` of `Engine`s registered on the `Environment`.
+    # If an `ext` argument is supplied, the `Engine` associated with
+    # that extension will be returned.
     #
     #     environment.engines
-    #     # => [CoffeeScriptTemplate, SassTemplate, ...]
+    #     # => {".coffee" => CoffeeScriptTemplate, ".sass" => SassTemplate, ...}
     #
     #     environment.engines('.coffee')
     #     # => CoffeeScriptTemplate

data/lib/sprockets/environment.rb

@@ -1,9 +1,6 @@
 require 'sprockets/base'
-require 'sprockets/charset_normalizer'
 require 'sprockets/context'
-require 'sprockets/directive_processor'
 require 'sprockets/index'
-require 'sprockets/safety_colons'
 
 require 'hike'
 require 'logger'
@@ -35,24 +32,24 @@ module Sprockets
       @digest_class = ::Digest::MD5
       @version = ''
 
-      @mime_types        = {}
+      @mime_types        = Sprockets.registered_mime_types
       @engines           = Sprockets.engines
-      @preprocessors     = Hash.new { |h, k| h[k] = [] }
-      @postprocessors    = Hash.new { |h, k| h[k] = [] }
-      @bundle_processors = Hash.new { |h, k| h[k] = [] }
+      @preprocessors     = Sprockets.preprocessors
+      @postprocessors    = Sprockets.postprocessors
+      @bundle_processors = Sprockets.bundle_processors
+      @compressors       = Sprockets.compressors
+
+      Sprockets.paths.each do |path|
+        append_path(path)
+      end
 
       @engines.each do |ext, klass|
         add_engine_to_trail(ext, klass)
       end
 
-      register_mime_type 'text/css', '.css'
-      register_mime_type 'application/javascript', '.js'
-
-      register_preprocessor 'text/css', DirectiveProcessor
-      register_preprocessor 'application/javascript', DirectiveProcessor
-
-      register_postprocessor 'application/javascript', SafetyColons
-      register_bundle_processor 'text/css', CharsetNormalizer
+      @mime_types.each do |ext, type|
+        @trail.append_extension(ext)
+      end
 
       expire_index!
 

data/lib/sprockets/errors.rb

@@ -7,6 +7,7 @@ module Sprockets
   class EncodingError           < Error; end
   class FileNotFound            < Error; end
   class FileOutsidePaths        < Error; end
+  class NotImplementedError     < Error; end
   class UnserializeError        < Error; end
 
   module EngineError

data/lib/sprockets/index.rb

@@ -31,6 +31,7 @@ module Sprockets
       @preprocessors     = environment.preprocessors
       @postprocessors    = environment.postprocessors
       @bundle_processors = environment.bundle_processors
+      @compressors       = environment.compressors
 
       # Initialize caches
       @assets  = {}

data/lib/sprockets/jst_processor.rb

@@ -2,9 +2,7 @@ require 'tilt'
 
 module Sprockets
   class JstProcessor < Tilt::Template
-    def self.default_mime_type
-      'application/javascript'
-    end
+    self.default_mime_type = 'application/javascript'
 
     def self.default_namespace
       'this.JST'
@@ -18,9 +16,7 @@ module Sprockets
 
     def evaluate(scope, locals, &block)
       <<-JST
-(function() {
-  #{namespace} || (#{namespace} = {});
-  #{namespace}[#{scope.logical_path.inspect}] = #{indent(data)};
+(function() { #{namespace} || (#{namespace} = {}); #{namespace}[#{scope.logical_path.inspect}] = #{indent(data)};
 }).call(this);
       JST
     end

data/lib/sprockets/manifest.rb

@@ -1,4 +1,5 @@
 require 'multi_json'
+require 'securerandom'
 require 'time'
 
 module Sprockets
@@ -18,26 +19,50 @@ module Sprockets
     # 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.
+    # filename will default a random "manifest-123.json" file in that
+    # directory.
     #
     #   Manifest.new(environment, "./public/assets/manifest.json")
     #
-    def initialize(environment, path)
-      @environment = environment
+    def initialize(*args)
+      if args.first.is_a?(Base) || args.first.nil?
+        @environment = args.shift
+      end
 
-      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)
+      @dir, @path = args[0], args[1]
+
+      # Expand paths
+      @dir  = File.expand_path(@dir) if @dir
+      @path = File.expand_path(@path) if @path
+
+      # If path is given as the second arg
+      if @dir && File.extname(@dir) != ""
+        @dir, @path = nil, @dir
+      end
+
+      # Default dir to the directory of the path
+      @dir ||= File.dirname(@path) if @path
+
+      # If directory is given w/o path, pick a random manifest.json location
+      if @dir && @path.nil?
+        # Find the first manifest.json in the directory
+        paths = Dir[File.join(@dir, "manifest*.json")]
+        if paths.any?
+          @path = paths.first
+        else
+          @path = File.join(@dir, "manifest-#{SecureRandom.hex(16)}.json")
+        end
+      end
+
+      unless @dir && @path
+        raise ArgumentError, "manifest requires output path"
       end
 
       data = nil
 
       begin
         if File.exist?(@path)
-          data = MultiJson.decode(File.read(@path))
+          data = json_decode(File.read(@path))
         end
       rescue MultiJson::DecodeError => e
         logger.error "#{@path} is invalid: #{e.class} #{e.message}"
@@ -83,14 +108,19 @@ module Sprockets
     #   compile("application.js")
     #
     def compile(*args)
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
       paths = environment.each_logical_path(*args).to_a +
-        args.flatten.select { |fn| Pathname.new(fn).absolute? }
+        args.flatten.select { |fn| Pathname.new(fn).absolute? if fn.is_a?(String)}
 
       paths.each do |path|
         if asset = find_asset(path)
           files[asset.digest_path] = {
             'logical_path' => asset.logical_path,
             'mtime'        => asset.mtime.iso8601,
+            'size'         => asset.bytesize,
             'digest'       => asset.digest
           }
           assets[asset.logical_path] = asset.digest_path
@@ -102,12 +132,13 @@ module Sprockets
           else
             logger.info "Writing #{target}"
             asset.write_to target
+            asset.write_to "#{target}.gz" if asset.is_a?(BundledAsset)
           end
 
-          save
-          asset
         end
       end
+      save
+      paths
     end
 
     # Removes file from directory and from manifest. `filename` must
@@ -117,6 +148,7 @@ module Sprockets
     #
     def remove(filename)
       path = File.join(dir, filename)
+      gzip = "#{path}.gz"
       logical_path = files[filename]['logical_path']
 
       if assets[logical_path] == filename
@@ -125,10 +157,11 @@ module Sprockets
 
       files.delete(filename)
       FileUtils.rm(path) if File.exist?(path)
+      FileUtils.rm(gzip) if File.exist?(gzip)
 
       save
 
-      logger.warn "Removed #{filename}"
+      logger.info "Removed #{filename}"
 
       nil
     end
@@ -151,7 +184,7 @@ module Sprockets
     # Wipe directive
     def clobber
       FileUtils.rm_r(@dir) if File.exist?(@dir)
-      logger.warn "Removed #{@dir}"
+      logger.info "Removed #{@dir}"
       nil
     end
 
@@ -177,21 +210,46 @@ module Sprockets
         ms = benchmark do
           asset = environment.find_asset(logical_path)
         end
-        logger.warn "Compiled #{logical_path}  (#{ms}ms)"
+        logger.debug "Compiled #{logical_path}  (#{ms}ms)"
         asset
       end
 
       # Persist manfiest back to FS
       def save
-        FileUtils.mkdir_p dir
+        FileUtils.mkdir_p File.dirname(path)
         File.open(path, 'w') do |f|
-          f.write MultiJson.encode(@data)
+          f.write json_encode(@data)
         end
       end
 
     private
+      # Feature detect newer MultiJson API
+      if MultiJson.respond_to?(:dump)
+        def json_decode(obj)
+          MultiJson.load(obj)
+        end
+
+        def json_encode(obj)
+          MultiJson.dump(obj)
+        end
+      else
+        def json_decode(obj)
+          MultiJson.decode(obj)
+        end
+
+        def json_encode(obj)
+          MultiJson.encode(obj)
+        end
+      end
+
       def logger
-        environment.logger
+        if environment
+          environment.logger
+        else
+          logger = Logger.new($stderr)
+          logger.level = Logger::FATAL
+          logger
+        end
       end
 
       def benchmark