sprockets 1.0.2 → 2.0.0

data/lib/sprockets/cache/file_store.rb

@@ -0,0 +1,41 @@
+require 'digest/md5'
+require 'fileutils'
+require 'pathname'
+
+module Sprockets
+  module Cache
+    # A simple file system cache store.
+    #
+    #     environment.cache = Sprockets::Cache::FileStore.new("tmp/sprockets")
+    #
+    class FileStore
+      def initialize(root)
+        @root = Pathname.new(root)
+
+        # Ensure directory exists
+        FileUtils.mkdir_p @root
+      end
+
+      # Lookup value in cache
+      def [](key)
+        pathname = path_for(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)}
+        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

@@ -0,0 +1,123 @@
+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
+    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
+      # for finding and building the asset if its not in cache.
+      def cache_asset(path)
+        # If `cache` is not set, return fast
+        if cache.nil?
+          yield
+
+        # Check cache for `path`
+        elsif (asset = asset_from_hash(cache_get_hash(path.to_s, digest.hexdigest))) && asset.fresh?
+          asset
+
+         # Otherwise yield block that slowly finds and builds the asset
+        elsif asset = yield
+          hash = {}
+          asset.encode_with(hash)
+
+          # Save the asset to at its path
+          cache_set_hash(path.to_s, digest.hexdigest, 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)
+          end
+
+          asset
+        end
+      end
+
+    private
+      # 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, '')))
+      end
+
+      def cache_get_hash(key, version)
+        hash = cache_get(cache_key_for(key))
+        if hash.is_a?(Hash) && version == hash['_version']
+          hash
+        end
+      end
+
+      def cache_set_hash(key, version, hash)
+        hash['_version'] = version
+        cache_set(cache_key_for(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/charset_normalizer.rb

@@ -0,0 +1,41 @@
+require 'tilt'
+
+module Sprockets
+  # Some browsers have issues with stylesheets that contain multiple
+  # `@charset` definitions. The issue surfaces while using Sass since
+  # it inserts a `@charset` at the top of each file. Then Sprockets
+  # concatenates them together.
+  #
+  # The `CharsetNormalizer` processor strips out multiple `@charset`
+  # definitions.
+  #
+  # The current implementation is naive. It picks the first `@charset`
+  # it sees and strips the others. This works for most people because
+  # the other definitions are usually `UTF-8`. A more sophisticated
+  # approach would be to re-encode stylesheets with mixed encodings.
+  #
+  # This behavior can be disabled with:
+  #
+  #     environment.unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
+  #
+  class CharsetNormalizer < Tilt::Template
+    def prepare
+    end
+
+    def evaluate(context, locals, &block)
+      charset = nil
+
+      # Find and strip out any `@charset` definitions
+      filtered_data = data.gsub(/^@charset "([^"]+)";$/) {
+        charset ||= $1; ""
+      }
+
+      if charset
+        # If there was a charset, move it to the top
+        "@charset \"#{charset}\";#{filtered_data}"
+      else
+        data
+      end
+    end
+  end
+end

data/lib/sprockets/context.rb

@@ -0,0 +1,217 @@
+require 'base64'
+require 'rack/utils'
+require 'sprockets/errors'
+require 'sprockets/utils'
+require 'pathname'
+require 'set'
+
+module Sprockets
+  # `Context` provides helper methods to all `Tilt` processors. They
+  # are typically accessed by ERB templates. You can mix in custom
+  # helpers by injecting them into `Environment#context_class`. Do not
+  # mix them into `Context` directly.
+  #
+  #     environment.instance_eval do
+  #       include MyHelper
+  #       def asset_url; end
+  #     end
+  #
+  #     <%= asset_url "foo.png" %>
+  #
+  # The `Context` also collects dependencies declared by
+  # assets. See `DirectiveProcessor` for an example of this.
+  class Context
+    attr_reader :environment, :pathname
+    attr_reader :_required_paths, :_dependency_paths, :_dependency_assets
+    attr_writer :__LINE__
+
+    def initialize(environment, logical_path, pathname)
+      @environment  = environment
+      @logical_path = logical_path
+      @pathname     = pathname
+      @__LINE__     = nil
+
+      @_required_paths    = []
+      @_dependency_paths  = Set.new([pathname.to_s])
+      @_dependency_assets = Set.new
+    end
+
+    # Returns the environment path that contains the file.
+    #
+    # If `app/javascripts` and `app/stylesheets` are in your path, and
+    # current file is `app/javascripts/foo/bar.js`, `root_path` would
+    # return `app/javascripts`.
+    def root_path
+      environment.paths.detect { |path| pathname.to_s[path] }
+    end
+
+    # Returns logical path without any file extensions.
+    #
+    #     'app/javascripts/application.js'
+    #     # => 'application'
+    #
+    def logical_path
+      @logical_path[/^([^.]+)/, 0]
+    end
+
+    # Returns content type of file
+    #
+    #     'application/javascript'
+    #     'text/css'
+    #
+    def content_type
+      environment.content_type_of(pathname)
+    end
+
+    # Given a logical path, `resolve` will find and return the fully
+    # expanded path. Relative paths will also be resolved. An optional
+    # `:content_type` restriction can be supplied to restrict the
+    # search.
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("./bar.js")
+    #     # => "/path/to/app/javascripts/bar.js"
+    #
+    def resolve(path, options = {}, &block)
+      pathname   = Pathname.new(path)
+      attributes = environment.attributes_for(pathname)
+
+      if pathname.absolute?
+        pathname
+
+      elsif content_type = options[:content_type]
+        content_type = self.content_type if content_type == :self
+
+        if attributes.format_extension
+          if content_type != attributes.content_type
+            raise ContentTypeMismatch, "#{path} is " +
+              "'#{attributes.content_type}', not '#{content_type}'"
+          end
+        end
+
+        resolve(path) do |candidate|
+          if self.content_type == environment.content_type_of(candidate)
+            return candidate
+          end
+        end
+
+        raise FileNotFound, "couldn't find file '#{path}'"
+      else
+        environment.resolve(path, :base_path => self.pathname.dirname, &block)
+      end
+    end
+
+    # `depend_on` allows you to state a dependency on a file without
+    # including it.
+    #
+    # This is used for caching purposes. Any changes made to
+    # the dependency file with invalidate the cache of the
+    # source file.
+    def depend_on(path)
+      @_dependency_paths << resolve(path).to_s
+      nil
+    end
+
+    # `depend_on_asset` allows you to state an asset dependency
+    # without including it.
+    #
+    # This is used for caching purposes. Any changes that would
+    # invalidate the dependency asset will invalidate the source
+    # file. Unlike `depend_on`, this will include recursively include
+    # the target asset's dependencies.
+    def depend_on_asset(path)
+      filename = resolve(path).to_s
+      @_dependency_assets << filename
+      nil
+    end
+
+    # `require_asset` declares `path` as a dependency of the file. The
+    # dependency will be inserted before the file and will only be
+    # included once.
+    #
+    # If ERB processing is enabled, you can use it to dynamically
+    # require assets.
+    #
+    #     <%= require_asset "#{framework}.js" %>
+    #
+    def require_asset(path)
+      pathname = resolve(path, :content_type => :self)
+      depend_on_asset(pathname)
+      @_required_paths << pathname.to_s
+      nil
+    end
+
+    # Tests if target path is able to be safely required into the
+    # current concatenation.
+    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)
+    end
+
+    # Reads `path` and runs processors on the file.
+    #
+    # This allows you to capture the result of an asset and include it
+    # directly in another.
+    #
+    #     <%= evaluate "bar.js" %>
+    #
+    def evaluate(path, options = {})
+      pathname   = resolve(path)
+      attributes = environment.attributes_for(pathname)
+      processors = options[:processors] || attributes.processors
+
+      if options[:data]
+        result = options[:data]
+      else
+        result = Sprockets::Utils.read_unicode(pathname)
+      end
+
+      processors.each do |processor|
+        begin
+          template = processor.new(pathname.to_s) { result }
+          result = template.render(self, {})
+        rescue Exception => e
+          annotate_exception! e
+          raise
+        end
+      end
+
+      result
+    end
+
+    # Returns a Base64-encoded `data:` URI with the contents of the
+    # asset at the specified path, and marks that path as a dependency
+    # of the current file.
+    #
+    # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
+    #
+    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
+    #
+    #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
+    #
+    def asset_data_uri(path)
+      depend_on(path)
+      asset  = environment.find_asset(path)
+      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
+      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
+    end
+
+    private
+      # Annotates exception backtrace with the original template that
+      # the exception was raised in.
+      def annotate_exception!(exception)
+        location = pathname.to_s
+        location << ":#{@__LINE__}" if @__LINE__
+
+        exception.extend(Sprockets::EngineError)
+        exception.sprockets_annotation = "  (in #{location})"
+      end
+
+      def logger
+        environment.logger
+      end
+  end
+end

data/lib/sprockets/digest.rb

@@ -0,0 +1,67 @@
+module Sprockets
+  # `Digest` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `Index` classes.
+  module Digest
+    # Returns a `Digest` implementation class.
+    #
+    # Defaults to `Digest::MD5`.
+    def digest_class
+      @digest_class
+    end
+
+    # Assign a `Digest` implementation class. This maybe any Ruby
+    # `Digest::` implementation such as `Digest::MD5` or
+    # `Digest::SHA1`.
+    #
+    #     environment.digest_class = Digest::SHA1
+    #
+    def digest_class=(klass)
+      expire_index!
+      @digest_class = klass
+    end
+
+    # The `Environment#version` is a custom value used for manually
+    # expiring all asset caches.
+    #
+    # Sprockets is able to track most file and directory changes and
+    # will take care of expiring the cache for you. However, its
+    # impossible to know when any custom helpers change that you mix
+    # into the `Context`.
+    #
+    # It would be wise to increment this value anytime you make a
+    # configuration change to the `Environment` object.
+    def version
+      @version
+    end
+
+    # Assign an environment version.
+    #
+    #     environment.version = '2.0'
+    #
+    def version=(version)
+      expire_index!
+      @version = version
+    end
+
+    # Returns a `Digest` instance for the `Environment`.
+    #
+    # This value serves two purposes. If two `Environment`s have the
+    # same digest value they can be treated as equal. This is more
+    # useful for comparing environment states between processes rather
+    # than in the same. Two equal `Environment`s can share the same
+    # cached assets.
+    #
+    # The value also provides a seed digest for all `Asset`
+    # digests. Any change in the environment digest will affect all of
+    # its assets.
+    def digest
+      # Compute the initial digest using the implementation class. The
+      # Sprockets release version and custom environment version are
+      # mixed in. So any new releases will affect all your assets.
+      @digest ||= digest_class.new.update(VERSION).update(version.to_s)
+
+      # Returned a dupped copy so the caller can safely mutate it with `.update`
+      @digest.dup
+    end
+  end
+end