ktheory-juicer 1.0.0.ktheory1

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

@@ -0,0 +1,58 @@
+require "test_helper"
+
+class Dummy
+  include Juicer::Command::Util
+end
+
+class TestCommandUtil < Test::Unit::TestCase
+
+  CSS_FILES = %w{a.css a1.css b.css b1.css c1.css d1.css path_test.css path_test2.css}
+  JS_FILES = %w{a.js}
+  ALL_FILES = (CSS_FILES + JS_FILES).sort
+
+  def setup
+    @impl = Dummy.new
+    Juicer::Test::FileSetup.new.create
+    Dir.glob("test/data/*.min.css").each { |file| File.delete(file) }
+  end
+
+  def test_files_from_single_file
+    files = @impl.files("test/data/a.css")
+    assert files.is_a?(Array)
+    assert_equal "test/data/a.css", files.sort.join
+  end
+
+  def test_files_from_single_glob_pattern
+    files = @impl.files("test/data/*.css")
+    assert files.is_a?(Array)
+    assert_equal CSS_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
+  end
+
+  def test_files_from_mixed_arguments
+    files = @impl.files("test/data/*.css", "test/data/a.js")
+    assert files.is_a?(Array)
+    assert_equal ALL_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
+  end
+
+  def test_files_from_array
+    files = @impl.files(["test/data/*.css", "test/data/a.js"])
+    assert files.is_a?(Array)
+    assert_equal ALL_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
+  end
+
+  def test_relative_path_single_file
+    assert_equal "test/data/a.css", @impl.relative("test/data/a.css")
+  end
+
+  def test_relative_path_many_files
+    files = @impl.relative(Dir.glob("test/data/*.css"))
+    assert files.is_a?(Array)
+    assert_equal CSS_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
+  end
+
+  def test_relative_path_many_files_explicit_reference
+    files = @impl.relative(Dir.glob("test/data/*.css"), "lib")
+    assert files.is_a?(Array)
+    assert_equal CSS_FILES.collect { |f| "../test/data/#{f}" }.join, files.sort.join
+  end
+end

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/unit/juicer/css_cache_buster_test.rb

@@ -0,0 +1,71 @@
+require "test_helper"
+
+class TestCssCacheBuster < Test::Unit::TestCase
+  def setup
+    Juicer::Test::FileSetup.new.create
+    @buster = Juicer::CssCacheBuster.new
+  end
+
+  def teardown
+    Juicer::Test::FileSetup.new.delete
+    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.collect { |a| a.path }.sort.join.gsub(path("/"), "")
+  end
+
+  def test_image_references_should_be_updated
+    file = path("css/test.css")
+    buster = Juicer::CssCacheBuster.new
+    buster.save file
+
+    File.read(file).scan(/url\(([^\)]*)\)/m).each do |path|
+      assert_match(/[^\?]*\?jcb=\d+/, path.first)
+    end
+  end
+
+  def test_absolute_path_without_web_root_should_fail
+    file = path("css/test2.css")
+    buster = Juicer::CssCacheBuster.new
+
+    assert_raise FileNotFoundError do
+      buster.save file
+    end
+  end
+
+  def test_absolute_path_should_be_resolved_when_web_root_known
+    file = path("css/test.css")
+    buster = Juicer::CssCacheBuster.new :web_root => path("")
+
+    assert_nothing_raised do
+      buster.save file
+    end
+
+    File.read(file).scan(/url\(([^\)]*)\)/m).each do |path|
+      assert_match(/[^\?]*\?jcb=\d+/, path.first)
+    end
+  end
+
+  def test_urls_should_only_have_mtime_appended_once
+    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.save file, output
+
+    buster.urls(output).each { |url| assert url !~ /(jcb=\d+).*(jcb=\d+)/, url }
+  end
+
+  def test_type_hard_should_produce_hard_buster_urls
+    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.save file, output
+
+    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/unit/juicer/dependency_resolver/css_dependency_resolver_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+class TestCssDependencyResolver < Test::Unit::TestCase
+  def setup
+    @resolver = Juicer::CssDependencyResolver.new
+    Juicer::Test::FileSetup.new.create
+  end
+
+  def test_init
+    assert_equal [], @resolver.files
+  end
+
+  def test_resolve
+    b_file = path('b.css')
+    a_file = path('a.css')
+
+    files = @resolver.resolve(path('a.css')) do |file|
+      assert b_file == file || a_file == file
+      b_file != file
+    end
+
+    assert_equal [a_file], files
+
+    files = @resolver.resolve(path('a.css')) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    assert_equal [a_file, b_file], files.sort
+  end
+
+  def test_load_order
+    files = @resolver.resolve(path("a1.css")).collect { |file| file.split("/").pop }
+    assert_equal "d1.cssb1.cssc1.cssa1.css", files.join
+  end
+end

data/test/unit/juicer/dependency_resolver/javascript_dependency_resolver_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+class TestJavaScriptDependencyResolver < Test::Unit::TestCase
+
+  def setup
+    @resolver = Juicer::JavaScriptDependencyResolver.new
+    Juicer::Test::FileSetup.new.create
+  end
+
+  def test_init
+    assert_equal [], @resolver.files
+  end
+
+  def test_resolve
+    b_file = path('b.js')
+    a_file = path('a.js')
+
+    files = @resolver.resolve(a_file) do |file|
+      assert b_file == file || a_file == file, file
+      b_file != file
+    end
+
+    assert_equal [a_file], files
+
+    files = @resolver.resolve(a_file) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    assert_equal [a_file, b_file], files.sort
+
+    files = @resolver.resolve(b_file) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    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

@@ -0,0 +1,59 @@
+require "test_helper"
+
+class TestStringExtensions < Test::Unit::TestCase
+  context "camel case method" do
+    should "convert underscored string" do
+      assert_equal "CamelCase", "camel_case".camel_case
+    end
+
+    should "convert spaced string" do
+      assert_equal "Camel case", "camel case".camel_case
+    end
+
+    should "convert upper-case underscored string" do
+      assert_equal "CamelCase", "CAMEL_CASE".camel_case
+    end
+
+    should "convert 'camel cased' underscored string" do
+      assert_equal "CamelCase", "Camel_Case".camel_case
+    end
+  end
+
+  context "to_class method" do
+    should "return String class" do
+      assert_equal String, "String".to_class
+    end
+
+    should "return String class from Object" do
+      assert_equal String, "String".to_class(Object)
+    end
+
+    should "return nested class" do
+      assert_equal Juicer::DependencyResolver, "Juicer::DependencyResolver".to_class
+    end
+
+    should "return class from module" do
+      assert_equal Juicer::DependencyResolver, "DependencyResolver".to_class(Juicer)
+    end
+
+    should "return class from nested module" do
+      assert_equal Juicer::Install::YuiCompressorInstaller, "YuiCompressorInstaller".to_class(Juicer::Install)
+    end
+  end
+
+  context "classify method" do
+    should "return class from underscored string" do
+      assert_equal Juicer::DependencyResolver, "dependency_resolver".classify(Juicer)
+    end
+
+    should "return top level class from underscored string" do
+      assert_equal FileUtils, "file_utils".classify
+    end
+  end
+
+  context "underscore method" do
+    should "return underscored string from camel cased string" do
+      assert_equal "stylesheet_merger", "StylesheetMerger".underscore
+    end
+  end
+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, :web_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