sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/resolve.rb

@@ -0,0 +1,289 @@
+module Sprockets
+  module Resolve
+    # Public: Iterate over every file under all load paths.
+    #
+    # Returns Enumerator if no block is given.
+    def each_file
+      return to_enum(__method__) unless block_given?
+
+      paths.each do |root|
+        stat_tree(root).each do |filename, stat|
+          if stat.file?
+            yield filename
+          end
+        end
+      end
+
+      nil
+    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(path, options = {})
+      resolve_all(path, options) do |filename|
+        return filename
+      end
+
+      accept = options[:accept]
+      message = "couldn't find file '#{path}'"
+      message << " with type '#{accept}'" if accept
+      raise FileNotFound, message
+    end
+
+    def resolve_in_load_path(load_path, logical_path, options = {})
+      if !self.paths.include?(load_path.to_s)
+        raise FileOutsidePaths, "#{load_path} isn't in paths: #{self.paths.join(', ')}"
+      end
+
+      resolve_all_under_load_path(load_path, logical_path, options) do |filename|
+        return filename
+      end
+
+      accept = options[:accept]
+      message = "couldn't find file '#{logical_path}' under '#{load_path}'"
+      message << " with type '#{accept}'" if accept
+      raise FileNotFound, message
+    end
+
+    def resolve_all_under_load_path(load_path, logical_path, options = {}, &block)
+      return to_enum(__method__, load_path, logical_path, options) unless block_given?
+
+      logical_name, mime_type, _ = parse_path_extnames(logical_path)
+      logical_basename = File.basename(logical_name)
+
+      accepts = parse_accept_options(mime_type, options[:accept])
+
+      _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
+
+      nil
+    end
+
+    # Public: Finds the expanded real path for a given logical path by searching
+    # the environment's paths. Includes all matching paths including fallbacks
+    # and shadowed matches.
+    #
+    #     resolve_all("application.js").first
+    #     # => "/path/to/app/javascripts/application.js.coffee"
+    #
+    # `resolve_all` returns an `Enumerator`. This allows you to filter your
+    # matches by any condition.
+    #
+    #     resolve_all("application").find do |path|
+    #       mime_type_for(path) == "text/css"
+    #     end
+    #
+    def resolve_all(path, options = {}, &block)
+      return to_enum(__method__, path, options) unless block_given?
+      path = path.to_s
+
+      logical_name, mime_type, _ = parse_path_extnames(path)
+      logical_basename = File.basename(logical_name)
+
+      accepts = parse_accept_options(mime_type, options[:accept])
+
+      self.paths.each do |load_path|
+        _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
+      end
+
+      nil
+    end
+
+    # Experimental: Get transform type for filename
+    def resolve_path_transform_type(filename, accept)
+      mime_type = parse_path_extnames(filename)[1]
+      resolve_transform_type(mime_type, accept)
+    end
+
+    # Experimental
+    def resolve_asset_uri(path, options = {})
+      path = path.to_s
+      accept = options[:accept]
+      skip_bundle = options.key?(:bundle) ? !options[:bundle] : false
+
+      available_encodings = self.encodings.keys + ['identity']
+      encoding = find_best_q_match(options[:accept_encoding], available_encodings)
+
+      if absolute_path?(path)
+        path = File.expand_path(path)
+        if file?(path) && (accept.nil? || resolve_path_transform_type(path, accept))
+          filename = path
+          type = resolve_path_transform_type(path, accept)
+        end
+      else
+        if filename = resolve_all(path, accept: accept).first
+          mime_type = parse_path_extnames(path)[1]
+          accept = parse_accept_options(mime_type, accept).map { |t, v| "#{t}; q=#{v}" }.join(", ")
+          type = resolve_path_transform_type(filename, accept)
+        end
+      end
+
+      if filename
+        encoding = nil if encoding == 'identity'
+        AssetURI.build(filename, type: type, skip_bundle: skip_bundle, encoding: encoding)
+      end
+    end
+
+    # Public: Enumerate over all logical paths in the environment.
+    #
+    # Returns an Enumerator of [logical_path, filename].
+    def logical_paths
+      return to_enum(__method__) unless block_given?
+
+      seen = Set.new
+
+      self.paths.each do |load_path|
+        stat_tree(load_path).each do |filename, stat|
+          next unless stat.file?
+
+          path = split_subpath(load_path, filename)
+          path, mime_type, _ = parse_path_extnames(path)
+          path = normalize_logical_path(path)
+          path += mime_types[mime_type][:extensions].first if mime_type
+
+          if !seen.include?(path)
+            yield path, filename
+            seen << path
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Deprecated: Iterate over all logical paths with a matcher.
+    #
+    # Remove from 4.x.
+    #
+    # args - List of matcher objects.
+    #
+    # Returns Enumerator if no block is given.
+    def each_logical_path(*args, &block)
+      return to_enum(__method__, *args) unless block_given?
+
+      filters = args.flatten.map { |arg| Manifest.compile_match_filter(arg) }
+      logical_paths.each do |a, b|
+        if filters.any? { |f| f.call(a, b) }
+          if block.arity == 2
+            yield a, b
+          else
+            yield a
+          end
+        end
+      end
+
+      nil
+    end
+
+    protected
+      def parse_accept_options(mime_type, types)
+        accepts = []
+        accepts += parse_q_values(types) if types
+
+        if mime_type
+          if accepts.empty? || accepts.any? { |accept, _| match_mime_type?(mime_type, accept) }
+            accepts = [[mime_type, 1.0]]
+          else
+            return []
+          end
+        end
+
+        if accepts.empty?
+          accepts << ['*/*', 1.0]
+        end
+
+        accepts
+      end
+
+      def normalize_logical_path(path)
+        dirname, basename = File.split(path)
+        path = dirname if basename == 'index'
+        path
+      end
+
+      def _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
+        filenames = path_matches(load_path, logical_name, logical_basename)
+
+        matches = []
+
+        # TODO: Cleanup double iteration of accept and filenames
+
+        # Exact mime type match first
+        matches += find_q_matches(accepts, filenames) do |filename, accepted|
+          if !file?(filename)
+            nil
+          elsif accepted == '*/*'
+            filename
+          elsif parse_path_extnames(filename)[1] == accepted
+            filename
+          end
+        end
+
+        # Then transformable match
+        matches += find_q_matches(accepts, filenames) do |filename, accepted|
+          if !file?(filename)
+            nil
+          elsif accepted == '*/*'
+            filename
+          elsif resolve_path_transform_type(filename, accepted)
+            filename
+          end
+        end
+
+        matches.uniq.each(&block)
+      end
+
+      def path_matches(load_path, logical_name, logical_basename)
+        filenames = []
+        dirname = File.dirname(File.join(load_path, logical_name))
+        dirname_matches(dirname, logical_basename) { |fn| filenames << fn }
+        resolve_alternates(load_path, logical_name) { |fn| filenames << fn }
+        dirname_matches(File.join(load_path, logical_name), "index") { |fn| filenames << fn }
+        filenames
+      end
+
+      def dirname_matches(dirname, basename)
+        self.entries(dirname).each do |entry|
+          name = parse_path_extnames(entry)[0]
+          if basename == name
+            yield File.join(dirname, entry)
+          end
+        end
+      end
+
+      def resolve_alternates(load_path, logical_name)
+      end
+
+      # Internal: Returns the name, mime type and `Array` of engine extensions.
+      #
+      #     "foo.js.coffee.erb"
+      #     # => ["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
+        end
+
+        name = path[0, len]
+        return [name, mime_type, engine_extnames]
+      end
+  end
+end

data/lib/sprockets/sass_compressor.rb

@@ -1,27 +1,46 @@
-require 'tilt'
+require 'sass'
 
 module Sprockets
-  class SassCompressor < Tilt::Template
-    self.default_mime_type = 'text/css'
+  # Public: Sass CSS minifier.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'text/css',
+  #       Sprockets::SassCompressor
+  #
+  # Or to pass options to the Sass::Engine class.
+  #
+  #     environment.register_bundle_processor 'text/css',
+  #       Sprockets::SassCompressor.new({ ... })
+  #
+  class SassCompressor
+    VERSION = '1'
 
-    def self.engine_initialized?
-      defined?(::Sass::Engine)
+    def self.call(*args)
+      new.call(*args)
     end
 
-    def initialize_engine
-      require_template_library 'sass'
+    def initialize(options = {})
+      @options = options
+      @cache_key = [
+        'SassCompressor',
+        ::Sass::VERSION,
+        VERSION,
+        options
+      ]
     end
 
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      ::Sass::Engine.new(data, {
-        :syntax => :scss,
-        :cache => false,
-        :read_cache => false,
-        :style => :compressed
-      }).render
+    def call(input)
+      data = input[:data]
+      input[:cache].fetch(@cache_key + [data]) do
+        options = {
+          syntax: :scss,
+          cache: false,
+          read_cache: false,
+          style: :compressed
+        }.merge(@options)
+        ::Sass::Engine.new(data, options).render
+      end
     end
   end
 end

data/lib/sprockets/sass_template.rb

@@ -1,66 +1,289 @@
-require 'tilt'
+require 'rack/utils'
+require 'sass'
+require 'uri'
 
 module Sprockets
-  # This custom Tilt handler replaces the one built into Tilt. The
-  # main difference is that it uses a custom importer that plays nice
-  # with sprocket's caching system.
+  # Template engine class for the SASS/SCSS compiler. Depends on the `sass` gem.
   #
-  # See `SassImporter` for more infomation.
-  class SassTemplate < Tilt::Template
-    self.default_mime_type = 'text/css'
-
-    def self.engine_initialized?
-      defined?(::Sass::Engine) && defined?(::Sass::Script::Functions) &&
-        ::Sass::Script::Functions < Sprockets::SassFunctions
+  # For more infomation see:
+  #
+  #   https://github.com/sass/sass
+  #   https://github.com/rails/sass-rails
+  #
+  class SassTemplate
+    # Internal: Defines default sass syntax to use. Exposed so the ScssTemplate
+    # may override it.
+    def self.syntax
+      :sass
     end
 
-    def initialize_engine
-      # Double check constant to avoid tilt warning
-      unless defined? ::Sass
-        require_template_library 'sass'
-      end
-
-      # Install custom functions. It'd be great if this didn't need to
-      # be installed globally, but could be passed into Engine as an
-      # option.
-      ::Sass::Script::Functions.send :include, Sprockets::SassFunctions
+    def self.call(*args)
+      new.call(*args)
     end
 
-    def prepare
-    end
+    # 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]
 
-    def syntax
-      :sass
+      @functions = Module.new do
+        include Functions
+        include options[:functions] if options[:functions]
+        class_eval(&block) if block_given?
+      end
     end
 
-    def evaluate(context, locals, &block)
-      # Use custom importer that knows about Sprockets Caching
-      cache_store = SassCacheStore.new(context.environment)
+    def call(input)
+      context = input[:environment].context_class.new(input)
 
       options = {
-        :filename => eval_file,
-        :line => line,
-        :syntax => syntax,
-        :cache_store => cache_store,
-        :importer => SassImporter.new(context.pathname.to_s),
-        :load_paths => context.environment.paths.map { |path| SassImporter.new(path.to_s) },
-        :sprockets => {
-          :context => context,
-          :environment => context.environment
+        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[:dependency_paths]
         }
       }
 
-      result = ::Sass::Engine.new(data, options).render
+      engine = ::Sass::Engine.new(input[:data], options)
+
+      css = Utils.module_include(::Sass::Script::Functions, @functions) do
+        engine.render
+      end
 
       # Track all imported files
-      filenames = ([options[:importer].imported_filenames] + options[:load_paths].map(&:imported_filenames)).flatten.uniq
-      filenames.each { |filename| context.depend_on(filename) }
-
-      result
-    rescue ::Sass::SyntaxError => e
-      # Annotates exception message with parse line number
-      context.__LINE__ = e.sass_backtrace.first[:line]
-      raise e
+      engine.dependencies.map do |dependency|
+        context.metadata[:dependency_paths] << 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::SassTemplate::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)
+        if asset = sprockets_environment.find_asset(path.value, accept_encoding: 'base64')
+          sprockets_dependencies << asset.filename
+          url = "data:#{asset.content_type};base64,#{Rack::Utils.escape(asset.to_s)}"
+          ::Sass::Script::String.new("url(" + url + ")")
+        end
+      end
+
+      protected
+        # Public: The Environment.
+        #
+        # Returns Sprockets::Environment.
+        def sprockets_environment
+          options[:sprockets][:environment]
+        end
+
+        # Public: Mutatable set dependency paths.
+        #
+        # 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 ScssTemplate < SassTemplate
+    def self.syntax
+      :scss
     end
   end
+
+  # Deprecated: Use Sprockets::SassTemplate::Functions instead.
+  SassFunctions = SassTemplate::Functions
+
+  # Deprecated: Use Sprockets::SassTemplate::CacheStore instead.
+  SassCacheStore = SassTemplate::CacheStore
 end