sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/erb_template.rb

@@ -0,0 +1,23 @@
+require 'erb'
+
+module Sprockets
+  class ERBTemplate
+    def self.call(input)
+      new.call(input)
+    end
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call(input)
+      engine = ::ERB.new(input[:data], nil, '<>')
+      context = input[:environment].context_class.new(input)
+      klass = (class << context; self; end)
+      klass.class_eval(&@block) if @block
+      engine.def_method(klass, :_evaluate_template, input[:filename])
+      data = context._evaluate_template
+      context.metadata.merge(data: data)
+    end
+  end
+end

data/lib/sprockets/errors.rb

@@ -2,19 +2,11 @@
 module Sprockets
   class Error           < StandardError; end
   class ArgumentError           < Error; end
-  class CircularDependencyError < Error; end
   class ContentTypeMismatch     < Error; end
-  class EncodingError           < Error; end
-  class FileNotFound            < Error; end
-  class FileOutsidePaths        < Error; end
   class NotImplementedError     < Error; end
-  class UnserializeError        < Error; end
-
-  module EngineError
-    attr_accessor :sprockets_annotation
-
-    def message
-      [super, sprockets_annotation].compact.join("\n")
-    end
-  end
+  class NotFound                < Error; end
+  class ConversionError         < NotFound; end
+  class FileNotFound            < NotFound; end
+  class FileOutsidePaths        < NotFound; end
+  class VersionNotFound         < NotFound; end
 end

data/lib/sprockets/http_utils.rb

@@ -0,0 +1,97 @@
+module Sprockets
+  module HTTPUtils
+    extend self
+
+    # Internal: 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
+
+    # 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 }.map { |match, quality| match }
+    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,42 @@
-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
+    def self.call(*args)
+      new.call(*args)
     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/lazy_processor.rb

@@ -0,0 +1,15 @@
+module Sprockets
+  # Internal: Used for lazy loading processors.
+  #
+  #   LazyProcessor.new { CoffeeScriptTemplate }
+  #
+  class LazyProcessor
+    def initialize(&block)
+      @block = block
+    end
+
+    def unwrap
+      @obj ||= @block.call
+    end
+  end
+end

data/lib/sprockets/legacy.rb

@@ -0,0 +1,23 @@
+module Sprockets
+  module Legacy
+    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
+  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)
+    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::CoffeeScriptTemplate)
+  #
+  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)
+    end
+  end
+end

data/lib/sprockets/manifest.rb

@@ -1,26 +1,25 @@
-require 'multi_json'
+require 'json'
 require 'securerandom'
 require 'time'
 
 module Sprockets
-  # The Manifest logs the contents of assets compiled to a single
-  # directory. It records basic attributes about the asset for fast
-  # lookup without having to compile. A pointer from each logical path
-  # indicates with fingerprinted asset is the current one.
+  # The Manifest logs the contents of assets compiled to a single directory. It
+  # records basic attributes about the asset for fast lookup without having to
+  # compile. A pointer from each logical path indicates which fingerprinted
+  # asset is the current one.
   #
-  # The JSON is part of the public API and should be considered
-  # stable. This should make it easy to read from other programming
-  # languages and processes that don't have sprockets loaded. See
-  # `#assets` and `#files` for more infomation about the structure.
+  # The JSON is part of the public API and should be considered stable. This
+  # should make it easy to read from other programming languages and processes
+  # that don't have sprockets loaded. See `#assets` and `#files` for more
+  # infomation about the structure.
   class Manifest
-    attr_reader :environment, :path, :dir
-
-    # Create new Manifest associated with an `environment`. `path` is
-    # a full path to the manifest json file. The file may or may not
-    # already exist. The dirname of the `path` will be used to write
-    # compiled assets to. Otherwise, if the path is a directory, the
-    # filename will default a random "manifest-123.json" file in that
-    # directory.
+    attr_reader :environment
+
+    # Create new Manifest associated with an `environment`. `filename` is a full
+    # path to the manifest json file. The file may or may not already exist. The
+    # dirname of the `filename` will be used to write compiled assets to.
+    # Otherwise, if the path is a directory, the filename will default a random
+    # "manifest-123.json" file in that directory.
     #
     #   Manifest.new(environment, "./public/assets/manifest.json")
     #
@@ -29,48 +28,55 @@ module Sprockets
         @environment = args.shift
       end
 
-      @dir, @path = args[0], args[1]
+      @directory, @filename = args[0], args[1]
 
       # Expand paths
-      @dir  = File.expand_path(@dir) if @dir
-      @path = File.expand_path(@path) if @path
+      @directory = File.expand_path(@directory) if @directory
+      @filename  = File.expand_path(@filename) if @filename
 
-      # If path is given as the second arg
-      if @dir && File.extname(@dir) != ""
-        @dir, @path = nil, @dir
+      # If filename is given as the second arg
+      if @directory && File.extname(@directory) != ""
+        @directory, @filename = nil, @directory
       end
 
-      # Default dir to the directory of the path
-      @dir ||= File.dirname(@path) if @path
+      # Default dir to the directory of the filename
+      @directory ||= File.dirname(@filename) if @filename
 
-      # If directory is given w/o path, pick a random manifest.json location
-      if @dir && @path.nil?
+      # If directory is given w/o filename, pick a random manifest.json location
+      if @directory && @filename.nil?
         # Find the first manifest.json in the directory
-        paths = Dir[File.join(@dir, "manifest*.json")]
-        if paths.any?
-          @path = paths.first
+        filenames = Dir[File.join(@directory, "manifest*.json")]
+        if filenames.any?
+          @filename = filenames.first
         else
-          @path = File.join(@dir, "manifest-#{SecureRandom.hex(16)}.json")
+          @filename = File.join(@directory, "manifest-#{SecureRandom.hex(16)}.json")
         end
       end
 
-      unless @dir && @path
-        raise ArgumentError, "manifest requires output path"
+      unless @directory && @filename
+        raise ArgumentError, "manifest requires output filename"
       end
 
-      data = nil
+      data = {}
 
       begin
-        if File.exist?(@path)
-          data = json_decode(File.read(@path))
+        if File.exist?(@filename)
+          data = json_decode(File.read(@filename))
         end
-      rescue MultiJson::DecodeError => e
-        logger.error "#{@path} is invalid: #{e.class} #{e.message}"
+      rescue JSON::ParserError => e
+        logger.error "#{@filename} is invalid: #{e.class} #{e.message}"
       end
 
-      @data = data.is_a?(Hash) ? data : {}
+      @data = data
     end
 
+    # Returns String path to manifest.json file.
+    attr_reader :filename
+    alias_method :path, :filename
+
+    attr_reader :directory
+    alias_method :dir, :directory
+
     # Returns internal assets mapping. Keys are logical paths which
     # map to the latest fingerprinted filename.
     #
@@ -100,6 +106,53 @@ module Sprockets
       @data['files'] ||= {}
     end
 
+    # Internal: 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
+
+    # Public: 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.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
+
     # Compile and write asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
@@ -112,11 +165,10 @@ module Sprockets
         raise Error, "manifest requires environment for compilation"
       end
 
-      paths = environment.each_logical_path(*args).to_a +
-        args.flatten.select { |fn| Pathname.new(fn).absolute? if fn.is_a?(String)}
+      filenames = []
 
-      paths.each do |path|
-        if asset = find_asset(path)
+      filter_logical_paths(*args).each do |_, filename|
+        find_assets(filename) do |asset|
           files[asset.digest_path] = {
             'logical_path' => asset.logical_path,
             'mtime'        => asset.mtime.iso8601,
@@ -132,13 +184,14 @@ module Sprockets
           else
             logger.info "Writing #{target}"
             asset.write_to target
-            asset.write_to "#{target}.gz" if asset.is_a?(BundledAsset)
           end
 
+          filenames << filename
         end
       end
       save
-      paths
+
+      filenames
     end
 
     # Removes file from directory and from manifest. `filename` must
@@ -148,7 +201,6 @@ module Sprockets
     #
     def remove(filename)
       path = File.join(dir, filename)
-      gzip = "#{path}.gz"
       logical_path = files[filename]['logical_path']
 
       if assets[logical_path] == filename
@@ -157,7 +209,6 @@ module Sprockets
 
       files.delete(filename)
       FileUtils.rm(path) if File.exist?(path)
-      FileUtils.rm(gzip) if File.exist?(gzip)
 
       save
 
@@ -169,77 +220,61 @@ module Sprockets
     # Cleanup old assets in the compile directory. By default it will
     # keep the latest version plus 2 backups.
     def clean(keep = 2)
-      self.assets.keys.each do |logical_path|
-        # Get assets sorted by ctime, newest first
-        assets = backups_for(logical_path)
+      asset_versions = files.group_by { |_, attrs| attrs['logical_path'] }
+
+      asset_versions.each do |logical_path, versions|
+        current = assets[logical_path]
+
+        backups = versions.reject { |path, _|
+          path == current
+        }.sort_by { |_, attrs|
+          # Sort by timestamp
+          Time.parse(attrs['mtime'])
+        }.reverse
 
         # Keep the last N backups
-        assets = assets[keep..-1] || []
+        backups = backups[keep..-1] || []
 
         # Remove old assets
-        assets.each { |path, _| remove(path) }
+        backups.each { |path, _| remove(path) }
       end
     end
 
     # Wipe directive
     def clobber
-      FileUtils.rm_r(@dir) if File.exist?(@dir)
-      logger.info "Removed #{@dir}"
+      FileUtils.rm_r(directory) if File.exist?(directory)
+      logger.info "Removed #{directory}"
       nil
     end
 
     protected
-      # Finds all the backup assets for a logical path. The latest
-      # version is always excluded. The return array is sorted by the
-      # assets mtime in descending order (Newest to oldest).
-      def backups_for(logical_path)
-        files.select { |filename, attrs|
-          # Matching logical paths
-          attrs['logical_path'] == logical_path &&
-            # Excluding whatever asset is the current
-            assets[logical_path] != filename
-        }.sort_by { |filename, attrs|
-          # Sort by timestamp
-          Time.parse(attrs['mtime'])
-        }.reverse
-      end
-
       # Basic wrapper around Environment#find_asset. Logs compile time.
-      def find_asset(logical_path)
-        asset = nil
-        ms = benchmark do
-          asset = environment.find_asset(logical_path)
+      def find_assets(path)
+        start = Utils.benchmark_start
+        environment.find_all_linked_assets(path) do |asset|
+          logger.debug do
+            "Compiled #{asset.logical_path}  (#{Utils.benchmark_end(start)}ms)"
+          end
+          yield asset
+          start = Utils.benchmark_start
         end
-        logger.debug "Compiled #{logical_path}  (#{ms}ms)"
-        asset
       end
 
       # Persist manfiest back to FS
       def save
-        FileUtils.mkdir_p File.dirname(path)
-        File.open(path, 'w') do |f|
+        FileUtils.mkdir_p File.dirname(filename)
+        File.open(filename, 'w') do |f|
           f.write json_encode(@data)
         end
       end
 
     private
-      # Feature detect newer MultiJson API
-      if MultiJson.respond_to?(:dump)
-        def json_decode(obj)
-          MultiJson.load(obj)
-        end
-
-        def json_encode(obj)
-          MultiJson.dump(obj)
-        end
-      else
-        def json_decode(obj)
-          MultiJson.decode(obj)
-        end
+      def json_decode(obj)
+        JSON.parse(obj, create_additions: false)
+      end
 
-        def json_encode(obj)
-          MultiJson.encode(obj)
-        end
+      def json_encode(obj)
+        JSON.generate(obj)
       end
 
       def logger
@@ -251,11 +286,5 @@ module Sprockets
           logger
         end
       end
-
-      def benchmark
-        start_time = Time.now.to_f
-        yield
-        ((Time.now.to_f - start_time) * 1000).to_i
-      end
   end
 end