sprockets 3.0.0.beta.6 → 3.0.0.beta.7

data/lib/sprockets/dependencies.rb

@@ -0,0 +1,73 @@
+require 'sprockets/digest_utils'
+require 'sprockets/path_digest_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  # `Dependencies` is an internal mixin whose public methods are exposed on the
+  # `Environment` and `CachedEnvironment` classes.
+  module Dependencies
+    include DigestUtils, PathDigestUtils, URIUtils
+
+    # Public: Mapping dependency schemes to resolver functions.
+    #
+    # key   - String scheme
+    # value - Proc.call(Environment, String)
+    #
+    # Returns Hash.
+    def dependency_resolvers
+      config[:dependency_resolvers]
+    end
+
+    # Public: Default set of dependency URIs for assets.
+    #
+    # Returns Set of String URIs.
+    def dependencies
+      config[:dependencies]
+    end
+
+    # Public: Register new dependency URI resolver.
+    #
+    # scheme - String scheme
+    # block  -
+    #   environment - Environment
+    #   uri - String dependency URI
+    #
+    # Returns nothing.
+    def register_dependency_resolver(scheme, &block)
+      self.config = hash_reassoc(config, :dependency_resolvers) do |hash|
+        hash.merge(scheme => block)
+      end
+    end
+
+    # Public: Add environmental dependency inheirted by all assets.
+    #
+    # uri - String dependency URI
+    #
+    # Returns nothing.
+    def add_dependency(uri)
+      self.config = hash_reassoc(config, :dependencies) do |set|
+        set + Set.new([uri])
+      end
+    end
+    alias_method :depend_on, :add_dependency
+
+    # Internal: Resolve set of dependency URIs.
+    #
+    # Returns Array of resolved Objects.
+    def resolve_dependencies(uris)
+      uris.map { |uri| resolve_dependency(uri) }
+    end
+
+    # Internal: Resolve dependency URIs.
+    #
+    # Returns resolved Object.
+    def resolve_dependency(str)
+      scheme = str[/([^:]+)/, 1]
+      if resolver = dependency_resolvers[scheme]
+        resolver.call(self, str)
+      else
+        raise TypeError, "unknown cache scheme: #{scheme}"
+      end
+    end
+  end
+end

data/lib/sprockets/digest_utils.rb

@@ -1,8 +1,11 @@
 require 'digest/md5'
 require 'digest/sha1'
 require 'digest/sha2'
+require 'set'
 
 module Sprockets
+  # Internal: Hash functions and digest related utilities. Mixed into
+  # Environment.
   module DigestUtils
     extend self
 
@@ -33,6 +36,9 @@ module Sprockets
 
     # Internal: Generate a hexdigest for a nested JSON serializable object.
     #
+    # This is used for generating cache keys, so its pretty important its
+    # wicked fast. Microbenchmarks away!
+    #
     # obj - A JSON serializable object.
     #
     # Returns a String digest of the object.
@@ -111,7 +117,7 @@ module Sprockets
     # Internal: Maps digest class to the named information hash algorithm name.
     #
     # http://www.iana.org/assignments/named-information/named-information.xhtml
-    NI_HASH_ALGORIHMS = {
+    NI_HASH_ALGORITHMS = {
       Digest::SHA256 => 'sha-256'.freeze,
       Digest::SHA384 => 'sha-384'.freeze,
       Digest::SHA512 => 'sha-512'.freeze
@@ -137,7 +143,7 @@ module Sprockets
         raise TypeError, "unknown digest: #{digest.inspect}"
       end
 
-      if hash_name = NI_HASH_ALGORIHMS[digest_class]
+      if hash_name = NI_HASH_ALGORITHMS[digest_class]
         uri = "ni:///#{hash_name};#{pack_urlsafe_base64digest(digest)}"
         uri << "?ct=#{content_type}" if content_type
         uri

data/lib/sprockets/directive_processor.rb

@@ -36,24 +36,6 @@ module Sprockets
   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.
-    #
-    # Directives in comments after the first non-whitespace line
-    # of code will not be processed.
-    #
-    HEADER_PATTERN = /
-      \A (
-        (?m:\s*) (
-          (\/\* (?m:.*?) \*\/) |
-          (\#\#\# (?m:.*?) \#\#\#) |
-          (\/\/ .* \n?)+ |
-          (\# .* \n?)+
-        )
-      )+
-    /x
-
     # Directives are denoted by a `=` followed by the name, then
     # argument list.
     #
@@ -67,40 +49,69 @@ module Sprockets
       ^ \W* = \s* (\w+.*?) (\*\/)? $
     /x
 
+    def self.instance
+      @instance ||= new(
+        # Deprecated: Default to C and Ruby comment styles
+        comments: ["//", ["/*", "*/"]] + ["#", ["###", "###"]]
+      )
+    end
+
     def self.call(input)
-      new.call(input)
+      instance.call(input)
+    end
+
+    def initialize(options = {})
+      @header_pattern = compile_header_pattern(Array(options[:comments]))
     end
 
     def call(input)
+      dup._call(input)
+    end
+
+    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]
+      @required     = Set.new(input[:metadata][:required])
+      @stubbed      = Set.new(input[:metadata][:stubbed])
+      @links        = Set.new(input[:metadata][:links])
+      @dependencies = Set.new(input[:metadata][:dependencies])
 
-      data = input[:data]
-      result = process_source(data)
-
-      data, directives = result.values_at(:data, :directives)
-
-      @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])
-
+      data, directives = process_source(input[:data])
       process_directives(directives)
 
       { data: data,
         required: @required,
         stubbed: @stubbed,
         links: @links,
-        dependency_paths: @dependency_paths }
+        dependencies: @dependencies }
     end
 
     protected
+      # Directives will only be picked up if they are in the header
+      # of the source file. C style (/* */), JavaScript (//), and
+      # Ruby (#) comments are supported.
+      #
+      # Directives in comments after the first non-whitespace line
+      # of code will not be processed.
+      def compile_header_pattern(comments)
+        re = comments.map { |c|
+          case c
+          when String
+            "(?:#{Regexp.escape(c)}.*\\n?)+"
+          when Array
+            "(?:#{Regexp.escape(c[0])}(?m:.*?)#{Regexp.escape(c[1])})"
+          else
+            raise TypeError, "unknown comment type: #{c.class}"
+          end
+        }.join("|")
+        Regexp.compile("\\A(?:(?m:\\s*)(?:#{re}))+")
+      end
+
       def process_source(source)
-        header = source[HEADER_PATTERN, 0] || ""
+        header = source[@header_pattern, 0] || ""
         body   = $' || source
 
         header, directives = extract_directives(header)
@@ -112,7 +123,7 @@ module Sprockets
         # Ensure body ends in a new line
         data << "\n" if data.length > 0 && data[-1] != "\n"
 
-        { data: data, directives: directives }
+        return data, directives
       end
 
       # Returns an Array of directive structures. Each structure
@@ -193,7 +204,7 @@ module Sprockets
       #     //= require "./bar"
       #
       def process_require_directive(path)
-        @required << locate(path, accept: @content_type, bundle: false)
+        @required << resolve(path, accept: @content_type, bundle: false)
       end
 
       # `require_self` causes the body of the current file to be inserted
@@ -220,28 +231,8 @@ module Sprockets
       #     //= require_directory "./javascripts"
       #
       def process_require_directory_directive(path = ".")
-        if @environment.relative_path?(path)
-          root = expand_relative_path(path)
-
-          unless (stats = @environment.stat(root)) && stats.directory?
-            raise ArgumentError, "require_directory argument must be a directory"
-          end
-
-          @dependency_paths << root
-
-          @environment.stat_directory(root).each do |subpath, stat|
-            if subpath == @filename
-              next
-            elsif stat.directory?
-              next
-            elsif uri = @environment.locate(subpath, accept: @content_type, bundle: false)
-              @required << uri
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_directory argument must be a relative path"
-        end
+        path = expand_relative_dirname(:require_directory, path)
+        require_paths(*@environment.stat_directory_with_dependencies(path))
       end
 
       # `require_tree` requires all the nested files in a directory.
@@ -250,28 +241,8 @@ module Sprockets
       #     //= require_tree "./public"
       #
       def process_require_tree_directive(path = ".")
-        if @environment.relative_path?(path)
-          root = expand_relative_path(path)
-
-          unless (stats = @environment.stat(root)) && stats.directory?
-            raise ArgumentError, "require_tree argument must be a directory"
-          end
-
-          @dependency_paths << root
-
-          @environment.stat_sorted_tree(root).each do |subpath, stat|
-            if subpath == @filename
-              next
-            elsif stat.directory?
-              @dependency_paths << subpath
-            elsif uri = @environment.locate(subpath, accept: @content_type, bundle: false)
-              @required << uri
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_tree argument must be a relative path"
-        end
+        path = expand_relative_dirname(:require_tree, path)
+        require_paths(*@environment.stat_sorted_tree_with_dependencies(path))
       end
 
       # Allows you to state a dependency on a file without
@@ -287,7 +258,7 @@ module Sprockets
       #     //= depend_on "foo.png"
       #
       def process_depend_on_directive(path)
-        @dependency_paths << resolve(path)
+        resolve(path)
       end
 
       # Allows you to state a dependency on an asset without including
@@ -302,9 +273,7 @@ module Sprockets
       #     //= depend_on_asset "bar.js"
       #
       def process_depend_on_asset_directive(path)
-        if asset = @environment.load(locate(path))
-          @dependency_paths.merge(asset.metadata[:dependency_paths])
-        end
+        load(resolve(path))
       end
 
       # Allows dependency to be excluded from the asset bundle.
@@ -316,7 +285,7 @@ module Sprockets
       #     //= stub "jquery"
       #
       def process_stub_directive(path)
-        @stubbed << locate(path, accept: @content_type, bundle: false)
+        @stubbed << resolve(path, accept: @content_type, bundle: false)
       end
 
       # Declares a linked dependency on the target asset.
@@ -328,10 +297,7 @@ module Sprockets
       #   /*= link "logo.png" */
       #
       def process_link_directive(path)
-        if asset = @environment.load(locate(path))
-          @dependency_paths.merge(asset.metadata[:dependency_paths])
-          @links << asset.uri
-        end
+        @links << load(resolve(path)).uri
       end
 
       # `link_directory` links all the files inside a single
@@ -340,31 +306,15 @@ module Sprockets
       #
       #     //= link_directory "./fonts"
       #
-      def process_link_directory_directive(path = ".")
-        if @environment.relative_path?(path)
-          root = expand_relative_path(path)
-
-          unless (stats = @environment.stat(root)) && stats.directory?
-            raise ArgumentError, "link_directory argument must be a directory"
-          end
-
-          @dependency_paths << root
-
-          @environment.stat_directory(root).each do |subpath, stat|
-            if subpath == @filename
-              next
-            elsif stat.directory?
-              next
-            elsif uri = @environment.locate(subpath)
-              asset = @environment.load(uri)
-              @dependency_paths.merge(asset.metadata[:dependency_paths])
-              @links << asset.uri
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "link_directory argument must be a relative path"
-        end
+      # Use caution when linking against JS or CSS assets. Include an explicit
+      # extension or content type in these cases
+      #
+      #     //= link_directory "./scripts" .js
+      #
+      def process_link_directory_directive(path = ".", accept = nil)
+        path = expand_relative_dirname(:link_directory, path)
+        accept = expand_accept_shorthand(accept)
+        link_paths(*@environment.stat_directory_with_dependencies(path), accept)
       end
 
       # `link_tree` links all the nested files in a directory.
@@ -372,76 +322,83 @@ module Sprockets
       #
       #     //= link_tree "./images"
       #
-      def process_link_tree_directive(path = ".")
-        if @environment.relative_path?(path)
-          root = expand_relative_path(path)
-
-          unless (stats = @environment.stat(root)) && stats.directory?
-            raise ArgumentError, "link_tree argument must be a directory"
-          end
+      # Use caution when linking against JS or CSS assets. Include an explicit
+      # extension or content type in these cases
+      #
+      #     //= link_tree "./styles" .css
+      #
+      def process_link_tree_directive(path = ".", accept = nil)
+        path = expand_relative_dirname(:link_tree, path)
+        accept = expand_accept_shorthand(accept)
+        link_paths(*@environment.stat_sorted_tree_with_dependencies(path), accept)
+      end
 
-          @dependency_paths << root
-
-          @environment.stat_sorted_tree(root).each do |subpath, stat|
-            if subpath == @filename
-              next
-            elsif stat.directory?
-              @dependency_paths << subpath
-            elsif uri = @environment.locate(subpath)
-              asset = @environment.load(uri)
-              @dependency_paths.merge(asset.metadata[:dependency_paths])
-              @links << asset.uri
-            end
-          end
+    private
+      def expand_accept_shorthand(accept)
+        if accept.nil?
+          nil
+        elsif accept.include?("/")
+          accept
+        elsif accept.start_with?(".")
+          @environment.mime_exts[accept]
         else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "link_tree argument must be a relative path"
+          @environment.mime_exts[".#{accept}"]
         end
       end
 
-    private
-      def expand_relative_path(path)
-        File.expand_path(path, @dirname)
+      def require_paths(paths, deps)
+        resolve_paths(paths, deps, accept: @content_type, bundle: false) do |uri|
+          @required << uri
+        end
       end
 
-      def locate(path, options = {})
-        _resolve(:locate, path, options)
+      def link_paths(paths, deps, accept)
+        resolve_paths(paths, deps, accept: accept) do |uri|
+          @links << load(uri).uri
+        end
       end
 
-      def resolve(path, options = {})
-        _resolve(:resolve, path, options)
+      def resolve_paths(paths, deps, options = {})
+        @dependencies.merge(deps)
+        paths.each do |subpath, stat|
+          next if subpath == @filename || stat.directory?
+          uri, deps = @environment.resolve(subpath, options.merge(compat: false))
+          @dependencies.merge(deps)
+          yield uri if uri
+        end
       end
 
-      # TODO: Cleanup relative resolver logic shared between context.
-      def _resolve(method, 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)
-            if filename = @environment.send(method, logical_path, options.merge(load_paths: [@load_path]))
-              filename
-            else
-              accept = options[:accept]
-              message = "couldn't find file '#{logical_path}' under '#{@load_path}'"
-              message << " with type '#{accept}'" if accept
-              raise FileNotFound, message
-            end
+      def expand_relative_dirname(directive, path)
+        if @environment.relative_path?(path)
+          path = File.expand_path(path, @dirname)
+          stat = @environment.stat(path)
+
+          if stat && stat.directory?
+            path
           else
-            raise FileOutsidePaths, "#{path} isn't under path: #{@load_path}"
+            raise ArgumentError, "#{directive} argument must be a directory"
           end
         else
-          filename = @environment.send(method, path, options)
+          # The path must be relative and start with a `./`.
+          raise ArgumentError, "#{directive} argument must be a relative path"
         end
+      end
 
-        if filename
-          filename
-        else
-          accept = options[:accept]
-          message = "couldn't find file '#{path}'"
-          message << " with type '#{accept}'" if accept
-          raise FileNotFound, message
+      def load(uri)
+        asset = @environment.load(uri)
+        @dependencies.merge(asset.metadata[:dependencies])
+        asset
+      end
+
+      def resolve(path, options = {})
+        # Prevent absolute paths in directives
+        if @environment.absolute_path?(path)
+          raise FileOutsidePaths, "can't require absolute file: #{path}"
         end
+
+        uri, deps = @environment.resolve!(path, options.merge(base_path: @dirname))
+        @dependencies.merge(deps)
+        uri
       end
   end
 end