jekyll-assets 1.0.0 → 2.0.0.pre.beta1

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

@@ -1,112 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Jekyll::Assets::Filters do
-  let(:context) { { :registers => { :site => @site } } }
-
-  def render(content)
-    ::Liquid::Template.parse(content).render({}, context)
-  end
-
-  def not_found_error(file)
-    "Liquid error: Couldn't find file '#{file}"
-  end
-
-  def render_tag(template, path, attrs = "")
-    template = Jekyll::Assets::Renderer.const_get template
-    format template, :path => path, :attrs => attrs
-  end
-
-  context "{{ '<file>' | image }}" do
-    def tag_re(name)
-      file = "/assets/#{name}-[a-f0-9]{32}\.png"
-      Regexp.new "^#{render_tag :IMAGE, file}$"
-    end
-
-    context "when <file> exists" do
-      subject { render("{{ 'noise.png' | image }}") }
-      it { is_expected.to match tag_re("noise") }
-    end
-
-    context "when <file> does not exists" do
-      subject { render("{{ 'not-found.png' | image }}") }
-      it { is_expected.to match not_found_error "not-found.png" }
-    end
-  end
-
-  context "{{ '<file>' | stylesheet }}" do
-    def tag_re(name)
-      file = "/assets/#{name}-[a-f0-9]{32}\.css"
-      Regexp.new "^#{render_tag :STYLESHEET, file}$"
-    end
-
-    context "when <file> exists" do
-      subject { render("{{ 'app.css' | stylesheet }}") }
-      it { is_expected.to match tag_re("app") }
-    end
-
-    context "when <file> extension is omited" do
-      subject { render("{{ 'app' | stylesheet }}") }
-      it { is_expected.to match tag_re("app") }
-    end
-
-    context "when <file> does not exists" do
-      subject { render("{{ 'not-found.css' | stylesheet }}") }
-      it { is_expected.to match not_found_error "not-found.css" }
-    end
-  end
-
-  context "{{ '<file>' | javascript }}" do
-    def tag_re(name)
-      file = "/assets/#{name}-[a-f0-9]{32}\.js"
-      Regexp.new "^#{render_tag :JAVASCRIPT, file}$"
-    end
-
-    context "when <file> exists" do
-      subject { render("{{ 'app.js' | javascript }}") }
-      it { is_expected.to match tag_re("app") }
-    end
-
-    context "when <file> extension omited" do
-      subject { render("{{ 'app' | javascript }}") }
-      it { is_expected.to match tag_re("app") }
-    end
-
-    context "when <file> does not exists" do
-      subject { render("{{ 'not-found.js' | javascript }}") }
-      it { is_expected.to match not_found_error "not-found.js" }
-    end
-  end
-
-  context "{{ '<file.ext>' | asset_path }}" do
-    context "when <file> exists" do
-      subject { render("{{ 'app.css' | asset_path }}") }
-      it { is_expected.to 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 { is_expected.to match not_found_error "not-found.css" }
-    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 { is_expected.to 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 { is_expected.to match(/body \{ background-image: url\(.+?\) \}/) }
-    end
-
-    context "when <file> does not exists" do
-      subject { render("{{ 'not-found.js' | asset }}") }
-      it { is_expected.to match not_found_error "not-found.js" }
-    end
-  end
-end

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

@@ -1,176 +0,0 @@
-require "spec_helper"
-
-# rubocop:disable LineLength
-
-RSpec.describe Jekyll::Assets::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 { is_expected.to be_a_kind_of ::Sprockets::Environment }
-
-    context "#cache_path" do
-      let(:source_path) { Pathname.new site.source }
-      subject           { site.assets.cache_path }
-
-      it { is_expected.to 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 Jekyll::Assets::Environment::AssetNotFound
-        end
-      end
-
-      context "when requested file found" do
-        it "has 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 "is blank" do
-          expect(site.assets["should_be_blank.css"].to_s)
-            .to match(/url\(\)/)
-        end
-      end
-    end
-  end
-
-  context "#asset_path" do
-    subject { site.asset_path "app.css" }
-
-    context "with none cachebust" do
-      before { site.assets_config.cachebust = :none }
-      it { is_expected.to match(%r{^/assets/app\.css$}) }
-    end
-
-    context "with soft cachebust" do
-      before { site.assets_config.cachebust = :soft }
-      it { is_expected.to match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}$}) }
-    end
-
-    context "with hard cachebust" do
-      before { site.assets_config.cachebust = :hard }
-      it { is_expected.to match(%r{^/assets/app-[a-f0-9]{32}\.css$}) }
-    end
-
-    context "with unknown cachebust" do
-      before { site.assets_config.cachebust = :wtf }
-      it "raises error" do
-        expect { site.asset_path "app.css" }.to raise_error
-      end
-    end
-
-    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 { is_expected.to match(%r{^/assets/app\.css\?foo=bar$}) }
-      end
-
-      context "and soft cachebust" do
-        before { site.assets_config.cachebust = :soft }
-        it { is_expected.to 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 { is_expected.to match(%r{^/assets/app-[a-f0-9]{32}\.css\?foo=bar$}) }
-      end
-    end
-
-    context "with anchor part in requested filename" do
-      subject { site.asset_path "app.css#foobar" }
-
-      context "and none cachebust" do
-        before { site.assets_config.cachebust = :none }
-        it { is_expected.to match(%r{^/assets/app\.css#foobar$}) }
-      end
-
-      context "and soft cachebust" do
-        before { site.assets_config.cachebust = :soft }
-        it { is_expected.to match(%r{^/assets/app\.css\?cb=[a-f0-9]{32}#foobar$}) }
-      end
-
-      context "and hard cachebust" do
-        before { site.assets_config.cachebust = :hard }
-        it { is_expected.to match(%r{^/assets/app-[a-f0-9]{32}\.css#foobar$}) }
-      end
-    end
-  end
-
-  context "#assets_config" do
-    subject { site.assets_config }
-    it { is_expected.to be_an_instance_of Jekyll::Assets::Configuration }
-
-    it "populated with `assets` section of config" do
-      expect(site.assets_config.dirname).not_to eq "foobar"
-      expect(site.assets_config.sources).to include "foobar"
-    end
-  end
-
-  it "regenerates assets upon multiple #process" do
-    @site.assets_config.cachebust = :none
-    2.times { @site.process }
-    expect(@dest.join "assets", "app.css").to exist
-  end
-
-  it "does not ignores files with duplicate contents" do
-    @site.assets_config.cachebust = :none
-    @site.process
-
-    expect(@dest.join "assets", "noise.png").to exist
-    expect(@dest.join "assets", "noize.png").to exist
-  end
-
-  context "with cache" do
-    before do
-      @site.assets_config.cache = true
-      @site.assets_config.cachebust = :none
-    end
-
-    after do
-      @site.assets.cache_path.rmtree if site.assets.cache_path.exist?
-    end
-
-    it "regenerates static assets upon multiple #process" do
-      2.times { @site.process }
-      expect(@dest.join "assets", "noise.png").to exist
-    end
-  end
-
-  context "#gzip" do
-    subject { site.assets_config }
-
-    it "generates a static assets if gzip is enabled" do
-      @site.assets_config.gzip = true
-      @site.process
-
-      expect(@dest.join "assets", "app.css.gz").to exist
-    end
-
-    it "does not generate a static assets if gzip is enabled" do
-      @site.assets_config.gzip = false
-      @site.process
-
-      expect(@dest.join "assets", "app.css.gz").to_not exist
-    end
-  end
-
-  it "is included into Jekyll::Site" do
-    expect(Jekyll::Site.included_modules).to include described_class
-  end
-end

data/spec/lib/jekyll/assets/renderer_spec.rb

@@ -1,286 +0,0 @@
-# stdlib
-require "ostruct"
-
-require "spec_helper"
-
-RSpec.describe Jekyll::Assets::Renderer do
-  let(:assets_config) { Hash.new }
-
-  let(:site) do
-    Jekyll::Site.new Jekyll.configuration({
-      "source"      => fixtures_path.to_s,
-      "destination" => @dest.to_s,
-      "assets"      => assets_config
-    })
-  end
-
-  let(:params)   { "app" }
-  let(:context)  { OpenStruct.new(:registers => { :site => site }) }
-  let(:renderer) { described_class.new context, params }
-
-  describe "#path" do
-    subject { renderer.path }
-
-    context "with logical path only" do
-      context "when logical path contains no spaces" do
-        let(:params) { "app" }
-        it { is_expected.to eq "app" }
-      end
-
-      context "when logical path contains spaces and double quoted" do
-        let(:params) { '"my app"' }
-        it { is_expected.to eq "my app" }
-      end
-
-      context "when logical path contains spaces and single quoted" do
-        let(:params) { "'my app'" }
-        it { is_expected.to eq "my app" }
-      end
-    end
-
-    context "with logical path and params" do
-      context "when logical path contains no spaces" do
-        let(:params) { 'app foo bar="baz"' }
-        it { is_expected.to eq "app" }
-      end
-
-      context "when logical path contains spaces and double quoted" do
-        let(:params) { '"my app" foo bar="baz"' }
-        it { is_expected.to eq "my app" }
-      end
-
-      context "when logical path contains spaces and single quoted" do
-        let(:params) { %q('my app' foo bar="baz") }
-        it { is_expected.to eq "my app" }
-      end
-    end
-  end
-
-  describe "#attrs" do
-    subject { renderer.attrs }
-
-    context "with logical path only" do
-      context "when logical path contains no spaces" do
-        let(:params) { "app" }
-        it { is_expected.to eq "" }
-      end
-
-      context "when logical path contains spaces and double quoted" do
-        let(:params) { '"my app"' }
-        it { is_expected.to eq "" }
-      end
-
-      context "when logical path contains spaces and single quoted" do
-        let(:params) { "'my app'" }
-        it { is_expected.to eq "" }
-      end
-    end
-
-    context "with logical path and params" do
-      context "when logical path contains no spaces" do
-        let(:params) { 'app foo bar="baz"' }
-        it { is_expected.to eq ' foo bar="baz"' }
-      end
-
-      context "when logical path contains spaces and double quoted" do
-        let(:params) { '"my app" foo bar="baz"' }
-        it { is_expected.to eq ' foo bar="baz"' }
-      end
-
-      context "when logical path contains spaces and single quoted" do
-        let(:params) { %q('my app' foo bar="baz") }
-        it { is_expected.to eq ' foo bar="baz"' }
-      end
-    end
-  end
-
-  describe "#options" do
-    subject { renderer.options }
-
-    context "with no options given" do
-      it { is_expected.to be_an Array }
-      it { is_expected.to be_empty }
-    end
-
-    context "with options given" do
-      let(:params) { "app [foo,bar]" }
-      it { is_expected.to eq %w(foo bar) }
-    end
-  end
-
-  describe "#render_javascript" do
-    subject { renderer.render_javascript }
-
-    context "when debug mode enabled" do
-      let(:assets_config) { Hash[:debug, true] }
-      it { is_expected.to match(/^(\s*<script src="[^"]+"><\/script>\s*){3}$/) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/app.js" }
-        it { is_expected.to match(/^<script src="#{params}"><\/script>$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "app data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-
-    context "when debug mode disabled" do
-      let(:assets_config) { Hash[:debug, false] }
-      it { is_expected.to match(/^(\s*<script src="[^"]+"><\/script>\s*){1}$/) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/app.js" }
-        it { is_expected.to match(/^<script src="#{params}"><\/script>$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "app data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-  end
-
-  describe "#render_stylesheet" do
-    subject { renderer.render_stylesheet }
-    let(:tag_prefix) { '<link rel="stylesheet"' }
-
-    context "when debug mode enabled" do
-      let(:assets_config) { Hash[:debug, true] }
-      it { is_expected.to match(/^(\s*#{tag_prefix} [^>]+>\s*){3}$/) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { is_expected.to match(/^#{tag_prefix} href="#{params}">$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "app data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-
-    context "when debug mode disabled" do
-      let(:assets_config) { Hash[:debug, false] }
-      it { is_expected.to match(/^(\s*#{tag_prefix} [^>]+>\s*){1}$/) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { is_expected.to match(/^#{tag_prefix} href="#{params}">$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "app data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-  end
-
-  describe "#render_image" do
-    subject { renderer.render_image }
-
-    let(:params) { "noise.png" }
-
-    context "when debug mode enabled" do
-      let(:assets_config) { Hash[:debug, true] }
-      it { is_expected.to match(%r{^<img src="/assets/noise-[^.]+\.png">$}) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { is_expected.to match(/^<img src="#{params}">$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "noise.png data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-
-    context "when debug mode disabled" do
-      let(:assets_config) { Hash[:debug, false] }
-      it { is_expected.to match(%r{^<img src="/assets/noise-[^.]+\.png">$}) }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { is_expected.to match(/^<img src="#{params}">$/) }
-      end
-
-      context "and path contains attributes" do
-        let(:params) { "noise.png data-test=true" }
-        it { is_expected.to include "data-test=true" }
-      end
-    end
-
-    context "with [autosize] helper option" do
-      let(:params)    { "noise.png [autosize]" }
-      let(:attr_src)  { 'src="/assets/noise-[^.]+\.png"' }
-      let(:attr_size) { 'width="100" height="100"' }
-
-      it { is_expected.to match(/^<img #{attr_src} #{attr_size}>$/) }
-    end
-
-    context "with [no-autosize] helper option" do
-      let(:params)    { "noise.png [no-autosize]" }
-      let(:attr_src)  { 'src="/assets/noise-[^.]+\.png"' }
-
-      it { is_expected.to match(/^<img #{attr_src}>$/) }
-    end
-
-    context "with autosize enabled in config" do
-      let(:assets_config) { Hash[:autosize, true] }
-      let(:attr_src)      { 'src="/assets/noise-[^.]+\.png"' }
-      let(:attr_size)     { 'width="100" height="100"' }
-
-      it { is_expected.to match(/^<img #{attr_src} #{attr_size}>$/) }
-
-      context "and [autosize] helper option given" do
-        let(:params) { "noise.png [autosize]" }
-        it { is_expected.to match(/^<img #{attr_src} #{attr_size}>$/) }
-      end
-
-      context "and [no-autosize] helper option given" do
-        let(:params) { "noise.png [no-autosize]" }
-        it { is_expected.to match(/^<img #{attr_src}>$/) }
-      end
-    end
-
-    context "with [resize:*] helper option" do
-      let(:params)    { "noise.png [resize:10x10]" }
-      let(:attr_src)  { 'src="/assets/noise-10x10-[^.]+\.png"' }
-      it { is_expected.to match(/^<img #{attr_src}>$/) }
-    end
-
-    context "with [resize:*] and [autosize] helpers" do
-      let(:params)    { "noise.png [resize:10x10, autosize]" }
-      let(:attr_src)  { 'src="/assets/noise-10x10-[^.]+\.png"' }
-      let(:attr_size) { 'width="10" height="10"' }
-      it { is_expected.to match(/^<img #{attr_src} #{attr_size}>$/) }
-    end
-  end
-
-  describe "#render_asset" do
-    subject { renderer.render_asset }
-    let(:params) { "alert.js" }
-
-    context "when debug mode enabled" do
-      let(:assets_config) { Hash[:debug, true] }
-      it { is_expected.to eq "alert('test');\n" }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { expect { subject }.to raise_error(/#{params}/) }
-      end
-    end
-
-    context "when debug mode disabled" do
-      let(:assets_config) { Hash[:debug, false] }
-      it { is_expected.to eq "alert('test');\n" }
-
-      context "and URI given" do
-        let(:params) { "http://example.com/style.css" }
-        it { expect { subject }.to raise_error(/#{params}/) }
-      end
-    end
-  end
-end