nanoc3 3.2.0a3 → 3.2.0a4

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

@@ -16,6 +16,8 @@ module Nanoc3
 
     # @return [Symbol] The name of the snapshot this rule will apply to.
     #   Ignored for compilation rules, but used for routing rules.
+    #
+    # @since 3.2.0
     attr_reader :snapshot_name
 
     # Creates a new item compilation rule with the given identifier regex,
@@ -62,7 +64,7 @@ module Nanoc3
     # @return [void]
     def apply_to(rep, params={})
       compiler = params[:compiler] or raise ArgumentError, "Required :compiler option is missing"
-      rep = Nanoc3::ItemRepProxy.new(rep, compiler)
+      rep = Nanoc3::ItemRepProxy.new(rep, compiler) unless rep.is_proxy?
       Nanoc3::RuleContext.new(:rep => rep, :compiler => compiler).instance_eval &@block
     end
 

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Nanoc3
+
+  # Calculates rule memories for objects that can be run through a rule (item
+  # representations and layouts).
+  #
+  # @api private
+  class RuleMemoryCalculator
+
+    extend Nanoc3::Memoization
+
+    # @option params [Nanoc3::RulesCollection] rules_collection The rules
+    #   collection
+    def initialize(params={})
+      super('tmp/rule_memory', 1)
+
+      @rules_collection = params[:rules_collection] or
+        raise ArgumentError, "Required :rules_collection option is missing"
+    end
+
+    # @param [#reference] obj The object to calculate the rule memory for
+    #
+    # @return [Array] The caluclated rule memory for the given object
+    def [](obj)
+      result = case obj.type
+        when :item_rep
+          @rules_collection.new_rule_memory_for_rep(obj)
+        when :layout
+          @rules_collection.new_rule_memory_for_layout(obj)
+        else
+          raise RuntimeError,
+            "Do not know how to calculate the rule memory for #{obj.inspect}"
+      end
+
+      result
+    end
+    memoize :[]
+
+  end
+
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Nanoc3
+
+  # Stores rule memories for objects that can be run through a rule (item
+  # representations and layouts).
+  #
+  # @api private
+  class RuleMemoryStore < ::Nanoc3::Store
+
+    # @option params [Nanoc3::Site] site The site where this rule memory store
+    #   belongs to
+    def initialize(params={})
+      super('tmp/rule_memory', 1)
+
+      @site = params[:site] if params.has_key?(:site)
+
+      @rule_memories = {}
+    end
+
+    # @param [Nanoc3::ItemRep, Nanoc3::Layout] obj The item representation or
+    #   the layout to get the rule memory for
+    #
+    # @return [Array] The rule memory for the given object
+    def [](obj)
+      @rule_memories[obj.reference]
+    end
+
+    # @param [Nanoc3::ItemRep, Nanoc3::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
+    #
+    # @return [void]
+    def []=(obj, rule_memory)
+      @rule_memories[obj.reference] = rule_memory
+    end
+
+  protected
+
+    # @see Nanoc3::Store#data
+    def data
+      @rule_memories
+    end
+
+    # @see Nanoc3::Store#data=
+    def data=(new_data)
+      @rule_memories = new_data
+    end
+
+  end
+
+end

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

@@ -0,0 +1,205 @@
+module Nanoc3
+
+  # Keeps track of the rules in a site.
+  #
+  # @api private
+  class RulesCollection
+
+    extend Nanoc3::Memoization
+
+    # @return [Array<Nanoc3::Rule>] The list of item compilation rules that
+    #   will be used to compile items.
+    attr_reader :item_compilation_rules
+
+    # @return [Array<Nanoc3::Rule>] The list of routing rules that will be
+    #   used to give all items a path.
+    attr_reader :item_routing_rules
+
+    # The hash containing layout-to-filter mapping rules. This hash is
+    # ordered: iterating over the hash will happen in insertion order.
+    #
+    # @return [Hash] The layout-to-filter mapping rules
+    attr_reader :layout_filter_mapping
+
+    # @return [Proc] The code block that will be executed after all data is
+    #   loaded but before the site is compiled
+    attr_accessor :preprocessor
+
+    # @param [Nanoc3::Compiler] compiler The site’s compiler
+    def initialize(compiler)
+      @compiler = compiler
+
+      @item_compilation_rules  = []
+      @item_routing_rules      = []
+      @layout_filter_mapping   = OrderedHash.new
+    end
+
+    # TODO document
+    def add_item_compilation_rule(rule, position=:after)
+      case position
+      when :before
+        @item_compilation_rules.unshift(rule)
+      when :after
+        @item_compilation_rules << rule
+      else
+        raise "#add_item_routing_rule expected position to be :after or :before"
+      end
+    end
+
+    # TODO document
+    def add_item_routing_rule(rule, position=:after)
+      case position
+      when :before
+        @item_routing_rules.unshift(rule)
+      when :after
+        @item_routing_rules << rule
+      else
+        raise "#add_item_routing_rule expected position to be :after or :before"
+      end
+    end
+
+    # TODO document
+    def item_compilation_rules_for(item)
+      @item_compilation_rules.select { |r| r.applicable_to?(item) }
+    end
+
+    # Loads this site’s rules.
+    def load
+      # Find rules file
+      rules_filenames = [ 'Rules', 'rules', 'Rules.rb', 'rules.rb' ]
+      rules_filename = rules_filenames.find { |f| File.file?(f) }
+      raise Nanoc3::Errors::NoRulesFileFound.new if rules_filename.nil?
+
+      # Get rule data
+      @data = File.read(rules_filename)
+
+      # Load DSL
+      dsl.instance_eval(@data, "./#{rules_filename}")
+    end
+
+    # Unloads this site’s rules.
+    def unload
+      @item_compilation_rules  = []
+      @item_routing_rules      = []
+      @layout_filter_mapping   = OrderedHash.new
+    end
+
+    # Finds the first matching compilation rule for the given item
+    # representation.
+    #
+    # @param [Nanoc3::ItemRep] rep The item rep for which to fetch the rule
+    #
+    # @return [Nanoc3::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|
+        rule.applicable_to?(rep.item) && rule.rep_name == rep.name
+      end
+    end
+
+    # Finds the first matching routing rule for the given item representation.
+    #
+    # @param [Nanoc3::ItemRep] rep The item rep for which to fetch the rule
+    #
+    # @return [Nanoc3::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|
+        rule.applicable_to?(rep.item) && rule.rep_name == rep.name
+      end
+    end
+
+    # Returns the list of routing rules that can be applied to the given item
+    # representation. For each snapshot, the first matching rule will be
+    # returned. The result is a hash containing the corresponding rule for
+    # each snapshot.
+    #
+    # @return [Hash<Symbol, Nanoc3::Rule>] The routing rules for the given rep
+    def routing_rules_for(rep)
+      rules = {}
+      @item_routing_rules.each do |rule|
+        next if !rule.applicable_to?(rep.item)
+        next if rule.rep_name != rep.name
+        next if rules.has_key?(rule.snapshot_name)
+
+        rules[rule.snapshot_name] = rule
+      end
+      rules
+    end
+
+    # Finds the filter name and arguments to use for the given layout.
+    #
+    # @param [Nanoc3::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.
+    def filter_for_layout(layout)
+      @layout_filter_mapping.each_pair do |layout_identifier, filter_name_and_args|
+        return filter_name_and_args if layout.identifier =~ layout_identifier
+      end
+      nil
+    end
+
+    # Returns the Nanoc3::CompilerDSL that should be used for this site.
+    def dsl
+      Nanoc3::CompilerDSL.new(self)
+    end
+    memoize :dsl
+
+    # TODO document
+    def reference
+      :rules
+    end
+
+    # TODO document
+    def data
+      @data
+    end
+
+    # TODO document
+    def checksum
+      @data.checksum
+    end
+
+    def inspect
+      "<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+
+    # @param [Nanoc3::ItemRep] rep The item representation to get the rule
+    #   memory for
+    #
+    # @return [Array] The rule memory for the given item representation
+    def new_rule_memory_for_rep(rep)
+      recording_proxy = rep.to_recording_proxy
+      compilation_rule_for(rep).apply_to(recording_proxy, :compiler => @compiler)
+      recording_proxy.rule_memory
+    end
+    memoize :new_rule_memory_for_rep
+
+    # @param [Nanoc3::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)
+      filter_for_layout(layout)
+    end
+    memoize :new_rule_memory_for_layout
+
+    # TODO document
+    def rule_memory_differs_for(obj)
+      !rule_memory_store[obj].eql?(rule_memory_calculator[obj])
+    end
+    memoize :rule_memory_differs_for
+
+    # TODO document
+    def rule_memory_store
+      @compiler.rule_memory_store
+    end
+
+    # TODO document
+    def rule_memory_calculator
+      @compiler.rule_memory_calculator
+    end
+
+  end
+
+end

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

@@ -24,6 +24,26 @@ module Nanoc3::ArrayExtensions
     end
   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
+  # to that message, or #freeze if they do not.
+  #
+  # @see Hash#freeze_recursively
+  #
+  # @return [void]
+  #
+  # @since 3.2.0
+  def freeze_recursively
+    freeze
+    each do |value|
+      if value.respond_to?(:freeze_recursively)
+        value.freeze_recursively
+      else
+        value.freeze
+      end
+    end
+  end
+
 end
 
 class Array

data/lib/nanoc3/base/core_ext/hash.rb

@@ -24,6 +24,36 @@ module Nanoc3::HashExtensions
     end
   end
 
+  # Freezes the contents of the hash, as well as all hash values. The hash
+  # values will be frozen using {#freeze_recursively} if they respond to
+  # that message, or #freeze if they do not.
+  #
+  # @see Array#freeze_recursively
+  #
+  # @return [void]
+  #
+  # @since 3.2.0
+  def freeze_recursively
+    freeze
+    each_pair do |key, value|
+      if value.respond_to?(:freeze_recursively)
+        value.freeze_recursively
+      else
+        value.freeze
+      end
+    end
+  end
+
+  # Calculates the checksum for this hash. Any change to this hash will result
+  # in a different checksum.
+  #
+  # @return [String] The checksum for this hash
+  #
+  # @api private
+  def checksum
+    Marshal.dump(self).checksum
+  end
+
 end
 
 class Hash

data/lib/nanoc3/base/core_ext/pathname.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Nanoc3::PathnameExtensions
+
+  # Calculates the checksum for the file referenced to by this pathname. Any
+  # change to the file contents will result in a different checksum.
+  #
+  # @return [String] The checksum for this file
+  #
+  # @api private
+  def checksum
+    digest = Digest::SHA1.new
+    File.open(self.to_s, 'r') do |io|
+      until io.eof
+        data = io.readpartial(2**10)
+        digest.update(data)
+      end
+    end
+    digest.hexdigest
+  end
+
+end
+
+class Pathname
+  include Nanoc3::PathnameExtensions
+end

data/lib/nanoc3/base/core_ext/string.rb

@@ -27,6 +27,18 @@ module Nanoc3::StringExtensions
     self.gsub(/“|”/, '"').gsub(/‘|’/, '\'').gsub('…', '...')
   end
 
+  # Calculates the checksum for this string. Any change to this string will
+  # result in a different checksum.
+  #
+  # @return [String] The checksum for this string
+  #
+  # @api private
+  def checksum
+    digest = Digest::SHA1.new
+    digest.update(self)
+    digest.hexdigest
+  end
+
 end
 
 class String

data/lib/nanoc3/base/core_ext.rb

@@ -2,4 +2,5 @@
 
 require 'nanoc3/base/core_ext/array'
 require 'nanoc3/base/core_ext/hash'
+require 'nanoc3/base/core_ext/pathname'
 require 'nanoc3/base/core_ext/string'

data/lib/nanoc3/base/directed_graph.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'set'
-
 module Nanoc3
 
   # Represents a directed graph. It is used by the dependency tracker for
@@ -89,6 +87,8 @@ module Nanoc3
     # @param to   End vertex of the edge
     #
     # @return [void]
+    #
+    # @since 3.2.0
     def delete_edge(from, to)
       @from_graph[from] ||= Set.new
       @from_graph[from].delete(to)
@@ -103,9 +103,11 @@ module Nanoc3
 
     # Adds the given vertex to the graph.
     #
-    # @param [Vertex] v The vertex to add to the graph
+    # @param v The vertex to add to the graph
     #
     # @return [void]
+    #
+    # @since 3.2.0
     def add_vertex(v)
       return if @vertices.include?(v)
 
@@ -120,6 +122,8 @@ module Nanoc3
     # @param from Vertex from which all edges should be removed
     #
     # @return [void]
+    #
+    # @since 3.2.0
     def delete_edges_from(from)
       return if @from_graph[from].nil?
 
@@ -150,6 +154,8 @@ module Nanoc3
     # @param v Vertex to remove from the graph
     #
     # @return [void]
+    #
+    # @since 3.2.0
     def delete_vertex(v)
       delete_edges_to(v)
       delete_edges_from(v)
@@ -217,6 +223,8 @@ module Nanoc3
     # Returns all root vertices, i.e. vertices where no edge points to.
     #
     # @return [Set] The set of all root vertices in this graph.
+    #
+    # @since 3.2.0
     def roots
       @roots
     end

data/lib/nanoc3/base/errors.rb

@@ -160,10 +160,6 @@ module Nanoc3
 
     end
 
-    # Error that is raised when an internal consistency error is detected.
-    class InternalConsistency < Generic
-    end
-
     # @deprecated No longer necessary, but kept for backwards compatibility.
     class DataNotYetAvailable < Generic
 

data/lib/nanoc3/base/memoization.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module Nanoc3
+
+  # Adds support for memoizing functions.
+  #
+  # @since 3.2.0
+  module Memoization
+
+    CACHE = {}
+
+    # Memoizes the method with the given name. The modified method will cache
+    # the results of the original method, so that calling a method twice with
+    # the same arguments will short-circuit and return the cached results
+    # immediately.
+    #
+    # Memoization assumes that the current object as well as the function
+    # arguments are immutable. Mutating the object or the arguments will not
+    # cause memoized methods to recalculate their results. There is no way to
+    # un-memoize a result, and calculation results will remain in memory even
+    # if they are no longer needed.
+    #
+    # @example A fast fib function due to memoization
+    #
+    #     class FibFast
+    # 
+    #       extend Nanoc3::Memoization
+    # 
+    #       def run(n)
+    #         if n == 0
+    #           0
+    #         elsif n == 1
+    #           1
+    #         else
+    #           run(n-1) + run(n-2)
+    #         end
+    #       end
+    #       memoize :run
+    # 
+    #     end
+    #
+    # @param [Symbol, String] method_name The name of the method to memoize
+    #
+    # @return [void]
+    def memoize(method_name)
+      # Alias
+      original_method_name = '__nonmemoized_' + method_name.to_s
+      alias_method original_method_name, method_name
+
+      # Redefine
+      define_method(method_name) do |*args|
+        # Get method-specific cache
+        key = [ self, method_name ]
+        if !CACHE.has_key?(key)
+          CACHE[key] = {}
+        end
+        method_cache = CACHE[key]
+
+        # Recalculate if necessary
+        if !method_cache.has_key?(args)
+          result = send(original_method_name, *args)
+          method_cache[args] = result
+        end
+
+        # Done
+        method_cache[args]
+      end
+    end
+
+  end
+
+end