nanoc 4.7.6 → 4.7.7

data/lib/nanoc/filters/colorize_syntax/colorizers.rb

@@ -0,0 +1,177 @@
+module Nanoc::Filters::ColorizeSyntax::Colorizers
+  class Abstract
+    extend DDPlugin::Plugin
+
+    def process(_code, _language, params = {}) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError
+    end
+
+    def postprocess(_language, _element); end
+
+    private
+
+    def check_availability(*cmd)
+      piper = Nanoc::Extra::Piper.new(stdout: StringIO.new, stderr: StringIO.new)
+      piper.run(cmd, nil)
+    end
+  end
+
+  class DummyColorizer < Abstract
+    identifier :dummy
+
+    def process(code, language, params = {}) # rubocop:disable Lint/UnusedMethodArgument
+      code
+    end
+  end
+
+  class CoderayColorizer < Abstract
+    identifier :coderay
+
+    def process(code, language, params = {})
+      require 'coderay'
+
+      ::CodeRay.scan(code, language).html(params)
+    end
+
+    def postprocess(_language, element)
+      # Skip if we're a free <code>
+      return if element.parent.nil?
+
+      # <div class="code">
+      div_inner = Nokogiri::XML::Node.new('div', element.document)
+      div_inner['class'] = 'code'
+      div_inner.children = element.dup
+
+      # <div class="CodeRay">
+      div_outer = Nokogiri::XML::Node.new('div', element.document)
+      div_outer['class'] = 'CodeRay'
+      div_outer.children = div_inner
+
+      # orig element
+      element.swap div_outer
+    end
+  end
+
+  class PygmentizeColorizer < Abstract
+    identifier :pygmentize
+
+    def process(code, language, params = {})
+      check_availability('pygmentize', '-V')
+
+      params[:encoding] ||= 'utf-8'
+      params[:nowrap] ||= 'True'
+
+      cmd = ['pygmentize', '-l', language, '-f', 'html']
+      cmd << '-O' << params.map { |k, v| "#{k}=#{v}" }.join(',') unless params.empty?
+
+      stdout = StringIO.new
+      stderr = $stderr
+      piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
+      piper.run(cmd, code)
+
+      stdout.string
+    end
+  end
+
+  class PygmentsrbColorizer < Abstract
+    identifier :pygmentsrb
+
+    def process(code, language, params = {})
+      require 'pygments'
+
+      args = params.dup
+      args[:lexer] ||= language
+      args[:options] ||= {}
+      args[:options][:encoding] ||= 'utf-8'
+      args[:options][:nowrap] ||= 'True'
+
+      Pygments.highlight(code, args)
+    end
+  end
+
+  class SimonHighlightColorizer < Abstract
+    identifier :simon_highlight
+
+    SIMON_HIGHLIGHT_OPT_MAP = {
+      wrap: '-W',
+      include_style: '-I',
+      line_numbers: '-l',
+    }.freeze
+
+    def process(code, language, params = {})
+      check_availability('highlight', '--version')
+
+      cmd = ['highlight', '--syntax', language, '--fragment']
+      params.each do |key, _value|
+        if SIMON_HIGHLIGHT_OPT_MAP[key]
+          cmd << SIMON_HIGHLIGHT_OPT_MAP[key]
+        else
+          # TODO: allow passing other options
+          case key
+          when :style
+            cmd << '--style' << params[:style]
+          end
+        end
+      end
+
+      stdout = StringIO.new
+      stderr = $stderr
+      piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
+      piper.run(cmd, code)
+
+      stdout.string
+    end
+  end
+
+  class RougeColorizer < Abstract
+    identifier :rouge
+
+    def process(code, language, params = {})
+      require 'rouge'
+
+      if Rouge.version < '2' || params.fetch(:legacy, false)
+        # Rouge 1.x or Rouge 2.x legacy options
+        formatter_options = {
+          css_class: params.fetch(:css_class, 'highlight'),
+          inline_theme: params.fetch(:inline_theme, nil),
+          line_numbers: params.fetch(:line_numbers, false),
+          start_line: params.fetch(:start_line, 1),
+          wrap: params.fetch(:wrap, false),
+        }
+        formatter_cls = Rouge::Formatters.const_get(Rouge.version < '2' ? 'HTML' : 'HTMLLegacy')
+        formatter = formatter_cls.new(formatter_options)
+      else
+        formatter = params.fetch(:formatter, Rouge::Formatters::HTML.new)
+      end
+
+      lexer = Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
+      formatter.format(lexer.lex(code))
+    end
+
+    def postprocess(_language, element)
+      # Removes the double wrapping.
+      #
+      # Before:
+      #
+      #   <pre><code class="language-ruby"><pre class="highlight"><code>
+      #
+      # After:
+      #
+      #   <pre><code class="language-ruby highlight">
+
+      return if element.name != 'pre'
+
+      code1 = element.xpath('code').first
+      return if code1.nil?
+
+      pre = code1.xpath('pre').first
+      return if pre.nil?
+
+      code2 = pre.xpath('code').first
+      return if code2.nil?
+
+      code1.inner_html = code2.inner_html
+      code1['class'] = [code1['class'], pre['class']].compact.join(' ')
+    end
+  end
+end

data/lib/nanoc/version.rb

@@ -1,4 +1,4 @@
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.7.6'.freeze
+  VERSION = '4.7.7'.freeze
 end

data/spec/nanoc/base/compiler_spec.rb

@@ -15,7 +15,7 @@ describe Nanoc::Int::Compiler do
   let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: items) }
   let(:action_sequence_store) { Nanoc::Int::ActionSequenceStore.new }
 
-  let(:dependency_store) { Nanoc::Int::DependencyStore.new(items.to_a) }
+  let(:dependency_store) { Nanoc::Int::DependencyStore.new(items, layouts) }
   let(:reps) { Nanoc::Int::ItemRepRepo.new }
 
   let(:outdatedness_store) { Nanoc::Int::OutdatednessStore.new(site: site, reps: reps) }
@@ -38,13 +38,16 @@ describe Nanoc::Int::Compiler do
   end
 
   let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-  let(:layouts) { [] }
   let(:code_snippets) { [] }
 
   let(:items) do
     Nanoc::Int::IdentifiableCollection.new(config, [item, other_item])
   end
 
+  let(:layouts) do
+    Nanoc::Int::IdentifiableCollection.new(config)
+  end
+
   let(:memory) do
     actions =
       [

data/spec/nanoc/base/entities/identifiable_collection_spec.rb

@@ -43,4 +43,33 @@ describe Nanoc::Int::IdentifiableCollection do
       end
     end
   end
+
+  describe '#object_with_identifier' do
+    let(:objects) do
+      [
+        Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/about.css')),
+        Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/about.md')),
+        Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/style.css')),
+      ]
+    end
+
+    let(:arg) { raise 'override me' }
+
+    subject { identifiable_collection.object_with_identifier(arg) }
+
+    context 'with string' do
+      let(:arg) { '/about.css' }
+      it { is_expected.to eq(objects[0]) }
+    end
+
+    context 'with identifier' do
+      let(:arg) { Nanoc::Identifier.new('/about.css') }
+      it { is_expected.to eq(objects[0]) }
+    end
+
+    context 'with glob string' do
+      let(:arg) { '/about.*' }
+      it { is_expected.to be_nil }
+    end
+  end
 end

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

@@ -1,43 +1,43 @@
 describe Nanoc::Int::DependencyStore do
-  let(:store) { described_class.new(objects) }
+  let(:store) { described_class.new(items, layouts) }
 
-  let(:objects) do
-    [obj_a, obj_b, obj_c]
-  end
+  let(:item_a) { Nanoc::Int::Item.new('a', {}, '/a.md') }
+  let(:item_b) { Nanoc::Int::Item.new('b', {}, '/b.md') }
+  let(:item_c) { Nanoc::Int::Item.new('c', {}, '/c.md') }
 
-  let(:obj_a) { Nanoc::Int::Item.new('a', {}, '/a.md') }
-  let(:obj_b) { Nanoc::Int::Item.new('b', {}, '/b.md') }
-  let(:obj_c) { Nanoc::Int::Item.new('c', {}, '/c.md') }
+  let(:items) { Nanoc::Int::IdentifiableCollection.new(config, [item_a, item_b, item_c]) }
+  let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) }
+  let(:config) { Nanoc::Int::Configuration.new }
 
   describe '#dependencies_causing_outdatedness_of' do
     context 'no dependencies' do
       it 'returns nothing for each' do
-        expect(store.dependencies_causing_outdatedness_of(obj_a)).to be_empty
-        expect(store.dependencies_causing_outdatedness_of(obj_b)).to be_empty
-        expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty
+        expect(store.dependencies_causing_outdatedness_of(item_a)).to be_empty
+        expect(store.dependencies_causing_outdatedness_of(item_b)).to be_empty
+        expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
       end
     end
 
     context 'one dependency' do
       context 'no props' do
         before do
-          # FIXME: weird argument order (obj_b depends on obj_a, not th other way around)
-          store.record_dependency(obj_a, obj_b)
+          # FIXME: weird argument order (item_b depends on item_a, not th other way around)
+          store.record_dependency(item_a, item_b)
         end
 
         it 'returns one dependency' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps.size).to eql(1)
         end
 
         it 'returns dependency from b to a' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
-          expect(deps[0].from).to eql(obj_b)
-          expect(deps[0].to).to eql(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
+          expect(deps[0].from).to eql(item_b)
+          expect(deps[0].to).to eql(item_a)
         end
 
         it 'returns true for all props by default' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps[0].props.raw_content?).to eq(true)
           expect(deps[0].props.attributes?).to eq(true)
           expect(deps[0].props.compiled_content?).to eq(true)
@@ -45,45 +45,45 @@ describe Nanoc::Int::DependencyStore do
         end
 
         it 'returns nothing for the others' do
-          expect(store.dependencies_causing_outdatedness_of(obj_b)).to be_empty
-          expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty
+          expect(store.dependencies_causing_outdatedness_of(item_b)).to be_empty
+          expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
         end
       end
 
       context 'one prop' do
         before do
-          # FIXME: weird argument order (obj_b depends on obj_a, not th other way around)
-          store.record_dependency(obj_a, obj_b, compiled_content: true)
+          # FIXME: weird argument order (item_b depends on item_a, not th other way around)
+          store.record_dependency(item_a, item_b, compiled_content: true)
         end
 
         it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps[0].props.raw_content?).to eq(false)
           expect(deps[0].props.attributes?).to eq(false)
           expect(deps[0].props.path?).to eq(false)
         end
 
         it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps[0].props.compiled_content?).to eq(true)
         end
       end
 
       context 'two props' do
         before do
-          # FIXME: weird argument order (obj_b depends on obj_a, not th other way around)
-          store.record_dependency(obj_a, obj_b, compiled_content: true)
-          store.record_dependency(obj_a, obj_b, attributes: true)
+          # FIXME: weird argument order (item_b depends on item_a, not th other way around)
+          store.record_dependency(item_a, item_b, compiled_content: true)
+          store.record_dependency(item_a, item_b, attributes: true)
         end
 
         it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps[0].props.raw_content?).to eq(false)
           expect(deps[0].props.path?).to eq(false)
         end
 
         it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(obj_a)
+          deps = store.dependencies_causing_outdatedness_of(item_a)
           expect(deps[0].props.attributes?).to eq(true)
           expect(deps[0].props.compiled_content?).to eq(true)
         end
@@ -92,48 +92,48 @@ describe Nanoc::Int::DependencyStore do
 
     context 'two dependency in a chain' do
       before do
-        # FIXME: weird argument order (obj_b depends on obj_a, not th other way around)
-        store.record_dependency(obj_a, obj_b)
-        store.record_dependency(obj_b, obj_c)
+        # FIXME: weird argument order (item_b depends on item_a, not th other way around)
+        store.record_dependency(item_a, item_b)
+        store.record_dependency(item_b, item_c)
       end
 
       it 'returns one dependency for object A' do
-        deps = store.dependencies_causing_outdatedness_of(obj_a)
+        deps = store.dependencies_causing_outdatedness_of(item_a)
         expect(deps.size).to eql(1)
-        expect(deps[0].from).to eql(obj_b)
+        expect(deps[0].from).to eql(item_b)
       end
 
       it 'returns one dependency for object B' do
-        deps = store.dependencies_causing_outdatedness_of(obj_b)
+        deps = store.dependencies_causing_outdatedness_of(item_b)
         expect(deps.size).to eql(1)
-        expect(deps[0].from).to eql(obj_c)
+        expect(deps[0].from).to eql(item_c)
       end
 
       it 'returns nothing for the others' do
-        expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty
+        expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
       end
     end
   end
 
   describe 'reloading' do
     before do
-      store.record_dependency(obj_a, obj_b, compiled_content: true)
-      store.record_dependency(obj_a, obj_b, attributes: true)
+      store.record_dependency(item_a, item_b, compiled_content: true)
+      store.record_dependency(item_a, item_b, attributes: true)
 
       store.store
-      store.objects = objects_after
+      store.items = items_after
       store.load
     end
 
-    context 'no new objects' do
-      let(:objects_after) { objects }
+    context 'no new items' do
+      let(:items_after) { items }
 
       it 'has the right dependencies for item A' do
-        deps = store.dependencies_causing_outdatedness_of(obj_a)
+        deps = store.dependencies_causing_outdatedness_of(item_a)
         expect(deps.size).to eql(1)
 
-        expect(deps[0].from).to eql(obj_b)
-        expect(deps[0].to).to eql(obj_a)
+        expect(deps[0].from).to eql(item_b)
+        expect(deps[0].to).to eql(item_a)
 
         expect(deps[0].props.raw_content?).to eq(false)
         expect(deps[0].props.attributes?).to eq(true)
@@ -142,82 +142,82 @@ describe Nanoc::Int::DependencyStore do
       end
 
       it 'has the right dependencies for item B' do
-        deps = store.dependencies_causing_outdatedness_of(obj_b)
+        deps = store.dependencies_causing_outdatedness_of(item_b)
         expect(deps).to be_empty
       end
 
       it 'has the right dependencies for item C' do
-        deps = store.dependencies_causing_outdatedness_of(obj_c)
+        deps = store.dependencies_causing_outdatedness_of(item_c)
         expect(deps).to be_empty
       end
     end
 
-    context 'one new object' do
-      let(:objects_after) do
-        [obj_a, obj_b, obj_c, obj_d]
+    context 'one new item' do
+      let(:items_after) do
+        Nanoc::Int::IdentifiableCollection.new(config, [item_a, item_b, item_c, item_d])
       end
 
-      let(:obj_d) { Nanoc::Int::Item.new('d', {}, '/d.md') }
+      let(:item_d) { Nanoc::Int::Item.new('d', {}, '/d.md') }
 
       it 'marks existing items as outdated' do
-        expect(store.objects_causing_outdatedness_of(obj_a)).to eq([obj_d])
-        expect(store.objects_causing_outdatedness_of(obj_b)).to eq([obj_d])
-        expect(store.objects_causing_outdatedness_of(obj_c)).to eq([obj_d])
+        expect(store.objects_causing_outdatedness_of(item_a)).to eq([item_d])
+        expect(store.objects_causing_outdatedness_of(item_b)).to eq([item_d])
+        expect(store.objects_causing_outdatedness_of(item_c)).to eq([item_d])
       end
 
       it 'marks new items as outdated' do
-        expect(store.objects_causing_outdatedness_of(obj_d)).to eq([obj_d])
+        expect(store.objects_causing_outdatedness_of(item_d)).to eq([item_d])
       end
     end
 
-    context 'two new objects' do
-      let(:objects_after) do
-        [obj_a, obj_b, obj_c, obj_d, obj_e]
+    context 'two new items' do
+      let(:items_after) do
+        Nanoc::Int::IdentifiableCollection.new(config, [item_a, item_b, item_c, item_d, item_e])
       end
 
-      let(:obj_d) { Nanoc::Int::Item.new('d', {}, '/d.md') }
-      let(:obj_e) { Nanoc::Int::Item.new('e', {}, '/e.md') }
+      let(:item_d) { Nanoc::Int::Item.new('d', {}, '/d.md') }
+      let(:item_e) { Nanoc::Int::Item.new('e', {}, '/e.md') }
 
       it 'marks existing items as outdated' do
         # Only one of obj D or E needed!
-        expect(store.objects_causing_outdatedness_of(obj_a)).to eq([obj_d]).or eq([obj_e])
-        expect(store.objects_causing_outdatedness_of(obj_b)).to eq([obj_d]).or eq([obj_e])
-        expect(store.objects_causing_outdatedness_of(obj_c)).to eq([obj_d]).or eq([obj_e])
+        expect(store.objects_causing_outdatedness_of(item_a)).to eq([item_d]).or eq([item_e])
+        expect(store.objects_causing_outdatedness_of(item_b)).to eq([item_d]).or eq([item_e])
+        expect(store.objects_causing_outdatedness_of(item_c)).to eq([item_d]).or eq([item_e])
       end
 
       it 'marks new items as outdated' do
         # Only one of obj D or E needed!
-        expect(store.objects_causing_outdatedness_of(obj_d)).to eq([obj_d]).or eq([obj_e])
-        expect(store.objects_causing_outdatedness_of(obj_e)).to eq([obj_d]).or eq([obj_e])
+        expect(store.objects_causing_outdatedness_of(item_d)).to eq([item_d]).or eq([item_e])
+        expect(store.objects_causing_outdatedness_of(item_e)).to eq([item_d]).or eq([item_e])
       end
     end
   end
 
   describe '#record_dependency' do
     context 'no props' do
-      subject { store.record_dependency(obj_a, obj_b) }
+      subject { store.record_dependency(item_a, item_b) }
 
       it 'records a dependency' do
         expect { subject }
-          .to change { store.objects_causing_outdatedness_of(obj_a) }
+          .to change { store.objects_causing_outdatedness_of(item_a) }
           .from([])
-          .to([obj_b])
+          .to([item_b])
       end
     end
 
     context 'compiled content prop' do
-      subject { store.record_dependency(obj_a, obj_b, compiled_content: true) }
+      subject { store.record_dependency(item_a, item_b, compiled_content: true) }
 
       it 'records a dependency' do
         expect { subject }
-          .to change { store.objects_causing_outdatedness_of(obj_a) }
+          .to change { store.objects_causing_outdatedness_of(item_a) }
           .from([])
-          .to([obj_b])
+          .to([item_b])
       end
 
       it 'records a dependency with the right props' do
         subject
-        deps = store.dependencies_causing_outdatedness_of(obj_a)
+        deps = store.dependencies_causing_outdatedness_of(item_a)
 
         expect(deps.first.props.attributes?).not_to be
         expect(deps.first.props.compiled_content?).to be
@@ -225,18 +225,18 @@ describe Nanoc::Int::DependencyStore do
     end
 
     context 'attribute prop (true)' do
-      subject { store.record_dependency(obj_a, obj_b, attributes: true) }
+      subject { store.record_dependency(item_a, item_b, attributes: true) }
 
       it 'records a dependency' do
         expect { subject }
-          .to change { store.objects_causing_outdatedness_of(obj_a) }
+          .to change { store.objects_causing_outdatedness_of(item_a) }
           .from([])
-          .to([obj_b])
+          .to([item_b])
       end
 
       it 'records a dependency with the right props' do
         subject
-        deps = store.dependencies_causing_outdatedness_of(obj_a)
+        deps = store.dependencies_causing_outdatedness_of(item_a)
 
         expect(deps.first.props.attributes?).to be
         expect(deps.first.props.attributes).to be
@@ -245,18 +245,18 @@ describe Nanoc::Int::DependencyStore do
     end
 
     context 'attribute prop (true)' do
-      subject { store.record_dependency(obj_a, obj_b, attributes: [:giraffe]) }
+      subject { store.record_dependency(item_a, item_b, attributes: [:giraffe]) }
 
       it 'records a dependency' do
         expect { subject }
-          .to change { store.objects_causing_outdatedness_of(obj_a) }
+          .to change { store.objects_causing_outdatedness_of(item_a) }
           .from([])
-          .to([obj_b])
+          .to([item_b])
       end
 
       it 'records a dependency with the right props' do
         subject
-        deps = store.dependencies_causing_outdatedness_of(obj_a)
+        deps = store.dependencies_causing_outdatedness_of(item_a)
 
         expect(deps.first.props.attributes?).to be
         expect(deps.first.props.attributes).to match_array([:giraffe])