nanoc 3.8.0 → 4.0.0a1

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

@@ -1,7 +1,9 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Module that contains all outdatedness reasons.
+  #
+  # @api private
   module OutdatednessReasons
     # A generic outdatedness reason. An outdatedness reason is basically a
     # descriptive message that explains why a given object is outdated.

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

@@ -1,7 +1,9 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Contains the processing information for a item.
+  #
+  # @api private
   class Rule
     # @return [Regexp] The regex that determines which items this rule can be
     #   applied to. This rule can be applied to items with a identifier
@@ -42,7 +44,7 @@ module Nanoc
       @block = block
     end
 
-    # @param [Nanoc::Item] item The item to check
+    # @param [Nanoc::Int::Item] item The item to check
     #
     # @return [Boolean] true if this rule can be applied to the given item
     #   rep, false otherwise
@@ -52,10 +54,10 @@ module Nanoc
 
     # Applies this rule to the given item rep.
     #
-    # @param [Nanoc::ItemRep] rep The item representation where this rule
+    # @param [Nanoc::Int::ItemRep] rep The item representation where this rule
     #   should be applied to
     #
-    # @option params [Nanoc::Compiler] :compiler The compiler
+    # @option params [Nanoc::Int::Compiler] :compiler The compiler
     #
     # @raise [ArgumentError] if no compiler is passed
     #
@@ -64,8 +66,8 @@ module Nanoc
       compiler = params.fetch(:compiler) do
         raise ArgumentError, 'Required :compiler option is missing'
       end
-      rep = Nanoc::ItemRepProxy.new(rep, compiler) unless rep.proxy?
-      context = Nanoc::RuleContext.new(rep: rep, compiler: compiler)
+      rep = Nanoc::Int::ItemRepProxy.new(rep, compiler) unless rep.proxy?
+      context = Nanoc::Int::RuleContext.new(rep: rep, compiler: compiler)
       context.instance_exec(matches(rep.item.identifier), &@block)
     end
 
@@ -78,7 +80,7 @@ module Nanoc
     #
     # @return [nil, Array] Captured groups, if any
     def matches(identifier)
-      matches = @identifier_regex.match(identifier)
+      matches = @identifier_regex.match(identifier.to_s)
       matches && matches.captures
     end
   end

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

@@ -1,25 +1,25 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Provides a context in which compilation and routing rules can be executed.
   # It provides access to the item representation that is being compiled or
   # routed.
   #
   # The following variables will be available in this rules context:
   #
-  # * `rep`     ({Nanoc::ItemRep})         - The current item rep
-  # * `item`    ({Nanoc::Item})            - The current item
-  # * `site`    ({Nanoc::Site})            - The site
+  # * `rep`     ({Nanoc::Int::ItemRep})         - The current item rep
+  # * `item`    ({Nanoc::Int::Item})            - The current item
+  # * `site`    ({Nanoc::Int::Site})            - The site
   # * `config`  ({Hash})                    - The site configuration
-  # * `items`   ({Array}<{Nanoc::Item}>)   - A list of all items
-  # * `layouts` ({Array}<{Nanoc::Layout}>) - A list of all layouts
+  # * `items`   ({Array}<{Nanoc::Int::Item}>)   - A list of all items
+  # * `layouts` ({Array}<{Nanoc::Int::Layout}>) - A list of all layouts
   #
   # @api private
-  class RuleContext < Context
-    # @option params [Nanoc::ItemRep] :rep The item representation that will
+  class RuleContext < Nanoc::Int::Context
+    # @option params [Nanoc::Int::ItemRep] :rep The item representation that will
     #   be processed in this rule context
     #
-    # @option params [Nanoc::Compiler] :compiler The compiler that is being
+    # @option params [Nanoc::Int::Compiler] :compiler The compiler that is being
     #   used to compile the site
     #
     # @raise [ArgumentError] if the `:rep` or the `:compiler` option is
@@ -43,10 +43,10 @@ module Nanoc
       })
     end
 
-    # Filters the current representation (calls {Nanoc::ItemRep#filter} with
+    # Filters the current representation (calls {Nanoc::Int::ItemRep#filter} with
     # the given arguments on the rep).
     #
-    # @see Nanoc::ItemRep#filter
+    # @see Nanoc::Int::ItemRep#filter
     #
     # @param [Symbol] filter_name The name of the filter to run the item
     #   representations' content through
@@ -59,10 +59,10 @@ module Nanoc
       rep.filter(filter_name, filter_args)
     end
 
-    # Layouts the current representation (calls {Nanoc::ItemRep#layout} with
+    # Layouts the current representation (calls {Nanoc::Int::ItemRep#layout} with
     # the given arguments on the rep).
     #
-    # @see Nanoc::ItemRep#layout
+    # @see Nanoc::Int::ItemRep#layout
     #
     # @param [String] layout_identifier The identifier of the layout the item
     #   should be laid out with
@@ -73,9 +73,9 @@ module Nanoc
     end
 
     # Creates a snapshot of the current compiled item content. Calls
-    # {Nanoc::ItemRep#snapshot} with the given arguments on the rep.
+    # {Nanoc::Int::ItemRep#snapshot} with the given arguments on the rep.
     #
-    # @see Nanoc::ItemRep#snapshot
+    # @see Nanoc::Int::ItemRep#snapshot
     #
     # @param [Symbol] snapshot_name The name of the snapshot to create
     #

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

@@ -1,14 +1,14 @@
 # encoding: utf-8
 
-module Nanoc
+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::Memoization
+    extend Nanoc::Int::Memoization
 
-    # @option params [Nanoc::RulesCollection] rules_collection The rules
+    # @option params [Nanoc::Int::RulesCollection] rules_collection The rules
     #   collection
     def initialize(params = {})
       @rules_collection = params.fetch(:rules_collection) do

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

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Stores rule memories for objects that can be run through a rule (item
   # representations and layouts).
   #
   # @api private
-  class RuleMemoryStore < ::Nanoc::Store
-    # @option params [Nanoc::Site] site The site where this rule memory store
+  class RuleMemoryStore < ::Nanoc::Int::Store
+    # @option params [Nanoc::Int::Site] site The site where this rule memory store
     #   belongs to
     def initialize(params = {})
       super('tmp/rule_memory', 1)
@@ -16,7 +16,7 @@ module Nanoc
       @rule_memories = {}
     end
 
-    # @param [Nanoc::ItemRep, Nanoc::Layout] obj The item representation or
+    # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or
     #   the layout to get the rule memory for
     #
     # @return [Array] The rule memory for the given object
@@ -24,7 +24,7 @@ module Nanoc
       @rule_memories[obj.reference]
     end
 
-    # @param [Nanoc::ItemRep, Nanoc::Layout] obj The item representation or
+    # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or
     #   the layout to set the rule memory for
     #
     # @param [Array] rule_memory The new rule memory to be stored
@@ -36,12 +36,12 @@ module Nanoc
 
     protected
 
-    # @see Nanoc::Store#data
+    # @see Nanoc::Int::Store#data
     def data
       @rule_memories
     end
 
-    # @see Nanoc::Store#data=
+    # @see Nanoc::Int::Store#data=
     def data=(new_data)
       @rule_memories = new_data
     end

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

@@ -1,22 +1,20 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Keeps track of the rules in a site.
   #
   # @api private
   class RulesCollection
     # @return [String] the contents of the Rules file
-    #
-    # @api private
     attr_accessor :data
 
-    extend Nanoc::Memoization
+    extend Nanoc::Int::Memoization
 
-    # @return [Array<Nanoc::Rule>] The list of item compilation rules that
+    # @return [Array<Nanoc::Int::Rule>] The list of item compilation rules that
     #   will be used to compile items.
     attr_reader :item_compilation_rules
 
-    # @return [Array<Nanoc::Rule>] The list of routing rules that will be
+    # @return [Array<Nanoc::Int::Rule>] The list of routing rules that will be
     #   used to give all items a path.
     attr_reader :item_routing_rules
 
@@ -33,7 +31,7 @@ module Nanoc
     #   be executed after all data is loaded but before the site is compiled
     attr_accessor :preprocessors
 
-    # @param [Nanoc::Compiler] compiler The site’s compiler
+    # @param [Nanoc::Int::Compiler] compiler The site’s compiler
     def initialize(compiler)
       @compiler = compiler
 
@@ -45,7 +43,7 @@ module Nanoc
 
     # Add the given rule to the list of item compilation rules.
     #
-    # @param [Nanoc::Rule] rule The item compilation rule to add
+    # @param [Nanoc::Int::Rule] rule The item compilation rule to add
     #
     # @return [void]
     def add_item_compilation_rule(rule)
@@ -54,14 +52,14 @@ module Nanoc
 
     # Add the given rule to the list of item routing rules.
     #
-    # @param [Nanoc::Rule] rule The item routing rule to add
+    # @param [Nanoc::Int::Rule] rule The item routing rule to add
     #
     # @return [void]
     def add_item_routing_rule(rule)
       @item_routing_rules << rule
     end
 
-    # @param [Nanoc::Item] item The item for which the compilation rules
+    # @param [Nanoc::Int::Item] item The item for which the compilation rules
     #   should be retrieved
     #
     # @return [Array] The list of item compilation rules for the given item
@@ -76,7 +74,7 @@ module Nanoc
       # Find rules file
       rules_filenames = ['Rules', 'rules', 'Rules.rb', 'rules.rb']
       rules_filename = rules_filenames.find { |f| File.file?(f) }
-      raise Nanoc::Errors::NoRulesFileFound.new if rules_filename.nil?
+      raise Nanoc::Int::Errors::NoRulesFileFound.new if rules_filename.nil?
 
       parse(rules_filename)
     end
@@ -106,9 +104,9 @@ module Nanoc
     # Finds the first matching compilation rule for the given item
     # representation.
     #
-    # @param [Nanoc::ItemRep] rep The item rep for which to fetch the rule
+    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rule
     #
-    # @return [Nanoc::Rule, nil] The compilation rule for the given item rep,
+    # @return [Nanoc::Int::Rule, nil] The compilation rule for the given item rep,
     #   or nil if no rules have been found
     def compilation_rule_for(rep)
       @item_compilation_rules.find do |rule|
@@ -118,9 +116,9 @@ module Nanoc
 
     # Finds the first matching routing rule for the given item representation.
     #
-    # @param [Nanoc::ItemRep] rep The item rep for which to fetch the rule
+    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rule
     #
-    # @return [Nanoc::Rule, nil] The routing rule for the given item rep, or
+    # @return [Nanoc::Int::Rule, nil] The routing rule for the given item rep, or
     #   nil if no rules have been found
     def routing_rule_for(rep)
       @item_routing_rules.find do |rule|
@@ -133,9 +131,9 @@ module Nanoc
     # returned. The result is a hash containing the corresponding rule for
     # each snapshot.
     #
-    # @param [Nanoc::ItemRep] rep The item rep for which to fetch the rules
+    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rules
     #
-    # @return [Hash<Symbol, Nanoc::Rule>] The routing rules for the given rep
+    # @return [Hash<Symbol, Nanoc::Int::Rule>] The routing rules for the given rep
     def routing_rules_for(rep)
       rules = {}
       @item_routing_rules.each do |rule|
@@ -150,7 +148,7 @@ module Nanoc
 
     # Finds the filter name and arguments to use for the given layout.
     #
-    # @param [Nanoc::Layout] layout The layout for which to fetch the filter.
+    # @param [Nanoc::Int::Layout] layout The layout for which to fetch the filter.
     #
     # @return [Array, nil] A tuple containing the filter name and the filter
     #   arguments for the given layout.
@@ -161,9 +159,9 @@ module Nanoc
       nil
     end
 
-    # Returns the Nanoc::CompilerDSL that should be used for this site.
+    # Returns the Nanoc::Int::CompilerDSL that should be used for this site.
     def dsl
-      Nanoc::CompilerDSL.new(self, @compiler.site.config)
+      Nanoc::Int::CompilerDSL.new(self, @compiler.site.config)
     end
     memoize :dsl
 
@@ -176,15 +174,15 @@ module Nanoc
 
     # @return [String] The checksum for this object. If its contents change,
     #   the checksum will change as well.
-    def checksum
-      Nanoc::Checksummer.calc(self)
+    def __nanoc_checksum
+      Nanoc::Int::Checksummer.calc(self)
     end
 
     def inspect
       "<#{self.class}>"
     end
 
-    # @param [Nanoc::ItemRep] rep The item representation to get the rule
+    # @param [Nanoc::Int::ItemRep] rep The item representation to get the rule
     #   memory for
     #
     # @return [Array] The rule memory for the given item representation
@@ -197,7 +195,7 @@ module Nanoc
     memoize :new_rule_memory_for_rep
 
     # Makes the given rule memory serializable by calling
-    # `Nanoc::Checksummer#calc` on the filter arguments, so that objects such as
+    # `Nanoc::Int::Checksummer#calc` on the filter arguments, so that objects such as
     # classes and filenames can be serialized.
     #
     # @param [Array] rs The rule memory for a certain item rep
@@ -206,14 +204,14 @@ module Nanoc
     def make_rule_memory_serializable(rs)
       rs.map do |r|
         if r[0] == :filter
-          [r[0], r[1], r[2].to_a.map { |a| Nanoc::Checksummer.calc(a) }]
+          [r[0], r[1], r[2].to_a.map { |a| Nanoc::Int::Checksummer.calc(a) }]
         else
           r
         end
       end
     end
 
-    # @param [Nanoc::Layout] layout The layout to get the rule memory for
+    # @param [Nanoc::Int::Layout] layout The layout to get the rule memory for
     #
     # @return [Array] The rule memory for the given layout
     def new_rule_memory_for_layout(layout)
@@ -221,7 +219,7 @@ module Nanoc
     end
     memoize :new_rule_memory_for_layout
 
-    # @param [Nanoc::ItemRep] rep The item representation for which to fetch
+    # @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
@@ -233,7 +231,7 @@ module Nanoc
       end
     end
 
-    # @param [Nanoc::Item] obj The object for which to check the rule memory
+    # @param [Nanoc::Int::Item] obj The object for which to check the rule memory
     #
     # @return [Boolean] true if the rule memory for the given object has
     # changed since the last compilation, false otherwise
@@ -242,12 +240,12 @@ module Nanoc
     end
     memoize :rule_memory_differs_for
 
-    # @return [Nanoc::RuleMemoryStore] The rule memory store
+    # @return [Nanoc::Int::RuleMemoryStore] The rule memory store
     def rule_memory_store
       @compiler.rule_memory_store
     end
 
-    # @return [Nanoc::RuleMemoryCalculator] The rule memory calculator
+    # @return [Nanoc::Int::RuleMemoryCalculator] The rule memory calculator
     def rule_memory_calculator
       @compiler.rule_memory_calculator
     end

data/lib/nanoc/base/context.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-module Nanoc
+module Nanoc::Int
   # Provides a context and a binding for use in filters such as the ERB and
   # Haml ones.
   class Context
@@ -15,7 +15,7 @@ module Nanoc
     #
     # @example Defining a context and accessing values
     #
-    #     context = Nanoc::Context.new(
+    #     context = Nanoc::Int::Context.new(
     #       :name     => 'Max Payne',
     #       :location => 'in a cheap motel'
     #     )

data/lib/nanoc/base/core_ext/array.rb

@@ -1,55 +1,46 @@
 # encoding: utf-8
 
+# @api private
 module Nanoc::ArrayExtensions
   # Returns a new array where all items' keys are recursively converted to
-  # symbols by calling {Nanoc::ArrayExtensions#symbolize_keys_recursively} or
-  # {Nanoc::HashExtensions#symbolize_keys_recursively}.
+  # symbols by calling {Nanoc::ArrayExtensions#__nanoc_symbolize_keys_recursively} or
+  # {Nanoc::HashExtensions#__nanoc_symbolize_keys_recursively}.
   #
   # @return [Array] The converted array
-  def symbolize_keys_recursively
+  def __nanoc_symbolize_keys_recursively
     array = []
     each do |element|
-      array << (element.respond_to?(:symbolize_keys_recursively) ? element.symbolize_keys_recursively : element)
+      array << (element.respond_to?(:__nanoc_symbolize_keys_recursively) ? element.__nanoc_symbolize_keys_recursively : element)
     end
     array
   end
 
-  # @deprecated Renamed to {#symbolize_keys_recursively}
-  def symbolize_keys
-    symbolize_keys_recursively
-  end
-
   # Returns a new array where all items' keys are recursively converted to
-  # strings by calling {Nanoc::ArrayExtensions#stringify_keys_recursively} or
-  # {Nanoc::HashExtensions#stringify_keys_recursively}.
+  # strings by calling {Nanoc::ArrayExtensions#__nanoc_stringify_keys_recursively} or
+  # {Nanoc::HashExtensions#__nanoc_stringify_keys_recursively}.
   #
   # @return [Array] The converted array
-  def stringify_keys_recursively
+  def __nanoc_stringify_keys_recursively
     reduce([]) do |array, element|
-      array + [element.respond_to?(:stringify_keys_recursively) ? element.stringify_keys_recursively : element]
+      array + [element.respond_to?(:__nanoc_stringify_keys_recursively) ? element.__nanoc_stringify_keys_recursively : element]
     end
   end
 
-  # @deprecated Renamed to {#stringify_keys_recursively}
-  def stringify_keys
-    stringify_keys_recursively
-  end
-
   # Freezes the contents of the array, as well as all array elements. The
-  # array elements will be frozen using {#freeze_recursively} if they respond
+  # array elements will be frozen using {#__nanoc_freeze_recursively} if they respond
   # to that message, or #freeze if they do not.
   #
-  # @see Hash#freeze_recursively
+  # @see Hash#__nanoc_freeze_recursively
   #
   # @return [void]
   #
   # @since 3.2.0
-  def freeze_recursively
+  def __nanoc_freeze_recursively
     return if self.frozen?
     freeze
     each do |value|
-      if value.respond_to?(:freeze_recursively)
-        value.freeze_recursively
+      if value.respond_to?(:__nanoc_freeze_recursively)
+        value.__nanoc_freeze_recursively
       else
         value.freeze
       end
@@ -62,11 +53,12 @@ module Nanoc::ArrayExtensions
   # @return [String] The checksum for this array
   #
   # @api private
-  def checksum
-    Nanoc::Checksummer.calc(self)
+  def __nanoc_checksum
+    Nanoc::Int::Checksummer.calc(self)
   end
 end
 
+# @api private
 class Array
   include Nanoc::ArrayExtensions
 end