nanoc 4.8.12 → 4.8.13

data/spec/nanoc/telemetry/labelled_summary_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::LabelledSummary do
-  subject(:summary) { described_class.new }
-
-  describe '#empty?' do
-    subject { summary.empty? }
-
-    context 'empty summary' do
-      it { is_expected.to be }
-    end
-
-    context 'some observations' do
-      before do
-        summary.observe(7.2, :erb)
-        summary.observe(5.3, :erb)
-        summary.observe(3.0, :haml)
-      end
-
-      it { is_expected.not_to be }
-    end
-  end
-
-  describe '#get' do
-    subject { summary.get(:erb) }
-
-    context 'empty summary' do
-      its(:count) { is_expected.to eq(0) }
-    end
-
-    context 'one observation with that label' do
-      before { summary.observe(0.1, :erb) }
-      its(:count) { is_expected.to eq(1) }
-    end
-
-    context 'one observation with a different label' do
-      before { summary.observe(0.1, :haml) }
-      its(:count) { is_expected.to eq(0) }
-    end
-  end
-
-  describe '#map' do
-    before do
-      subject.observe(2.1, :erb)
-      subject.observe(4.1, :erb)
-      subject.observe(5.3, :haml)
-    end
-
-    it 'yields label and summary' do
-      res = subject.map { |label, summary| [label, summary.avg.round(3)] }
-      expect(res).to eql([[:erb, 3.1], [:haml, 5.3]])
-    end
-  end
-
-  describe '#quantile' do
-    before do
-      subject.observe(2.1, :erb)
-      subject.observe(4.1, :erb)
-      subject.observe(5.3, :haml)
-    end
-
-    it 'has proper quantiles for :erb' do
-      expect(subject.quantile(0.00, :erb)).to be_within(0.000001).of(2.1)
-      expect(subject.quantile(0.25, :erb)).to be_within(0.000001).of(2.6)
-      expect(subject.quantile(0.50, :erb)).to be_within(0.000001).of(3.1)
-      expect(subject.quantile(0.90, :erb)).to be_within(0.000001).of(3.9)
-      expect(subject.quantile(0.99, :erb)).to be_within(0.000001).of(4.08)
-    end
-
-    it 'has proper quantiles for :erb' do
-      expect(subject.quantile(0.00, :haml)).to be_within(0.000001).of(5.3)
-      expect(subject.quantile(0.25, :haml)).to be_within(0.000001).of(5.3)
-      expect(subject.quantile(0.50, :haml)).to be_within(0.000001).of(5.3)
-      expect(subject.quantile(0.90, :haml)).to be_within(0.000001).of(5.3)
-      expect(subject.quantile(0.99, :haml)).to be_within(0.000001).of(5.3)
-    end
-  end
-end

data/spec/nanoc/telemetry/stopwatch_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::Stopwatch do
-  subject(:stopwatch) { described_class.new }
-
-  after { Timecop.return }
-
-  it 'is zero by default' do
-    expect(stopwatch.duration).to eq(0.0)
-  end
-
-  # TODO: if running, raise error when asking for #duration
-
-  it 'records correct duration after start+stop' do
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
-    stopwatch.start
-
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
-    stopwatch.stop
-
-    expect(stopwatch.duration).to eq(1.0)
-  end
-
-  it 'records correct duration after start+stop+start+stop' do
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
-    stopwatch.start
-
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
-    stopwatch.stop
-
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
-    stopwatch.start
-
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
-    stopwatch.stop
-
-    expect(stopwatch.duration).to eq(1.0 + 3.0)
-  end
-
-  it 'errors when stopping when not started' do
-    expect { stopwatch.stop }.to raise_error(Nanoc::Telemetry::Stopwatch::NotRunningError)
-  end
-
-  it 'errors when starting when already started' do
-    stopwatch.start
-    expect { stopwatch.start }.to raise_error(Nanoc::Telemetry::Stopwatch::AlreadyRunningError)
-  end
-
-  it 'reports running status' do
-    expect(stopwatch).not_to be_running
-    expect(stopwatch).to be_stopped
-
-    stopwatch.start
-
-    expect(stopwatch).to be_running
-    expect(stopwatch).not_to be_stopped
-
-    stopwatch.stop
-
-    expect(stopwatch).not_to be_running
-    expect(stopwatch).to be_stopped
-  end
-end

data/spec/nanoc/telemetry/summary_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::Summary do
-  subject(:summary) { described_class.new }
-
-  context 'no observations' do
-    it 'errors on #min' do
-      expect { subject.min }
-        .to raise_error(Nanoc::Telemetry::Summary::EmptySummaryError)
-    end
-
-    it 'errors on #max' do
-      expect { subject.max }
-        .to raise_error(Nanoc::Telemetry::Summary::EmptySummaryError)
-    end
-
-    it 'errors on #avg' do
-      expect { subject.avg }
-        .to raise_error(Nanoc::Telemetry::Summary::EmptySummaryError)
-    end
-
-    it 'errors on #sum' do
-      expect { subject.sum }
-        .to raise_error(Nanoc::Telemetry::Summary::EmptySummaryError)
-    end
-
-    its(:count) { is_expected.to eq(0) }
-  end
-
-  context 'one observation' do
-    before { subject.observe(2.1) }
-
-    its(:count) { is_expected.to eq(1) }
-    its(:sum) { is_expected.to eq(2.1) }
-    its(:avg) { is_expected.to eq(2.1) }
-    its(:min) { is_expected.to eq(2.1) }
-    its(:max) { is_expected.to eq(2.1) }
-
-    it 'has proper quantiles' do
-      expect(subject.quantile(0.00)).to eq(2.1)
-      expect(subject.quantile(0.25)).to eq(2.1)
-      expect(subject.quantile(0.50)).to eq(2.1)
-      expect(subject.quantile(0.90)).to eq(2.1)
-      expect(subject.quantile(0.99)).to eq(2.1)
-    end
-  end
-
-  context 'two observations' do
-    before do
-      subject.observe(2.1)
-      subject.observe(4.1)
-    end
-
-    its(:count) { is_expected.to be_within(0.000001).of(2) }
-    its(:sum) { is_expected.to be_within(0.000001).of(6.2) }
-    its(:avg) { is_expected.to be_within(0.000001).of(3.1) }
-    its(:min) { is_expected.to be_within(0.000001).of(2.1) }
-    its(:max) { is_expected.to be_within(0.000001).of(4.1) }
-
-    it 'has proper quantiles' do
-      expect(subject.quantile(0.00)).to be_within(0.000001).of(2.1)
-      expect(subject.quantile(0.25)).to be_within(0.000001).of(2.6)
-      expect(subject.quantile(0.50)).to be_within(0.000001).of(3.1)
-      expect(subject.quantile(0.90)).to be_within(0.000001).of(3.9)
-      expect(subject.quantile(0.99)).to be_within(0.000001).of(4.08)
-    end
-  end
-end

data/spec/nanoc/telemetry/table_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::Table do
-  let(:table) { described_class.new(rows) }
-
-  let(:rows) do
-    [
-      %w[name awesomeness],
-      %w[denis high],
-      %w[REDACTED low],
-    ]
-  end
-
-  example do
-    expect(table.to_s).to eq(<<~EOS.rstrip)
-          name │ awesomeness
-      ─────────┼────────────
-         denis │        high
-      REDACTED │         low
-    EOS
-  end
-end

data/spec/nanoc/telemetry_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry do
-  subject { described_class.new }
-
-  example do
-    expect(subject.counter(:filters).values).to eq({})
-    expect(subject.counter(:filters).get(:erb).value).to eq(0)
-    expect(subject.counter(:filters).value(:erb)).to eq(0)
-
-    subject.counter(:filters).increment(:erb)
-    expect(subject.counter(:filters).values).to eq(erb: 1)
-    expect(subject.counter(:filters).get(:erb).value).to eq(1)
-    expect(subject.counter(:filters).value(:erb)).to eq(1)
-  end
-
-  example do
-    subject.summary(:filters).observe(0.1, :erb)
-    expect(subject.summary(:filters).quantile(0.0, :erb)).to be_within(0.00001).of(0.1)
-    expect(subject.summary(:filters).quantile(0.5, :erb)).to be_within(0.00001).of(0.1)
-    expect(subject.summary(:filters).quantile(1.0, :erb)).to be_within(0.00001).of(0.1)
-
-    subject.summary(:filters).observe(1.1, :erb)
-    expect(subject.summary(:filters).quantile(0.0, :erb)).to be_within(0.00001).of(0.1)
-    expect(subject.summary(:filters).quantile(0.5, :erb)).to be_within(0.00001).of(0.6)
-    expect(subject.summary(:filters).quantile(1.0, :erb)).to be_within(0.00001).of(1.1)
-  end
-end

data/spec/regression_filenames_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe 'regression tests', chdir: false do
-  let(:regression_test_filenames) do
-    Dir['spec/nanoc/regressions/*']
-  end
-
-  let(:regression_test_numbers) do
-    regression_test_filenames
-      .map { |fn| File.readlines(fn).find { |l| l =~ /^describe/ }.match(/GH-(\d+)/)[1] }
-  end
-
-  it 'should have the proper filenames' do
-    regression_test_filenames.zip(regression_test_numbers) do |fn, num|
-      expect(fn).to match(/gh_#{num}[a-z]*_spec/), "#{fn} has the wrong name in its #define block"
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,371 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-SimpleCov.start
-
-require 'codecov'
-SimpleCov.formatter = SimpleCov::Formatter::Codecov
-
-require 'nanoc'
-require 'nanoc/cli'
-require 'nanoc/spec'
-
-require 'ddbuffer'
-require 'timecop'
-require 'rspec/its'
-require 'fuubar'
-require 'yard'
-
-Nanoc::CLI.setup
-
-RSpec.configure do |c|
-  c.include(Nanoc::Spec::Helper)
-
-  c.include(Nanoc::Spec::HelperHelper, helper: true)
-
-  c.fuubar_progress_bar_options = {
-    format: '%c/%C |<%b>%i| %p%%',
-  }
-
-  c.around(:each) do |example|
-    Nanoc::CLI::ErrorHandler.disable
-    example.run
-    Nanoc::CLI::ErrorHandler.enable
-  end
-
-  c.around(:each) do |example|
-    Dir.mktmpdir('nanoc-test') do |dir|
-      chdir(dir) { example.run }
-    end
-  end
-
-  c.around(:each, chdir: false) do |example|
-    Dir.chdir(__dir__ + '/..')
-    example.run
-  end
-
-  c.before(:each) do
-    Nanoc::Int::NotificationCenter.reset
-  end
-
-  c.around(:each, stdio: true) do |example|
-    orig_stdout = $stdout
-    orig_stderr = $stderr
-
-    unless ENV['QUIET'] == 'false'
-      $stdout = StringIO.new
-      $stderr = StringIO.new
-    end
-
-    example.run
-
-    $stdout = orig_stdout
-    $stderr = orig_stderr
-  end
-
-  c.before(:each, site: true) do
-    FileUtils.mkdir_p('content')
-    FileUtils.mkdir_p('layouts')
-    FileUtils.mkdir_p('lib')
-    FileUtils.mkdir_p('output')
-
-    File.write('nanoc.yaml', '{}')
-
-    File.write('Rules', 'passthrough "/**/*"')
-  end
-end
-
-RSpec::Matchers.define_negated_matcher :not_match, :match
-
-RSpec::Matchers.define :raise_frozen_error do |_expected|
-  match do |actual|
-    begin
-      actual.call
-      false
-    rescue => e
-      if e.is_a?(RuntimeError) || e.is_a?(TypeError)
-        e.message =~ /(^can't modify frozen |^unable to modify frozen object$)/
-      else
-        false
-      end
-    end
-  end
-
-  supports_block_expectations
-
-  failure_message do |_actual|
-    'expected that proc would raise a frozen error'
-  end
-
-  failure_message_when_negated do |_actual|
-    'expected that proc would not raise a frozen error'
-  end
-end
-
-RSpec::Matchers.define :be_humanly_sorted do
-  match do |actual|
-    actual == sort(actual)
-  end
-
-  description do
-    'be humanly sorted'
-  end
-
-  failure_message do |actual|
-    expected_order = []
-    actual.zip(sort(actual)).each do |a, b|
-      if a != b
-        expected_order << b
-      end
-    end
-
-    "expected collection to be sorted (incorrect order: #{expected_order.join(' < ')})"
-  end
-
-  def sort(x)
-    x.sort_by { |n| n.dup.unicode_normalize(:nfd).encode('ASCII', fallback: ->(_) { '' }).downcase }
-  end
-end
-
-RSpec::Matchers.define :finish_in_under do |expected|
-  supports_block_expectations
-
-  match do |actual|
-    before = Time.now
-    actual.call
-    after = Time.now
-    @actual_duration = after - before
-    @actual_duration < expected
-  end
-
-  chain :seconds do
-  end
-
-  failure_message do |_actual|
-    "expected that proc would finish in under #{expected}s, but took #{format '%0.1fs', @actual_duration}"
-  end
-
-  failure_message_when_negated do |_actual|
-    "expected that proc would not finish in under #{expected}s, but took #{format '%0.1fs', @actual_duration}"
-  end
-end
-
-RSpec::Matchers.define :yield_from_fiber do |expected|
-  supports_block_expectations
-
-  include RSpec::Matchers::Composable
-
-  match do |actual|
-    @res = Fiber.new { actual.call }.resume
-    values_match?(expected, @res)
-  end
-
-  description do
-    "yield #{expected.inspect} from fiber"
-  end
-
-  failure_message do |_actual|
-    "expected that proc would yield #{expected.inspect} from fiber, but was #{@res.inspect}"
-  end
-
-  failure_message_when_negated do |_actual|
-    "expected that proc would not yield #{expected.inspect} from fiber, but was #{@res.inspect}"
-  end
-end
-
-RSpec::Matchers.define :raise_wrapped_error do |expected|
-  supports_block_expectations
-
-  include RSpec::Matchers::Composable
-
-  match do |actual|
-    begin
-      actual.call
-    rescue Nanoc::Int::Errors::CompilationError => e
-      values_match?(expected, e.unwrap)
-    end
-  end
-
-  description do
-    "raise wrapped error #{expected.inspect}"
-  end
-
-  failure_message do |_actual|
-    "expected that proc would raise wrapped error #{expected.inspect}"
-  end
-
-  failure_message_when_negated do |_actual|
-    "expected that proc would not raise wrapped error #{expected.inspect}"
-  end
-end
-
-RSpec::Matchers.define :be_some_textual_content do |expected|
-  include RSpec::Matchers::Composable
-
-  match do |actual|
-    actual.is_a?(Nanoc::Int::TextualContent) && values_match?(expected, actual.string)
-  end
-
-  description do
-    "textual content matching #{expected.inspect}"
-  end
-
-  failure_message do |actual|
-    "expected #{actual.inspect} to be textual content matching #{expected.inspect}"
-  end
-
-  failure_message_when_negated do |actual|
-    "expected #{actual.inspect} not to be textual content matching #{expected.inspect}"
-  end
-end
-
-RSpec::Matchers.define :be_some_binary_content do |expected|
-  include RSpec::Matchers::Composable
-
-  match do |actual|
-    actual.is_a?(Nanoc::Int::BinaryContent) && values_match?(expected, File.read(actual.filename))
-  end
-
-  description do
-    "binary content matching #{expected.inspect}"
-  end
-
-  failure_message do |actual|
-    "expected #{actual.inspect} to be binary content matching #{expected.inspect}"
-  end
-
-  failure_message_when_negated do |actual|
-    "expected #{actual.inspect} not to be binary content matching #{expected.inspect}"
-  end
-end
-
-RSpec::Matchers.alias_matcher :some_textual_content, :be_some_textual_content
-RSpec::Matchers.alias_matcher :some_binary_content, :be_some_binary_content
-
-RSpec::Matchers.define :send_notification do |name, *expected_args|
-  supports_block_expectations
-
-  include RSpec::Matchers::Composable
-
-  match do |actual|
-    @actual_notifications = []
-    Nanoc::Int::NotificationCenter.on(name, self) do |*actual_args|
-      @actual_notifications << actual_args
-    end
-    actual.call
-    @actual_notifications.any? { |c| c == expected_args }
-  end
-
-  description do
-    "send notification #{name.inspect} with args #{expected_args.inspect}"
-  end
-
-  failure_message do |_actual|
-    s = "expected that proc would send notification #{name.inspect} with args #{expected_args.inspect}"
-    if @actual_notifications.any?
-      s << " (received #{@actual_notifications.size} times with other arguments: #{@actual_notifications.map(&:inspect).join(', ')})"
-    end
-    s
-  end
-
-  failure_message_when_negated do |_actual|
-    "expected that proc would not send notification #{name.inspect} with args #{expected_args.inspect}"
-  end
-end
-
-RSpec::Matchers.define :have_correct_yard_examples do |_name, *_expected_args|
-  chain :in_file do |file|
-    root_dir = File.expand_path(__dir__ + '/..')
-    YARD.parse(root_dir + '/' + file)
-  end
-
-  match do |actual|
-    examples =
-      P(actual).tags(:example).flat_map do |example|
-        # Classify
-        lines = example.text.lines.map do |line|
-          [line =~ /^\s*# ?=>/ ? :result : :code, line]
-        end
-
-        # Join
-        pieces = []
-        lines.each do |line|
-          if !pieces.empty? && pieces.last.first == line.first
-            pieces.last.last << line.last
-          else
-            pieces << line
-          end
-        end
-        lines = pieces.map(&:last)
-
-        # Collect
-        lines.each_slice(2).to_a
-      end
-
-    b = binding
-    executed_examples = examples.map do |pair|
-      {
-        input:    pair.first,
-        expected: eval(pair.last.match(/# ?=>(.*)/)[1], b),
-        actual:   eval(pair.first, b),
-      }
-    end
-
-    @failing_examples = executed_examples.reject { |ex| ex[:expected] == ex[:actual] }
-
-    @failing_examples.empty?
-  end
-
-  failure_message do |_actual|
-    parts =
-      @failing_examples.map do |ex|
-        format(
-          "%s\nexpected to be\n    %s\nbut was\n    %s",
-          ex[:input],
-          ex[:expected].inspect,
-          ex[:actual].inspect,
-        )
-      end
-
-    parts.join("\n\n---\n\n")
-  end
-end
-
-RSpec::Matchers.define :leak_open_files do |_name, *_expected_args|
-  # Some remarks:
-  #
-  # • This matcher relies on global state (list of file descriptors and their
-  #   state), which means that a test case that uses this matcher can fail if
-  #   tests are being run in parallel.
-  #
-  # • This matcher assumes that file descriptors are closed explicitly, rather
-  #   than implicitly through garbage collection. This means that a test case
-  #   that uses this matcher can fail if the code exercised by the test case
-  #   relies on file descriptors to be closed when they are garbage collected.
-
-  supports_block_expectations
-
-  match do |actual|
-    open_files_before = []
-    ObjectSpace.each_object(File) { |f| open_files_before << f.fileno unless f.closed? }
-
-    actual.call
-
-    open_files_after = []
-    ObjectSpace.each_object(File) { |f| open_files_after << f.fileno unless f.closed? }
-
-    open_files_before.sort != open_files_after.sort
-  end
-
-  description do
-    'leak open files'
-  end
-
-  failure_message do |_actual|
-    'expected that proc would leak open files'
-  end
-
-  failure_message_when_negated do |_actual|
-    'expected that proc would not leak open files'
-  end
-end