rack-less 1.5.0 → 2.0.0

data/test/options_test.rb

@@ -0,0 +1,60 @@
+require "test/helper"
+require 'rack/less/options'
+require 'fixtures/mock_options'
+
+class OptionsTest < Test::Unit::TestCase
+  context 'Rack::Less::Options' do
+    setup { @options = MockOptions.new }
+
+    should "use a namespace" do
+      assert_equal 'rack-less', Rack::Less::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 => ".",
+      :source => 'app/stylesheets',
+      :public => 'public',
+      :hosted_at => '/stylesheets'
+    }.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::Less::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
+
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,142 @@
+require "test/helper"
+require 'rack/less/request'
+
+class RequestTest < Test::Unit::TestCase
+
+  context 'Rack::Less::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_format,
+          :path_info_resource,
+          :source,
+          :hosted_at?,
+          :cached?,
+          :for_css?,
+          :for_less?
+        ].each do |a|
+          assert_respond_to less_request("GET", "/foo.css"), a, "request does not respond to #{a.inspect}"
+        end
+      end
+
+      should "know it's resource format" do
+        assert_equal '.css', less_request("GET", "/foo.css").path_info_format
+        assert_equal '.css', less_request("GET", "/foo/bar.css").path_info_format
+        assert_equal '', less_request("GET", "/foo/bar").path_info_format
+      end
+
+      should "sanitize the :hosted_at options" do
+        req = less_request("GET", "/something.css")
+        req.options = {:hosted_at => "/here"}
+        assert_equal "/here", req.hosted_at_option
+
+        req = less_request("GET", "/something.css")
+        req.options = {:hosted_at => "//there"}
+        assert_equal "/there", req.hosted_at_option
+
+        req = less_request("GET", "/something.css")
+        req.options = {:hosted_at => "/where/"}
+        assert_equal "/where", req.hosted_at_option
+
+        req = less_request("GET", "/something.css")
+        req.options = {:hosted_at => "what/"}
+        assert_equal "/what", req.hosted_at_option
+
+        req = less_request("GET", "/something.css")
+        req.options = {:hosted_at => "why//"}
+        assert_equal "/why", req.hosted_at_option
+      end
+
+      should "know it's resource" do
+        assert_equal '/something', less_request("GET", "/stylesheets/something.css").path_info_resource
+        assert_equal '/something.awesome', less_request("GET", "/stylesheets/something.awesome.css").path_info_resource
+        assert_equal '/nested/something', less_request("GET", "/stylesheets/nested/something.css").path_info_resource
+        assert_equal '/something/really/awesome', less_request("GET", "/stylesheets/something/really/awesome.css").path_info_resource
+        assert_equal '/something', less_request("GET", "/something.css").path_info_resource
+        assert_equal '/something', less_request("GET", "///something.css").path_info_resource
+        assert_equal '/nested/something', less_request("GET", "/nested/something.css").path_info_resource
+        assert_equal '/nested/something', less_request("GET", "/nested///something.css").path_info_resource
+      end
+    end
+
+    context "#source " do
+      should "match :compress settings with Rack::Less:Config" do
+        req = less_request("GET", "/stylesheets/normal.css")
+        assert_equal Rack::Less.config.compress?, req.source.compress?
+      end
+
+      should "set it's cache value to nil when Rack::Less not configured to cache" do
+        Rack::Less.config = Rack::Less::Config.new
+        req = less_request("GET", "/stylesheets/normal.css")
+
+        assert_equal false, req.source.cache?
+        assert_equal nil, req.source.cache
+      end
+
+      should "set it's cache to the appropriate path when Rack::Less configured to cache" do
+        Rack::Less.config = Rack::Less::Config.new :cache => true
+        req = less_request("GET", "/stylesheets/normal.css")
+        cache_path = File.join(req.options(:root), req.options(:public), req.hosted_at_option)
+
+        assert_equal true, req.source.cache?
+        assert_equal cache_path, req.source.cache
+      end
+    end
+
+    should_not_be_a_valid_rack_less_request({
+      :method      => "POST",
+      :resource    => "/foo.html",
+      :description => "a non-css resource"
+    })
+
+    should_not_be_a_valid_rack_less_request({
+      :method      => "POST",
+      :resource    => "/foo.css",
+      :description => "a css resource"
+    })
+
+    should_not_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/foo.css",
+      :description => "a css resource hosted somewhere other than where Rack::Less expects them"
+    })
+
+    should_not_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/stylesheets/foo.css",
+      :description => "a css resource hosted where Rack::Less expects them but does not match any source"
+    })
+
+    should_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/stylesheets/normal.css",
+      :description => "a css resource hosted where Rack::Less expects them that matches source"
+    })
+
+    should_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/stylesheets/some-styles.css",
+      :description => "a proper css resource with a '-' in the name"
+    })
+
+    should_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/stylesheets/some_styles.css",
+      :description => "a proper css resource with a '_' in the name"
+    })
+
+    should_be_a_valid_rack_less_request({
+      :method      => "GET",
+      :resource    => "/stylesheets/styles1.css",
+      :description => "a proper css resource with a number in the name"
+    })
+  end
+
+end

data/test/response_test.rb

@@ -0,0 +1,41 @@
+require "test/helper"
+require 'rack/less/response'
+
+class RequestTest < Test::Unit::TestCase
+
+  context 'Rack::Less::Response' do
+    setup do
+      @defaults = env_defaults
+      @css = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'css_compiled.css'))
+      @response = less_response(@css)
+    end
+
+    should "have some attributes" do
+      [ :options,
+        :status,
+        :headers,
+        :body,
+        :content_length,
+        :content_type,
+        :to_rack
+      ].each do |a|
+        assert_respond_to @response, a, "request does not respond to #{a.inspect}"
+      end
+    end
+
+    should "set it's status to '#{Rack::Utils::HTTP_STATUS_CODES[200]}'" do
+      assert_equal 200, @response.status
+    end
+
+    should "set it's Content-Type to '#{Rack::Less::MIME_TYPE}'" do
+      assert_equal Rack::Less::MIME_TYPE, @response.content_type, 'the content_type accessor is incorrect'
+      assert_equal Rack::Less::MIME_TYPE, @response.headers['Content-Type'], 'the Content-Type header is incorrect'
+    end
+
+    should "set it's Content-Length appropriately" do
+      assert_equal Rack::Less::Response.content_length(@css), @response.content_length, 'the content_length accessor is incorrect'
+      assert_equal Rack::Less::Response.content_length(@css), @response.headers['Content-Length'].to_i
+    end
+  end
+
+end

data/test/sinatra_test.rb

@@ -0,0 +1,54 @@
+require "test/helper"
+require "test/app_helper"
+require 'test/fixtures/sinatra/app'
+
+class SinatraTest < Test::Unit::TestCase
+
+  def app
+    @app ||= SinatraApp
+  end
+  def default_value(name)
+    Rack::Less::Base.defaults["#{Rack::Less::Options::RACK_ENV_NS}.#{name}"]
+  end
+
+  context "A Sinatra app using Rack::Less" do
+
+    context "requesting valid LESS" do
+      setup do
+        app.use Rack::Less,
+          :root => file_path('test','fixtures','sinatra')
+
+        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'normal_compiled.css'))
+        @response = visit "/stylesheets/normal.css"
+      end
+
+      should_respond_with_compiled_css
+    end
+
+    context "requesting a nested valid LESS" do
+      setup do
+        app.use Rack::Less,
+          :root => file_path('test','fixtures','sinatra')
+
+        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'file_compiled.css'))
+        @response = visit "/stylesheets/nested/file.css"
+      end
+
+      should_respond_with_compiled_css
+    end
+
+    context "requesting a really nested valid LESS" do
+      setup do
+        app.use Rack::Less,
+          :root => file_path('test','fixtures','sinatra')
+
+        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'really', 'really_compiled.css'))
+        @response = visit "/stylesheets/nested/really/really.css"
+      end
+
+      should_respond_with_compiled_css
+    end
+
+  end
+
+end

data/test/source_test.rb

@@ -0,0 +1,158 @@
+require "test/helper"
+require 'rack/less/source'
+
+class SourceTest < Test::Unit::TestCase
+  context 'Rack::Less::Source' do
+    setup do
+      @source_folder = file_path('test','fixtures','sinatra','app','stylesheets')
+      @cache = file_path('test','fixtures','sinatra','public','stylesheets')
+    end
+
+    should "require an existing :folder" do
+      assert_raise ArgumentError do
+         Rack::Less::Source.new('foo')
+      end
+      assert_raise ArgumentError do
+        Rack::Less::Source.new('foo', :folder => file_path('does','not','exist'))
+      end
+      assert_nothing_raised do
+        Rack::Less::Source.new('foo', :folder => @source_folder)
+      end
+    end
+
+    should "accept both .less and .css extensions, prefering .less over .css though" do
+      assert_equal [:less, :css], Rack::Less::Source::PREFERRED_EXTENSIONS
+    end
+
+    context "object" do
+      setup do
+        @basic = Rack::Less::Source.new('basic', :folder => @source_folder)
+        @nested = Rack::Less::Source.new('this/source/is/nested', :folder => @source_folder)
+        @ugly = Rack::Less::Source.new('//this/source/is/ugly', :folder => @source_folder)
+        @compressed = Rack::Less::Source.new('compressed', {
+          :folder => @source_folder,
+          :compress => true
+        })
+        @cached = Rack::Less::Source.new('cached', {
+          :folder => @source_folder,
+          :cache => @cache,
+          :compress => false
+        })
+      end
+
+      should "have accessors for path and cache values" do
+        assert_respond_to @basic, :css_resource
+        assert_equal 'basic', @basic.css_resource
+        assert_respond_to @basic, :cache
+        assert_equal 'this/source/is/nested', @nested.css_resource
+        assert_equal 'this/source/is/ugly', @ugly.css_resource
+      end
+
+      should "have an option for using compression" do
+        assert_equal false, @basic.compress?, 'the basic app should not compress'
+        assert_equal true, @compressed.compress?, 'the compressed app should compress'
+        assert_equal false, @cached.compress?, 'the cached app should not compress'
+      end
+
+      should "have an option for caching output to files" do
+        assert_equal false, @basic.cache?, 'the basic app should not cache'
+        assert_equal true, @cached.cache?, 'the cached app should cache'
+      end
+
+      should "have a source files list" do
+        assert_respond_to @basic, :files, 'engine does not respond to :files'
+        assert_kind_of Array, @basic.files, 'the engine files is not an Array'
+      end
+
+      should "have compiled css" do
+        assert_respond_to @basic, :to_css, 'engine does not respond to :to_css'
+        assert_respond_to @basic, :css, 'engine does not respond to :css'
+      end
+    end
+
+    context "with no corresponding source" do
+      setup do
+        @none = Rack::Less::Source.new('none', :folder => @source_folder)
+      end
+
+      should "have an empty file list" do
+        assert @none.files.empty?, 'engine file list is not empty'
+      end
+
+      should "generate no css" do
+        assert @none.to_css.empty?, 'engine generated css when it should not have'
+      end
+    end
+
+    should_compile_source('normal', "needing to be compiled")
+    should_compile_source('nested/file', "that is nested, needing to be compiled")
+    should_compile_source('css', "that is a CSS stylesheet")
+
+
+    context "with whitespace compression" do
+      setup do
+        @compiled = File.read(File.join(@source_folder, "normal_compiled.css"))
+        @compressed_normal = Rack::Less::Source.new('normal', {
+          :folder => @source_folder,
+          :compress => :whitespace
+        })
+      end
+
+      should "compress the compiled css" do
+        assert_equal @compiled.strip.delete("\n"), @compressed_normal.to_css, "the compiled css is compressed incorrectly"
+      end
+    end
+
+    context "with yui compression" do
+      setup do
+        @compiled = File.read(File.join(@source_folder, "normal_compiled.css"))
+        @compressed_normal = Rack::Less::Source.new('normal', {
+          :folder => @source_folder,
+          :compress => :yui
+        })
+      end
+
+      should "compress the compiled css" do
+        comp = YUI::CssCompressor.new(Rack::Less::Source::YUI_OPTS).compress(@compiled.strip)
+        assert_equal comp, @compressed_normal.to_css, "the compiled css is compressed incorrectly"
+      end
+    end
+
+    context "with caching" do
+      setup do
+        FileUtils.rm_rf(File.dirname(@cache)) if File.exists?(File.dirname(@cache))
+        @expected = Rack::Less::Source.new('normal', {
+          :folder => @source_folder,
+          :cache => @cache
+        }).to_css
+        @cached_file = File.join(@cache, "normal.css")
+      end
+      teardown do
+        FileUtils.rm_rf(File.dirname(@cache)) if File.exists?(File.dirname(@cache))
+      end
+
+      should "store the compiled css to a file in the cache" do
+        assert File.exists?(@cache), 'the cache folder does not exist'
+        assert File.exists?(@cached_file), 'the css was not cached to a file'
+        assert_equal @expected.strip, File.read(@cached_file).strip, "the compiled css is incorrect"
+      end
+    end
+
+    context "that is a combination of multiple files" do
+      setup do
+        @compiled = File.read(File.join(@source_folder, "all_compiled.css"))
+        @combinations_before = Rack::Less.config.combinations
+        Rack::Less.config.combinations = {'all' => ['all_one', 'all_two']}
+        @all = Rack::Less::Source.new('all', :folder => @source_folder)
+      end
+      teardown do
+        Rack::Less.config.combinations = @combinations_before
+      end
+
+      should "combine the compiled css" do
+        assert_equal @compiled.strip, @all.to_css.strip, "the compiled css is combined incorrectly"
+      end
+    end
+
+  end
+end