ruhoh 0.0.2 → 0.0.3

data/lib/ruhoh/db.rb

@@ -3,24 +3,12 @@ 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
+      WhiteList = [:site, :posts, :drafts, :pages, :routes, :layouts, :partials]
+      self.__send__ :attr_reader, *WhiteList
 
-      # 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
@@ -30,6 +18,8 @@ class Ruhoh
             Ruhoh::Parsers::Routes.generate
           when :posts
             Ruhoh::Parsers::Posts.generate
+          when :drafts
+            Ruhoh::Parsers::Drafts.generate
           when :pages
             Ruhoh::Parsers::Pages.generate
           when :layouts
@@ -45,9 +35,9 @@ class Ruhoh
       end
 
       def update!
-        self.instance_variables.each { |var|
-          self.__send__ :update, var.to_s.gsub('@', '').to_sym
-        }
+        WhiteList.each do |var|
+          self.__send__ :update, var
+        end
       end
       
     end #self

data/lib/ruhoh/deployers/s3.rb

@@ -0,0 +1,71 @@
+require 'aws/s3'
+
+class Ruhoh
+  
+  module Deployers
+    
+    # Deploy to Amazon S3
+    # See http://amazon.rubyforge.org/ for usage.
+    class AmazonS3 < AWS::S3::S3Object
+  
+      def initialize
+        credentials = Ruhoh::Utils.parse_file_as_yaml(Ruhoh.paths.site_source, "_deploy.yml")['s3']
+        self.connect(credentials)
+        self.ensure_bucket(credentials["bucket"])
+        #set_current_bucket_to(credentials["bucket"])
+        @bucket = credentials["bucket"]
+      end
+  
+      def connect(credentials)
+        AWS::S3::Base.establish_connection!({
+          :access_key_id      => credentials["access_key_id"],
+          :secret_access_key  => credentials["secret_access_key"]
+        })
+      end
+
+      def deploy(compiled_directory)
+        FileUtils.cd(compiled_directory) {
+          Dir.glob("**/**") do |filepath|
+            next if FileTest.directory?(file)
+            self.store(filepath)
+          end
+        }
+      end
+      
+      def ensure_bucket(bucket)
+        AWS::S3::Bucket.find(bucket)
+      rescue
+        Ruhoh::Friend.say { 
+          yellow "'#{@bucket}' bucket not found, trying to create..."
+        }
+        AWS::S3::Bucket.create(bucket, :access => :public_read)
+
+        if AWS::S3::Service.response.success?
+          Ruhoh::Friend.say { green "Bucket created!" }
+        else
+          Ruhoh::Friend.say { 
+            red "Bucket creation failed!"
+            plain "Perhaps you will need to manually create the bucket."
+          }
+          exit
+        end
+      end
+      
+      # save/update a file to s3
+      def store(filepath)
+        File.open(filepath) do |file|
+          AWS::S3::S3Object.store(filepath, file, @bucket, :access => :public_read)
+        end
+
+        if AWS::S3::Service.response.success?
+          Ruhoh::Friend.say { green "#{filepath}: success!" }
+        else
+          Ruhoh::Friend.say { green "#{filepath}: failure!" }
+        end
+      end
+    
+    end #S3
+    
+  end #Deployers
+  
+end #Ruhoh

data/lib/ruhoh/friend.rb

@@ -0,0 +1,71 @@
+class Ruhoh
+
+  # The Friend is good for conversation.
+  # He tells you what's going on.
+  # Implementation is largely copied from rspec gem: http://rspec.info/
+  class Friend
+    
+    class << self
+      
+      def say(&block)
+        self.instance_eval(&block)
+      end
+    
+      # TODO: Adds ability to disable if color is not supported?
+      def color_enabled?
+        true
+      end
+      
+      def list(caption, listings)
+        red("  " + caption)
+        listings.each do |pair|
+          cyan("    - " + pair[0])
+          cyan("      " + pair[1])
+        end
+      end
+      
+      def color(text, color_code)
+        puts color_enabled? ? "#{color_code}#{text}\e[0m" : text
+      end
+
+      def plain(text)
+        puts text
+      end
+      
+      def bold(text)
+        color(text, "\e[1m")
+      end
+
+      def red(text)
+        color(text, "\e[31m")
+      end
+
+      def green(text)
+        color(text, "\e[32m")
+      end
+
+      def yellow(text)
+        color(text, "\e[33m")
+      end
+
+      def blue(text)
+        color(text, "\e[34m")
+      end
+
+      def magenta(text)
+        color(text, "\e[35m")
+      end
+
+      def cyan(text)
+        color(text, "\e[36m")
+      end
+
+      def white(text)
+        color(text, "\e[37m")
+      end
+      
+    end #self
+    
+  end #Friend
+
+end #Ruhoh

data/lib/ruhoh/page.rb

@@ -1,35 +1,59 @@
 class Ruhoh
 
   class Page
-    attr_reader :data, :content, :sub_layout, :master_layout
+    attr_reader :id, :data, :content, :sub_layout, :master_layout
+    attr_accessor :templater, :converter
 
+    def initialize
+      @templater = Ruhoh::Templaters::Base
+      @converter = Ruhoh::Converter
+    end
+    
     # 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]
+      
+      @data = if id =~ Regexp.new("^#{Ruhoh.folders.posts}")
+        Ruhoh::DB.posts['dictionary'][id] 
+      elsif id =~ Regexp.new("^#{Ruhoh.folders.drafts}")
+        Ruhoh::DB.drafts[id] 
+      else
+        Ruhoh::DB.pages[id]
+      end
+      
       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]
+      id = if url =~ Regexp.new("^/#{Ruhoh.folders.drafts}")
+        url.gsub(/^\//,'')
+      else
+        Ruhoh::DB.routes[url]
+      end
+      
       raise "Page id not found for url: #{url}" unless id
       self.change(id)
     end
     
     def render
+      raise "ID is null: Id must be set via page.change(id) or page.change_with_url(url)" if @id.nil?
       self.process_layouts
       self.process_content
-      Ruhoh::Templater.expand_and_render(self)
+      @templater.render(self)
     end
     
     def process_layouts
-      @sub_layout = Ruhoh::DB.layouts[@data['layout']]
-      
-      if @sub_layout['data']['layout']
+      raise "ID is null: Id must be set via page.change(id) or page.change_with_url(url)" if @id.nil?
+      if @data['layout']
+        @sub_layout = Ruhoh::DB.layouts[@data['layout']]
+        raise "Layout does not exist: #{@data['layout']}" unless @sub_layout
+      end
+    
+      if @sub_layout && @sub_layout['data']['layout']
         @master_layout = Ruhoh::DB.layouts[@sub_layout['data']['layout']]
+        raise "Layout does not exist: #{@sub_layout['data']['layout']}" unless @master_layout
       end
     end
     
@@ -37,14 +61,18 @@ class Ruhoh
     # 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)
+      raise "ID is null: Id must be set via page.change(id) or page.change_with_url(url)" if @id.nil?
+      data = Ruhoh::Utils.parse_file(Ruhoh.paths.site_source, @id)
+      raise "Invalid Frontmatter in page: #{@id}" if data.empty?
+      
+      @content = @templater.parse(data['content'], self)
+      @content = @converter.convert(self)
     end
     
     # Public: Return page attributes suitable for inclusion in the
     # 'payload' of the given templater.
     def attributes
+      raise "ID is null: Id must be set via page.change(id) or page.change_with_url(url)" if @id.nil?
       @data['content'] = @content
       @data
     end
@@ -53,7 +81,9 @@ class Ruhoh
     #
     # Returns: [String] The relative path to the compiled file for this page.
     def compiled_path
+      raise "ID is null: Id must be set via page.change(id) or page.change_with_url(url)" if @id.nil?
       path = CGI.unescape(@data['url']).gsub(/^\//, '') #strip leading slash.
+      path = "index.html" if path.empty?
       path += '/index.html' unless path =~ /\.html$/
       path
     end

data/lib/ruhoh/parsers/drafts.rb

@@ -0,0 +1,54 @@
+class Ruhoh
+  module Parsers
+    module Drafts
+      
+      def self.generate
+        raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
+        
+        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']
+          data['id']            = filename
+          data['url']           = "/#{filename}"
+          dictionary[filename]  = data
+        end
+        
+        self.report(dictionary, invalid)
+        dictionary
+      end
+      
+      def self.files
+        FileUtils.cd(Ruhoh.paths.site_source) {
+          return Dir["#{Ruhoh.folders.drafts}/**/*.*"].select { |filename|
+            next if FileTest.directory?(filename)
+            next if ['.'].include? filename[0]
+            true
+          }
+        }
+      end
+      
+      def self.report(dictionary, invalid)
+        output = "#{dictionary.count}/#{dictionary.count + invalid.count} drafts processed."
+        if dictionary.empty? && invalid.empty?
+          Ruhoh::Friend.say { plain "0 drafts to process." }
+        elsif invalid.empty?
+          Ruhoh::Friend.say { green output }
+        else
+          Ruhoh::Friend.say {
+            yellow output
+            list "Drafts not processed:", invalid
+          }
+        end
+      end
+      
+    end #Drafts
+  end #Parsers
+end #Ruhoh

data/lib/ruhoh/parsers/layouts.rb

@@ -1,25 +1,30 @@
 class Ruhoh
-  
   module Parsers
-    
     module Layouts
 
       # Generate layouts only from the active theme.
       def self.generate
         layouts = {}
+        
+        self.files.each do |filename|
+          id = File.basename(filename, File.extname(filename))
+          layouts[id] = Ruhoh::Utils.parse_file(Ruhoh.paths.layouts, filename)
+          raise "Invalid Frontmatter in layout: #{filename}" if layouts[id].empty?
+        end
+        
+        layouts
+      end
+
+      def self.files
         FileUtils.cd(Ruhoh.paths.layouts) {
-          Dir.glob("**/*.*") { |filename|
+          return Dir["**/*.*"].select { |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)
+            true
           }
         }
-        layouts
       end
-
+      
     end #Layouts
-  
   end #Parsers
-  
 end #Ruhoh

data/lib/ruhoh/parsers/pages.rb

@@ -8,59 +8,71 @@ class Ruhoh
       #
       def self.generate
         raise "Ruhoh.config cannot be nil.\n To set config call: Ruhoh.setup" unless Ruhoh.config
-        puts "=> Generating Pages..."
 
-        invalid_pages = []
+        pages = self.files
+        invalid = []
         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
+        pages.each do |filename|
+          parsed_page = Ruhoh::Utils.parse_file(filename)
+          if parsed_page.empty?
+            error = "Invalid Yaml Front Matter.\n Ensure this page has valid YAML, even if it's empty."
+            invalid << [filename, error] ; next
+          end
+          
+          parsed_page['data']['id']     = filename
+          parsed_page['data']['url']    = self.permalink(parsed_page['data'])
+          parsed_page['data']['title']  = parsed_page['data']['title'] || self.titleize(filename)
 
-              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
+          dictionary[filename] = parsed_page['data']
+        end
+          
+        report = "#{pages.count - invalid.count }/#{pages.count} pages processed."
+        
+        if pages.count.zero? && invalid.empty?
+          Ruhoh::Friend.say { plain "0 pages to process." }
+        elsif invalid.empty?
+          Ruhoh::Friend.say { green report }
+        else
+          Ruhoh::Friend.say {
+            yellow report
+            list "Pages not processed:", invalid
           }
-        }
+        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 }
+
+      def self.files
+        FileUtils.cd(Ruhoh.paths.site_source) {
+          return Dir["**/*.*"].select { |filename| 
+            next unless self.is_valid_page?(filename)
+            true
+          }
+        }
+      end
+      
+      def self.is_valid_page?(filepath)
+        return false if FileTest.directory?(filepath)
+        return false if ['_', '.'].include? filepath[0]
+        return false if Ruhoh.filters.pages['names'].include? filepath
+        Ruhoh.filters.pages['regexes'].each {|regex| return false if filepath =~ regex }
         true
       end
     
       def self.titleize(filename)
-        File.basename( filename, File.extname(filename) ).gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
+        name = File.basename( filename, File.extname(filename) )
+        name = filename.split('/')[-2] if name == 'index' && !filename.index('/').nil?
+        name.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.gsub!(/\/index.html$/, '')
+        url = "/" if url.empty?
+        
         url
       end
     

data/lib/ruhoh/parsers/partials.rb

@@ -5,7 +5,19 @@ class Ruhoh
     module Partials
     
       def self.generate
-        self.process(Ruhoh.paths.global_partials).merge( self.process(Ruhoh.paths.partials) )
+        self.system_partials.merge(self.global_partials).merge(self.theme_partials)
+      end
+
+      def self.theme_partials
+        self.process(Ruhoh.paths.partials)
+      end
+      
+      def self.global_partials
+        self.process(Ruhoh.paths.global_partials)
+      end
+
+      def self.system_partials
+        self.process(File.join(Ruhoh::Root, 'system_partials'))
       end
 
       def self.process(path)
@@ -16,7 +28,7 @@ class Ruhoh
           Dir.glob("**/*").each { |filename|
             next if FileTest.directory?(filename)
             next if ['.'].include? filename[0]
-            partials[filename] = File.open(filename).read
+            File.open(filename) { |f| partials[filename] = f.read }
           }
         }
         partials