sprockets 2.11.3 → 3.7.2

data/lib/sprockets/resolve.rb

@@ -0,0 +1,211 @@
+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}'"
+
+        if relative_path?(path) && options[:base_path]
+          load_path, _ = paths_split(config[:paths], options[:base_path])
+          message << " under '#{load_path}'"
+        end
+
+        message << " with type '#{options[:accept]}'" if options[:accept]
+        message << "\nChecked in these paths: \n  #{ config[:paths].join("\n  ") }"
+
+        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 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|
+          next unless File.basename(entry).start_with?(basename)
+          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,29 +1,34 @@
 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[:contents]
-      else
-        nil
+      def _retrieve(key, version, sha)
+        @cache.get("#{@version}/#{version}/#{key}/#{sha}", true)
+      end
+
+      def path_to(key)
+        key
       end
     end
+  end
 
-    def path_to(key)
-      key
+  # Deprecated: Use Sprockets::SassProcessor::CacheStore instead.
+  class SassCacheStore < SassProcessor::CacheStore
+    def initialize(*args)
+      Deprecation.new.warn "SassCacheStore is deprecated please use SassProcessor::CacheStore instead"
+      super
     end
   end
 end

data/lib/sprockets/sass_compressor.rb

@@ -1,27 +1,51 @@
-require 'tilt'
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
 
 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)
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SassCompressor object.
+    def self.instance
+      @instance ||= new
     end
 
-    def initialize_engine
-      require_template_library 'sass'
+    def self.call(input)
+      instance.call(input)
     end
 
-    def prepare
+    def self.cache_key
+      instance.cache_key
     end
 
-    def evaluate(context, locals, &block)
-      ::Sass::Engine.new(data, {
-        :syntax => :scss,
-        :cache => false,
-        :read_cache => false,
-        :style => :compressed
-      }).render
+    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)
+      Autoload::Sass::Engine.new(input[:data], @options).render
     end
   end
 end

data/lib/sprockets/sass_functions.rb

@@ -1,70 +1,2 @@
-require 'sass'
-
-module Sprockets
-  module SassFunctions
-    def asset_path(path)
-      Sass::Script::String.new(sprockets_context.asset_path(path.value), :string)
-    end
-
-    def asset_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.asset_path(path.value) + ")")
-    end
-
-    def image_path(path)
-      Sass::Script::String.new(sprockets_context.image_path(path.value), :string)
-    end
-
-    def image_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.image_path(path.value) + ")")
-    end
-
-    def video_path(path)
-      Sass::Script::String.new(sprockets_context.video_path(path.value), :string)
-    end
-
-    def video_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.video_path(path.value) + ")")
-    end
-
-    def audio_path(path)
-      Sass::Script::String.new(sprockets_context.audio_path(path.value), :string)
-    end
-
-    def audio_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.audio_path(path.value) + ")")
-    end
-
-    def font_path(path)
-      Sass::Script::String.new(sprockets_context.font_path(path.value), :string)
-    end
-
-    def font_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.font_path(path.value) + ")")
-    end
-
-    def javascript_path(path)
-      Sass::Script::String.new(sprockets_context.javascript_path(path.value), :string)
-    end
-
-    def javascript_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.javascript_path(path.value) + ")")
-    end
-
-    def stylesheet_path(path)
-      Sass::Script::String.new(sprockets_context.stylesheet_path(path.value), :string)
-    end
-
-    def stylesheet_url(path)
-      Sass::Script::String.new("url(" + sprockets_context.stylesheet_path(path.value) + ")")
-    end
-
-    protected
-      def sprockets_context
-        options[:sprockets][:context]
-      end
-
-      def sprockets_environment
-        options[:sprockets][:environment]
-      end
-  end
-end
+# 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(filename)
-      end
-      engine
-    end
-
-    def find(*args)
-      engine = super
-      if engine && (filename = engine.options[:filename])
-        @context.depend_on(filename)
-      end
-      engine
-    end
-  end
-end
+# Deprecated: Require sprockets/sass_processor instead
+require 'sprockets/sass_processor'