nanoc 4.0.2 → 4.1.0a1

data/lib/nanoc/base/services.rb

@@ -1,5 +1,13 @@
+require_relative 'services/compiler_loader'
 require_relative 'services/executor'
+require_relative 'services/item_rep_builder'
+require_relative 'services/item_rep_router'
+require_relative 'services/item_rep_selector'
 require_relative 'services/item_rep_writer'
 require_relative 'services/notification_center'
+require_relative 'services/preprocessor'
+require_relative 'services/postprocessor'
 require_relative 'services/recording_executor'
+require_relative 'services/rule_memory_calculator'
+require_relative 'services/rules_loader'
 require_relative 'services/temp_filename_factory'

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

@@ -0,0 +1,49 @@
+module Nanoc::Int
+  # @api private
+  class CompilerLoader
+    def load(site)
+      rules_collection = Nanoc::Int::RulesCollection.new
+
+      rule_memory_store = Nanoc::Int::RuleMemoryStore.new
+
+      rule_memory_calculator =
+        Nanoc::Int::RuleMemoryCalculator.new(
+          rules_collection: rules_collection, site: site)
+
+      dependency_store =
+        Nanoc::Int::DependencyStore.new(site.items.to_a + site.layouts.to_a)
+
+      checksum_store =
+        Nanoc::Int::ChecksumStore.new(site: site)
+
+      item_rep_repo = Nanoc::Int::ItemRepRepo.new
+
+      outdatedness_checker =
+        Nanoc::Int::OutdatednessChecker.new(
+          site: site,
+          checksum_store: checksum_store,
+          dependency_store: dependency_store,
+          rules_collection: rules_collection,
+          rule_memory_store: rule_memory_store,
+          rule_memory_calculator: rule_memory_calculator,
+          reps: item_rep_repo,
+        )
+
+      params = {
+        compiled_content_cache: Nanoc::Int::CompiledContentCache.new,
+        checksum_store: checksum_store,
+        rule_memory_store: rule_memory_store,
+        rule_memory_calculator: rule_memory_calculator,
+        dependency_store: dependency_store,
+        outdatedness_checker: outdatedness_checker,
+        reps: item_rep_repo,
+      }
+
+      compiler = Nanoc::Int::Compiler.new(site, rules_collection, params)
+
+      Nanoc::Int::RulesLoader.new(site.config, rules_collection).load
+
+      compiler
+    end
+  end
+end

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

@@ -98,18 +98,18 @@ module Nanoc
         end
       end
 
-      def snapshot(rep, snapshot_name, params = {})
-        is_final = params.fetch(:final, true)
+      def snapshot(rep, snapshot_name, final: true, path: nil) # rubocop:disable Lint/UnusedMethodArgument
+        # NOTE: :path is irrelevant
 
         unless rep.binary?
           rep.snapshot_contents[snapshot_name] = rep.snapshot_contents[:last]
         end
 
-        if snapshot_name == :pre && is_final
+        if snapshot_name == :pre && final
           rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:pre, true)
         end
 
-        if is_final
+        if final
           raw_path = rep.raw_path(snapshot: snapshot_name)
           if raw_path
             ItemRepWriter.new.write(rep, raw_path)

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

@@ -0,0 +1,30 @@
+module Nanoc::Int
+  # @api private
+  class ItemRepBuilder
+    attr_reader :reps
+
+    def initialize(site, rules_collection, rule_memory_calculator, reps)
+      @site = site
+      @rules_collection = rules_collection
+      @rule_memory_calculator = rule_memory_calculator
+      @reps = reps
+    end
+
+    def run
+      @site.items.each do |item|
+        rep_names_for(item).each do |rep_name|
+          @reps << Nanoc::Int::ItemRep.new(item, rep_name)
+        end
+      end
+
+      Nanoc::Int::ItemRepRouter.new(@reps, @rule_memory_calculator, @site).run
+    end
+
+    def rep_names_for(item)
+      matching_rules = @rules_collection.item_compilation_rules_for(item)
+      raise Nanoc::Int::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?
+
+      matching_rules.map(&:rep_name).uniq
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Nanoc::Int
+  # Assigns paths to reps.
+  #
+  # @api private
+  class ItemRepRouter
+    class IdenticalRoutesError < ::Nanoc::Error
+      def initialize(output_path, rep_a, rep_b)
+        super("The item representations #{rep_a.inspect} and #{rep_b.inspect} are both routed to #{output_path}.")
+      end
+    end
+
+    # TODO: Replace rule_memory_calculator with { rep => rule_memory }
+    def initialize(reps, rule_memory_calculator, site)
+      @reps = reps
+      @rule_memory_calculator = rule_memory_calculator
+      @site = site
+    end
+
+    def run
+      paths_to_reps = {}
+      @reps.each do |rep|
+        mem = @rule_memory_calculator[rep]
+        mem.snapshot_actions.each do |snapshot_action|
+          route_rep(rep, snapshot_action, paths_to_reps)
+        end
+      end
+    end
+
+    def route_rep(rep, snapshot_action, paths_to_reps)
+      basic_path = snapshot_action.path
+      return if basic_path.nil?
+
+      # Check for duplicate paths
+      if paths_to_reps.key?(basic_path)
+        raise IdenticalRoutesError.new(basic_path, paths_to_reps[basic_path], rep)
+      else
+        paths_to_reps[basic_path] = rep
+      end
+
+      rep.raw_paths[snapshot_action.snapshot_name] = @site.config[:output_dir] + basic_path
+      rep.paths[snapshot_action.snapshot_name] = strip_index_filename(basic_path)
+    end
+
+    def strip_index_filename(basic_path)
+      @site.config[:index_filenames].each do |index_filename|
+        rep_path_ending = basic_path[-index_filename.length..-1]
+        next unless rep_path_ending == index_filename
+
+        return basic_path[0..-index_filename.length - 1]
+      end
+
+      basic_path
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Nanoc::Int
+  # Yields item reps to compile.
+  #
+  # @api private
+  class ItemRepSelector
+    def initialize(reps)
+      @reps = reps
+    end
+
+    def each
+      graph = Nanoc::Int::DirectedGraph.new(@reps)
+
+      loop do
+        break if graph.roots.empty?
+        rep = graph.roots.each { |e| break e }
+
+        begin
+          yield(rep)
+          graph.delete_vertex(rep)
+        rescue Nanoc::Int::Errors::UnmetDependency => e
+          handle_dependency_error(e, rep, graph)
+        end
+      end
+
+      # Check whether everything was compiled
+      unless graph.vertices.empty?
+        raise Nanoc::Int::Errors::RecursiveCompilation.new(graph.vertices)
+      end
+    end
+
+    def handle_dependency_error(e, rep, graph)
+      other_rep = e.rep
+      graph.add_edge(other_rep, rep)
+      unless graph.vertices.include?(other_rep)
+        graph.add_vertex(other_rep)
+      end
+    end
+  end
+end

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

@@ -28,6 +28,8 @@ module Nanoc::Int
       # Write
       FileUtils.cp(temp_path, raw_path) if is_modified
 
+      item_rep.modified = is_modified
+
       # Notify
       Nanoc::Int::NotificationCenter.post(
         :rep_written, item_rep, raw_path, is_created, is_modified)

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

@@ -0,0 +1,26 @@
+module Nanoc::Int
+  # @api private
+  class Postprocessor
+    def initialize(context, site:, rules_collection:)
+      @context = context
+      @site = site
+      @rules_collection = rules_collection
+    end
+
+    def run
+      ctx = new_postprocessor_context
+
+      @rules_collection.postprocessors.each_value do |postprocessor|
+        ctx.instance_eval(&postprocessor)
+      end
+    end
+
+    # @api private
+    def new_postprocessor_context
+      Nanoc::Int::Context.new(
+        config: Nanoc::ConfigView.new(@site.config, @context),
+        items: Nanoc::PostCompileItemCollectionView.new(@site.items, @context),
+      )
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Nanoc::Int
+  # @api private
+  class Preprocessor
+    def initialize(site:, rules_collection:)
+      @site = site
+      @rules_collection = rules_collection
+    end
+
+    def run
+      ctx = new_preprocessor_context
+
+      @rules_collection.preprocessors.each_value do |preprocessor|
+        ctx.instance_eval(&preprocessor)
+      end
+    end
+
+    # @api private
+    def new_preprocessor_context
+      Nanoc::Int::Context.new(
+        config: Nanoc::MutableConfigView.new(@site.config, nil),
+        items: Nanoc::MutableItemCollectionView.new(@site.items, nil),
+        layouts: Nanoc::MutableLayoutCollectionView.new(@site.layouts, nil),
+      )
+    end
+  end
+end

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

@@ -1,40 +1,54 @@
 module Nanoc
   module Int
     class RecordingExecutor
+      class NonFinalSnapshotWithPathError < ::Nanoc::Error
+        def initialize
+          super('This call to #snapshot specifies `final: false`, but it also specifies a path, which is an impossible combination.')
+        end
+      end
+
+      class PathWithoutInitialSlashError < ::Nanoc::Error
+        def initialize(rep, basic_path)
+          super("The path returned for the #{rep.inspect} item representation, “#{basic_path}”, does not start with a slash. Please ensure that all routing rules return a path that starts with a slash.")
+        end
+      end
+
       attr_reader :rule_memory
 
-      def initialize
-        @rule_memory = []
+      def initialize(item_rep, rules_collection, site)
+        @item_rep = item_rep
+        @rules_collection = rules_collection
+        @site = site
+
+        @rule_memory = Nanoc::Int::RuleMemory.new(item_rep)
       end
 
       def filter(_rep, filter_name, filter_args = {})
-        @rule_memory << [:filter, filter_name, filter_args]
+        @rule_memory.add_filter(filter_name, filter_args)
       end
 
-      def layout(_rep, layout_identifier, extra_filter_args = nil)
-        if extra_filter_args
-          @rule_memory << [:layout, layout_identifier, extra_filter_args]
-        else
-          @rule_memory << [:layout, layout_identifier]
-        end
+      def layout(_rep, layout_identifier, extra_filter_args = {})
+        @rule_memory.add_layout(layout_identifier, extra_filter_args)
       end
 
-      def snapshot(_rep, snapshot_name, params = {})
-        @rule_memory << [:snapshot, snapshot_name, params]
-
-        # Count
-        existing = Set.new
-        names = @rule_memory.select { |r| r[0] == :snapshot }.map { |r| r[1] }
-        names.each do |n|
-          if existing.include?(n)
-            raise Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName.new(@item_rep, snapshot_name)
-          end
-          existing << n
+      def snapshot(rep, snapshot_name, final: true, path: nil)
+        actual_path = path || basic_path_from_rules_for(rep, snapshot_name)
+        if !final && actual_path
+          raise NonFinalSnapshotWithPathError
         end
+        @rule_memory.add_snapshot(snapshot_name, final, actual_path)
       end
 
-      def record_write(_rep, path)
-        @rule_memory << [:write, path]
+      def basic_path_from_rules_for(rep, snapshot_name)
+        routing_rules = @rules_collection.routing_rules_for(rep)
+        routing_rule = routing_rules[snapshot_name]
+        return nil if routing_rule.nil?
+
+        basic_path = routing_rule.apply_to(rep, executor: nil, site: @site, view_context: nil)
+        if basic_path && !basic_path.start_with?('/')
+          raise PathWithoutInitialSlashError.new(rep, basic_path)
+        end
+        basic_path
       end
     end
   end

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

@@ -0,0 +1,84 @@
+module Nanoc::Int
+  # Calculates rule memories for objects that can be run through a rule (item
+  # representations and layouts).
+  #
+  # @api private
+  class RuleMemoryCalculator
+    extend Nanoc::Int::Memoization
+
+    class UnsupportedObjectTypeException < ::Nanoc::Error
+      def initialize(obj)
+        super("Do not know how to calculate the rule memory for #{obj.inspect}")
+      end
+    end
+
+    # @api private
+    attr_accessor :rules_collection
+
+    # @param [Nanoc::Int::Site] site
+    # @param [Nanoc::Int::RulesCollection] rules_collection
+    def initialize(site:, rules_collection:)
+      @site = site
+      @rules_collection = rules_collection
+    end
+
+    # @param [#reference] obj
+    #
+    # @return [Nanoc::Int::RuleMemory]
+    def [](obj)
+      case obj
+      when Nanoc::Int::ItemRep
+        new_rule_memory_for_rep(obj)
+      when Nanoc::Int::Layout
+        new_rule_memory_for_layout(obj)
+      else
+        raise UnsupportedObjectTypeException.new(obj)
+      end
+    end
+    memoize :[]
+
+    # @param [Nanoc::Int::ItemRep] rep The item representation for which to fetch
+    #   the list of snapshots
+    #
+    # @return [Array] A list of snapshots, represented as arrays where the
+    #   first element is the snapshot name (a Symbol) and the last element is
+    #   a Boolean indicating whether the snapshot is final or not
+    def snapshots_defs_for(rep)
+      self[rep].snapshot_actions.map do |a|
+        Nanoc::Int::SnapshotDef.new(a.snapshot_name, a.final?)
+      end
+    end
+
+    # @param [Nanoc::Int::ItemRep] rep The item representation to get the rule
+    #   memory for
+    #
+    # @return [Nanoc::Int::RuleMemory]
+    def new_rule_memory_for_rep(rep)
+      # FIXME: This is more-or-less duplicated from Compiler#recalculate_content_for_rep.
+      # Letting the compiler use the rule memory would fix this.
+
+      # FIXME: What if #compilation_rule_for returns nil?
+
+      executor = Nanoc::Int::RecordingExecutor.new(rep, @rules_collection, @site)
+      executor.snapshot(rep, :raw)
+      executor.snapshot(rep, :pre, final: false)
+      @rules_collection
+        .compilation_rule_for(rep)
+        .apply_to(rep, executor: executor, site: @site, view_context: nil)
+      executor.snapshot(rep, :post) if rep.has_snapshot?(:post)
+      executor.snapshot(rep, :last) unless executor.rule_memory.snapshot_actions.any? { |sa| sa.snapshot_name == :last }
+      executor.rule_memory
+    end
+
+    # @param [Nanoc::Int::Layout]
+    #
+    # @return [Nanoc::Int::RuleMemory]
+    def new_rule_memory_for_layout(layout)
+      res = @rules_collection.filter_for_layout(layout)
+      # FIXME: what if res is nil?
+      Nanoc::Int::RuleMemory.new(layout).tap do |rm|
+        rm.add_filter(res[0], res[1])
+      end
+    end
+  end
+end