jekyll-assets 0.7.7 → 0.7.8

data/spec/lib/jekyll/assets_plugin/environment_spec.rb

@@ -1,19 +1,21 @@
 require "spec_helper"
 
-module Jekyll::AssetsPlugin
-  describe Environment do
-    context "#asset_path of context" do
-      it "should properly handle query params" do
-        css = @site.assets["vapor.css"].to_s
-        css.should match(/fonts\/vapor-[a-f0-9]{32}\.eot\?#iefix/)
-        css.should match(/fonts\/vapor-[a-f0-9]{32}\.svg#iefix/)
-      end
+module Jekyll
+  module AssetsPlugin
+    describe Environment do
+      context "#asset_path of context" do
+        it "should properly handle query params" do
+          css = @site.assets["vapor.css"].to_s
+          css.should match(/fonts\/vapor-[a-f0-9]{32}\.eot\?#iefix/)
+          css.should match(/fonts\/vapor-[a-f0-9]{32}\.svg#iefix/)
+        end
 
-      it "should properly handle relative paths" do
-        css = @site.assets["lib/relative.css"].to_s
-        css.should =~ %r{/assets/fonts/vapor-[a-f0-9]{32}\.eot\?#iefix}
-        css.should =~ %r{/assets/fonts/vapor-[a-f0-9]{32}\.svg#iefix}
-        puts css
+        it "should properly handle relative paths" do
+          css = @site.assets["lib/relative.css"].to_s
+          css.should =~ %r{/assets/fonts/vapor-[a-f0-9]{32}\.eot\?#iefix}
+          css.should =~ %r{/assets/fonts/vapor-[a-f0-9]{32}\.svg#iefix}
+          puts css
+        end
       end
     end
   end

data/spec/lib/jekyll/assets_plugin/filters_spec.rb

@@ -1,105 +1,103 @@
 require "spec_helper"
 
-module Jekyll::AssetsPlugin
-  describe Filters do
-    let(:context) { { :registers => { :site => @site } } }
+describe Jekyll::AssetsPlugin::Filters do
+  let(:context) { { :registers => { :site => @site } } }
 
-    def render(content)
-      Liquid::Template.parse(content).render({}, context)
+  def render(content)
+    ::Liquid::Template.parse(content).render({}, context)
+  end
+
+  context "{{ '<file>' | image }}" do
+    def tag_re(name)
+      file = "/assets/#{name}-[a-f0-9]{32}\.png"
+      Regexp.new "^#{Jekyll::AssetsPlugin::Renderer::IMAGE % file}$"
     end
 
-    context "{{ '<file>' | image }}" do
-      def tag_re(name)
-        file = "/assets/#{name}-[a-f0-9]{32}\.png"
-        Regexp.new "^#{Renderer::IMAGE % file}$"
-      end
+    context "when <file> exists" do
+      subject { render("{{ 'noise.png' | image }}") }
+      it { should match tag_re("noise") }
+    end
 
-      context "when <file> exists" do
-        subject { render("{{ 'noise.png' | image }}") }
-        it { should match tag_re("noise") }
-      end
+    context "when <file> does not exists" do
+      subject { render("{{ 'not-found.png' | image }}") }
+      it { should match "Liquid error: Couldn't find file 'not-found.png'" }
+    end
+  end
 
-      context "when <file> does not exists" do
-        subject { render("{{ 'not-found.png' | image }}") }
-        it { should match "Liquid error: Couldn't find file 'not-found.png'" }
-      end
+  context "{{ '<file>' | stylesheet }}" do
+    def tag_re(name)
+      file = "/assets/#{name}-[a-f0-9]{32}\.css"
+      Regexp.new "^#{Jekyll::AssetsPlugin::Renderer::STYLESHEET % file}$"
     end
 
-    context "{{ '<file>' | stylesheet }}" do
-      def tag_re(name)
-        file = "/assets/#{name}-[a-f0-9]{32}\.css"
-        Regexp.new "^#{Renderer::STYLESHEET % file}$"
-      end
+    context "when <file> exists" do
+      subject { render("{{ 'app.css' | stylesheet }}") }
+      it { should match tag_re("app") }
+    end
 
-      context "when <file> exists" do
-        subject { render("{{ 'app.css' | stylesheet }}") }
-        it { should match tag_re("app") }
-      end
+    context "when <file> extension is omited" do
+      subject { render("{{ 'app' | stylesheet }}") }
+      it { should match tag_re("app") }
+    end
 
-      context "when <file> extension is omited" do
-        subject { render("{{ 'app' | stylesheet }}") }
-        it { should match tag_re("app") }
-      end
+    context "when <file> does not exists" do
+      subject { render("{{ 'not-found.css' | stylesheet }}") }
+      it { should match "Liquid error: Couldn't find file 'not-found.css'" }
+    end
+  end
 
-      context "when <file> does not exists" do
-        subject { render("{{ 'not-found.css' | stylesheet }}") }
-        it { should match "Liquid error: Couldn't find file 'not-found.css'" }
-      end
+  context "{{ '<file>' | javascript }}" do
+    def tag_re(name)
+      file = "/assets/#{name}-[a-f0-9]{32}\.js"
+      Regexp.new "^#{Jekyll::AssetsPlugin::Renderer::JAVASCRIPT % file}$"
     end
 
-    context "{{ '<file>' | javascript }}" do
-      def tag_re(name)
-        file = "/assets/#{name}-[a-f0-9]{32}\.js"
-        Regexp.new "^#{Renderer::JAVASCRIPT % file}$"
-      end
+    context "when <file> exists" do
+      subject { render("{{ 'app.js' | javascript }}") }
+      it { should match tag_re("app") }
+    end
 
-      context "when <file> exists" do
-        subject { render("{{ 'app.js' | javascript }}") }
-        it { should match tag_re("app") }
-      end
+    context "when <file> extension omited" do
+      subject { render("{{ 'app' | javascript }}") }
+      it { should match tag_re("app") }
+    end
 
-      context "when <file> extension omited" do
-        subject { render("{{ 'app' | javascript }}") }
-        it { should match tag_re("app") }
-      end
+    context "when <file> does not exists" do
+      subject { render("{{ 'not-found.js' | javascript }}") }
+      it { should match "Liquid error: Couldn't find file 'not-found.js'" }
+    end
+  end
 
-      context "when <file> does not exists" do
-        subject { render("{{ 'not-found.js' | javascript }}") }
-        it { should match "Liquid error: Couldn't find file 'not-found.js'" }
-      end
+  context "{{ '<file.ext>' | asset_path }}" do
+    context "when <file> exists" do
+      subject { render("{{ 'app.css' | asset_path }}") }
+      it { should match(%r{^/assets/app-[a-f0-9]{32}\.css$}) }
     end
 
-    context "{{ '<file.ext>' | asset_path }}" do
-      context "when <file> exists" do
-        subject { render("{{ 'app.css' | asset_path }}") }
-        it { should match(%r{^/assets/app-[a-f0-9]{32}\.css$}) }
-      end
+    context "when <file> does not exists" do
+      subject { render("{{ 'not-found.css' | asset_path }}") }
+      it { should match "Liquid error: Couldn't find file 'not-found.css'" }
+    end
 
-      context "when <file> does not exists" do
-        subject { render("{{ 'not-found.css' | asset_path }}") }
-        it { should match "Liquid error: Couldn't find file 'not-found.css'" }
+    context "with baseurl given as /foobar/" do
+      before do
+        context[:registers][:site].assets_config.baseurl = "/foobar/"
       end
 
-      context "with baseurl given as /foobar/" do
-        before do
-          context[:registers][:site].assets_config.baseurl = "/foobar/"
-        end
-
-        subject { render("{{ 'app.css' | asset_path }}") }
-        it { should match(%r{^/foobar/app-[a-f0-9]{32}\.css$}) }
-      end
+      subject { render("{{ 'app.css' | asset_path }}") }
+      it { should match(%r{^/foobar/app-[a-f0-9]{32}\.css$}) }
     end
+  end
 
-    context "{{ '<file.ext>' | asset }}" do
-      context "when <file> exists" do
-        subject { render("{{ 'app.css' | asset }}") }
-        it { should match(/body \{ background-image: url\(.+?\) \}/) }
-      end
+  context "{{ '<file.ext>' | asset }}" do
+    context "when <file> exists" do
+      subject { render("{{ 'app.css' | asset }}") }
+      it { should match(/body \{ background-image: url\(.+?\) \}/) }
+    end
 
-      context "when <file> does not exists" do
-        subject { render("{{ 'not-found.js' | asset }}") }
-        it { should match "Liquid error: Couldn't find file 'not-found.js'" }
-      end
+    context "when <file> does not exists" do
+      subject { render("{{ 'not-found.js' | asset }}") }
+      it { should match "Liquid error: Couldn't find file 'not-found.js'" }
     end
   end
 end

data/spec/lib/jekyll/assets_plugin/patches/site_patch_spec.rb

@@ -1,172 +1,168 @@
 require "spec_helper"
 
-module Jekyll::AssetsPlugin
-  module Patches
-    describe SitePatch do
-      let(:site) do
-        Jekyll::Site.new Jekyll.configuration({
-          "source"  => RSpecHelpers.fixtures_path.to_s,
-          "dirname" => "foobar",
-          "assets"  => {
-            "sources" => %w{ foobar _assets }
-          }
-        })
-      end
+describe Jekyll::AssetsPlugin::Patches::SitePatch do
+  let(:site) do
+    Jekyll::Site.new Jekyll.configuration({
+      "source"  => fixtures_path.to_s,
+      "dirname" => "foobar",
+      "assets"  => {
+        "sources" => %w[foobar _assets]
+      }
+    })
+  end
 
-      context "#assets" do
-        subject { site.assets }
-        it { should be_a_kind_of Sprockets::Environment }
+  context "#assets" do
+    subject { site.assets }
+    it { should be_a_kind_of ::Sprockets::Environment }
 
-        context "#cache_path" do
-          let(:source_path) { Pathname.new site.source }
-          subject           { site.assets.cache_path }
+    context "#cache_path" do
+      let(:source_path) { Pathname.new site.source }
+      subject           { site.assets.cache_path }
 
-          it { should eq source_path.join(".jekyll-assets-cache") }
-        end
+      it { should eq source_path.join(".jekyll-assets-cache") }
+    end
 
-        context "calling #asset_path within assets" do
-          context "when requested file not found" do
-            it "raises a NotFound error" do
-              expect { site.assets["should_fail.css"] }
-                .to raise_error Environment::AssetNotFound
-            end
-          end
-
-          context "when requested file found" do
-            it "should have proper asset path" do
-              expect(site.assets["app.css"].to_s)
-                .to match(%r{url\(/assets/noise-[a-f0-9]{32}\.png\)})
-            end
-          end
-
-          context "when passed a blank path" do
-            it "should be blank" do
-              expect(site.assets["should_be_blank.css"].to_s)
-                .to match(/url\(\)/)
-            end
-          end
+    context "calling #asset_path within assets" do
+      context "when requested file not found" do
+        it "raises a NotFound error" do
+          expect { site.assets["should_fail.css"] }
+            .to raise_error Jekyll::AssetsPlugin::Environment::AssetNotFound
         end
       end
 
-      context "#asset_path" do
-        subject { site.asset_path "app.css" }
-
-        context "with none cachebust" do
-          before { site.assets_config.cachebust = :none }
-          it { should match(%r{^/assets/app\.css$}) }
-        end
-
-        context "with soft cachebust" do
-          before { site.assets_config.cachebust = :soft }
-          it { should match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}$}) }
+      context "when requested file found" do
+        it "should have proper asset path" do
+          expect(site.assets["app.css"].to_s)
+            .to match(%r{url\(/assets/noise-[a-f0-9]{32}\.png\)})
         end
+      end
 
-        context "with hard cachebust" do
-          before { site.assets_config.cachebust = :hard }
-          it { should match(%r{^/assets/app-[a-f0-9]{32}\.css$}) }
+      context "when passed a blank path" do
+        it "should be blank" do
+          expect(site.assets["should_be_blank.css"].to_s)
+            .to match(/url\(\)/)
         end
+      end
+    end
+  end
 
-        context "with unknown cachebust" do
-          before { site.assets_config.cachebust = :wtf }
-          it "should raise error" do
-            expect { site.asset_path "app.css" }.to raise_error
-          end
-        end
+  context "#asset_path" do
+    subject { site.asset_path "app.css" }
 
-        context "with query part in requested filename" do
-          subject { site.asset_path "app.css?foo=bar" }
+    context "with none cachebust" do
+      before { site.assets_config.cachebust = :none }
+      it { should match(%r{^/assets/app\.css$}) }
+    end
 
-          context "and none cachebust" do
-            before { site.assets_config.cachebust = :none }
-            it { should match(%r{^/assets/app\.css\?foo=bar$}) }
-          end
+    context "with soft cachebust" do
+      before { site.assets_config.cachebust = :soft }
+      it { should match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}$}) }
+    end
 
-          context "and soft cachebust" do
-            before { site.assets_config.cachebust = :soft }
-            it { should match %r{^/assets/app\.css\?cb=[a-f0-9]{32}&foo=bar$} }
-          end
+    context "with hard cachebust" do
+      before { site.assets_config.cachebust = :hard }
+      it { should match(%r{^/assets/app-[a-f0-9]{32}\.css$}) }
+    end
 
-          context "and hard cachebust" do
-            before { site.assets_config.cachebust = :hard }
-            it { should match(%r{^/assets/app-[a-f0-9]{32}\.css\?foo=bar$}) }
-          end
-        end
+    context "with unknown cachebust" do
+      before { site.assets_config.cachebust = :wtf }
+      it "should raise error" do
+        expect { site.asset_path "app.css" }.to raise_error
+      end
+    end
 
-        context "with anchor part in requested filename" do
-          subject { site.asset_path "app.css#foobar" }
+    context "with query part in requested filename" do
+      subject { site.asset_path "app.css?foo=bar" }
 
-          context "and none cachebust" do
-            before { site.assets_config.cachebust = :none }
-            it { should match(%r{^/assets/app\.css#foobar$}) }
-          end
+      context "and none cachebust" do
+        before { site.assets_config.cachebust = :none }
+        it { should match(%r{^/assets/app\.css\?foo=bar$}) }
+      end
 
-          context "and soft cachebust" do
-            before { site.assets_config.cachebust = :soft }
-            it { should match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}#foobar$}) }
-          end
+      context "and soft cachebust" do
+        before { site.assets_config.cachebust = :soft }
+        it { should match %r{^/assets/app\.css\?cb=[a-f0-9]{32}&foo=bar$} }
+      end
 
-          context "and hard cachebust" do
-            before { site.assets_config.cachebust = :hard }
-            it { should match(%r{^/assets/app-[a-f0-9]{32}\.css#foobar$}) }
-          end
-        end
+      context "and hard cachebust" do
+        before { site.assets_config.cachebust = :hard }
+        it { should match(%r{^/assets/app-[a-f0-9]{32}\.css\?foo=bar$}) }
       end
+    end
 
-      context "#assets_config" do
-        subject { site.assets_config }
-        it { should be_an_instance_of Configuration }
+    context "with anchor part in requested filename" do
+      subject { site.asset_path "app.css#foobar" }
 
-        it "should been populated with `assets` section of config" do
-          site.assets_config.dirname.should_not eq "foobar"
-          site.assets_config.sources.should include "foobar"
-        end
+      context "and none cachebust" do
+        before { site.assets_config.cachebust = :none }
+        it { should match(%r{^/assets/app\.css#foobar$}) }
       end
 
-      it "should regenerate assets upon multiple #process" do
-        @site.assets_config.cachebust = :none
-        2.times { @site.process }
-        @dest.join("assets", "app.css").exist?.should be_true
+      context "and soft cachebust" do
+        before { site.assets_config.cachebust = :soft }
+        it { should match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}#foobar$}) }
       end
 
-      context "with cache" do
-        def site
-          Jekyll::Site.new(Jekyll.configuration({
-            "source"      => fixtures_path.to_s,
-            "assets"      => { "cache" => true, "cachebust" => :none },
-            "destination" => @dest.to_s
-          }))
-        end
+      context "and hard cachebust" do
+        before { site.assets_config.cachebust = :hard }
+        it { should match(%r{^/assets/app-[a-f0-9]{32}\.css#foobar$}) }
+      end
+    end
+  end
 
-        after do
-          site.assets.cache_path.rmtree if site.assets.cache_path.exist?
-        end
+  context "#assets_config" do
+    subject { site.assets_config }
+    it { should be_an_instance_of Jekyll::AssetsPlugin::Configuration }
 
-        it "should regenerate static assets upon multiple #process" do
-          2.times { site.process }
-          @dest.join("assets", "noise.png").exist?.should be_true
-        end
-      end
+    it "should been populated with `assets` section of config" do
+      site.assets_config.dirname.should_not eq "foobar"
+      site.assets_config.sources.should include "foobar"
+    end
+  end
 
-      context "#gzip" do
-        subject { site.assets_config }
+  it "should regenerate assets upon multiple #process" do
+    @site.assets_config.cachebust = :none
+    2.times { @site.process }
+    @dest.join("assets", "app.css").exist?.should be_true
+  end
 
-        it "should generate a static assets if gzip is enabled" do
-          @site.assets_config.gzip = true
-          @site.process
-          @dest.join("assets", "app.css.gz").exist?.should be_true
-        end
+  context "with cache" do
+    def site
+      Jekyll::Site.new(Jekyll.configuration({
+        "source"      => fixtures_path.to_s,
+        "assets"      => { "cache" => true, "cachebust" => :none },
+        "destination" => @dest.to_s
+      }))
+    end
 
-        it "should not generate a static assets if gzip is enabled" do
-          @site.assets_config.gzip = false
-          @site.process
-          @dest.join("assets", "app.css.gz").exist?.should be_false
-        end
+    after do
+      site.assets.cache_path.rmtree if site.assets.cache_path.exist?
+    end
 
-      end
+    it "should regenerate static assets upon multiple #process" do
+      2.times { site.process }
+      @dest.join("assets", "noise.png").exist?.should be_true
+    end
+  end
 
-      it "should be included into Jekyll::Site" do
-        Jekyll::Site.included_modules.should include SitePatch
-      end
+  context "#gzip" do
+    subject { site.assets_config }
+
+    it "should generate a static assets if gzip is enabled" do
+      @site.assets_config.gzip = true
+      @site.process
+      @dest.join("assets", "app.css.gz").exist?.should be_true
     end
+
+    it "should not generate a static assets if gzip is enabled" do
+      @site.assets_config.gzip = false
+      @site.process
+      @dest.join("assets", "app.css.gz").exist?.should be_false
+    end
+
+  end
+
+  it "should be included into Jekyll::Site" do
+    Jekyll::Site.included_modules.should include described_class
   end
 end