plate 0.5.4 → 0.6.0

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## Plate 0.6.0 (Unreleased)
+
+* Meta data can be read from the config file and used to store common site data such as title, description, author, etc.
+* Modified new site generator to use meta data structure
+* Added RSS feed as part of new site generation
+* Added helper for making relative links absolute for use within RSS feeds
+* Documentation updates
+* Added a new DSL for callbacks and other extensions. Files within `./lib` will now be evaluated using the DSL instead of just being required.
+* Helpers have been moved to a separate directory in the site source root named `./helpers`.
+* Added new site template with some base CSS styles and helpful information to get started.
+* Allow a build destination to be set within the config.yml file.
+* Allow customization of Sass output style with config variable :sass_style
+* Added DSL methods to register asset and template engines.
+* Added engine for Less CSS processing. Install the less gem to use this engine.
+
 ## Plate 0.5.4
 
 * Added config option to command line utility to load a specific config file.

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://secure.travis-ci.org/jdtornow/plate.png)](http://travis-ci.org/jdtornow/plate) [![Dependency Status](https://gemnasium.com/jdtornow/plate.png?travis)](https://gemnasium.com/jdtornow/plate)
 
-Plate is a super simple static site generator and blog engine. At its core, it takes a folder full of Markdown files and turns it into a static HTML site that you can host anywhere. 
+Plate is a super simple static site generator and blog engine. At its core, it takes a folder full of Markdown files and turns it into a static HTML site that you can host anywhere.
 
 In addition to basic formatting with Markdown, Plate also supports generating more dynamic files with ERB or HAML, and compiling asset files with CoffeeScript, Sass and others.
 
@@ -25,39 +25,35 @@ Plate is designed to be a command-line utility. Here is a rundown of some of the
 To generate a new site with plate, run the following command:
 
     platify .
-    
+
 Or, with the normal `plate` command:
 
     plate new .
-    
+
 ### Building a site
-     
+
 To build your site, run:
 
     plate build
-    
+
 Or, just run `plate` without any options to build the site.
 
     plate
-    
+
 To show details about the site build, enable verbose mode:
 
     plate --verbose
-    
-When writing a post, it is sometimes helpful to watch the site for changes and just reload content after each file save. To enable this mode, run the build command with the `--watch` option. Every time a file is saved, the utility will rebuild that file so you can simply hit refresh in your browser to see the changes without rebuilding the entire site.
 
-    plate --watch
-    
 ### Creating a new post
-    
+
 To create a new blog post with the default options, run:
 
     plate post "New Post Name"
-    
+
 You can also put default post options (such as a category or layout) into the command line:
 
     plate post "New Post Name" --category Articles --layout post
-    
+
 Or, if you always use the same default category and/or layout, you can put those options into your config file instead like so:
 
     # In config/plate.yml
@@ -73,14 +69,15 @@ Plate observes the following folder structure in your site:
 
 * config/ - Put your global configuration settings here.
 * content/ - All custom content for the site, besides blog posts. Everything in this folder will be copied over to the published site.
+* helpers/ - Helpers are loaded into views automatically and can be used within dynamically rendered pages using a template language. (Such as Erb or Haml)
 * layouts/ - Global layouts available for use on all content pages and posts.
-* lib/ - Extend the basic functionality of Plate with plugins in this directory. All `.rb` files will be loaded automatically.
+* lib/ - Extend the basic functionality of Plate with plugins in this directory. All `.rb` files run against the Plate DSL.
 * posts/ - All blog post content for the site. Posts can be organized into sub-directories if you like.
 * public/ - This will be generated if it does not exist, contains the produced site. Set this as the web server root to your site for development mode.
 
 ## Extending Plate
 
-Plate is meant to be extended easily. You might want to extend the basic functionality of Plate to add additional functionality for your site. To get started, create a directory named `lib` in the root of your site. Any Ruby files (ending in `.rb`) will be automatically loaded into the stack when Plate is run. 
+Plate is meant to be extended easily. You might want to extend the basic functionality of Plate to add additional functionality for your site. To get started, create a directory named `lib` in the root of your site. Any Ruby files (ending in `.rb`) will be automatically loaded into the stack when Plate is run.
 
 ### Callbacks
 
@@ -89,28 +86,33 @@ Callbacks are used to call certain blocks of code when an event happens in the l
 The callbacks currently available are:
 
 * Site - `before_render`, `after_render`
-* Page/Post - `before_render`, `after_render`
+* Page/Post - `before_render`, `after_render`, `before_write`, `after_write`
+* Asset - `before_render`, `after_render`, `before_write`, `after_write`
 
 Example of a callback to be run when a site completes the build:
 
-    Plate::Site.register_callback :after_render do |site|
+    register_callback :site, :after_render do |site|
        puts "the site finished rendering!"
     end
 
+Put the above snippet in any file in the lib folder, and it will be registered when your site is compiled.
+
 ### Helpers
 
 Helpers are modules that are automatically loaded into views. Any methods in the module will be available when you render a page.
 
-An example of a helper file located in `lib/sample_helper.rb`
+An example of a helper file located in `helpers/sample_helper.rb`
 
     module SampleHelper
       def sample_helper_method
         "yes"
       end
     end
-    
+
 Then, in your `.erb` view you can call `sample_helper_method`.
 
+All files in the `helpers/` directory are assumed to be helper modules and will be loaded automatically at runtime.
+
 ## Full Documentation
 
 View the [full documentation on rdoc.info](http://rdoc.info/gems/plate/frames)

data/Rakefile

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'rake'
-require 'yard'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w(lib)))
 
@@ -17,11 +16,16 @@ end
 namespace :test do
   desc "Build the sample site and leave its contents in test/sample/public"
   task :sample do
-    sh %q(ruby -I"lib:test" test/test_builder.rb -n /sample/)
+    sh %q(turn -I"lib:test" test/test_builder.rb -n /sample/)
   end
 end
 
-YARD::Rake::YardocTask.new do |t|
-end
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new do |t|
+  end
 
-task :doc => :yard
+  task :doc => :yard
+rescue LoadError
+end

data/lib/plate.rb

@@ -10,44 +10,49 @@ require 'plate/errors'
 
 module Plate
   autoload :CLI,                            'plate/cli'
-  
+  autoload :Dsl,                            'plate/dsl'
+
   autoload :Builder,                        'plate/builder'
   autoload :Callbacks,                      'plate/callbacks'
   autoload :Layout,                         'plate/layout'
   autoload :Site,                           'plate/site'
-  
+
   autoload :BloggingHelper,                 'plate/helpers/blogging_helper'
   autoload :MetaHelper,                     'plate/helpers/meta_helper'
   autoload :URLHelper,                      'plate/helpers/url_helper'
-  
+
   autoload :View,                           'plate/view'
-  
+
   autoload :PostCollection,                 'plate/post_collection'
-  
+  autoload :HashProxy,                      'plate/hash_proxy'
+
   autoload :Asset,                          'plate/asset'
   autoload :DynamicPage,                    'plate/dynamic_page'
   autoload :Page,                           'plate/page'
   autoload :Post,                           'plate/post'
   autoload :StaticPage,                     'plate/static_page'
-  
-  autoload :Engine,                         'plate/engine'  
+
+  autoload :Engine,                         'plate/engine'
+
   autoload :HamlTemplate,                   'plate/haml_template'
+  autoload :LessTemplate,                   'plate/less_template'
   autoload :MarkdownTemplate,               'plate/markdown_template'
   autoload :SassTemplate,                   'plate/sass_template'
   autoload :ScssTemplate,                   'plate/scss_template'
-  
+
   extend Engine
   @engines ||= {}
-  
+
   # Set up the basic engines that are supported by Plate. Add your own this same way.
   # Thanks to sprockets for the inspiration.
   # https://github.com/sstephenson/sprockets
-  
+
   # Assets
   register_asset_engine :coffee,          Tilt::CoffeeScriptTemplate
+  register_asset_engine :less,            LessTemplate
   register_asset_engine :sass,            SassTemplate
   register_asset_engine :scss,            ScssTemplate
-  
+
   # Layouts & Markup
   register_template_engine :erb,          Tilt::ERBTemplate
   register_template_engine :haml,         HamlTemplate

data/lib/plate/asset.rb

@@ -1,50 +1,113 @@
 module Plate
-  # An asset is a CoffeeScript or Sass file that needs to be compiled before writing
-  # to the destination.
+  # An asset is a dynamic stylesheet or javascript file that needs some processing before it is ready
+  # to be placed into the site's destination directory.
+  #
+  # Some examples of supported asset formats are [CoffeeScript](http://coffeescript.org)
+  # and [Sass](http://sass-lang.com).
+  #
+  # # Asset Engines
+  #
+  # Assets are compiled based on the file extensions of the source file, and the so-called "engines"
+  # that are available and registered to Plate. By default, Plate does not require any of these
+  # asset engines to run, so any external dependencies will need to be installed before attempting
+  # to use an asset engine.
+  #
+  # For example, in order to use the CoffeeScript engine (and thus a file with the extension of
+  # `.coffee`) the CoffeeScript gem will need to be installed. (`gem install coffee-script`).
+  #
+  # # File Naming
+  #
+  # For best results, name your source files exactly how you would like them to be displayed
+  # once compiled.
+  #
+  # To create a file in the destination named site.js that is compiled from a CoffeeScript source,
+  # name the file in the source directory site.js.coffee. The asset compilation engine will
+  # stop trying to render the file with an asset engine when it finds the first non-registered
+  # file extension. In this case, "js" is not recognized as an asset engine extension that needs
+  # compilation, so compilation stops and the file is written to the destination.
   class Asset < Page
+    # The engines in use for this asset. Engines are determined by looping through
+    # the extensions of the base file and associating those with a registered engine.
+    #
+    # @return [Array] List of engines in use for this file.
     def engines
       @engines ||= self.extensions.reverse.collect { |e| self.site.registered_asset_engines[e.gsub(/\./, '').to_sym] }.reject { |e| !e }
     end
-    
+
+    # The file extensions for this asset's source file.
+    #
+    # @return [Array] List of extensions
     def extensions
       @extensions ||= self.basename.scan(/\.[^.]+/)
     end
-    
+
+    # The end result format for this file. This is the first file extension in the asset's
+    # source file name that is not a registered engine extension.
+    #
+    # For example, a file named `screen.css.css` will have a format extension of "css".
+    #
+    # @return [String]
     def format_extension
       self.extensions.reverse.detect { |e| !self.site.asset_engine_extensions.include?(e) }
     end
-    
-    def file_path      
-      "#{directory}/#{file_name}"
+
+    # The destination file path for this asset.
+    #
+    # @return [String]
+    def file_path
+      [ directory, file_name ].join('/')
     end
-    
+
+    # Directory name for the source asset file
+    #
+    # @return [String]
     def pathname
       File.dirname(self.file)
     end
-    
-    # Same as page, but no layout applied
+
+    # Generates the resulting content for this asset using the `engines` determined
+    # by the source file's name. Unlike a page, assets do not render content
+    # using a layout.
+    #
+    # @return [String]
     def rendered_content
       return @rendered_content if @rendered_content
-      
-      result = File.read(file)
-      
-      self.engines.each do |engine|
-        template = engine.new() { result }
-        result = template.render(self, :site => self.site)
+
+      around_callback :render do
+        result = File.read(file)
+
+        self.engines.each do |engine|
+          template = engine.new() { result }
+          result = template.render(self, :site => self.site)
+        end
+
+        @rendered_content = result
       end
-      
-      @rendered_content = result
+
+      @rendered_content
     end
-    
-    # Write this page to the destination. For static files this just results
-    # in copying the file over to the destination
+
+    # Write this asset file to the destination. The content is written to disk using the path
+    # designated in {#file_path} and the content from {#rendered_content}.
+    #
+    # The callbacks `before_write` and `after_write` are included here. To perform
+    # custom actions before or after an asset file is written to disk, use these callback
+    # methods.
+    #
+    # See {Plate::Callbacks} for more information on setting up callbacks.
+    #
+    # @return [String] The file path that was written to.
     def write!
       path = File.join(site.build_destination, file_path)
       FileUtils.mkdir_p(File.dirname(path))
 
-      File.open(path, 'w') do |f|
-        f.write(self.rendered_content)
+      around_callback :write do
+        File.open(path, 'w') do |f|
+          f.write(self.rendered_content)
+        end
       end
+
+      path
     end
   end
 end

data/lib/plate/builder.rb

@@ -1,257 +1,357 @@
 require 'yaml'
 require 'digest'
 
-module Plate  
-  # Used by the command line tool to generate a site in the given directory.
+module Plate
+  # The builder is used to compile create a site from a source directory and output it to a destination.
+  #
+  # In most cases, the Builder is called directly from the command line tools (see {Plate::CLI}) and does
+  # not need to be called directly.
   class Builder
-    attr_accessor :source, :destination, :options, :site, :enable_logging, :helpers
-    
+    include Callbacks
+
+    # @return [String] The destination directory path where the site should be placed upon a completed build.
+    attr_accessor :destination
+
+    # @return [Boolean] Is logging enabled for this build? Set using the `--verbose` command line option.
+    attr_accessor :enable_logging
+
+    # @return [Hash] A hash of meta values loaded from the config file in the site's source.
+    attr_accessor :metadata
+
+    # @return [Hash] The options hash for this site build.
+    attr_accessor :options
+
+    # @return [Site] The site instance for this build.
+    attr_accessor :site
+
+    # @return [String] The source directory path where the site's content is loaded from.
+    attr_accessor :source
+
+    # @return [Array] A list of helper classes loaded from the `source/helpers` directory.
+    attr_reader :helpers
+
+    # Create a new instance of the builder for the given site source, destination
+    # and options.
+    #
+    # In most cases this should be initialized from the command line utilities.
     def initialize(source, destination, options = {})
       @source = source
       @destination = destination
-      @options = Hash === options ? options.clone : {}      
+      @metadata = {}
+      @options = Hash === options ? options.clone : {}
       @options.symbolize_keys!
     end
-    
+
+    # The directory where the build details are cached. Caching is used to store
+    # temporary data, and as a temporary spot to build the site in before it is
+    # moved to the destination directory.
+    #
+    # Caching is probably a bad name for this since nothing is truly "cached", it is
+    # merely a temporary directory.
+    #
+    # The directory can be set in a site options, or uses the default which is in the user's
+    # current home directory under ~/.plate...
+    #
+    # @return [String]
     def cache_location
       return @cache_location if @cache_location
-      
+
       if self.options.has_key?(:cache_location)
         @cache_location ||= File.expand_path(self.options[:cache_location])
       else
         @cache_location ||= File.expand_path("~/.plate/#{self.id}")
-      end     
+      end
     end
-    
-    # Remove any caches from this site build, also resets any variables for the caching and 
-    # temporary build folders so they can be reset
+
+    # Remove any caches and temporary data from this site build.
     def clear_cache!
       FileUtils.rm_rf(cache_location)
-      
+
       @cache_location = nil
       @tmp_destination = nil
       @loaded = false
     end
-    
-    # Returns the options for this site.
+
+    # Loads the site, if not already loaded and returns the options listed.
+    #
+    # @return [Hash]
     def config
-      self.load!
+      load!
       @options
     end
-    
-    # A unique id for this site, based off of the source directory
+
+    # A unique id for this site, based off of the source directory.
+    #
+    # @return [String]
     def id
       check_source!
-      
       @id ||= [ File.basename(source), Digest::MD5.hexdigest(source) ].collect { |s| s.to_s.downcase.parameterize }.join('-')
     end
-    
+
+    # Are there any items loaded within this site build? Returns false if there are no items.
+    #
+    # When builing a site from the source directory and there are no items persent, the builder
+    # will exit.
+    #
+    # @return [Boolean]
     def items?
       self.total_items > 0
     end
-    
+
+    # Read the source directory from the file system, configure the {Plate::Site} instance,
+    # and load any helpers and plugins.
+    #
+    # The loaded data is cached so this method can safely be called multiple times without
+    # having to read from the filesystem more than once.
+    #
+    # @return [Boolean] Was the source loaded?
     def load!
       unless @loaded
         log('Site builder initialized.')
-        
-        self.require_plugins!
-        self.load_config_file!
-        self.setup_site!
-        self.setup_tmp_directory!
-        
+
+        require_plugins!
+        load_config_file!
+        setup_site!
+        setup_tmp_directory!
+
         @loaded = true
       end
-      
+
       @loaded
     end
-    
+
+    # Utility method to grab the relative path of a specific file from the site's source.
+    #
+    # @return [String] File path relative to source directory.
     def relative_path(file_or_directory)
       file_or_directory.gsub(/^#{Regexp.quote(source)}(.*)$/, '\1')
     end
-    
+
+    # Rebuilds the entire site from source. Used when watching a directory for changes.
+    #
+    # @return [Boolean]
     def rebuild!
       log('Re-rendering site...')
-      
+
       clear_cache!
-      
-      self.site.reload!
-      self.render_site!
-      self.copy_to_destination!
-      
+
+      site.reload!
+      render_site!
+      copy_to_destination!
+
       true
     end
-    
+
     # When watching a directory for changes, allow reloading of site content based on modifications
     # only in the content, layouts and posts folder. Changes to config or lib files will need to
     # be reloaded manually.
+    #
+    # @return [Boolean]
     def reloadable?(relative_file)
       relative_file =~ /^\/?(content|layouts|posts)\/(.*?)/
     end
-    
-    # Called to start the rendering of the site based on the provided, source, destination and config options.
+
+    # Start the rendering of the site based on the provided, source, destination and
+    # config options.
+    #
+    # The site will be loaded if it has not already been read from source, and rendered first to
+    # the temporary {#cache_location}
+    #
+    # @return [Boolean]
     def render!
       @start_time = Time.now
-      
-      log("Building full site...")
-      
-      self.load!
-      self.render_site!
-      self.copy_to_destination!
-      
-      @end_time = Time.now
-      
-      log("Site build completed in #{timer} seconds")      
-      
+
+      around_callback :render do
+        log("Building full site...")
+
+        load!
+        render_site!
+        copy_to_destination!
+
+        @end_time = Time.now
+
+        log("Site build completed in #{timer} seconds")
+      end
+
       true
     end
-    
+
+    # Render a single file from the source to destination directories. This is used
+    # when watching a site for changes and recompiling a specific file on demand.
+    #
+    # For layout files, the entire site is reloaded. For all other files, only that file
+    # and corresponding destination file are reloaded.
+    #
+    # This may produce some unexpected behavior due to plugins and helpers not being reloaded and
+    # is still considered experimental.
+    #
+    # @return [Boolean]
     def render_file!(relative_file_path)
-      self.load!
-      
-      page = self.site.find(relative_file_path)
-      
+      load!
+
+      page = site.find(relative_file_path)
+
+      # Ensure that the file path it is trying to reload actually exists
       if page and page.file?
-        # if the file is a layout, rebuild all pages using it
+        # If the file is a layout, rebuild all pages using it
         if Layout === page
           page.reload!
-          
+
           log("Building layout [#{page.relative_file}]")
-          
-          self.site.find_by_layout(page.relative_file).each do |layout_page|
+
+          # Rebuild all pages using that particular layout.
+          site.find_by_layout(page.relative_file).each do |layout_page|
             self.render_file!(layout_page.relative_file)
           end
         else
           log("Building file [#{page.relative_file}]")
-          
-          # Remove tmp file
+
+          # Does the file have an existing temporary file in the {#cache_location}
           existing_tmp = File.join(tmp_destination, page.file_path)
-          
+
           if File.exists?(existing_tmp)
             FileUtils.rm_rf(existing_tmp)
           end
-          
+
           page.reload!
           page.write!
-          
+
           # File should exist again, even though we just removed it since we re-wrote it.
           if File.exists?(existing_tmp)
             existing = File.join(destination, page.file_path)
 
-            if File.exists?(existing)          
+            if File.exists?(existing)
               log("Removing existing file [#{existing}]", :indent)
               FileUtils.rm_rf(existing)
             end
 
             FileUtils.mkdir_p(File.dirname(existing))
             FileUtils.cp(existing_tmp, existing)
-            
+
             log("File build complete.", :indent)
           end
         end
       else
         log("Cannot render file, it doesn't exist. [#{relative_file_path}]")
       end
-      
+
       true
     end
-    
-    # Total number of all assets, posts and pages. 
+
+    # The total number of all assets, layouts pages and posts in the source
+    # directory.
+    #
+    # @return [Integer]
     def total_items
-      return 0 unless self.site
-      @total_items ||= self.site.all_files.size
+      return 0 unless site
+      @total_items ||= site.all_files.size
     end
-    
+
     # Returns the time it took to run render! (in milliseconds)
+    #
+    # @return [Float] Milliseconds
     def timer
-      return 0 unless @end_time and @start_time      
-      ((@end_time - @start_time)).round
+      return 0 unless @end_time and @start_time
+      (@end_time - @start_time).round
     end
-    
+
     # The directory path of where to put the files while the site is being built.
     #
     # If this value is nil, no temporary directory is used and files are built
     # directly in the normal destination folder.
+    #
+    # @return [String] Full file path
     def tmp_destination
       return @tmp_destination if @tmp_destination
-        
+
       result = ""
-        
-      if self.options.has_key?(:tmp_destination)
-        if self.options[:tmp_destination]
-          result = File.expand_path(self.options[:tmp_destination])
+
+      if options.has_key?(:tmp_destination)
+        if options[:tmp_destination]
+          result = File.expand_path(options[:tmp_destination])
         end
       else
         result = File.join(cache_location, 'build-cache')
       end
-      
+
       @tmp_destination = result
     end
-    
+
+    # Is this site using a temporary destination location?
+    #
+    # @return [Boolean]
     def tmp_destination?
-      self.tmp_destination.to_s.size > 0
+      tmp_destination.to_s.size > 0
     end
-    
+
     protected
       # Allows process to continue if the source directory exists. If the source directory does not
       # exist, raise a source does not exist error.
+      #
+      # @private
       def check_source!
         raise SourceNotFound unless directory_exists?(source)
       end
-      
+
       # Copy all files from within the tmp/ build directory into the actual destination.
       #
       # Warning: This will overwrite any files already in the destination.
+      #
+      # @private
       def copy_to_destination!
         if items?
           self.setup_destination!
-          
+
           if tmp_destination?
-            log("Copying content to destination directory")        
+            log("Copying content to destination directory")
             FileUtils.cp_r(Dir.glob("#{tmp_destination}**/*"), destination)
-          end          
+          end
         end
       end
-      
+
       # Utility method for switching between ruby 1.8* and 1.9+
+      #
+      # @private
       def directory_exists?(dir)
         Dir.respond_to?(:exists?) ? Dir.exists?(dir) : File.directory?(dir)
       end
-    
+
       # Loads the configuration options to use for rendering this site. By default, this information
       # is loaded from a file located in config/plate.yml. If this file does not exist, no config
       # data is loaded by default.
-      # 
+      #
       # You can specific additional options by passing them into the options block of this class:
       #
       # ## Custom Config File
-      # 
-      # To load a different file, pass in the relative path of that file to the source root into the :config 
+      #
+      # To load a different file, pass in the relative path of that file to the source root into the :config
       # option:
       #
       #     Builder.new(source, destination, :config => 'config/other-file.yml')
-      # 
-      # On the command line when building a site, or creating a new post, you can specify the 
+      #
+      # On the command line when building a site, or creating a new post, you can specify the
       # custom config file as a command line option as well:
       #
       #     plate build --config config/other-file.yml
-      # 
+      #
+      # @return [Hash] Options hash. Also set to {#options}
       def load_config_file!
         config_file = 'config/plate.yml'
-        
+
         # Check for provided config options
         if options.has_key?(:config)
           # If config is false, just return without loading anything.
           if options[:config] == false
-            log("Skipping config file load.")            
-            config_file = false            
+            log("Skipping config file load.")
+            config_file = false
           # If something is provided for config set the config_file
           else
             config_file = options[:config]
           end
         end
-        
+
         if config_file
-          config_file_path = File.join(self.source, config_file)
+          config_file_path = File.join(source, config_file)
 
           log("Checking for config file... [#{config_file_path}]")
 
@@ -267,72 +367,101 @@ module Plate
             end
           end
         end
-        
+
+        # If meta data was provided, add it to the site's meta data instance
+        if @options.has_key?(:meta) and Hash === @options[:meta]
+          @metadata = @options[:meta]
+          @metadata.symbolize_keys!
+          @options.delete(:meta)
+        end
+
+        # If a custom destination was provided in the config file, use it.
+        if @options.has_key?(:destination)
+          @destination = File.expand_path(@options[:destination])
+        end
+
         # Make sure that the defaults are available.
         @options.reverse_merge!({
           :permalink => '/:category/:year/:month/:slug'
         })
       end
-      
+
       # Write to the log if enable_logging is enabled
+      #
+      # @private
       def log(message, style = :arrow)
-        prefix = { 
+        prefix = {
           :arrow => '  -> ',
           :indent => '       '
         }[style] || style
-        
+
         puts "#{prefix}#{message}" if !!enable_logging
       end
-      
-      # Build out the site and store it in the destination directory
+
+      # Build out the site and store it in the destination directory.
+      #
+      # @private
       def render_site!
         if items?
           log("Rendering site...")
-          
+
           paths = []
-          
-          self.site.run_callback(:before_render)
-          
-          paths += self.site.assets.collect(&:write!)
-          paths += self.site.pages.collect(&:write!)
-          paths += self.site.posts.collect(&:write!)
-          
+
+          site.run_callback(:before_render)
+
+          paths += site.assets.collect(&:write!)
+          paths += site.pages.collect(&:write!)
+          paths += site.posts.collect(&:write!)
+
           @build_paths = paths
-          
-          self.site.run_callback(:after_render)
-          
+
+          site.run_callback(:after_render)
+
           log("Site rendered!", :indent)
         else
           log("No assets, posts or pages found. :(")
         end
       end
-      
-      # Load any plugins and helpers in the ./lib folder. Any modules named with the 
-      # format SomethingHelper will automatically be loaded into all views.
+
+      # Load any plugins in the ./lib folder and helper modules in the ./helpers folder.
+      #
+      # Any modules named with the format `SomethingHelper` will automatically be loaded
+      # into all views.
+      #
+      # @private
       def require_plugins!
-        self.helpers = []
-        
-        matcher = /^#{Regexp.quote(File.join(source, 'lib'))}\/?(.*).rb$/
-        
-        plugins = Dir.glob(File.join(source, "lib/**/*.rb"))
-        
-        if plugins.length > 0
+        # For plugins, load all .rb files in the lib directory, regardless of name.
+        plugin_files = Dir.glob(File.join(source, 'lib/**/*.rb'))
+
+        if plugin_files.length > 0
           log("Loading plugins...")
-          
-          plugins.each do |file|
-            require file
 
+          plugin_files.each do |file|
+            Dsl.evaluate_plugin(file)
+          end
+        end
+
+        # For helpers, load all files that match `abc_helper.rb`, then check to make sure
+        # there is an appropriately named Module within that file.
+        @helpers = []
+
+        helper_files = Dir.glob(File.join(source, 'helpers/**/*.rb'))
+        matcher = /^#{Regexp.quote(File.join(source, 'helpers'))}\/?(.*).rb$/
+
+        if helper_files.length > 0
+          helper_files.each do |file|
             underscore_name = file.sub(matcher, '\1')
 
-            # For helpers, make sure the module is defined, and add it to the helpers list
             if underscore_name =~ /(.*?)_helper$/
+              require file
+
               class_name = underscore_name.classify
 
               if defined? class_name
                 log("Loaded helper [#{class_name}]", :indent)
 
-                klass = class_name.constantize              
-                self.helpers << klass
+                klass = class_name.constantize
+                @helpers << klass
 
                 View.send(:include, klass)
               end
@@ -340,49 +469,56 @@ module Plate
           end
         end
       end
-      
-      # Clear out the destination directory, if it exists. Leave the root of the 
+
+      # Clear out the destination directory, if it exists. Leave the root of the
       # destination itself, but clear any files within it.
+      #
+      # @private
       def setup_destination!
         if directory_exists?(destination)
           log("Clearing destination directory [#{destination}]")
-          
+
           FileUtils.rm_r(Dir.glob("#{destination}**/*"), :force => true)
         elsif items?
           log("Creating destination directory [#{destination}]")
-          
-          FileUtils.mkdir_p(destination) 
+
+          FileUtils.mkdir_p(destination)
         end
       end
-      
+
       # Setup the Site instance and prepare it for loading
+      #
+      # @private
       def setup_site!
         log("Setting up site instance")
-        
-        self.site = Site.new(source, destination, options)        
+
+        self.site = Site.new(source, destination, options)
         self.site.logger = self
         self.site.cache_location = self.cache_location
-        
+        self.site.metadata = self.metadata
+
         log("Site data loaded from source")
       end
-      
-      # Create a temporary folder to build everything in. Once the build was successful, 
+
+      # Create a temporary folder to build everything in. Once the build was successful,
       # all files will then be placed into the actual destination.
+      #
+      # @private
       def setup_tmp_directory!
         return unless tmp_destination?
-        
+
         log("Setting up tmp build directory [#{tmp_destination}]")
-        
+
         # Clear out any existing tmp folder contents
         if directory_exists?(tmp_destination)
           log("Clearing existing tmp directory content")
-          
+
           FileUtils.rm_rf(tmp_destination)
         end
-        
+
         FileUtils.mkdir_p(tmp_destination)
-        
-        self.site.build_destination = tmp_destination
+
+        site.build_destination = tmp_destination
       end
   end
 end