nanoc 3.8.0 → 4.0.0a1

data/lib/nanoc/base/checksummer.rb

@@ -1,10 +1,12 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Creates checksums for given objects.
   #
   # A checksum is a string, such as “mL+TaqNsEeiPkWloPgCtAofT1yg=”, that is used
   # to determine whether a piece of data has changed.
+  #
+  # @api private
   class Checksummer
     class << self
       # @param obj The object to create a checksum for
@@ -49,11 +51,11 @@ module Nanoc
           else
             digest.update('???')
           end
-        when Nanoc::RulesCollection
+        when Nanoc::Int::RulesCollection
           update(obj.data, digest)
-        when Nanoc::CodeSnippet
+        when Nanoc::Int::CodeSnippet
           update(obj.data, digest)
-        when Nanoc::Item, Nanoc::Layout
+        when Nanoc::Int::Item, Nanoc::Int::Layout
           digest.update('content')
           if obj.respond_to?(:binary?) && obj.binary?
             update(Pathname.new(obj.raw_filename), digest)

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

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Stores checksums for objects in order to be able to detect whether a file
   # has changed since the last site compilation.
   #
   # @api private
-  class ChecksumStore < ::Nanoc::Store
-    # @option params [Nanoc::Site] site The site where this checksum store
+  class ChecksumStore < ::Nanoc::Int::Store
+    # @option params [Nanoc::Int::Site] site The site where this checksum store
     #   belongs to
     def initialize(params = {})
       super('tmp/checksums', 1)
@@ -35,7 +35,7 @@ module Nanoc
       @checksums[obj.reference] = checksum
     end
 
-    # @see Nanoc::Store#unload
+    # @see Nanoc::Int::Store#unload
     def unload
       @checksums = {}
     end

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

@@ -1,11 +1,11 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Represents a cache than can be used to store already compiled content,
   # to prevent it from being needlessly recompiled.
   #
   # @api private
-  class CompiledContentCache < ::Nanoc::Store
+  class CompiledContentCache < ::Nanoc::Int::Store
     def initialize
       super('tmp/compiled_content', 1)
 
@@ -17,7 +17,7 @@ module Nanoc
     # are the snapshot names and the values the compiled content at the
     # given snapshot.
     #
-    # @param [Nanoc::ItemRep] rep The item rep to fetch the content for
+    # @param [Nanoc::Int::ItemRep] rep The item rep to fetch the content for
     #
     # @return [Hash<Symbol,String>] A hash containing the cached compiled
     #   content for the given item representation
@@ -28,7 +28,7 @@ module Nanoc
 
     # Sets the compiled content for the given representation.
     #
-    # @param [Nanoc::ItemRep] rep The item representation for which to set
+    # @param [Nanoc::Int::ItemRep] rep The item representation for which to set
     #   the compiled content
     #
     # @param [Hash<Symbol,String>] content A hash containing the compiled
@@ -40,7 +40,7 @@ module Nanoc
       @cache[rep.item.identifier][rep.name] = content
     end
 
-    # @see Nanoc::Store#unload
+    # @see Nanoc::Int::Store#unload
     def unload
       @cache = {}
     end

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

@@ -1,10 +1,10 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Responsible for compiling a site’s item representations.
   #
   # The compilation process makes use of notifications (see
-  # {Nanoc::NotificationCenter}) to track dependencies between items,
+  # {Nanoc::Int::NotificationCenter}) to track dependencies between items,
   # layouts, etc. The following notifications are used:
   #
   # * `compilation_started` — indicates that the compiler has started
@@ -37,12 +37,14 @@ module Nanoc
   #
   # * `processing_ended` — indicates that the compiler has finished processing
   #   the specified object.
+  #
+  # @api private
   class Compiler
-    extend Nanoc::Memoization
+    extend Nanoc::Int::Memoization
 
     # @group Accessors
 
-    # @return [Nanoc::Site] The site this compiler belongs to
+    # @return [Nanoc::Int::Site] The site this compiler belongs to
     attr_reader :site
 
     # The compilation stack. When the compiler begins compiling a rep or a
@@ -56,7 +58,7 @@ module Nanoc
 
     # Creates a new compiler fo the given site
     #
-    # @param [Nanoc::Site] site The site this compiler belongs to
+    # @param [Nanoc::Int::Site] site The site this compiler belongs to
     def initialize(site)
       @site = site
 
@@ -88,25 +90,23 @@ module Nanoc
       dependency_tracker.stop
       store
     ensure
-      Nanoc::TempFilenameFactory.instance.cleanup(
+      Nanoc::Int::TempFilenameFactory.instance.cleanup(
         Nanoc::Filter::TMP_BINARY_ITEMS_DIR)
-      Nanoc::TempFilenameFactory.instance.cleanup(
-        Nanoc::ItemRep::TMP_TEXT_ITEMS_DIR)
+      Nanoc::Int::TempFilenameFactory.instance.cleanup(
+        Nanoc::Int::ItemRep::TMP_TEXT_ITEMS_DIR)
     end
 
     # @group Private instance methods
 
-    # @return [Nanoc::RulesCollection] The collection of rules to be used
+    # @return [Nanoc::Int::RulesCollection] The collection of rules to be used
     #   for compiling this site
     def rules_collection
-      Nanoc::RulesCollection.new(self)
+      Nanoc::Int::RulesCollection.new(self)
     end
     memoize :rules_collection
 
     # Load the helper data that is used for compiling the site.
     #
-    # @api private
-    #
     # @return [void]
     def load
       return if @loaded || @loading
@@ -135,8 +135,6 @@ module Nanoc
 
     # Undoes the effects of {#load}. Used when {#load} raises an exception.
     #
-    # @api private
-    #
     # @return [void]
     def unload
       return if @unloading
@@ -158,8 +156,6 @@ module Nanoc
 
     # Store the modified helper data used for compiling the site.
     #
-    # @api private
-    #
     # @return [void]
     def store
       # Calculate rule memory
@@ -169,7 +165,7 @@ module Nanoc
 
       # Calculate checksums
       objects.each do |obj|
-        checksum_store[obj] = obj.checksum
+        checksum_store[obj] = obj.__nanoc_checksum
       end
 
       # Store
@@ -179,11 +175,9 @@ module Nanoc
     # Returns the dependency tracker for this site, creating it first if it
     # does not yet exist.
     #
-    # @api private
-    #
-    # @return [Nanoc::DependencyTracker] The dependency tracker for this site
+    # @return [Nanoc::Int::DependencyTracker] The dependency tracker for this site
     def dependency_tracker
-      dt = Nanoc::DependencyTracker.new(@site.items + @site.layouts)
+      dt = Nanoc::Int::DependencyTracker.new(@site.items + @site.layouts)
       dt.compiler = self
       dt
     end
@@ -215,12 +209,12 @@ module Nanoc
       items.each do |item|
         # Find matching rules
         matching_rules = rules_collection.item_compilation_rules_for(item)
-        raise Nanoc::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?
+        raise Nanoc::Int::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?
 
         # Create reps
         rep_names = matching_rules.map(&:rep_name).uniq
         rep_names.each do |rep_name|
-          item.reps << ItemRep.new(item, rep_name)
+          item.reps << Nanoc::Int::ItemRep.new(item, rep_name)
         end
       end
     end
@@ -232,7 +226,7 @@ module Nanoc
       reps.each do |rep|
         # Find matching rules
         rules = rules_collection.routing_rules_for(rep)
-        raise Nanoc::Errors::NoMatchingRoutingRuleFound.new(rep) if rules[:last].nil?
+        raise Nanoc::Int::Errors::NoMatchingRoutingRuleFound.new(rep) if rules[:last].nil?
 
         rules.each_pair do |snapshot, rule|
           # Get basic path by applying matching rule
@@ -259,7 +253,7 @@ module Nanoc
       end
     end
 
-    # @param [Nanoc::ItemRep] rep The item representation for which the
+    # @param [Nanoc::Int::ItemRep] rep The item representation for which the
     #   assigns should be fetched
     #
     # @return [Hash] The assigns that should be used in the next filter/layout
@@ -273,20 +267,21 @@ module Nanoc
         content_or_filename_assigns = { content: rep.content[:last] }
       end
 
+      # TODO: Do not expose @site (necessary for captures store though…)
       content_or_filename_assigns.merge({
-        item: rep.item,
-        rep: rep,
-        item_rep: rep,
-        items: site.items,
-        layouts: site.layouts,
-        config: site.config,
-        site: site
+        item: Nanoc::ItemView.new(rep.item),
+        rep: Nanoc::ItemRepView.new(rep),
+        item_rep: Nanoc::ItemRepView.new(rep),
+        items: Nanoc::ItemCollectionView.new(site.items),
+        layouts: Nanoc::LayoutCollectionView.new(site.layouts),
+        config: Nanoc::ConfigView.new(site.config),
+        site: Nanoc::SiteView.new(site),
       })
     end
 
-    # @return [Nanoc::OutdatednessChecker] The outdatedness checker
+    # @return [Nanoc::Int::OutdatednessChecker] The outdatedness checker
     def outdatedness_checker
-      Nanoc::OutdatednessChecker.new(
+      Nanoc::Int::OutdatednessChecker.new(
         site: @site,
         checksum_store: checksum_store,
         dependency_tracker: dependency_tracker)
@@ -295,19 +290,19 @@ module Nanoc
 
     private
 
-    # @return [Array<Nanoc::Item>] The site’s items
+    # @return [Array<Nanoc::Int::Item>] The site’s items
     def items
       @site.items
     end
     memoize :items
 
-    # @return [Array<Nanoc::ItemRep>] The site’s item representations
+    # @return [Array<Nanoc::Int::ItemRep>] The site’s item representations
     def reps
       items.map(&:reps).flatten
     end
     memoize :reps
 
-    # @return [Array<Nanoc::Layout>] The site’s layouts
+    # @return [Array<Nanoc::Int::Layout>] The site’s layouts
     def layouts
       @site.layouts
     end
@@ -319,11 +314,11 @@ module Nanoc
     #
     # @return [void]
     def compile_reps(reps)
-      content_dependency_graph = Nanoc::DirectedGraph.new(reps)
+      content_dependency_graph = Nanoc::Int::DirectedGraph.new(reps)
 
       # Listen to processing start/stop
-      Nanoc::NotificationCenter.on(:processing_started, self) { |obj| @stack.push(obj) }
-      Nanoc::NotificationCenter.on(:processing_ended,   self) { |_obj| @stack.pop       }
+      Nanoc::Int::NotificationCenter.on(:processing_started, self) { |obj| @stack.push(obj) }
+      Nanoc::Int::NotificationCenter.on(:processing_ended,   self) { |_obj| @stack.pop       }
 
       # Assign snapshots
       reps.each do |rep|
@@ -340,7 +335,7 @@ module Nanoc
         begin
           compile_rep(rep)
           content_dependency_graph.delete_vertex(rep)
-        rescue Nanoc::Errors::UnmetDependency => e
+        rescue Nanoc::Int::Errors::UnmetDependency => e
           content_dependency_graph.add_edge(e.rep, rep)
           unless content_dependency_graph.vertices.include?(e.rep)
             content_dependency_graph.add_vertex(e.rep)
@@ -350,33 +345,33 @@ module Nanoc
 
       # Check whether everything was compiled
       unless content_dependency_graph.vertices.empty?
-        raise Nanoc::Errors::RecursiveCompilation.new(content_dependency_graph.vertices)
+        raise Nanoc::Int::Errors::RecursiveCompilation.new(content_dependency_graph.vertices)
       end
     ensure
-      Nanoc::NotificationCenter.remove(:processing_started, self)
-      Nanoc::NotificationCenter.remove(:processing_ended,   self)
+      Nanoc::Int::NotificationCenter.remove(:processing_started, self)
+      Nanoc::Int::NotificationCenter.remove(:processing_ended,   self)
     end
 
     # Compiles the given item representation.
     #
     # This method should not be called directly; please use
-    # {Nanoc::Compiler#run} instead, and pass this item representation's item
+    # {Nanoc::Int::Compiler#run} instead, and pass this item representation's item
     # as its first argument.
     #
-    # @param [Nanoc::ItemRep] rep The rep that is to be compiled
+    # @param [Nanoc::Int::ItemRep] rep The rep that is to be compiled
     #
     # @return [void]
     def compile_rep(rep)
-      Nanoc::NotificationCenter.post(:compilation_started, rep)
-      Nanoc::NotificationCenter.post(:processing_started,  rep)
-      Nanoc::NotificationCenter.post(:visit_started,       rep.item)
+      Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+      Nanoc::Int::NotificationCenter.post(:processing_started,  rep)
+      Nanoc::Int::NotificationCenter.post(:visit_started,       rep.item)
 
       # Calculate rule memory if we haven’t yet done do
       rules_collection.new_rule_memory_for_rep(rep)
 
       if !rep.item.forced_outdated? && !outdatedness_checker.outdated?(rep) && compiled_content_cache[rep]
         # Reuse content
-        Nanoc::NotificationCenter.post(:cached_content_used, rep)
+        Nanoc::Int::NotificationCenter.post(:cached_content_used, rep)
         rep.content = compiled_content_cache[rep]
       else
         # Recalculate content
@@ -390,19 +385,19 @@ module Nanoc
       rep.compiled = true
       compiled_content_cache[rep] = rep.content
 
-      Nanoc::NotificationCenter.post(:processing_ended,  rep)
-      Nanoc::NotificationCenter.post(:compilation_ended, rep)
+      Nanoc::Int::NotificationCenter.post(:processing_ended,  rep)
+      Nanoc::Int::NotificationCenter.post(:compilation_ended, rep)
     rescue => e
       rep.forget_progress
-      Nanoc::NotificationCenter.post(:compilation_failed, rep, e)
+      Nanoc::Int::NotificationCenter.post(:compilation_failed, rep, e)
       raise e
     ensure
-      Nanoc::NotificationCenter.post(:visit_ended,       rep.item)
+      Nanoc::Int::NotificationCenter.post(:visit_ended,       rep.item)
     end
 
     # Clears the list of dependencies for items that will be recompiled.
     #
-    # @param [Array<Nanoc::Item>] items The list of items for which to forget
+    # @param [Array<Nanoc::Int::Item>] items The list of items for which to forget
     #   the dependencies
     #
     # @return [void]
@@ -416,36 +411,36 @@ module Nanoc
 
     # Returns a preprocessor context, creating one if none exists yet.
     def preprocessor_context
-      Nanoc::Context.new({
-        site: @site,
-        config: @site.config,
-        items: @site.items,
-        layouts: @site.layouts
+      Nanoc::Int::Context.new({
+        site: Nanoc::SiteView.new(@site), # TODO: remove me
+        config: Nanoc::MutableConfigView.new(@site.config),
+        items: Nanoc::MutableItemCollectionView.new(@site.items),
+        layouts: Nanoc::MutableLayoutCollectionView.new(@site.layouts),
       })
     end
     memoize :preprocessor_context
 
-    # @return [CompiledContentCache] The compiled content cache
+    # @return [Nanoc:Int::CompiledContentCache] The compiled content cache
     def compiled_content_cache
-      Nanoc::CompiledContentCache.new
+      Nanoc::Int::CompiledContentCache.new
     end
     memoize :compiled_content_cache
 
     # @return [ChecksumStore] The checksum store
     def checksum_store
-      Nanoc::ChecksumStore.new(site: @site)
+      Nanoc::Int::ChecksumStore.new(site: @site)
     end
     memoize :checksum_store
 
     # @return [RuleMemoryStore] The rule memory store
     def rule_memory_store
-      Nanoc::RuleMemoryStore.new(site: @site)
+      Nanoc::Int::RuleMemoryStore.new(site: @site)
     end
     memoize :rule_memory_store
 
     # @return [RuleMemoryCalculator] The rule memory calculator
     def rule_memory_calculator
-      Nanoc::RuleMemoryCalculator.new(rules_collection: rules_collection)
+      Nanoc::Int::RuleMemoryCalculator.new(rules_collection: rules_collection)
     end
     memoize :rule_memory_calculator
 

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

@@ -1,18 +1,20 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Contains methods that will be executed by the site’s `Rules` file.
   class CompilerDSL
     # The current rules filename.
     #
     # @return [String] The current rules filename.
+    #
+    # @api private
     attr_accessor :rules_filename
 
     # Creates a new compiler DSL for the given collection of rules.
     #
     # @api private
     #
-    # @param [Nanoc::RulesCollection] rules_collection The collection of
+    # @param [Nanoc::Int::RulesCollection] rules_collection The collection of
     #   rules to modify when loading this DSL
     #
     # @param [Hash] config The site configuration
@@ -75,7 +77,7 @@ module Nanoc
       rep_name = params[:rep] || :default
 
       # Create rule
-      rule = Rule.new(identifier_to_regex(identifier), rep_name, block)
+      rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, block)
       @rules_collection.add_item_compilation_rule(rule)
     end
 
@@ -120,7 +122,7 @@ module Nanoc
       snapshot_name = params[:snapshot] || :last
 
       # Create rule
-      rule = Rule.new(identifier_to_regex(identifier), rep_name, block, snapshot_name: snapshot_name)
+      rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, block, snapshot_name: snapshot_name)
       @rules_collection.add_item_routing_rule(rule)
     end
 
@@ -186,7 +188,7 @@ module Nanoc
 
       # Create compilation rule
       compilation_block = proc {}
-      compilation_rule = Rule.new(identifier_to_regex(identifier), rep_name, compilation_block)
+      compilation_rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, compilation_block)
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
       # Create routing rule
@@ -197,7 +199,7 @@ module Nanoc
         # data source.
         item[:extension].nil? || (item[:content_filename].nil? && item.identifier =~ %r{#{item[:extension]}/$}) ? item.identifier.chop : item.identifier.chop + '.' + item[:extension]
       end
-      routing_rule = Rule.new(identifier_to_regex(identifier), rep_name, routing_block, snapshot_name: :last)
+      routing_rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, routing_block, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 
@@ -225,10 +227,10 @@ module Nanoc
 
       rep_name = params[:rep] || :default
 
-      compilation_rule = Rule.new(identifier_to_regex(identifier), rep_name, proc {})
+      compilation_rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, proc {})
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
-      routing_rule = Rule.new(identifier_to_regex(identifier), rep_name, proc {}, snapshot_name: :last)
+      routing_rule = Nanoc::Int::Rule.new(identifier_to_regex(identifier), rep_name, proc {}, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 
@@ -246,7 +248,7 @@ module Nanoc
     #     include_rules 'rules/content'
     def include_rules(name)
       filename = ["#{name}", "#{name}.rb", "./#{name}", "./#{name}.rb"].find { |f| File.file?(f) }
-      raise Nanoc::Errors::NoRulesFileFound.new if filename.nil?
+      raise Nanoc::Int::Errors::NoRulesFileFound.new if filename.nil?
 
       @rules_collection.parse(filename)
     end