nanoc 4.8.12 → 4.8.13

data/spec/nanoc/base/memoization_spec.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Memoization do
-  class MemoizationSpecSample1
-    extend Nanoc::Int::Memoization
-
-    def initialize(value)
-      @value = value
-    end
-
-    def run(n)
-      @value * 10 + n
-    end
-    memoize :run
-  end
-
-  class MemoizationSpecSample2
-    extend Nanoc::Int::Memoization
-
-    def initialize(value)
-      @value = value
-    end
-
-    def run(n)
-      @value * 100 + n
-    end
-    memoize :run
-  end
-
-  class MemoizationSpecUpcaser
-    extend Nanoc::Int::Memoization
-
-    def run(value)
-      value.upcase
-    end
-    memoize :run
-  end
-
-  class MemoizationSpecUpcaserInlineSyntax
-    extend Nanoc::Int::Memoization
-
-    memoized def run(value)
-      value.upcase
-    end
-  end
-
-  class MemoizationSpecInlineSyntaxReturn
-    extend Nanoc::Int::Memoization
-
-    class << self
-      attr_reader :sym
-    end
-
-    def self.record(sym)
-      @sym = sym
-    end
-
-    record memoized def run; end
-  end
-
-  example do
-    sample1a = MemoizationSpecSample1.new(10)
-    sample1b = MemoizationSpecSample1.new(15)
-    sample2a = MemoizationSpecSample2.new(20)
-    sample2b = MemoizationSpecSample2.new(25)
-
-    3.times do
-      expect(sample1a.run(5)).to eq(10 * 10 + 5)
-      expect(sample1b.run(7)).to eq(10 * 15 + 7)
-      expect(sample2a.run(5)).to eq(100 * 20 + 5)
-      expect(sample2b.run(7)).to eq(100 * 25 + 7)
-    end
-  end
-
-  it 'supports frozen objects' do
-    sample = MemoizationSpecSample1.new(10)
-    sample.freeze
-    sample.run(5)
-  end
-
-  it 'supports memoized def … syntax' do
-    upcaser = MemoizationSpecUpcaserInlineSyntax.new
-    expect(upcaser.run('hi')).to eq('HI')
-  end
-
-  it 'does not crash on #inspect' do
-    upcaser = MemoizationSpecUpcaser.new
-    10_000.times do |i|
-      upcaser.run("hello world #{i}")
-    end
-
-    GC.start
-    GC.start
-
-    upcaser.inspect
-  end
-
-  it 'returns method name' do
-    expect(MemoizationSpecInlineSyntaxReturn.sym).to eq(:run)
-  end
-
-  it 'sends notifications' do
-    sample = MemoizationSpecSample1.new(10)
-    expect { sample.run(5) }.to send_notification(:memoization_miss, 'MemoizationSpecSample1#run')
-    expect { sample.run(5) }.to send_notification(:memoization_hit, 'MemoizationSpecSample1#run')
-    expect { sample.run(5) }.to send_notification(:memoization_hit, 'MemoizationSpecSample1#run')
-  end
-end

data/spec/nanoc/base/repos/aggregate_data_source_spec.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::AggregateDataSource, stdio: true do
-  let(:klass_1) do
-    Class.new(Nanoc::DataSource) do
-      def items
-        [Nanoc::Int::Item.new('One', {}, '/one.md')]
-      end
-
-      def item_changes
-        %i[one_foo one_bar]
-      end
-
-      def layouts
-        [Nanoc::Int::Layout.new('One', {}, '/one.md')]
-      end
-
-      def layout_changes
-        %i[one_foo one_bar]
-      end
-    end
-  end
-
-  let(:klass_2) do
-    Class.new(Nanoc::DataSource) do
-      def items
-        [Nanoc::Int::Item.new('Two', {}, '/two.md')]
-      end
-
-      def item_changes
-        %i[two_foo two_bar]
-      end
-
-      def layouts
-        [Nanoc::Int::Layout.new('Two', {}, '/two.md')]
-      end
-
-      def layout_changes
-        %i[two_foo two_bar]
-      end
-    end
-  end
-
-  let(:data_source_1) do
-    klass_1.new({}, nil, nil, {})
-  end
-
-  let(:data_source_2) do
-    klass_2.new({}, nil, nil, {})
-  end
-
-  subject(:data_source) do
-    described_class.new([data_source_1, data_source_2], {})
-  end
-
-  describe '#items' do
-    subject { data_source.items }
-
-    it 'contains all items' do
-      expect(subject).to match_array(data_source_1.items + data_source_2.items)
-    end
-  end
-
-  describe '#layouts' do
-    subject { data_source.layouts }
-
-    it 'contains all layouts' do
-      expect(subject).to match_array(data_source_1.layouts + data_source_2.layouts)
-    end
-  end
-
-  describe '#item_changes' do
-    subject { data_source.item_changes }
-
-    it 'yields changes from both' do
-      expect(subject).to match_array(data_source_1.item_changes + data_source_2.item_changes)
-    end
-  end
-
-  describe '#layout_changes' do
-    subject { data_source.layout_changes }
-
-    it 'yields changes from both' do
-      expect(subject).to match_array(data_source_1.layout_changes + data_source_2.layout_changes)
-    end
-  end
-end

data/spec/nanoc/base/repos/checksum_store_spec.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ChecksumStore do
-  let(:store) { described_class.new(objects: objects) }
-
-  let(:objects) { [item, code_snippet] }
-
-  let(:item) { Nanoc::Int::Item.new('asdf', item_attributes, '/foo.md') }
-  let(:other_item) { Nanoc::Int::Item.new('asdf', other_item_attributes, '/sneaky.md') }
-
-  let(:item_attributes) { {} }
-  let(:other_item_attributes) { {} }
-
-  let(:code_snippet) { Nanoc::Int::CodeSnippet.new('def hi ; end', 'lib/foo.rb') }
-  let(:other_code_snippet) { Nanoc::Int::CodeSnippet.new('def ho ; end', 'lib/bar.rb') }
-
-  context 'nothing added' do
-    it 'has no checksum' do
-      expect(store[item]).to be_nil
-    end
-
-    it 'has no content checksum' do
-      expect(store.content_checksum_for(item)).to be_nil
-    end
-
-    it 'has no attributes checksum' do
-      expect(store.attributes_checksum_for(item)).to be_nil
-    end
-  end
-
-  context 'setting content on known non-document' do
-    before { store.add(code_snippet) }
-
-    it 'has checksum' do
-      expect(store[code_snippet]).not_to be_nil
-    end
-
-    it 'has no content checksum' do
-      expect(store.content_checksum_for(code_snippet)).to be_nil
-    end
-
-    it 'has no attributes checksum' do
-      expect(store.attributes_checksum_for(code_snippet)).to be_nil
-    end
-
-    context 'after storing and loading' do
-      before do
-        store.store
-        store.load
-      end
-
-      it 'has checksum' do
-        expect(store[code_snippet]).not_to be_nil
-      end
-    end
-  end
-
-  context 'setting content on unknown non-document' do
-    before { store.add(other_code_snippet) }
-
-    it 'has checksum' do
-      expect(store[other_code_snippet]).not_to be_nil
-    end
-
-    it 'has no content checksum' do
-      expect(store.content_checksum_for(other_code_snippet)).to be_nil
-    end
-
-    it 'has no attributes checksum' do
-      expect(store.attributes_checksum_for(other_code_snippet)).to be_nil
-    end
-
-    context 'after storing and loading' do
-      before do
-        store.store
-        store.load
-      end
-
-      it 'has no checksum' do
-        expect(store[other_code_snippet]).to be_nil
-      end
-    end
-  end
-
-  context 'setting content on known item' do
-    before { store.add(item) }
-
-    it 'has checksum' do
-      expect(store[item]).not_to be_nil
-    end
-
-    it 'has content checksum' do
-      expect(store.content_checksum_for(item)).not_to be_nil
-    end
-
-    it 'has attributes checksum' do
-      expect(store.attributes_checksum_for(item)).not_to be_nil
-      expect(store.attributes_checksum_for(item)).to eq({})
-    end
-
-    context 'item has attributes' do
-      let(:item_attributes) { { animal: 'donkey' } }
-
-      it 'has attribute checksum for specified attribute' do
-        expect(store.attributes_checksum_for(item)).to have_key(:animal)
-      end
-    end
-
-    context 'after storing and loading' do
-      before do
-        store.store
-        store.load
-      end
-
-      it 'has checksum' do
-        expect(store[item]).not_to be_nil
-      end
-    end
-  end
-
-  context 'setting content on unknown item' do
-    before { store.add(other_item) }
-
-    it 'has checksum' do
-      expect(store[other_item]).not_to be_nil
-    end
-
-    it 'has content checksum' do
-      expect(store.content_checksum_for(other_item)).not_to be_nil
-    end
-
-    it 'has attributes checksum' do
-      expect(store.attributes_checksum_for(other_item)).not_to be_nil
-    end
-
-    context 'item has attributes' do
-      let(:other_item_attributes) { { location: 'Bernauer Str.' } }
-
-      it 'has attribute checksum for specified attribute' do
-        expect(store.attributes_checksum_for(other_item)).to have_key(:location)
-      end
-    end
-
-    context 'after storing and loading' do
-      before do
-        store.store
-        store.load
-      end
-
-      it 'has no checksum' do
-        expect(store[other_item]).to be_nil
-      end
-    end
-  end
-end

data/spec/nanoc/base/repos/compiled_content_cache_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::CompiledContentCache do
-  let(:cache) { described_class.new(items: items, site: site) }
-
-  let(:items) { [item] }
-
-  let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
-  let(:item_rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-  let(:other_item) { Nanoc::Int::Item.new('asdf', {}, '/sneaky.md') }
-  let(:other_item_rep) { Nanoc::Int::ItemRep.new(other_item, :default) }
-
-  let(:content) { Nanoc::Int::Content.create('omg') }
-
-  let(:site) do
-    Nanoc::Int::Site.new(
-      config: Nanoc::Int::Configuration.new.with_defaults,
-      code_snippets: [],
-      data_source: Nanoc::Int::InMemDataSource.new(items, []),
-    )
-  end
-
-  it 'has no content by default' do
-    expect(cache[item_rep]).to be_nil
-  end
-
-  context 'setting content on known item' do
-    before { cache[item_rep] = { last: content } }
-
-    it 'has content' do
-      expect(cache[item_rep][:last].string).to eql('omg')
-    end
-
-    context 'after storing and loading' do
-      before do
-        cache.store
-        cache.load
-      end
-
-      it 'has content' do
-        expect(cache[item_rep][:last].string).to eql('omg')
-      end
-    end
-  end
-
-  context 'setting content on unknown item' do
-    before { cache[other_item_rep] = { last: content } }
-
-    it 'has content' do
-      expect(cache[other_item_rep][:last].string).to eql('omg')
-    end
-
-    context 'after storing and loading' do
-      before do
-        cache.store
-        cache.load
-      end
-
-      it 'has no content' do
-        expect(cache[other_item_rep]).to be_nil
-      end
-    end
-  end
-end

data/spec/nanoc/base/repos/config_loader_spec.rb

@@ -1,245 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ConfigLoader do
-  let(:loader) { described_class.new }
-
-  describe '#new_from_cwd' do
-    subject { loader.new_from_cwd }
-
-    context 'no config file present' do
-      it 'errors' do
-        expect { subject }.to raise_error(
-          Nanoc::Int::ConfigLoader::NoConfigFileFoundError,
-        )
-      end
-    end
-
-    context 'config file present' do
-      before do
-        File.write('nanoc.yaml', YAML.dump(foo: 'bar'))
-      end
-
-      it 'returns a configuration' do
-        expect(subject).to be_a(Nanoc::Int::Configuration)
-      end
-
-      it 'has the defaults' do
-        expect(subject[:output_dir]).to eq('output')
-      end
-
-      it 'has the custom option' do
-        expect(subject[:foo]).to eq('bar')
-      end
-    end
-
-    context 'config file and parent present' do
-      before do
-        File.write('nanoc.yaml', YAML.dump(parent_config_file: 'parent.yaml'))
-        File.write('parent.yaml', YAML.dump(foo: 'bar'))
-      end
-
-      it 'returns the configuration' do
-        expect(subject).to be_a(Nanoc::Int::Configuration)
-      end
-
-      it 'has the defaults' do
-        expect(subject[:output_dir]).to eq('output')
-      end
-
-      it 'has the custom option' do
-        expect(subject[:foo]).to eq('bar')
-      end
-
-      it 'does not include parent config option' do
-        expect(subject[:parent_config_file]).to be_nil
-      end
-    end
-
-    context 'config file present, environment defined' do
-      let(:active_env_name) { 'default' }
-
-      let(:config) do
-        {
-          foo: 'bar',
-          tofoo: 'bar',
-          environments: {
-            test: { foo: 'test-bar' },
-            default: { foo: 'default-bar' },
-          },
-        }
-      end
-
-      before do
-        File.write('nanoc.yaml', YAML.dump(config))
-      end
-
-      before do
-        expect(ENV).to receive(:fetch).with('NANOC_ENV', 'default').and_return(active_env_name)
-      end
-
-      it 'returns the configuration' do
-        expect(subject).to be_a(Nanoc::Int::Configuration)
-      end
-
-      it 'has option defined not within environments' do
-        expect(subject[:tofoo]).to eq('bar')
-      end
-
-      context 'current env is test' do
-        let(:active_env_name) { 'test' }
-
-        it 'has the test environment custom option' do
-          expect(subject[:foo]).to eq('test-bar')
-        end
-      end
-
-      it 'has the default environment custom option' do
-        expect(subject[:foo]).to eq('default-bar')
-      end
-    end
-  end
-
-  describe '.cwd_is_nanoc_site? + .config_filename_for_cwd' do
-    context 'no config files' do
-      it 'is not considered a nanoc site dir' do
-        expect(described_class.cwd_is_nanoc_site?).to eq(false)
-        expect(described_class.config_filename_for_cwd).to be_nil
-      end
-    end
-
-    context 'nanoc.yaml config file' do
-      before do
-        File.write('nanoc.yaml', 'stuff')
-      end
-
-      it 'is considered a nanoc site dir' do
-        expect(described_class.cwd_is_nanoc_site?).to eq(true)
-        expect(described_class.config_filename_for_cwd).to eq(File.expand_path('nanoc.yaml'))
-      end
-    end
-
-    context 'config.yaml config file' do
-      before do
-        File.write('config.yaml', 'stuff')
-      end
-
-      it 'is considered a nanoc site dir' do
-        expect(described_class.cwd_is_nanoc_site?).to eq(true)
-        expect(described_class.config_filename_for_cwd).to eq(File.expand_path('config.yaml'))
-      end
-    end
-  end
-
-  describe '#apply_parent_config' do
-    subject { loader.apply_parent_config(config, processed_paths) }
-
-    let(:config) { Nanoc::Int::Configuration.new(hash: { foo: 'bar' }) }
-
-    let(:processed_paths) { ['nanoc.yaml'] }
-
-    context 'no parent_config_file' do
-      it 'returns self' do
-        expect(subject).to eq(config)
-      end
-    end
-
-    context 'parent config file is set' do
-      let(:config) do
-        Nanoc::Int::Configuration.new(hash: { parent_config_file: 'foo.yaml', foo: 'bar' })
-      end
-
-      context 'parent config file is not present' do
-        it 'errors' do
-          expect { subject }.to raise_error(
-            Nanoc::Int::ConfigLoader::NoParentConfigFileFoundError,
-          )
-        end
-      end
-
-      context 'parent config file is present' do
-        context 'parent-child cycle' do
-          before do
-            File.write('foo.yaml', 'parent_config_file: bar.yaml')
-            File.write('bar.yaml', 'parent_config_file: foo.yaml')
-          end
-
-          it 'errors' do
-            expect { subject }.to raise_error(
-              Nanoc::Int::ConfigLoader::CyclicalConfigFileError,
-            )
-          end
-        end
-
-        context 'self parent-child cycle' do
-          before do
-            File.write('foo.yaml', 'parent_config_file: foo.yaml')
-          end
-
-          it 'errors' do
-            expect { subject }.to raise_error(
-              Nanoc::Int::ConfigLoader::CyclicalConfigFileError,
-            )
-          end
-        end
-
-        context 'no parent-child cycle' do
-          before do
-            File.write('foo.yaml', 'animal: giraffe')
-          end
-
-          it 'returns a configuration' do
-            expect(subject).to be_a(Nanoc::Int::Configuration)
-          end
-
-          it 'has no defaults (added in #new_from_cwd only)' do
-            expect(subject[:output_dir]).to be_nil
-          end
-
-          it 'inherits options from parent' do
-            expect(subject[:animal]).to eq('giraffe')
-          end
-
-          it 'takes options from child' do
-            expect(subject[:foo]).to eq('bar')
-          end
-
-          it 'does not include parent config option' do
-            expect(subject[:parent_config_file]).to be_nil
-          end
-        end
-
-        context 'long parent chain' do
-          before do
-            File.write('foo.yaml', "parrots: 43\nparent_config_file: bar.yaml\n")
-            File.write('bar.yaml', "day_one: lasers\nslugs: false\n")
-          end
-
-          it 'returns a configuration' do
-            expect(subject).to be_a(Nanoc::Int::Configuration)
-          end
-
-          it 'has no defaults (added in #new_from_cwd only)' do
-            expect(subject[:output_dir]).to be_nil
-          end
-
-          it 'inherits options from grandparent' do
-            expect(subject[:day_one]).to eq('lasers')
-            expect(subject[:slugs]).to eq(false)
-          end
-
-          it 'inherits options from parent' do
-            expect(subject[:parrots]).to eq(43)
-          end
-
-          it 'takes options from child' do
-            expect(subject[:foo]).to eq('bar')
-          end
-
-          it 'does not include parent config option' do
-            expect(subject[:parent_config_file]).to be_nil
-          end
-        end
-      end
-    end
-  end
-end