sprockets 1.0.2 → 2.0.0

data/lib/sprockets/asset_attributes.rb

@@ -0,0 +1,158 @@
+require 'pathname'
+
+module Sprockets
+  # `AssetAttributes` is a wrapper similar to `Pathname` that provides
+  # some helper accessors.
+  #
+  # These methods should be considered internalish.
+  class AssetAttributes
+    attr_reader :environment, :pathname
+
+    def initialize(environment, path)
+      @environment = environment
+      @pathname = path.is_a?(Pathname) ? path : Pathname.new(path.to_s)
+    end
+
+    # Replaces `$root` placeholder with actual environment root.
+    def expand_root
+      pathname.to_s.sub(/^\$root/, environment.root)
+    end
+
+    # Replaces environment root with `$root` placeholder.
+    def relativize_root
+      pathname.to_s.sub(/^#{Regexp.escape(environment.root)}/, '$root')
+    end
+
+    # Returns paths search the load path for.
+    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
+      end
+
+      paths
+    end
+
+    # Reverse guess logical path for fully expanded path.
+    #
+    # This has some known issues. For an example if a file is
+    # shaddowed in the path, but is required relatively, its logical
+    # path will be incorrect.
+    def logical_path
+      raise ArgumentError unless pathname.absolute?
+
+      if root_path = environment.paths.detect { |path| pathname.to_s[path] }
+        path = pathname.relative_path_from(Pathname.new(root_path)).to_s
+        path = engine_extensions.inject(path) { |p, ext| p.sub(ext, '') }
+        path = "#{path}#{engine_format_extension}" unless format_extension
+        path
+      end
+    end
+
+    # Returns `Array` of extension `String`s.
+    #
+    #     "foo.js.coffee"
+    #     # => [".js", ".coffee"]
+    #
+    def extensions
+      @extensions ||= @pathname.basename.to_s.scan(/\.[^.]+/)
+    end
+
+    # Returns the format extension.
+    #
+    #     "foo.js.coffee"
+    #     # => ".js"
+    #
+    def format_extension
+      extensions.detect { |ext|
+        @environment.mime_types(ext) && !@environment.engines(ext)
+      }
+    end
+
+    # Returns an `Array` of engine extensions.
+    #
+    #     "foo.js.coffee.erb"
+    #     # => [".coffee", ".erb"]
+    #
+    def engine_extensions
+      exts = extensions
+
+      if offset = extensions.index(format_extension)
+        exts = extensions[offset+1..-1]
+      end
+
+      exts.select { |ext| @environment.engines(ext) }
+    end
+
+    # Returns engine classes.
+    def engines
+      engine_extensions.map { |ext| @environment.engines(ext) }
+    end
+
+    # Returns all processors to run on the path.
+    def processors
+      environment.preprocessors(content_type) +
+        engines.reverse +
+        environment.postprocessors(content_type)
+    end
+
+    # Returns the content type for the pathname. Falls back to `application/octet-stream`.
+    def content_type
+      @content_type ||= begin
+        if format_extension.nil?
+          engine_content_type || 'application/octet-stream'
+        else
+          @environment.mime_types(format_extension) ||
+            engine_content_type ||
+            'application/octet-stream'
+        end
+      end
+    end
+
+    # Gets digest fingerprint.
+    #
+    #     "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+    #     # => "0aa2105d29558f3eb790d411d7d8fb66"
+    #
+    def path_fingerprint
+      pathname.basename(extensions.join).to_s =~ /-([0-9a-f]{7,40})$/ ? $1 : nil
+    end
+
+    # Injects digest fingerprint into path.
+    #
+    #     "foo.js"
+    #     # => "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+    #
+    def path_with_fingerprint(digest)
+      if old_digest = path_fingerprint
+        pathname.sub(old_digest, digest).to_s
+      else
+        basename = "#{pathname.basename(extensions.join)}-#{digest}#{extensions.join}"
+        pathname.dirname.to_s == '.' ? basename : pathname.dirname.join(basename).to_s
+      end
+    end
+
+    private
+      # Returns implicit engine content type.
+      #
+      # `.coffee` files carry an implicit `application/javascript`
+      # content type.
+      def engine_content_type
+        engines.reverse.each do |engine|
+          if engine.respond_to?(:default_mime_type) && engine.default_mime_type
+            return engine.default_mime_type
+          end
+        end
+        nil
+      end
+
+      def engine_format_extension
+        if content_type = engine_content_type
+          environment.extension_for_mime_type(content_type)
+        end
+      end
+  end
+end

data/lib/sprockets/base.rb

@@ -0,0 +1,163 @@
+require 'sprockets/asset_attributes'
+require 'sprockets/bundled_asset'
+require 'sprockets/caching'
+require 'sprockets/digest'
+require 'sprockets/processing'
+require 'sprockets/server'
+require 'sprockets/static_asset'
+require 'sprockets/trail'
+require 'pathname'
+
+module Sprockets
+  # `Base` class for `Environment` and `Index`.
+  class Base
+    include Digest
+    include Caching, Processing, Server, Trail
+
+    # Get and set `Logger` instance.
+    attr_accessor :logger
+
+    # Get `Context` class.
+    #
+    # This class maybe mutated and mixed in with custom helpers.
+    #
+    #     environment.context_class.instance_eval do
+    #       include MyHelpers
+    #       def asset_url; end
+    #     end
+    #
+    attr_reader :context_class
+
+    # Get persistent cache store
+    attr_reader :cache
+
+    # Set persistent cache store
+    #
+    # The cache store must implement a pair of getters and
+    # setters. Either `get(key)`/`set(key, value)`,
+    # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
+    def cache=(cache)
+      expire_index!
+      @cache = cache
+    end
+
+    # Return an `Index`. Must be implemented by the subclass.
+    def index
+      raise NotImplementedError
+    end
+
+    # Works like `Dir.entries`.
+    #
+    # Subclasses may cache this method.
+    def entries(pathname)
+      trail.entries(pathname)
+    end
+
+    # Works like `File.stat`.
+    #
+    # Subclasses may cache this method.
+    def stat(path)
+      trail.stat(path)
+    end
+
+    # Read and compute digest of filename.
+    #
+    # Subclasses may cache this method.
+    def file_digest(path, data = nil)
+      if stat = self.stat(path)
+        # `data` maybe provided
+        if data
+          digest.update(data)
+
+        # If its a file, digest the contents
+        elsif stat.file?
+          digest.file(path.to_s)
+
+        # If its a directive, digest the list of filenames
+        elsif stat.directory?
+          contents = self.entries(path).join(',')
+          digest.update(contents)
+        end
+      end
+    end
+
+    # Internal. Return a `AssetAttributes` for `path`.
+    def attributes_for(path)
+      AssetAttributes.new(self, path)
+    end
+
+    # Internal. Return content type of `path`.
+    def content_type_of(path)
+      attributes_for(path).content_type
+    end
+
+    # Find asset by logical path or expanded path.
+    def find_asset(path, options = {})
+      pathname = Pathname.new(path)
+
+      if pathname.absolute?
+        build_asset(attributes_for(pathname).logical_path, pathname, options)
+      else
+        find_asset_in_path(pathname, options)
+      end
+    end
+
+    # Preferred `find_asset` shorthand.
+    #
+    #     environment['application.js']
+    #
+    def [](*args)
+      find_asset(*args)
+    end
+
+    def each_file
+      return to_enum(__method__) unless block_given?
+      paths.each do |base_path|
+        Dir["#{base_path}/**/*"].each do |filename|
+          yield filename unless File.directory?(filename)
+        end
+      end
+      nil
+    end
+
+    def each_logical_path
+      return to_enum(__method__) unless block_given?
+      files = {}
+      each_file do |filename|
+        logical_path = attributes_for(filename).logical_path
+        yield logical_path unless files[logical_path]
+        files[logical_path] = true
+      end
+      nil
+    end
+
+    # Pretty inspect
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} " +
+        "root=#{root.to_s.inspect}, " +
+        "paths=#{paths.inspect}, " +
+        "digest=#{digest.to_s.inspect}" +
+        ">"
+    end
+
+    protected
+      # Clear index after mutating state. Must be implemented by the subclass.
+      def expire_index!
+        raise NotImplementedError
+      end
+
+      def build_asset(logical_path, pathname, options)
+        pathname = Pathname.new(pathname)
+
+        return unless stat(pathname)
+
+        # If there are any processors to run on the pathname, use
+        # `BundledAsset`. Otherwise use `StaticAsset` and treat is as binary.
+        if attributes_for(pathname).processors.any?
+          BundledAsset.new(self, logical_path, pathname, options)
+        else
+          StaticAsset.new(self, logical_path, pathname)
+        end
+      end
+  end
+end

data/lib/sprockets/bundled_asset.rb

@@ -0,0 +1,258 @@
+require 'sprockets/asset'
+require 'sprockets/errors'
+require 'fileutils'
+require 'set'
+require 'zlib'
+
+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
+
+    def initialize(environment, logical_path, pathname, options)
+      super(environment, logical_path, pathname)
+      @options = options || {}
+    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]
+      }
+
+      @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)
+      end
+    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']))
+      }
+    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']
+    end
+
+    # Return an `Array` of `Asset` files that are declared dependencies.
+    def dependencies
+      to_a - [self]
+    end
+
+    # Expand asset into an `Array` of parts.
+    def to_a
+      @assets ||= build_dependencies_paths_and_assets[1]
+    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}+")
+    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