deplot 0.0.4 → 0.1.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Cyril Nusko 
+Copyright (c) 2013 Cyril Nusko 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.md

@@ -1,63 +1,169 @@
-deplot
-======
+# deplot
 
-Deplot is a static web site generator with a ruby DSL.
+Deplot is a lightweight and very extensible static web site generator written in ruby.
 
-Intention
----------
+## Intention
 
-Deplot is intended to simplify the progress of creating and maintaining a static web site. Its main advantages are:
+Deplot is intended to simplify the process of creating and maintaining a static web site. Its simple DSL makes it easy to describe and understand the structure of a web site, while giving you power over every part of the building process.
 
-* Separating content from markup with layout (template) files
-* Independency from specific markup languages by using [tilt][tilt] in both layout and content files
-* Simplifying the design/development workflow with a pre-built Guardfile that allows [guard][guard] to recompile any asset or the whole project if a source file changes.
-* Easy deployment with a folder structure ready for [git-ftp][git-ftp]
+## Using deplot
 
-Installation and usage
------
+### Installing
 
-Install the deplot gem via rubygems.org: `gem install deplot`. Or build it directly from the sources with `gem build deplot.gemspec; gem install deplot-0.0.x.gem` in the cloned repo. For both `gem install` commands, admin rights may be required.
+The current deplot gem is published on rubygems.org, so you only need to type the following command into your favorite shell (`sudo` may be necessary, depending on your setup):
 
-If the deplot gem is installed, calling `deplot new <project_name>` will create a project directory with all the files and directories needed to get a new site started. You can also use an existing skeleton with `deplot new <project_name> <git_url>`, which will clone the specified git repo. Deplot's built upon a custom DSL that's used to describe your site's pages (in the `Deplotfile`):
+```
+$ gem install deplot
+```
+
+### The structure of a deplot project
+
+A standard deplot project consists of a folder (the *root folder*) with the following structure:
+
+```
+- assets/
+- Deplotfile
+- documents/
+- media/
+- modules/
+```
+
+Only the Deplotfile is necessary for deplot to run without errors; but in order to build a website, you probably need some content. By default, all output goes to this *root* directory: as soon as you build the project, the root folder will contain a lot more folders and files.
+
+### A simple example
+
+The core of a deplot project, the `Deplotfile`, uses the mentioned DSL that makes it easy to understand the different processes to build the website.
+
+For example, if you were to set up a blog with one page per blog post and a collection of posts on the front page, you could write this simple code:
+
+```
+documents_in "posts" do
+	collect_in "index.html"
+	output_to "posts"
+end
+```
+
+Now every post in `documents/posts/` is first being collected in `index.html` and then rendered into its single page, `posts/<filename>.html`.
+
+To make this work, you first need to install the deplot gem and invoke deplot like this:
+
+```
+$ deplot make
+```
+
+Deplot uses [tilt][tilt] to render all content and layout files and is therefore able to process almost anything from ERB to Markdown.
+
+### Command reference
+
+#### Render blocks
+
+The top-level **render blocks**  are built using the two methods `documents_in` (as seen in the previous example) and `media_in`. They are called with two arguments: the path to the folder containing the source files (relative to `documents/` and `media/`, respectively) and a block that contains all the instructions for rendering the sources. At the moment, `media_in` is currently only able to filter and copy files:
+
+```
+media_in "images" do
+	filter :only => [/.*.png$/]
+	copy_to "img"
+end
+```
+
+#### Inline render blocks
+
+There are situations in which you may want to render multiple sets of files to different parts of your website (a newsticker in the sidebar, for example). The two commands `output_documents_in` and `collect_documents_in` will take care of this by returning the rendered content as array and string, respectively. In the following example, both layout and content files could then make use of the variable "@news":
 
-```ruby
-path "/" do
-	render "index.markdown"
+```
+documents_in "pages" do
+	@news = collect_documents_in "news"
+	output_to "/"
 end
 ```
 
-You can create multiple pages from multiple source files with `render_all` (the `#` is replaced by the file name with `.html` extension):
+#### copy_to (media only)
+
+`copy_to` does exactly what you would expect of it: it copies the source files into the specified directory.
+
+#### output_to (documents only)
+
+`output_to` is the equivalent to `copy_to` in that it renders every source into a single file in the given directory. Unlike `copy_to`, it is able to take a block as last argument that can be used for instructions *specific to this output directory*.
+
+#### collect_in (documents only)
+
+`collect_in` concatenates all the rendered files and writes them to a single file. Like `output_to`, it can be called with a block (the `apply` example makes use of this feature).
+
+#### filter
+
+The `filter` command is available for both media and document renderers and is used to filter out files from the specified sources. It can be used in two ways:
+
+```
+filter :only => [/.*.markdown$/]
+filter :exclude => [/.*.erb$/]
+```
+
+#### apply
+
+The mightiest of all commands, `apply`, can be used to execute custom code (so-called *modules*) in the context of the current set of sources. Modules are searched for in the `modules/` folder of your project and need to be included in the Deplotfle (`use :teaser` for `teaser.rb`). For our basic blog, we may want to shorten the text displayed on the front page and display a link to the post page:
 
-```ruby
-path "/blog/#" do # will create /blog/<file_name>.html
-	render_all "blog/"
+```
+class Teaser < DeplotPreprocessor
+  def preprocess source, arguments
+    link = "posts/" + File.basename(source[:filename]).gsub(/\.md/, ".html")
+    source[:content] = "#{source[:content][0..40]}… <a href=\"#{link}\">Read on &raquo;</a>"
+  end
 end
 ```
 
-or create an index file from multiple sources:
+Now we can include this preprocessor to be used for `index.html` as follows:
+
+```
+use :teaser
 
-```ruby
-path "/blog/" do # will create /blog/index.html
-	render_all "blog/"
+documents_in "posts" do
+	collect_in "index.html" do
+		apply :teaser
+	end
+	output_to "posts"
 end
 ```
 
-Deplot uses [tilt][tilt] to render the source and layout file/s, so it can be used with almost every markup language and template engine.
+There are three types of modules: the filter, the preprocessor, the processor modules.
+
+* **Filter modules** are used to sort out files and can be applied everywhere.
+* **Preprocessor modules** (documents only) alter the *source code* of the documents (text written in markdown, for example). They cause deplot to read the source files and can't be executed after processor modules.
+* **Processor modules** (documents only) are used to alter *rendered code* (HTML, for now). They cause deplot to read *and* render the source files and need to be executed after preprocessor modules.
+
+#### layout (documents only)
+
+`layout` is used to specify a template file which is rendered just before the files is written to disk. This file can be used to link to css and javascript files or display content that stays the same over multiple pages:
+
+```
+<html>
+<head>
+	<link rel="stylesheet" href="style.css" />
+</head>
+<body>
+	<h1>Page title</h1>
+	<div class="wrapper">
+		<%= yield %>
+	</div>
+</body>
+</html>
+```
 
-Assets like `LESS`, `SASS` or `CoffeeScript` files are compiled by [guard][guard], which will also call deplot if any content or layout changes. Take a look at the default `Guardfile`, which has usable default settings. Or just run `guard` and press `enter` to compile everything.
 
-Since all files are compiled into the root directory of the project, you can deploy your site with [git-ftp][git-ftp] - the project's page has details on how to deploy a git repo with git-ftp.
+## Planned features
 
-Development
------------
+* Ability to use custom renderer code (block and module)
+* Non-media asset processing (compiling, compressing, concatenating) for files written in LESS, SASS, CoffeScript etc. 
+* Filter: keep or discard file when one or more, but not necessarily all conditions are met (considered bug)
+* Automatic rebuilding using [guard][guard]
+* Media resizing and conversion
+* Partials (for more modular layouts)
+* Ability to sort source files
 
-To use the latest version, you will need to manually build and install the gem. A `gem build deplot.gemspec; sudo gem install deplot-0.0.x.x.gem` in the cloned repo will suffice.
+Please submit feature requests and bugfixes in the issue tracker.
 
-License
--------
+## License
 
 See LICENSE file.
 
-[tilt]: https://github.com/rtomayko/tilt
-[guard]: https://github.com/guard/guard
-[git-ftp]: https://github.com/resmo/git-ftp
+[tilt]: https://github.com/rtomayko/ti
+[guard]: https://github.com/guard/guardlt

data/bin/deplot

@@ -1,575 +1,348 @@
 #!/usr/bin/env ruby
 
+VERSION = "0.1.0"
+
 require 'thor'
 require 'fileutils'
 require 'tilt'
+require 'colorize'
 
-# Deplot DSL
-
-$assets_dir = Dir.pwd+"/assets"
-$content_dir = Dir.pwd+"/content"
-$root_dir = Dir.pwd
+=begin
 
-$is_currently_rendering = false
+This file, and Deplot itself, consist/s of three major parts:
 
-$template_arguments = {}
-$global_variables = {}
-$variables = {}
+1. The 'DeplotRenderer' class
+  contains all the logic of deplot and the rendering process
+2. Base classes for modules
+  that can be used to build modules for custom behaviour
+3. The DSL methods
+  are the 'interface' to deplot, accessible via the Deplotfile
+4. The 'Deplot' CLI class
+  provides all command line methods to Thor
 
-$tasks = []
-$render_type = ""
-$current_source = ""
-$layout = ""
-$options = {}
+This seemed the least complex way to do it; if you can think
+of any simplifications or suggestions for alternative designs,
+please submit them to the issue tracker. Thanks!
 
-$errors_occured = 0
+=end
 
-# helper methods
-def puts_alert text
-	puts "#{Thor::Shell::Color::RED}#{text}#{Thor::Shell::Color::CLEAR}"
-	$errors_occured += 1
-end
-def puts_success text
-	puts "#{Thor::Shell::Color::GREEN}#{text}#{Thor::Shell::Color::CLEAR}"
-end
-
-# dsl methods for page specification
-def assets_dir dir
-	$assets_dir = $root_dir + "/" + dir.gsub(/^\//, "").gsub(/\/$/, "")
-end
-def content_dir dir
-	$content_dir = $root_dir + "/" + dir.gsub(/^\//, "").gsub(/\/$/, "")
-end
-def variables vars
-	if $is_currently_rendering
-  	$variables.merge! vars
-	else
-		$global_variables.merge! vars
-	end
-end
-def layout file
-  $layout = file
-end
-def render file
-  $render_type = "render-single"
-  $current_source = file
-end
-def render_each base = "", paths = []
-  $render_type = "render-all"
-  unless base.is_a? Array
-		$current_source = [base, paths]
-	else
-		$current_source = ["./", base]
-	end
-end
-def render_all path
-  $render_type = "render-all"
-  $current_source = path
-end
+#
+# DeplotRenderer and subclasses, containing the render logic
+#
 
-# base of route specification
-def path path, &block
-  # reset
-  $render_type = ""
-  $current_source = ""
-  $layout = "layout.erb"
-	$options = {}
-	$variables = {}
-  $is_currently_rendering = true
-	
-  # set
-  block.call
-	
-	$is_currently_rendering = false
+# Base class
+class DeplotRenderer
+  attr_accessor :layout
+  attr_accessor :context
   
-  # remember
-  if $render_type == "render-all"
-    $render_type = (/\#/ =~ path) ? "render-all" : "render-all-one-file"
-    $tasks << [$render_type, path, $current_source, $layout, $options, $variables]
-  else
-    $tasks << [$render_type, path, $current_source, $layout, $options, $variables]
+  def alert s
+    puts " ---->#{s}".yellow
+  end
+  
+  def initialize base_dir
+    @rendered = false
+    @read = false
+    @sources = (Dir.glob(base_dir + "*") - [".", "..", ".DS_STORE"]).collect { |file| {:filename => file} }
+    @base_dir = base_dir
+    @layout = ""
+  end
+  
+  # Filter out sources based on file name
+  def filter options
+    if options.has_key? :only or options.has_key? :exclude
+      filter_type = (options.has_key? :only) ? :only : :exclude
+      options[filter_type].each do |filter|
+        @sources.send (filter_type == :only ? :keep_if : :delete_if) do |source|
+          file = source[:filename]
+          if filter.is_a? Regexp
+            filter =~ file
+          else
+            filter == file || @base_dir + filter == file
+          end
+        end
+      end
+    else
+      alert "filter: No valid argument/s found."
+    end
   end
 end
 
-# set options
-def reverse_order
-	$options[:reverse_order] = true
-end
-def extension ext
-	$options[:extension] = ext
-end
-
-# methods for partials
-def partial name, options = {}
-	begin
-    source_tilt = Tilt.new($assets_dir+"/"+name)
-	rescue Exception => e
-		puts "- ERROR creating tilt instance (possibly missing source file for partial)."
-		return ""
-	end
-	if options.has_key? :layout
-		begin
-      layout_tilt = Tilt.new(options[:layout])
-		rescue Exception => e
-			puts "- ERROR creating tilt instance (possibly missing layout file for partial)."
-			return ""
-		end
-		return layout_tilt.render(Object.new, $template_arguments) do
-			source_tilt.render(Object.new, $template_arguments)
-		end
-	else
-		return source_tilt.render(Object.new, $template_arguments)
-	end
+# Media renderer
+class DeplotMediaRenderer < DeplotRenderer
+  def initialize base_dir
+    puts "Media renderer initialized.".green
+    super
+  end
+  
+  def copy_to output_dir
+    puts "Copying files..."
+    FileUtils.mkdir_p(output_dir)
+    @sources.each do |source|
+       FileUtils.cp(source[:filename], output_dir)
+       puts "  Copied '#{source[:filename]}'."
+    end
+  end
+  
+  def apply module_name, *args
+    begin
+      module_const = module_name.to_s.split("_").collect { |s| s.capitalize }.join()
+      the_module = Kernel.const_get(module_const).new
+    rescue
+      raise "'#{module_name}' not defined! Maybe not 'use'd?"
+    end
+    if the_module.is_a? DeplotFilter
+      @sources.each do |source|
+        the_module.filter source, args
+      end
+    else
+      raise "Only filter modules can be applied within media renderers! (#{module_name})"
+    end
+  end
 end
 
-# publishing methods
-def check_directories?
-	[$assets_dir, $content_dir].each do |dir|
-		unless File.exists?(dir) and File.directory?(dir)
-			return false
-		end
-	end
-	return true
-end
-def publish
-  puts "Publishing site..."
-  $tasks.each do |task|
-    action, path, source, $layout, options, variables = task
-		unless path == "/"
-			path = "/" + path.gsub(/^\//, "")
-		end
-		variables.merge! $global_variables
-    content = ""
-    $template_arguments = {:path => "", :source => "", :file_name => "", :depth => 0}
-		$template_arguments.merge! variables
-		options[:extension] = (options[:extension].nil?) ? "html" : options[:extension]
-		unless check_directories?
-			puts "- ERROR: content or assets directory does't exist. Exiting..."
-			return
-		end
-		
-    if action == "render-single"
-      
-      ## R E N D E R   S I N G L E
-      # Destination
-      destination_dir = File.dirname path
-      destination_base = File.basename path
-      if /\/$/ =~ path
-        destination_dir = path.gsub /\/$/, ""
-        destination_base = "index.#{options[:extension]}"
-			end
-      $template_arguments.merge! :path => "#{destination_dir}/#{destination_base}"
-			$template_arguments.merge! :file_name => destination_base
-			$template_arguments.merge! :source => source
-			$template_arguments.merge! :depth => (destination_dir.count "/")
-    
-      puts "Rendering path '"+destination_dir.gsub(/\/$/, "")+"/#{destination_base}'"
-      # make path
-      FileUtils.mkdir_p "."+destination_dir
-      unless File.directory? "."+destination_dir
-        puts "  Path '"+path+"' could not be created. Skipping..."
-        next
-      end
-    
-      # Read source
-      Dir.chdir $content_dir do
-        unless File.exist? source
-          puts "  Source file could not be found. Skipping..."
-          next
-        end
-        content = File.read source
-      end
-      puts "  Read source file."
-    
-      # Create tilt instances
-      layout_tilt = nil
-      Dir.chdir $assets_dir do
-				begin
-	        layout_tilt = Tilt.new($layout)
-				rescue Exception => e
-					puts_alert "- ERROR creating tilt instance (possibly missing layout file)."
-					layout_tilt = nil
-				end
-      end
-      if layout_tilt.nil?
-        puts "  Layout could not be found or rendered. Skipping..."
-        next
-      end
-      source_tilt = nil
-      Dir.chdir $content_dir do
-				begin
-	        source_tilt = Tilt.new(source)
-				rescue Exception => e
-					puts_alert "- ERROR creating tilt instance (possibly missing source file)."
-					source_tilt = nil
-				end
-      end
-      if source_tilt.nil?
-         puts "  Source file could not be rendered. Skipping..."
-         next
-      end
-      puts "  Created tilt instances."
-    
-      # Render and write
-      Dir.chdir "."+destination_dir do
-        File.open destination_base, "w" do |file|
-          file.puts layout_tilt.render(Object.new, $template_arguments){
-            source_tilt.render(Object.new, $template_arguments)
-          }
-        end
-      end
-      puts "  Wrote to file."
-    elsif action == "render-all"
-      
-      ## R E N D E R   A L L
-      # Destination
-      destination_dir = File.dirname path
-      destination_base = File.basename path
-      if /\/$/ =~ path
-        destination_dir = path.gsub /\/$/, ""
-        destination_base = "index.#{options[:extension]}"
-			end
-    
-      puts "Rendering path/s '"+destination_dir+"/...'"
-      # make path
-      FileUtils.mkdir_p "."+destination_dir
-      unless File.directory? "."+destination_dir
-        next
+# Document renderer
+class DeplotDocumentRenderer < DeplotRenderer
+  def initialize base_dir
+    puts "Documents renderer initialized.".green
+    super
+  end
+  
+  def read
+    puts "Reading files..."
+    @sources.each do |source|
+      source[:content] = File.read source[:filename]
+      puts "  Read '#{source[:filename]}'."
+    end
+    @read = true
+  end
+  
+  def render
+    read if @read == false
+    puts "Rendering..."
+    @rendered = true
+    @sources.each do |source|
+      renderer = Tilt[source[:filename]]
+      unless renderer.nil?
+        source[:content] = renderer.new do
+          source[:content]
+        end.render context
+      else
+        alert "No Tilt renderer found for '#{source[:filename]}', falling back to echo."
       end
-    
-      # Read source
-      Dir.chdir $content_dir do
-				paths = []
-				if source.is_a? Array
-					source, paths = source
-				end
-        source.gsub!(/\/$/, "")
-        Dir.chdir source do
-          # Create layout tilt instance
-          layout_tilt = nil
-          Dir.chdir $assets_dir do
-						begin
-			        layout_tilt = Tilt.new($layout)
-						rescue Exception => e
-							puts_alert "- ERROR creating tilt instance (possibly missing layout file)."
-							layout_tilt = nil
-						end
-          end
-          if layout_tilt.nil?
-            puts "  Layout could not be found or rendered. Skipping..."
-            next
-          end
-          (paths == [] ? Dir.glob("*") : paths).each do |content_file|
-            puts "  Read source file #{source}/#{content_file}"
-        		$template_arguments.merge! :source => "#{source}/#{content_file}"
-        		
-            # Create tilt instances
-            source_tilt = nil
-						begin
-            	source_tilt = Tilt.new(content_file)
-						rescue Exception => e
-							puts_alert "- ERROR creating tilt instance (possibly missing source file)."
-							source_tilt = nil
-						end
-            if source_tilt.nil?
-               puts "  Source file could not be rendered. Skipping..."
-               next
-            end
-            
-            # Render and write
-            Dir.chdir $root_dir+destination_dir do
-              file_name = File.basename(content_file).gsub(File.extname(content_file), ".#{options[:extension]}")
-              $template_arguments.merge! :path => "#{destination_dir}/#{file_name}"
-          		$template_arguments.merge! :file_name => file_name
-          		$template_arguments.merge! :depth => (destination_dir.count "/")
-              File.open destination_base.gsub("#", file_name), "w" do |file|
-                file.puts layout_tilt.render(Object.new, $template_arguments){
-                  source_tilt.render(Object.new, $template_arguments)
-                }
-              end
-		          puts "  Wrote to file: " + file_name
-            end
-          end
+    end
+  end
+  
+  def output
+    render if @rendered == false
+    output = []
+    @sources.each do |source|
+      unless @layout == ""
+        output.push Tilt.new("assets/#{@layout}").render context do
+          source[:content]
         end
+      else
+        output.push source[:content]
       end
-    elsif action == "render-all-one-file"
-      
-      ## R E N D E R   A L L   O N E   F I L E
-      # Destination
-      destination_dir = File.dirname path
-      destination_base = File.basename path
-      if /\/$/ =~ path
-        destination_dir = path.gsub /\/$/, ""
-        destination_base = "index.#{options[:extension]}"
-			end
-      
-      $template_arguments.merge! :path => "#{destination_dir}/#{destination_base}"
-			$template_arguments.merge! :file_name => destination_base
-			$template_arguments.merge! :depth => (destination_dir.count "/")
-    
-      puts "Rendering path '#{destination_dir}/#{destination_base}'"
-      # make path
-      FileUtils.mkdir_p "."+destination_dir
-      unless File.directory? "."+destination_dir
-        puts "  Path '"+path+"' could not be created. Skipping..."
-        next
+    end
+    output
+  end
+  
+  def output_to output_dir
+    render if @rendered == false
+    puts "Writing files..."
+    @sources.each do |source|
+      output_dir += "/" unless output_dir =~ /\/$/
+      output_path = output_dir + source[:filename].gsub(/^#{@base_dir}/, '')
+      extname = File.extname(output_path)
+      if extname == ""
+        output_path += ".html"
+      else
+        output_path.gsub! /#{extname}$/, ".html"
       end
-      
-      sources_rendered = []
-      # Read source/s
-      Dir.chdir $content_dir do
-				paths = []
-				if source.is_a? Array
-					source, paths = source
-				end
-        Dir.chdir source do
-          paths = (paths == [] ? Dir.glob("*") : paths)
-					if options.has_key? :reverse_order and options[:reverse_order] == true
-						paths.reverse!
-					end
-					paths.each do |content_file|
-            #content = File.read content_file
-            puts "  Read source file #{source}#{content_file}"
-      			$template_arguments.merge! :source => "#{source}#{content_file}"
-            
-            # Create tilt instance
-            source_tilt = nil
-						begin
-            	source_tilt = Tilt.new(content_file)
-						rescue Exception => e
-							puts_alert "- ERROR creating tilt instance (possibly missing source file)."
-							source_tilt = nil
-						end
-            if source_tilt.nil?
-               puts "  Source file could not be rendered. Skipping..."
-               next
-            end
-            sources_rendered << {:content => source_tilt.render(Object.new, $template_arguments)}.merge($template_arguments)
-          end
+      FileUtils.mkdir_p(File.dirname(output_path))
+      File.open(output_path, "w") do |file|
+        if @layout == ""
+          file.write source[:content]
+        else
+          file.write (Tilt.new("assets/#{@layout}").render context do
+            source[:content]
+          end)
         end
-      end
-      
-      # Create layout tilt instance
-      layout_tilt = nil
-      Dir.chdir $assets_dir do
-				begin
-	        layout_tilt = Tilt.new($layout)
-				rescue Exception => e
-					puts_alert "- ERROR creating tilt instance (possibly missing layout file)."
-					layout_tilt = nil
-				end
-      end
-      if layout_tilt.nil?
-        puts "  Layout could not be found or rendered. Skipping..."
-        next
-      end
-      # Render and write
-      Dir.chdir "."+destination_dir do
-        File.open destination_base, "w" do |file|
-          file.puts layout_tilt.render(Object.new, {:items => sources_rendered}.merge($template_arguments))
-        end	
-      end	
-      puts "  Wrote to file."
-    end # End of action switching
+      end 
+      puts "  Wrote to file '#{output_path}'."
+    end
   end
-	if $errors_occured == 0
-		puts_success "Successfully created all pages."
-	elsif $errors_occured == 1
-		puts_alert "#{$errors_occured} error occurred!"
-	else
-		puts_alert "#{$errors_occured} errors occurred!"
-	end
-end
-
-# Thor: Deplot CLI
-
-class Deplot < Thor
   
-  desc "init", "Create a new deplot project in the current directory"
-  def init
-    # Content directory
-    puts "  Making directory '"+$content_dir+"'..."
-    FileUtils.mkdir $content_dir
-    # Assets directory
-    puts "  Making directory '"+$assets_dir+"'..."
-    FileUtils.mkdir $assets_dir
-    #   Basic Layout
-    Dir.chdir $assets_dir do
-      File.open "layout.erb", "w" do |file|
-        file.write <<-EOF
-<html>
-<head>
-	<title>Deplot Project</title>
-	<link rel="stylesheet" href="style.css" />
-</head>
-<body>
-<div id="wrapper">
-	<%= yield %>
-</div>
-</body>
-</html>
-EOF
-      end
-      File.open "style.less", "w" do |file|
-        file.write <<-EOF
-body {
-	margin: 0;
-	font-family: "Helvetica", sans-serif;
-	background-color: #EEE;
-}
-#wrapper {
-	width: 500px;
-	padding: 10px;
-	margin: 10px auto;
-	background-color: #FFF;
-	border: 3px solid #DDD;
-}
-p {
-	color: #444;
-}
-h1 {
-	margin-bottom: 20px;
-	padding-bottom: 8px;
-	border-bottom: 1px solid #EEE;
-}
-
-EOF
+  def collect
+    render if @rendered == false
+    puts "Collecting documents..."
+    content = @sources.collect{ |source| source[:content] }.join
+    unless @layout == ""
+      return Tilt.new("assets/#{@layout}").render context do
+        content
       end
+    else
+      return content
     end
-    # Deplotfile
-    puts "  Creating Deplotfile..."
-    File.open "Deplotfile", "w" do |file|
-      file.write <<-EOF
-path '/' do
-	render "index.markdown"
-end
-EOF
+  end
+  
+  def collect_in output_file
+    puts "Writing file..."
+    sources_contents = collect
+    FileUtils.mkdir_p(File.dirname(output_file))
+    File.open(output_file, "w") do |file|
+      file.write sources_contents
+    end  
+    puts "  Wrote to file '#{output_file}'."
+  end
+  
+  # Apply a user module (located in modules/)
+  def apply module_name, *args
+    begin
+      module_const = module_name.to_s.split("_").collect { |s| s.capitalize }.join()
+      the_module = Kernel.const_get(module_const).new
+    rescue
+      raise "'#{module_name}' not defined! Maybe not 'use'd?"
     end
-    # Guardfile
-    puts "  Creating Guardfile..."
-    File.open "Guardfile", "w" do |file|
-      file.write <<-EOF
-# CoffeeScript
-guard :coffeescript, :input => 'assets', :output => '.'
-
-# CSS <- LESS, SASS
-guard :sass, :input => 'assets', :output => '.'
-guard :less, :output => '.' do
-	watch(/^assets\\/(.+\.less)$/)
+    puts "Applying '#{module_name}'..."
+    # Prepare module
+    module_type = nil
+    if the_module.is_a? DeplotPreprocessor
+      raise "Cannot preprocess if already rendered! (module '#{module_name}')" if @rendered == true
+      read if @read == false
+      module_type = :preprocess
+    elsif the_module.is_a? DeplotProcessor
+      read if @read == false # No preprocessors
+      render if @rendered == false
+      module_type = :process
+    elsif the_module.is_a? DeplotFilter  
+      module_type = :filter
+    else
+      raise "'#{module_name}' is not a deplot module!"
+    end  
+    # Apply to each source
+    @sources.each do |source|
+      the_module.send module_type, source, args
+    end
+  end
 end
 
-# Invoke deplot
-guard :shell do
-watch(/(assets|content)\\/(.*)/) do |m|
-		`echo ""; echo "File '\#{m[2]}' changed."; deplot make`
-	end
-end
-EOF
-    end
-		# .git-ftp-ignore
-    puts "  Creating .git-ftp-ignore..."
-    File.open ".git-ftp-ignore", "w" do |file|
-      file.write <<-EOF
-.gitignore
-.git-ftp-ignore
-Deplotfile
-Guardfile
-assets/.*
-content/.*
-EOF
-    end
-    # Example content
-    Dir.chdir $content_dir do
-      File.open "index.markdown", "w" do |file|
-        file.write <<-EOF
-# New deplot project
+$current_instance = nil
 
-This is the default page of your new project. Change the Deplotfile in the project
-directory to add new routes (see examples below) or change the contents of this file
-by editing `content/index.markdown`. Remember to call `deplot make` to build the
-project or, better, run `guard` to recompile if anything changes.
+#
+# Base classes for user modules
+#
 
-## Editing the Deplotfile
+class DeplotFilter
+  def filter sources, arguments
+    raise "Module error: 'filter' method is not defined!"
+  end
+end
+class DeplotPreprocessor
+  def preprocess sources, arguments
+    raise "Module error: 'preprocess' method is not defined!"
+  end
+end
+class DeplotProcessor
+  def process sources, arguments
+    raise "Module error: 'process' method is not defined!"
+  end
+end
 
-The basic syntax to describe a page of your site is to call `path` with the page location
-as a string and with a block containing the specific instructions, like the `render`
-method:
+#
+# Deplot DSL, the language of the Deplotfile
+#
 
-	path '/' do
-		render "index.markdown"
-	end
+def use module_name
+  puts "Loading '#{module_name}'..."
+  require "./modules/#{module_name}.rb"
+end
 
-This is, by the way, also the code that is used to generate this introduction page.  
-To render more than one file, for example all files in a directory called `blog/`,
-you can use `render_all`:
+# Assign methods
+["layout"].each do |variable_name|
+  self.class.send :define_method, variable_name do |*args|
+    unless $current_instance.nil?
+      $current_instance.send("#{variable_name}=", *args)
+    end
+  end
+end
 
-	path '/blog/#'
-		render_all "blog/"
-	end
+# Basic methods
+["filter", "apply", "copy_to"].each do |method_name|
+  self.class.send :define_method, method_name do |*args|
+    unless $current_instance.nil?
+      $current_instance.context = binding.eval("self")
+      $current_instance.send(method_name, *args)
+    end
+  end
+end
 
-The symbol `#` will then be replaced by the name of the source file (without its
-extension and with `.html` at the end). Omitting the symbol will cause deplot to render
-all source files into one single file. The code below will produce an index file
-`blog/index.html` that uses another layout (`layout_index.erb`).
+# Output methods
+["output_to", "collect_in"].each do |method_name|
+  self.class.send :define_method, method_name do |path, &block|
+    unless $current_instance.nil?
+      backup = Marshal.load(Marshal.dump($current_instance))
+      block.call unless block.nil?
+      @output_path = path
+      @depth = path.count("/")
+      @depth += 1 if File.directory?(path) && path[-1] != "/"
+      $current_instance.context = (block.nil? ? binding : block.binding).eval("self")
+      $current_instance.send(method_name, path)
+      $current_instance = backup
+    end
+  end
+end
 
-	path '/blog/'
-		layout "layout_index.erb"
-		render_all "blog/"
-	end
+# Render blocks
+["media", "documents"].each do |type|
+  self.class.send :define_method, "#{type}_in" do |dir, &block|
+    # Maybe run $current_instance's output_to, define default behaviour?
+    # If so, remember to output after 'load "Deplotfile" too.
+    base = "#{type}/#{dir}/"
+    if type == "media"
+      $current_instance = DeplotMediaRenderer.new(base)
+    else
+      $current_instance = DeplotDocumentRenderer.new(base)
+    end
+    block.call
+  end
+end
 
-## Editing content
+# Inline document render blocks
+["collect", "output"].each do |method|
+  self.class.send :define_method, "#{method}_documents_in" do |dir, &block|
+    # Maybe run $current_instance's output_to, define default behaviour?
+    # If so, remember to output after 'load "Deplotfile" too.
+    base = "documents/#{dir}/"
+    $current_instance.context = nil
+    backup = Marshal.load(Marshal.dump($current_instance))
+    $current_instance = DeplotDocumentRenderer.new(base)
+    block.call unless block.nil?
+    $current_instance.context = (block.nil? ? binding : block.binding).eval("self")
+    output = $current_instance.send method
+    $current_instance = backup
+    return output
+  end
+end
 
-All content is by default in the directory `content/` and can be written in any language
-that `tilt` understands. The directory in which deplot searches for the source files can
-be changed with a call to `content_dir`, and the directory for all assets (layouts,
-stylesheets) with `assets_dir`.
+#
+# Deplot Thor CLI, all the methods of the CLI
+#
 
-EOF
-      end
-    end
-  end
-	
-	desc "new <project_name> (<git_repo>)", "Create a new deplot project, if a git repo is specified by cloning an existing skeleton"
-  def new(project_name, git_skeleton = "")
-    if File.exist? project_name
-      puts "Directory '"+project_name+"' already exists. Exiting..."
-      return
-    end
-    puts "Creating project folder..."
-		if git_skeleton == ""
-			FileUtils.mkdir project_name
-		  $root_dir = Dir.pwd + "/" + project_name
-		  $assets_dir = $root_dir + "/assets"
-	    $content_dir = $root_dir + "/content"
-	   	Dir.chdir project_name do
-		    init
-		  end
-			puts "Finished creating '#{project_name}'- ready to build your site!"
-		else
-    	`git clone #{git_skeleton} #{project_name}`
-			if File.exist? project_name
-    		begin
-					`rm -rf #{project_name}/.git`
-				rescue
-					puts "Unable to delete git references."
-				end
-				puts "Finished creating '#{project_name}' - ready to build your site! (If 'git clone' didn't fail.)"
-			else
-				puts "Git clone failed (see output above)."
-			end
-    end
+class Deplot < Thor
+  desc "version", "Show the installed deplot gem's version."
+  def version
+    puts "Deplot version #{VERSION}."
   end
-  
-  desc "make", "Run deplot and build your project"
-  def make()
-    puts "Making project..."
+  desc "make", "Build the deplot project in the current directory"
+  def make
+    puts "Deplot #{VERSION} will re/build the project.".green
     unless File.exist? "Deplotfile"
-      puts "Deplotfile not found. Exiting..."
+      puts "Deplotfile not found. Exiting...".red
       return
     end
     $LOAD_PATH.unshift(Dir.pwd)
     load "Deplotfile"
-		publish
   end
 end
 Deplot.start

data/deplot.gemspec

@@ -1,9 +1,12 @@
 Gem::Specification.new do |s|
   s.name        = 'deplot'
-  s.version     = '0.0.4'
-  s.date        = '2012-04-29'
-  s.description = "A ruby static web site generator"
-  s.summary     = s.description
+  s.version     = '0.1.0'
+  s.date        = '2013-03-01'
+  s.summary     = "A lightweight and very extensible static web site generator"
+  s.description = %{
+Deplot intends to simplify the process of creating and maintaining a static
+web site and allows for modifications of every part of the building process.
+}.delete "\n"
   s.authors     = ["Cyril Nusko"]
   s.email       = 'gitcdn@gmail.com'
   s.files       = ["bin/deplot"]
@@ -18,4 +21,5 @@ Gem::Specification.new do |s|
 	]
 	s.add_dependency 'thor', "~> 0.14.6"
 	s.add_dependency 'tilt', "~> 1.3.3"
+	s.add_dependency 'colorize'
 end

metadata

@@ -1,63 +1,72 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: deplot
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 0.1.0
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 4
-  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Cyril Nusko
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-04-29 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: thor
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 43
-        segments: 
-        - 0
-        - 14
-        - 6
+      - !ruby/object:Gem::Version
         version: 0.14.6
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+- !ruby/object:Gem::Dependency
   name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 29
-        segments: 
-        - 1
-        - 3
-        - 3
+      - !ruby/object:Gem::Version
         version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-description: A ruby static web site generator
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Deplot intends to simplify the process of creating and maintaining a
+  staticweb site and allows for modifications of every part of the building process.
 email: gitcdn@gmail.com
-executables: 
+executables:
 - deplot
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - Gemfile
 - LICENSE
 - README.md
@@ -65,36 +74,26 @@ files:
 - deplot.gemspec
 homepage: http://www.github.com/cdn64/deplot
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.4
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: A ruby static web site generator
+summary: A lightweight and very extensible static web site generator
 test_files: []
-