nanoc 4.0.2 → 4.1.0a1

data/lib/nanoc/base/compilation/compiler_dsl.rb

@@ -50,8 +50,7 @@ module Nanoc::Int
     # @param [String] identifier A pattern matching identifiers of items that
     #   should be compiled using this rule
     #
-    # @option params [Symbol] :rep (:default) The name of the representation
-    #   that should be compiled using this rule
+    # @param [Symbol] rep The name of the representation
     #
     # @yield The block that will be executed when an item matching this
     #   compilation rule needs to be compiled
@@ -69,15 +68,10 @@ module Nanoc::Int
     #     compile '/bar/', :rep => :raw do
     #       # do nothing
     #     end
-    def compile(identifier, params = {}, &block)
-      # Require block
+    def compile(identifier, rep: :default, &block)
       raise ArgumentError.new('#compile requires a block') unless block_given?
 
-      # Get rep name
-      rep_name = params[:rep] || :default
-
-      # Create rule
-      rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, block)
+      rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, block)
       @rules_collection.add_item_compilation_rule(rule)
     end
 
@@ -94,8 +88,7 @@ module Nanoc::Int
     # @param [String] identifier A pattern matching identifiers of items that
     #   should be routed using this rule
     #
-    # @option params [Symbol] :rep (:default) The name of the representation
-    #   that should be routed using this rule
+    # @param [Symbol] :rep The name of the representation
     #
     # @yield The block that will be executed when an item matching this
     #   compilation rule needs to be routed
@@ -113,16 +106,10 @@ module Nanoc::Int
     #     route '/bar/', :rep => :raw do
     #       '/raw' + item.identifier + 'index.txt'
     #     end
-    def route(identifier, params = {}, &block)
-      # Require block
+    def route(identifier, rep: :default, snapshot: :last, &block)
       raise ArgumentError.new('#route requires a block') unless block_given?
 
-      # Get rep name
-      rep_name      = params[:rep] || :default
-      snapshot_name = params[:snapshot] || :last
-
-      # Create rule
-      rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, block, snapshot_name: snapshot_name)
+      rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, block, snapshot_name: snapshot)
       @rules_collection.add_item_routing_rule(rule)
     end
 
@@ -166,8 +153,7 @@ module Nanoc::Int
     # @param [String] identifier A pattern matching identifiers of items that
     #   should be processed using this meta-rule
     #
-    # @option params [Symbol] :rep (:default) The name of the representation
-    #   that should be routed using this rule
+    # @param [Symbol] rep The name of the representation
     #
     # @return [void]
     #
@@ -180,16 +166,11 @@ module Nanoc::Int
     # @example Copying the `:raw` rep of the `/bar/` item as-is
     #
     #     passthrough '/bar/', :rep => :raw
-    def passthrough(identifier, params = {})
-      # Require no block
+    def passthrough(identifier, rep: :default)
       raise ArgumentError.new('#passthrough does not require a block') if block_given?
 
-      # Get rep name
-      rep_name = params[:rep] || :default
-
-      # Create compilation rule
       compilation_block = proc {}
-      compilation_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, compilation_block)
+      compilation_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, compilation_block)
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
       # Create routing rule
@@ -204,7 +185,7 @@ module Nanoc::Int
           item[:extension].nil? || (item[:content_filename].nil? && item.identifier =~ %r{#{item[:extension]}/$}) ? item.identifier.chop : item.identifier.chop + '.' + item[:extension]
         end
       end
-      routing_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, routing_block, snapshot_name: :last)
+      routing_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, routing_block, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 
@@ -219,23 +200,20 @@ module Nanoc::Int
     # @param [String] identifier A pattern matching identifiers of items that
     #   should be processed using this meta-rule
     #
-    # @option params [Symbol] :rep (:default) The name of the representation
-    #   that should be routed using this rule
+    # @param [Symbol] rep The name of the representation
     #
     # @return [void]
     #
     # @example Suppressing compilation and output for all all `/foo/*` items.
     #
     #     ignore '/foo/*'
-    def ignore(identifier, params = {})
+    def ignore(identifier, rep: :default)
       raise ArgumentError.new('#ignore does not require a block') if block_given?
 
-      rep_name = params[:rep] || :default
-
-      compilation_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, proc {})
+      compilation_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, proc {})
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
-      routing_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep_name, proc {}, snapshot_name: :last)
+      routing_rule = Nanoc::Int::Rule.new(create_pattern(identifier), rep, proc {}, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 
@@ -255,7 +233,21 @@ module Nanoc::Int
       filename = ["#{name}", "#{name}.rb", "./#{name}", "./#{name}.rb"].find { |f| File.file?(f) }
       raise Nanoc::Int::Errors::NoRulesFileFound.new if filename.nil?
 
-      @rules_collection.parse(filename)
+      Nanoc::Int::RulesLoader.new(@config, @rules_collection).parse(filename)
+    end
+
+    # Creates a postprocessor block that will be executed after all data is
+    # loaded and the site is compiled.
+    #
+    # @yield The block that will be executed after site compilation completes
+    #
+    # @return [void]
+    def postprocess(&block)
+      if @rules_collection.postprocessors[rules_filename]
+        warn 'WARNING: A postprocess block is already defined. Defining ' \
+          'another postprocess block overrides the previously one.'
+      end
+      @rules_collection.postprocessors[rules_filename] = block
     end
 
     # @api private

data/lib/nanoc/base/compilation/dependency_tracker.rb

@@ -1,193 +1,48 @@
 module Nanoc::Int
-  # Responsible for remembering dependencies between items and layouts. It is
-  # used to speed up compilation by only letting an item be recompiled when it
-  # is outdated or any of its dependencies (or dependencies’ dependencies,
-  # etc) is outdated.
-  #
-  # The dependencies tracked by the dependency tracker are not dependencies
-  # based on an item’s or a layout’s content. When one object uses an
-  # attribute of another object, then this is also treated as a dependency.
-  # While dependencies based on an item’s or layout’s content (handled in
-  # {Nanoc::Int::Compiler}) cannot be mutually recursive, the more general
-  # dependencies in Nanoc::Int::DependencyTracker can (e.g. item A can use an
-  # attribute of item B and vice versa without problems).
-  #
-  # The dependency tracker remembers the dependency information between runs.
-  # Dependency information is stored in the `tmp/dependencies` file.
-  #
   # @api private
-  class DependencyTracker < ::Nanoc::Int::Store
-    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] The list of items and
-    #   layouts that are being tracked by the dependency tracker
-    attr_reader :objects
-
-    # @return [Nanoc::Int::Compiler] The compiler that corresponds to this
-    #   dependency tracker
-    attr_accessor :compiler
-
-    # Creates a new dependency tracker for the given items and layouts.
-    #
-    # @param [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] objects The list of items
-    #   and layouts whose dependencies should be managed
-    def initialize(objects)
-      super('tmp/dependencies', 4)
-
-      @objects = objects
-      @graph   = Nanoc::Int::DirectedGraph.new([nil] + @objects)
-      @stack   = []
+  class DependencyTracker
+    def initialize(dependency_store)
+      @dependency_store = dependency_store
     end
 
-    # Starts listening for dependency messages (`:visit_started` and
-    # `:visit_ended`) and start recording dependencies.
+    # Record dependencies for the duration of the block.
     #
     # @return [void]
-    def start
-      # Initialize dependency stack. An object will be pushed onto this stack
-      # when it is visited. Therefore, an object on the stack always depends
-      # on all objects pushed above it.
-      @stack = []
+    def run
+      unless block_given?
+        raise ArgumentError, 'No block given'
+      end
+
+      stack = []
+      start_tracking(stack)
+      yield
+    ensure
+      stop_tracking(stack)
+    end
 
-      # Register start of visits
+    # @api private
+    def start_tracking(stack)
       Nanoc::Int::NotificationCenter.on(:visit_started, self) do |obj|
-        unless @stack.empty?
-          Nanoc::Int::NotificationCenter.post(:dependency_created, @stack.last, obj)
-          record_dependency(@stack.last, obj)
+        unless stack.empty?
+          Nanoc::Int::NotificationCenter.post(:dependency_created, stack.last, obj)
+          @dependency_store.record_dependency(stack.last, obj)
         end
-        @stack.push(obj)
+        stack.push(obj)
       end
 
-      # Register end of visits
       Nanoc::Int::NotificationCenter.on(:visit_ended, self) do |_obj|
-        @stack.pop
+        stack.pop
       end
     end
 
-    # Stop listening for dependency messages and stop recording dependencies.
-    #
-    # @return [void]
-    def stop
-      # Sanity check
-      unless @stack.empty?
+    # @api private
+    def stop_tracking(stack)
+      unless stack.empty?
         raise 'Internal inconsistency: dependency tracker stack not empty at end of compilation'
       end
 
-      # Unregister
       Nanoc::Int::NotificationCenter.remove(:visit_started, self)
       Nanoc::Int::NotificationCenter.remove(:visit_ended,   self)
     end
-
-    # @return The topmost item on the stack, i.e. the one currently being
-    #   compiled
-    def top
-      @stack.last
-    end
-
-    # Returns the direct dependencies for the given object.
-    #
-    # The direct dependencies of the given object include the items and
-    # layouts that, when outdated will cause the given object to be marked as
-    # outdated. Indirect dependencies will not be returned (e.g. if A depends
-    # on B which depends on C, then the direct dependencies of A do not
-    # include C).
-    #
-    # The direct predecessors can include nil, which indicates an item that is
-    # no longer present in the site.
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for
-    #   which to fetch the direct predecessors
-    #
-    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout, nil>] The direct
-    # predecessors of
-    #   the given object
-    def objects_causing_outdatedness_of(object)
-      @graph.direct_predecessors_of(object)
-    end
-
-    # Returns the direct inverse dependencies for the given object.
-    #
-    # The direct inverse dependencies of the given object include the objects
-    # that will be marked as outdated when the given object is outdated.
-    # Indirect dependencies will not be returned (e.g. if A depends on B which
-    # depends on C, then the direct inverse dependencies of C do not include
-    # A).
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for which to
-    #   fetch the direct successors
-    #
-    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] The direct successors of
-    #   the given object
-    def objects_outdated_due_to(object)
-      @graph.direct_successors_of(object).compact
-    end
-
-    # Records a dependency from `src` to `dst` in the dependency graph. When
-    # `dst` is oudated, `src` will also become outdated.
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] src The source of the dependency,
-    #   i.e. the object that will become outdated if dst is outdated
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] dst The destination of the
-    #   dependency, i.e. the object that will cause the source to become
-    #   outdated if the destination is outdated
-    #
-    # @return [void]
-    def record_dependency(src, dst)
-      # Warning! dst and src are *reversed* here!
-      @graph.add_edge(dst, src) unless src == dst
-    end
-
-    # Empties the list of dependencies for the given object. This is necessary
-    # before recompiling the given object, because otherwise old dependencies
-    # will stick around and new dependencies will appear twice. This function
-    # removes all incoming edges for the given vertex.
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for which to
-    #   forget all dependencies
-    #
-    # @return [void]
-    def forget_dependencies_for(object)
-      @graph.delete_edges_to(object)
-    end
-
-    # @see Nanoc::Int::Store#unload
-    def unload
-      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
-    end
-
-    protected
-
-    def data
-      {
-        edges: @graph.edges,
-        vertices: @graph.vertices.map { |obj| obj && obj.reference },
-      }
-    end
-
-    def data=(new_data)
-      # Create new graph
-      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
-
-      # Load vertices
-      previous_objects = new_data[:vertices].map do |reference|
-        @objects.find { |obj| reference == obj.reference }
-      end
-
-      # Load edges
-      new_data[:edges].each do |edge|
-        from_index, to_index = *edge
-        from = from_index && previous_objects[from_index]
-        to   = to_index && previous_objects[to_index]
-        @graph.add_edge(from, to)
-      end
-
-      # Record dependency from all items on new items
-      new_objects = (@objects - previous_objects)
-      new_objects.each do |new_obj|
-        @objects.each do |obj|
-          next unless obj.is_a?(Nanoc::Int::Item)
-          @graph.add_edge(new_obj, obj)
-        end
-      end
-    end
   end
 end

data/lib/nanoc/base/compilation/filter.rb

@@ -181,11 +181,10 @@ module Nanoc
     # the given collection of items. In other words, require the given items
     # to be compiled first before this items is processed.
     #
-    # @param [Array<Nanoc::Int::Item>] items The items that are depended on.
-    #
     # @return [void]
     def depend_on(items)
-      items = items.map { |i| i.unwrap rescue i }
+      orig_items = items
+      items = items.map { |i| i.is_a?(Nanoc::ItemView) ? i.unwrap : i }
 
       # Notify
       items.each do |item|
@@ -195,7 +194,7 @@ module Nanoc
 
       # Raise unmet dependency error if necessary
       items.each do |item|
-        rep = item.reps.find { |r| !r.compiled? }
+        rep = orig_items.sample._context.reps[item].find { |r| !r.compiled? }
         raise Nanoc::Int::Errors::UnmetDependency.new(rep) if rep
       end
     end

data/lib/nanoc/base/compilation/item_rep_repo.rb

@@ -0,0 +1,33 @@
+module Nanoc::Int
+  # Stores item reps (in memory).
+  #
+  # @api private
+  class ItemRepRepo
+    include Enumerable
+
+    def initialize
+      @reps = []
+      @reps_by_item = {}
+    end
+
+    def <<(rep)
+      @reps << rep
+
+      @reps_by_item[rep.item] ||= []
+      @reps_by_item[rep.item] << rep
+    end
+
+    def to_a
+      @reps
+    end
+
+    def each(&block)
+      @reps.each(&block)
+      self
+    end
+
+    def [](item)
+      @reps_by_item.fetch(item, [])
+    end
+  end
+end

data/lib/nanoc/base/compilation/outdatedness_checker.rb

@@ -5,24 +5,30 @@ module Nanoc::Int
   class OutdatednessChecker
     extend Nanoc::Int::Memoization
 
-    # @option params [Nanoc::Int::Site] :site (nil) The site this outdatedness
-    #   checker belongs to.
-    #
-    # @option params [Nanoc::Int::ChecksumStore] :checksum_store (nil) The
-    #   checksum store where checksums of items, layouts, … are stored.
-    #
-    # @option params [Nanoc::Int::DependencyTracker] :dependency_tracker (nil) The
-    #   dependency tracker for the given site.
-    def initialize(params = {})
-      @site = params.fetch(:site) do
-        raise ArgumentError, 'Nanoc::Int::OutdatednessChecker#initialize needs a :site parameter'
-      end
-      @checksum_store = params.fetch(:checksum_store) do
-        raise ArgumentError, 'Nanoc::Int::OutdatednessChecker#initialize needs a :checksum_store parameter'
-      end
-      @dependency_tracker = params.fetch(:dependency_tracker) do
-        raise ArgumentError, 'Nanoc::Int::OutdatednessChecker#initialize needs a :dependency_tracker parameter'
-      end
+    attr_reader :checksum_store
+    attr_reader :dependency_store
+    attr_reader :rule_memory_calculator
+    attr_reader :rule_memory_store
+    attr_reader :rules_collection
+    attr_reader :site
+
+    Reasons = Nanoc::Int::OutdatednessReasons
+
+    # @param [Nanoc::Int::Site] site
+    # @param [Nanoc::Int::ChecksumStore] checksum_store
+    # @param [Nanoc::Int::DependencyStore] dependency_store
+    # @param [Nanoc::Int::RulesCollection] rules_collection
+    # @param [Nanoc::Int::RuleMemoryStore] rule_memory_store
+    # @param [Nanoc::Int::RuleMemoryCalculator] rule_memory_calculator
+    # @param [Nanoc::Int::ItemRepRepo] reps
+    def initialize(site:, checksum_store:, dependency_store:, rules_collection:, rule_memory_store:, rule_memory_calculator:, reps:)
+      @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 = reps
 
       @basic_outdatedness_reasons = {}
       @outdatedness_reasons = {}
@@ -45,12 +51,12 @@ module Nanoc::Int
     # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object
     #   whose outdatedness reason should be calculated.
     #
-    # @return [Nanoc::Int::OutdatednessReasons::Generic, nil] The reason why the
+    # @return [Reasons::Generic, nil] The reason why the
     #   given object is outdated, or nil if the object is not outdated.
     def outdatedness_reason_for(obj)
       reason = basic_outdatedness_reason_for(obj)
       if reason.nil? && outdated_due_to_dependencies?(obj)
-        reason = Nanoc::Int::OutdatednessReasons::DependenciesOutdated
+        reason = Reasons::DependenciesOutdated
       end
       reason
     end
@@ -78,42 +84,42 @@ module Nanoc::Int
     # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object
     #   whose outdatedness reason should be calculated.
     #
-    # @return [Nanoc::Int::OutdatednessReasons::Generic, nil] The reason why the
+    # @return [Reasons::Generic, nil] The reason why the
     #   given object is outdated, or nil if the object is not outdated.
     def basic_outdatedness_reason_for(obj)
       case obj
       when Nanoc::Int::ItemRep
         # Outdated if rules outdated
-        return Nanoc::Int::OutdatednessReasons::RulesModified if
+        return Reasons::RulesModified if
           rule_memory_differs_for(obj)
 
         # Outdated if checksums are missing or different
-        return Nanoc::Int::OutdatednessReasons::NotEnoughData unless checksums_available?(obj.item)
-        return Nanoc::Int::OutdatednessReasons::SourceModified unless checksums_identical?(obj.item)
+        return Reasons::NotEnoughData unless checksums_available?(obj.item)
+        return Reasons::SourceModified unless checksums_identical?(obj.item)
 
         # Outdated if compiled file doesn't exist (yet)
-        return Nanoc::Int::OutdatednessReasons::NotWritten if obj.raw_path && !File.file?(obj.raw_path)
+        return Reasons::NotWritten if obj.raw_path && !File.file?(obj.raw_path)
 
         # Outdated if code snippets outdated
-        return Nanoc::Int::OutdatednessReasons::CodeSnippetsModified if site.code_snippets.any? do |cs|
+        return Reasons::CodeSnippetsModified if site.code_snippets.any? do |cs|
           object_modified?(cs)
         end
 
         # Outdated if configuration outdated
-        return Nanoc::Int::OutdatednessReasons::ConfigurationModified if object_modified?(site.config)
+        return Reasons::ConfigurationModified if object_modified?(site.config)
 
         # Not outdated
         return nil
       when Nanoc::Int::Item
-        obj.reps.find { |rep| basic_outdatedness_reason_for(rep) }
+        @reps[obj].find { |rep| basic_outdatedness_reason_for(rep) }
       when Nanoc::Int::Layout
         # Outdated if rules outdated
-        return Nanoc::Int::OutdatednessReasons::RulesModified if
+        return Reasons::RulesModified if
           rule_memory_differs_for(obj)
 
         # Outdated if checksums are missing or different
-        return Nanoc::Int::OutdatednessReasons::NotEnoughData unless checksums_available?(obj)
-        return Nanoc::Int::OutdatednessReasons::SourceModified unless checksums_identical?(obj)
+        return Reasons::NotEnoughData unless checksums_available?(obj)
+        return Reasons::SourceModified unless checksums_identical?(obj)
 
         # Not outdated
         return nil
@@ -149,7 +155,7 @@ module Nanoc::Int
       return false if processed.include?(obj)
 
       # Calculate
-      is_outdated = dependency_tracker.objects_causing_outdatedness_of(obj).any? do |other|
+      is_outdated = dependency_store.objects_causing_outdatedness_of(obj).any? do |other|
         other.nil? || basic_outdated?(other) || outdated_due_to_dependencies?(other, processed.merge([obj]))
       end
 
@@ -166,7 +172,7 @@ module Nanoc::Int
     # @return [Boolean] true if the rule memory for the given item
     #   represenation has changed, false otherwise
     def rule_memory_differs_for(obj)
-      rules_collection.rule_memory_differs_for(obj)
+      !rule_memory_store[obj].eql?(rule_memory_calculator[obj].serialize)
     end
     memoize :rule_memory_differs_for
 
@@ -196,25 +202,5 @@ module Nanoc::Int
       !checksums_available?(obj) || !checksums_identical?(obj)
     end
     memoize :object_modified?
-
-    # @return [Nanoc::Int::ChecksumStore] The checksum store
-    def checksum_store
-      @checksum_store
-    end
-
-    # @return [Nanoc::Int::RulesCollection] The rules collection
-    def rules_collection
-      site.compiler.rules_collection
-    end
-
-    # @return [Nanoc::Int::DependencyTracker] The dependency tracker
-    def dependency_tracker
-      @dependency_tracker
-    end
-
-    # @return [Nanoc::Int::Site] The site
-    def site
-      @site
-    end
   end
 end