sprockets 2.3.2 → 3.0.0

data/lib/sprockets/resolve.rb

@@ -0,0 +1,208 @@
+require 'set'
+require 'sprockets/http_utils'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  module Resolve
+    include HTTPUtils, PathDependencyUtils, URIUtils
+
+    # Public: Find Asset URI for given a logical path by searching the
+    # environment's load paths.
+    #
+    #     resolve("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")
+    #     # => "file:///path/to/app/javascripts/application.coffee?type=application/javascript"
+    #
+    # The String Asset URI is returned or nil if no results are found.
+    def resolve(path, options = {})
+      path = path.to_s
+      paths = options[:load_paths] || config[:paths]
+      accept = options[:accept]
+
+      if valid_asset_uri?(path)
+        uri, deps = resolve_asset_uri(path)
+      elsif absolute_path?(path)
+        filename, type, deps = resolve_absolute_path(paths, path, accept)
+      elsif relative_path?(path)
+        filename, type, pipeline, deps = resolve_relative_path(paths, path, options[:base_path], accept)
+      else
+        filename, type, pipeline, deps = resolve_logical_path(paths, path, accept)
+      end
+
+      if filename
+        params = {}
+        params[:type] = type if type
+        params[:pipeline] = pipeline if pipeline
+        params[:pipeline] = options[:pipeline] if options[:pipeline]
+        uri = build_asset_uri(filename, params)
+      end
+
+      return uri, deps
+    end
+
+    # 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))
+
+      unless uri
+        message = "couldn't find file '#{path}'"
+        message << " with type '#{options[:accept]}'" if options[:accept]
+        raise FileNotFound, message
+      end
+
+      return uri, deps
+    end
+
+    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)
+        deps = Set.new
+        filename = File.expand_path(filename)
+
+        # Ensure path is under load paths
+        return nil, nil, deps unless paths_split(paths, filename)
+
+        _, mime_type, _, _ = parse_path_extnames(filename)
+        type = resolve_transform_type(mime_type, accept)
+        return nil, nil, deps if accept && !type
+
+        return nil, nil, deps unless file?(filename)
+
+        deps << build_file_digest_uri(filename)
+        return filename, type, deps
+      end
+
+      def resolve_relative_path(paths, path, dirname, accept)
+        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)
+        else
+          return nil, nil, Set.new
+        end
+      end
+
+      def resolve_logical_path(paths, logical_path, accept)
+        logical_name, mime_type, _, pipeline = parse_path_extnames(logical_path)
+        parsed_accept = parse_accept_options(mime_type, accept)
+        transformed_accepts = expand_transform_accepts(parsed_accept)
+        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)
+          return filename, type, pipeline, deps
+        else
+          return nil, nil, nil, deps
+        end
+      end
+
+      def resolve_under_paths(paths, logical_name, accepts)
+        all_deps = Set.new
+        return nil, nil, all_deps if accepts.empty?
+
+        logical_basename = File.basename(logical_name)
+        paths.each do |load_path|
+          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 + [all_deps] if candidate
+        end
+
+        return nil, nil, all_deps
+      end
+
+      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 path_matches(load_path, logical_name, logical_basename)
+        dirname    = File.dirname(File.join(load_path, logical_name))
+        candidates = dirname_matches(dirname, logical_basename)
+        deps       = file_digest_dependency_set(dirname)
+
+        result = resolve_alternates(load_path, logical_name)
+        result[0].each do |fn|
+          candidates << [fn, parse_path_extnames(fn)[1]]
+        end
+        deps.merge(result[1])
+
+        dirname = File.join(load_path, logical_name)
+        if directory? dirname
+          result = dirname_matches(dirname, "index")
+          candidates.concat(result)
+        end
+
+        deps.merge(file_digest_dependency_set(dirname))
+
+        return candidates.select { |fn, _| file?(fn) }, deps
+      end
+
+      def dirname_matches(dirname, basename)
+        candidates = []
+        entries = self.entries(dirname)
+        entries.each do |entry|
+          name, type, _, _ = parse_path_extnames(entry)
+          if basename == name
+            candidates << [File.join(dirname, entry), type]
+          end
+        end
+        candidates
+      end
+
+      def resolve_alternates(load_path, logical_name)
+        return [], Set.new
+      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)
+        engines = []
+        extname, value = match_path_extname(path, extname_map)
+
+        if extname
+          path = path.chomp(extname)
+          type, engines, pipeline = value.values_at(:type, :engines, :pipeline)
+        end
+
+        return path, type, engines, pipeline
+      end
+  end
+end

data/lib/sprockets/sass_cache_store.rb

@@ -1,25 +1,29 @@
 require 'sass'
 
 module Sprockets
-  class SassCacheStore < ::Sass::CacheStores::Base
-    attr_reader :environment
+  class SassProcessor
+    # Internal: Cache wrapper for Sprockets cache adapter.
+    class CacheStore < ::Sass::CacheStores::Base
+      VERSION = '1'
 
-    def initialize(environment)
-      @environment = environment
-    end
+      def initialize(cache, version)
+        @cache, @version = cache, "#{VERSION}/#{version}"
+      end
 
-    def _store(key, version, sha, contents)
-      environment.cache_set("sass/#{key}", {:version => version, :sha => sha, :contents => contents})
-    end
+      def _store(key, version, sha, contents)
+        @cache.set("#{@version}/#{version}/#{key}/#{sha}", contents, true)
+      end
 
-    def _retrieve(key, version, sha)
-      if obj = environment.cache_get("sass/#{key}")
-        return unless obj[:version] == version
-        return unless obj[:sha] == sha
-        obj[:obj]
-      else
-        nil
+      def _retrieve(key, version, sha)
+        @cache.get("#{@version}/#{version}/#{key}/#{sha}", true)
+      end
+
+      def path_to(key)
+        key
       end
     end
   end
+
+  # Deprecated: Use Sprockets::SassProcessor::CacheStore instead.
+  SassCacheStore = SassProcessor::CacheStore
 end

data/lib/sprockets/sass_compressor.rb

@@ -0,0 +1,59 @@
+require 'sprockets/autoload'
+
+module Sprockets
+  # 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'
+
+    # 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 self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @options = options
+      @cache_key = [
+        self.class.name,
+        Autoload::Sass::VERSION,
+        VERSION,
+        options
+      ].freeze
+    end
+
+    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)
+        Autoload::Sass::Engine.new(data, options).render
+      end
+    end
+  end
+end

data/lib/sprockets/sass_functions.rb

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

data/lib/sprockets/sass_importer.rb

@@ -1,29 +1,2 @@
-require 'sass'
-
-module Sprockets
-  # This custom importer adds sprockets dependency tracking on to Sass
-  # `@import` statements. This makes the Sprockets and Sass caching
-  # systems work together.
-  class SassImporter < Sass::Importers::Filesystem
-    def initialize(context, root)
-      @context = context
-      super root.to_s
-    end
-
-    def find_relative(*args)
-      engine = super
-      if engine && (filename = engine.options[:filename])
-        @context.depend_on_asset(filename)
-      end
-      engine
-    end
-
-    def find(*args)
-      engine = super
-      if engine && (filename = engine.options[:filename])
-        @context.depend_on_asset(filename)
-      end
-      engine
-    end
-  end
-end
+# Deprecated: Require sprockets/sass_processor instead
+require 'sprockets/sass_processor'

data/lib/sprockets/sass_processor.rb

@@ -0,0 +1,285 @@
+require 'rack/utils'
+require 'sprockets/autoload'
+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
+    autoload :CacheStore, 'sprockets/sass_cache_store'
+
+    # 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,
+        Autoload::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 = Autoload::Sass::Engine.new(input[:data], options)
+
+      css = Utils.module_include(Autoload::Sass::Script::Functions, @functions) do
+        engine.render
+      end
+
+      # Track all imported files
+      sass_dependencies = Set.new([input[:filename]])
+      engine.dependencies.map do |dependency|
+        sass_dependencies << dependency.options[:filename]
+        context.metadata[:dependencies] << URIUtils.build_file_digest_uri(dependency.options[:filename])
+      end
+
+      context.metadata.merge(data: css, sass_dependencies: sass_dependencies)
+    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
+
+        Autoload::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 = {})
+        Autoload::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)
+        Autoload::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
+  end
+
+  class ScssProcessor < SassProcessor
+    def self.syntax
+      :scss
+    end
+  end
+
+  # Deprecated: Use Sprockets::SassProcessor::Functions instead.
+  SassFunctions = SassProcessor::Functions
+end

data/lib/sprockets/sass_template.rb

@@ -1,47 +1,7 @@
-require 'tilt'
+require 'sprockets/sass_processor'
 
 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.
-  #
-  # See `SassImporter` for more infomation.
-  class SassTemplate < Tilt::Template
-    self.default_mime_type = 'text/css'
-
-    def self.engine_initialized?
-      defined? ::Sass::Engine
-    end
-
-    def initialize_engine
-      require_template_library 'sass'
-    end
-
-    def prepare
-    end
-
-    def syntax
-      :sass
-    end
-
-    def evaluate(context, locals, &block)
-      # Use custom importer that knows about Sprockets Caching
-      cache_store = SassCacheStore.new(context.environment)
-
-      options = {
-        :filename => eval_file,
-        :line => line,
-        :syntax => syntax,
-        :cache_store => cache_store,
-        :importer => SassImporter.new(context, context.pathname),
-        :load_paths => context.environment.paths.map { |path| SassImporter.new(context, path) }
-      }
-
-      ::Sass::Engine.new(data, options).render
-    rescue ::Sass::SyntaxError => e
-      # Annotates exception message with parse line number
-      context.__LINE__ = e.sass_backtrace.first[:line]
-      raise e
-    end
-  end
+  # Deprecated
+  SassTemplate = SassProcessor
+  ScssTemplate = ScssProcessor
 end