ruhoh 0.0.2

data/README.md

@@ -0,0 +1,57 @@
+=)
+
+
+## Setup/Config
+
+Ruhoh.setup is responsible for building the configuration data.
+The config takes a given source directory, parses its \_config.yml
+and builds absolute paths to all the Filesystem API endpoints relative to the source directory.
+
+## Parsers
+
+Parsers are small, atomic, functional methods used to process data.
+Parsers follow the Ruhoh interface specification, to locate, extract, and process data relative to the source directory.
+
+
+## DB
+
+The database is responsible for holding website's main data.
+The database depends on Ruhoh.config. 
+It depends on the parsers to parse the source directory in order to return the data.
+
+
+## Page
+
+The page class models a page in the ruhoh system.
+A page is technically a post object or a page object.
+
+- content
+- data (includes yaml front matter + url, id etc.)
+- sub\_layout
+- master\_layout
+
+## Converter
+
+The converter is responsible for converting a pages 'content' into HTML.
+A page can be written in various markup formats specified by the page's extension.
+
+## Templater
+
+The templater is responsible for building the finished page by 
+utilizing the layouts, content, and any embedded templating language expressions.
+
+
+# Compiler
+
+Compiles the full website
+
+# Preview
+
+Serves a singular page view to a web-server identified by its url.
+
+
+
+
+
+
+

data/bin/ruhoh

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'ruhoh'
+require 'ruhoh/client'
+
+help = <<HELP
+Ruhoh is the best static blog generator known to mankind.
+
+Basic Command Line Usage:
+  Test
+HELP
+
+case ARGV[0]
+when 'new'
+  Ruhoh::Client.new_blog(ARGV[1])
+when 'help'
+  puts help
+else
+  puts help
+end

data/lib/ruhoh/client.rb

@@ -0,0 +1,28 @@
+class Ruhoh
+  
+  module Client
+    Root = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+
+    def self.new_blog(name)
+      if name.nil?
+        puts "Name must be specified"
+        exit 0
+      end
+
+      source_directory = File.join(Root, 'scaffolds/blog')
+      target_directory = File.join(Dir.pwd, name)
+
+      if File.exist?(target_directory)
+        puts "#{target_directory} already exists. Specify another directory."
+        exit 0
+      end
+
+      FileUtils.mkdir target_directory
+      FileUtils.cp_r "#{source_directory}/.", target_directory
+      
+      puts "=> Blog successfully cloned to:"
+      puts "=> #{target_directory}"
+    end
+  end
+  
+end #Ruhoh

data/lib/ruhoh/compiler.rb

@@ -0,0 +1,58 @@
+class Ruhoh
+  
+  class Compiler
+    
+    def initialize(target_directory = './_compiled')
+      Ruhoh::DB.initialize
+      @target = target_directory
+      @page = Ruhoh::Page.new
+    end
+    
+    def compile
+      FileUtils.mkdir @target unless File.exist?(@target)
+      self.theme
+      self.pages
+      self.media
+    end
+    
+    def pages
+      processed = []
+      
+      FileUtils.cd(@target) {
+        Ruhoh::DB.posts['dictionary'].merge(Ruhoh::DB.pages).each_value do |p|
+          @page.change(p['id'])
+          
+          FileUtils.mkdir_p File.dirname(@page.compiled_path)
+          File.open(@page.compiled_path, 'w') { |p| p.puts @page.render }
+
+          processed << path
+        end
+      }
+
+      puts "=> Posts Processed:"
+      puts processed
+    end
+    
+    def theme
+      FileUtils.mkdir_p File.join(@target, Ruhoh.config.asset_path)
+      FileUtils.cp_r Ruhoh.paths.theme, File.join(@target, Ruhoh.folders.templates, Ruhoh.folders.themes)
+    end
+    
+    def media
+      FileUtils.mkdir_p File.join(@target, Ruhoh.folders.media)
+      FileUtils.cp_r Ruhoh.paths.media, File.join(@target)
+    end
+    
+    def write_data
+      File.open(Ruhoh.paths.database + '/posts_dictionary.yml', 'w') { |page|
+        page.puts Ruhoh::DB.posts.to_yaml
+      }
+  
+      File.open(Ruhoh.paths.database + '/pages_dictionary.yml', 'w') { |page|
+        page.puts Ruhoh::DB.pages.to_yaml
+      }
+    end
+  
+  end #Compiler
+  
+end #Ruhoh

data/lib/ruhoh/converters/converter.rb

@@ -0,0 +1,17 @@
+require 'maruku'
+
+class Ruhoh
+
+  module Converter
+    
+    def self.convert(page)
+      if ['.md', '.markdown'].include? File.extname(page.data['id']).downcase
+        Maruku.new(page.content).to_html
+      else
+        page.content
+      end
+    end
+    
+  end #Converter
+  
+end #Ruhoh

data/lib/ruhoh/db.rb

@@ -0,0 +1,57 @@
+require "observer"
+
+class Ruhoh
+  
+  # Public: Database class for interacting with "data" in Ruhoh.
+  #
+  class DB
+    
+    class << self
+      include Observable
+      attr_reader :site, :routes, :posts, :pages, :layouts, :partials
+
+      # Note this is class-level so you have to call it manually.
+      def initialize
+        @site       =  ''
+        @routes       =  ''
+        @posts        =  ''
+        @pages        =  ''
+        @layouts      =  ''
+        @partials     =  ''
+        self.update!
+      end
+      
+      def update(name)
+        self.instance_variable_set("@#{name}", 
+          case name
+          when :site
+            Ruhoh::Parsers::Site.generate
+          when :routes
+            Ruhoh::Parsers::Routes.generate
+          when :posts
+            Ruhoh::Parsers::Posts.generate
+          when :pages
+            Ruhoh::Parsers::Pages.generate
+          when :layouts
+            Ruhoh::Parsers::Layouts.generate
+          when :partials
+            Ruhoh::Parsers::Partials.generate
+          else
+            raise "Data type: '#{name}' is not a valid data type."
+          end
+        )
+        changed
+        notify_observers(name)
+      end
+
+      def update!
+        self.instance_variables.each { |var|
+          self.__send__ :update, var.to_s.gsub('@', '').to_sym
+        }
+      end
+      
+    end #self
+    
+  end #DB
+  
+end #Ruhoh

data/lib/ruhoh/page.rb

@@ -0,0 +1,63 @@
+class Ruhoh
+
+  class Page
+    attr_reader :data, :content, :sub_layout, :master_layout
+
+    # Public: Change this page using an id.
+    def change(id)
+      @data = nil
+      @data = id =~ Regexp.new("^#{Ruhoh.folders.posts}") ? Ruhoh::DB.posts['dictionary'][id] : Ruhoh::DB.pages[id]
+      raise "Page #{id} not found in database" unless @data
+      @id = id
+    end
+    
+    # Public: Change this page using a URL.
+    def change_with_url(url)
+      url = '/index.html' if url == '/'
+      id = Ruhoh::DB.routes[url]
+      raise "Page id not found for url: #{url}" unless id
+      self.change(id)
+    end
+    
+    def render
+      self.process_layouts
+      self.process_content
+      Ruhoh::Templater.expand_and_render(self)
+    end
+    
+    def process_layouts
+      @sub_layout = Ruhoh::DB.layouts[@data['layout']]
+      
+      if @sub_layout['data']['layout']
+        @master_layout = Ruhoh::DB.layouts[@sub_layout['data']['layout']]
+      end
+    end
+    
+    # We need to pre-process the content data
+    # in order to invoke converters on the result.
+    # Converters (markdown) always choke on the templating language.
+    def process_content
+      @content = Ruhoh::Utils.parse_file(Ruhoh.paths.site_source, @id)['content']
+      @content = Ruhoh::Templater.render(@content, self)
+      @content = Ruhoh::Converter.convert(self)
+    end
+    
+    # Public: Return page attributes suitable for inclusion in the
+    # 'payload' of the given templater.
+    def attributes
+      @data['content'] = @content
+      @data
+    end
+    
+    # Public: Formats the path to the compiled file based on the URL.
+    #
+    # Returns: [String] The relative path to the compiled file for this page.
+    def compiled_path
+      path = CGI.unescape(@data['url']).gsub(/^\//, '') #strip leading slash.
+      path += '/index.html' unless path =~ /\.html$/
+      path
+    end
+    
+  end #Page
+  
+end #Ruhoh

data/lib/ruhoh/parsers/layouts.rb

@@ -0,0 +1,25 @@
+class Ruhoh
+  
+  module Parsers
+    
+    module Layouts
+
+      # Generate layouts only from the active theme.
+      def self.generate
+        layouts = {}
+        FileUtils.cd(Ruhoh.paths.layouts) {
+          Dir.glob("**/*.*") { |filename|
+            next if FileTest.directory?(filename)
+            next if ['_','.'].include? filename[0]
+            id = File.basename(filename, File.extname(filename))
+            layouts[id] = Ruhoh::Utils.parse_file(Ruhoh.paths.layouts, filename)
+          }
+        }
+        layouts
+      end
+
+    end #Layouts
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/parsers/pages.rb

@@ -0,0 +1,71 @@
+class Ruhoh
+
+  module Parsers
+    
+    module Pages
+    
+      # Public: Generate the Pages dictionary.
+      #
+      def self.generate
+        raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
+        puts "=> Generating Pages..."
+
+        invalid_pages = []
+        dictionary = {}
+        total_pages = 0
+        FileUtils.cd(Ruhoh.paths.site_source) {
+          Dir.glob("**/*.*") { |filename| 
+            next unless self.is_valid_page?(filename)
+            total_pages += 1
+
+            File.open(filename) do |page|
+              front_matter = page.read.match(Ruhoh::Utils::FMregex)
+              if !front_matter
+                invalid_pages << filename ; next
+              end
+
+              data = YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
+              data['id'] = filename
+              data['url'] = self.permalink(data)
+              data['title'] = data['title'] || self.titleize(filename)
+
+              dictionary[filename] = data
+            end
+          }
+        }
+
+        if invalid_pages.empty?
+          puts "=> #{total_pages - invalid_pages.count }/#{total_pages} pages processed."
+        else
+          puts "=> Invalid pages not processed:"
+          puts invalid_pages.to_yaml
+        end   
+      
+        dictionary 
+      end
+    
+      def self.is_valid_page?(filename)
+        return false if FileTest.directory?(filename)
+        return false if ['_', '.'].include? filename[0]
+        return false if Ruhoh.filters.pages['names'].include? filename
+        Ruhoh.filters.pages['regexes'].each {|regex| return false if filename =~ regex }
+        true
+      end
+    
+      def self.titleize(filename)
+        File.basename( filename, File.extname(filename) ).gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
+      end
+    
+      def self.permalink(page)
+        url = '/' + page['id'].gsub(File.extname(page['id']), '.html')
+      
+        # sanitize url
+        url = url.split('/').reject{ |part| part =~ /^\.+$/ }.join('/')
+        url
+      end
+    
+    end # Pages
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/parsers/partials.rb

@@ -0,0 +1,29 @@
+class Ruhoh
+
+  module Parsers
+    
+    module Partials
+    
+      def self.generate
+        self.process(Ruhoh.paths.global_partials).merge( self.process(Ruhoh.paths.partials) )
+      end
+
+      def self.process(path)
+        return {} unless File.exist?(path)
+      
+        partials = {}
+        FileUtils.cd(path) {
+          Dir.glob("**/*").each { |filename|
+            next if FileTest.directory?(filename)
+            next if ['.'].include? filename[0]
+            partials[filename] = File.open(filename).read
+          }
+        }
+        partials
+      end
+    
+    end #Partials
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/parsers/posts.rb

@@ -0,0 +1,209 @@
+class Ruhoh
+
+  module Parsers
+    
+    module Posts
+    
+      MATCHER = /^(.+\/)*(\d+-\d+-\d+)-(.*)(\.[^.]+)$/
+
+      # Public: Generate the Posts dictionary.
+      #
+      def self.generate
+        raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
+        puts "=> Generating Posts..."
+
+        dictionary, invalid_posts = process_posts
+        ordered_posts = []
+        dictionary.each_value { |val| ordered_posts << val }
+      
+        ordered_posts.sort! {
+          |a,b| Date.parse(b['date']) <=> Date.parse(a['date'])
+        }
+      
+        data = {
+          'dictionary' => dictionary,
+          'chronological' => build_chronology(ordered_posts),
+          'collated' => collate(ordered_posts),
+          'tags' => parse_tags(ordered_posts),
+          'categories' => parse_categories(ordered_posts)
+        }
+
+        if invalid_posts.empty?
+          puts "=> #{dictionary.count}/#{dictionary.count + invalid_posts.count} posts processed."
+        else
+          puts "=> Invalid posts not processed:"
+          puts invalid_posts.to_yaml
+        end
+      
+        data
+      end
+
+      def self.process_posts
+        dictionary = {}
+        invalid_posts = []
+
+        FileUtils.cd(Ruhoh.paths.site_source) {
+          Dir.glob("#{Ruhoh.folders.posts}/**/*.*") { |filename| 
+            next if FileTest.directory?(filename)
+            next if ['.'].include? filename[0]
+
+            File.open(filename) do |page|
+              front_matter = page.read.match(Ruhoh::Utils::FMregex)
+              if !front_matter
+                invalid_posts << filename ; next
+              end
+        
+              post = YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
+            
+              m, path, file_date, file_slug, ext = *filename.match(MATCHER)
+              post['date'] = post['date'] || file_date
+
+              ## Test for valid date
+              begin 
+                Time.parse(post['date'])
+              rescue
+                puts "Invalid date format on: #{filename}"
+                puts "Date should be: YYYY/MM/DD"
+                invalid_posts << filename
+                next
+              end
+            
+              post['id'] = filename
+              post['title'] = post['title'] || self.titleize(file_slug)
+              post['url'] = self.permalink(post)
+              dictionary[filename] = post
+            end
+          }
+        }
+
+        [dictionary, invalid_posts]
+      end
+    
+      # my-post-title ===> My Post Title
+      def self.titleize(file_slug)
+        file_slug.gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
+      end
+    
+      # Another blatently stolen method from Jekyll
+      def self.permalink(post)
+        date = Date.parse(post['date'])
+        title = post['title'].downcase.gsub(' ', '-').gsub('.','')
+        format = case (post['permalink'] || Ruhoh.config.permalink)
+        when :pretty
+          "/:categories/:year/:month/:day/:title/"
+        when :none
+          "/:categories/:title.html"
+        when :date
+          "/:categories/:year/:month/:day/:title.html"
+        else
+          post['permalink'] || Ruhoh.config.permalink
+        end
+      
+        url = {
+          "year"       => date.strftime("%Y"),
+          "month"      => date.strftime("%m"),
+          "day"        => date.strftime("%d"),
+          "title"      => CGI::escape(title),
+          "i_day"      => date.strftime("%d").to_i.to_s,
+          "i_month"    => date.strftime("%m").to_i.to_s,
+          "categories" => Array(post['categories'] || post['category']).join('/'),
+          "output_ext" => 'html' # what's this for?
+        }.inject(format) { |result, token|
+          result.gsub(/:#{Regexp.escape token.first}/, token.last)
+        }.gsub(/\/\//, "/")
+
+        # sanitize url
+        url = url.split('/').reject{ |part| part =~ /^\.+$/ }.join('/')
+        url += "/" if url =~ /\/$/
+        url
+      end
+    
+      def self.build_chronology(posts)
+        posts.map { |post| post['id'] }
+      end
+
+      # Internal: Create a collated posts data structure.
+      #
+      # posts - Required [Array] 
+      #  Must be sorted chronologically beforehand.
+      #
+      # [{ 'year': year, 
+      #   'months' : [{ 'month' : month, 
+      #     'posts': [{}, {}, ..] }, ..] }, ..]
+      # 
+      def self.collate(posts)
+        collated = []
+        posts.each_with_index do |post, i|
+          thisYear = Time.parse(post['date']).strftime('%Y')
+          thisMonth = Time.parse(post['date']).strftime('%B')
+          if posts[i-1] 
+            prevYear = Time.parse(posts[i-1]['date']).strftime('%Y')
+            prevMonth = Time.parse(posts[i-1]['date']).strftime('%B')
+          end
+        
+          if(prevYear == thisYear) 
+            if(prevMonth == thisMonth)
+              collated.last['months'].last['posts'] << post['id'] # append to last year & month
+            else
+              collated.last['months'] << {
+                  'month' => thisMonth,
+                  'posts' => [post['id']]
+                } # create new month
+            end
+          else
+            collated << { 
+              'year' => thisYear,
+              'months' => [{ 
+                'month' => thisMonth,
+                'posts' => [post['id']]
+              }]
+            } # create new year & month
+          end
+
+        end
+
+        collated
+      end
+
+      def self.parse_tags(posts)
+        tags = {}
+  
+        posts.each do |post|
+          Array(post['tags']).each do |tag|
+            if tags[tag]
+              tags[tag]['count'] += 1
+            else
+              tags[tag] = { 'count' => 1, 'name' => tag, 'posts' => [] }
+            end 
+
+            tags[tag]['posts'] << post['id']
+          end
+        end  
+        tags
+      end
+
+      def self.parse_categories(posts)
+        categories = {}
+
+        posts.each do |post|
+          cats = post['categories'] ? post['categories'] : Array(post['category']).join('/')
+    
+          Array(cats).each do |cat|
+            cat = Array(cat).join('/')
+            if categories[cat]
+              categories[cat]['count'] += 1
+            else
+              categories[cat] = { 'count' => 1, 'name' => cat, 'posts' => [] }
+            end 
+
+            categories[cat]['posts'] << post['id']
+          end
+        end  
+        categories
+      end
+
+    end # Post
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/parsers/routes.rb

@@ -0,0 +1,24 @@
+class Ruhoh
+
+  module Parsers
+    
+    module Routes
+
+      #[{"url" => "id"}, ... ]
+      def self.generate
+        routes = {}
+        Ruhoh::Parsers::Pages.generate.each_value { |page|
+          routes[page['url']] = page['id'] 
+        }
+        Ruhoh::Parsers::Posts.generate['dictionary'].each_value { |page|
+          routes[page['url']] = page['id'] 
+        }
+      
+        routes
+      end
+    
+    end #Routes
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/parsers/site.rb

@@ -0,0 +1,25 @@
+class Ruhoh
+
+  module Parsers
+
+    # Sitewide data hash + configuration file.
+    module Site
+      
+      def self.generate
+        site = File.join(Ruhoh.paths.site_source, Ruhoh.files.site)
+        site = File.exist?(site) ? File.open(site).read : ''
+        site = YAML.load(site) || {}
+        
+        config = File.join(Ruhoh.paths.site_source, Ruhoh.files.config)
+        config = File.exist?(config) ? File.open(config).read : ''
+        config = YAML.load(config) || {}
+        
+        site['config'] = config
+        site
+      end
+    
+    end #Site
+  
+  end #Parsers
+  
+end #Ruhoh

data/lib/ruhoh/preview.rb

@@ -0,0 +1,36 @@
+class Ruhoh
+  
+  # Public: Rack application used to render singular pages via their URL.
+  # 
+  # Examples
+  #
+  #  In config.ru:
+  #
+  #   require 'ruhoh'
+  #
+  #   Ruhoh.setup
+  #   use Rack::Static, {:root => '.', :urls => ['/_media', "/#{Ruhoh.folders.templates}"]}
+  #   run Ruhoh::Preview.new
+  #
+  class Preview
+    
+    def initialize
+      Ruhoh::DB.initialize
+      @page = Ruhoh::Page.new
+      Ruhoh::Watch.start
+    end
+
+    def call(env)
+      return favicon if env['PATH_INFO'] == '/favicon.ico'
+      
+      @page.change_with_url(env['PATH_INFO'])
+      [200, {'Content-Type' => 'text/html'}, [@page.render]]
+    end
+    
+    def favicon
+      [200, {'Content-Type' => 'image/x-icon'}, ['']]
+    end
+
+  end #Preview
+  
+end #Ruhoh

data/lib/ruhoh/templaters/helper_mustache.rb

@@ -0,0 +1,109 @@
+require 'pp'
+
+class Ruhoh
+  
+  class HelperMustache < Mustache
+
+    class HelperContext < Context
+    
+      # Overload find method to catch helper expressions
+      def find(obj, key, default = nil)
+        return super unless key.to_s.index('?')
+      
+        puts "=> Executing helper: #{key}"
+        context, helper = key.to_s.split('?')
+        context = context.empty? ? obj : super(obj, context)
+
+        self.mustache_in_stack.__send__ helper, context
+      end  
+
+    end #HelperContext
+  
+    def context
+      @context ||= HelperContext.new(self)
+    end
+  
+    def partial(name)
+      Ruhoh::DB.partials[name.to_s]
+    end
+  
+    def debug(sub_context)
+      puts "=>DEBUG:"
+      puts sub_context.class
+      puts sub_context.inspect
+      "<pre>#{sub_context.class}\n#{sub_context.pretty_inspect}</pre>"
+    end
+    
+    def to_tags(sub_context)
+      if sub_context.is_a?(Array)
+        sub_context.map { |id|
+          self.context['_posts']['tags'][id] if self.context['_posts']['tags'][id]
+        }
+      else
+        tags = []
+        self.context['_posts']['tags'].each_value { |tag|
+          tags << tag
+        }
+        tags
+      end
+    end
+  
+    def to_posts(sub_context)
+      sub_context = sub_context.is_a?(Array) ? sub_context : self.context['_posts']['chronological']
+    
+      sub_context.map { |id|
+        self.context['_posts']['dictionary'][id] if self.context['_posts']['dictionary'][id]
+      }
+    end
+  
+    def to_pages(sub_context)
+      puts "=> call: pages_list with context: #{sub_context}"
+      pages = []
+      if sub_context.is_a?(Array) 
+        sub_context.each do |id|
+          if self.context[:pages][id]
+            pages << self.context[:pages][id]
+          end
+        end
+      else
+        self.context[:pages].each_value {|page| pages << page }
+      end
+      pages
+    end
+    
+    def to_categories(sub_context)
+      if sub_context.is_a?(Array)
+        sub_context.map { |id|
+          self.context['_posts']['categories'][id] if self.context['_posts']['categories'][id]
+        }
+      else
+        cats = []
+        self.context['_posts']['categories'].each_value { |cat|
+          cats << cat
+        }
+        cats
+      end
+    end
+    
+    def analytics
+      analytics_config = self.context['site']['config']['analytics']
+      return '' unless analytics_config && analytics_config['provider']
+      code = self.partial("analytics-providers/#{analytics_config['provider']}")
+      return "<h2 style='color:red'>!Analytics Provider partial for '#{analytics_config['provider']}' not found </h2>" if code.nil?
+
+      self.render(code)
+    end
+
+    def comments
+      comments_config = self.context['site']['config']['comments']
+      return '' unless comments_config && comments_config['provider']
+      code = self.partial("comments-providers/#{comments_config['provider']}")
+      puts "comments-provders/#{comments_config['provider']}"
+      return "<h2 style='color:red'>!Comments Provider partial for '#{comments_config['provider']}' not found </h2>" if code.nil?
+
+      self.render(code)
+    end
+    
+  end #HelperMustache
+  
+end #Ruhoh

data/lib/ruhoh/templaters/templater.rb

@@ -0,0 +1,39 @@
+class Ruhoh
+
+  module Templater
+    
+    def self.build_payload(page)
+      {
+        "page"    => page.attributes,
+        "site"    => Ruhoh::DB.site,
+        "pages"   => Ruhoh::DB.pages,
+        "_posts"  => Ruhoh::DB.posts,
+        "ASSET_PATH" => Ruhoh.config.asset_path
+      }
+    end
+
+    def self.expand_and_render(page)
+      self.render(self.expand(page), page)
+    end
+    
+    def self.render(output, page)
+      Ruhoh::HelperMustache.render(output, self.build_payload(page))
+    end
+    
+    # Expand the page.
+    # Places page content into sub-template then into master template if available.
+    def self.expand(page)
+      output = page.sub_layout['content'].gsub(Ruhoh::Utils::ContentRegex, page.content)
+
+      # An undefined master means the page/post layouts is only one deep.
+      # This means it expects to load directly into a master template.
+      if page.master_layout && page.master_layout['content']
+        output = page.master_layout['content'].gsub(Ruhoh::Utils::ContentRegex, output);
+      end
+      
+      output
+    end
+    
+  end #Templater
+  
+end #Ruhoh

data/lib/ruhoh/utils.rb

@@ -0,0 +1,28 @@
+class Ruhoh
+  
+  module Utils
+    
+    FMregex = /^---\n(.|\n)*---\n/
+    ContentRegex = /\{\{\s*content\s*\}\}/i
+    
+    # Relative file_path from site_source
+    def self.parse_file(*args)
+      path = File.__send__ :join, args
+
+      raise "File not found: #{path}" unless File.exist?(path)
+
+      page = File.open(path).read
+      front_matter = page.match(FMregex)
+      raise "Invalid Frontmatter" unless front_matter
+
+      data = YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
+
+      { 
+        "data" => data, 
+        "content" => page.gsub(FMregex, '')
+      }
+    end
+  
+  end
+  
+end #Ruhoh

data/lib/ruhoh/version.rb

@@ -0,0 +1,3 @@
+class Ruhoh
+  Version = VERSION = '0.0.2'
+end

data/lib/ruhoh/watch.rb

@@ -0,0 +1,57 @@
+require 'directory_watcher'
+
+class Ruhoh
+  module Watch
+  
+    # Internal: Watch website source directory for file changes.
+    # The observer triggers data regeneration as files change
+    # in order to keep the data up to date in real time.
+    #
+    # Returns: Nothing
+    def self.start
+      raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
+      puts "=> Start watching: #{Ruhoh.paths.site_source}"
+      glob = ''
+    
+      # Watch all files + all sub directories except for special folders e.g '_database'
+      Dir.chdir(Ruhoh.paths.site_source) {
+        dirs = Dir['*'].select { |x| File.directory?(x) }
+        dirs -= [Ruhoh.folders.database]
+        dirs = dirs.map { |x| "#{x}/**/*" }
+        dirs += ['*']
+        glob = dirs
+      }
+
+      dw = DirectoryWatcher.new(Ruhoh.paths.site_source, {
+        :glob => glob, 
+        :pre_load => true
+      })
+      dw.interval = 1
+      dw.add_observer {|*args| 
+        args.each {|event|
+          path = event['path'].gsub(Ruhoh.paths.site_source, '')
+          puts path
+          if path =~ Regexp.new("^\/?#{Ruhoh.folders.posts}")
+            puts "Watch: update posts"
+            Ruhoh::DB.update(:posts)
+            Ruhoh::DB.update(:routes)
+          elsif path =~ Regexp.new("^\/?#{Ruhoh.folders.templates}")
+            puts "Watch: update themes"
+            Ruhoh::DB.update(:layouts)
+            Ruhoh::DB.update(:partials)
+          else
+            puts "Watch: update pages"
+            Ruhoh::DB.update(:pages)
+            Ruhoh::DB.update(:routes)
+          end
+  
+          t = Time.now.strftime("%H:%M:%S")
+          puts "[#{t}] regeneration: #{args.size} files changed"
+        }
+      }
+
+      dw.start
+    end   
+
+  end  #Watch
+end #Ruhoh

data/lib/ruhoh.rb

@@ -0,0 +1,84 @@
+require 'yaml'
+require 'json'
+require 'time'
+require 'cgi'
+require 'fileutils'
+
+require 'mustache'
+
+require 'ruhoh/utils'
+require 'ruhoh/parsers/posts'
+require 'ruhoh/parsers/pages'
+require 'ruhoh/parsers/routes'
+require 'ruhoh/parsers/layouts'
+require 'ruhoh/parsers/partials'
+require 'ruhoh/parsers/site'
+require 'ruhoh/db'
+require 'ruhoh/templaters/helper_mustache'
+require 'ruhoh/templaters/templater'
+require 'ruhoh/converters/converter'
+require 'ruhoh/page'
+require 'ruhoh/preview'
+require 'ruhoh/watch'
+
+class Ruhoh
+
+  class << self; attr_reader :folders, :files, :config, :paths, :filters end
+  
+  Folders = Struct.new(:database, :posts, :templates, :themes, :layouts, :partials, :media)
+  Files = Struct.new(:site, :config)
+  Filters = Struct.new(:posts, :pages, :static)
+  Config = Struct.new(:permalink, :theme, :asset_path)
+  Paths = Struct.new(
+    :site_source,
+    :database,
+    :posts,
+    :theme,
+    :layouts,
+    :partials,
+    :global_partials,
+    :media
+  )
+  
+  # Public: Setup Ruhoh utilities relative to the current directory
+  # of the application and its corresponding ruhoh.json file.
+  #
+  def self.setup
+    @folders    = Folders.new('_database', '_posts', '_templates', 'themes', 'layouts', 'partials', "_media")
+    @files      = Files.new('_site.yml', '_config.yml')
+    @filters    = Filters.new
+    @config     = Config.new
+    @paths      = Paths.new
+    
+    config = { 'site_source' => Dir.getwd }
+    site_config = YAML.load_file( File.join(config['site_source'], '_config.yml') )
+
+    @config.permalink         = site_config['permalink'] || :date
+    @config.theme             = site_config['theme']
+    @config.asset_path        = File.join('/', @folders.templates, @folders.themes, @config.theme)
+    
+    @paths.site_source = config['site_source']
+    @paths.database    = self.absolute_path(@folders.database)
+    @paths.posts       = self.absolute_path(@folders.posts)
+
+    @paths.theme       = self.absolute_path(@folders.templates, @folders.themes, @config.theme)
+    @paths.layouts     = self.absolute_path(@folders.templates, @folders.themes, @config.theme, @folders.layouts)
+    @paths.partials    = self.absolute_path(@folders.templates, @folders.themes, @config.theme, @folders.partials)
+    @paths.global_partials = self.absolute_path(@folders.templates, @folders.partials)
+    @paths.media = self.absolute_path(@folders.media)
+    
+
+    # filename filters:
+    @filters.pages = { 'names' => [], 'regexes' => [] }
+    exclude = ['Gemfile', 'Gemfile.lock', 'config.ru', 'README.md']
+    exclude.each {|node| 
+      @filters.pages['names'] << node if node.is_a?(String)
+      @filters.pages['regexes'] << node if node.is_a?(Regexp)
+    }
+  end
+  
+  def self.absolute_path(*args)
+    File.__send__ :join, args.unshift(self.paths.site_source)
+  end
+    
+end # Ruhoh  

data/ruhoh.gemspec

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift 'lib'
+require 'ruhoh/version'
+
+Gem::Specification.new do |s|
+  s.name              = "ruhoh"
+  s.version           = Ruhoh::Version
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.license           = "http://unlicense.org/"
+  s.summary           = 'Ruby based library to process your Ruhoh static blog.'
+  s.homepage          = "http://github.com/plusjade/ruhoh.rb"
+  s.email             = "plusjade@gmail.com"
+  s.authors           = ['Jade Dominguez']
+  s.description       = 'Ruhoh is a Universal API for your static blog.'
+  s.executables       = ["ruhoh"]
+  
+  # dependencies defined in Gemfile
+  s.add_dependency 'rack'
+  s.add_dependency 'mustache'
+  s.add_dependency 'directory_watcher'
+  s.add_dependency 'maruku'
+  
+  # = MANIFEST =
+  s.files = %w[
+    README.md
+    bin/ruhoh
+    lib/ruhoh.rb
+    lib/ruhoh/client.rb
+    lib/ruhoh/compiler.rb
+    lib/ruhoh/converters/converter.rb
+    lib/ruhoh/db.rb
+    lib/ruhoh/page.rb
+    lib/ruhoh/parsers/layouts.rb
+    lib/ruhoh/parsers/pages.rb
+    lib/ruhoh/parsers/partials.rb
+    lib/ruhoh/parsers/posts.rb
+    lib/ruhoh/parsers/routes.rb
+    lib/ruhoh/parsers/site.rb
+    lib/ruhoh/preview.rb
+    lib/ruhoh/templaters/helper_mustache.rb
+    lib/ruhoh/templaters/templater.rb
+    lib/ruhoh/utils.rb
+    lib/ruhoh/version.rb
+    lib/ruhoh/watch.rb
+    ruhoh.gemspec
+  ]
+  # = MANIFEST =
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: ruhoh
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jade Dominguez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70125560161900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70125560161900
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: &70125560161480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70125560161480
+- !ruby/object:Gem::Dependency
+  name: directory_watcher
+  requirement: &70125560190740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70125560190740
+- !ruby/object:Gem::Dependency
+  name: maruku
+  requirement: &70125560190320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70125560190320
+description: Ruhoh is a Universal API for your static blog.
+email: plusjade@gmail.com
+executables:
+- ruhoh
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/ruhoh
+- lib/ruhoh.rb
+- lib/ruhoh/client.rb
+- lib/ruhoh/compiler.rb
+- lib/ruhoh/converters/converter.rb
+- lib/ruhoh/db.rb
+- lib/ruhoh/page.rb
+- lib/ruhoh/parsers/layouts.rb
+- lib/ruhoh/parsers/pages.rb
+- lib/ruhoh/parsers/partials.rb
+- lib/ruhoh/parsers/posts.rb
+- lib/ruhoh/parsers/routes.rb
+- lib/ruhoh/parsers/site.rb
+- lib/ruhoh/preview.rb
+- lib/ruhoh/templaters/helper_mustache.rb
+- lib/ruhoh/templaters/templater.rb
+- lib/ruhoh/utils.rb
+- lib/ruhoh/version.rb
+- lib/ruhoh/watch.rb
+- ruhoh.gemspec
+homepage: http://github.com/plusjade/ruhoh.rb
+licenses:
+- http://unlicense.org/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Ruby based library to process your Ruhoh static blog.
+test_files: []