sprockets 2.11.3 → 3.7.2

data/lib/sprockets/http_utils.rb

@@ -0,0 +1,117 @@
+module Sprockets
+  # Internal: HTTP URI utilities. Many adapted from Rack::Utils. Mixed into
+  # Environment.
+  module HTTPUtils
+    extend self
+
+    # Public: Test mime type against mime range.
+    #
+    #    match_mime_type?('text/html', 'text/*') => true
+    #    match_mime_type?('text/plain', '*') => true
+    #    match_mime_type?('text/html', 'application/json') => false
+    #
+    # Returns true if the given value is a mime match for the given mime match
+    # specification, false otherwise.
+    def match_mime_type?(value, matcher)
+      v1, v2 = value.split('/', 2)
+      m1, m2 = matcher.split('/', 2)
+      (m1 == '*' || v1 == m1) && (m2.nil? || m2 == '*' || m2 == v2)
+    end
+
+    # Public: Return values from Hash where the key matches the mime type.
+    #
+    # hash      - Hash of String matcher keys to Object values
+    # mime_type - String mime type
+    #
+    # Returns Array of Object values.
+    def match_mime_type_keys(hash, mime_type)
+      type, subtype = mime_type.split('/', 2)
+      [
+        hash["*"],
+        hash["*/*"],
+        hash["#{type}/*"],
+        hash["#{type}/#{subtype}"]
+      ].compact
+    end
+
+    # Internal: Parse Accept header quality values.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns an Array of [String, Float].
+    def parse_q_values(values)
+      values.to_s.split(/\s*,\s*/).map do |part|
+        value, parameters = part.split(/\s*;\s*/, 2)
+        quality = 1.0
+        if md = /\Aq=([\d.]+)/.match(parameters)
+          quality = md[1].to_f
+        end
+        [value, quality]
+      end
+    end
+
+    # Internal: Find all qvalue matches from an Array of available options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns Array of matched Strings from available Array or [].
+    def find_q_matches(q_values, available, &matcher)
+      matcher ||= lambda { |a, b| a == b }
+
+      matches = []
+
+      case q_values
+      when Array
+      when String
+        q_values = parse_q_values(q_values)
+      when NilClass
+        q_values = []
+      else
+        raise TypeError, "unknown q_values type: #{q_values.class}"
+      end
+
+      q_values.each do |accepted, quality|
+        if match = available.find { |option| matcher.call(option, accepted) }
+          matches << [match, quality]
+        end
+      end
+
+      matches.sort_by! { |match, quality| -quality }
+      matches.map! { |match, quality| match }
+      matches
+    end
+
+    # Internal: Find the best qvalue match from an Array of available options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns the matched String from available Array or nil.
+    def find_best_q_match(q_values, available, &matcher)
+      find_q_matches(q_values, available, &matcher).first
+    end
+
+    # Internal: Find the all qvalue match from an Array of available mime type
+    # options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns Array of matched mime type Strings from available Array or [].
+    def find_mime_type_matches(q_value_header, available)
+      find_q_matches(q_value_header, available) do |a, b|
+        match_mime_type?(a, b)
+      end
+    end
+
+    # Internal: Find the best qvalue match from an Array of available mime type
+    # options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns the matched mime type String from available Array or nil.
+    def find_best_mime_type_match(q_value_header, available)
+      find_best_q_match(q_value_header, available) do |a, b|
+        match_mime_type?(a, b)
+      end
+    end
+  end
+end

data/lib/sprockets/jst_processor.rb

@@ -1,29 +1,49 @@
-require 'tilt'
-
 module Sprockets
-  class JstProcessor < Tilt::Template
-    self.default_mime_type = 'application/javascript'
-
+  # Public: .jst engine.
+  #
+  # Exports server side compiled templates to an object.
+  #
+  # Name your template "users/show.jst.ejs", "users/new.jst.eco", etc.
+  #
+  # To accept the default options
+  #
+  #     environment.register_engine '.jst',
+  #       JstProcessor,
+  #       mime_type: 'application/javascript'
+  #
+  # Change the default namespace.
+  #
+  #     environment.register_engine '.jst',
+  #       JstProcessor.new(namespace: 'App.templates'),
+  #       mime_type: 'application/javascript'
+  #
+  class JstProcessor
     def self.default_namespace
       'this.JST'
     end
 
-    def prepare
-      @namespace = self.class.default_namespace
+    # Public: Return singleton instance with default options.
+    #
+    # Returns JstProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
     end
 
-    attr_reader :namespace
+    def initialize(options = {})
+      @namespace = options[:namespace] || self.class.default_namespace
+    end
 
-    def evaluate(scope, locals, &block)
+    def call(input)
+      data = input[:data].gsub(/$(.)/m, "\\1  ").strip
+      key  = input[:name]
       <<-JST
-(function() { #{namespace} || (#{namespace} = {}); #{namespace}[#{scope.logical_path.inspect}] = #{indent(data)};
+(function() { #{@namespace} || (#{@namespace} = {}); #{@namespace}[#{key.inspect}] = #{data};
 }).call(this);
       JST
     end
-
-    private
-      def indent(string)
-        string.gsub(/$(.)/m, "\\1  ").strip
-      end
   end
 end

data/lib/sprockets/legacy.rb

@@ -0,0 +1,330 @@
+require 'pathname'
+require 'sprockets/asset'
+require 'sprockets/base'
+require 'sprockets/cached_environment'
+require 'sprockets/context'
+require 'sprockets/manifest'
+require 'sprockets/resolve'
+
+module Sprockets
+  autoload :CoffeeScriptTemplate, 'sprockets/coffee_script_template'
+  autoload :EcoTemplate, 'sprockets/eco_template'
+  autoload :EjsTemplate, 'sprockets/ejs_template'
+  autoload :ERBTemplate, 'sprockets/erb_template'
+  autoload :SassTemplate, 'sprockets/sass_template'
+  autoload :ScssTemplate, 'sprockets/sass_template'
+
+  # Deprecated
+  Index = CachedEnvironment
+
+  class Base
+    include Resolve
+
+    # Deprecated: Change default return type of resolve() to return 2.x
+    # compatible plain filename String. 4.x will always return an Asset URI
+    # and a set of file system dependencies that had to be read to compute the
+    # result.
+    #
+    #   2.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #   3.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: true)
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: false)
+    #     # => [
+    #     #   "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #     #    #<Set: {"file-digest:/path/to/app/javascripts/foo.js"}>
+    #     # ]
+    #
+    #   4.x
+    #
+    #     resolve("foo.js")
+    #     # => [
+    #     #   "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #     #    #<Set: {"file-digest:/path/to/app/javascripts/foo.js"}>
+    #     # ]
+    #
+    def resolve_with_compat(path, options = {})
+      options = options.dup
+      if options.delete(:compat) { true }
+        uri, _ = resolve_without_compat(path, options)
+        if uri
+          path, _ = parse_asset_uri(uri)
+          path
+        else
+          nil
+        end
+      else
+        resolve_without_compat(path, options)
+      end
+    end
+    alias_method :resolve_without_compat, :resolve
+    alias_method :resolve, :resolve_with_compat
+
+    # 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
+
+    # Deprecated: 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
+
+      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
+
+    def cache_get(key)
+      cache.get(key)
+    end
+
+    def cache_set(key, value)
+      cache.set(key, value)
+    end
+
+    def normalize_logical_path(path)
+      dirname, basename = File.split(path)
+      path = dirname if basename == 'index'
+      path
+    end
+
+    private
+      # Deprecated: Seriously.
+      def matches_filter(filters, logical_path, filename)
+        return true if filters.empty?
+
+        filters.any? do |filter|
+          if filter.is_a?(Regexp)
+            filter.match(logical_path)
+          elsif filter.respond_to?(:call)
+            if filter.arity == 1
+              filter.call(logical_path)
+            else
+              filter.call(logical_path, filename.to_s)
+            end
+          else
+            File.fnmatch(filter.to_s, logical_path)
+          end
+        end
+      end
+
+      # URI.unescape is deprecated on 1.9. We need to use URI::Parser
+      # if its available.
+      if defined? URI::DEFAULT_PARSER
+        def unescape(str)
+          str = URI::DEFAULT_PARSER.unescape(str)
+          str.force_encoding(Encoding.default_internal) if Encoding.default_internal
+          str
+        end
+      else
+        def unescape(str)
+          URI.unescape(str)
+        end
+      end
+  end
+
+  class Asset
+    # Deprecated: Use #filename instead.
+    #
+    # Returns Pathname.
+    def pathname
+      @pathname ||= Pathname.new(filename)
+    end
+
+    # Deprecated: Expand asset into an `Array` of parts.
+    #
+    # Appending all of an assets body parts together should give you
+    # the asset's contents as a whole.
+    #
+    # This allows you to link to individual files for debugging
+    # purposes.
+    #
+    # Use Asset#included instead. Keeping a full copy of the bundle's processed
+    # assets in memory (and in cache) is expensive and redundant. The common use
+    # case is to relink to the assets anyway.
+    #
+    # Returns Array of Assets.
+    def to_a
+      if metadata[:included]
+        metadata[:included].map { |uri| @environment.load(uri) }
+      else
+        [self]
+      end
+    end
+
+    # Deprecated: Get all required Assets.
+    #
+    # See Asset#to_a
+    #
+    # Returns Array of Assets.
+    def dependencies
+      to_a.reject { |a| a.filename.eql?(self.filename) }
+    end
+
+    # Deprecated: Returns Time of the last time the source was modified.
+    #
+    # Time resolution is normalized to the nearest second.
+    #
+    # Returns Time.
+    def mtime
+      Time.at(@mtime)
+    end
+  end
+
+  class Context
+    # Deprecated: Change default return type of resolve() to return 2.x
+    # compatible plain filename String. 4.x will always return an Asset URI.
+    #
+    #   2.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #   3.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: true)
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: false)
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #
+    #   4.x
+    #
+    #     resolve("foo.js")
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #
+    def resolve_with_compat(path, options = {})
+      options = options.dup
+
+      # Support old :content_type option, prefer :accept going forward
+      if type = options.delete(:content_type)
+        type = self.content_type if type == :self
+        options[:accept] ||= type
+      end
+
+      if options.delete(:compat) { true }
+        uri = resolve_without_compat(path, options)
+        path, _ = environment.parse_asset_uri(uri)
+        path
+      else
+        resolve_without_compat(path, options)
+      end
+    end
+    alias_method :resolve_without_compat, :resolve
+    alias_method :resolve, :resolve_with_compat
+  end
+
+  class Manifest
+    # Deprecated: Compile logical path matching filter into a proc that can be
+    # passed to logical_paths.select(&proc).
+    #
+    #   compile_match_filter(proc { |logical_path|
+    #     File.extname(logical_path) == '.js'
+    #   })
+    #
+    #   compile_match_filter(/application.js/)
+    #
+    #   compile_match_filter("foo/*.js")
+    #
+    # Returns a Proc or raise a TypeError.
+    def self.compile_match_filter(filter)
+      # If the filter is already a proc, great nothing to do.
+      if filter.respond_to?(:call)
+        filter
+      # If the filter is a regexp, wrap it in a proc that tests it against the
+      # logical path.
+      elsif filter.is_a?(Regexp)
+        proc { |logical_path| filter.match(logical_path) }
+      elsif filter.is_a?(String)
+        # If its an absolute path, detect the matching full filename
+        if PathUtils.absolute_path?(filter)
+          proc { |logical_path, filename| filename == filter.to_s }
+        else
+          # Otherwise do an fnmatch against the logical path.
+          proc { |logical_path| File.fnmatch(filter.to_s, logical_path) }
+        end
+      else
+        raise TypeError, "unknown filter type: #{filter.inspect}"
+      end
+    end
+
+    def self.simple_logical_path?(str)
+      str.is_a?(String) &&
+        !PathUtils.absolute_path?(str) &&
+        str !~ /\*|\*\*|\?|\[|\]|\{|\}/
+    end
+
+    def self.compute_alias_logical_path(path)
+      dirname, basename = File.split(path)
+      extname = File.extname(basename)
+      if File.basename(basename, extname) == 'index'
+        "#{dirname}#{extname}"
+      else
+        nil
+      end
+    end
+
+    # Deprecated: Filter logical paths in environment. Useful for selecting what
+    # files you want to compile.
+    #
+    # Returns an Enumerator.
+    def filter_logical_paths(*args)
+      filters = args.flatten.map { |arg| self.class.compile_match_filter(arg) }
+      environment.cached.logical_paths.select do |a, b|
+        filters.any? { |f| f.call(a, b) }
+      end
+    end
+
+    # Deprecated alias.
+    alias_method :find_logical_paths, :filter_logical_paths
+  end
+end

data/lib/sprockets/legacy_proc_processor.rb

@@ -0,0 +1,35 @@
+require 'delegate'
+
+module Sprockets
+  # Deprecated: Wraps legacy process Procs with new processor call signature.
+  #
+  # Will be removed in Sprockets 4.x.
+  #
+  #     LegacyProcProcessor.new(:compress,
+  #       proc { |context, data| data.gsub(...) })
+  #
+  class LegacyProcProcessor < Delegator
+    def initialize(name, proc)
+      @name = name
+      @proc = proc
+    end
+
+    def __getobj__
+      @proc
+    end
+
+    def name
+      "Sprockets::LegacyProcProcessor (#{@name})"
+    end
+
+    def to_s
+      name
+    end
+
+    def call(input)
+      context = input[:environment].context_class.new(input)
+      data = @proc.call(context, input[:data])
+      context.metadata.merge(data: data.to_str)
+    end
+  end
+end

data/lib/sprockets/legacy_tilt_processor.rb

@@ -0,0 +1,29 @@
+require 'delegate'
+
+module Sprockets
+  # Deprecated: Wraps legacy engine and process Tilt templates with new
+  # processor call signature.
+  #
+  # Will be removed in Sprockets 4.x.
+  #
+  #     LegacyTiltProcessor.new(Tilt::CoffeeScriptProcessor)
+  #
+  class LegacyTiltProcessor < Delegator
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def __getobj__
+      @klass
+    end
+
+    def call(input)
+      filename = input[:filename]
+      data     = input[:data]
+      context  = input[:environment].context_class.new(input)
+
+      data = @klass.new(filename) { data }.render(context, {})
+      context.metadata.merge(data: data.to_str)
+    end
+  end
+end