nanoc3 3.2.0a3 → 3.2.0a4

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

@@ -5,16 +5,14 @@ module Nanoc3
   # Contains methods that will be executed by the site’s `Rules` file.
   class CompilerDSL
 
-    # @return [Nanoc3::Compiler] The compiler where this DSL belongs to.
-    attr_reader :compiler
-
-    # Creates a new compiler DSL for the given compiler.
+    # Creates a new compiler DSL for the given collection of rules.
     #
     # @api private
     #
-    # @param [Nanoc3::Site] site The site this DSL belongs to
-    def initialize(compiler)
-      @compiler = compiler
+    # @param [Nanoc3::RulesCollection] rules_collection The collection of rules
+    #   to modify when loading this DSL
+    def initialize(rules_collection)
+      @rules_collection = rules_collection
     end
 
     # Creates a preprocessor block that will be executed after all data is
@@ -24,7 +22,7 @@ module Nanoc3
     #
     # @return [void]
     def preprocess(&block)
-      compiler.preprocessor = block
+      @rules_collection.preprocessor = block
     end
 
     # Creates a compilation rule for all items whose identifier match the
@@ -68,7 +66,7 @@ module Nanoc3
 
       # Create rule
       rule = Rule.new(identifier_to_regex(identifier), rep_name, block)
-      compiler.item_compilation_rules << rule
+      @rules_collection.add_item_compilation_rule(rule)
     end
 
     # Creates a routing rule for all items whose identifier match the
@@ -113,7 +111,7 @@ module Nanoc3
 
       # Create rule
       rule = Rule.new(identifier_to_regex(identifier), rep_name, block, :snapshot_name => snapshot_name)
-      compiler.item_routing_rules << rule
+      @rules_collection.add_item_routing_rule(rule)
     end
 
     # Creates a layout rule for all layouts whose identifier match the given
@@ -141,7 +139,52 @@ module Nanoc3
     #
     #     layout '/custom/',  :haml, :format => :html5
     def layout(identifier, filter_name, params={})
-      compiler.layout_filter_mapping[identifier_to_regex(identifier)] = [ filter_name, params ]
+      @rules_collection.layout_filter_mapping[identifier_to_regex(identifier)] = [ filter_name, params ]
+    end
+
+    # Creates a pair of compilation and routing rules that indicate that the
+    # specified item(s) should be copied to the output folder as-is. The items
+    # are selected using an identifier, which may either be a string
+    # containing the `*` wildcard, or a regular expression.
+    #
+    # This meta-rule will be applicable to reps with a name equal to
+    # `:default`; this can be changed by giving an explicit `:rep` parameter.
+    #
+    # @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
+    #
+    # @return [void]
+    #
+    # @since 3.2.0
+    #
+    # @example Copying the `/foo/` item as-is
+    #
+    #     passthrough '/foo/'
+    #
+    # @example Copying the `:raw` rep of the `/bar/` item as-is
+    #
+    #     passthrough '/bar/', :rep => :raw
+    def passthrough(identifier, params={})
+      # Require no block
+      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 = Rule.new(identifier_to_regex(identifier), rep_name, compilation_block)
+      @rules_collection.add_item_compilation_rule(compilation_rule, :before)
+
+      # Create routing rule
+      routing_block = proc do
+        item.identifier.chop + '.' + item[:extension]
+      end
+      routing_rule = Rule.new(identifier_to_regex(identifier), rep_name, routing_block)
+      @rules_collection.add_item_routing_rule(routing_rule, :before)
     end
 
   private

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'pstore'
-
 module Nanoc3
 
   # Responsible for remembering dependencies between items and layouts. It is
@@ -18,9 +16,9 @@ module Nanoc3
   # 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. This file
-  # also contains a version number; when a dependencies file with an
-  # incompatible version is found, it is ignored.
+  # Dependency information is stored in the `tmp/dependencies` file.
+  #
+  # @api private
   class DependencyTracker < ::Nanoc3::Store
 
     # @return [Array<Nanoc3::Item, Nanoc3::Layout>] The list of items and
@@ -41,8 +39,6 @@ module Nanoc3
       @objects = objects
 
       @graph = Nanoc3::DirectedGraph.new([ nil ] + @objects)
-      @previous_objects = []
-      @objects_outdated_due_to_dependencies = Set.new
     end
 
     # Starts listening for dependency messages (`:visit_started` and
@@ -76,33 +72,25 @@ module Nanoc3
       Nanoc3::NotificationCenter.remove(:visit_ended,   self)
     end
 
-    # Checks whether the given object is outdated due to dependencies, i.e.
-    # check whether there are other objects that are outdated that cause this
-    # object to be outdated.
-    #
-    # @param [Nanoc3::Item, Nanoc3::Layout] obj The object to check
-    #
-    # @return [Boolean] true if the given object is outdated due to
-    #   dependencies, false if not.
-    def outdated_due_to_dependencies?(obj)
-      @objects_outdated_due_to_dependencies.include?(obj)
-    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 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 [Nanoc3::Item, Nanoc3::Layout] object The object for
     #   which to fetch the direct predecessors
     #
-    # @return [Array<Nanoc3::Item, Nanoc3::Layout>] The direct predecessors of
+    # @return [Array<Nanoc3::Item, Nanoc3::Layout, nil>] The direct
+    # predecessors of
     #   the given object
-    def direct_predecessors_of(object)
-      @graph.direct_predecessors_of(object).compact
+    def objects_causing_outdatedness_of(object)
+      @graph.direct_predecessors_of(object)
     end
 
     # Returns the direct inverse dependencies for the given object.
@@ -118,7 +106,7 @@ module Nanoc3
     #
     # @return [Array<Nanoc3::Item, Nanoc3::Layout>] The direct successors of
     #   the given object
-    def direct_successors_of(object)
+    def objects_outdated_due_to(object)
       @graph.direct_successors_of(object).compact
     end
 
@@ -138,35 +126,6 @@ module Nanoc3
       @graph.add_edge(dst, src) unless src == dst
     end
 
-    # Traverses the dependency graph and marks all objects that (directly or
-    # indirectly) depend on an outdated object as outdated.
-    #
-    # @return [void]
-    def propagate_outdatedness
-      # Unmark everything
-      @objects_outdated_due_to_dependencies.clear
-
-      # Mark new objects as outdated
-      added_objects = @objects - @previous_objects
-      @objects_outdated_due_to_dependencies.merge(added_objects)
-
-      # Mark successors of outdated objects as outdated
-      require 'set'
-      unprocessed = [ nil ] + @objects.select { |o| compiler.outdated?(o) }
-      seen        = Set.new(unprocessed)
-      until unprocessed.empty?
-        obj = unprocessed.shift
-
-        self.direct_successors_of(obj).each do |successor|
-          next if seen.include?(successor)
-          seen << successor
-
-          @objects_outdated_due_to_dependencies << successor
-          unprocessed << successor
-        end
-      end
-    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
@@ -182,11 +141,6 @@ module Nanoc3
       @graph.delete_edges_to(object)
     end
 
-    # @deprecated Use {#propagate_outdatedness} instead.
-    def mark_outdated_items
-      propagate_outdatedness
-    end
-
     # @deprecated Use {#store} instead
     def store_graph
       self.store
@@ -197,6 +151,11 @@ module Nanoc3
       self.load
     end
 
+    # @see Nanoc3::Store#unload
+    def unload
+      @graph = Nanoc3::DirectedGraph.new([ nil ] + @objects)
+    end
+
   protected
 
     def data
@@ -211,17 +170,25 @@ module Nanoc3
       @graph = Nanoc3::DirectedGraph.new([ nil ] + @objects)
 
       # Load vertices
-      @previous_objects = new_data[:vertices].map do |reference|
+      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]
+        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|
+          @graph.add_edge(new_obj, obj)
+        end
+      end
     end
 
   end

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

@@ -110,17 +110,18 @@ module Nanoc3
     #   used on binary items. When running a binary filter on a file, the
     #   resulting file must end up in the location returned by this method.
     #
+    # The returned filename will be absolute, so it is safe to change to
+    #   another directory inside the filter.
+    #
     # @return [String] The output filename
     def output_filename
       @output_filename ||= begin
-        require 'tempfile'
-
         FileUtils.mkdir_p(TMP_BINARY_ITEMS_DIR)
         tempfile = Tempfile.new(filename.gsub(/[^a-z]/, '-'), TMP_BINARY_ITEMS_DIR)
         new_filename = tempfile.path
         tempfile.close!
 
-        new_filename
+        File.expand_path(new_filename)
       end
     end
 

data/lib/nanoc3/base/compilation/item_rep_proxy.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'forwardable'
-
 module Nanoc3
 
   # Represents an item representation, but provides an interface that is
@@ -65,19 +63,36 @@ module Nanoc3
       set_assigns
 
       layout = layout_with_identifier(layout_identifier)
-      filter_name, filter_args = @compiler.filter_for_layout(layout)
+      filter_name, filter_args = @compiler.rules_collection.filter_for_layout(layout)
 
       @item_rep.layout(layout, filter_name, filter_args)
     end
 
+    # Returns true because this item is already a proxy, and therefore doesn’t
+    # need to be wrapped anymore.
+    #
+    # @api private
+    #
+    # @return [true]
+    #
+    # @see Nanoc3::ItemRep#is_proxy?
+    # @see Nanoc3::ItemRepRecorderProxy#is_proxy?
+    def is_proxy?
+      true
+    end
+
   private
 
     def set_assigns
       @item_rep.assigns = @compiler.assigns_for(@item_rep)
     end
 
+    def layouts
+      @compiler.site.layouts
+    end
+
     def layout_with_identifier(layout_identifier)
-      layout ||= @compiler.site.layouts.find { |l| l.identifier == layout_identifier.cleaned_identifier }
+      layout ||= layouts.find { |l| l.identifier == layout_identifier.cleaned_identifier }
       raise Nanoc3::Errors::UnknownLayout.new(layout_identifier) if layout.nil?
       layout
     end

data/lib/nanoc3/base/compilation/item_rep_recorder_proxy.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module Nanoc3
+
+  # Represents a fake iem representation that does not actually perform any
+  # actual filtering, layouting or snapshotting, but instead keeps track of
+  # what would happen if a real item representation would have been used
+  # instead. It therefore “records” the actions that happens upon it.
+  #
+  # The list of recorded actions is used during compilation to determine
+  # whether an item representation needs to be recompiled: if the list of
+  # actions is different from the list of actions from the previous
+  # compilation run, the item needs to be recompiled; if it is the same, it
+  # may not need to be recompiled.
+  #
+  # @api private
+  class ItemRepRecorderProxy
+
+    extend Forwardable
+
+    def_delegators :@item_rep, :item, :name, :binary, :binary?, :compiled_content, :has_snapshot?, :raw_path, :path, :assigns, :assigns=
+
+    # @return The list of recorded actions (“rule memory”)
+    #
+    # @example The compilation rule and the corresponding rule memory
+    #
+    #     # rule
+    #     compile '/foo/' do
+    #       filter :erb
+    #       filter :myfilter, :arg1 => 'stuff'
+    #       layout 'meh'
+    #     end
+    #
+    #     # memory
+    #     [
+    #       [ :filter, :erb, {} ],
+    #       [ :filter, :myfilter, { :arg1 => 'stuff' } ],
+    #       [ :layout, 'meh' ]
+    #     ]
+    #
+    # @return [Array] The rule memory
+    attr_reader :rule_memory
+
+    # @param [Nanoc3::ItemRep] item_rep The item representation that this
+    #   proxy should behave like
+    def initialize(item_rep)
+      @item_rep = item_rep
+      @rule_memory = []
+    end
+
+    # @return [void]
+    #
+    # @see Nanoc3::ItemRepProxy#filter, Nanoc3::ItemRep#filter
+    def filter(name, args={})
+      @rule_memory << [ :filter, name, args ]
+    end
+
+    # @return [void]
+    #
+    # @see Nanoc3::ItemRepProxy#layout, Nanoc3::ItemRep#layout
+    def layout(layout_identifier)
+      @rule_memory << [ :layout, layout_identifier ]
+    end
+
+    # @return [void]
+    #
+    # @see Nanoc3::ItemRep#snapshot
+    def snapshot(snapshot_name, params={})
+      @rule_memory << [ :snapshot, snapshot_name, params ]
+    end
+
+    # @return [{}]
+    def content
+      {}
+    end
+
+    # Returns true because this item is already a proxy, and therefore doesn’t
+    # need to be wrapped anymore.
+    #
+    # @return [true]
+    #
+    # @see Nanoc3::ItemRep#is_proxy?
+    # @see Nanoc3::ItemRepProxy#is_proxy?
+    def is_proxy?
+      true
+    end
+
+  end
+
+end

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

@@ -7,16 +7,27 @@ module Nanoc3
   # @api private
   class OutdatednessChecker
 
+    extend Nanoc3::Memoization
+
     # @option params [Nanoc3::Site] :site (nil) The site this outdatedness
     #   checker belongs to.
     #
     # @option params [Nanoc3::ChecksumStore] :checksum_store (nil) The
     #   checksum store where checksums of items, layouts, … are stored.
+    #
+    # @option params [Nanoc3::DependencyTracker] :dependency_tracker (nil) The
+    #   dependency tracker for the given site.
     def initialize(params={})
-      @site           = params[:site]           if params.has_key?(:site)
-      @checksum_store = params[:checksum_store] if params.has_key?(:checksum_store)
-
+      @site = params[:site] or raise ArgumentError,
+        'Nanoc3::OutdatednessChecker#initialize needs a :site parameter'
+      @checksum_store = params[:checksum_store] or raise ArgumentError,
+        'Nanoc3::OutdatednessChecker#initialize needs a :checksum_store parameter'
+      @dependency_tracker = params[:dependency_tracker] or raise ArgumentError,
+        'Nanoc3::OutdatednessChecker#initialize needs a :dependency_tracker parameter'
+
+      @basic_outdatedness_reasons = {}
       @outdatedness_reasons = {}
+      @objects_outdated_due_to_dependencies = {}
     end
 
     # Checks whether the given object is outdated and therefore needs to be
@@ -38,34 +49,72 @@ module Nanoc3
     # @return [Nanoc3::OutdatednessReasons::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 = Nanoc3::OutdatednessReasons::DependenciesOutdated
+      end
+      reason
+    end
+    memoize :outdatedness_reason_for
+
+  private
+
+    # Checks whether the given object is outdated and therefore needs to be
+    # recompiled. This method does not take dependencies into account; use
+    # {#outdated?} if you want to include dependencies in the outdatedness
+    # check.
+    #
+    # @param [Nanoc3::Item, Nanoc3::ItemRep, Nanoc3::Layout] obj The object
+    #   whose outdatedness should be checked.
+    #
+    # @return [Boolean] true if the object is outdated, false otherwise
+    def basic_outdated?(obj)
+      !basic_outdatedness_reason_for(obj).nil?
+    end
+
+    # Calculates the reason why the given object is outdated. This method does
+    # not take dependencies into account; use {#outdatedness_reason_for?} if
+    # you want to include dependencies in the outdatedness check.
+    #
+    # @param [Nanoc3::Item, Nanoc3::ItemRep, Nanoc3::Layout] obj The object
+    #   whose outdatedness reason should be calculated.
+    #
+    # @return [Nanoc3::OutdatednessReasons::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.type
         when :item_rep
+          # Outdated if rules outdated
+          return Nanoc3::OutdatednessReasons::RulesModified if
+            rule_memory_differs_for(obj)
+
           # Outdated if checksums are missing or different
-          return Nanoc3::OutdatednessReasons::NotEnoughData if !checksum_store.checksums_available?(obj.item)
-          return Nanoc3::OutdatednessReasons::SourceModified if !checksum_store.checksums_identical?(obj.item)
+          return Nanoc3::OutdatednessReasons::NotEnoughData if !checksums_available?(obj.item)
+          return Nanoc3::OutdatednessReasons::SourceModified if !checksums_identical?(obj.item)
 
           # Outdated if compiled file doesn't exist (yet)
           return Nanoc3::OutdatednessReasons::NotWritten if obj.raw_path && !File.file?(obj.raw_path)
 
           # Outdated if code snippets outdated
-          return Nanoc3::OutdatednessReasons::CodeSnippetsModified if @site.code_snippets.any? do |cs|
-            checksum_store.object_modified?(cs)
+          return Nanoc3::OutdatednessReasons::CodeSnippetsModified if site.code_snippets.any? do |cs|
+            object_modified?(cs)
           end
 
           # Outdated if configuration outdated
-          return Nanoc3::OutdatednessReasons::ConfigurationModified if checksum_store.object_modified?(@site.config)
-
-          # Outdated if rules outdated
-          return Nanoc3::OutdatednessReasons::RulesModified if checksum_store.object_modified?(@site.compiler.rules_with_reference)
+          return Nanoc3::OutdatednessReasons::ConfigurationModified if object_modified?(site.config)
 
           # Not outdated
           return nil
         when :item
-          obj.reps.find { |rep| outdatedness_reason_for(rep) }
+          obj.reps.find { |rep| basic_outdatedness_reason_for(rep) }
         when :layout
+          # Outdated if rules outdated
+          return Nanoc3::OutdatednessReasons::RulesModified if
+            rule_memory_differs_for(obj)
+
           # Outdated if checksums are missing or different
-          return Nanoc3::OutdatednessReasons::NotEnoughData if !checksum_store.checksums_available?(obj)
-          return Nanoc3::OutdatednessReasons::SourceModified if !checksum_store.checksums_identical?(obj)
+          return Nanoc3::OutdatednessReasons::NotEnoughData if !checksums_available?(obj)
+          return Nanoc3::OutdatednessReasons::SourceModified if !checksums_identical?(obj)
 
           # Not outdated
           return nil
@@ -73,14 +122,102 @@ module Nanoc3
           raise RuntimeError, "do not know how to check outdatedness of #{obj.inspect}"
       end
     end
+    memoize :basic_outdatedness_reason_for
 
-  private
+    # Checks whether the given object is outdated due to dependencies.
+    #
+    # @param [Nanoc3::Item, Nanoc3::ItemRep, Nanoc3::Layout] obj The object
+    #   whose outdatedness should be checked.
+    #
+    # @param [Set] processed The collection of items that has been visited
+    #   during this outdatedness check. This is used to prevent checks for
+    #   items that (indirectly) depend on their own from looping
+    #   indefinitely. It should not be necessary to pass this a custom value.
+    #
+    # @return [Boolean] true if the object is outdated, false otherwise
+    def outdated_due_to_dependencies?(obj, processed=Set.new)
+      # Convert from rep to item if necessary
+      obj = obj.item if obj.type == :item_rep
+
+      # Get from cache
+      if @objects_outdated_due_to_dependencies.has_key?(obj)
+        return @objects_outdated_due_to_dependencies[obj]
+      end
+
+      # Check processed
+      # Don’t return true; the false will be or’ed into a true if there
+      # really is a dependency that is causing outdatedness.
+      return false if processed.include?(obj)
+
+      # Calculate
+      is_outdated = dependency_tracker.objects_causing_outdatedness_of(obj).any? do |other|
+        other.nil? || basic_outdated?(other) || outdated_due_to_dependencies?(other, processed.merge([obj]))
+      end
+
+      # Cache
+      @objects_outdated_due_to_dependencies[obj] = is_outdated
+
+      # Done
+      is_outdated
+    end
+
+    # @param [Nanoc3::ItemRep, Nanoc3::Layout] obj The layout or item
+    #   representation to check the rule memory for
+    #
+    # @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)
+    end
+    memoize :rule_memory_differs_for
+
+    # @param obj
+    #
+    # @return [Boolean] false if either the new or the old checksum for the
+    #   given object is not available, true if both checksums are available
+    def checksums_available?(obj)
+      !!checksum_store[obj] && obj.checksum
+    end
+    memoize :checksums_available?
+
+    # @param obj
+    #
+    # @return [Boolean] false if the old and new checksums for the given
+    #   object differ, true if they are identical
+    def checksums_identical?(obj)
+      checksum_store[obj] == obj.checksum
+    end
+    memoize :checksums_identical?
+
+    # @param obj
+    #
+    # @return [Boolean] true if the old and new checksums for the given object
+    #   are available and identical, false otherwise
+    def object_modified?(obj)
+      !checksums_available?(obj) || !checksums_identical?(obj)
+    end
+    memoize :object_modified?
 
     # @return [Nanoc3::ChecksumStore] The checksum store
     def checksum_store
       @checksum_store
     end
 
+    # TODO document
+    def rules_collection
+      site.compiler.rules_collection
+    end
+
+    # @return [Nanoc3::DependencyTracker] The dependency tracker
+    def dependency_tracker
+      @dependency_tracker
+    end
+
+    # @return [Nanoc3::Site] The site
+    def site
+      @site
+    end
+
   end
 
 end

data/lib/nanoc3/base/compilation/outdatedness_reasons.rb

@@ -20,24 +20,27 @@ module Nanoc3
 
     end
 
-    NotEnoughData = Generic.new(
-      'Not enough data is present to correctly determine whether the item is outdated.')
-
-    NotWritten = Generic.new(
-      'This item representation has not yet been written to the output directory (but it does have a path).')
-
-    SourceModified = Generic.new(
-      'The source file of this item has been modified since the last time the site was compiled.')
-
     CodeSnippetsModified = Generic.new(
       'The code snippets have been modified since the last time the site was compiled.')
 
     ConfigurationModified = Generic.new(
       'The site configuration has been modified since the last time the site was compiled.')
 
+    DependenciesOutdated = Generic.new(
+      'This item uses content or attributes that have changed since the last time the site was compiled.')
+
+    NotEnoughData = Generic.new(
+      'Not enough data is present to correctly determine whether the item is outdated.')
+
+    NotWritten = Generic.new(
+      'This item representation has not yet been written to the output directory (but it does have a path).')
+
     RulesModified = Generic.new(
       'The rules file has been modified since the last time the site was compiled.')
 
+    SourceModified = Generic.new(
+      'The source file of this item has been modified since the last time the site was compiled.')
+
   end
 
 end