ruhoh 0.0.2 → 0.0.3

data/lib/ruhoh/parsers/posts.rb

@@ -1,7 +1,5 @@
 class Ruhoh
-
   module Parsers
-    
     module Posts
     
       MATCHER = /^(.+\/)*(\d+-\d+-\d+)-(.*)(\.[^.]+)$/
@@ -10,95 +8,142 @@ class Ruhoh
       #
       def self.generate
         raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
-        puts "=> Generating Posts..."
+        
+        dictionary = self.process
+        ordered_posts = self.ordered_posts(dictionary)
 
-        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'])
+        {
+          'dictionary'      => dictionary,
+          'chronological'   => self.build_chronology(ordered_posts),
+          'collated'        => self.collate(ordered_posts),
+          'tags'            => self.parse_tags(ordered_posts),
+          'categories'      => self.parse_categories(ordered_posts)
         }
+      end
       
-        data = {
-          'dictionary' => dictionary,
-          'chronological' => build_chronology(ordered_posts),
-          'collated' => collate(ordered_posts),
-          'tags' => parse_tags(ordered_posts),
-          'categories' => parse_categories(ordered_posts)
-        }
+      def self.process
+        dictionary = {}
+        invalid = []
+        
+        self.files.each do |filename|
+          parsed_page = Ruhoh::Utils.parse_file(filename)
+          if parsed_page.empty?
+            error = "Invalid YAML Front Matter. Ensure this page has valid YAML, even if it's empty."
+            invalid << [filename, error] ; next
+          end
+          data = parsed_page['data']
+          
+          filename_data = self.parse_filename(filename)
+          if filename_data.empty?
+            error = "Invalid Filename Format. Format should be: YYYY-MM-DD-my-post-title.ext"
+            invalid << [filename, error] ; next
+          end
+          
+          data['date'] ||= filename_data['date']
 
-        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
+          unless self.formatted_date(data['date'])
+            error = "Invalid Date Format. Date should be: YYYY-MM-DD"
+            invalid << [filename, error] ; next
+          end
+        
+          data['date']          = data['date'].to_s
+          data['id']            = filename
+          data['title']         = data['title'] || filename_data['title']
+          data['url']           = self.permalink(data)
+          dictionary[filename]  = data
         end
-      
-        data
+        
+        self.report(dictionary, invalid)
+        dictionary
       end
+      
+      
+      def self.process_file(filename)
+        p = Ruhoh::Utils.parse_file(filename)
+        filename_data = self.parse_filename(filename)
+        
+        if p['data']['title'].nil? || p['data']['title'].gsub(/\s/, '').empty?
+          p['data']['title'] = filename_data['title'] || nil
+        end
 
-      def self.process_posts
-        dictionary = {}
-        invalid_posts = []
-
+        p['data']['date'] ||= filename_data['date']
+        p['data']['date'] = self.formatted_date(p['data']['date'] || Time.now)
+        
+        p
+      end
+      
+      def self.formatted_date(date)
+        Time.parse(date.to_s).strftime('%Y-%m-%d')
+      rescue
+        false
+      end
+      
+      def self.report(dictionary, invalid)
+        output = "#{dictionary.count}/#{dictionary.count + invalid.count} posts processed."
+        if dictionary.empty? && invalid.empty?
+          Ruhoh::Friend.say { plain "0 posts to process." }
+        elsif invalid.empty?
+          Ruhoh::Friend.say { green output }
+        else
+          Ruhoh::Friend.say {
+            yellow output
+            list "Posts not processed:", invalid
+          }
+        end
+      end
+      
+      def self.files
         FileUtils.cd(Ruhoh.paths.site_source) {
-          Dir.glob("#{Ruhoh.folders.posts}/**/*.*") { |filename| 
+          return Dir["#{Ruhoh.folders.posts}/**/*.*"].select { |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
+            true
           }
         }
+      end
+
+      def self.ordered_posts(dictionary)
+        ordered_posts = []
+        dictionary.each_value { |val| ordered_posts << val }
+        ordered_posts.sort! {
+          |a,b| Date.parse(b['date']) <=> Date.parse(a['date'])
+        }
 
-        [dictionary, invalid_posts]
+        ordered_posts
       end
-    
+      
+      def self.parse_filename(filename)
+        data = *filename.match(MATCHER)
+        return {} if data.empty?
+        {
+          "path" => data[1],
+          "date" => data[2],
+          "slug" => data[3],
+          "title" => self.titleize(data[3]),
+          "extension" => data[4]
+        }
+      end
+      
       # my-post-title ===> My Post Title
       def self.titleize(file_slug)
         file_slug.gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
       end
     
+      # My Post Title ===> my-post-title
+      def self.to_slug(title)
+        title.downcase.strip.gsub(/\s/, '-').gsub(/[^\w-]/, '')
+      end
+        
+      def self.to_filename(data)
+        File.join(Ruhoh.paths.posts, "#{self.formatted_date(data['date'])}-#{self.to_slug(data['title'])}.#{data['ext']}")
+      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
-      
+        format = post['permalink'] || Ruhoh.config.permalink  || "/:categories/:year/:month/:day/:title.html"
+        
         url = {
           "year"       => date.strftime("%Y"),
           "month"      => date.strftime("%m"),
@@ -106,7 +151,7 @@ class Ruhoh
           "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('/'),
+          "categories" => Array(post['categories'])[0] || '',
           "output_ext" => 'html' # what's this for?
         }.inject(format) { |result, token|
           result.gsub(/:#{Regexp.escape token.first}/, token.last)
@@ -118,8 +163,8 @@ class Ruhoh
         url
       end
     
-      def self.build_chronology(posts)
-        posts.map { |post| post['id'] }
+      def self.build_chronology(ordered_posts)
+        ordered_posts.map { |post| post['id'] }
       end
 
       # Internal: Create a collated posts data structure.
@@ -131,16 +176,16 @@ class Ruhoh
       #   'months' : [{ 'month' : month, 
       #     'posts': [{}, {}, ..] }, ..] }, ..]
       # 
-      def self.collate(posts)
+      def self.collate(ordered_posts)
         collated = []
-        posts.each_with_index do |post, i|
+        ordered_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')
+          if (i-1 >= 0)
+            prevYear = Time.parse(ordered_posts[i-1]['date']).strftime('%Y')
+            prevMonth = Time.parse(ordered_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
@@ -165,15 +210,20 @@ class Ruhoh
         collated
       end
 
-      def self.parse_tags(posts)
+      def self.parse_tags(ordered_posts)
         tags = {}
   
-        posts.each do |post|
+        ordered_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' => [] }
+              tags[tag] = { 
+                'count' => 1, 
+                'name' => tag,
+                'url'  => "/tags.html##{tag}-ref",
+                'posts' => [] 
+              }
             end 
 
             tags[tag]['posts'] << post['id']
@@ -182,18 +232,21 @@ class Ruhoh
         tags
       end
 
-      def self.parse_categories(posts)
+      def self.parse_categories(ordered_posts)
         categories = {}
 
-        posts.each do |post|
-          cats = post['categories'] ? post['categories'] : Array(post['category']).join('/')
-    
-          Array(cats).each do |cat|
+        ordered_posts.each do |post|
+          Array(post['categories']).each do |cat|
             cat = Array(cat).join('/')
             if categories[cat]
               categories[cat]['count'] += 1
             else
-              categories[cat] = { 'count' => 1, 'name' => cat, 'posts' => [] }
+              categories[cat] = { 
+                'count' => 1, 
+                'name' => cat, 
+                'url'  => "/categories.html##{cat}-ref",
+                'posts' => []
+              }
             end 
 
             categories[cat]['posts'] << post['id']
@@ -203,7 +256,5 @@ class Ruhoh
       end
 
     end # Post
-  
   end #Parsers
-  
 end #Ruhoh

data/lib/ruhoh/parsers/routes.rb

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

data/lib/ruhoh/parsers/site.rb

@@ -6,14 +6,8 @@ class Ruhoh
     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 = Ruhoh::Utils.parse_file_as_yaml(Ruhoh.paths.site_source, Ruhoh.files.site) || {}
+        config = Ruhoh::Utils.parse_file_as_yaml(Ruhoh.paths.site_source, Ruhoh.files.config)
         site['config'] = config
         site
       end

data/lib/ruhoh/previewer.rb

@@ -0,0 +1,48 @@
+class Ruhoh
+  
+  # Public: Rack application used to render singular pages via their URL.
+  # 
+  # Examples
+  #
+  #  In config.ru:
+  #
+  #   require 'ruhoh'
+  #
+  #   Ruhoh.setup
+  #   use Rack::Static, {:urls => ["/#{Ruhoh.folders.media}", "/#{Ruhoh.folders.templates}"]}
+  #   run Ruhoh::Previewer.new
+  #
+  class Previewer
+    
+    def initialize
+      Ruhoh::DB.update!
+      @page = Ruhoh::Page.new
+      Ruhoh::Watch.start
+    end
+
+    def call(env)
+      return favicon if env['PATH_INFO'] == '/favicon.ico'
+      return drafts if ["/#{Ruhoh.folders.drafts}", "/#{Ruhoh.folders.drafts}/"].include?(env['PATH_INFO'])
+      
+      @page.change_with_url(env['PATH_INFO'])
+      [200, {'Content-Type' => 'text/html'}, [@page.render]]
+    end
+    
+    def favicon
+      [200, {'Content-Type' => 'image/x-icon'}, ['']]
+    end
+
+    def drafts
+      html = '<h3>Drafts</h3>'
+      html += '<ul>'
+      Ruhoh::DB.drafts.each_value do |draft|
+        html += "<li><a href='#{draft['url']}'>#{draft['id']}: #{draft['title']}</a></li>"
+      end
+      html += '</ul>'
+      
+      [200, {'Content-Type' => 'text/html'}, [html]]
+    end
+    
+  end #Previewer
+  
+end #Ruhoh

data/lib/ruhoh/templaters/base.rb

@@ -0,0 +1,53 @@
+class Ruhoh
+  
+  module Templaters
+    
+    module Base
+    
+      def self.build_payload(page)
+        {
+          "page"    => page.attributes,
+          "site"    => Ruhoh::DB.site,
+          "pages"   => Ruhoh::DB.pages,
+          "_posts"  => Ruhoh::DB.posts,
+          "THEME_PATH" => Ruhoh.config.theme_path,
+          "SYNTAX_PATH" => Ruhoh.config.syntax_path,
+          "MEDIA_PATH" => Ruhoh.config.media_path
+        }
+      end
+    
+      # Render a given page object.
+      # This is different from parse only in that rendering a page
+      # assumes we use page.content and its layouts as the incoming view.
+      def self.render(page)
+        self.parse(self.expand(page), page)
+      end
+
+      # Parse arbitrary content relative to a given page.
+      def self.parse(output, page)
+        Ruhoh::Templaters::RMustache.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)
+        if page.sub_layout
+          output = page.sub_layout['content'].gsub(Ruhoh::Utils::ContentRegex, page.content)
+        else
+          output = page.content
+        end
+
+        # 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 #Base
+  
+  end #Templaters
+  
+end #Ruhoh

data/lib/ruhoh/templaters/helpers.rb

@@ -0,0 +1,159 @@
+require 'pp'
+
+class Ruhoh
+
+  module Templaters
+    
+    module Helpers
+
+      def partial(name)
+        Ruhoh::DB.partials[name.to_s]
+      end
+
+      def raw_code(sub_context)
+        code = sub_context.gsub('{', '&#123;').gsub('}', '&#125;').gsub('<', '&lt;').gsub('>', '&gt;')
+        "<pre><code>#{code}</code></pre>"
+      end
+      
+      def debug(sub_context)
+        Ruhoh::Friend.say { 
+          yellow "?debug:"
+          magenta sub_context.class
+          cyan 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)
+        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.each_with_index do |page, i| 
+          next unless page['id'] == self.context[:page]['id']
+          active_page = page.dup
+          active_page['is_active_page'] = true
+          pages[i] = active_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 next(sub_context)
+        return unless sub_context.is_a?(String) || sub_context.is_a?(Hash)
+        id = sub_context.is_a?(Hash) ? sub_context['id'] : sub_context
+        return unless id
+        index = self.context['_posts']['chronological'].index(id)
+        return unless index && (index-1 >= 0)
+        next_id = self.context['_posts']['chronological'][index-1]
+        return unless next_id
+        self.to_posts([next_id])
+      end
+      
+      def previous(sub_context)
+        return unless sub_context.is_a?(String) || sub_context.is_a?(Hash)
+        id = sub_context.is_a?(Hash) ? sub_context['id'] : sub_context
+        return unless id
+        index = self.context['_posts']['chronological'].index(id)
+        return unless index && (index+1 >= 0)
+        prev_id = self.context['_posts']['chronological'][index+1]
+        return unless prev_id
+        self.to_posts([prev_id])
+      end
+            
+      def analytics
+        return '' if self.context['page']['analytics'].to_s == 'false'
+        analytics_config = self.context['site']['config']['analytics']
+        return '' unless analytics_config && analytics_config['provider']
+        
+        if analytics_config['provider'] == "custom"
+          code = self.partial("custom_analytics")
+        else
+          code = self.partial("analytics/#{analytics_config['provider']}")
+        end
+
+        return "<h2 style='color:red'>!Analytics Provider partial for '#{analytics_config['provider']}' not found </h2>" if code.nil?
+
+        self.render(code)
+      end
+
+      def comments
+        return '' if self.context['page']['comments'].to_s == 'false'
+        comments_config = self.context['site']['config']['comments']
+        return '' unless comments_config && comments_config['provider']
+        
+        if comments_config['provider'] == "custom"
+          code = self.partial("custom_comments")
+        else
+          code = self.partial("comments/#{comments_config['provider']}")
+        end
+        
+        return "<h2 style='color:red'>!Comments Provider partial for '#{comments_config['provider']}' not found </h2>" if code.nil?
+
+        self.render(code)
+      end
+    
+      def syntax
+        syntax_config = self.context['site']['config']['syntax']
+        return '' unless syntax_config && syntax_config['provider']
+        
+        if syntax_config['provider'] == "custom"
+          code = self.partial("custom_syntax")
+        else
+          code = self.partial("syntax/#{syntax_config['provider']}")
+        end
+        
+        return "<h2 style='color:red'>!Syntax Provider partial for '#{syntax_config['provider']}' not found </h2>" if code.nil?
+
+        self.render(code)
+      end
+      
+    end #Helpers
+  
+  end #Templaters
+  
+end #Ruhoh

data/lib/ruhoh/templaters/rmustache.rb

@@ -0,0 +1,29 @@
+class Ruhoh
+
+  module Templaters  
+
+    class RMustache < Mustache
+      include Ruhoh::Templaters::Helpers
+
+      class RContext < Context
+    
+        # Overload find method to catch helper expressions
+        def find(obj, key, default = nil)
+          return super unless key.to_s.index('?')
+          context, helper = key.to_s.split('?')
+          context = context.empty? ? obj : super(obj, context)
+
+          self.mustache_in_stack.__send__ helper, context
+        end  
+
+      end #RContext
+  
+      def context
+        @context ||= RContext.new(self)
+      end
+
+    end #RMustache
+  
+  end #Templaters
+
+end #Ruhoh