sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/context.rb

@@ -1,15 +1,13 @@
-require 'base64'
-require 'rack/utils'
-require 'sprockets/errors'
-require 'sprockets/utils'
 require 'pathname'
+require 'rack/utils'
 require 'set'
+require 'sprockets/errors'
 
 module Sprockets
-  # `Context` provides helper methods to all `Tilt` processors. They
-  # are typically accessed by ERB templates. You can mix in custom
-  # helpers by injecting them into `Environment#context_class`. Do not
-  # mix them into `Context` directly.
+  # Deprecated: `Context` provides helper methods to all `Template` processors.
+  # They are typically accessed by ERB templates. You can mix in custom helpers
+  # by injecting them into `Environment#context_class`. Do not mix them into
+  # `Context` directly.
   #
   #     environment.context_class.class_eval do
   #       include MyHelper
@@ -21,49 +19,52 @@ module Sprockets
   # The `Context` also collects dependencies declared by
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
-    attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_stubbed_assets
-    attr_reader :_dependency_paths, :_dependency_assets
-    attr_writer :__LINE__
+    attr_reader :environment, :filename, :pathname
 
-    def initialize(environment, logical_path, pathname)
-      @environment  = environment
-      @logical_path = logical_path
-      @pathname     = pathname
-      @__LINE__     = nil
+    def initialize(input)
+      @environment  = input[:environment]
+      @metadata     = input[:metadata]
+      @load_path    = input[:load_path]
+      @logical_path = input[:name]
+      @filename     = input[:filename]
+      @dirname      = File.dirname(@filename)
+      @pathname     = Pathname.new(@filename)
+      @content_type = input[:content_type]
 
-      @_required_paths    = []
-      @_stubbed_assets    = Set.new
-      @_dependency_paths  = Set.new
-      @_dependency_assets = Set.new([pathname.to_s])
+      @required         = Set.new(@metadata[:required])
+      @stubbed          = Set.new(@metadata[:stubbed])
+      @links            = Set.new(@metadata[:links])
+      @dependency_paths = Set.new(@metadata[:dependency_paths])
+    end
+
+    def metadata
+      { required: @required,
+        stubbed: @stubbed,
+        links: @links,
+        dependency_paths: @dependency_paths }
     end
 
     # Returns the environment path that contains the file.
     #
     # If `app/javascripts` and `app/stylesheets` are in your path, and
-    # current file is `app/javascripts/foo/bar.js`, `root_path` would
+    # current file is `app/javascripts/foo/bar.js`, `load_path` would
     # return `app/javascripts`.
-    def root_path
-      environment.paths.detect { |path| pathname.to_s[path] }
-    end
+    attr_reader :load_path
+    alias_method :root_path, :load_path
 
     # Returns logical path without any file extensions.
     #
     #     'app/javascripts/application.js'
     #     # => 'application'
     #
-    def logical_path
-      @logical_path.chomp(File.extname(@logical_path))
-    end
+    attr_reader :logical_path
 
     # Returns content type of file
     #
     #     'application/javascript'
     #     'text/css'
     #
-    def content_type
-      environment.content_type_of(pathname)
-    end
+    attr_reader :content_type
 
     # Given a logical path, `resolve` will find and return the fully
     # expanded path. Relative paths will also be resolved. An optional
@@ -76,36 +77,21 @@ module Sprockets
     #     resolve("./bar.js")
     #     # => "/path/to/app/javascripts/bar.js"
     #
-    def resolve(path, options = {}, &block)
-      pathname   = Pathname.new(path)
-      attributes = environment.attributes_for(pathname)
+    def resolve(path, options = {})
+      options[:content_type] = self.content_type if options[:content_type] == :self
+      options[:accept] = options.delete(:content_type)
 
-      if pathname.absolute?
-        if environment.stat(pathname)
-          pathname
+      if environment.absolute_path?(path)
+        path
+      elsif environment.relative_path?(path)
+        path = File.expand_path(path, @dirname)
+        if logical_path = @environment.split_subpath(load_path, path)
+          environment.resolve_in_load_path(load_path, logical_path, options)
         else
-          raise FileNotFound, "couldn't find file '#{pathname}'"
+          raise FileOutsidePaths, "#{path} isn't under path: #{load_path}"
         end
-
-      elsif content_type = options[:content_type]
-        content_type = self.content_type if content_type == :self
-
-        if attributes.format_extension
-          if content_type != attributes.content_type
-            raise ContentTypeMismatch, "#{path} is " +
-              "'#{attributes.content_type}', not '#{content_type}'"
-          end
-        end
-
-        resolve(path) do |candidate|
-          if self.content_type == environment.content_type_of(candidate)
-            return candidate
-          end
-        end
-
-        raise FileNotFound, "couldn't find file '#{path}'"
       else
-        environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
+        environment.resolve(path, options)
       end
     end
 
@@ -116,7 +102,7 @@ module Sprockets
     # the dependency file with invalidate the cache of the
     # source file.
     def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
+      @dependency_paths << resolve(path).to_s
       nil
     end
 
@@ -128,8 +114,9 @@ module Sprockets
     # file. Unlike `depend_on`, this will include recursively include
     # the target asset's dependencies.
     def depend_on_asset(path)
-      filename = resolve(path).to_s
-      @_dependency_assets << filename
+      if asset = @environment.find_asset(resolve(path))
+        @dependency_paths.merge(asset.metadata[:dependency_paths])
+      end
       nil
     end
 
@@ -143,9 +130,8 @@ module Sprockets
     #     <%= require_asset "#{framework}.js" %>
     #
     def require_asset(path)
-      pathname = resolve(path, :content_type => :self)
-      depend_on_asset(pathname)
-      @_required_paths << pathname.to_s
+      filename = resolve(path, accept: @content_type)
+      @required << @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
       nil
     end
 
@@ -153,55 +139,22 @@ module Sprockets
     # `path` must be an asset which may or may not already be included
     # in the bundle.
     def stub_asset(path)
-      @_stubbed_assets << resolve(path, :content_type => :self).to_s
+      filename = resolve(path, accept: @content_type)
+      @stubbed << @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
       nil
     end
 
-    # Tests if target path is able to be safely required into the
-    # current concatenation.
-    def asset_requirable?(path)
-      pathname = resolve(path)
-      content_type = environment.content_type_of(pathname)
-      stat = environment.stat(path)
-      return false unless stat && stat.file?
-      self.content_type.nil? || self.content_type == content_type
-    end
-
-    # Reads `path` and runs processors on the file.
-    #
-    # This allows you to capture the result of an asset and include it
-    # directly in another.
+    # `link_asset` declares an external dependency on an asset without directly
+    # including it. The target asset is returned from this function making it
+    # easy to construct a link to it.
     #
-    #     <%= evaluate "bar.js" %>
-    #
-    def evaluate(path, options = {})
-      pathname   = resolve(path)
-      attributes = environment.attributes_for(pathname)
-      processors = options[:processors] || attributes.processors
-
-      if options[:data]
-        result = options[:data]
-      else
-        if environment.respond_to?(:default_external_encoding)
-          mime_type = environment.mime_types(pathname.extname)
-          encoding  = environment.encoding_for_mime_type(mime_type)
-          result    = Sprockets::Utils.read_unicode(pathname, encoding)
-        else
-          result = Sprockets::Utils.read_unicode(pathname)
-        end
-      end
-
-      processors.each do |processor|
-        begin
-          template = processor.new(pathname.to_s) { result }
-          result = template.render(self, {})
-        rescue Exception => e
-          annotate_exception! e
-          raise
-        end
+    # Returns an Asset or nil.
+    def link_asset(path)
+      if asset = @environment.find_asset(resolve(path))
+        @dependency_paths.merge(asset.metadata[:dependency_paths])
+        @links << asset.uri
       end
-
-      result
+      asset
     end
 
     # Returns a Base64-encoded `data:` URI with the contents of the
@@ -216,9 +169,8 @@ module Sprockets
     #
     def asset_data_uri(path)
       depend_on_asset(path)
-      asset  = environment.find_asset(path)
-      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
-      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
+      asset = environment.find_asset(path, accept_encoding: 'base64')
+      "data:#{asset.content_type};base64,#{Rack::Utils.escape(asset.to_s)}"
     end
 
     # Expands logical path to full url to asset.
@@ -243,47 +195,32 @@ Extend your environment context with a custom method.
 
     # Expand logical image asset path.
     def image_path(path)
-      asset_path(path, :type => :image)
+      asset_path(path, type: :image)
     end
 
     # Expand logical video asset path.
     def video_path(path)
-      asset_path(path, :type => :video)
+      asset_path(path, type: :video)
     end
 
     # Expand logical audio asset path.
     def audio_path(path)
-      asset_path(path, :type => :audio)
+      asset_path(path, type: :audio)
     end
 
     # Expand logical font asset path.
     def font_path(path)
-      asset_path(path, :type => :font)
+      asset_path(path, type: :font)
     end
 
     # Expand logical javascript asset path.
     def javascript_path(path)
-      asset_path(path, :type => :javascript)
+      asset_path(path, type: :javascript)
     end
 
     # Expand logical stylesheet asset path.
     def stylesheet_path(path)
-      asset_path(path, :type => :stylesheet)
+      asset_path(path, type: :stylesheet)
     end
-
-    private
-      # Annotates exception backtrace with the original template that
-      # the exception was raised in.
-      def annotate_exception!(exception)
-        location = pathname.to_s
-        location << ":#{@__LINE__}" if @__LINE__
-
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
-
-      def logger
-        environment.logger
-      end
   end
 end

data/lib/sprockets/directive_processor.rb

@@ -1,7 +1,5 @@
-require 'pathname'
+require 'set'
 require 'shellwords'
-require 'tilt'
-require 'yaml'
 
 module Sprockets
   # The `DirectiveProcessor` is responsible for parsing and evaluating
@@ -20,10 +18,9 @@ module Sprockets
   #      *= require "baz"
   #      */
   #
-  # The Processor is implemented as a `Tilt::Template` and is loosely
-  # coupled to Sprockets. This makes it possible to disable or modify
-  # the processor to do whatever you'd like. You could add your own
-  # custom directives or invent your own directive syntax.
+  # This makes it possible to disable or modify the processor to do whatever
+  # you'd like. You could add your own custom directives or invent your own
+  # directive syntax.
   #
   # `Environment#processors` includes `DirectiveProcessor` by default.
   #
@@ -36,7 +33,9 @@ module Sprockets
   #
   #     env.register_processor('text/css', MyProcessor)
   #
-  class DirectiveProcessor < Tilt::Template
+  class DirectiveProcessor
+    VERSION = '1'
+
     # Directives will only be picked up if they are in the header
     # of the source file. C style (/* */), JavaScript (//), and
     # Ruby (#) comments are supported.
@@ -68,76 +67,82 @@ module Sprockets
       ^ \W* = \s* (\w+.*?) (\*\/)? $
     /x
 
-    attr_reader :pathname
-    attr_reader :header, :body
+    def self.call(input)
+      new.call(input)
+    end
 
-    def prepare
-      @pathname = Pathname.new(file)
+    def call(input)
+      @environment  = input[:environment]
+      @uri          = input[:uri]
+      @load_path    = input[:load_path]
+      @filename     = input[:filename]
+      @dirname      = File.dirname(@filename)
+      @content_type = input[:content_type]
+
+      data = input[:data]
+      cache_key = ['DirectiveProcessor', VERSION, data]
+      result = input[:cache].fetch(cache_key) do
+        process_source(data)
+      end
 
-      @header = data[HEADER_PATTERN, 0] || ""
-      @body   = $' || data
-      # Ensure body ends in a new line
-      @body  += "\n" if @body != "" && @body !~ /\n\Z/m
+      data, directives = result.values_at(:data, :directives)
 
-      @included_pathnames = []
-      @compat             = false
-    end
+      @required         = Set.new(input[:metadata][:required])
+      @stubbed          = Set.new(input[:metadata][:stubbed])
+      @links            = Set.new(input[:metadata][:links])
+      @dependency_paths = Set.new(input[:metadata][:dependency_paths])
 
-    # Implemented for Tilt#render.
-    #
-    # `context` is a `Context` instance with methods that allow you to
-    # access the environment and append to the bundle. See `Context`
-    # for the complete API.
-    def evaluate(context, locals, &block)
-      @context = context
+      process_directives(directives)
 
-      @result = ""
-      @result.force_encoding(body.encoding) if body.respond_to?(:encoding)
+      { data: data,
+        required: @required,
+        stubbed: @stubbed,
+        links: @links,
+        dependency_paths: @dependency_paths }
+    end
 
-      @has_written_body = false
+    protected
+      def process_source(source)
+        header = source[HEADER_PATTERN, 0] || ""
+        body   = $' || source
 
-      process_directives
-      process_source
+        header, directives = extract_directives(header)
 
-      @result
-    end
+        data = ""
+        data.force_encoding(body.encoding)
+        data << header << "\n" unless header.empty?
+        data << body
+        # Ensure body ends in a new line
+        data << "\n" if data.length > 0 && data[-1] != "\n"
 
-    # Returns the header String with any directives stripped.
-    def processed_header
-      lineno = 0
-      @processed_header ||= header.lines.map { |line|
-        lineno += 1
-        # Replace directive line with a clean break
-        directives.assoc(lineno) ? "\n" : line
-      }.join.chomp
-    end
+        { data: data, directives: directives }
+      end
 
-    # Returns the source String with any directives stripped.
-    def processed_source
-      @processed_source ||= processed_header + body
-    end
+      # Returns an Array of directive structures. Each structure
+      # is an Array with the line number as the first element, the
+      # directive name as the second element, followed by any
+      # arguments.
+      #
+      #     [[1, "require", "foo"], [2, "require", "bar"]]
+      #
+      def extract_directives(header)
+        processed_header = ""
+        directives = []
 
-    # Returns an Array of directive structures. Each structure
-    # is an Array with the line number as the first element, the
-    # directive name as the second element, followed by any
-    # arguments.
-    #
-    #     [[1, "require", "foo"], [2, "require", "bar"]]
-    #
-    def directives
-      @directives ||= header.lines.each_with_index.map { |line, index|
-        if directive = line[DIRECTIVE_PATTERN, 1]
-          name, *args = Shellwords.shellwords(directive)
-          if respond_to?("process_#{name}_directive", true)
-            [index + 1, name, *args]
+        header.lines.each_with_index do |line, index|
+          if directive = line[DIRECTIVE_PATTERN, 1]
+            name, *args = Shellwords.shellwords(directive)
+            if respond_to?("process_#{name}_directive", true)
+              directives << [index + 1, name, *args]
+              # Replace directive line with a clean break
+              line = "\n"
+            end
           end
+          processed_header << line
         end
-      }.compact
-    end
 
-    protected
-      attr_reader :included_pathnames
-      attr_reader :context
+        return processed_header.chomp, directives
+      end
 
       # Gathers comment directives in the source and processes them.
       # Any directive method matching `process_*_directive` will
@@ -150,7 +155,7 @@ module Sprockets
       #
       #     class DirectiveProcessor < Sprockets::DirectiveProcessor
       #       def process_require_glob_directive
-      #         Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
+      #         Dir["#{dirname}/#{glob}"].sort.each do |filename|
       #           require(filename)
       #         end
       #       end
@@ -161,29 +166,14 @@ module Sprockets
       #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
       #     env.register_processor('text/css', DirectiveProcessor)
       #
-      def process_directives
+      def process_directives(directives)
         directives.each do |line_number, name, *args|
-          context.__LINE__ = line_number
-          send("process_#{name}_directive", *args)
-          context.__LINE__ = nil
-        end
-      end
-
-      def process_source
-        unless @has_written_body || processed_header.empty?
-          @result << processed_header << "\n"
-        end
-
-        included_pathnames.each do |pathname|
-          @result << context.evaluate(pathname)
-        end
-
-        unless @has_written_body
-          @result << body
-        end
-
-        if compat? && constants.any?
-          @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
+          begin
+            send("process_#{name}_directive", *args)
+          rescue Exception => e
+            e.set_backtrace(["#{@filename}:#{line_number}"] + e.backtrace)
+            raise e
+          end
         end
       end
 
@@ -206,22 +196,13 @@ module Sprockets
       #     //= require "./bar"
       #
       def process_require_directive(path)
-        if @compat
-          if path =~ /<([^>]+)>/
-            path = $1
-          else
-            path = "./#{path}" unless relative?(path)
-          end
-        end
-
-        context.require_asset(path)
+        @required << resolve_uri(path)
       end
 
-      # `require_self` causes the body of the current file to be
-      # inserted before any subsequent `require` or `include`
-      # directives. Useful in CSS files, where it's common for the
-      # index file to contain global styles that need to be defined
-      # before other dependencies are loaded.
+      # `require_self` causes the body of the current file to be inserted
+      # before any subsequent `require` directives. Useful in CSS files, where
+      # it's common for the index file to contain global styles that need to
+      # be defined before other dependencies are loaded.
       #
       #     /*= require "reset"
       #      *= require_self
@@ -229,26 +210,10 @@ module Sprockets
       #      */
       #
       def process_require_self_directive
-        if @has_written_body
+        if @required.include?(@uri)
           raise ArgumentError, "require_self can only be called once per source file"
         end
-
-        context.require_asset(pathname)
-        process_source
-        included_pathnames.clear
-        @has_written_body = true
-      end
-
-      # The `include` directive works similar to `require` but
-      # inserts the contents of the dependency even if it already
-      # has been required.
-      #
-      #     //= include "header"
-      #
-      def process_include_directive(path)
-        pathname = context.resolve(path)
-        context.depend_on_asset(pathname)
-        included_pathnames << pathname
+        @required << @uri
       end
 
       # `require_directory` requires all the files inside a single
@@ -258,21 +223,20 @@ module Sprockets
       #     //= require_directory "./javascripts"
       #
       def process_require_directory_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
+        if @environment.relative_path?(path)
+          root = expand_relative_path(path)
 
-          unless (stats = stat(root)) && stats.directory?
+          unless (stats = @environment.stat(root)) && stats.directory?
             raise ArgumentError, "require_directory argument must be a directory"
           end
 
-          context.depend_on(root)
+          @dependency_paths << root
 
-          entries(root).each do |pathname|
-            pathname = root.join(pathname)
-            if pathname.to_s == self.file
+          @environment.stat_directory(root).each do |subpath, stat|
+            if subpath == @filename
               next
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
+            elsif @environment.resolve_path_transform_type(subpath, @content_type)
+              @required << @environment.resolve_asset_uri(subpath, accept: @content_type, bundle: false)
             end
           end
         else
@@ -287,24 +251,28 @@ module Sprockets
       #     //= require_tree "./public"
       #
       def process_require_tree_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
+        if @environment.relative_path?(path)
+          root = expand_relative_path(path)
 
-          unless (stats = stat(root)) && stats.directory?
+          unless (stats = @environment.stat(root)) && stats.directory?
             raise ArgumentError, "require_tree argument must be a directory"
           end
 
-          context.depend_on(root)
+          @dependency_paths << root
 
-          each_entry(root) do |pathname|
-            if pathname.to_s == self.file
+          required = []
+          @environment.stat_tree(root).each do |subpath, stat|
+            if subpath == @filename
               next
-            elsif stat(pathname).directory?
-              context.depend_on(pathname)
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
+            elsif stat.directory?
+              @dependency_paths << subpath
+            elsif @environment.resolve_path_transform_type(subpath, @content_type)
+              required << subpath
             end
           end
+          required.sort_by(&:to_s).each do |subpath|
+            @required << @environment.resolve_asset_uri(subpath, accept: @content_type, bundle: false)
+          end
         else
           # The path must be relative and start with a `./`.
           raise ArgumentError, "require_tree argument must be a relative path"
@@ -324,7 +292,7 @@ module Sprockets
       #     //= depend_on "foo.png"
       #
       def process_depend_on_directive(path)
-        context.depend_on(path)
+        @dependency_paths << resolve(path, accept: "#{@content_type}, */*")
       end
 
       # Allows you to state a dependency on an asset without including
@@ -339,7 +307,9 @@ module Sprockets
       #     //= depend_on_asset "bar.js"
       #
       def process_depend_on_asset_directive(path)
-        context.depend_on_asset(path)
+        if asset = @environment.find_asset(resolve(path, accept: "#{@content_type}, */*"))
+          @dependency_paths.merge(asset.metadata[:dependency_paths])
+        end
       end
 
       # Allows dependency to be excluded from the asset bundle.
@@ -351,58 +321,47 @@ module Sprockets
       #     //= stub "jquery"
       #
       def process_stub_directive(path)
-        context.stub_asset(path)
+        @stubbed << resolve_uri(path)
       end
 
-      # Enable Sprockets 1.x compat mode.
+      # Declares a linked dependency on the target asset.
       #
-      # Makes it possible to use the same JavaScript source
-      # file in both Sprockets 1 and 2.
+      # The `path` must be a valid asset and should not already be part of the
+      # bundle. Any linked assets will automatically be compiled along with the
+      # current.
       #
-      #     //= compat
+      #   /*= link "logo.png" */
       #
-      def process_compat_directive
-        @compat = true
-      end
-
-      # Checks if Sprockets 1.x compat mode enabled
-      def compat?
-        @compat
-      end
-
-      # Sprockets 1.x allowed for constant interpolation if a
-      # constants.yml was present. This is only available if
-      # compat mode is on.
-      def constants
-        if compat?
-          pathname = Pathname.new(context.root_path).join("constants.yml")
-          stat(pathname) ? YAML.load_file(pathname) : {}
-        else
-          {}
+      def process_link_directive(path)
+        if asset = @environment.find_asset(resolve(path, accept: "#{@content_type}, */*"))
+          @dependency_paths.merge(asset.metadata[:dependency_paths])
+          @links << asset.uri
         end
       end
 
-      # `provide` is stubbed out for Sprockets 1.x compat.
-      # Mutating the path when an asset is being built is
-      # not permitted.
-      def process_provide_directive(path)
-      end
-
     private
-      def relative?(path)
-        path =~ /^\.($|\.?\/)/
+      def expand_relative_path(path)
+        File.expand_path(path, @dirname)
       end
 
-      def stat(path)
-        context.environment.stat(path)
+      def resolve_uri(path)
+        filename = resolve(path, accept: @content_type)
+        @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
       end
 
-      def entries(path)
-        context.environment.entries(path)
-      end
-
-      def each_entry(root, &block)
-        context.environment.each_entry(root, &block)
+      def resolve(path, options = {})
+        if @environment.absolute_path?(path)
+          raise FileOutsidePaths, "can't require absolute file: #{path}"
+        elsif @environment.relative_path?(path)
+          path = expand_relative_path(path)
+          if logical_path = @environment.split_subpath(@load_path, path)
+            @environment.resolve_in_load_path(@load_path, logical_path, options)
+          else
+            raise FileOutsidePaths, "#{path} isn't under path: #{@load_path}"
+          end
+        else
+          @environment.resolve(path, options)
+        end
       end
   end
 end