nanoc 4.8.12 → 4.8.13

data/spec/nanoc/filters/asciidoctor_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Filters::Asciidoctor do
-  subject { filter.setup_and_run(input, params) }
-
-  let(:filter) { described_class.new }
-
-  let(:input) { '== Blah blah' }
-  let(:params) { {} }
-
-  it { is_expected.to match(%r{<h2 id="_blah_blah">Blah blah</h2>}) }
-end

data/spec/nanoc/filters/colorize_syntax/rouge_spec.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require 'rouge'
-
-describe Nanoc::Filters::ColorizeSyntax, filter: true do
-  subject { filter.setup_and_run(input, default_colorizer: :rouge, rouge: params) }
-  let(:filter) { ::Nanoc::Filters::ColorizeSyntax.new }
-  let(:params) { {} }
-  let(:wrap) { false }
-  let(:css_class) { 'highlight' }
-  let(:input) do
-    <<~EOS
-      before
-      <pre><code class="language-ruby">
-        def foo
-        end
-      </code></pre>
-      after
-    EOS
-  end
-  let(:output) do
-    <<~EOS
-      before
-      <pre><code class=\"language-ruby#{wrap ? " #{css_class}" : ''}\">  <span class=\"k\">def</span> <span class=\"nf\">foo</span>
-        <span class=\"k\">end</span></code></pre>
-      after
-    EOS
-  end
-
-  context 'with Rouge' do
-    context 'with default options' do
-      it { is_expected.to eql output }
-    end
-
-    context 'with legacy' do
-      let(:legacy) { true }
-      let(:params) { super().merge(legacy: legacy) }
-
-      it { is_expected.to eql output }
-
-      context 'with pygments wrapper' do
-        let(:wrap) { true }
-        let(:params) { super().merge(wrap: wrap) }
-
-        it { is_expected.to eql output }
-
-        context 'with css_class' do
-          let(:css_class) { 'nanoc' }
-          let(:params) { super().merge(css_class: css_class) }
-
-          it { is_expected.to eql output }
-        end
-      end
-
-      context 'with line number' do
-        let(:line_numbers) { true }
-        let(:params) { super().merge(line_numbers: line_numbers) }
-        let(:output) do
-          <<~EOS
-            before
-            <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
-            <td class="rouge-gutter gl"><pre class="lineno">1
-            2
-            </pre></td>
-            <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
-              <span class="k">end</span></pre></td>
-            </tr></tbody></table></code></pre>
-            after
-          EOS
-        end
-
-        it { is_expected.to eql output }
-      end
-    end
-
-    context 'with formater' do
-      let(:params) { super().merge(formatter: formatter) }
-
-      context 'with inline' do
-        let(:formatter) { Rouge::Formatters::HTMLInline.new(theme) }
-
-        context 'with github theme' do
-          let(:theme) { Rouge::Themes::Github.new }
-          let(:output) do
-            <<~EOS
-              before
-              <pre><code class="language-ruby">  <span style="color: #000000;font-weight: bold">def</span> <span style="color: #990000;font-weight: bold">foo</span>
-                <span style="color: #000000;font-weight: bold">end</span></code></pre>
-              after
-            EOS
-          end
-
-          it { is_expected.to eql output }
-        end
-
-        context 'with colorful theme' do
-          let(:theme) { Rouge::Themes::Colorful.new }
-          let(:output) do
-            <<~EOS
-              before
-              <pre><code class="language-ruby">  <span style="color: #080;font-weight: bold">def</span> <span style="color: #06B;font-weight: bold">foo</span>
-                <span style="color: #080;font-weight: bold">end</span></code></pre>
-              after
-            EOS
-          end
-
-          it { is_expected.to eql output }
-        end
-      end
-
-      context 'with linewise' do
-        let(:formatter) { Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTML.new) }
-        let(:output) do
-          <<~EOS
-            before
-            <pre><code class="language-ruby"><div class="line-1">  <span class="k">def</span> <span class="nf">foo</span>
-            </div>
-            <div class="line-2">  <span class="k">end</span>
-            </div></code></pre>
-            after
-          EOS
-        end
-
-        it { is_expected.to eql output }
-      end
-
-      context 'with pygments' do
-        let(:wrap) { true }
-        let(:css_class) { 'codehilite' }
-        let(:formatter) { Rouge::Formatters::HTMLPygments.new(Rouge::Formatters::HTML.new) }
-
-        it { is_expected.to eql output }
-      end
-
-      context 'with table' do
-        let(:formatter) { Rouge::Formatters::HTMLTable.new(Rouge::Formatters::HTML.new) }
-        let(:output) do
-          <<~EOS
-            before
-            <pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
-            <td class="rouge-gutter gl"><pre class="lineno">1
-            2
-            </pre></td>
-            <td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
-              <span class="k">end</span></pre></td>
-            </tr></tbody></table></code></pre>
-            after
-          EOS
-        end
-
-        it { is_expected.to eql output }
-      end
-    end
-  end
-end

data/spec/nanoc/filters/less_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Filters::Less, site: true, stdio: true do
-  # These tests are high-level in order to interact well with the compiler. This is important for
-  # this :less filter, because of the way it handles fibers.
-
-  before do
-    File.open('Rules', 'w') do |io|
-      io.write "compile '/**/*.less' do\n"
-      io.write "  filter :less\n"
-      io.write "  write item.identifier.without_ext + '.css'\n"
-      io.write "end\n"
-    end
-  end
-
-  context 'one file' do
-    let(:content_a) { 'p { color: red; }' }
-
-    before do
-      File.write('content/a.less', content_a)
-    end
-
-    it 'compiles a.less' do
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
-    end
-
-    context 'with compression' do
-      let(:content_a) { '.foo { bar: a; } .bar { foo: b; }' }
-
-      before do
-        File.open('Rules', 'w') do |io|
-          io.write "compile '/*.less' do\n"
-          io.write "  filter :less, compress: true\n"
-          io.write "  write item.identifier.without_ext + '.css'\n"
-          io.write "end\n"
-        end
-      end
-
-      it 'compiles and compresses a.less' do
-        Nanoc::CLI.run(%w[compile])
-        expect(File.read('output/a.css')).to match(/^\.foo\{bar:a\}\n?\.bar\{foo:b\}/)
-      end
-    end
-  end
-
-  context 'two files' do
-    let(:content_a) { '@import "b.less";' }
-    let(:content_b) { 'p { color: red; }' }
-
-    before do
-      File.write('content/a.less', content_a)
-      File.write('content/b.less', content_b)
-    end
-
-    it 'compiles a.less' do
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
-    end
-
-    it 'recompiles a.less if b.less has changed' do
-      Nanoc::CLI.run(%w[compile])
-
-      File.write('content/b.less', 'p { color: blue; }')
-
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
-    end
-  end
-
-  context 'paths relative to site directory' do
-    let(:content_a) { '@import "content/foo/bar/imported_file.less";' }
-    let(:content_b) { 'p { color: red; }' }
-
-    before do
-      FileUtils.mkdir_p('content/foo/bar')
-
-      File.write('content/a.less', content_a)
-      File.write('content/foo/bar/imported_file.less', content_b)
-    end
-
-    it 'compiles a.less' do
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
-    end
-
-    it 'recompiles a.less if b.less has changed' do
-      Nanoc::CLI.run(%w[compile])
-
-      File.write('content/foo/bar/imported_file.less', 'p { color: blue; }')
-
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
-    end
-  end
-
-  context 'paths relative to current file' do
-    let(:content_a) { '@import "bar/imported_file.less";' }
-    let(:content_b) { 'p { color: red; }' }
-
-    before do
-      FileUtils.mkdir_p('content/foo/bar')
-
-      File.write('content/foo/a.less', content_a)
-      File.write('content/foo/bar/imported_file.less', content_b)
-    end
-
-    it 'compiles a.less' do
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
-    end
-
-    it 'recompiles a.less if b.less has changed' do
-      Nanoc::CLI.run(%w[compile])
-
-      File.write('content/foo/bar/imported_file.less', 'p { color: blue; }')
-
-      Nanoc::CLI.run(%w[compile])
-      expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
-    end
-  end
-end

data/spec/nanoc/helpers/blogging_spec.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::Blogging, helper: true do
-  before do
-    allow(ctx.dependency_tracker).to receive(:enter)
-    allow(ctx.dependency_tracker).to receive(:exit)
-  end
-
-  describe '#articles' do
-    subject { helper.articles }
-
-    before do
-      ctx.create_item('blah', { kind: 'item' }, '/0')
-      ctx.create_item('blah blah', { kind: 'article' }, '/1')
-      ctx.create_item('blah blah blah', { kind: 'article' }, '/2')
-    end
-
-    it 'returns the two articles' do
-      expect(subject.map(&:identifier)).to match_array(['/1', '/2'])
-    end
-  end
-
-  describe '#sorted_articles' do
-    subject { helper.sorted_articles }
-
-    before do
-      attrs = { kind: 'item' }
-      ctx.create_item('blah', attrs, '/0')
-
-      attrs = { kind: 'article', created_at: (Date.today - 1).to_s }
-      ctx.create_item('blah blah', attrs, '/1')
-
-      attrs = { kind: 'article', created_at: (Time.now - 500).to_s }
-      ctx.create_item('blah blah blah', attrs, '/2')
-    end
-
-    it 'returns the two articles in descending order' do
-      expect(subject.map(&:identifier)).to eq(['/2', '/1'])
-    end
-  end
-
-  describe '#url_for' do
-    subject { helper.url_for(ctx.items['/stuff']) }
-
-    let(:item_attributes) { {} }
-
-    before do
-      ctx.create_item('Stuff', item_attributes, '/stuff')
-      ctx.create_rep(ctx.items['/stuff'], '/rep/path/stuff.html')
-
-      ctx.config[:base_url] = base_url
-    end
-
-    context 'without base_url' do
-      let(:base_url) { nil }
-
-      it 'raises' do
-        expect { subject }.to raise_error(Nanoc::Error)
-      end
-    end
-
-    context 'with base_url' do
-      let(:base_url) { 'http://url.base' }
-
-      context 'with custom_url_in_feed' do
-        let(:item_attributes) do
-          { custom_url_in_feed: 'http://example.com/stuff.html' }
-        end
-
-        it 'returns custom URL' do
-          expect(subject).to eql('http://example.com/stuff.html')
-        end
-      end
-
-      context 'without custom_url_in_feed' do
-        context 'with custom_path_in_feed' do
-          let(:item_attributes) do
-            { custom_path_in_feed: '/stuff.html' }
-          end
-
-          it 'returns base URL + custom path' do
-            expect(subject).to eql('http://url.base/stuff.html')
-          end
-        end
-
-        context 'without custom_path_in_feed' do
-          it 'returns base URL + path' do
-            expect(subject).to eql('http://url.base/rep/path/stuff.html')
-          end
-        end
-      end
-    end
-  end
-
-  describe '#feed_url' do
-    subject { helper.feed_url }
-
-    let(:item_attributes) { {} }
-
-    before do
-      ctx.create_item('Feed', item_attributes, '/feed')
-      ctx.create_rep(ctx.items['/feed'], '/feed.xml')
-
-      ctx.item = ctx.items['/feed']
-      ctx.config[:base_url] = base_url
-    end
-
-    context 'without base_url' do
-      let(:base_url) { nil }
-
-      it 'raises' do
-        expect { subject }.to raise_error(Nanoc::Error)
-      end
-    end
-
-    context 'with base_url' do
-      let(:base_url) { 'http://url.base' }
-
-      context 'with feed_url' do
-        let(:item_attributes) do
-          { feed_url: 'http://custom.feed.url/feed.rss' }
-        end
-
-        it 'returns custom URL' do
-          expect(subject).to eql('http://custom.feed.url/feed.rss')
-        end
-      end
-
-      context 'without feed_url' do
-        it 'returns base URL + path' do
-          expect(subject).to eql('http://url.base/feed.xml')
-        end
-      end
-    end
-  end
-
-  describe '#attribute_to_time' do
-    subject { helper.attribute_to_time(arg) }
-
-    let(:noon_s) { 1_446_903_076 }
-    let(:beginning_of_day_s) { 1_446_854_400 }
-
-    let(:around_noon_local) { Time.at(noon_s - Time.at(noon_s).utc_offset) }
-    let(:around_noon_utc) { Time.at(noon_s) }
-    let(:beginning_of_day_utc) { Time.at(beginning_of_day_s) }
-
-    context 'with Time instance' do
-      let(:arg) { around_noon_utc }
-      it { is_expected.to eql(around_noon_utc) }
-    end
-
-    context 'with Date instance' do
-      let(:arg) { Date.new(2015, 11, 7) }
-      it { is_expected.to eql(beginning_of_day_utc) }
-    end
-
-    context 'with DateTime instance' do
-      let(:arg) { DateTime.new(2015, 11, 7, 13, 31, 16) } # rubocop:disable Style/DateTime
-      it { is_expected.to eql(around_noon_utc) }
-    end
-
-    context 'with string' do
-      let(:arg) { '2015-11-7 13:31:16' }
-      it { is_expected.to eql(around_noon_local) }
-    end
-  end
-
-  describe '#atom_tag_for' do
-    subject { helper.atom_tag_for(ctx.items['/stuff']) }
-
-    let(:item_attributes) { { created_at: '2015-05-19 12:34:56' } }
-    let(:item_rep_path) { '/stuff.xml' }
-    let(:base_url) { 'http://url.base' }
-
-    before do
-      ctx.create_item('Stuff', item_attributes, '/stuff')
-      ctx.create_rep(ctx.items['/stuff'], item_rep_path)
-
-      ctx.config[:base_url] = base_url
-    end
-
-    context 'item with path' do
-      let(:item_rep_path) { '/stuff.xml' }
-      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
-    end
-
-    context 'item without path' do
-      let(:item_rep_path) { nil }
-      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff') }
-    end
-
-    context 'bare URL without subdir' do
-      let(:base_url) { 'http://url.base' }
-      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
-    end
-
-    context 'bare URL with subdir' do
-      let(:base_url) { 'http://url.base/sub' }
-      it { is_expected.to eql('tag:url.base,2015-05-19:/sub/stuff.xml') }
-    end
-
-    context 'created_at is date' do
-      let(:item_attributes) do
-        { created_at: Date.parse('2015-05-19 12:34:56') }
-      end
-      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
-    end
-
-    context 'created_at is time' do
-      let(:item_attributes) do
-        { created_at: Time.parse('2015-05-19 12:34:56') }
-      end
-      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
-    end
-
-    # TODO: handle missing base_dir
-    # TODO: handle missing created_at
-  end
-end