sprockets 2.2.3 → 2.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be373494a4e64c06e55a9ad11e2c9efae09f1492
-  data.tar.gz: b683ce4b0ed64e683ea98d0b5af268bdeca3f584
+  metadata.gz: 4ac3ec814692936eab4dc58704519ca15c383880
+  data.tar.gz: 1888571f870ed8cb1a4e7a36dd78b2c7079991ed
 SHA512:
-  metadata.gz: fa430704b4ef87304b8a128cb83fbb64c66e24d0bdae3d9e9e343bbebd56bf8823f65cba4a0ad1eb33204308c814910ebdd9c2b570c33fbbf89a2fadd2383b33
-  data.tar.gz: 785eb7a9f36afa38e6f010a573240768a9620ed216f4b20614835ffe9564d258a0e5340c9e8dbf3b538e8b960d9f7fd22342581b5e597dbbfc4e892bac7f7d3a
+  metadata.gz: 5a11411a3911b1bb069ec8b350e3017d96377f70a7a41b62db3b8da1616186c57dd31a9d746f01cc7b16c1e717dd7dfcc1c513a2d92420a4ddbc7f1ee292bdb0
+  data.tar.gz: 036a48e5dc1c97776e9aa455e6b254ecfcd83edbd0cabc1c999c1b23f4881685458f9e2683c35e38d9ad72946facbefe05b2bdef962d9cc2ab9fa73c74780b82

data/README.md

@@ -159,9 +159,9 @@ variables, mixins, operations and functions.
 
 If the `less` gem is available to your application, you can use LESS
 to write CSS assets in Sprockets. Note that the LESS compiler is
-written in JavaScript, and at the time of this writing, the `less` gem
-depends on `therubyracer` which embeds the V8 JavaScript runtime in
-Ruby.
+written in JavaScript and the `less` gem (on MRI) uses `therubyracer`
+which embeds the V8 JavaScript runtime in Ruby, while on JRuby you're
+going to need `therubyrhino` gem installed.
 
 To write CSS assets with LESS, use the extension `.css.less`.
 
@@ -336,6 +336,18 @@ source file before any subsequent `require` or `include` directives.
 including it in the bundle. This is useful when you need to expire an
 asset's cache in response to a change in another file.
 
+### The `depend_on_asset` Directive ###
+
+`depend_on_asset` *path* works like `depend_on`, but operates
+recursively reading the the file and following the directives found.
+
+### The `stub` Directive ###
+
+`stub` *path* 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`.
+
 # Development #
 
 ## Contributing ##
@@ -354,7 +366,126 @@ submit a pull request.
 
 ## Version History ##
 
-**2.2.0** (Unreleased)
+**2.12.3** (October 28, 2014)
+
+* Security: Fix directory traversal bug in development mode server.
+
+**2.12.2** (September 5, 2014)
+
+* Ensure internal asset lookups calls are still restricted to load paths within
+  asset compiles. Though, you should not depend on internal asset resolves to be
+  completely restricted for security reasons. Assets themselves should be
+  considered full scripting environments with filesystem access.
+
+**2.12.1** (April 17, 2014)
+
+* Fix making manifest target directory when its different than the output directory.
+
+**2.12.0** (March 13, 2014)
+
+* Avoid context reference in SassImporter hack so its Marshallable. Fixes
+ issues with Sass 3.3.x.
+
+**2.11.0** (February 19, 2014)
+
+* Support for `.bower.json`
+
+**2.10.0** (May 24, 2013)
+
+* Support for `bower.json`
+
+**2.9.3** (April 20, 2013)
+
+* Fixed sass caching bug
+
+**2.9.2** (April 8, 2013)
+
+* Improve file freshness check performance
+* Directive processor encoding fixes
+
+**2.9.1** (April 6, 2013)
+
+* Support for Uglifier 2.x
+
+**2.9.0** (February 25, 2013)
+
+* Write out gzipped variants of bundled assets.
+
+**2.8.2** (December 10, 2012)
+
+* Fixed top level Sass constant references
+* Fixed manifest logger when environment is disabled
+
+**2.8.1** (October 31, 2012)
+
+* Fixed Sass importer bug
+
+**2.8.0** (October 16, 2012)
+
+* Allow manifest location to be seperated from output directory
+* Pass logical path and absolute path to each_logical_path iterator
+
+**2.7.0** (October 10, 2012)
+
+* Added --css-compressor and --js-compressor command line flags
+* Added css/js compressor shorthand
+* Change default manifest.json filename to be a randomized manifest-16HEXBYTES.json
+* Allow nil environment to be passed to manifest
+* Allow manifest instance to be set on rake task
+
+**2.6.0** (September 19, 2012)
+
+* Added bower component.json require support
+
+**2.5.0** (September 4, 2012)
+
+* Fixed Ruby 2.0 RegExp warning
+* Provide stubbed implementation of context *_path helpers
+* Add SassCompressor
+
+**2.4.5** (July 10, 2012)
+
+* Tweaked some logger levels
+
+**2.4.4** (July 2, 2012)
+
+* Canonicalize logical path extensions
+* Check absolute paths passed to depend_on
+
+**2.4.3** (May 16, 2012)
+
+* Exposed :sprockets in sass options
+* Include dependency paths in asset mtime
+
+**2.4.2** (May 7, 2012)
+
+* Fixed MultiJson feature detect
+
+**2.4.1** (April 26, 2012)
+
+* Fixed MultiJson API change
+* Fixed gzip mtime
+
+**2.4.0** (March 27, 2012)
+
+* Added global path registry
+* Added global processor registry
+
+**2.3.2** (March 26, 2012)
+
+* Fix Context#logical_path with dots
+
+**2.3.1** (February 11, 2012)
+
+* Added bytesize to manifest
+* Added Asset#bytesize alias
+* Security: Check path for forbidden access after unescaping
+
+**2.3.0** (January 16, 2012)
+
+* Added special Sass importer that automatically tracks any `@import`ed files.
+
+**2.2.0** (January 10, 2012)
 
 * Added `sprockets` command line utility.
 * Added rake/sprocketstask.

data/bin/sprockets

@@ -40,6 +40,14 @@ OptionParser.new do |opts|
     manifest = Sprockets::Manifest.new(environment, directory)
   end
 
+  opts.on("--css-compressor=COMPRESSOR", "Use CSS compressor") do |compressor|
+    environment.css_compressor = compressor.to_sym
+  end
+
+  opts.on("--js-compressor=COMPRESSOR", "Use JavaScript compressor") do |compressor|
+    environment.js_compressor = compressor.to_sym
+  end
+
   opts.on("--noenv", "Disables .sprocketsrc file") do
   end
 

data/lib/rake/sprocketstask.rb

@@ -37,6 +37,24 @@ module Rake
     end
     attr_writer :environment
 
+    # Returns cached indexed environment
+    def index
+      @index ||= environment.index if environment
+    end
+
+    # `Manifest` instance used for already compiled assets.
+    #
+    # Will be created by default if an environment and output
+    # directory are given
+    def manifest
+      if !@manifest.is_a?(Sprockets::Manifest) && @manifest.respond_to?(:call)
+        @manifest = @manifest.call
+      else
+        @manifest
+      end
+    end
+    attr_writer :manifest
+
     # Directory to write compiled assets too. As well as the manifest file.
     #
     #   t.output = "./public/assets"
@@ -79,6 +97,7 @@ module Rake
     def initialize(name = :assets)
       @name         = name
       @environment  = lambda { Sprockets::Environment.new(Dir.pwd) }
+      @manifest     = lambda { Sprockets::Manifest.new(index, output) }
       @logger       = Logger.new($stderr)
       @logger.level = Logger::INFO
       @keep         = 2
@@ -117,24 +136,16 @@ module Rake
     end
 
     private
-      # Returns cached indexed environment
-      def index
-        @index ||= environment.index
-      end
-
-      # Returns manifest for tasks
-      def manifest
-        @manifest ||= Sprockets::Manifest.new(index, output)
-      end
-
       # Sub out environment logger with our rake task logger that
       # writes to stderr.
       def with_logger
-        old_logger = index.logger
-        index.logger = @logger
+        if env = manifest.environment
+          old_logger = env.logger
+          env.logger = @logger
+        end
         yield
       ensure
-        index.logger = old_logger
+        env.logger = old_logger if env
       end
   end
 end

data/lib/sprockets.rb

@@ -3,7 +3,6 @@ require 'sprockets/version'
 module Sprockets
   # Environment
   autoload :Base,                    "sprockets/base"
-  autoload :Engines,                 "sprockets/engines"
   autoload :Environment,             "sprockets/environment"
   autoload :Index,                   "sprockets/index"
   autoload :Manifest,                "sprockets/manifest"
@@ -15,14 +14,16 @@ module Sprockets
   autoload :StaticAsset,             "sprockets/static_asset"
 
   # Processing
-  autoload :CharsetNormalizer,       "sprockets/charset_normalizer"
   autoload :Context,                 "sprockets/context"
-  autoload :DirectiveProcessor,      "sprockets/directive_processor"
   autoload :EcoTemplate,             "sprockets/eco_template"
   autoload :EjsTemplate,             "sprockets/ejs_template"
   autoload :JstProcessor,            "sprockets/jst_processor"
   autoload :Processor,               "sprockets/processor"
-  autoload :SafetyColons,            "sprockets/safety_colons"
+  autoload :SassCacheStore,          "sprockets/sass_cache_store"
+  autoload :SassFunctions,           "sprockets/sass_functions"
+  autoload :SassImporter,            "sprockets/sass_importer"
+  autoload :SassTemplate,            "sprockets/sass_template"
+  autoload :ScssTemplate,            "sprockets/scss_template"
 
   # Internal utilities
   autoload :ArgumentError,           "sprockets/errors"
@@ -39,8 +40,51 @@ module Sprockets
   end
 
   # Extend Sprockets module to provide global registry
-  extend Engines
-  @engines = {}
+  require 'hike'
+  require 'sprockets/engines'
+  require 'sprockets/mime'
+  require 'sprockets/processing'
+  require 'sprockets/compressing'
+  require 'sprockets/paths'
+  extend Engines, Mime, Processing, Compressing, Paths
+
+  @trail             = Hike::Trail.new(File.expand_path('..', __FILE__))
+  @mime_types        = {}
+  @engines           = {}
+  @preprocessors     = Hash.new { |h, k| h[k] = [] }
+  @postprocessors    = Hash.new { |h, k| h[k] = [] }
+  @bundle_processors = Hash.new { |h, k| h[k] = [] }
+  @compressors       = Hash.new { |h, k| h[k] = {} }
+
+  register_mime_type 'text/css', '.css'
+  register_mime_type 'application/javascript', '.js'
+
+  require 'sprockets/directive_processor'
+  register_preprocessor 'text/css',               DirectiveProcessor
+  register_preprocessor 'application/javascript', DirectiveProcessor
+
+  require 'sprockets/safety_colons'
+  register_postprocessor 'application/javascript', SafetyColons
+
+  require 'sprockets/charset_normalizer'
+  register_bundle_processor 'text/css', CharsetNormalizer
+
+  require 'sprockets/sass_compressor'
+  register_compressor 'text/css', :sass, SassCompressor
+  register_compressor 'text/css', :scss, SassCompressor
+
+  require 'sprockets/yui_compressor'
+  register_compressor 'text/css', :yui, YUICompressor
+
+  require 'sprockets/closure_compressor'
+  register_compressor 'application/javascript', :closure, ClosureCompressor
+
+  require 'sprockets/uglifier_compressor'
+  register_compressor 'application/javascript', :uglifier, UglifierCompressor
+  register_compressor 'application/javascript', :uglify, UglifierCompressor
+
+  require 'sprockets/yui_compressor'
+  register_compressor 'application/javascript', :yui, YUICompressor
 
   # Cherry pick the default Tilt engines that make sense for
   # Sprockets. We don't need ones that only generate html like HAML.
@@ -55,8 +99,8 @@ module Sprockets
 
   # CSS engines
   register_engine '.less',   Tilt::LessTemplate
-  register_engine '.sass',   Tilt::SassTemplate
-  register_engine '.scss',   Tilt::ScssTemplate
+  register_engine '.sass',   SassTemplate
+  register_engine '.scss',   ScssTemplate
 
   # Other
   register_engine '.erb',    Tilt::ERBTemplate

data/lib/sprockets/asset.rb

@@ -30,13 +30,17 @@ module Sprockets
 
     attr_reader :logical_path, :pathname
     attr_reader :content_type, :mtime, :length, :digest
+    alias_method :bytesize, :length
 
     def initialize(environment, logical_path, pathname)
+      raise ArgumentError, "Asset logical path has no extension: #{logical_path}" if File.extname(logical_path) == ""
+
       @root         = environment.root
       @logical_path = logical_path.to_s
       @pathname     = Pathname.new(pathname)
       @content_type = environment.content_type_of(pathname)
-      @mtime        = environment.stat(pathname).mtime
+      # drop precision to 1 second, same pattern followed elsewhere
+      @mtime        = Time.at(environment.stat(pathname).mtime.to_i)
       @length       = environment.stat(pathname).size
       @digest       = environment.file_digest(pathname).hexdigest
     end
@@ -55,8 +59,7 @@ module Sprockets
       end
 
       if mtime = coder['mtime']
-        # Parse time string
-        @mtime = Time.parse(mtime)
+        @mtime = Time.at(mtime)
       end
 
       if length = coder['length']
@@ -71,7 +74,7 @@ module Sprockets
       coder['logical_path'] = logical_path
       coder['pathname']     = relativize_root_path(pathname).to_s
       coder['content_type'] = content_type
-      coder['mtime']        = mtime.iso8601
+      coder['mtime']        = mtime.to_i
       coder['length']       = length
       coder['digest']       = digest
     end
@@ -144,12 +147,12 @@ module Sprockets
         if options[:compress]
           # Run contents through `Zlib`
           gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+          gz.mtime = mtime.to_i
           gz.write to_s
           gz.close
         else
           # Write out as is
           f.write to_s
-          f.close
         end
       end
 
@@ -233,7 +236,7 @@ module Sprockets
           return false
         end
 
-        # Compare dependency mime to the actual mtime. If the
+        # Compare dependency mtime to the actual mtime. If the
         # dependency mtime is newer than the actual mtime, the file
         # hasn't changed since we created this `Asset` instance.
         #
@@ -241,7 +244,11 @@ module Sprockets
         # stale. Many deployment environments may recopy or recheckout
         # assets on each deploy. In this case the mtime would be the
         # time of deploy rather than modified time.
-        if mtime >= stat.mtime
+        #
+        # Note: to_i is used in eql? and write_to we assume fidelity of 1 second
+        #  if people save files more frequently than 1 second sprockets may
+        #  not pick it up, by design
+        if mtime.to_i >= stat.mtime.to_i
           return true
         end
 

data/lib/sprockets/asset_attributes.rb

@@ -17,10 +17,21 @@ module Sprockets
     def search_paths
       paths = [pathname.to_s]
 
-      if pathname.basename(extensions.join).to_s != 'index'
-        path_without_extensions = extensions.inject(pathname) { |p, ext| p.sub(ext, '') }
-        index_path = path_without_extensions.join("index#{extensions.join}").to_s
-        paths << index_path
+      extension = format_extension
+      path_without_extension = extension ?
+        pathname.sub(extension, '') :
+        pathname
+
+      # optimization: bower.json can only be nested one level deep
+      if !path_without_extension.to_s.index('/')
+        paths << path_without_extension.join(".bower.json").to_s
+        paths << path_without_extension.join("bower.json").to_s
+        # DEPRECATED bower configuration file
+        paths << path_without_extension.join("component.json").to_s
+      end
+
+      if pathname.basename(extension.to_s).to_s != 'index'
+        paths << path_without_extension.join("index#{extension}").to_s
       end
 
       paths

data/lib/sprockets/base.rb

@@ -1,17 +1,17 @@
 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.
     #
@@ -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