nanoc 2.0.4 → 2.1

data/lib/nanoc/base/defaults.rb

@@ -0,0 +1,30 @@
+module Nanoc
+
+  # Nanoc::Defaults represent the default attributes for a given set of
+  # objects in the site. It is basically a hash with an optional modification
+  # time.
+  class Defaults
+
+    # Th site where this set of defaults belongs to.
+    attr_accessor :site
+
+    # A hash containing the default attributes.
+    attr_reader   :attributes
+
+    # The time when this set of defaults was last modified.
+    attr_reader   :mtime
+
+    # Creates a new set of defaults.
+    #
+    # +attributes+:: The hash containing the metadata that individual objects
+    #                will override.
+    #
+    # +mtime+:: The time when the defaults were last modified (optional).
+    def initialize(attributes, mtime=nil)
+      @attributes = attributes.clean
+      @mtime      = mtime
+    end
+
+  end
+
+end

data/lib/nanoc/base/enhancements.rb

@@ -1,89 +1,14 @@
-# Get requirements
-begin ; require 'rubygems' ; rescue LoadError ; end
-require 'yaml'
-require 'fileutils'
-
-# Logging (level can be :off, :high, :low)
-$log_level = :high
-def log(log_level, s, io=$stdout)
-  io.puts s if ($log_level == :low or $log_level == log_level) and $log_level != :off
+# Convenience function for printing warnings
+def warn(s, pre='WARNING')
+  $stderr.puts "#{pre}: #{s}"
 end
 
-# Convenience function for printing errors
-def error(s, pre='ERROR')
-  log(:high, pre + ': ' + s, $stderr)
-  exit(1)
-end
+############################# OLD AND DEPRECATED #############################
 
-# Convenience function for requiring libraries
-def nanoc_require(x, message="'#{x}' is required to compile this site.")
+def nanoc_require(x)
+  warn(
+    "'nanoc_require' is deprecated and will be removed in a future version. Please use 'require' instead.",
+    'DEPRECATION WARNING'
+  )
   require x
-rescue LoadError
-  error(message)
-end
-
-# Rendering sub-layouts
-def render(name, other_assigns={})
-  layout = @site.layouts.find { |l| l[:name] == name }
-  layout_processor_class = Nanoc::PluginManager.layout_processor_for_extension(layout[:extension])
-  layout_processor = layout_processor_class.new(@page, @pages, @site.config, @site, other_assigns)
-  layout_processor.run(layout[:content])
-end
-
-# Convenience function for cd'ing in and out of a directory
-def in_dir(path)
-  FileUtils.cd(File.join(path))
-  yield
-ensure
-  FileUtils.cd(File.join(path.map { |n| '..' }))
-end
-
-class FileManager
-
-  ACTION_COLORS = {
-    :create     => "\e[1m" + "\e[32m", # bold + green
-    :update     => "\e[1m" + "\e[33m", # bold + yellow
-    :identical  => "\e[1m"             # bold
-  }
-
-  def self.file_log(log_level, action, path)
-    log(log_level, '%s%12s%s  %s' % [ACTION_COLORS[action.to_sym], action, "\e[0m", path])
-  end
-
-  def self.create_dir(name)
-    # Check whether directory exists
-    return if File.exist?(name)
-
-    # Create dir
-    FileUtils.mkdir_p(name)
-    log(:create, name)
-  end
-
-  def self.create_file(path)
-    # Create parent directory if necessary
-    if path =~ /\//
-      parent_path = path.sub(/\/[^\/]+$/, '')
-      FileManager.create_dir(parent_path)
-    end
-
-    # Get contents
-    content_old = File.exist?(path) ? File.read(path) : nil
-    content_new = yield
-    content_new = content_new.force_encoding(content_old.encoding) if content_old and String.method_defined?(:force_encoding)
-    modified = (content_old != content_new)
-
-    # Log
-    if File.exist?(path)
-      file_log(*(modified ? [ :high, :update, path ] : [ :low, :identical, path ]))
-    else
-      file_log(:high, :create, path)
-    end
-
-    # Write
-    open(path, 'w') { |io| io.write(content_new) }
-
-    # Report back
-    modified
-  end
-
 end

data/lib/nanoc/base/filter.rb

@@ -1,16 +1,119 @@
 module Nanoc
+
+  # Nanoc::Filter is responsible for filtering pages and textual assets
+  # (binary assets are filtered using Nanoc::BinaryFilter). It is the
+  # (abstract) superclass for all textual filters. Subclasses should override
+  # the +run+ method.
   class Filter < Plugin
 
-    def initialize(page, pages, config, site)
-      @page   = page
-      @pages  = pages
-      @config = config
-      @site   = site
+    # Deprecated
+    EXTENSIONS_MAP = {}
+
+    # Creates a new filter for the given object (page or asset) and site.
+    #
+    # +kind+:: The kind of object that is passed. Can be either +:page+ or
+    #          +:asset+.
+    #
+    # +obj_rep+:: A proxy for the page or asset representation (Nanoc::PageRep
+    #             or Nanoc::AssetRep) that should be compiled by this filter.
+    #
+    # +obj+:: A proxy for the page or asset's page (Nanoc::Page or
+    #         Nanoc::Asset).
+    #
+    # +site+:: The site (Nanoc::Site) this filter belongs to.
+    #
+    # +other_assigns+:: A hash containing other variables that should be made
+    #                   available during filtering.
+    def initialize(obj_rep, other_assigns={})
+      # Determine kind
+      @kind = obj_rep.is_a?(Nanoc::PageRep) ? :page : :asset
+
+      # Set object
+      @obj_rep = obj_rep
+      @obj     = (@kind == :page ? @obj_rep.page : @obj_rep.asset)
+
+      # Set page/asset and page/asset reps
+      if @kind == :page
+        @page       = @obj
+        @page_rep   = @obj_rep
+      else
+        @asset      = @obj
+        @asset_rep  = @obj_rep
+      end
+
+      # Set site
+      @site = @obj.site
+
+      # Set other assigns
+      @other_assigns  = other_assigns
     end
 
+    # Runs the filter. This method returns the filtered content.
+    #
+    # +content+:: The unprocessed content that should be filtered.
+    #
+    # Subclasses must implement this method.
     def run(content)
-      error 'Filter#run must be overridden'
+      raise NotImplementedError.new("Nanoc::Filter subclasses must implement #run")
+    end
+
+    # Returns a hash with data that should be available.
+    def assigns
+      @assigns ||= @other_assigns.merge({
+        :_obj_rep   => @obj_rep,
+        :_obj       => @obj,
+        :page_rep   => @kind == :page  ? @page_rep.to_proxy  : nil,
+        :page       => @kind == :page  ? @page.to_proxy      : nil,
+        :asset_rep  => @kind == :asset ? @asset_rep.to_proxy : nil,
+        :asset      => @kind == :asset ? @asset.to_proxy     : nil,
+        :pages      => @site.pages.map    { |obj| obj.to_proxy },
+        :assets     => @site.assets.map   { |obj| obj.to_proxy },
+        :layouts    => @site.layouts.map  { |obj| obj.to_proxy },
+        :config     => @site.config,
+        :site       => @site
+      })
+    end
+
+    class << self
+
+      # Deprecated
+      def extensions(*extensions) # :nodoc:
+        # Initialize
+        @extensions = [] unless instance_variables.include?('@extensions')
+
+        if extensions.empty?
+          @extensions
+        else
+          @extensions = extensions
+          @extensions.each { |e| register_extension(e, self) }
+        end
+      end
+
+      # Deprecated
+      def extension(extension=nil) # :nodoc:
+        # Initialize
+        @extensions = [] unless instance_variables.include?('@extensions')
+
+        if extension.nil?
+          @extensions.first
+        else
+          @extensions = [ extension ]
+          register_extension(extension, self)
+        end
+      end
+
+      # Deprecated
+      def register_extension(extension, klass)
+        EXTENSIONS_MAP[extension] = klass
+      end
+
+      # Deprecated
+      def with_extension(extension)
+        EXTENSIONS_MAP[extension]
+      end
+
     end
 
   end
+
 end

data/lib/nanoc/base/layout.rb

@@ -0,0 +1,91 @@
+module Nanoc
+
+  # A Nanoc::Layout represents a layout in a nanoc site. It has content,
+  # attributes (for determining which filter to use for laying out a page), a
+  # path (because layouts are organised hierarchically), and a modification
+  # time (to speed up compilation).
+  class Layout
+
+    # Default values for layouts.
+    DEFAULTS = {
+      :filter => 'erb'
+    }
+
+    # The Nanoc::Site this layout belongs to.
+    attr_accessor :site
+
+    # The raw content of this layout.
+    attr_reader :content
+
+    # A hash containing this layout's attributes.
+    attr_reader :attributes
+
+    # This layout's path, starting and ending with a slash.
+    attr_reader :path
+
+    # The time when this layout was last modified.
+    attr_reader :mtime
+
+    # Creates a new layout.
+    #
+    # +content+:: The raw content of this layout.
+    #
+    # +attributes+:: A hash containing this layout's attributes.
+    #
+    # +path+:: This layout's path, starting and ending with a slash.
+    #
+    # +mtime+:: The time when this layout was last modified.
+    def initialize(content, attributes, path, mtime=nil)
+      @content    = content
+      @attributes = attributes.clean
+      @path       = path.cleaned_path
+      @mtime      = mtime
+    end
+
+    # Returns a proxy (Nanoc::LayoutProxy) for this layout.
+    def to_proxy
+      @proxy ||= LayoutProxy.new(self)
+    end
+
+    # Returns the attribute with the given name.
+    def attribute_named(name)
+      return @attributes[name] if @attributes.has_key?(name)
+      return DEFAULTS[name]
+    end
+
+    # Returns the filter class needed for this layout.
+    def filter_class
+      if attribute_named(:extension).nil?
+        Nanoc::Filter.named(attribute_named(:filter))
+      else
+        Nanoc::Filter.with_extension(attribute_named(:extension))
+      end
+    end
+
+    # Saves the layout in the database, creating it if it doesn't exist yet or
+    # updating it if it already exists. Tells the site's data source to save
+    # the layout.
+    def save
+      @site.data_source.loading do
+        @site.data_source.save_layout(self)
+      end
+    end
+
+    # Moves the layout to a new path. Tells the site's data source to move the
+    # layout.
+    def move_to(new_path)
+      @site.data_source.loading do
+        @site.data_source.move_layout(self, new_path)
+      end
+    end
+
+    # Deletes the layout. Tells the site's data source to delete the layout.
+    def delete
+      @site.data_source.loading do
+        @site.data_source.delete_layout(self)
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/base/notification_center.rb

@@ -0,0 +1,66 @@
+module Nanoc
+
+  # Nanoc::NotificationCenter 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.
+      #
+      # +name+:: The name of the notification that will be posted.
+      #
+      # +id+:: An identifier for the block. This is only used to be able to
+      #        remove the block (using the remove method) later. Defaults to
+      #        nil.
+      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. All arguments wil be passed
+      # to the blocks handling the notification.
+      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.
+      #
+      # +name+:: The name of the notification that will be posted.
+      #
+      # +id+:: The identifier of the block that should be removed.
+      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/page.rb

@@ -1,160 +1,128 @@
 module Nanoc
+
+  # A Nanoc::Page represents a page in a nanoc site. It has content and
+  # attributes, as well as a path. It can also store the modification time to
+  # speed up compilation.
+  #
+  # Each page has a list of page representations or reps (Nanoc::PageRep);
+  # compiling a page actually compiles all of its representations.
   class Page
 
-    PAGE_DEFAULTS = {
+    # Default values for pages.
+    DEFAULTS = {
       :custom_path  => nil,
       :extension    => 'html',
       :filename     => 'index',
       :filters_pre  => [],
       :filters_post => [],
-      :haml_options => {},
-      :is_draft     => false,
       :layout       => 'default',
-      :path         => nil,
       :skip_output  => false
     }
 
-    attr_reader   :attributes
-    attr_accessor :parent, :children
-
-    def initialize(hash, site)
-      @site                   = site
-      @compiler               = site.compiler
-
-      @attributes             = hash
-      @content                = { :pre => attribute_named(:uncompiled_content), :post => nil }
+    # The Nanoc::Site this page belongs to.
+    attr_accessor :site
+
+    # The parent page of this page. This can be nil even for non-root pages.
+    attr_accessor :parent
+
+    # The child pages of this page.
+    attr_accessor :children
+
+    # This page's raw, uncompiled content.
+    attr_reader   :content
+
+    # A hash containing this page's attributes.
+    attr_accessor :attributes
+
+    # This page's path.
+    attr_reader   :path
+
+    # The time when this page was last modified.
+    attr_reader   :mtime
+
+    # This page's list of page representations.
+    attr_reader   :reps
+
+    # Creates a new page.
+    #
+    # +content+:: This page's unprocessed content.
+    #
+    # +attributes+:: A hash containing this page's attributes.
+    #
+    # +path+:: This page's path.
+    #
+    # +mtime+:: The time when this page was last modified.
+    def initialize(content, attributes, path, mtime=nil)
+      # Set primary attributes
+      @attributes     = attributes.clean
+      @content        = content
+      @path           = path.cleaned_path
+      @mtime          = mtime
+
+      # Start disconnected
+      @parent         = nil
+      @children       = []
+      @reps           = []
+    end
 
-      @parent                 = nil
-      @children               = []
+    # Builds the individual page representations (Nanoc::PageRep) for this
+    # page.
+    def build_reps
+      # Get list of rep names
+      rep_names_default = (@site.page_defaults.attributes[:reps] || {}).keys
+      rep_names_this    = (@attributes[:reps] || {}).keys + [ :default ]
+      rep_names         = rep_names_default | rep_names_this
+
+      # Get list of reps
+      reps = rep_names.inject({}) do |memo, rep_name|
+        rep = (@attributes[:reps] || {})[rep_name]
+        is_bad = (@attributes[:reps] || {}).has_key?(rep_name) && rep.nil?
+        is_bad ? memo : memo.merge(rep_name => rep || {})
+      end
 
-      @filtered_pre           = false
-      @layouted               = false
-      @filtered_post          = false
-      @written                = false
+      # Build reps
+      @reps = []
+      reps.each_pair do |name, attrs|
+        @reps << PageRep.new(self, attrs, name)
+      end
     end
 
-    # Proxy support
-
+    # Returns a proxy (Nanoc::PageProxy) for this page.
     def to_proxy
       @proxy ||= PageProxy.new(self)
     end
 
-    # Accessors, kind of
-
-    def modified? ; @modified ; end
-
+    # Returns the attribute with the given name.
     def attribute_named(name)
-      return @attributes[name]         if @attributes.has_key?(name)
-      return @site.page_defaults[name] if @site.page_defaults.has_key?(name)
-      return PAGE_DEFAULTS[name]
-    end
-
-    def content
-      compile(false) unless @filtered_pre
-      @content[:pre]
-    end
-
-    def layouted_content
-      compile(true)
-      @content[:post]
-    end
-
-    def skip_output?
-      attribute_named(:skip_output)
-    end
-
-    def path
-      attribute_named(:custom_path) || attribute_named(:path)
-    end
-
-    def path_on_filesystem
-      if attribute_named(:custom_path).nil?
-        @site.config[:output_dir] + attribute_named(:path) +
-          attribute_named(:filename) + '.' + attribute_named(:extension)
-      else
-        @site.config[:output_dir] + attribute_named(:custom_path)
-      end
+      return @attributes[name] if @attributes.has_key?(name)
+      return @site.page_defaults.attributes[name] if @site.page_defaults.attributes.has_key?(name)
+      return DEFAULTS[name]
     end
 
-    # Compiling
-
-    def compile(full=true)
-      @modified = false
-
-      # Check for recursive call
-      if @compiler.stack.include?(self)
-        log(:high, "\n" + 'ERROR: Recursive call to page content. Page filter stack:', $stderr)
-        log(:high, "  - #{self.attribute_named(:path)}", $stderr)
-        @compiler.stack.each_with_index do |page, i|
-          log(:high, "  - #{page.attribute_named(:path)}", $stderr)
-        end
-        exit(1)
-      end
-
-      @compiler.stack.push(self)
-
-      # Filter pre
-      unless @filtered_pre
-        filter(:pre)
-        @filtered_pre = true
-      end
-
-      # Layout
-      if !@layouted and full
-        layout
-        @layouted = true
-      end
-
-      # Filter post
-      if !@filtered_post and full
-        filter(:post)
-        @filtered_post = true
+    # Saves the page in the database, creating it if it doesn't exist yet or
+    # updating it if it already exists. Tells the site's data source to save
+    # the page.
+    def save
+      @site.data_source.loading do
+        @site.data_source.save_page(self)
       end
-
-      # Write
-      if !@written and full
-        @modified = FileManager.create_file(self.path_on_filesystem) { @content[:post] } unless skip_output?
-        @written = true
-      end
-
-      @compiler.stack.pop
     end
 
-    def filter(stage)
-      # Get filters
-      error 'The `filters` property is no longer supported; please use `filters_pre` instead.' unless attribute_named(:filters).nil?
-      filters = attribute_named(stage == :pre ? :filters_pre : :filters_post)
-
-      filters.each do |filter_name|
-        # Create filter
-        filter_class = PluginManager.filter_named(filter_name)
-        error "Unknown filter: '#{filter_name}'" if filter_class.nil?
-        filter = filter_class.new(self.to_proxy, @site.pages.map { |p| p.to_proxy }, @site.config, @site)
-
-        # Run filter
-        @content[stage] = filter.run(@content[stage])
+    # Moves the page to a new path. Tells the site's data source to move the
+    # page.
+    def move_to(new_path)
+      @site.data_source.loading do
+        @site.data_source.move_page(self, new_path)
       end
     end
 
-    def layout
-      # Don't layout if not necessary
-      if attribute_named(:layout).nil?
-        @content[:post] = @content[:pre]
-        return
+    # Deletes the page. Tells the site's data source to delete the page.
+    def delete
+      @site.data_source.loading do
+        @site.data_source.delete_page(self)
       end
-
-      # Find layout
-      layout = @site.layouts.find { |l| l[:name] == attribute_named(:layout) }
-      error 'Unknown layout: ' + attribute_named(:layout) if layout.nil?
-
-      # Find layout processor
-      layout_processor_class = PluginManager.layout_processor_for_extension(layout[:extension])
-      error "Unknown layout processor: '#{layout[:extension]}'" if layout_processor_class.nil?
-      layout_processor = layout_processor_class.new(self.to_proxy, @site.pages.map { |p| p.to_proxy }, @site.config, @site)
-
-      # Layout
-      @content[:post] = layout_processor.run(layout[:content])
     end
 
   end
+
 end