sprockets 2.2.3 → 2.12.5

data/lib/sprockets/base.rb

@@ -1,24 +1,24 @@
 require 'sprockets/asset_attributes'
 require 'sprockets/bundled_asset'
 require 'sprockets/caching'
+require 'sprockets/errors'
 require 'sprockets/processed_asset'
-require 'sprockets/processing'
 require 'sprockets/server'
 require 'sprockets/static_asset'
-require 'sprockets/trail'
+require 'multi_json'
 require 'pathname'
 
 module Sprockets
   # `Base` class for `Environment` and `Index`.
   class Base
-    include Caching, Processing, Server, Trail
+    include Caching, Paths, Mime, Processing, Compressing, Engines, Server
 
     # Returns a `Digest` implementation class.
     #
     # Defaults to `Digest::MD5`.
     attr_reader :digest_class
 
-    # Assign a `Digest` implementation class. This maybe any Ruby
+    # Assign a `Digest` implementation class. This may be any Ruby
     # `Digest::` implementation such as `Digest::MD5` or
     # `Digest::SHA1`.
     #
@@ -98,6 +98,114 @@ module Sprockets
       @cache = cache
     end
 
+    def prepend_path(path)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def append_path(path)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def clear_paths
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    # Finds the expanded real path for a given logical path by
+    # searching the environment's paths.
+    #
+    #     resolve("application.js")
+    #     # => "/path/to/app/javascripts/application.js.coffee"
+    #
+    # A `FileNotFound` exception is raised if the file does not exist.
+    def resolve(logical_path, options = {})
+      # If a block is given, preform an iterable search
+      if block_given?
+        args = attributes_for(logical_path).search_paths + [options]
+        @trail.find(*args) do |path|
+          pathname = Pathname.new(path)
+          if %w( .bower.json bower.json component.json ).include?(pathname.basename.to_s)
+            bower = json_decode(pathname.read)
+            case bower['main']
+            when String
+              yield pathname.dirname.join(bower['main'])
+            when Array
+              extname = File.extname(logical_path)
+              bower['main'].each do |fn|
+                if extname == "" || extname == File.extname(fn)
+                  yield pathname.dirname.join(fn)
+                end
+              end
+            end
+          else
+            yield pathname
+          end
+        end
+      else
+        resolve(logical_path, options) do |pathname|
+          return pathname
+        end
+        raise FileNotFound, "couldn't find file '#{logical_path}'"
+      end
+    end
+
+    # Register a new mime type.
+    def register_mime_type(mime_type, ext)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      @trail.append_extension(ext)
+      super
+    end
+
+    # Registers a new Engine `klass` for `ext`.
+    def register_engine(ext, klass)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      add_engine_to_trail(ext, klass)
+      super
+    end
+
+    def register_preprocessor(mime_type, klass, &block)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def unregister_preprocessor(mime_type, klass)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def register_postprocessor(mime_type, klass, &block)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def unregister_postprocessor(mime_type, klass)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def register_bundle_processor(mime_type, klass, &block)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
+    def unregister_bundle_processor(mime_type, klass)
+      # Overrides the global behavior to expire the index
+      expire_index!
+      super
+    end
+
     # Return an `Index`. Must be implemented by the subclass.
     def index
       raise NotImplementedError
@@ -113,14 +221,14 @@ module Sprockets
     #
     # Subclasses may cache this method.
     def entries(pathname)
-      trail.entries(pathname)
+      @trail.entries(pathname)
     end
 
     # Works like `File.stat`.
     #
     # Subclasses may cache this method.
     def stat(path)
-      trail.stat(path)
+      @trail.stat(path)
     end
 
     # Read and compute digest of filename.
@@ -153,7 +261,7 @@ module Sprockets
     # Find asset by logical path or expanded path.
     def find_asset(path, options = {})
       logical_path = path
-      pathname     = Pathname.new(path)
+      pathname     = Pathname.new(path).cleanpath
 
       if pathname.absolute?
         return unless stat(pathname)
@@ -161,6 +269,16 @@ module Sprockets
       else
         begin
           pathname = resolve(logical_path)
+
+          # If logical path is missing a mime type extension, append
+          # the absolute path extname so it has one.
+          #
+          # Ensures some consistency between finding "foo/bar" vs
+          # "foo/bar.js".
+          if File.extname(logical_path) == ""
+            expanded_logical_path = attributes_for(pathname).logical_path
+            logical_path += File.extname(expanded_logical_path)
+          end
         rescue FileNotFound
           return nil
         end
@@ -210,13 +328,20 @@ module Sprockets
       nil
     end
 
-    def each_logical_path(*args)
+    def each_logical_path(*args, &block)
       return to_enum(__method__, *args) unless block_given?
       filters = args.flatten
       files = {}
       each_file do |filename|
         if logical_path = logical_path_for_filename(filename, filters)
-          yield logical_path unless files[logical_path]
+          unless files[logical_path]
+            if block.arity == 2
+              yield logical_path, filename.to_s
+            else
+              yield logical_path
+            end
+          end
+
           files[logical_path] = true
         end
       end
@@ -275,14 +400,14 @@ module Sprockets
       def logical_path_for_filename(filename, filters)
         logical_path = attributes_for(filename).logical_path.to_s
 
-        if matches_filter(filters, logical_path)
+        if matches_filter(filters, logical_path, filename)
           return logical_path
         end
 
         # If filename is an index file, retest with alias
         if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
           path = logical_path.sub(/\/index\./, '.')
-          if matches_filter(filters, path)
+          if matches_filter(filters, path, filename)
             return path
           end
         end
@@ -290,18 +415,33 @@ module Sprockets
         nil
       end
 
-      def matches_filter(filters, filename)
+      def matches_filter(filters, logical_path, filename)
         return true if filters.empty?
 
         filters.any? do |filter|
           if filter.is_a?(Regexp)
-            filter.match(filename)
+            filter.match(logical_path)
           elsif filter.respond_to?(:call)
-            filter.call(filename)
+            if filter.arity == 1
+              filter.call(logical_path)
+            else
+              filter.call(logical_path, filename.to_s)
+            end
           else
-            File.fnmatch(filter.to_s, filename)
+            File.fnmatch(filter.to_s, logical_path)
           end
         end
       end
+
+      # Feature detect newer MultiJson API
+      if MultiJson.respond_to?(:dump)
+        def json_decode(obj)
+          MultiJson.load(obj)
+        end
+      else
+        def json_decode(obj)
+          MultiJson.decode(obj)
+        end
+      end
   end
 end

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