sprockets 3.0.0.beta.6 → 3.0.0.beta.7

data/lib/sprockets/processor_utils.rb

@@ -0,0 +1,97 @@
+require 'sprockets/autoload_processor'
+
+module Sprockets
+  # Functional utilities for dealing with Processor functions.
+  #
+  # A Processor is a general function that my modify or transform an asset as
+  # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
+  # or Concatenation are all implemented as seperate Processor steps.
+  #
+  # Processors maybe any object that responds to call. So procs or a class that
+  # defines a self.call method.
+  #
+  # For ergonomics, processors may return a number of shorthand values.
+  # Unfortunately, this means that processors can not compose via ordinary
+  # function composition. The composition helpers here can help.
+  module ProcessorUtils
+    extend self
+
+    # Internal: Setup autoload and wrapper for lazy loaded processor.
+    #
+    #   Sprockets.autoload_processor :CoffeeScriptProcessor, 'sprockets/coffee_script_processor'
+    #
+    # mod      - Symbol name of processor class/module
+    # filename - String require path for module
+    #
+    # Returns AutoloadProcessor.
+    def autoload_processor(mod, filename)
+      autoload(mod, filename)
+      AutoloadProcessor.new(self, mod)
+    end
+
+    # Public: Compose processors in right to left order.
+    #
+    # processors - Array of processors callables
+    #
+    # Returns a composed Proc.
+    def compose_processors(*processors)
+      context = self
+      obj = method(:call_processors).to_proc.curry[processors]
+      metaclass = (class << obj; self; end)
+      metaclass.send(:define_method, :cache_key) do
+        context.processors_cache_keys(processors)
+      end
+      obj
+    end
+
+    # Public: Invoke list of processors in right to left order.
+    #
+    # The right to left order processing mirrors standard function composition.
+    # Think about:
+    #
+    #   bundle.call(uglify.call(coffee.call(input)))
+    #
+    # processors - Array of processor callables
+    # input - Hash of input data to pass to each processor
+    #
+    # Returns a Hash with :data and other processor metadata key/values.
+    def call_processors(processors, input)
+      data = input[:data] || ""
+      metadata = input[:metadata] || {}
+
+      processors.reverse_each do |processor|
+        result = processor.call(input.merge(data: data, metadata: metadata))
+        case result
+        when NilClass
+        when Hash
+          data = result.delete(:data) if result.key?(:data)
+          metadata.merge!(result)
+        when String
+          data = result
+        else
+          raise TypeError, "invalid processor return type: #{result.class}"
+        end
+      end
+
+      metadata.merge(data: data)
+    end
+
+    # Internal: Get processor defined cached key.
+    #
+    # processor - Processor function
+    #
+    # Returns JSON serializable key or nil.
+    def processor_cache_key(processor)
+      processor.cache_key if processor.respond_to?(:cache_key)
+    end
+
+    # Internal: Get combined cache keys for set of processors.
+    #
+    # processors - Array of processor functions
+    #
+    # Returns Array of JSON serializable keys.
+    def processors_cache_keys(processors)
+      processors.map { |processor| processor_cache_key(processor) }
+    end
+  end
+end

data/lib/sprockets/resolve.rb

@@ -1,110 +1,121 @@
-require 'sprockets/asset_uri'
+require 'set'
+require 'sprockets/http_utils'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/uri_utils'
 
 module Sprockets
   module Resolve
-    # Public: Finds the absolute path for a given logical path by searching the
+    include HTTPUtils, PathDependencyUtils, URIUtils
+
+    # Public: Find Asset URI for given a logical path by searching the
     # environment's load paths.
     #
     #     resolve("application.js")
-    #     # => "/path/to/app/javascripts/application.js"
+    #     # => "file:///path/to/app/javascripts/application.js?type=application/javascript"
     #
     # An accept content type can be given if the logical path doesn't have a
     # format extension.
     #
     #     resolve("application", accept: "application/javascript")
-    #     # => "/path/to/app/javascripts/application.js"
+    #     # => "file:///path/to/app/javascripts/application.coffee?type=application/javascript"
     #
-    # The String path is returned or nil if no results are found.
+    # The String Asset URI is returned or nil if no results are found.
     def resolve(path, options = {})
-      logical_name, mime_type, _ = parse_path_extnames(path)
-
+      path = path.to_s
       paths = options[:load_paths] || self.paths
+      accept = options[:accept]
+      skip_bundle = options.key?(:bundle) ? !options[:bundle] : false
 
-      if absolute_path?(path)
-        path = File.expand_path(path)
-        if paths_split(paths, path) && file?(path)
-          if accept = options[:accept]
-            find_best_q_match(accept, [path]) do |candidate, matcher|
-              match_mime_type?(mime_type || "application/octet-stream", matcher)
-            end
-          else
-            path
-          end
-        end
+      if valid_asset_uri?(path)
+        resolve_asset_uri(path)
+      elsif absolute_path?(path)
+        resolve_absolute_path(paths, path, accept, skip_bundle)
+      elsif relative_path?(path)
+        resolve_relative_path(paths, path, options[:base_path], accept, skip_bundle)
       else
-        accepts = parse_accept_options(mime_type, options[:accept])
-        filename, _ = resolve_under_paths(paths, logical_name, mime_type, accepts)
-        filename
+        resolve_logical_path(paths, path, accept, skip_bundle)
       end
     end
 
-    # Public: Find Asset URI for given a logical path by searching the
-    # environment's load paths.
-    #
-    #     locate("application.js")
-    #     # => "file:///path/to/app/javascripts/application.js?content_type=application/javascript"
-    #
-    # An accept content type can be given if the logical path doesn't have a
-    # format extension.
-    #
-    #     locate("application", accept: "application/javascript")
-    #     # => "file:///path/to/app/javascripts/application.coffee?content_type=application/javascript"
-    #
-    # The String Asset URI is returned or nil if no results are found.
-    def locate(path, options = {})
-      path = path.to_s
-      accept = options[:accept]
-      skip_bundle = options.key?(:bundle) ? !options[:bundle] : false
+    # Public: Same as resolve() but raises a FileNotFound exception instead of
+    # nil if no assets are found.
+    def resolve!(path, options = {})
+      uri, deps = resolve(path, options.merge(compat: false))
 
-      available_encodings = self.encodings.keys + ['identity']
-      encoding = find_best_q_match(options[:accept_encoding], available_encodings)
+      unless uri
+        message = "couldn't find file '#{path}'"
+        message << " with type '#{options[:accept]}'" if options[:accept]
+        raise FileNotFound, message
+      end
 
-      paths = options[:load_paths] || self.paths
+      return uri, deps
+    end
 
-      if AssetURI.valid?(path)
-        return path
-      elsif absolute_path?(path)
-        path = File.expand_path(path)
-        if paths_split(paths, path) && file?(path)
-          mime_type = parse_path_extnames(path)[1]
-          _type = resolve_transform_type(mime_type, accept)
-          if !accept || _type
-            filename = path
-            type = _type
-          end
-        end
-      else
-        logical_name, mime_type, _ = parse_path_extnames(path)
-        parsed_accept = parse_accept_options(mime_type, accept)
+    protected
+      def resolve_asset_uri(uri)
+        filename, _ = parse_asset_uri(uri)
+        return uri, Set.new([build_file_digest_uri(filename)])
+      end
+
+      def resolve_absolute_path(paths, filename, accept, skip_bundle)
+        deps = Set.new
+        filename = File.expand_path(filename)
+
+        # Ensure path is under load paths
+        return nil, deps unless paths_split(paths, filename)
 
-        if parsed_accept.empty?
-          return
+        mime_type = parse_path_extnames(filename)[1]
+        type = resolve_transform_type(mime_type, accept)
+        return nil, deps if accept && !type
+
+        return nil, deps unless file?(filename)
+
+        uri = build_asset_uri(filename, type: type, skip_bundle: skip_bundle)
+        deps << build_file_digest_uri(filename)
+        return uri, deps
+      end
+
+      def resolve_relative_path(paths, path, dirname, accept, skip_bundle)
+        filename = File.expand_path(path, dirname)
+        load_path, _ = paths_split(paths, dirname)
+        if load_path && logical_path = split_subpath(load_path, filename)
+          resolve_logical_path([load_path], logical_path, accept, skip_bundle)
+        else
+          [nil, Set.new]
         end
+      end
 
+      def resolve_logical_path(paths, logical_path, accept, skip_bundle)
+        logical_name, mime_type, _ = parse_path_extnames(logical_path)
+        parsed_accept = parse_accept_options(mime_type, accept)
         transformed_accepts = expand_transform_accepts(parsed_accept)
-        filename, mime_type = resolve_under_paths(paths, logical_name, mime_type, transformed_accepts)
-        type = resolve_transform_type(mime_type, parsed_accept) if filename
+        filename, mime_type, deps = resolve_under_paths(paths, logical_name, transformed_accepts)
+
+        if filename
+          deps << build_file_digest_uri(filename)
+          type = resolve_transform_type(mime_type, parsed_accept)
+          uri = build_asset_uri(filename, type: type, skip_bundle: skip_bundle)
+          return uri, deps
+        else
+          return nil, deps
+        end
       end
 
-      if filename
-        encoding = nil if encoding == 'identity'
-        AssetURI.build(filename, type: type, skip_bundle: skip_bundle, encoding: encoding)
-      end
-    end
+      def resolve_under_paths(paths, logical_name, accepts)
+        all_deps = Set.new
+        return nil, nil, all_deps if accepts.empty?
 
-    protected
-      def resolve_under_paths(paths, logical_name, mime_type, accepts)
         logical_basename = File.basename(logical_name)
-
         paths.each do |load_path|
-          candidates = path_matches(load_path, logical_name, logical_basename)
+          candidates, deps = path_matches(load_path, logical_name, logical_basename)
+          all_deps.merge(deps)
           candidate = find_best_q_match(accepts, candidates) do |c, matcher|
             match_mime_type?(c[1] || "application/octet-stream", matcher)
           end
-          return candidate if candidate
+          return candidate + [all_deps] if candidate
         end
 
-        nil
+        return nil, nil, all_deps
       end
 
       def parse_accept_options(mime_type, types)
@@ -133,24 +144,40 @@ module Sprockets
       end
 
       def path_matches(load_path, logical_name, logical_basename)
-        candidates = []
+        candidates, deps = [], Set.new
         dirname = File.dirname(File.join(load_path, logical_name))
-        dirname_matches(dirname, logical_basename) { |candidate| candidates << candidate }
-        resolve_alternates(load_path, logical_name) { |fn| candidates << [fn, parse_path_extnames(fn)[1]] }
-        dirname_matches(File.join(load_path, logical_name), "index") { |candidate| candidates << candidate }
-        candidates.select { |fn, _| file?(fn) }
+
+        result = dirname_matches(dirname, logical_basename)
+        candidates.concat(result[0])
+        deps.merge(result[1])
+
+        result = resolve_alternates(load_path, logical_name)
+        result[0].each do |fn|
+          candidates << [fn, parse_path_extnames(fn)[1]]
+        end
+        deps.merge(result[1])
+
+        result = dirname_matches(File.join(load_path, logical_name), "index")
+        candidates.concat(result[0])
+        deps.merge(result[1])
+
+        return candidates.select { |fn, _| file?(fn) }, deps
       end
 
       def dirname_matches(dirname, basename)
-        self.entries(dirname).each do |entry|
+        candidates = []
+        entries, deps = self.entries_with_dependencies(dirname)
+        entries.each do |entry|
           name, type, _ = parse_path_extnames(entry)
           if basename == name
-            yield [File.join(dirname, entry), type]
+            candidates << [File.join(dirname, entry), type]
           end
         end
+        return candidates, deps
       end
 
       def resolve_alternates(load_path, logical_name)
+        return [], Set.new
       end
 
       # Internal: Returns the name, mime type and `Array` of engine extensions.
@@ -159,26 +186,12 @@ module Sprockets
       #     # => ["foo", "application/javascript", [".coffee", ".erb"]]
       #
       def parse_path_extnames(path)
-        mime_type       = nil
-        engine_extnames = []
-        len = path.length
-
-        path_extnames(path).reverse_each do |extname|
-          if engines.key?(extname)
-            mime_type = engine_mime_types[extname]
-            engine_extnames.unshift(extname)
-            len -= extname.length
-          elsif mime_exts.key?(extname)
-            mime_type = mime_exts[extname]
-            len -= extname.length
-            break
-          else
-            break
-          end
+        extname, value = match_path_extname(path, config[:_extnames])
+        if extname
+          return path.chomp(extname), value[:type], value[:engines]
+        else
+          return path, nil, []
         end
-
-        name = path[0, len]
-        return [name, mime_type, engine_extnames]
       end
   end
 end

data/lib/sprockets/sass_cache_store.rb

@@ -1,2 +1,2 @@
-# Deprecated: Require sprockets/sass_template instead
-require 'sprockets/sass_template'
+# Deprecated: Require sprockets/sass_processor instead
+require 'sprockets/sass_processor'

data/lib/sprockets/sass_compressor.rb

@@ -16,18 +16,31 @@ module Sprockets
   class SassCompressor
     VERSION = '1'
 
-    def self.call(*args)
-      new.call(*args)
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SassCompressor object.
+    def self.instance
+      @instance ||= new
     end
 
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
     def initialize(options = {})
       @options = options
       @cache_key = [
-        'SassCompressor',
+        self.class.name,
         ::Sass::VERSION,
         VERSION,
         options
-      ]
+      ].freeze
     end
 
     def call(input)

data/lib/sprockets/sass_functions.rb

@@ -1,2 +1,2 @@
-# Deprecated: Require sprockets/sass_template instead
-require 'sprockets/sass_template'
+# Deprecated: Require sprockets/sass_processor instead
+require 'sprockets/sass_processor'

data/lib/sprockets/sass_importer.rb

@@ -1,2 +1,2 @@
-# Deprecated: Require sprockets/sass_template instead
-require 'sprockets/sass_template'
+# Deprecated: Require sprockets/sass_processor instead
+require 'sprockets/sass_processor'

data/lib/sprockets/sass_processor.rb

@@ -0,0 +1,305 @@
+require 'rack/utils'
+require 'sass'
+require 'uri'
+
+module Sprockets
+  # Processor engine class for the SASS/SCSS compiler. Depends on the `sass` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sass/sass
+  #   https://github.com/rails/sass-rails
+  #
+  class SassProcessor
+    # Internal: Defines default sass syntax to use. Exposed so the ScssProcessor
+    # may override it.
+    def self.syntax
+      :sass
+    end
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SassProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    # Public: Initialize template with custom options.
+    #
+    # options - Hash
+    #   cache_version - String custom cache version. Used to force a cache
+    #                   change after code changes are made to Sass Functions.
+    #
+    def initialize(options = {}, &block)
+      @cache_version = options[:cache_version]
+      @cache_key = [
+        self.class.name,
+        VERSION,
+        Sass::VERSION,
+        @cache_version
+      ].freeze
+
+      @functions = Module.new do
+        include Functions
+        include options[:functions] if options[:functions]
+        class_eval(&block) if block_given?
+      end
+    end
+
+    def call(input)
+      context = input[:environment].context_class.new(input)
+
+      options = {
+        filename: input[:filename],
+        syntax: self.class.syntax,
+        cache_store: CacheStore.new(input[:cache], @cache_version),
+        load_paths: input[:environment].paths,
+        sprockets: {
+          context: context,
+          environment: input[:environment],
+          dependencies: context.metadata[:dependencies]
+        }
+      }
+
+      engine = ::Sass::Engine.new(input[:data], options)
+
+      css = Utils.module_include(::Sass::Script::Functions, @functions) do
+        engine.render
+      end
+
+      # Track all imported files
+      engine.dependencies.map do |dependency|
+        context.metadata[:dependencies] << URIUtils.build_file_digest_uri(dependency.options[:filename])
+      end
+
+      context.metadata.merge(data: css)
+    end
+
+    # Public: Functions injected into Sass context during Sprockets evaluation.
+    #
+    # This module may be extended to add global functionality to all Sprockets
+    # Sass environments. Though, scoping your functions to just your environment
+    # is preferred.
+    #
+    # module Sprockets::SassProcessor::Functions
+    #   def asset_path(path, options = {})
+    #   end
+    # end
+    #
+    module Functions
+      # Public: Generate a url for asset path.
+      #
+      # Default implementation is deprecated. Currently defaults to
+      # Context#asset_path.
+      #
+      # Will raise NotImplementedError in the future. Users should provide their
+      # own base implementation.
+      #
+      # Returns a Sass::Script::String.
+      def asset_path(path, options = {})
+        path = path.value
+
+        path, _, query, fragment = URI.split(path)[5..8]
+        path     = sprockets_context.asset_path(path, options)
+        query    = "?#{query}" if query
+        fragment = "##{fragment}" if fragment
+
+        ::Sass::Script::String.new("#{path}#{query}#{fragment}", :string)
+      end
+
+      # Public: Generate a asset url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def asset_url(path, options = {})
+        ::Sass::Script::String.new("url(#{asset_path(path, options).value})")
+      end
+
+      # Public: Generate url for image path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def image_path(path)
+        asset_path(path, type: :image)
+      end
+
+      # Public: Generate a image url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def image_url(path)
+        asset_url(path, type: :image)
+      end
+
+      # Public: Generate url for video path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def video_path(path)
+        asset_path(path, type: :video)
+      end
+
+      # Public: Generate a video url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def video_url(path)
+        asset_url(path, type: :video)
+      end
+
+      # Public: Generate url for audio path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def audio_path(path)
+        asset_path(path, type: :audio)
+      end
+
+      # Public: Generate a audio url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def audio_url(path)
+        asset_url(path, type: :audio)
+      end
+
+      # Public: Generate url for font path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def font_path(path)
+        asset_path(path, type: :font)
+      end
+
+      # Public: Generate a font url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def font_url(path)
+        asset_url(path, type: :font)
+      end
+
+      # Public: Generate url for javascript path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def javascript_path(path)
+        asset_path(path, type: :javascript)
+      end
+
+      # Public: Generate a javascript url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def javascript_url(path)
+        asset_url(path, type: :javascript)
+      end
+
+      # Public: Generate url for stylesheet path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def stylesheet_path(path)
+        asset_path(path, type: :stylesheet)
+      end
+
+      # Public: Generate a stylesheet url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def stylesheet_url(path)
+        asset_url(path, type: :stylesheet)
+      end
+
+      # Public: Generate a data URI for asset path.
+      #
+      # path - Sass::Script::String logical asset path
+      #
+      # Returns a Sass::Script::String.
+      def asset_data_url(path)
+        url = sprockets_context.asset_data_uri(path.value)
+        ::Sass::Script::String.new("url(" + url + ")")
+      end
+
+      protected
+        # Public: The Environment.
+        #
+        # Returns Sprockets::Environment.
+        def sprockets_environment
+          options[:sprockets][:environment]
+        end
+
+        # Public: Mutatable set of dependencies.
+        #
+        # Returns a Set.
+        def sprockets_dependencies
+          options[:sprockets][:dependencies]
+        end
+
+        # Deprecated: Get the Context instance. Use APIs on
+        # sprockets_environment or sprockets_dependencies directly.
+        #
+        # Returns a Context instance.
+        def sprockets_context
+          options[:sprockets][:context]
+        end
+
+    end
+
+    # Internal: Cache wrapper for Sprockets cache adapter.
+    class CacheStore < ::Sass::CacheStores::Base
+      VERSION = '1'
+
+      def initialize(cache, version)
+        @cache, @version = cache, "#{VERSION}/#{version}"
+      end
+
+      def _store(key, version, sha, contents)
+        @cache.set("#{@version}/#{version}/#{key}/#{sha}", contents)
+      end
+
+      def _retrieve(key, version, sha)
+        @cache.get("#{@version}/#{version}/#{key}/#{sha}")
+      end
+
+      def path_to(key)
+        key
+      end
+    end
+  end
+
+  class ScssProcessor < SassProcessor
+    def self.syntax
+      :scss
+    end
+  end
+
+  # Deprecated: Use Sprockets::SassProcessor::Functions instead.
+  SassFunctions = SassProcessor::Functions
+
+  # Deprecated: Use Sprockets::SassProcessor::CacheStore instead.
+  SassCacheStore = SassProcessor::CacheStore
+end