nanoc 3.2.4 → 3.3.0

data/lib/nanoc/base/errors.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Module that contains all nanoc-specific errors.
+  module Errors
+
+    # Generic error. Superclass for all nanoc-specific errors.
+    class Generic < ::StandardError
+    end
+
+    # Error that is raised when a site is loaded that uses a data source with
+    # an unknown identifier.
+    class UnknownDataSource < Generic
+
+      # @param [String] data_source_name The data source name for which no
+      #   data source could be found
+      def initialize(data_source_name)
+        super("The data source specified in the site’s configuration file, “#{data_source_name}”, does not exist.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised during site compilation when an item uses a layout
+    # that is not present in the site.
+    class UnknownLayout < Generic
+
+      # @param [String] layout_identifier The layout identifier for which no
+      #   layout could be found
+      def initialize(layout_identifier)
+        super("The site does not have a layout with identifier “#{layout_identifier}”.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised during site compilation when an item uses a filter
+    # that is not known.
+    class UnknownFilter < Generic
+
+      # @param [Symbol] filter_name The filter name for which no filter could
+      #   be found
+      def initialize(filter_name)
+        super("The requested filter, “#{filter_name}”, does not exist.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised during site compilation when a layout is compiled
+    # for which the filter cannot be determined. This is similar to the
+    # {UnknownFilter} error, but specific for filters for layouts.
+    class CannotDetermineFilter < Generic
+
+      # @param [String] layout_identifier The identifier of the layout for
+      #   which the filter could not be determined
+      def initialize(layout_identifier)
+        super("The filter to be used for the “#{layout_identifier}” layout could not be determined. Make sure the layout does have a filter.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised during site compilation when an item (directly or
+    # indirectly) includes its own item content, leading to endless recursion.
+    class RecursiveCompilation < Generic
+
+      # @param [Array<Nanoc::ItemRep>] reps A list of item representations
+      #   that mutually depend on each other
+      def initialize(reps)
+        list = reps.map { |r| r.inspect }.join("\n")
+        super("The site cannot be compiled because the following items mutually depend on each other:\n#{list}.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when no rules file can be found in the current
+    # working directory.
+    class NoRulesFileFound < Generic
+
+      def initialize
+        super("This site does not have a rules file, which is required for nanoc sites.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when no compilation rule that can be applied to the
+    # current item can be found.
+    class NoMatchingCompilationRuleFound < Generic
+
+      # @param [Nanoc::Item] item The item for which no compilation rule
+      #   could be found
+      def initialize(item)
+        super("No compilation rules were found for the “#{item.identifier}” item.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when no routing rule that can be applied to the
+    # current item can be found.
+    class NoMatchingRoutingRuleFound < Generic
+
+      # @param [Nanoc::Item] item The item for which no routing rule could be
+      #   found
+      def initialize(rep)
+        super("No routing rules were found for the “#{rep.item.identifier}” item (rep “#{rep.name}”).".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when an rep cannot be compiled because it depends
+    # on other representations.
+    class UnmetDependency < Generic
+
+      # @return [Nanoc::ItemRep] The item representation that cannot yet be
+      #   compiled
+      attr_reader :rep
+
+      # @param [Nanoc::ItemRep] The item representation that cannot yet be
+      #   compiled
+      def initialize(rep)
+        @rep = rep
+        super("The current item cannot be compiled yet because of an unmet dependency on the “#{rep.item.identifier}” item (rep “#{rep.name}”).".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when a binary item is attempted to be laid out.
+    class CannotLayoutBinaryItem < Generic
+
+      # @param [Nanoc::ItemRep] The item representation that was attempted to
+      #   be laid out
+      def initialize(rep)
+        super("The “{rep.item.identifier}” item (rep “#{rep.name}”) cannot be laid out because it is a binary item. If you are getting this error for an item that should be textual instead of binary, make sure that its extension is included in the text_extensions array in the site configuration.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when a textual filter is attempted to be applied to
+    # a binary item representation.
+    class CannotUseTextualFilter < Generic
+
+      # @param [Nanoc::ItemRep] rep The item representation that was
+      #   attempted to be filtered
+      #
+      # @param [Class] filter_class The filter class that was used
+      def initialize(rep, filter_class)
+        super("The “#{filter_class.inspect}” filter cannot be used to filter the “#{rep.item.identifier}” item (rep “#{rep.name}”), because textual filters cannot be used on binary items.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when a binary filter is attempted to be applied to
+    # a textual item representation.
+    class CannotUseBinaryFilter < Generic
+
+      # @param [Nanoc::ItemRep] rep The item representation that was
+      #   attempted to be filtered
+      #
+      # @param [Class] filter_class The filter class that was used
+      def initialize(rep, filter_class)
+        super("The “#{filter_class.inspect}” filter cannot be used to filter the “#{rep.item.identifier}” item (rep “#{rep.name}”), because binary filters cannot be used on textual items. If you are getting this error for an item that should be textual instead of binary, make sure that its extension is included in the text_extensions array in the site configuration.".make_compatible_with_env)
+      end
+
+    end
+
+    # Error that is raised when the compiled content at a non-existing snapshot
+    # is requested.
+    class NoSuchSnapshot < Generic
+
+      # @return [Nanoc::ItemRep] The item rep from which the compiled content
+      #   was requested
+      attr_reader :item_rep
+
+      # @return [Symbol] The requested snapshot
+      attr_reader :snapshot
+
+      # @param [Nanoc::ItemRep] item_rep The item rep from which the compiled
+      #   content was requested
+      #
+      # @param [Symbol] snapshot The requested snapshot
+      def initialize(item_rep, snapshot)
+        @item_rep, @snapshot = item_rep, snapshot
+        super("The “#{item_rep.inspect}” item rep does not have a snapshot “#{snapshot.inspect}”")
+      end
+
+    end
+
+    # Error that is raised when a snapshot with an existing name is made.
+    class CannotCreateMultipleSnapshotsWithSameName < Generic
+
+      # @param [Nanoc::ItemRep] rep The item representation for which a
+      #   snapshot was attempted to be made
+      #
+      # @param [Symbol] snapshot The name of the snapshot that was attempted to
+      #   be made
+      def initialize(rep, snapshot)
+        super("Attempted to create a snapshot with a duplicate name #{snapshot.inspect} for the item rep “#{rep.inspect}”".make_compatible_with_env)
+      end
+
+    end
+
+    # @deprecated No longer necessary, but kept for backwards compatibility.
+    class DataNotYetAvailable < Generic
+
+      def initialize(type, plural)
+        super("#{type} #{plural ? 'are' : 'is'} not available yet. You may be missing a Nanoc::Site#load_data call.".make_compatible_with_env)
+      end
+
+    end
+
+  end
+
+end

data/lib/nanoc/base/memoization.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Adds support for memoizing functions.
+  #
+  # @since 3.2.0
+  module Memoization
+
+    # 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 Nanoc::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 cache
+        @__memoization_cache ||= {}
+        @__memoization_cache[method_name] ||= {}
+
+        # Recalculate if necessary
+        if !@__memoization_cache[method_name].has_key?(args)
+          result = send(original_method_name, *args)
+          @__memoization_cache[method_name][args] = result
+        end
+
+        # Done
+        @__memoization_cache[method_name][args]
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/base/notification_center.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # Provides a way to send notifications between objects. It allows blocks
+  # associated with a certain notification name to be registered; these blocks
+  # will be called when the notification with the given name is posted.
+  #
+  # It is a slightly different implementation of the Observer pattern; the
+  # table of subscribers is not stored in the observable object itself, but in
+  # the notification center.
+  class NotificationCenter
+
+    class << self
+
+      # Adds the given block to the list of blocks that should be called when
+      # the notification with the given name is received.
+      #
+      # @param [String, Symbol] name The name of the notification that will
+      #   cause the given block to be called.
+      #
+      # @param [String, Symbol, nil] id An identifier for the block. This is
+      #   only used to be able to remove the block (using the remove method)
+      #   later. Can be nil, but this is not recommended because it prevents
+      #   the given notification block from being unregistered.
+      #
+      # @yield [*args] Will be executed with the arguments passed to {.post}
+      #
+      # @return [void]
+      def on(name, id=nil, &block)
+        initialize_if_necessary(name)
+
+        # Add observer
+        @notifications[name] << { :id => id, :block => block }
+      end
+
+      # Posts a notification with the given name and the given arguments.
+      #
+      # @param [String, Symbol] name The name of the notification that should
+      #   be posted.
+      #
+      # @param args Arguments that wil be passed to the blocks handling the
+      #   notification.
+      #
+      # @return [void]
+      def post(name, *args)
+        initialize_if_necessary(name)
+
+        # Notify all observers
+        @notifications[name].each do |observer|
+          observer[:block].call(*args)
+        end
+      end
+
+      # Removes the block with the given identifier from the list of blocks
+      # that should be called when the notification with the given name is
+      # posted.
+      #
+      # @param [String, Symbol] name The name of the notification that should
+      #   no longer be registered.
+      #
+      # @param [String, Symbol] id The identifier of the block that should be
+      #   removed.
+      #
+      # @return [void]
+      def remove(name, id)
+        initialize_if_necessary(name)
+
+        # Remove relevant observers
+        @notifications[name].reject! { |i| i[:id] == id }
+      end
+
+    private
+
+      def initialize_if_necessary(name)
+        @notifications ||= {}       # name => observers dictionary
+        @notifications[name] ||= [] # list of observers
+      end
+
+    end
+
+  end
+
+end

data/lib/nanoc/base/ordered_hash.rb

@@ -0,0 +1,200 @@
+
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+class OrderedHash < ::Hash
+    attr_accessor :order
+
+    class << self
+        def [] *args
+          hsh = OrderedHash.new
+          if Hash === args[0]
+            hsh.replace args[0]
+          elsif (args.size % 2) != 0
+            raise ArgumentError, "odd number of elements for Hash"
+          else
+            0.step(args.size - 1, 2) do |a|
+              b = a + 1
+              hsh[args[a]] = args[b]
+            end
+          end
+          hsh
+        end
+    end
+    def initialize(*a, &b)
+      super
+      @order = []
+    end
+    def store_only a,b
+        store a,b
+    end
+    alias orig_store store    
+    def store a,b
+        @order.push a unless has_key? a
+        super a,b
+    end
+    alias []= store
+    def == hsh2
+        return false if @order != hsh2.order
+        super hsh2
+    end
+    def clear
+        @order = []
+        super
+    end
+    def delete key
+        @order.delete key
+        super
+    end
+    def each_key
+        @order.each { |k| yield k }
+        self
+    end
+    def each_value
+        @order.each { |k| yield self[k] }
+        self
+    end
+    def each
+        @order.each { |k| yield k,self[k] }
+        self
+    end
+    alias each_pair each    
+    def delete_if
+        @order.clone.each { |k| 
+            delete k if yield(k)
+        }
+        self
+    end
+    def values
+        ary = []
+        @order.each { |k| ary.push self[k] }
+        ary
+    end
+    def keys
+        @order
+    end
+    def first
+      {@order.first => self[@order.first]}
+    end
+    def last
+      {@order.last => self[@order.last]}
+    end
+    def invert
+        hsh2 = Hash.new    
+        @order.each { |k| hsh2[self[k]] = k }
+        hsh2
+    end
+    def reject &block
+        self.dup.delete_if &block
+    end
+    def reject! &block
+        hsh2 = reject &block
+        self == hsh2 ? nil : hsh2
+    end
+    def replace hsh2
+        @order = hsh2.keys 
+        super hsh2
+    end
+    def shift
+        key = @order.first
+        key ? [key,delete(key)] : super
+    end
+    def unshift k,v
+        unless self.include? k
+            @order.unshift k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    def push k,v
+        unless self.include? k
+            @order.push k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    def pop
+        key = @order.last
+        key ? [key,delete(key)] : nil
+    end
+    def to_a
+        ary = []
+        each { |k,v| ary << [k,v] }
+        ary
+    end
+    def to_s
+        self.to_a.to_s
+    end
+    def inspect
+        ary = []
+        each {|k,v| ary << k.inspect + "=>" + v.inspect}
+        '{' + ary.join(", ") + '}'
+    end
+    def update hsh2
+        hsh2.each { |k,v| self[k] = v }
+        self
+    end
+    alias :merge! update
+    def merge hsh2
+        self.dup update(hsh2)
+    end
+    def select
+        ary = []
+        each { |k,v| ary << [k,v] if yield k,v }
+        ary
+    end
+    def class
+      Hash
+    end
+    def __class__
+      OrderedHash
+    end
+
+    attr_accessor "to_yaml_style"
+    def yaml_inline= bool
+      if respond_to?("to_yaml_style")
+        self.to_yaml_style = :inline
+      else
+        unless defined? @__yaml_inline_meth
+          @__yaml_inline_meth =
+            lambda {|opts|
+              YAML::quick_emit(object_id, opts) {|emitter|
+                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
+              }
+            }
+          class << self
+            def to_yaml opts = {}
+              begin
+                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+              rescue
+                @to_yaml_style = :inline
+                super
+              end
+            end
+          end
+        end
+      end
+      @__yaml_inline = bool
+    end
+    def yaml_inline!() self.yaml_inline = true end
+
+    def each_with_index
+      @order.each_with_index { |k, index| yield k, self[k], index }
+      self
+    end
+end # class OrderedHash
+
+def OrderedHash(*a, &b)
+  OrderedHash.new(*a, &b)
+end