sprockets 4.0.1

data/lib/sprockets/resolve.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+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, load_paths: config[:paths], accept: nil, pipeline: nil, base_path: nil)
+      paths = load_paths
+
+      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, path_pipeline, deps, index_alias = resolve_relative_path(paths, path, base_path, accept)
+      else
+        filename, type, path_pipeline, deps, index_alias = resolve_logical_path(paths, path, accept)
+      end
+
+      if filename
+        uri = build_asset_uri(filename, type: type, pipeline: pipeline || path_pipeline, index_alias: index_alias)
+      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, **kargs)
+      uri, deps = resolve(path, **kargs)
+
+      unless uri
+        message = +"couldn't find file '#{path}'"
+
+        if relative_path?(path) && kargs[:base_path]
+          load_path, _ = paths_split(config[:paths], kargs[:base_path])
+          message << " under '#{load_path}'"
+        end
+
+        message << " with type '#{kargs[:accept]}'" if kargs[:accept]
+
+        load_paths = kargs[:load_paths] || config[:paths]
+        message << "\nChecked in these paths: \n  #{ load_paths.join("\n  ") }"
+
+        raise FileNotFound, message
+      end
+
+      return uri, deps
+    end
+
+    protected
+
+      # Internal: Finds an asset given a URI
+      #
+      # uri - String. Contains file:// scheme, absolute path to
+      #       file.
+      #       e.g. "file:///Users/schneems/sprockets/test/fixtures/default/gallery.js?type=application/javascript"
+      #
+      # Returns Array. Contains a String uri and Set of dependencies
+      def resolve_asset_uri(uri)
+        filename, _ = URIUtils.parse_asset_uri(uri)
+        return uri, Set.new( [URIUtils.build_file_digest_uri(filename)] )
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths    - Array of Strings.
+      # filename - String containing absolute path to a file including extension.
+      #            e.g. "/Users/schneems/sprockets/test/fixtures/asset/application.js"
+      # accept   - String. A Quality value incoded set of
+      #            mime types that we are looking for. Can be nil.
+      #            e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      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 PathUtils.paths_split(paths, filename)
+
+        _, mime_type = PathUtils.match_path_extname(filename, config[:mime_exts])
+        type = resolve_transform_type(mime_type, accept)
+        return nil, nil, deps if accept && !type
+
+        return nil, nil, deps unless file?(filename)
+
+        deps << URIUtils.build_file_digest_uri(filename)
+        return filename, type, deps
+      end
+
+      # Internal: Finds a relative file in a set of given paths
+      #
+      # paths   - Array of Strings.
+      # path    - String. A relative filename with or without extension
+      #           e.g. "./jquery" or "../foo.js"
+      # dirname - String. Base path where we start looking for the given file.
+      # accept  - String. A Quality value incoded set of
+      #           mime types that we are looking for. Can be nil.
+      #           e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      def resolve_relative_path(paths, path, dirname, accept)
+        filename = File.expand_path(path, dirname)
+        load_path, _ = PathUtils.paths_split(paths, dirname)
+        if load_path && logical_path = PathUtils.split_subpath(load_path, filename)
+          resolve_logical_path([load_path], logical_path, accept)
+        else
+          return nil, nil, nil, Set.new
+        end
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_path - String. A filename with extension
+      #                e.g. "coffee/foo.js" or "foo.js"
+      # accept       - String. A Quality value incoded set of
+      #                mime types that we are looking for. Can be nil.
+      #                e.g. "application/javascript" or "text/css, */*"
+      #
+      # Finds a file on the given paths.
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      def resolve_logical_path(paths, logical_path, accept)
+        extname, mime_type = PathUtils.match_path_extname(logical_path, config[:mime_exts])
+        logical_name = logical_path.chomp(extname)
+
+        extname, pipeline = PathUtils.match_path_extname(logical_name, config[:pipeline_exts])
+        logical_name = logical_name.chomp(extname)
+
+        parsed_accept = parse_accept_options(mime_type, accept)
+        transformed_accepts = expand_transform_accepts(parsed_accept)
+
+        filename, mime_type, deps, index_alias = 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, index_alias
+        else
+          return nil, nil, nil, deps
+        end
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # accepts      - Array of array containing mime/version pairs
+      #                e.g. [["application/javascript", 1.0]]
+      #
+      # Finds a file with the same name as `logical_name` or "index" inside
+      # of the `logical_name` directory that matches a valid mime-type/version from
+      # `accepts`.
+      #
+      # Returns Array. Filename, type, dependencies, and index_alias
+      def resolve_under_paths(paths, logical_name, accepts)
+        deps = Set.new
+        return nil, nil, deps if accepts.empty?
+
+        # TODO: Allow new path resolves to be registered
+        @resolvers ||= [
+          method(:resolve_main_under_path),
+          method(:resolve_alts_under_path),
+          method(:resolve_index_under_path)
+        ]
+        mime_exts = config[:mime_exts]
+
+        paths.each do |load_path|
+          candidates = []
+          @resolvers.each do |fn|
+            result = fn.call(load_path, logical_name, mime_exts)
+            candidates.concat(result[0])
+            deps.merge(result[1])
+          end
+
+          candidate = HTTPUtils.find_best_q_match(accepts, candidates) do |c, matcher|
+            match_mime_type?(c[:type] || "application/octet-stream", matcher)
+          end
+          return candidate[:filename], candidate[:type], deps, candidate[:index_alias] if candidate
+        end
+
+        return nil, nil, deps
+      end
+
+      # Internal: Finds candidate files on a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Finds files that match a given `logical_name` with an acceptable
+      # mime type that is included in `mime_exts` on the `load_path`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_main_under_path(load_path, logical_name, mime_exts)
+        dirname    = File.dirname(File.join(load_path, logical_name))
+        candidates = self.find_matching_path_for_extensions(dirname, File.basename(logical_name), mime_exts)
+        candidates.map! do |c|
+          { filename: c[0], type: c[1] }
+        end
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
+      end
+
+
+      # Internal: Finds candidate index files in a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Looking in the given `load_path` this method will find all files under the `logical_name` directory
+      # that are named `index` and have a matching mime type in `mime_exts`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_index_under_path(load_path, logical_name, mime_exts)
+        dirname = File.join(load_path, logical_name)
+
+        if self.directory?(dirname)
+          candidates = self.find_matching_path_for_extensions(dirname, "index".freeze, mime_exts)
+        else
+          candidates = []
+        end
+
+        candidates.map! do |c|
+          { filename: c[0],
+            type: c[1],
+            index_alias: compress_from_root(c[0].sub(/\/index(\.[^\/]+)$/, '\1')) }
+        end
+
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
+      end
+
+      def resolve_alts_under_path(load_path, logical_name, mime_exts)
+        filenames, deps = self.resolve_alternates(load_path, logical_name)
+        filenames.map! do |fn|
+          _, mime_type = PathUtils.match_path_extname(fn, mime_exts)
+          { filename: fn, type: mime_type }
+        end
+        return filenames, deps
+      end
+
+      # Internal: Converts mimetype into accept Array
+      #
+      # - mime_type     - String, optional. e.g. "text/html"
+      # - explicit_type - String, optional. e.g. "application/javascript"
+      #
+      # When called with an explicit_type and a mime_type, only a mime_type
+      # that matches the given explicit_type will be accepted.
+      #
+      # Returns Array of Array
+      #
+      #     [["application/javascript", 1.0]]
+      #     [["*/*", 1.0]]
+      #     []
+      def parse_accept_options(mime_type, explicit_type)
+        if mime_type
+          return [[mime_type, 1.0]] if explicit_type.nil?
+          return [[mime_type, 1.0]] if HTTPUtils.parse_q_values(explicit_type).any? { |accept, _| HTTPUtils.match_mime_type?(mime_type, accept) }
+          return []
+        end
+
+        accepts = HTTPUtils.parse_q_values(explicit_type)
+        accepts << ['*/*'.freeze, 1.0] if accepts.empty?
+        return accepts
+      end
+
+      def resolve_alternates(load_path, logical_name)
+        return [], Set.new
+      end
+  end
+end

data/lib/sprockets/sass_cache_store.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require 'sass'
+
+module Sprockets
+  class SassProcessor
+    # 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, true)
+      end
+
+      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,63 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
+require 'sprockets/source_map_utils'
+
+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 = {
+        syntax: :scss,
+        cache: false,
+        read_cache: false,
+        style: :compressed
+      }.merge(options).freeze
+      @cache_key = "#{self.class.name}:#{Autoload::Sass::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      css, map = Autoload::Sass::Engine.new(
+        input[:data],
+        @options.merge(filename: input[:filename])
+      ).render_with_sourcemap('')
+
+      css = css.sub("/*# sourceMappingURL= */\n", '')
+
+      map = SourceMapUtils.format_source_map(JSON.parse(map.to_json(css_uri: '')), input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+      { data: css, map: map }
+    end
+  end
+end

data/lib/sprockets/sass_functions.rb

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

data/lib/sprockets/sass_importer.rb

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

data/lib/sprockets/sass_processor.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+require 'rack/utils'
+require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
+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
+      @importer_class = options[:importer] || Sass::Importers::Filesystem
+      @sass_config = options[:sass_config] || {}
+      @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)
+
+      engine_options = merge_options({
+        filename: input[:filename],
+        syntax: self.class.syntax,
+        cache_store: build_cache_store(input, @cache_version),
+        load_paths: context.environment.paths.map { |p| @importer_class.new(p.to_s) },
+        importer: @importer_class.new(Pathname.new(context.filename).to_s),
+        sprockets: {
+          context: context,
+          environment: input[:environment],
+          dependencies: context.metadata[:dependencies]
+        }
+      })
+
+      engine = Autoload::Sass::Engine.new(input[:data], engine_options)
+
+      css, map = Utils.module_include(Autoload::Sass::Script::Functions, @functions) do
+        engine.render_with_sourcemap('')
+      end
+
+      css = css.sub("\n/*# sourceMappingURL= */\n", '')
+
+      map = SourceMapUtils.format_source_map(JSON.parse(map.to_json(css_uri: '')), input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+      # 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, map: map)
+    end
+
+    private
+
+    # Public: Build the cache store to be used by the Sass engine.
+    #
+    # input - the input hash.
+    # version - the cache version.
+    #
+    # Override this method if you need to use a different cache than the
+    # Sprockets cache.
+    def build_cache_store(input, version)
+      CacheStore.new(input[:cache], version)
+    end
+
+    def merge_options(options)
+      defaults = @sass_config.dup
+
+      if load_paths = defaults.delete(:load_paths)
+        options[:load_paths] += load_paths
+      end
+
+      options.merge!(defaults)
+      options
+    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