juicer 0.2.6 → 1.0.0

data/test/unit/juicer/command/verify_test.rb

@@ -0,0 +1,48 @@
+require "test_helper"
+
+class TestVerifyCommand < Test::Unit::TestCase
+  def setup
+    @io = StringIO.new
+    @command = Juicer::Command::Verify.new(Logger.new(@io))
+    @path = Dir.pwd
+    @juicer = Juicer.home
+  end
+
+  def teardown
+    Dir.chdir(@path)
+    Juicer.home = @juicer
+  end
+
+  context "executing command" do
+    should "fail with no files" do
+      assert_raise ArgumentError do
+        @command.execute []
+      end
+    end
+
+    should "fail if installer is not found" do
+      Juicer.home = path("somewhere")
+      Dir.chdir("lib")
+      command = Juicer::Command::Verify.new(Logger.new(@io))
+
+      assert_raise FileNotFoundError do
+        command.execute path("a.js")
+      end
+    end
+
+    should "verify several files" do
+      files = %w[file1.js file2.js file3.js]
+      ok = "OK!\njslint: No problems"
+
+      Juicer::Command::Verify.any_instance.expects(:files).with(files).returns(files)
+      Juicer::JsLint.any_instance.expects(:check).with(files[0]).returns(Juicer::JsLint::Report.new)
+      Juicer::JsLint.any_instance.expects(:check).with(files[1]).returns(Juicer::JsLint::Report.new(["Oops"]))
+      Juicer::JsLint.any_instance.expects(:check).with(files[2]).returns(Juicer::JsLint::Report.new)
+      
+      @command.execute(files)
+     
+      assert_match(/OK!/, @io.string)
+      assert_match(/Problems detected/, @io.string)
+    end
+  end
+end

data/test/{juicer/test_css_cache_buster.rb → unit/juicer/css_cache_buster_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), %w[.. test_helper])) unless defined?(Juicer)
+require "test_helper"
 
 class TestCssCacheBuster < Test::Unit::TestCase
   def setup
@@ -8,34 +8,13 @@ class TestCssCacheBuster < Test::Unit::TestCase
 
   def teardown
     Juicer::Test::FileSetup.new.delete
-  end
-
-  def test_resolve_full_url
-    assert_equal "http://localhost/images/1.png", @buster.resolve("http://localhost/images/1.png", "")
-  end
-
-  def test_resolve_relative_url
-    file = path("images/1.png")
-    assert_equal(file, @buster.resolve("../images/1.png", path("css/test.css")))
-  end
-
-  def test_resolve_absolute_url_without_web_root_should_fail
-    file = path("images/1.png")
-    assert_raise FileNotFoundError do
-      @buster.resolve("/images/1.png", path("css/test.css"))
-    end
-  end
-
-  def test_resolve_absolute_url_with_web_root
-    buster = Juicer::CssCacheBuster.new :web_root => path("")
-    file = path("images/1.png")
-    assert_equal(file, buster.resolve("/images/1.png", path("css/test.css")))
+    Juicer::Test::FileSetup.new.create
   end
 
   def test_find_urls
     urls = @buster.urls(path("css/test.css"))
     assert_equal 3, urls.length
-    assert_equal "../a1.css../images/1.png2.gif", urls.sort.join.gsub(path("/"), "")
+    assert_equal "../a1.css../images/1.png2.gif", urls.collect { |a| a.path }.sort.join.gsub(path("/"), "")
   end
 
   def test_image_references_should_be_updated
@@ -48,7 +27,7 @@ class TestCssCacheBuster < Test::Unit::TestCase
     end
   end
 
-  def test_absolute_path_without_web_root_should_fail
+  def test_absolute_path_without_document_root_should_fail
     file = path("css/test2.css")
     buster = Juicer::CssCacheBuster.new
 
@@ -57,9 +36,9 @@ class TestCssCacheBuster < Test::Unit::TestCase
     end
   end
 
-  def test_absolute_path_should_be_resolved_when_web_root_known
+  def test_absolute_path_should_be_resolved_when_document_root_known
     file = path("css/test.css")
-    buster = Juicer::CssCacheBuster.new :web_root => path("")
+    buster = Juicer::CssCacheBuster.new :document_root => path("")
 
     assert_nothing_raised do
       buster.save file
@@ -74,7 +53,7 @@ class TestCssCacheBuster < Test::Unit::TestCase
     File.open(path("a2.css"), "w") { |f| f.puts "" }
     file = path("path_test2.css")
     output = path("path_test3.css")
-    buster = Juicer::CssCacheBuster.new :web_root => path("")
+    buster = Juicer::CssCacheBuster.new :document_root => path("")
     buster.save file, output
 
     buster.urls(output).each { |url| assert url !~ /(jcb=\d+).*(jcb=\d+)/, url }
@@ -84,8 +63,9 @@ class TestCssCacheBuster < Test::Unit::TestCase
     File.open(path("a2.css"), "w") { |f| f.puts "" }
     file = path("path_test2.css")
     output = path("path_test3.css")
-    buster = Juicer::CssCacheBuster.new :web_root => path(""), :type => :hard
+    buster = Juicer::CssCacheBuster.new :document_root => path(""), :type => :hard
     buster.save file, output
-    buster.urls(output).each { |url| assert url =~ /-\d+\.[a-z]{3}/, url }
+
+    buster.urls(output).each { |asset| assert_match /-jcb\d+\.[a-z]{3}$/, asset.path }
   end
 end

data/test/unit/juicer/datafy_test.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require "test_helper"
+
+class TC_Datafy < Test::Unit::TestCase
+
+  def test_make_data_uri_text_plain
+    assert_equal(SHORT_TEXT_PLAIN_URI, Datafy::make_data_uri(SHORT_STRING, TEXT_PLAIN))
+    assert_equal(LONG_TEXT_PLAIN_URI, Datafy::make_data_uri(LONG_STRING, TEXT_PLAIN))
+  end
+
+  def test_make_data_uri_octet_stream
+    assert_equal(SHORT_APPLICATION_OCTET_STREAM_URI, Datafy::make_data_uri(SHORT_STRING, APPLICATION_OCTET_STREAM))
+    assert_equal(LONG_APPLICATION_OCTET_STREAM_URI, Datafy::make_data_uri(LONG_STRING, APPLICATION_OCTET_STREAM))
+  end
+
+  # mime types
+  TEXT_PLAIN = 'text/plain'
+  APPLICATION_OCTET_STREAM = 'application/octet-stream'
+
+  # string versions
+  SHORT_STRING = 'this is some text'
+  SHORT_BASE64 = 'dGhpcyBpcyBzb21lIHRleHQ='
+  SHORT_URLENCODED = 'this+is+some+text'
+
+  LONG_STRING = 'this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string.'
+  LONG_BASE64 = 'dGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4='
+  LONG_URLENCODED = 'this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.'
+
+  # data: uris
+  SHORT_APPLICATION_OCTET_STREAM_URI = "data:#{APPLICATION_OCTET_STREAM};base64,#{SHORT_BASE64}"
+  SHORT_TEXT_PLAIN_URI = "data:#{TEXT_PLAIN},#{SHORT_URLENCODED}"
+
+  LONG_APPLICATION_OCTET_STREAM_URI = "data:#{APPLICATION_OCTET_STREAM};base64,#{LONG_BASE64}"
+  LONG_TEXT_PLAIN_URI = "data:#{TEXT_PLAIN},#{LONG_URLENCODED}"
+
+
+end

data/test/{juicer/merger/test_css_dependency_resolver.rb → unit/juicer/dependency_resolver/css_dependency_resolver_test.rb}

@@ -1,8 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+require "test_helper"
 
 class TestCssDependencyResolver < Test::Unit::TestCase
   def setup
-    @resolver = Juicer::Merger::CssDependencyResolver.new
+    @resolver = Juicer::CssDependencyResolver.new
     Juicer::Test::FileSetup.new.create
   end
 

data/test/{juicer/merger/test_javascript_dependency_resolver.rb → unit/juicer/dependency_resolver/javascript_dependency_resolver_test.rb}

@@ -1,9 +1,9 @@
-require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+require "test_helper"
 
 class TestJavaScriptDependencyResolver < Test::Unit::TestCase
 
   def setup
-    @resolver = Juicer::Merger::JavaScriptDependencyResolver.new
+    @resolver = Juicer::JavaScriptDependencyResolver.new
     Juicer::Test::FileSetup.new.create
   end
 
@@ -36,4 +36,15 @@ class TestJavaScriptDependencyResolver < Test::Unit::TestCase
 
     assert_equal [a_file, b_file], files.sort
   end
+
+  def test_directory_resolve
+    my_app = path("my_app.js")
+    expected_files = %w(pkg/pkg.js
+    pkg/module/moda.js
+    pkg/module/modb.js
+    my_app.js).map{|file| path(file)}
+
+    actual_files = @resolver.resolve(my_app)
+    assert_equal expected_files, actual_files
+  end
 end

data/test/unit/juicer/ext/{#string_test.rb# → string_test.rb}

@@ -1,6 +1,5 @@
 require "test_helper"
 
-
 class TestStringExtensions < Test::Unit::TestCase
   context "camel case method" do
     should "convert underscored string" do
@@ -25,12 +24,6 @@ class TestStringExtensions < Test::Unit::TestCase
       assert_equal String, "String".to_class
     end
 
-    should "raise error when loading String class from array class" do
-      assert_raise RuntimeError do
-        "String".to_class(Array)
-      end
-    end
-
     should "return String class from Object" do
       assert_equal String, "String".to_class(Object)
     end

data/test/unit/juicer/ext/symbol_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class TestSymbolExtensions < Test::Unit::TestCase
+  context "camel case method" do
+    should "return camel cased string from underscored symbol" do
+      assert_equal "CamelCase", :camel_case.camel_case
+    end
+
+    should "return camel cased string from upper cased underscored symbol" do
+      assert_equal "CamelCase", :CAMEL_CASE.camel_case
+    end
+
+    should "return camel cased string from 'camel cased' underscored symbol" do
+      assert_equal "CamelCase", :Camel_Case.camel_case
+    end
+  end
+
+  context "classify method" do
+    should "return nested class" do
+      assert_equal Juicer::DependencyResolver, :dependency_resolver.classify(Juicer)
+    end
+
+    should "return top level class from underscored symbol" do
+      assert_equal FileUtils, :file_utils.classify
+    end
+  end
+end

data/test/unit/juicer/image_embed_test.rb

@@ -0,0 +1,271 @@
+require "test_helper"
+require 'fakefs/safe'
+
+class TestImageEmbed < Test::Unit::TestCase
+  include FakeFS
+
+  context "ImageEmbed instance using data_uri," do
+    setup do
+      FakeFS.activate!
+      FileSystem.clear
+      FileUtils.mkdir_p("/stylesheets")
+      FileUtils.mkdir_p("/images")
+
+      @supported_assets = [
+                           { :path => '/images/test.png', :content => 'hello png!' },
+                           { :path => '/images/test.gif', :content => 'hello gif!' },
+                           {  :path => '/images/test.jpg', :content => 'hello jpg!' },
+                           { :path => '/images/test.jpeg', :content => 'hello jpeg!' },
+                          ]
+      create_files(@supported_assets)
+
+      @unsupported_assets = [
+                             { :path => '/images/test.bmp', :content => 'hello bmp!' },
+                             { :path => '/images/test.js', :content => 'hello js!' },
+                             { :path => '/images/test.txt', :content => 'hello txt!' },
+                             { :path => '/images/test.swf', :content => 'hello swf!' },
+                             { :path => '/images/test.swf', :content => 'hello swf!' },
+                             { :path => '/images/test.ico', :content => 'hello ico!' },
+                             { :path => '/images/test.tif', :content => 'hello tif!' },
+                             { :path => '/images/test.tiff', :content => 'hello tiff!' },
+                             { :path => '/images/test.applet', :content => 'hello applet!' },
+                             { :path => '/images/test.jar', :content => 'hello jar!' }
+                            ]
+      create_files(@unsupported_assets)
+      @embedder = Juicer::ImageEmbed.new(:type => :data_uri, :document_root => '')
+    end
+
+    teardown do
+      FakeFS.deactivate!
+    end
+
+    context "save method" do
+      context "with files exceeding SIZE_LIMIT" do
+        setup do
+          @large_files = [{ :path => '/images/large-file.png',
+                            :content => "hello png!" + (" " * @embedder.size_limit) }]
+          create_files(@large_files)
+
+          @stylesheets = [{
+                            :path => '/stylesheets/test_embed_duplicates.css',
+                            :content => "body: { background: url(#{@large_files.first[:path]}?embed=true); }"
+                          }]
+          create_files(@stylesheets)
+        end
+
+        should "not embed images that exceeds size limit" do
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save @stylesheets.first[:path]
+          end
+
+          css_contents = File.read(@stylesheets.first[:path])
+
+          # encode the image
+          image_contents = File.read( @large_files.first[:path] )
+          data_uri = Datafy::make_data_uri(image_contents, 'image/png')
+
+          # make sure the encoded data_uri is not present in the stylesheet
+          assert !css_contents.include?(data_uri)
+
+          # make sure the original url still exist in the stylesheet
+          assert_match Regexp.new(@large_files.first[:path]), css_contents
+        end
+      end
+
+      context "with duplicated urls" do
+        setup do
+          @stylesheets = [{
+                            :path => '/stylesheets/test_embed_duplicates.css',
+                            :content => <<-EOF
+         body: { background: url(#{@supported_assets.first[:path]}?embed=true); }
+         div.section: { background: url(#{@supported_assets.first[:path]}?embed=true); }
+         div.article: { background: url(#{@supported_assets.last[:path]}?embed=true); }
+                            EOF
+                          }]
+          create_files(@stylesheets)
+        end
+
+        should_eventually "provide warnings for duplicate urls"
+
+        should "not embed duplicates" do
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save @stylesheets.first[:path]
+          end
+
+          css_contents = File.read(@stylesheets.first[:path])
+
+          # encode the image
+          image_contents = File.read(@supported_assets.first[:path])
+          data_uri = Datafy::make_data_uri(image_contents, 'image/png')
+
+          # make sure the encoded data_uri is not present in the stylesheet
+          assert !css_contents.include?(data_uri)
+        end
+
+        should "embed distinct urls" do
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save @stylesheets.first[:path]
+          end
+
+          css_contents = File.read(@stylesheets.first[:path])
+
+          # encode the image
+          image_contents = File.read(@supported_assets.last[:path])
+          data_uri = Datafy::make_data_uri(image_contents, 'image/jpeg')
+
+          # make sure the encoded data_uri is not present in the stylesheet
+          assert css_contents.include?(data_uri)
+
+          assert_no_match Regexp.new(@supported_assets.last[:path]), css_contents
+        end
+
+      end
+
+      should "embed images into css file" do
+        @stylesheets = [
+                        {
+                          :path => '/stylesheets/test_embed_true.css',
+                          :content => "body: { background: url(#{@supported_assets.first[:path]}?embed=true); }"
+                        }
+                       ]
+        create_files( @stylesheets )
+
+        @stylesheets.each do |stylesheet|
+          old_contents = File.read( stylesheet[:path] )
+
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save stylesheet[:path]
+          end
+
+          css_contents = File.read( stylesheet[:path] )
+
+          # make sure the original url does not exist anymore
+          assert_no_match( Regexp.new( @supported_assets.first[:path] ), css_contents )
+
+          # make sure the url has been converted into a data uri
+          image_contents = File.read( @supported_assets.first[:path] )
+
+          # # create the data uri from the image contents
+          data_uri = Datafy::make_data_uri( image_contents, 'image/png' )
+
+          # let's see if the data uri exists in the file
+          assert css_contents.include?( data_uri )
+        end
+      end
+
+      should "not embed unflagged images" do
+        @stylesheets = [
+                        {
+                          :path => '/stylesheets/test_embed_true.css',
+                          :content => "
+        body: { background: url(#{@supported_assets.first[:path]}); }
+        h1: { background: url(#{@supported_assets.last[:path]}?embed=false); }
+      "
+                        }
+                       ]
+        create_files( @stylesheets )
+
+        @stylesheets.each do |stylesheet|
+          old_contents = File.read( stylesheet[:path] )
+
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save stylesheet[:path]
+          end
+
+          css_contents = File.read( stylesheet[:path] )
+
+          # make sure the original url still exists
+          assert_match( Regexp.new( @supported_assets.first[:path] ), css_contents )
+          assert_match( Regexp.new( @supported_assets.last[:path] ), css_contents )
+        end
+      end
+
+
+      should "not embed unsupported images" do
+        @stylesheets = [
+                        {
+                          :path => '/stylesheets/test_embed_true.css',
+                          :content => "
+        body: { background: url(#{@unsupported_assets.first[:path]}?embed=true); }
+        h1: { background: url(#{@unsupported_assets.last[:path]}?embed=true); }
+      "
+                        }
+                       ]
+        create_files( @stylesheets )
+
+        @stylesheets.each do |stylesheet|
+          old_contents = File.read( stylesheet[:path] )
+
+          # make sure there are no errors
+          assert_nothing_raised do
+            @embedder.save stylesheet[:path]
+          end
+
+          css_contents = File.read( stylesheet[:path] )
+
+          # make sure the original url still exists
+          assert_match( Regexp.new( @unsupported_assets.first[:path] ), css_contents )
+          assert_match( Regexp.new( @unsupported_assets.last[:path] ), css_contents )
+        end
+      end
+
+
+    end # context
+
+    context "embed method" do
+      should "not modify regular paths" do
+        path = @supported_assets.first[:path]
+        assert_equal( path, @embedder.embed_data_uri( path ) )
+      end
+
+      should "not modify paths flagged as not embeddable" do
+        path = "#{@supported_assets.first[:path]}?embed=false"
+        assert_equal( path, @embedder.embed_data_uri( path ) )
+      end
+
+      should "embed image when path flagged as embeddable" do
+        path = "#{@supported_assets.first[:path]}?embed=true"
+        assert_not_equal( path, @embedder.embed_data_uri( path ) )
+      end
+
+      should "encode all supported asset types" do
+        @supported_assets.each do |asset|
+          path = "#{asset[:path]}?embed=true"
+          assert_not_equal( path, @embedder.embed_data_uri( path ) )
+        end
+      end
+
+      should "not encod unsupported asset types" do
+        @unsupported_assets.each do |asset|
+          path = "#{asset[:path]}?embed=true"
+          assert_equal( path, @embedder.embed_data_uri( path ) )
+        end
+      end
+
+      should "set correct mimetype for supported extensions" do
+        @supported_assets.each do |asset|
+          path = "#{asset[:path]}?embed=true"
+          extension = /(png|gif|jpg|jpeg)/.match( asset[:path] )
+          assert_match(/image\/#{extension}/, @embedder.embed_data_uri( path ) )
+        end
+      end
+    end  # context
+  end
+
+  private
+  # expects the containing path to have been created already
+  def create_files( files = [] )
+    files.each do |file|
+      path = file[:path]
+      File.open(path, 'w') do |f|
+        f.write file[:content]
+        assert File.exists?( file[:path] )
+      end
+    end
+  end
+end