rack-sprockets 1.0.4 → 1.1.0

data/lib/rack/sprockets/version.rb

@@ -1,13 +1,5 @@
-module RackSprockets
-  module Version
-    
-    MAJOR = 1
-    MINOR = 0
-    TINY  = 4
-    
-    def self.to_s # :nodoc:
-      [MAJOR, MINOR, TINY].join('.')
-    end
-    
+module Rack
+  module Sprockets
+    VERSION = "1.1.0"
   end
-end
+end

data/rack-sprockets.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack/sprockets/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rack-sprockets"
+  s.version     = Rack::Sprockets::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kelly Redding"]
+  s.email       = ["kelly@kelredd.com"]
+  s.homepage    = "http://github.com/kelredd/rack-sprockets"
+  s.summary     = %q{Sprockets javascript preprocessing for Rack apps.}
+  s.description = %q{Use rack middleware to handle sprockets preprocessing.  Processing happens on requests to sprockets resources.  This allows you to develop, check in, and deploy unprocessed sprockets resources and leave the processing to the middleware.  Allows for optimizing by environment: never-cache, always-reprocess in development; cache, process-once in production (for example).}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("bundler", ["~> 1.0"])
+  s.add_development_dependency("test-belt", ["= 0.2.1"]) # locked to a specific version for test stability
+  s.add_development_dependency("sinatra", [">= 0.9.4"])
+  s.add_development_dependency("rack-test", [">= 0.5.3"])
+  s.add_development_dependency("webrat", [">= 0.6.0"])
+  s.add_development_dependency("yui-compressor", [">=0.9.1"])
+
+  s.add_dependency("rack", ["~> 1.0"])
+  s.add_dependency("sprockets", ["~> 1.0"])
+end

data/test/app_helper.rb

@@ -0,0 +1,25 @@
+require 'rack/test'
+require 'webrat'
+
+class Test::Unit::TestCase
+  include Rack::Test::Methods
+  include Webrat::Methods
+  include Webrat::Matchers
+ 
+  Webrat.configure do |config|
+    config.mode = :rack
+  end 
+
+  class << self
+
+    def should_respond_with_compiled_js
+      should "return compiled js" do
+        assert_equal 200, @response.status, "status is not '#{Rack::Utils::HTTP_STATUS_CODES[200]}'"
+        assert @response.headers["Content-Type"].include?(Rack::Sprockets::MIME_TYPE), "content type is not '#{Rack::Sprockets::MIME_TYPE}'"
+        assert_equal @compiled.strip, @response.body.strip, "the compiled js is incorrect"
+      end
+    end
+
+  end
+
+end

data/test/config_test.rb

@@ -0,0 +1,80 @@
+require 'test/helper'
+require 'rack/sprockets/config'
+
+class ConfigTest < Test::Unit::TestCase
+  context 'Rack::Sprockets::Config' do
+    setup do
+      @config = Rack::Sprockets::Config.new
+    end
+
+    { :cache => false,
+      :compress => false
+    }.each do |k,v|
+      should "have an accessor for #{k}" do
+        assert_respond_to @config, k, "no reader for #{k}"
+        assert_respond_to @config, "#{k}=".to_sym, "no writer for #{k}"
+      end
+
+      should "default #{k} correctly" do
+        assert_equal v, @config.send(k)
+      end
+    end
+
+    should "provide boolean readers" do
+      assert_respond_to @config, :cache?, "no reader for :cache?"
+      assert_equal !!@config.cache, @config.cache?
+      assert_respond_to @config, :compress?, "no reader for :compress?"
+      assert_equal !!@config.compress, @config.compress?
+    end
+
+    should "allow init with setting hash" do
+      settings = {
+        :cache => true,
+        :compress => true
+      }
+      config = Rack::Sprockets::Config.new settings
+
+      assert_equal true, config.cache
+      assert_equal true, config.compress
+    end
+
+    should "be accessible at Rack::Sprockets class level" do
+      assert_respond_to Rack::Sprockets, :configure
+      assert_respond_to Rack::Sprockets, :config
+      assert_respond_to Rack::Sprockets, :config=
+    end
+
+    context "given a new configuration" do
+      setup do
+        @old_config = Rack::Sprockets.config
+        @settings = {
+          :cache => true,
+          :compress => true,
+        }
+        @traditional_config = Rack::Sprockets::Config.new @settings
+      end
+      teardown do
+        Rack::Sprockets.config = @old_config
+      end
+
+      should "allow Rack::Sprockets to directly apply settings" do
+        Rack::Sprockets.config = @traditional_config.dup
+
+        assert_equal @traditional_config.cache, Rack::Sprockets.config.cache
+        assert_equal @traditional_config.compress, Rack::Sprockets.config.compress
+      end
+
+      should "allow Rack::Sprockets to apply settings using a block" do
+        Rack::Sprockets.configure do |config|
+          config.cache  = true
+          config.compress = true
+        end
+
+        assert_equal @traditional_config.cache, Rack::Sprockets.config.cache
+        assert_equal @traditional_config.compress, Rack::Sprockets.config.compress
+      end
+
+    end
+
+  end
+end

data/test/env.rb

@@ -0,0 +1,9 @@
+# Add test and lib paths to the $LOAD_PATH
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), '..', 'lib')
+].each do |path|
+  full_path = File.expand_path(path)
+  $LOAD_PATH.unshift(full_path) unless $LOAD_PATH.include?(full_path)
+end
+
+require 'rack/sprockets'

data/test/fixtures/mock_options.rb

@@ -0,0 +1,9 @@
+class MockOptions
+  include Rack::Sprockets::Options
+  
+  def initialize
+    @env = nil
+    initialize_options
+  end
+end
+

data/test/fixtures/sinatra/app.rb

@@ -0,0 +1,9 @@
+require 'sinatra/base'
+
+class SinatraApp < Sinatra::Base
+  
+  configure do
+    set :root, File.expand_path(File.dirname(__FILE__))
+  end
+  
+end

data/test/fixtures/sinatra/app/javascripts/alert_one.js

@@ -0,0 +1,2 @@
+var one_message = 'alert one';
+alert(one_message);

data/test/fixtures/sinatra/app/javascripts/alert_two.js

@@ -0,0 +1,2 @@
+var two_message = 'alert 2';
+alert(two_message);

data/test/fixtures/sinatra/app/javascripts/app.js

@@ -0,0 +1,10 @@
+//= require <alert_one>
+//= require <alert_two>
+
+var app_message = 'full app';
+alert(app_message);
+
+function () {
+  var foo = {};
+  foo["bar"] = "baz";
+}

data/test/fixtures/sinatra/app/javascripts/app_compiled.js

@@ -0,0 +1,12 @@
+var one_message = 'alert one';
+alert(one_message);
+var two_message = 'alert 2';
+alert(two_message);
+
+var app_message = 'full app';
+alert(app_message);
+
+function () {
+  var foo = {};
+  foo["bar"] = "baz";
+}

data/test/fixtures/sinatra/app/javascripts/nested/dependency.js

@@ -0,0 +1,2 @@
+var dependency_msg = 'dependent';
+alert(dependency_msg);

data/test/fixtures/sinatra/app/javascripts/nested/thing.js

@@ -0,0 +1,11 @@
+//= require <alert_one>
+//= require <alert_two>
+//= require <nested/dependency>
+
+var thing_message = 'thing';
+alert(thing_message);
+
+function () {
+  var ahh = {};
+  ahh["boo"] = "poo";
+}

data/test/fixtures/sinatra/app/javascripts/nested/thing_compiled.js

@@ -0,0 +1,14 @@
+var one_message = 'alert one';
+alert(one_message);
+var two_message = 'alert 2';
+alert(two_message);
+var dependency_msg = 'dependent';
+alert(dependency_msg);
+
+var thing_message = 'thing';
+alert(thing_message);
+
+function () {
+  var ahh = {};
+  ahh["boo"] = "poo";
+}

data/test/helper.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'test_belt'
+require 'test/env'
+
+class Test::Unit::TestCase
+
+  def file_path(*segments)
+    segs = segments.unshift([File.dirname(__FILE__), '..']).flatten
+    File.expand_path(segs.join(File::SEPARATOR))
+  end
+
+  def env_defaults
+    Rack::Sprockets::Base.defaults.merge({
+      Rack::Sprockets::Base.option_name(:root) => file_path('test','fixtures','sinatra')
+    })
+  end
+
+  def self.should_compile_source(name, desc)
+    context desc do
+      setup do
+        @compiled = File.read(File.join(@source_folder, "#{name}_compiled.js"))
+        @source = Rack::Sprockets::Source.new(name, {
+          :folder => @source_folder,
+          :secretary => @secretary
+        })
+      end
+
+      should "compile to Javascript" do
+        assert_equal @compiled.strip, @source.compiled.strip, '.compiled is incorrect'
+        assert_equal @compiled.strip, @source.to_js.strip, '.to_js is incorrect'
+        assert_equal @compiled.strip, @source.js.strip, '.js is incorrect'
+      end
+    end
+  end
+
+  def sprockets_request(method, path_info)
+    Rack::Sprockets::Request.new(@defaults.merge({
+      'REQUEST_METHOD' => method,
+      'PATH_INFO' => path_info
+    }))
+  end
+
+  def sprockets_response(js)
+    Rack::Sprockets::Response.new(@defaults, js)
+  end
+
+  def self.should_not_be_a_valid_rack_sprockets_request(args)
+    context "to #{args[:method].upcase} #{args[:resource]} (#{args[:description]})" do
+      setup do
+        @request = sprockets_request(args[:method], args[:resource])
+      end
+
+      should "not be a valid endpoint for Rack::Sprockets" do
+        not_valid = !@request.get?
+        not_valid ||= !@request.for_js?
+        not_valid ||= @request.source.files.empty?
+        assert not_valid, 'request is a GET for .js format and has source'
+        assert !@request.for_sprockets?, 'the request is for sprockets'
+      end
+    end
+  end
+  def self.should_be_a_valid_rack_sprockets_request(args)
+    context "to #{args[:method].upcase} #{args[:resource]} (#{args[:description]})" do
+      setup do
+        @request = sprockets_request(args[:method], args[:resource])
+      end
+
+      should "be a valid endpoint for Rack::Sprockets" do
+        assert @request.get?, 'the request is not a GET'
+        assert @request.for_js?, 'the request is not for js'
+        assert !@request.source.files.empty?, 'the request resource has no source'
+        assert @request.for_sprockets?, 'the request is not for sprockets'
+      end
+    end
+  end
+
+end

data/test/options_test.rb

@@ -0,0 +1,78 @@
+require 'test/helper'
+require 'rack/sprockets/options'
+require 'fixtures/mock_options'
+
+class OptionsTest < Test::Unit::TestCase
+  context 'Rack::Sprockets::Options' do
+    setup { @options = MockOptions.new }
+
+    should "use a namespace" do
+      assert_equal 'rack-sprockets', Rack::Sprockets::Options::RACK_ENV_NS
+    end
+
+    should "provide an option_name helper" do
+      assert_respond_to MockOptions, :option_name
+    end
+
+    should "provide defaults" do
+      assert_respond_to MockOptions, :defaults
+    end
+
+    should "allow access to the options" do
+      assert_respond_to @options, :options, 'no #options accessor'
+      assert_kind_of Hash, @options.options, '#options is not a Hash'
+      assert_equal MockOptions.defaults[MockOptions.option_name(:source)], @options.options(:source)
+    end
+
+    { :root => ".",
+      :public => 'public',
+      :source => 'app/javascripts',
+      :hosted_at => '/javascripts',
+      :load_path => ["app/javascripts/", "vendor/javascripts/"],
+      :expand_paths => true
+    }.each do |k,v|
+      should "default #{k} correctly" do
+        assert_equal v, @options.options[MockOptions.option_name(k)]
+      end
+    end
+
+    context '#set' do
+      should "set a Symbol option as #{Rack::Sprockets::Options::RACK_ENV_NS}.symbol" do
+        @options.set :foo, 'bar'
+        assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
+      end
+      should 'set a String option as string' do
+        @options.set 'foo.bar', 'baz'
+        assert_equal 'baz', @options.options['foo.bar']
+      end
+      should 'set all key/value pairs when given a Hash' do
+        @options.set :foo => 'bar', 'foo.bar' => 'baz'
+        assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
+        assert_equal 'baz', @options.options['foo.bar']
+      end
+    end
+
+    should 'allow setting multiple options via assignment' do
+      @options.options = { :foo => 'bar', 'foo.bar' => 'baz' }
+      assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
+      assert_equal 'baz', @options.options['foo.bar']
+    end
+
+    context "when writing to collection options" do
+      setup do
+        @option = Rack::Sprockets::Options::COLLECTION_OPTS.first
+      end
+
+      should "force the option to an array value" do
+        @options.set @option, ["blah", "whatever"]
+        assert_kind_of Array, @options.options[@option]
+        assert_equal 2, @options.options[@option].length
+
+        @options.set @option, "something"
+        assert_kind_of Array, @options.options[@option]
+        assert_equal 1, @options.options[@option].length
+      end
+    end
+
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,141 @@
+require 'test/helper'
+require 'rack/sprockets/base'
+require 'rack/sprockets/request'
+
+class RequestTest < Test::Unit::TestCase
+
+  context 'Rack::Sprockets::Request' do
+    setup do
+      @defaults = env_defaults
+    end
+
+    context "basic object" do
+      should "have some attributes" do
+        [ :options,
+          :hosted_at_option,
+          :request_method,
+          :path_info,
+          :path_info_resource,
+          :path_info_format,
+          :source,
+          :hosted_at?,
+          :cached?,
+          :for_js?,
+          :for_sprockets?
+        ].each do |a|
+          assert_respond_to sprockets_request("GET", "/foo.js"), a, "request does not respond to #{a.inspect}"
+        end
+      end
+
+      should "sanitize the :hosted_at options" do
+        req = sprockets_request("GET", "/something.js")
+        req.options = {:hosted_at => "/here"}
+        assert_equal "/here", req.hosted_at_option
+
+        req = sprockets_request("GET", "/something.js")
+        req.options = {:hosted_at => "//there"}
+        assert_equal "/there", req.hosted_at_option
+
+        req = sprockets_request("GET", "/something.js")
+        req.options = {:hosted_at => "/where/"}
+        assert_equal "/where", req.hosted_at_option
+
+        req = sprockets_request("GET", "/something.js")
+        req.options = {:hosted_at => "what/"}
+        assert_equal "/what", req.hosted_at_option
+
+        req = sprockets_request("GET", "/something.js")
+        req.options = {:hosted_at => "why//"}
+        assert_equal "/why", req.hosted_at_option
+      end
+
+      should "know it's resource" do
+        assert_equal '/something', sprockets_request("GET", "/javascripts/something.js").path_info_resource
+        assert_equal '/something.awesome', sprockets_request("GET", "/javascripts/something.awesome.js").path_info_resource
+        assert_equal '/nested/something', sprockets_request("GET", "/javascripts/nested/something.js").path_info_resource
+        assert_equal '/something', sprockets_request("GET", "/something.js").path_info_resource
+        assert_equal '/something', sprockets_request("GET", "///something.js").path_info_resource
+        assert_equal '/nested/something', sprockets_request("GET", "/nested/something.js").path_info_resource
+        assert_equal '/nested/something', sprockets_request("GET", "/nested///something.js").path_info_resource
+      end
+
+      should "know it's resource format" do
+        assert_equal '.js', sprockets_request("GET", "/foo.js").path_info_format
+        assert_equal '.js', sprockets_request("GET", "/foo/bar.js").path_info_format
+      end
+    end
+
+    context "#source " do
+      should "match :compress settings with Rack::Sprockets:Config" do
+        req = sprockets_request("GET", "/javascripts/app.js")
+        assert_equal Rack::Sprockets.config.compress?, req.source.compress?
+      end
+
+      should "set it's cache value to nil when Rack::Sprockets not configured to cache" do
+        Rack::Sprockets.config = Rack::Sprockets::Config.new
+        req = sprockets_request("GET", "/javascripts/app.js")
+
+        assert_equal false, req.source.cache?
+        assert_equal nil, req.source.cache
+      end
+
+      should "set it's cache to the appropriate path when Rack::Sprockets configured to cache" do
+        Rack::Sprockets.config = Rack::Sprockets::Config.new :cache => true
+        req = sprockets_request("GET", "/javascripts/app.js")
+        cache_path = File.join(req.options(:root), req.options(:public), req.options(:hosted_at))
+
+        assert_equal true, req.source.cache?
+        assert_equal cache_path, req.source.cache
+      end
+    end
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "POST",
+      :resource    => "/foo.html",
+      :description => "a non-js resource"
+    })
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "POST",
+      :resource    => "/foo.css",
+      :description => "a css resource"
+    })
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/foo.html",
+      :description => "a non-js resource"
+    })
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/foo.js",
+      :description => "a js resource hosted somewhere other than where Rack::Sprockets expects them"
+    })
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/javascripts/foo.js",
+      :description => "a js resource hosted where Rack::Sprockets expects them but does not match any source"
+    })
+
+    should_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/javascripts/app.js",
+      :description => "a js resource hosted where Rack::Sprockets expects them that matches source"
+    })
+
+    should_not_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/javascripts/nested/foo.js",
+      :description => "a nested js resource hosted where Rack::Sprockets expects them but does not match any source"
+    })
+
+    should_be_a_valid_rack_sprockets_request({
+      :method      => "GET",
+      :resource    => "/javascripts/nested/thing.js",
+      :description => "a nested js resource hosted where Rack::Sprockets expects them that matches source"
+    })
+  end
+
+end