asset_hat 0.3.1 → 0.4.0

data/lib/asset_hat/railtie.rb

@@ -0,0 +1,19 @@
+require 'asset_hat'
+require 'asset_hat_helper'
+require 'rails'
+
+module AssetHat
+  class Railtie < Rails::Railtie #:nodoc:
+    initializer 'asset_hat.action_view' do |app|
+      require 'asset_hat/initializers/action_view'
+    end
+
+    initializer 'asset_hat.cache_last_commit_ids' do |app|
+      require 'asset_hat/initializers/cache_last_commit_ids'
+    end
+
+    rake_tasks do
+      load 'tasks/asset_hat.rake'
+    end
+  end
+end

data/lib/asset_hat/tasks.rb

@@ -26,7 +26,9 @@ namespace :asset_hat do
   end
 
   desc 'Prepare configuration file'
-  task :config, :needs => :environment do
+  task :config do
+    require 'asset_hat'
+
     template_filepath = File.join(File.dirname(__FILE__), '..', '..',
       AssetHat::RELATIVE_CONFIG_FILEPATH)
     target_filepath = AssetHat::CONFIG_FILEPATH
@@ -40,7 +42,8 @@ namespace :asset_hat do
     end
 
     FileUtils.cp(template_filepath, target_filepath)
-    puts "Wrote to #{target_filepath}"
+    puts "\nWrote to #{target_filepath}. Next, open this file in your editor"
+    puts 'and set up your CSS/JS bundles.'
   end
 
 end # namespace :asset_hat

data/lib/asset_hat/unicorn.rb

@@ -0,0 +1,9 @@
+# Add the code below to your app's unicorn.conf.rb or similar so that assets'
+# commit IDs are precached only once by the Unicorn master, then propagated
+# out to workers. (Otherwise, each worker will precache commit IDs, which
+# wastes resources.) More on configuring Unicorn:
+# http://unicorn.bogomips.org/Unicorn/Configurator.html
+
+before_fork do |server, worker|
+  AssetHat.cache_last_commit_ids if defined?(AssetHat)
+end

data/lib/asset_hat/vcs.rb

@@ -46,7 +46,7 @@ module AssetHat
     # Process arguments
     type = type.to_sym
     unless TYPES.include?(type)
-      raise "Unknown type \"#{type}\"; should be one of: #{TYPES.join(', ')}."
+      raise %{Unknown type "#{type}"; should be one of: #{TYPES.join(', ')}.}
       return
     end
 
@@ -58,7 +58,8 @@ module AssetHat
       dir = self.assets_dir(type)
       filepaths = self.bundle_filepaths(bundle, type)
       if filepaths.present?
-        @last_bundle_commit_ids[type][bundle] = self.last_commit_id(*filepaths)
+        @last_bundle_commit_ids[type][bundle] =
+          self.last_commit_id(*filepaths)
       end
     end
 

data/{app/helpers → lib}/asset_hat_helper.rb

@@ -20,33 +20,34 @@ module AssetHatHelper
     end
 
     options   = args.extract_options!.symbolize_keys
-    filenames = []
+    filenames = [] # May or may not have proper extensions
     sources   = [] # The URLs that are ultimately included via HTML
     source_commit_ids = {} # Last commit ID for each source
 
-    # Set to `true` to use bundles and minified code:
+    # If `use_caching` is `true`, bundles and minified code will be used:
     use_caching = AssetHat.cache?
     use_caching = options[:cache] unless options[:cache].nil?
     options.delete :cache # Completely avoid Rails' built-in caching
 
+    # Gather list of filenames, which may not have proper extensions yet
+    filenames = args.dup
     if options[:bundle].present? || options[:bundles].present?
       bundles = [options.delete(:bundle), options.delete(:bundles)].
                   flatten.reject(&:blank?)
       if use_caching
-        sources += bundles.map do |bundle|
+        filenames += bundles.map do |bundle|
           File.join(AssetHat.bundles_dir(options.slice(:ssl)),
                     "#{bundle}.min.#{type}")
         end
       else
         config = AssetHat.config
-        filenames = bundles.map { |b| AssetHat.bundle_filenames(b, type) }.
+        filenames += bundles.map { |b| AssetHat.bundle_filenames(b, type) }.
                       flatten.reject(&:blank?)
       end
-    else
-      filenames = args
     end
 
-    # Add extensions if needed, using minified file if it already exists
+    # Build `sources`, adding extensions if needed, using minified file if it
+    # already exists
     filenames.each do |filename|
       if filename.match(/\.#{type}$/)
         sources << filename
@@ -88,26 +89,34 @@ module AssetHatHelper
       end
     end
 
-    # Build output HTML
+    # Prepare return value
     options.delete :ssl
-    sources.map do |src|
-      case type
-      when :css ; stylesheet_link_tag(src, options)
-      when :js  ; javascript_include_tag(src, options)
-      else nil
-      end
-    end.join("\n")
+    if options[:only_url]
+      # Return only asset URLs, not HTML inclusions
+      source_urls = sources.map { |source| asset_path(type, source) }
+      source_urls.size == 1 ? source_urls.first : source_urls
+    else
+      html = sources.map do |src|
+        case type
+        when :css then stylesheet_link_tag(src, options)
+        when :js  then javascript_include_tag(src, options)
+        else nil
+        end
+      end.join("\n")
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
   end # def include_assets
 
   # <code>include_css</code> is a smart wrapper for Rails'
   # <code>stylesheet_link_tag</code>. The two can be used together while
   # migrating to AssetHat.
   #
-  # Include a single stylesheet:
+  # Include a single, minified stylesheet:
   #   include_css 'diagnostics'
   #   =>  <link href="/stylesheets/diagnostics.min.css" media="screen,projection" rel="stylesheet" type="text/css" />
   #
-  # Include a single unminified stylesheet:
+  # Include a single, unminified stylesheet:
   #   include_css 'diagnostics.css'
   #   =>  <link href="/stylesheets/diagnostics.css" media="screen,projection" rel="stylesheet" type="text/css" />
   #
@@ -117,15 +126,36 @@ module AssetHatHelper
   #   =>  <link href="/stylesheets/bundles/application.min.css" ... />
   #
   # Include multiple stylesheets separately (not as cool):
-  #   include_css 'reset', 'application', 'clearfix'
+  #   include_css 'reset', 'application'
   #   =>  <link href="/stylesheets/reset.min.css" ... />
   #       <link href="/stylesheets/application.min.css" ... />
-  #       <link href="/stylesheets/clearfix.min.css" ... />
   #
   # Include a stylesheet with extra media types:
   #   include_css 'mobile', :media => 'handheld,screen,projection'
   #   =>  <link href="/stylesheets/mobile.min.css"
   #             media="handheld,screen,projection" ... />
+  #
+  # Get the URL for a single, minified stylesheet:
+  #   include_css 'diagnostics', :only_url => true
+  #   => '/stylesheets/diagnostics.min.css'
+  #
+  # Get the URL for a single, unminified stylesheet:
+  #   include_css 'diagnostics.css', :only_url => true
+  #   => '/stylesheets/diagnostics.css'
+  #
+  # Get the URL for a bundle of stylesheets when environment *enables* caching
+  # (e.g., staging, production):
+  #   include_css :bundle => 'application', :only_url => true
+  #   => '/stylesheets/bundles/application.min.css'
+  #
+  # Get URLs for a bundle of stylesheets when environment *disables* caching
+  # (e.g., development, test):
+  #   include_css :bundle => 'application', :only_url => true
+  #   => ['/stylesheets/reset.css', '/stylesheets/common.css', ...]
+  #
+  # Get URLs for multiple stylesheets manually:
+  #   include_css 'reset', 'application', :only_url => true
+  #   => ['/stylesheets/reset.css', '/stylesheets/application.css']
   def include_css(*args)
     return if args.blank?
 
@@ -145,18 +175,18 @@ module AssetHatHelper
     end
 
     html ||= AssetHat.html_cache[:css][cache_key]
-    html
+    html.respond_to?(:html_safe) ? html.html_safe : html
   end
 
   # <code>include_js</code> is a smart wrapper for Rails'
   # <code>javascript_include_tag</code>. The two can be used together while
   # migrating to AssetHat.
   #
-  # Include a single JS file:
+  # Include a single, minified JS file:
   #   include_js 'application'
   #   =>  <script src="/javascripts/application.min.js" type="text/javascript"></script>
   #
-  # Include a single JS unminified file:
+  # Include a single, unminified JS file:
   #   include_js 'application.js'
   #   =>  <script src="/javascripts/application.js" type="text/javascript"></script>
   #
@@ -169,7 +199,7 @@ module AssetHatHelper
   #   include_js :jquery
   #   =>  <script src="http://ajax.googleapis.com/.../jquery.min.js" ...></script>
   #     # Set jQuery versions either in `config/assets.yml`, or by using
-  #     # `include_js :jquery, :version => '1.4'`.
+  #     # `include_js :jquery, :version => '1.6.0'`.
   #
   # Include a bundle of JS files (i.e., a concatenated set of files;
   # configure in <code>config/assets.yml</code>):
@@ -186,6 +216,82 @@ module AssetHatHelper
   #   =>  <script src="/javascripts/bloombox.min.js" ...></script>
   #       <script src="/javascripts/jquery.cookie.min.js" ...></script>
   #       <script src="/javascripts/jquery.json.min.js" ...></script>
+  #
+  # Get the URL for a single, minified JS file:
+  #   include_js 'application', :only_url => true
+  #   =>  '/javascripts/application.min.js'
+  #
+  # Get the URL for a single, unminified JS file:
+  #   include_js 'application.js', :only_url => true
+  #   =>  '/javascripts/application.js', :only_url => true
+  #
+  # Get the URL for jQuery:
+  #   # Development/test environment:
+  #   include_js :jquery, :only_url => true
+  #   =>  '/javascripts/jquery-VERSION.min.js'
+  #
+  #   # Staging/production environment:
+  #   include_js :jquery, :only_url => true
+  #   =>  'http://ajax.googleapis.com/.../jquery.min.js'
+  #
+  # Get the URL for a bundle of JS files when environment *enables* caching
+  # (e.g., staging, production):
+  #   include_js :bundle => 'application', :only_url => true
+  #   => '/javascripts/bundles/application.min.js'
+  #
+  # Get URLs for a bundle of JS files when environment *disables* caching
+  # (e.g., development, test):
+  #   include_js :bundle => 'application', :only_url => true
+  #   => ['/javascripts/jquery.plugin-foo.js',
+  #       '/javascripts/jquery.plugin-bar.min.js',
+  #       '/javascripts/json2.js',
+  #       ...]
+  #
+  # Get URLs for multiple JS files manually:
+  #   include_js 'json2', 'application', :only_url => true
+  #   => ['/javascripts/json2.js', '/javascripts/application.js']
+  #
+  # Load JS files with {LABjs}[http://labjs.com] (hosted either from cdnjs or
+  # your own web server, if found in <code>public/javascripts/</code>):
+  #
+  #   # config/assets.yml:
+  #   js:
+  #     vendors:
+  #       lab_js:
+  #         version: 1.x.x
+  #
+  #   # Usage:
+  #   include_js :jquery, :bundle => 'application', :loader => :lab_js
+  #   =>  <script src="http://ajax.cdnjs.com/.../1.x.x/LAB.min.js" ...></script>
+  #       <script type="text/javascript">
+  #       window.$LABinst=$LAB.
+  #         script('http://ajax.googleapis.com/.../jquery.min.js').wait().
+  #         script('/javascripts/bundles/application.min.js').wait();
+  #       </script>
+  #
+  #   # For advanced fine-tuning, build the LABjs calls manually (based on
+  #   # example from http://labjs.com/documentation.php ):
+  #   <script>
+  #      window.$LABinst = $LAB.
+  #        script('<%= include_js 'framework', :only_url => true %>').wait().
+  #        script('<%= include_js 'plugin.framework.js',
+  #                               :only_url => true %>').
+  #        script('<%= include_js 'myplugin.framework.js',
+  #                               :only_url => true %>').wait().
+  #        script('<%= include_js 'init.js', :only_url => true %>').wait();
+  #   </script>
+  #
+  #   # If you want to execute an inline <script> block that relies on any
+  #   # of these dependencies, use the JS variable `window.$LABinst`.
+  #   # Example (using jQuery to handle when DOM is ready):
+  #   <script>
+  #   window.$LABinst(function(){
+  #     console.log('JS dependencies are ready');
+  #     $(function(){
+  #       console.log('DOM is ready');
+  #     });
+  #   });
+  #   </script>
   def include_js(*args)
     return if args.blank?
 
@@ -199,24 +305,73 @@ module AssetHatHelper
     if !AssetHat.cache? || AssetHat.html_cache[:js][cache_key].blank?
       # Generate HTML and write to cache
 
-      html = []
+      htmls = []
+      include_assets_options = options.except(:ssl, :version)
+      loader = nil
+
+      if options[:loader].present?
+        loader = options.delete(:loader)
+        include_assets_options.merge!(:only_url => true)
+      end
+
+      # Get vendor HTML/URLs
       included_vendors = (args & AssetHat::JS::VENDORS)
+
+      # Add HTML inclusions for vendors
       included_vendors.each do |vendor|
         args.delete vendor
         src = AssetHat::JS::Vendors.source_for(
                 vendor, options.slice(:ssl, :version))
-        html << include_assets(:js, src, :cache => true)
+        htmls << include_assets(:js, src,
+                  include_assets_options.merge(:cache => true).
+                                         except(:bundle, :bundles))
       end
 
-      options.except! :ssl, :version
+      # Get non-vendor HTML/URLs
+      htmls << include_assets(:js, *(args + [include_assets_options]))
+      htmls.reject!(&:blank?)
 
-      html << include_assets(:js, *(args + [options]))
-      html = html.join("\n").strip
+      if loader
+        # `htmls` actually contains URLs; convert to an HTML/JS block
+        urls  = htmls.dup.flatten
+        htmls = []
+
+        case loader
+        when :lab_js
+          htmls << include_js(:lab_js)
+          htmls << '<script type="text/javascript">'
+          htmls << AssetHat::JS::Vendors.loader_js(:lab_js, :urls => urls)
+          htmls << '</script>'
+        end
+      end
+
+      # Convert to a URL (string), array of URLs, or one long HTML string
+      html =  if options[:only_url]
+                # Return one URL (string) or multiple (array of strings).
+                # Not actually HTML.
+                htmls.flatten!
+                htmls.size == 1 ? htmls.first : htmls
+              else
+                # Return one long string of HTML
+                htmls.join("\n").strip
+              end
       AssetHat.html_cache[:js][cache_key] = html
     end
 
     html ||= AssetHat.html_cache[:js][cache_key]
-    html
+    html.respond_to?(:html_safe) ? html.html_safe : html
+  end
+
+  # Returns the public URL path to the given source file.
+  #
+  # <code>type</code> argument: <code>:css</code> or <code>:js</code>
+  def asset_path(type, source)
+    case type.to_sym
+    when :css ; stylesheet_path(source)
+    when :js  ; javascript_path(source)
+    else
+      raise %{Unknown type "#{type}"; should be one of: #{TYPES.join(', ')}.}
+    end
   end
 
 end

data/rails/init.rb

@@ -1,2 +1,2 @@
-::ActionView::Base.send(:include, AssetHatHelper)
-AssetHat.cache_last_commit_ids unless defined?(::IRB)
+require 'asset_hat/initializers/action_view'
+require 'asset_hat/initializers/cache_last_commit_ids'

data/test/asset_hat_helper_test.rb

@@ -4,71 +4,116 @@ class AssetHatHelperTest < ActionView::TestCase
   RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
 
   context 'include_css' do
+    setup { flexmock_rails_app }
+
     context 'with caching enabled' do
       context 'with minified versions' do
         setup do
           @commit_id = '111'
-          flexmock(AssetHat, :last_commit_id => @commit_id)
+          flexmock(AssetHat).should_receive(:last_commit_id => @commit_id).
+            by_default
         end
 
         should 'include one file by name, and ' +
                'automatically use minified version' do
           flexmock(AssetHat, :asset_exists? => true)
-          output = include_css('foo', :cache => true)
-          assert_equal css_tag("foo.min.css?#{@commit_id}"), output
+          expected_html = css_tag("foo.min.css?#{@commit_id}")
+          expected_path =
+            AssetHat.assets_path(:css) + "/foo.min.css?#{@commit_id}"
+
+          assert_equal expected_html, include_css('foo', :cache => true)
+          assert_equal expected_path, include_css('foo', :cache => true,
+                                        :only_url => true)
         end
 
         should 'include one unminified file by name and extension' do
-          output = include_css('foo.css', :cache => true)
-          assert_equal css_tag("foo.css?#{@commit_id}"), output
+          expected_html = css_tag("foo.css?#{@commit_id}")
+          expected_path =
+            AssetHat.assets_path(:css) + "/foo.css?#{@commit_id}"
+
+          assert_equal expected_html, include_css('foo.css', :cache => true)
+          assert_equal expected_path, include_css('foo.css', :cache => true,
+                                        :only_url => true)
         end
 
         should 'include one minified file by name and extension' do
-          output = include_css('foo.min.css', :cache => true)
-          assert_equal css_tag("foo.min.css?#{@commit_id}"), output
+          expected_html = css_tag("foo.min.css?#{@commit_id}")
+          expected_path =
+            AssetHat.assets_path(:css) + "/foo.min.css?#{@commit_id}"
+
+          assert_equal expected_html,
+            include_css('foo.min.css', :cache => true)
+          assert_equal expected_path,
+            include_css('foo.min.css', :cache => true, :only_url => true)
         end
 
         should 'include multiple files by name' do
           flexmock(AssetHat, :asset_exists? => true)
-          expected = %w[foo bar].map do |source|
+
+          sources = %w[foo bar]
+          expected_html = sources.map do |source|
             css_tag("#{source}.min.css?#{@commit_id}")
           end.join("\n")
-          output = include_css('foo', 'bar', :cache => true)
-          assert_equal expected, output
+          expected_paths = sources.map do |source|
+            AssetHat.assets_path(:css) + "/#{source}.min.css?#{@commit_id}"
+          end
+
+          assert_equal expected_html,
+            include_css('foo', 'bar', :cache => true)
+          assert_equal expected_paths,
+            include_css('foo', 'bar', :cache => true, :only_url => true)
         end
 
         should 'include multiple files as a bundle' do
           bundle = 'css-bundle-1'
-          output = include_css(:bundle => bundle, :cache => true)
-          assert_equal(
-            css_tag("bundles/#{bundle}.min.css?#{@commit_id}"), output)
+          expected_html = css_tag("bundles/#{bundle}.min.css?#{@commit_id}")
+          expected_path =
+            AssetHat.bundles_path(:css) + "/#{bundle}.min.css?#{@commit_id}"
+
+          assert_equal expected_html,
+            include_css(:bundle => bundle, :cache => true)
+          assert_equal expected_path,
+            include_css(:bundle => bundle, :cache => true, :only_url => true)
         end
 
         context 'via SSL' do
           setup do
-            @request = ActionController::TestRequest.new
-            flexmock(@controller, :request => @request)
-            flexmock(@controller.request, :ssl? => true)
+            @request = test_request
+            flexmock(@controller).should_receive(:request => @request).
+              by_default
+            flexmock(@controller.request).should_receive(:ssl? => true).
+              by_default
             assert @controller.request.ssl?,
               'Precondition: Request should use SSL'
           end
 
           should 'include multiple files as a SSL bundle' do
             flexmock(AssetHat, :ssl_asset_host_differs? => true)
-
             bundle = 'css-bundle-1'
-            output = include_css(:bundle => bundle, :cache => true)
-            assert_equal(
-              css_tag("bundles/ssl/#{bundle}.min.css?#{@commit_id}"), output)
+            expected_html =
+              css_tag("bundles/ssl/#{bundle}.min.css?#{@commit_id}")
+            expected_path = AssetHat.bundles_path(:css, :ssl => true) +
+              "/#{bundle}.min.css?#{@commit_id}"
+
+            assert_equal expected_html,
+              include_css(:bundle => bundle, :cache => true)
+            assert_equal expected_path,
+              include_css(:bundle => bundle, :cache => true,
+                :only_url => true)
           end
 
           should 'use non-SSL CSS if SSL/non-SSL asset hosts are the same' do
             flexmock(AssetHat, :ssl_asset_host_differs? => false)
-
             bundle = 'css-bundle-1'
-            output = include_css(:bundle => bundle, :cache => true)
-            assert_equal(
-              css_tag("bundles/#{bundle}.min.css?#{@commit_id}"), output)
+            expected_html = css_tag("bundles/#{bundle}.min.css?#{@commit_id}")
+            expected_path = AssetHat.bundles_path(:css) +
+              "/#{bundle}.min.css?#{@commit_id}"
+
+            assert_equal expected_html,
+              include_css(:bundle => bundle, :cache => true)
+            assert_equal expected_path,
+              include_css(:bundle => bundle, :cache => true,
+                :only_url => true)
           end
         end # context 'via SSL'
 
@@ -77,8 +122,11 @@ class AssetHatHelperTest < ActionView::TestCase
       context 'without minified versions' do
         should 'include one file by name, and ' +
                'automatically use original version' do
-          output = include_css('foo')
-          assert_equal css_tag('foo.css'), output
+          expected_html = css_tag('foo.css')
+          expected_path = AssetHat.assets_path(:css) + '/foo.css'
+
+          assert_equal expected_html, include_css('foo')
+          assert_equal expected_path, include_css('foo', :only_url => true)
         end
       end # context 'without minified versions'
     end # context 'with caching enabled'
@@ -86,20 +134,35 @@ class AssetHatHelperTest < ActionView::TestCase
     context 'with caching disabled' do
       should 'include one file by name, and ' +
              'automatically use original version' do
-        output = include_css('foo', :cache => false)
-        assert_equal css_tag('foo.css'), output
+        expected_html = css_tag('foo.css')
+        expected_path = AssetHat.assets_path(:css) + '/foo.css'
+
+        assert_equal expected_html, include_css('foo', :cache => false)
+        assert_equal expected_path, include_css('foo', :cache => false,
+                                      :only_url => true)
       end
 
       should 'include one unminified file by name and extension' do
-        output = include_css('foo.css', :cache => false)
-        assert_equal css_tag('foo.css'), output
+        expected_html = css_tag('foo.css')
+        expected_path = AssetHat.assets_path(:css) + '/foo.css'
+
+        assert_equal expected_html, include_css('foo.css', :cache => false)
+        assert_equal expected_path, include_css('foo.css', :cache => false,
+                                      :only_url => true)
       end
 
       should 'include multiple files by name' do
-        expected = %w[foo bar.min].
-          map { |src| css_tag("#{src}.css") }.join("\n")
-        output = include_css('foo', 'bar.min', :cache => false)
-        assert_equal expected, output
+        sources = %w[foo bar.min]
+        expected_html =
+          sources.map { |source| css_tag("#{source}.css") }.join("\n")
+        expected_paths = sources.map do |source|
+          AssetHat.assets_path(:css) + "/#{source}.css"
+        end
+
+        assert_equal expected_html,
+          include_css('foo', 'bar.min', :cache => false)
+        assert_equal expected_paths,
+          include_css('foo', 'bar.min', :cache => false, :only_url => true)
       end
 
       context 'with real bundle files' do
@@ -111,31 +174,70 @@ class AssetHatHelperTest < ActionView::TestCase
 
         should 'include a bundle as separate files' do
           bundle = 'css-bundle-1'
-          expected = @config['css']['bundles'][bundle].map do |source|
+          bundle_filenames = @config['css']['bundles'][bundle]
+          expected_html = bundle_filenames.map do |source|
             css_tag("#{source}.css?#{@asset_id}")
           end.join("\n")
-          output = include_css(:bundle => bundle, :cache => false)
-          assert_equal expected, output
+          expected_paths = bundle_filenames.map do |source|
+            AssetHat.assets_path(:css) + "/#{source}.css?#{@asset_id}"
+          end
+
+          assert_equal expected_html,
+            include_css(:bundle => bundle, :cache => false)
+          assert_equal expected_paths,
+            include_css(:bundle => bundle, :cache => false, :only_url => true)
         end
 
         should 'include a bundle as separate files ' +
                'with a symbol bundle name' do
           bundle = 'css-bundle-1'
-          expected = @config['css']['bundles'][bundle].map do |source|
+          expected = @config['css']['bundles'][bundle].map { |source|
             css_tag("#{source}.css?#{@asset_id}")
-          end.join("\n")
+          }.join("\n")
           output = include_css(:bundle => bundle.to_sym, :cache => false)
           assert_equal expected, output
         end
 
         should 'include multiple bundles as separate files' do
-          bundles = [1,2,3].map { |i| "css-bundle-#{i}" }
-          expected = bundles.map do |bundle|
+          bundles = [1,2].map { |i| "css-bundle-#{i}" }
+          expected_html = bundles.map { |bundle|
             sources = @config['css']['bundles'][bundle]
             sources.map { |src| css_tag("#{src}.css?#{@asset_id}") }
-          end.flatten.uniq.join("\n")
-          output = include_css(:bundles => bundles, :cache => false)
-          assert_equal expected, output
+          }.flatten.uniq.join("\n")
+          expected_paths = bundles.map do |bundle|
+            sources = @config['css']['bundles'][bundle]
+            sources.map do |src|
+              AssetHat.assets_path(:css) + "/#{src}.css?#{@asset_id}"
+            end
+          end.flatten.uniq
+
+          assert_equal expected_html,
+            include_css(:bundles => bundles, :cache => false)
+          assert_equal expected_paths,
+            include_css(:bundles => bundles, :cache => false,
+              :only_url => true)
+        end
+
+        should 'include named files and bundles together' do
+          bundles = ['css-bundle-2']
+          expected_html = css_tag("css-file-1-1.css?#{@asset_id}") + "\n" +
+            bundles.map do |bundle|
+              sources = @config['css']['bundles'][bundle]
+              sources.map { |src| css_tag("#{src}.css?#{@asset_id}") }
+            end.flatten.uniq.join("\n")
+          expected_paths = ["/stylesheets/css-file-1-1.css?#{@asset_id}"] +
+            bundles.map do |bundle|
+              sources = @config['css']['bundles'][bundle]
+              sources.map do |src|
+                AssetHat.assets_path(:css) + "/#{src}.css?#{@asset_id}"
+              end
+            end.flatten.uniq
+
+          assert_equal expected_html,
+            include_css('css-file-1-1', :bundles => bundles, :cache => false)
+          assert_equal expected_paths,
+            include_css('css-file-1-1', :bundles => bundles, :cache => false,
+              :only_url => true)
         end
       end # context 'with real bundle files'
     end # context 'with caching disabled'
@@ -143,78 +245,123 @@ class AssetHatHelperTest < ActionView::TestCase
 
   context 'include_js' do
     setup do
-      @request = ActionController::TestRequest.new
-      flexmock(@controller, :request => @request)
+      flexmock_rails_app
+      @request = test_request
+      flexmock(@controller).should_receive(:request => @request).by_default
     end
 
     context 'with caching enabled' do
       context 'with minified versions' do
         setup do
           @commit_id = '111'
-          flexmock(AssetHat,
-            :last_commit_id => @commit_id,
+          flexmock(AssetHat).should_receive(
+            :last_commit_id        => @commit_id,
             :last_bundle_commit_id => @commit_id
-          )
+          ).by_default
         end
 
         should 'include one file by name, and ' +
                'automatically use minified version' do
           flexmock(AssetHat, :asset_exists? => true)
-          output = include_js('jquery.some-plugin', :cache => true)
-          assert_equal js_tag("jquery.some-plugin.min.js?#{@commit_id}"),
-            output
+          expected_html = js_tag("jquery.some-plugin.min.js?#{@commit_id}")
+          expected_path = AssetHat.assets_path(:js) +
+            "/jquery.some-plugin.min.js?#{@commit_id}"
+
+          assert_equal expected_html,
+            include_js('jquery.some-plugin', :cache => true)
+          assert_equal expected_path,
+            include_js('jquery.some-plugin', :cache => true,
+              :only_url => true)
         end
 
         should 'include one unminified file by name and extension' do
-          output = include_js('jquery.some-plugin.js', :cache => true)
-          assert_equal js_tag("jquery.some-plugin.js?#{@commit_id}"), output
+          filename = 'jquery.some-plugin.js'
+          expected_html = js_tag("#{filename}?#{@commit_id}")
+          expected_path =
+            AssetHat.assets_path(:js) + "/#{filename}?#{@commit_id}"
+
+          assert_equal expected_html, include_js(filename, :cache => true)
+          assert_equal expected_path, include_js(filename, :cache => true,
+                                        :only_url => true)
         end
 
         should 'include one minified file by name and extension' do
-          output = include_js('jquery.some-plugin.min.js', :cache => true)
-          assert_equal(
-            js_tag("jquery.some-plugin.min.js?#{@commit_id}"), output)
+          filename = 'jquery.some-plugin.min.js'
+          expected_html = js_tag("#{filename}?#{@commit_id}")
+          expected_path =
+            AssetHat.assets_path(:js) + "/#{filename}?#{@commit_id}"
+
+          assert_equal expected_html, include_js(filename, :cache => true)
+          assert_equal expected_path, include_js(filename, :cache => true,
+                                        :only_url => true)
         end
 
         context 'with vendors' do
           should 'know where to find each vendor file' do
             AssetHat::JS::VENDORS.each do |vendor|
               assert include_js(vendor, :cache => true).present?
+              assert include_js(vendor, :cache => true,
+                                        :only_url => true).present?
             end
           end
 
-          should 'include jQuery and jQuery UI' do
-            flexmock(AssetHat, :config => @original_config)
+          should 'include jQuery and jQuery UI via local vendor files' do
             [:jquery, :jquery_ui].each do |vendor|
-              output = include_js(vendor, :cache => true)
-              assert_equal(
-                js_tag("#{vendor.to_s.dasherize}.min.js?#{@commit_id}"),
-                output)
+              vendor_filename = "#{vendor.to_s.dasherize}.min.js"
+              flexmock(AssetHat).should_receive(:asset_exists?).
+                with(vendor_filename, :js).and_return(true)
+
+              expected_html = js_tag("#{vendor_filename}?#{@commit_id}")
+              expected_path = AssetHat.assets_path(:js) +
+                                "/#{vendor_filename}?#{@commit_id}"
+
+              assert_equal expected_html, include_js(vendor, :cache => true)
+              assert_equal expected_path, include_js(vendor, :cache => true,
+                                            :only_url => true)
             end
           end
 
-          should 'include Prototype and script.aculo.us' do
+          should 'include Prototype and script.aculo.us ' +
+                 'via local vendor files' do
             [:prototype, :scriptaculous].each do |vendor|
-              output = include_js(vendor, :cache => true)
-              assert_equal js_tag("#{vendor}.js?#{@commit_id}"), output
+              vendor_filename = "#{vendor}.js"
+              flexmock(AssetHat).should_receive(:asset_exists?).
+                with(vendor_filename, :js).and_return(true)
+
+              expected_html = js_tag("#{vendor_filename}?#{@commit_id}")
                 # N.B.: Including only the regular, not minified, version
+              expected_path = AssetHat.assets_path(:js) +
+                                "/#{vendor_filename}?#{@commit_id}"
+
+              assert_equal expected_html, include_js(vendor, :cache => true)
+              assert_equal expected_path, include_js(vendor, :cache => true,
+                                            :only_url => true)
             end
           end
 
+          should 'not use a remote URL fallback if version is unknown' do
+            output = include_js(:jquery, :cache => true)
+            assert_equal js_tag("jquery.min.js?#{@commit_id}"), output
+          end
+
           context 'with remote requests via SSL' do
             should 'include vendor JS via Google CDN' do
-              AssetHat::JS::VENDORS.each do |vendor|
+              AssetHat::JS::Vendors::VENDORS_ON_GOOGLE_CDN.each do |vendor|
                 AssetHat.html_cache[:js] = {}
                 helper_opts = {:version => '1', :cache => true}
 
+                # Setup
                 flexmock_teardown
-                flexmock(AssetHat, :cache? => true)
-                flexmock(ActionController::Base,
-                  :consider_all_requests_local => false)
+                flexmock_rails_app
+                flexmock(AssetHat,
+                  :cache? => true,
+                  :consider_all_requests_local? => false
+                )
+
+                # Test inclusion via SSL
                 flexmock(@controller.request, :ssl? => true)
                 assert @controller.request.ssl?,
                   'Precondition: Request should use SSL'
-
                 https_html = include_js(vendor, helper_opts.dup)
                 assert_match(
                   %r{src="https://ajax\.googleapis\.com/}, https_html)
@@ -223,12 +370,17 @@ class AssetHatHelperTest < ActionView::TestCase
                   AssetHat.html_cache[:js].to_a.first[1],
                   'SSL HTML should be cached'
 
-                http_cache_key = AssetHat.html_cache[:js].to_a.first[0]
+                # Re-setup
                 flexmock_teardown
-                flexmock(AssetHat, :cache? => true)
-                flexmock(ActionController::Base,
-                  :consider_all_requests_local => false)
+                flexmock_rails_app
+                flexmock(AssetHat,
+                  :cache? => true,
+                  :consider_all_requests_local? => false
+                )
+
+                # Test caching of SSL inclusion HTML
                 flexmock(@controller.request, :ssl? => false)
+                http_cache_key = AssetHat.html_cache[:js].to_a.first[0]
                 assert !@controller.request.ssl?,
                   'Precondition: Request should not use SSL'
                 assert_equal 1, AssetHat.html_cache[:js].size
@@ -236,7 +388,8 @@ class AssetHatHelperTest < ActionView::TestCase
                   AssetHat.html_cache[:js][http_cache_key],
                   'SSL HTML should be still be cached'
 
-                http_html = include_js(vendor, helper_opts)
+                # Test inclusion, and caching of inclusion HTML, via non-SSL
+                http_html = include_js(vendor, helper_opts.dup)
                 assert_match(
                   %r{src="http://ajax\.googleapis\.com/},
                   http_html,
@@ -251,53 +404,181 @@ class AssetHatHelperTest < ActionView::TestCase
                   'Non-SSL HTML should be cached'
               end
             end
+
+            should 'get vendor URLs pointing to Google CDN' do
+              AssetHat::JS::Vendors::VENDORS_ON_GOOGLE_CDN.each do |vendor|
+                AssetHat.html_cache[:js] = {}
+                helper_opts = {:version => '1', :cache => true}
+
+                # Setup
+                flexmock_teardown
+                flexmock_rails_app
+                flexmock(AssetHat,
+                  :cache? => true,
+                  :consider_all_requests_local? => false
+                )
+
+                # Test SSL URL and URL caching
+                flexmock(@controller.request, :ssl? => true)
+                assert @controller.request.ssl?,
+                  'Precondition: Request should use SSL'
+                https_url = include_js(vendor,
+                  helper_opts.dup.merge(:only_url => true))
+                assert_equal 1, AssetHat.html_cache[:js].size
+                assert_match %r{^https://ajax\.googleapis\.com/}, https_url
+
+                # Re-setup
+                flexmock_teardown
+                flexmock_rails_app
+                flexmock(AssetHat,
+                  :cache? => true,
+                  :consider_all_requests_local? => false
+                )
+
+                # Test non-SSL URL and URL caching
+                flexmock(@controller.request, :ssl? => false)
+                assert !@controller.request.ssl?,
+                  'Precondition: Request should not use SSL'
+                http_url = include_js(vendor,
+                  helper_opts.dup.merge(:only_url => true))
+                assert_equal 2, AssetHat.html_cache[:js].size
+                assert_match %r{^http://ajax\.googleapis\.com/}, http_url
+              end
+            end
           end # context 'with remote requests via SSL'
         end # context 'with vendor JS'
 
-        should 'include jQuery by version via helper option' do
-          version = '1.4.1'
-          output = include_js(:jquery, :version => version, :cache => true)
-          assert_equal(
-            js_tag("jquery-#{version}.min.js?#{@commit_id}"), output)
-        end
-
-        context 'with a mock config' do
+        context 'with a mock config containing a version number' do
           setup do
-            version = '1.4.1'
+            @vendor_version = '1.6.0'
             config = AssetHat.config
             config['js']['vendors'] = {
-              'jquery' => {
-                'version' => version,
-                'remote_url' => 'http://example.com/cdn/jquery.min.js',
-                'remote_ssl_url' => 'https://secure.example.com/cdn/jquery.min.js'
-              }
+              'jquery' => {'version' => @vendor_version}
             }
-            flexmock(AssetHat, :config => config)
+            flexmock(AssetHat).should_receive(:config => config).by_default
           end
 
-          should 'include jQuery by version via config file' do
-            version = AssetHat.config['js']['vendors']['jquery']['version']
+          should 'include local copy of vendor with version in config file' do
+            vendor_filename = "jquery-#{@vendor_version}.min.js"
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(vendor_filename, :js).and_return(true)
+
+            expected_html = js_tag("#{vendor_filename}?#{@commit_id}")
+            expected_path =
+              AssetHat.assets_path(:js) + "/#{vendor_filename}?#{@commit_id}"
+
+            assert_equal expected_html, include_js(:jquery, :cache => true)
+            assert_equal expected_path, include_js(:jquery, :cache => true,
+                                          :only_url => true)
+          end
+
+          should 'include local copy of vendor with ' +
+                 'custom version in helper options' do
+            custom_version  = '1.3.2'
+            vendor_filename = "jquery-#{custom_version}.min.js"
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(vendor_filename, :js).and_return(true)
+
             assert_equal(
-              js_tag("jquery-#{version}.min.js?#{@commit_id}"),
-              include_js(:jquery, :cache => true)
-            )
+              js_tag("#{vendor_filename}?#{@commit_id}"),
+              include_js(:jquery, :version => custom_version, :cache => true))
           end
 
-          context 'with remote requests' do
+          context 'with local requests but no local copy of vendor file' do
             setup do
-              flexmock(ActionController::Base,
-                :consider_all_requests_local => false)
+              # Mock for version from config file:
+              flexmock(AssetHat).should_receive(:asset_exists?).
+                with("jquery-#{@vendor_version}.min.js", :js).
+                and_return(false).by_default
+
+              # Mock for version from helper options:
+              @custom_vendor_version = '1.3.2'
+              flexmock(AssetHat).should_receive(:asset_exists?).
+                with("jquery-#{@custom_vendor_version}.min.js", :js).
+                and_return(false).by_default
+
+              assert AssetHat.consider_all_requests_local?, 'Precondition'
+            end
+
+            should 'fall back to default remote vendor URL ' +
+                   'with version in config file' do
+              src = "http://ajax.googleapis.com/ajax/libs/jquery/" +
+                    "#{@vendor_version}/jquery.min.js"
+
+              assert_equal(
+                %{<script src="#{src}" type="text/javascript"></script>},
+                include_js(:jquery, :cache => true))
+            end
+
+            should 'fall back to default remote vendor URL ' +
+                   'with custom version in helper options' do
+              src = "http://ajax.googleapis.com/ajax/libs/jquery/" +
+                    "#{@custom_vendor_version}/jquery.min.js"
+
+              assert_equal(
+                %{<script src="#{src}" type="text/javascript"></script>},
+                include_js(:jquery, :version => @custom_vendor_version,
+                                    :cache   => true))
+            end
+
+            should 'fall back to default remote vendor SSL URL ' +
+                   'with version in config file' do
+              flexmock(@controller.request, :ssl? => true)
+              src = "https://ajax.googleapis.com/ajax/libs/jquery/" +
+                    "#{@vendor_version}/jquery.min.js"
+
+              assert_equal(
+                %{<script src="#{src}" type="text/javascript"></script>},
+                include_js(:jquery, :cache => true))
+            end
+
+            should 'fall back to default remote vendor SSL URL ' +
+                   'with custom version in helper options' do
+              flexmock(@controller.request, :ssl? => true)
+              src = "https://ajax.googleapis.com/ajax/libs/jquery/" +
+                    "#{@custom_vendor_version}/jquery.min.js"
+
+              assert_equal(
+                %{<script src="#{src}" type="text/javascript"></script>},
+                include_js(:jquery, :version => @custom_vendor_version,
+                                    :cache   => true))
             end
 
-            should 'use specified remote URL for jQuery' do
+          end # context 'with local requests but no local copy of vendor file'
+        end # context 'with a mock config containing a version number'
+
+        context 'with a mock config containing custom CDN URLs' do
+          setup do
+            @vendor_version = '1.6.0'
+            config = AssetHat.config
+            config['js']['vendors'] = {
+              'jquery' => {
+                'version'        => @vendor_version,
+                'remote_url'     => 'http://example.com/cdn/' +
+                                    "jquery-#{@vendor_version}.min.js",
+                'remote_ssl_url' => 'https://secure.example.com/cdn/' +
+                                    "jquery-#{@vendor_version}.min.js"
+              }
+            }
+            flexmock(AssetHat).should_receive(:config => config).by_default
+          end
+
+          context 'with local requests but no local copy of vendor file' do
+            setup do
+              flexmock(AssetHat).should_receive(:asset_exists?).
+                with("jquery-#{@vendor_version}.min.js", :js).
+                and_return(false).by_default
+              assert AssetHat.consider_all_requests_local?, 'Precondition'
+            end
+
+            should 'fall back to configured remote vendor URL' do
               src = AssetHat.config['js']['vendors']['jquery']['remote_url']
               assert_equal(
                 %{<script src="#{src}" type="text/javascript"></script>},
-                include_js(:jquery, :cache => true)
-              )
+                include_js(:jquery, :cache => true))
             end
 
-            should 'use specified remote SSL URL for jQuery' do
+            should 'fall back to configured remote vendor SSL URL' do
               flexmock(@controller.request, :ssl? => true)
               src =
                 AssetHat.config['js']['vendors']['jquery']['remote_ssl_url']
@@ -307,59 +588,123 @@ class AssetHatHelperTest < ActionView::TestCase
                 include_js(:jquery, :cache => true)
               )
             end
+          end # context 'with local requests but no local copy of vendor file'
+
+          context 'with remote requests' do
+            setup do
+              flexmock(AssetHat).
+                should_receive(:consider_all_requests_local? => false)
+              assert !AssetHat.consider_all_requests_local?, 'Precondition'
+            end
+
+            should 'use specified remote URL for vendor' do
+              src = AssetHat.config['js']['vendors']['jquery']['remote_url']
+              expected_html =
+                %{<script src="#{src}" type="text/javascript"></script>}
+              expected_path = src
+
+              assert_equal expected_html, include_js(:jquery, :cache => true)
+              assert_equal expected_path, include_js(:jquery, :cache => true,
+                                            :only_url => true)
+            end
+
+            should 'use specified remote SSL URL for vendor' do
+              flexmock(@controller.request, :ssl? => true)
+              src =
+                AssetHat.config['js']['vendors']['jquery']['remote_ssl_url']
+              expected_html =
+                %{<script src="#{src}" type="text/javascript"></script>}
+              expected_path = src
+
+              assert_equal expected_html, include_js(:jquery, :cache => true)
+              assert_equal expected_path, include_js(:jquery, :cache => true,
+                                            :only_url => true)
+            end
           end # context 'with remote requests'
-        end # context 'with a mock config'
+
+        end # context 'with a mock config containing custom CDN URLs'
 
         should 'include multiple files by name' do
           flexmock(AssetHat, :asset_exists? => true)
-          expected = %w[foo jquery.bar].map do |source|
+          sources = %w[foo jquery.plugin]
+          expected_html = sources.map do |source|
             js_tag("#{source}.min.js?#{@commit_id}")
           end.join("\n")
-          output = include_js('foo', 'jquery.bar', :cache => true)
-          assert_equal expected, output
+          expected_paths = sources.map do |source|
+            AssetHat.assets_path(:js) + "/#{source}.min.js?#{@commit_id}"
+          end
+
+          assert_equal expected_html,
+            include_js('foo', 'jquery.plugin', :cache => true)
+          assert_equal expected_paths,
+            include_js('foo', 'jquery.plugin', :cache => true,
+              :only_url => true)
         end
 
         should 'include multiple files as a bundle' do
-          bundle = 'js-bundle-1'
-          output = include_js(:bundle => bundle, :cache => true)
-          assert_equal(
-            js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
+          bundle   = 'js-bundle-1'
+          filename = "#{bundle}.min.js"
+          expected_html = js_tag("bundles/#{filename}?#{@commit_id}")
+          expected_path =
+            AssetHat.bundles_path(:js) + "/#{filename}?#{@commit_id}"
+
+          assert_equal expected_html,
+            include_js(:bundle => bundle, :cache => true)
+          assert_equal expected_path,
+            include_js(:bundle => bundle, :cache => true, :only_url => true)
         end
 
         should 'include multiple bundles' do
           flexmock(AssetHat, :asset_exists? => true)
-          expected = %w[foo bar].map do |bundle|
+          bundles = %w[foo bar]
+          expected_html = bundles.map do |bundle|
             js_tag("bundles/#{bundle}.min.js?#{@commit_id}")
           end.join("\n")
-          output = include_js(:bundles => %w[foo bar], :cache => true)
-          assert_equal expected, output
+          expected_paths = bundles.map do |bundle|
+            AssetHat.bundles_path(:js) + "/#{bundle}.min.js?#{@commit_id}"
+          end
+
+          assert_equal expected_html,
+            include_js(:bundles => bundles, :cache => true)
+          assert_equal expected_paths,
+            include_js(:bundles => bundles, :cache => true, :only_url => true)
         end
 
         context 'via SSL' do
           setup do
-            @request = ActionController::TestRequest.new
-            flexmock(@controller, :request => @request)
-            flexmock(@controller.request, :ssl? => true)
+            @request = test_request
+            flexmock(@controller).should_receive(:request => @request).
+              by_default
+            flexmock(@controller.request).should_receive(:ssl? => true).
+              by_default
             assert @controller.request.ssl?,
               'Precondition: Request should use SSL'
           end
 
           should 'use non-SSL JS if SSL/non-SSL asset hosts differ' do
             flexmock(AssetHat, :ssl_asset_host_differs? => true)
-
             bundle = 'js-bundle-1'
-            output = include_js(:bundle => bundle, :cache => true)
-            assert_equal(
-              js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
+            expected_html = js_tag("bundles/#{bundle}.min.js?#{@commit_id}")
+            expected_path =
+              AssetHat.bundles_path(:js) + "/#{bundle}.min.js?#{@commit_id}"
+
+            assert_equal expected_html,
+              include_js(:bundle => bundle, :cache => true)
+            assert_equal expected_path,
+              include_js(:bundle => bundle, :cache => true, :only_url => true)
           end
 
           should 'use non-SSL JS if SSL/non-SSL asset hosts are the same' do
             flexmock(AssetHat, :ssl_asset_host_differs? => false)
-
             bundle = 'js-bundle-1'
-            output = include_js(:bundle => bundle, :cache => true)
-            assert_equal(
-              js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
+            expected_html = js_tag("bundles/#{bundle}.min.js?#{@commit_id}")
+            expected_path =
+              AssetHat.bundles_path(:js) + "/#{bundle}.min.js?#{@commit_id}"
+
+            assert_equal expected_html,
+              include_js(:bundle => bundle, :cache => true)
+            assert_equal expected_path,
+              include_js(:bundle => bundle, :cache => true, :only_url => true)
           end
         end # context 'via SSL'
       end # context 'with minified versions'
@@ -367,8 +712,13 @@ class AssetHatHelperTest < ActionView::TestCase
       context 'without minified versions' do
         should 'include one file by name, and ' +
                'automatically use original version' do
-          output = include_js('jquery.some-plugin', :cache => true)
-          assert_equal js_tag('jquery.some-plugin.js'), output
+          source = 'jquery.some-plugin'
+          expected_html = js_tag("#{source}.js")
+          expected_path = AssetHat.assets_path(:js) + "/#{source}.js"
+
+          assert_equal expected_html, include_js(source, :cache => true)
+          assert_equal expected_path, include_js(source, :cache => true,
+                                        :only_url => true)
         end
       end # context 'without minified versions'
     end # context 'with caching enabled'
@@ -376,25 +726,48 @@ class AssetHatHelperTest < ActionView::TestCase
     context 'with caching disabled' do
       should 'include one file by name, and ' +
              'automatically use original version' do
-        output = include_js('foo', :cache => false)
-        assert_equal js_tag('foo.js'), output
+        source = 'foo'
+        expected_html = js_tag("#{source}.js")
+        expected_path = AssetHat.assets_path(:js) + "/#{source}.js"
+
+        assert_equal expected_html, include_js(source, :cache => true)
+        assert_equal expected_path, include_js(source, :cache => true,
+                                      :only_url => true)
       end
 
       should 'include one unminified file by name and extension' do
-        output = include_js('foo.js', :cache => false)
-        assert_equal js_tag('foo.js'), output
+        filename = 'foo.js'
+        expected_html = js_tag(filename)
+        expected_path = AssetHat.assets_path(:js) + "/#{filename}"
+
+        assert_equal expected_html, include_js(filename, :cache => true)
+        assert_equal expected_path, include_js(filename, :cache => true,
+                                      :only_url => true)
       end
 
       should 'include one minified file by name and extension' do
-        output = include_js('foo.min.js', :cache => false)
-        assert_equal js_tag('foo.min.js'), output
+        filename = 'foo.min.js'
+        expected_html = js_tag(filename)
+        expected_path = AssetHat.assets_path(:js) + "/#{filename}"
+
+        assert_equal expected_html, include_js(filename, :cache => true)
+        assert_equal expected_path, include_js(filename, :cache => true,
+                                      :only_url => true)
       end
 
       should 'include multiple files by name' do
-        expected = %w[foo bar.min].
-          map { |src| js_tag("#{src}.js") }.join("\n")
-        output = include_js('foo', 'bar.min', :cache => false)
-        assert_equal expected, output
+        sources = %w[foo bar.min]
+        expected_html = sources.map do |source|
+          js_tag("#{source}.js")
+        end.join("\n")
+        expected_paths = sources.map do |source|
+          AssetHat.assets_path(:js) + "/#{source}.js"
+        end
+
+        assert_equal expected_html,
+          include_js('foo', 'bar.min', :cache => false)
+        assert_equal expected_paths,
+          include_js('foo', 'bar.min', :cache => false, :only_url => true)
       end
 
       context 'with real bundle files' do
@@ -407,16 +780,23 @@ class AssetHatHelperTest < ActionView::TestCase
         should 'include a bundle as separate files' do
           bundle = 'js-bundle-1'
           sources = @config['js']['bundles'][bundle]
-          expected = sources.
-            map { |src| js_tag("#{src}.js?#{@asset_id}") }.join("\n")
-          output = include_js(:bundle => bundle, :cache => false)
-          assert_equal expected, output
+          expected_html = sources.map do |source|
+            js_tag("#{source}.js?#{@asset_id}")
+          end.join("\n")
+          expected_paths = sources.map do |source|
+            AssetHat.assets_path(:js) + "/#{source}.js?#{@asset_id}"
+          end
+
+          assert_equal expected_html,
+            include_js(:bundle => bundle, :cache => false)
+          assert_equal expected_paths,
+            include_js(:bundle => bundle, :cache => false, :only_url => true)
         end
 
         should 'include a bundle as separate files ' +
                'with a symbol bundle name' do
-          bundle = 'js-bundle-1'
-          sources = @config['js']['bundles'][bundle]
+          bundle   = 'js-bundle-1'
+          sources  = @config['js']['bundles'][bundle]
           expected = sources.
             map { |src| js_tag("#{src}.js?#{@asset_id}") }.join("\n")
           output = include_js(:bundle => bundle.to_sym, :cache => false)
@@ -424,19 +804,194 @@ class AssetHatHelperTest < ActionView::TestCase
         end
 
         should 'include multiple bundles as separate files' do
-          bundles = [1,2,3].map { |i| "js-bundle-#{i}" }
-          expected = bundles.map do |bundle|
+          bundles = [1,2].map { |i| "js-bundle-#{i}" }
+          expected_html = bundles.map { |bundle|
             sources = @config['js']['bundles'][bundle]
             sources.map { |src| js_tag("#{src}.js?#{@asset_id}") }
-          end.flatten.uniq.join("\n")
-          output = include_js(:bundles => bundles, :cache => false)
-          assert_equal expected, output
+          }.flatten.uniq.join("\n")
+          expected_paths = bundles.map do |bundle|
+            sources = @config['js']['bundles'][bundle]
+            sources.map do |src|
+              AssetHat.assets_path(:js) + "/#{src}.js?#{@asset_id}"
+            end
+          end.flatten.uniq
+
+          assert_equal expected_html,
+            include_js(:bundles => bundles, :cache => false)
+          assert_equal expected_paths,
+            include_js(:bundles => bundles, :cache => false,
+              :only_url => true)
+        end
+
+        should 'include vendors, named files and bundles together' do
+          bundles = ['js-bundle-2']
+          expected_html =
+            js_tag("jquery.min.js?#{@asset_id}") + "\n" +
+            js_tag("js-file-1-1.js?#{@asset_id}") + "\n" +
+            bundles.map do |bundle|
+              sources = @config['js']['bundles'][bundle]
+              sources.map { |src| js_tag("#{src}.js?#{@asset_id}") }
+            end.flatten.uniq.join("\n")
+          expected_paths =
+            [ "/javascripts/jquery.min.js?#{@asset_id}",
+              "/javascripts/js-file-1-1.js?#{@asset_id}" ] +
+            bundles.map do |bundle|
+              sources = @config['js']['bundles'][bundle]
+              sources.map do |src|
+                AssetHat.assets_path(:js) + "/#{src}.js?#{@asset_id}"
+              end
+            end.flatten.uniq
+
+          assert_equal expected_html,
+            include_js(:jquery, 'js-file-1-1', :bundles => bundles,
+              :cache => false)
+          assert_equal expected_paths,
+            include_js(:jquery, 'js-file-1-1', :bundles => bundles,
+              :cache => false, :only_url => true)
         end
       end # context 'with real bundle files'
     end # context 'with caching disabled'
 
+    context 'with LABjs' do
+      should 'render with default config and basic URL arguments' do
+        urls      = [ '/javascripts/foo.js',
+                      'http://cdn.example.com/bar.js' ]
+        expected  = %{<script src="/javascripts/LAB.min.js" } +
+                      %{type="text/javascript"></script>\n}
+        expected << %{<script type="text/javascript">\n}
+        expected << %{window.$LABinst=$LAB.\n}
+        expected << %{  script('#{urls.first}').wait().\n}
+        expected << %{  script('#{urls.second}').wait();\n}
+        expected << %{</script>}
+
+        assert_equal expected,
+          include_js('foo', urls.second, :loader => :lab_js)
+      end
+
+      context 'with LABjs version config, vendor, and multiple bundles' do
+        setup do
+          @config = AssetHat.config
+          @config['js']['vendors'] = {
+            'jquery' => {'version' => '1.6.0'},
+            'lab_js' => {'version' => '1.2.0'}
+          }
+          flexmock(AssetHat).should_receive(:config => @config).by_default
+
+          @asset_id = ENV['RAILS_ASSET_ID'] = ''
+          flexmock(AssetHat).should_receive(
+            :asset_exists?  => false,
+            :last_commit_id => ''
+          ).by_default
+
+          @jquery_version = @config['js']['vendors']['jquery']['version']
+          @lab_js_version = @config['js']['vendors']['lab_js']['version']
+        end
+        teardown { ENV['RAILS_ASSET_ID'] = nil }
+
+        context 'with local requests' do
+          should 'render with caching disabled' do
+            loader_filename = "LAB-#{@lab_js_version}.min.js"
+            vendor_filename = "jquery-#{@jquery_version}.min.js"
+
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(loader_filename, :js).and_return(true)
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(vendor_filename, :js).and_return(true)
+            assert AssetHat.asset_exists?(vendor_filename, :js),
+              'Precondition'
+
+            expected =  %{<script src="/javascripts/#{loader_filename}" } +
+                          %{type="text/javascript"></script>\n}
+            expected << %{<script type="text/javascript">\n}
+            expected << "window.$LABinst=$LAB.\n"
+            expected << "  script('/javascripts/#{vendor_filename}').wait().\n"
+            expected << "  script('/javascripts/foo.js').wait().\n"
+            expected << "  script('/javascripts/js-file-1-1.js').wait().\n"
+            expected << "  script('/javascripts/js-file-1-2.js').wait().\n"
+            expected << "  script('/javascripts/js-file-1-3.js').wait().\n"
+            expected << "  script('/javascripts/js-file-2-1.js').wait().\n"
+            expected << "  script('/javascripts/js-file-2-2.js').wait().\n"
+            expected << "  script('/javascripts/js-file-2-3.js').wait();\n"
+            expected << '</script>'
+
+            assert_equal expected, include_js(:jquery, 'foo',
+                                    :bundles => %w[js-bundle-1 js-bundle-2],
+                                    :loader  => :lab_js)
+          end
+
+          should 'render with caching disabled and remote vendor ' +
+                 'if local loader vendor is missing' do
+            loader_filename = "LAB-#{@lab_js_version}.min.js"
+            vendor_filename = "jquery-#{@jquery_version}.min.js"
+            loader_url      = 'http://ajax.cdnjs.com/ajax/libs/labjs/' +
+                                @lab_js_version + '/LAB.min.js'
+
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(loader_filename, :js).and_return(false)
+            flexmock(AssetHat).should_receive(:asset_exists?).
+              with(vendor_filename, :js).and_return(true)
+            assert AssetHat.asset_exists?(vendor_filename, :js),
+              'Precondition'
+
+            expected =  %{<script src="#{loader_url}" } +
+                          %{type="text/javascript"></script>\n}
+            expected << %{<script type="text/javascript">\n}
+            expected << "window.$LABinst=$LAB.\n"
+            expected << "  script('/javascripts/#{vendor_filename}').wait().\n"
+            expected << "  script('/javascripts/foo.js').wait();\n"
+            expected << '</script>'
+
+            assert_equal expected,
+              include_js(:jquery, 'foo', :loader => :lab_js)
+          end
+        end # context 'with local requests'
+
+        context 'with remote requests' do
+          setup do
+            flexmock(AssetHat, :consider_all_requests_local? => false)
+          end
+
+          should 'render with caching enabled and remote vendors' do
+            lab_js_url = 'http://ajax.cdnjs.com/ajax/libs/labjs/' +
+                          @lab_js_version + '/LAB.min.js'
+            jquery_url = 'http://ajax.googleapis.com/ajax/libs/jquery/' +
+                          @jquery_version + '/jquery.min.js'
+
+            expected =  %{<script src="#{lab_js_url}" } +
+                          %{type="text/javascript"></script>\n}
+            expected << %{<script type="text/javascript">\n}
+            expected << "window.$LABinst=$LAB.\n"
+            expected << "  script('#{jquery_url}').wait().\n"
+            expected << "  script('/javascripts/foo.js').wait().\n"
+            expected << "  script('/javascripts/" +
+                            "bundles/js-bundle-1.min.js').wait().\n"
+            expected << "  script('/javascripts/" +
+                            "bundles/js-bundle-2.min.js').wait();\n"
+            expected << '</script>'
+
+            assert_equal expected, include_js(:jquery, 'foo',
+                                    :bundles => %w[js-bundle-1 js-bundle-2],
+                                    :loader  => :lab_js,
+                                    :cache   => true)
+          end
+        end # context 'with remote requests'
+      end # context 'with LABjs version config, vendor, and multiple bundles'
+    end # context 'with LABjs'
+
   end # context 'include_js'
 
+  should 'compute public asset paths' do
+    flexmock_rails_app
+
+    assert_equal '/stylesheets/foo.css', asset_path(:css, 'foo')
+    assert_equal '/stylesheets/bundles/foo.min.css',
+      asset_path(:css, 'bundles/foo.min.css')
+
+    assert_equal '/javascripts/foo.js', asset_path(:js, 'foo')
+    assert_equal '/javascripts/bundles/foo.min.js',
+      asset_path(:js, 'bundles/foo.min.js')
+  end
+
 
 
   private
@@ -452,4 +1007,32 @@ class AssetHatHelperTest < ActionView::TestCase
     %{<script src="/javascripts/#{filename}" type="text/javascript"></script>}
   end
 
+  def flexmock_rails_app
+    # Creates just enough hooks for a dummy Rails app.
+    flexmock(Rails,
+      :application => flexmock('dummy_app', :env_defaults => {}),
+      :logger      => flexmock('dummy_logger', :warn => nil)
+    )
+
+    if defined?(config) # Rails 3.x
+      config.assets_dir = AssetHat::ASSETS_DIR
+    end
+
+    flexmock(AssetHat).should_receive(:consider_all_requests_local? => true).
+      by_default
+  end
+
+  # def flexmock_rails_app_config(opts)
+  #   flexmock(Rails.application.config, opts)  # Rails 3.x
+  #   flexmock(ActionController::Base, opts)    # Rails 2.x
+  # end
+
+  def test_request
+    if defined?(ActionDispatch) # Rails 3.x
+      ActionDispatch::TestRequest.new
+    else # Rails 2.x
+      ActionController::TestRequest.new
+    end
+  end
+
 end