sprockets 2.0.5 → 2.1.0.beta

data/lib/sprockets/bundled_asset.rb

@@ -8,251 +8,72 @@ module Sprockets
   # `BundledAsset`s are used for files that need to be processed and
   # concatenated with other assets. Use for `.js` and `.css` files.
   class BundledAsset < Asset
-    # Define extra attributes to be serialized.
-    def self.serialized_attributes
-      super + %w( content_type mtime )
-    end
+    attr_reader :source
 
-    def initialize(environment, logical_path, pathname, options)
+    def initialize(environment, logical_path, pathname)
       super(environment, logical_path, pathname)
-      @options = options || {}
+
+      @processed_asset = environment.find_asset(pathname, :bundle => false)
+      @required_assets = @processed_asset.required_assets
+
+      @source = ""
+
+      # Explode Asset into parts and gather the dependency bodies
+      to_a.each { |dependency| @source << dependency.to_s }
+
+      # 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
+      @length = Rack::Utils.bytesize(source)
+      @digest = environment.digest.update(source).hexdigest
     end
 
     # Initialize `BundledAsset` from serialized `Hash`.
     def init_with(environment, coder)
-      @options = {}
-
       super
 
-      @body   = coder['body']
-      @assets = coder['asset_paths'].map { |p|
-        p = expand_root_path(p)
-        p == pathname.to_s ? self : environment[p, @options]
-      }
+      @processed_asset = environment.find_asset(pathname, :bundle => false)
+      @required_assets = @processed_asset.required_assets
 
-      @dependency_paths = coder['dependency_paths'].map { |h|
-        h.merge('path' => expand_root_path(h['path']))
-      }
-      @dependency_paths.each do |dep|
-        dep['mtime'] = Time.parse(dep['mtime']) if dep['mtime'].is_a?(String)
+      if @processed_asset.dependency_digest != coder['required_assets_digest']
+        raise UnserializeError, "processed asset belongs to a stale environment"
       end
+
+      @source = coder['source']
     end
 
     # Serialize custom attributes in `BundledAsset`.
     def encode_with(coder)
       super
 
-      coder['body']        = body
-      coder['asset_paths'] = to_a.map { |a| relativize_root_path(a.pathname) }
-      coder['dependency_paths'] = dependency_paths.map { |h|
-        h.merge('path' => relativize_root_path(h['path']))
-      }
+      coder['source'] = source
+      coder['required_assets_digest'] = @processed_asset.dependency_digest
     end
 
     # Get asset's own processed contents. Excludes any of its required
     # dependencies but does run any processors or engines on the
     # original file.
     def body
-      @body ||= build_dependency_context_and_body[1]
-    end
-
-    # Get latest mtime of all its dependencies.
-    def mtime
-      @mtime ||= dependency_paths.map { |h| h['mtime'] }.max
-    end
-
-    # Get size of concatenated source.
-    def length
-      @length ||= build_source['length']
-    end
-
-    # Compute digest of concatenated source.
-    def digest
-      @digest ||= build_source['digest']
+      @processed_asset.source
     end
 
     # Return an `Array` of `Asset` files that are declared dependencies.
     def dependencies
-      to_a - [self]
+      to_a.reject { |a| a.eql?(@processed_asset) }
     end
 
     # Expand asset into an `Array` of parts.
     def to_a
-      @assets ||= build_dependencies_paths_and_assets[1]
+      required_assets
     end
 
     # Checks if Asset is stale by comparing the actual mtime and
     # digest to the inmemory model.
-    def fresh?
-      # Check freshness of all declared dependencies
-      dependency_paths.all? { |h| dependency_fresh?(h) }
-    end
-
-    # Return `String` of concatenated source.
-    def to_s
-      @source ||= build_source['source']
-    end
-
-    # Save asset to disk.
-    def write_to(filename, options = {})
-      # Gzip contents if filename has '.gz'
-      options[:compress] ||= File.extname(filename) == '.gz'
-
-      File.open("#{filename}+", 'wb') do |f|
-        if options[:compress]
-          # Run contents through `Zlib`
-          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
-          gz.write to_s
-          gz.close
-        else
-          # Write out as is
-          f.write to_s
-          f.close
-        end
-      end
-
-      # Atomic write
-      FileUtils.mv("#{filename}+", filename)
-
-      # Set mtime correctly
-      File.utime(mtime, mtime, filename)
-
-      nil
-    ensure
-      # Ensure tmp file gets cleaned up
-      FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
+    def fresh?(environment)
+      @processed_asset.fresh?(environment)
     end
-
-    protected
-      # Return new blank `Context` to evaluate processors in.
-      def blank_context
-        environment.context_class.new(environment, logical_path.to_s, pathname)
-      end
-
-      # Get `Context` after processors have been ran on it. This
-      # trackes any dependencies that processors have added to it.
-      def dependency_context
-        @dependency_context ||= build_dependency_context_and_body[0]
-      end
-
-      # All paths that this asset depends on. This list may include
-      # non-assets like directories.
-      def dependency_paths
-        @dependency_paths ||= build_dependencies_paths_and_assets[0]
-      end
-
-    private
-      def logger
-        environment.logger
-      end
-
-      # Check if self has already been required and raise a fast
-      # error. Otherwise you end up with a StackOverflow error.
-      def check_circular_dependency!
-        requires = @options[:_requires] ||= []
-        if requires.include?(pathname.to_s)
-          raise CircularDependencyError, "#{pathname} has already been required"
-        end
-        requires << pathname.to_s
-      end
-
-      def build_dependency_context_and_body
-        start_time = Time.now.to_f
-
-        context = blank_context
-
-        # Read original data once and pass it along to `Context`
-        data = Sprockets::Utils.read_unicode(pathname)
-
-        # Prime digest cache with data, since we happen to have it
-        environment.file_digest(pathname, data)
-
-        # Runs all processors on `Context`
-        body = context.evaluate(pathname, :data => data)
-
-        @dependency_context, @body = context, body
-
-        elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
-        logger.info "Compiled #{logical_path}  (#{elapsed_time}ms)  (pid #{Process.pid})"
-
-        return context, body
-      end
-
-      def build_dependencies_paths_and_assets
-        check_circular_dependency!
-
-        paths, assets = {}, []
-
-        # Define an `add_dependency` helper
-        add_dependency = lambda do |asset|
-          unless assets.any? { |a| a.pathname == asset.pathname }
-            assets << asset
-          end
-        end
-
-        # Iterate over all the declared require paths from the `Context`
-        dependency_context._required_paths.each do |required_path|
-          # Catch `require_self`
-          if required_path == pathname.to_s
-            add_dependency.call(self)
-          else
-            # Recursively lookup required asset
-            environment[required_path, @options].to_a.each do |asset|
-              add_dependency.call(asset)
-            end
-          end
-        end
-
-        # Ensure self is added to the dependency list
-        add_dependency.call(self)
-
-        dependency_context._dependency_paths.each do |path|
-          paths[path] ||= {
-            'path'      => path,
-            'mtime'     => environment.stat(path).mtime,
-            'hexdigest' => environment.file_digest(path).hexdigest
-          }
-        end
-
-        dependency_context._dependency_assets.each do |path|
-          # Skip if depending on self
-          next if path == pathname.to_s
-
-          # Recursively lookup required asset
-          environment[path, @options].to_a.each do |asset|
-            asset.dependency_paths.each do |dep|
-              paths[dep['path']] ||= dep
-            end
-          end
-        end
-
-        @dependency_paths, @assets = paths.values, assets
-
-        return @dependency_paths, @assets
-      end
-
-      def build_source
-        hash = environment.cache_hash("#{pathname}:source", id) do
-          data = ""
-
-          # Explode Asset into parts and gather the dependency bodies
-          to_a.each { |dependency| data << dependency.body }
-
-          # Run bundle processors on concatenated source
-          data = blank_context.evaluate(pathname, :data => data,
-            :processors => environment.bundle_processors(content_type))
-
-          { 'length' => Rack::Utils.bytesize(data),
-            'digest' => environment.digest.update(data).hexdigest,
-            'source' => data }
-        end
-        hash['length'] = Integer(hash['length']) if hash['length'].is_a?(String)
-
-        @length = hash['length']
-        @digest = hash['digest']
-        @source = hash['source']
-
-        hash
-      end
   end
 end

data/lib/sprockets/cache/file_store.rb

@@ -18,24 +18,15 @@ module Sprockets
 
       # Lookup value in cache
       def [](key)
-        pathname = path_for(key)
+        pathname = @root.join(key)
         pathname.exist? ? pathname.open('rb') { |f| Marshal.load(f) } : nil
       end
 
       # Save value to cache
       def []=(key, value)
-        path_for(key).open('w') { |f| Marshal.dump(value, f)}
+        @root.join(key).open('w') { |f| Marshal.dump(value, f)}
         value
       end
-
-      private
-        # Returns path for cache key.
-        #
-        # The key may include some funky characters so hash it into
-        # safe hex.
-        def path_for(key)
-          @root.join(::Digest::MD5.hexdigest(key))
-        end
     end
   end
 end

data/lib/sprockets/caching.rb

@@ -1,38 +1,7 @@
-require 'sprockets/bundled_asset'
-require 'sprockets/static_asset'
-
 module Sprockets
   # `Caching` is an internal mixin whose public methods are exposed on
   # the `Environment` and `Index` classes.
   module Caching
-    # Return `Asset` instance for serialized `Hash`.
-    def asset_from_hash(hash)
-      return unless hash.is_a?(Hash)
-      case hash['class']
-      when 'BundledAsset'
-        BundledAsset.from_hash(self, hash)
-      when 'StaticAsset'
-        StaticAsset.from_hash(self, hash)
-      else
-        nil
-      end
-    rescue Exception => e
-      logger.debug "Cache for Asset (#{hash['logical_path']}) is stale"
-      logger.debug e
-      nil
-    end
-
-    def cache_hash(key, version)
-      if cache.nil?
-        yield
-      elsif hash = cache_get_hash(key, version)
-        hash
-      elsif hash = yield
-        cache_set_hash(key, version, hash)
-        hash
-      end
-    end
-
     protected
       # Cache helper method. Takes a `path` argument which maybe a
       # logical path or fully expanded path. The `&block` is passed
@@ -43,7 +12,7 @@ module Sprockets
           yield
 
         # Check cache for `path`
-        elsif (asset = asset_from_hash(cache_get_hash(path.to_s, digest.hexdigest))) && asset.fresh?
+        elsif (asset = Asset.from_hash(self, cache_get_hash(path.to_s))) && asset.fresh?(self)
           asset
 
          # Otherwise yield block that slowly finds and builds the asset
@@ -52,12 +21,12 @@ module Sprockets
           asset.encode_with(hash)
 
           # Save the asset to its path
-          cache_set_hash(path.to_s, digest.hexdigest, hash)
+          cache_set_hash(path.to_s, hash)
 
           # Since path maybe a logical or full pathname, save the
           # asset its its full path too
           if path.to_s != asset.pathname.to_s
-            cache_set_hash(asset.pathname.to_s, digest.hexdigest, hash)
+            cache_set_hash(asset.pathname.to_s, hash)
           end
 
           asset
@@ -68,20 +37,20 @@ module Sprockets
       # Strips `Environment#root` from key to make the key work
       # consisently across different servers. The key is also hashed
       # so it does not exceed 250 characters.
-      def cache_key_for(key)
-        File.join('sprockets', digest.hexdigest(key.sub(root, '')))
+      def expand_cache_key(key)
+        File.join('sprockets', digest_class.hexdigest(key.sub(root, '')))
       end
 
-      def cache_get_hash(key, version)
-        hash = cache_get(cache_key_for(key))
-        if hash.is_a?(Hash) && version == hash['_version']
+      def cache_get_hash(key)
+        hash = cache_get(expand_cache_key(key))
+        if hash.is_a?(Hash) && digest.hexdigest == hash['_version']
           hash
         end
       end
 
-      def cache_set_hash(key, version, hash)
-        hash['_version'] = version
-        cache_set(cache_key_for(key), hash)
+      def cache_set_hash(key, hash)
+        hash['_version'] = digest.hexdigest
+        cache_set(expand_cache_key(key), hash)
         hash
       end
 

data/lib/sprockets/context.rb

@@ -32,8 +32,8 @@ module Sprockets
       @__LINE__     = nil
 
       @_required_paths    = []
-      @_dependency_paths  = Set.new([pathname.to_s])
-      @_dependency_assets = Set.new
+      @_dependency_paths  = Set.new
+      @_dependency_assets = Set.new([pathname.to_s])
     end
 
     # Returns the environment path that contains the file.
@@ -78,7 +78,7 @@ module Sprockets
       pathname   = Pathname.new(path)
       attributes = environment.attributes_for(pathname)
 
-      if pathname.absolute?
+      if pathname.to_s =~ /^\//
         pathname
 
       elsif content_type = options[:content_type]
@@ -148,7 +148,9 @@ module Sprockets
     def asset_requirable?(path)
       pathname = resolve(path)
       content_type = environment.content_type_of(pathname)
-      pathname.file? && (self.content_type.nil? || self.content_type == content_type)
+      stat = environment.stat(path)
+      return false unless stat && stat.file?
+      self.content_type.nil? || self.content_type == content_type
     end
 
     # Reads `path` and runs processors on the file.
@@ -193,7 +195,7 @@ module Sprockets
     #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
     #
     def asset_data_uri(path)
-      depend_on(path)
+      depend_on_asset(path)
       asset  = environment.find_asset(path)
       base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
       "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"

data/lib/sprockets/engines.rb

@@ -71,28 +71,4 @@ module Sprockets
         hash.inject(initial) { |h, (k, a)| h[k] = a.dup; h }
       end
   end
-
-  # Extend Sprockets module to provide global registry
-  extend Engines
-  @engines = {}
-
-  # Cherry pick the default Tilt engines that make sense for
-  # Sprockets. We don't need ones that only generate html like HAML.
-
-  # Mmm, CoffeeScript
-  register_engine '.coffee', Tilt::CoffeeScriptTemplate
-
-  # JST engines
-  register_engine '.jst',    JstProcessor
-  register_engine '.eco',    EcoTemplate
-  register_engine '.ejs',    EjsTemplate
-
-  # CSS engines
-  register_engine '.less',   Tilt::LessTemplate
-  register_engine '.sass',   Tilt::SassTemplate
-  register_engine '.scss',   Tilt::ScssTemplate
-
-  # Other
-  register_engine '.erb',    Tilt::ERBTemplate
-  register_engine '.str',    Tilt::StringTemplate
 end