nanoc 4.6.0 → 4.6.1

data/lib/nanoc/base/services/compiler.rb

@@ -72,309 +72,6 @@ module Nanoc::Int
       end
     end
 
-    # All phases for the compilation of a single item rep. Phases will be repeated for every rep.
-    module Phases
-      # Provides functionality for (re)calculating the content of an item rep, without caching or
-      # outdatedness checking.
-      class Recalculate
-        include Nanoc::Int::ContractsSupport
-
-        def initialize(action_provider:, dependency_store:, compilation_context:)
-          @action_provider = action_provider
-          @dependency_store = dependency_store
-          @compilation_context = compilation_context
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
-        def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
-          dependency_tracker = Nanoc::Int::DependencyTracker.new(@dependency_store)
-          dependency_tracker.enter(rep.item)
-
-          executor = Nanoc::Int::Executor.new(rep, @compilation_context, dependency_tracker)
-
-          @compilation_context.snapshot_repo.set(rep, :last, rep.item.content)
-
-          @action_provider.memory_for(rep).each do |action|
-            case action
-            when Nanoc::Int::ProcessingActions::Filter
-              executor.filter(action.filter_name, action.params)
-            when Nanoc::Int::ProcessingActions::Layout
-              executor.layout(action.layout_identifier, action.params)
-            when Nanoc::Int::ProcessingActions::Snapshot
-              executor.snapshot(action.snapshot_name)
-            else
-              raise Nanoc::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}"
-            end
-          end
-        ensure
-          dependency_tracker.exit
-        end
-      end
-
-      # Provides functionality for (re)calculating the content of an item rep, with caching or
-      # outdatedness checking. Delegates to s::Recalculate if outdated or no cache available.
-      class Cache
-        include Nanoc::Int::ContractsSupport
-
-        def initialize(compiled_content_cache:, snapshot_repo:, wrapped:)
-          @compiled_content_cache = compiled_content_cache
-          @snapshot_repo = snapshot_repo
-          @wrapped = wrapped
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
-        def run(rep, is_outdated:)
-          if can_reuse_content_for_rep?(rep, is_outdated: is_outdated)
-            Nanoc::Int::NotificationCenter.post(:cached_content_used, rep)
-
-            @snapshot_repo.set_all(rep, @compiled_content_cache[rep])
-          else
-            @wrapped.run(rep, is_outdated: is_outdated)
-          end
-
-          rep.compiled = true
-          @compiled_content_cache[rep] = @snapshot_repo.get_all(rep)
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Bool
-        def can_reuse_content_for_rep?(rep, is_outdated:)
-          !is_outdated && !@compiled_content_cache[rep].nil?
-        end
-      end
-
-      # Provides functionality for suspending and resuming item rep compilation (using fibers).
-      class Resume
-        include Nanoc::Int::ContractsSupport
-
-        def initialize(wrapped:)
-          @wrapped = wrapped
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
-        def run(rep, is_outdated:)
-          fiber = fiber_for(rep, is_outdated: is_outdated)
-          while fiber.alive?
-            Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
-            res = fiber.resume
-
-            case res
-            when Nanoc::Int::Errors::UnmetDependency
-              Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, res)
-              raise(res)
-            when Proc
-              fiber.resume(res.call)
-            else
-              # TODO: raise
-            end
-          end
-
-          Nanoc::Int::NotificationCenter.post(:compilation_ended, rep)
-        end
-
-        private
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => Fiber
-        def fiber_for(rep, is_outdated:)
-          @fibers ||= {}
-
-          @fibers[rep] ||=
-            Fiber.new do
-              @wrapped.run(rep, is_outdated: is_outdated)
-              @fibers.delete(rep)
-            end
-
-          @fibers[rep]
-        end
-      end
-
-      class Write
-        include Nanoc::Int::ContractsSupport
-
-        def initialize(snapshot_repo:, wrapped:)
-          @snapshot_repo = snapshot_repo
-          @wrapped = wrapped
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
-        def run(rep, is_outdated:)
-          @wrapped.run(rep, is_outdated: is_outdated)
-
-          rep.snapshot_defs.each do |sdef|
-            ItemRepWriter.new.write(rep, @snapshot_repo, sdef.name)
-          end
-        end
-      end
-
-      class MarkDone
-        include Nanoc::Int::ContractsSupport
-
-        def initialize(wrapped:, outdatedness_store:)
-          @wrapped = wrapped
-          @outdatedness_store = outdatedness_store
-        end
-
-        contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any
-        def run(rep, is_outdated:)
-          @wrapped.run(rep, is_outdated: is_outdated)
-          @outdatedness_store.remove(rep)
-        end
-      end
-    end
-
-    module Stages
-      class Preprocess
-        def initialize(action_provider:, site:, dependency_store:, checksum_store:)
-          @action_provider = action_provider
-          @site = site
-          @dependency_store = dependency_store
-          @checksum_store = checksum_store
-        end
-
-        def run
-          @action_provider.preprocess(@site)
-
-          @dependency_store.objects = @site.items.to_a + @site.layouts.to_a
-          @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config]
-
-          @site.freeze
-        end
-      end
-
-      class Prune
-        def initialize(config:, reps:)
-          @config = config
-          @reps = reps
-        end
-
-        def run
-          if @config[:prune][:auto_prune]
-            Nanoc::Pruner.new(@config, @reps, exclude: prune_config_exclude).run
-          end
-        end
-
-        private
-
-        def prune_config
-          @config[:prune] || {}
-        end
-
-        def prune_config_exclude
-          prune_config[:exclude] || {}
-        end
-      end
-
-      class DetermineOutdatedness
-        def initialize(reps:, outdatedness_checker:, outdatedness_store:)
-          @reps = reps
-          @outdatedness_checker = outdatedness_checker
-          @outdatedness_store = outdatedness_store
-        end
-
-        def run
-          outdated_reps_tmp = @reps.select do |r|
-            @outdatedness_store.include?(r) || @outdatedness_checker.outdated?(r)
-          end
-
-          outdated_items = outdated_reps_tmp.map(&:item).uniq
-          outdated_reps = Set.new(outdated_items.flat_map { |i| @reps[i] })
-
-          outdated_reps.each { |r| @outdatedness_store.add(r) }
-
-          yield(outdated_items)
-        end
-      end
-
-      class CompileReps
-        def initialize(outdatedness_store:, dependency_store:, action_provider:, compilation_context:, compiled_content_cache:)
-          @outdatedness_store = outdatedness_store
-          @dependency_store = dependency_store
-          @action_provider = action_provider
-          @compilation_context = compilation_context
-          @compiled_content_cache = compiled_content_cache
-        end
-
-        def run
-          selector = Nanoc::Int::ItemRepSelector.new(@outdatedness_store.to_a)
-          selector.each do |rep|
-            handle_errors_while(rep) { compile_rep(rep, is_outdated: @outdatedness_store.include?(rep)) }
-          end
-        ensure
-          @outdatedness_store.store
-          @compiled_content_cache.store
-        end
-
-        private
-
-        def handle_errors_while(item_rep)
-          yield
-        rescue => e
-          raise Nanoc::Int::Errors::CompilationError.new(e, item_rep)
-        end
-
-        def compile_rep(rep, is_outdated:)
-          item_rep_compiler.run(rep, is_outdated: is_outdated)
-        end
-
-        def item_rep_compiler
-          @_item_rep_compiler ||= begin
-            recalculate_phase = Phases::Recalculate.new(
-              action_provider: @action_provider,
-              dependency_store: @dependency_store,
-              compilation_context: @compilation_context,
-            )
-
-            cache_phase = Phases::Cache.new(
-              compiled_content_cache: @compiled_content_cache,
-              snapshot_repo: @compilation_context.snapshot_repo,
-              wrapped: recalculate_phase,
-            )
-
-            resume_phase = Phases::Resume.new(
-              wrapped: cache_phase,
-            )
-
-            write_phase = Phases::Write.new(
-              snapshot_repo: @compilation_context.snapshot_repo,
-              wrapped: resume_phase,
-            )
-
-            mark_done_phase = Phases::MarkDone.new(
-              wrapped: write_phase,
-              outdatedness_store: @outdatedness_store,
-            )
-
-            mark_done_phase
-          end
-        end
-      end
-
-      class Cleanup
-        def initialize(config)
-          @config = config
-        end
-
-        def run
-          cleanup_temps(Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
-          cleanup_temps(Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
-          cleanup_unused_stores
-        end
-
-        private
-
-        def cleanup_temps(dir)
-          Nanoc::Int::TempFilenameFactory.instance.cleanup(dir)
-        end
-
-        def cleanup_unused_stores
-          used_paths = @config.output_dirs.map { |d| Nanoc::Int::Store.tmp_path_prefix(d) }
-          all_paths = Dir.glob('tmp/nanoc/*')
-          (all_paths - used_paths).each do |obsolete_path|
-            FileUtils.rm_rf(obsolete_path)
-          end
-        end
-      end
-    end
-
     include Nanoc::Int::ContractsSupport
 
     # @api private
@@ -431,7 +128,7 @@ module Nanoc::Int
       determine_outdatedness
       forget_dependencies_if_needed
       store
-      compile_reps
+      compile_reps_stage.run
       store_output_state
       @action_provider.postprocess(@site, @reps)
     ensure
@@ -530,10 +227,6 @@ module Nanoc::Int
       @outdated_items.each { |i| @dependency_store.forget_dependencies_for(i) }
     end
 
-    def compile_reps
-      compile_reps_stage.run
-    end
-
     # Returns all stores that can load/store data that can be used for
     # compilation.
     def stores

data/lib/nanoc/base/services/item_rep_selector.rb

@@ -7,18 +7,24 @@ module Nanoc::Int
       @reps = reps
     end
 
+    NONE = Object.new
+
     def each
       graph = Nanoc::Int::DirectedGraph.new(@reps)
 
+      prio_dependent = Set.new
+      prio_in_progress = Set.new
       loop do
-        break if graph.roots.empty?
-        rep = graph.roots.each { |e| break e }
+        rep = find(graph, prio_dependent, prio_in_progress)
+        break if NONE.equal?(rep)
 
         begin
+          prio_in_progress << rep
           yield(rep)
+          prio_in_progress.delete(rep)
           graph.delete_vertex(rep)
         rescue => e
-          handle_error(e, rep, graph)
+          handle_error(e, rep, graph, prio_dependent)
         end
       end
 
@@ -28,7 +34,32 @@ module Nanoc::Int
       end
     end
 
-    def handle_error(e, rep, graph)
+    def find(graph, prio_dependent, prio_in_progress)
+      if graph.roots.empty?
+        NONE
+      elsif prio_dependent.any?
+        find_prio(graph, prio_dependent, prio_dependent, prio_in_progress)
+      elsif prio_in_progress.any?
+        find_prio(graph, prio_in_progress, prio_dependent, prio_in_progress)
+      else
+        graph.roots.each { |e| break e }
+      end
+    end
+
+    def find_prio(graph, prio, prio_dependent, prio_in_progress)
+      until prio.empty?
+        rep = prio.each { |e| break e }
+        if graph.roots.include?(rep)
+          return rep
+        else
+          prio.delete(rep)
+        end
+      end
+
+      find(graph, prio_dependent, prio_in_progress)
+    end
+
+    def handle_error(e, rep, graph, prio_dependent)
       actual_error =
         if e.is_a?(Nanoc::Int::Errors::CompilationError)
           e.unwrap
@@ -37,14 +68,15 @@ module Nanoc::Int
         end
 
       if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency)
-        handle_dependency_error(actual_error, rep, graph)
+        handle_dependency_error(actual_error, rep, graph, prio_dependent)
       else
         raise(e)
       end
     end
 
-    def handle_dependency_error(e, rep, graph)
+    def handle_dependency_error(e, rep, graph, prio_dependent)
       other_rep = e.rep
+      prio_dependent << other_rep
       graph.add_edge(other_rep, rep)
       unless graph.vertices.include?(other_rep)
         graph.add_vertex(other_rep)

data/lib/nanoc/base/services.rb

@@ -15,4 +15,7 @@ require_relative 'services/temp_filename_factory'
 require_relative 'services/outdatedness_rule'
 require_relative 'services/outdatedness_rules'
 
+require_relative 'services/compiler/phases'
+require_relative 'services/compiler/stages'
+
 require_relative 'services/outdatedness_checker'

data/lib/nanoc/cli/commands/compile.rb

@@ -211,10 +211,26 @@ module Nanoc::CLI::Commands
 
       protected
 
+      def profiling_table
+        headers = ['', 'count', 'min', 'avg', 'max', 'tot']
+
+        rows = durations_per_filter.to_a.sort_by { |r| r[1] }.map do |row|
+          filter_name, samples = *row
+          count = samples.size
+          min   = samples.min
+          tot   = samples.reduce(0, &:+)
+          avg   = tot / count
+          max   = samples.max
+
+          [filter_name.to_s, count.to_s] + [min, avg, max, tot].map { |r| "#{format('%4.2f', r)}s" }
+        end
+
+        [headers] + rows
+      end
+
       def print_profiling_feedback
         # Get max filter length
-        max_filter_name_length = durations_per_filter.keys.map { |k| k.to_s.size }.max
-        return if max_filter_name_length.nil?
+        return if durations_per_filter.empty?
 
         # Print warning if necessary
         if @reps.any? { |r| !r.compiled? }
@@ -223,37 +239,24 @@ module Nanoc::CLI::Commands
                        'some items were not compiled.'
         end
 
-        # Print header
         puts
-        puts ' ' * max_filter_name_length + ' | count    min    avg    max     tot'
-        puts '-' * max_filter_name_length + '-+-----------------------------------'
+        print_table profiling_table
+      end
 
-        durations_per_filter.to_a.sort_by { |r| r[1] }.each do |row|
-          print_row(row, max_filter_name_length)
-        end
+      def print_table(table)
+        lengths = table.transpose.map { |r| r.map(&:size).max }
+
+        print_row(table[0], lengths)
+
+        puts "#{'-' * lengths[0]}-+-#{lengths[1..-1].map { |length| '-' * length }.join('---')}"
+
+        table[1..-1].each { |row| print_row(row, lengths) }
       end
 
-      def print_row(row, length)
-        # Extract data
-        filter_name, samples = *row
-
-        # Calculate stats
-        count = samples.size
-        min   = samples.min
-        tot   = samples.reduce(0) { |acc, elem| acc + elem }
-        avg   = tot / count
-        max   = samples.max
-
-        # Format stats
-        count = format('%4d',   count)
-        min   = format('%4.2f', min)
-        avg   = format('%4.2f', avg)
-        max   = format('%4.2f', max)
-        tot   = format('%5.2f', tot)
-
-        # Output stats
-        key = format("%#{length}s", filter_name)
-        puts "#{key} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
+      def print_row(row, lengths)
+        values = row.zip(lengths).map { |text, length| text.rjust length }
+
+        puts values[0] + ' | ' + values[1..-1].join('   ')
       end
 
       def durations_per_filter

data/lib/nanoc/data_sources/filesystem.rb

@@ -164,7 +164,7 @@ module Nanoc::DataSources
             content,
             attributes,
             identifier,
-            content_checksum_data: proto_doc.content_checksum_data,
+            content_checksum_data: content_checksum_data_for(proto_doc),
             attributes_checksum_data: attributes_checksum_data_for(proto_doc, content_filename, meta_filename),
           )
         end
@@ -173,10 +173,18 @@ module Nanoc::DataSources
       res
     end
 
+    def content_checksum_data_for(proto_doc)
+      Digest::SHA1.digest(
+        proto_doc.content_checksum_data || '',
+      )
+    end
+
     def attributes_checksum_data_for(proto_doc, content_filename, meta_filename)
-      YAML.dump(
-        attributes: proto_doc.attributes_checksum_data,
-        extra_attributes: extra_attributes_for(content_filename, meta_filename),
+      Digest::SHA1.digest(
+        YAML.dump(
+          attributes: proto_doc.attributes_checksum_data,
+          extra_attributes: extra_attributes_for(content_filename, meta_filename),
+        ),
       )
     end
 

data/lib/nanoc/version.rb

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

data/spec/nanoc/base/compiler_spec.rb

@@ -76,83 +76,6 @@ describe Nanoc::Int::Compiler do
     allow(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
   end
 
-  describe '#compile_reps' do
-    subject do
-      compiler.send(:determine_outdatedness)
-      compiler.send(:compile_reps)
-    end
-
-    before do
-      allow(action_provider).to receive(:snapshots_defs_for).with(rep).and_return(snapshot_defs_for_rep)
-      allow(action_provider).to receive(:snapshots_defs_for).with(other_rep).and_return(snapshot_defs_for_rep)
-    end
-
-    let(:snapshot_defs_for_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last)]
-    end
-
-    let(:snapshot_defs_for_other_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last)]
-    end
-
-    it 'compiles individual reps' do
-      expect { subject }.to change { compiler.snapshot_repo.get(rep, :last) }
-        .from(nil)
-        .to(some_textual_content('3'))
-    end
-
-    it 'removes the item rep from the outdatedness store' do
-      expect(compiler.outdatedness_store.include?(rep)).not_to be
-      expect { subject }.not_to change { compiler.outdatedness_store.include?(rep) }
-    end
-
-    context 'rep in outdatedness store' do
-      before do
-        compiler.outdatedness_store.add(rep)
-      end
-
-      it 'removes the item rep from the outdatedness store' do
-        expect { subject }.to change { compiler.outdatedness_store.include?(rep) }.from(true).to(false)
-      end
-    end
-
-    context 'exception' do
-      let(:item) { Nanoc::Int::Item.new('<%= raise "lol" %>', {}, '/hi.md') }
-
-      it 'wraps exception' do
-        expect { subject }.to raise_error(Nanoc::Int::Errors::CompilationError)
-      end
-
-      it 'contains the right item rep in the wrapped exception' do
-        expect { subject }.to raise_error do |err|
-          expect(err.item_rep).to eql(rep)
-        end
-      end
-
-      it 'contains the right wrapped exception' do
-        expect { subject }.to raise_error do |err|
-          expect(err.unwrap).to be_a(RuntimeError)
-          expect(err.unwrap.message).to eq('lol')
-        end
-      end
-
-      it 'adds the item rep to the outdatedness store' do
-        expect { subject rescue nil }.to change { compiler.outdatedness_store.include?(rep) }.from(false).to(true)
-      end
-
-      context 'rep in outdatedness store' do
-        before do
-          compiler.outdatedness_store.add(rep)
-        end
-
-        it 'keeps the item rep in the outdatedness store' do
-          expect(compiler.outdatedness_store.include?(rep)).to be
-          expect { subject rescue nil }.not_to change { compiler.outdatedness_store.include?(rep) }
-        end
-      end
-    end
-  end
-
   describe '#compile_rep' do
     let(:stage) { compiler.send(:compile_reps_stage) }
 

data/spec/nanoc/base/services/compiler/stages/cleanup_spec.rb

@@ -8,7 +8,71 @@ describe Nanoc::Int::Compiler::Stages::Cleanup do
   describe '#run' do
     subject { stage.run }
 
-    example do
+    it 'removes temporary binary items' do
+      a = Nanoc::Int::TempFilenameFactory.instance.create(Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
+      File.write(a, 'hello there')
+
+      expect { subject }
+        .to change { File.file?(a) }
+        .from(true).to(false)
+    end
+
+    it 'removes temporary textual items' do
+      a = Nanoc::Int::TempFilenameFactory.instance.create(Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR)
+      File.write(a, 'hello there')
+
+      expect { subject }
+        .to change { File.file?(a) }
+        .from(true).to(false)
+    end
+
+    shared_examples 'an old store' do
+      it 'removes the old store' do
+        FileUtils.mkdir_p('tmp')
+        File.write('tmp/' + store_name, 'stuff')
+
+        expect { subject }
+          .to change { File.file?('tmp/' + store_name) }
+          .from(true).to(false)
+      end
+    end
+
+    context 'tmp/checksums' do
+      let(:store_name) { 'checksums' }
+      it_behaves_like 'an old store'
+    end
+
+    context 'tmp/compiled_content' do
+      let(:store_name) { 'compiled_content' }
+      it_behaves_like 'an old store'
+    end
+
+    context 'tmp/dependencies' do
+      let(:store_name) { 'dependencies' }
+      it_behaves_like 'an old store'
+    end
+
+    context 'tmp/outdatedness' do
+      let(:store_name) { 'outdatedness' }
+      it_behaves_like 'an old store'
+    end
+
+    context 'tmp/rule_memory' do
+      let(:store_name) { 'rule_memory' }
+      it_behaves_like 'an old store'
+    end
+
+    context 'tmp/somethingelse' do
+      it 'does not removes the store' do
+        FileUtils.mkdir_p('tmp')
+        File.write('tmp/somethingelse', 'stuff')
+
+        expect { subject }
+          .not_to change { File.file?('tmp/somethingelse') }
+      end
+    end
+
+    it 'removes stores for unused output paths' do
       FileUtils.mkdir_p('tmp/nanoc/2f0692fb1a1d')
       FileUtils.mkdir_p('tmp/nanoc/1a2195bfef6c')
       FileUtils.mkdir_p('tmp/nanoc/1029d67644815')