ruhoh 0.3.0 → 1.0.0.alpha

data/lib/ruhoh/paths.rb

@@ -0,0 +1,75 @@
+class Ruhoh
+  # Structured container for all paths to relevant directories and files in the system.
+  # Paths are based on the ruhohspec for the Universal Blog API.
+  # Additionally we store some system (gem) level paths for cascading to default functionality,
+  # such as default widgets, default dashboard view, etc.
+  module Paths
+    Paths = Struct.new(
+      :base,
+      :compiled,
+      :config_data,
+      :dashboard_file,
+      :media,
+      :pages,
+      :partials,
+      :plugins,
+      :posts,
+      :site_data,
+      :themes,
+      :widgets,
+      
+      :theme,
+      :theme_config_data,
+      :theme_dashboard_file,
+      :theme_layouts,
+      :theme_media,
+      :theme_partials,
+      :theme_javascripts,
+      :theme_stylesheets,
+      :theme_widgets,
+    
+      :system_dashboard_file,
+      :system_widgets
+    )
+    
+    def self.generate(config, base)
+      paths                     = Paths.new
+      paths.base                = base
+      paths.config_data         = File.join(base, Ruhoh.names.config_data)
+      paths.pages               = File.join(base, Ruhoh.names.pages)
+      paths.posts               = File.join(base, Ruhoh.names.posts)
+      paths.partials            = File.join(base, Ruhoh.names.partials)
+      paths.media               = File.join(base, Ruhoh.names.media)
+      paths.widgets             = File.join(base, Ruhoh.names.widgets)
+      paths.compiled            = File.join(base, Ruhoh.names.compiled)
+      paths.dashboard_file      = File.join(base, Ruhoh.names.dashboard_file)
+      paths.site_data           = File.join(base, Ruhoh.names.site_data)
+      paths.themes              = File.join(base, Ruhoh.names.themes)
+      paths.plugins             = File.join(base, Ruhoh.names.plugins)
+      
+      paths.theme               = File.join(base, Ruhoh.names.themes, config.theme)
+      paths.theme_dashboard_file= File.join(paths.theme, Ruhoh.names.dashboard_file)
+      paths.theme_config_data   = File.join(paths.theme, Ruhoh.names.theme_config)
+      paths.theme_layouts       = File.join(paths.theme, Ruhoh.names.layouts)
+      paths.theme_stylesheets   = File.join(paths.theme, Ruhoh.names.stylesheets)
+      paths.theme_javascripts       = File.join(paths.theme, Ruhoh.names.javascripts)
+      paths.theme_media         = File.join(paths.theme, Ruhoh.names.media)
+      paths.theme_widgets       = File.join(paths.theme, Ruhoh.names.widgets)
+      paths.theme_partials      = File.join(paths.theme, Ruhoh.names.partials)
+      
+      return false unless self.theme_is_valid?(paths)
+      
+      paths.system_dashboard_file = File.join(Ruhoh::Root, Ruhoh.names.dashboard_file)
+      paths.system_widgets      = File.join(Ruhoh::Root, Ruhoh.names.widgets)
+
+      paths
+    end
+    
+    def self.theme_is_valid?(paths)
+      return true if FileTest.directory?(paths.theme)
+      Ruhoh.log.error("Theme directory does not exist: #{paths.theme}")
+      return false
+    end
+    
+  end #Paths
+end #Ruhoh

data/lib/ruhoh/previewer.rb

@@ -14,8 +14,7 @@ class Ruhoh
 
     def call(env)
       return favicon if env['PATH_INFO'] == '/favicon.ico'
-      dash = File.basename(Ruhoh.files.dashboard, File.extname(Ruhoh.files.dashboard))
-      return admin if ["/#{dash}", "/#{dash}/"].include?(env['PATH_INFO'])
+      return admin if [Ruhoh.urls.dashboard, "#{Ruhoh.urls.dashboard}/"].include?(env['PATH_INFO'])
       
       id = Ruhoh::DB.routes[env['PATH_INFO']]
       raise "Page id not found for url: #{env['PATH_INFO']}" unless id
@@ -29,9 +28,16 @@ class Ruhoh
     end
 
     def admin
-      system_dash  = File.join(Ruhoh::Root, Ruhoh.files.dashboard)
-      template     = File.open(File.exist?(Ruhoh.paths.dashboard) ? Ruhoh.paths.dashboard : system_dash) {|f| f.read }
-      output       = Ruhoh::Templaters::Base.parse(template, nil)
+      template = nil
+      [
+        Ruhoh.paths.theme_dashboard_file,
+        Ruhoh.paths.dashboard_file,
+        Ruhoh.paths.system_dashboard_file
+      ].each do |path|
+        template = path and break if File.exist?(path)
+      end
+      template = File.open(template, 'r:UTF-8') {|f| f.read }
+      output = @page.templater.render(template, Ruhoh::DB.payload)
       
       [200, {'Content-Type' => 'text/html'}, [output]]
     end

data/lib/ruhoh/program.rb

@@ -12,17 +12,48 @@ class Ruhoh
     #   run Ruhoh::Program.preview
     #
     # Returns: A new Rack builder object which should work inside config.ru
-    def self.preview(watch=true)
+    def self.preview(opts={})
+      opts[:watch] ||= true
+      opts[:env] ||= 'development'
+      
       Ruhoh.setup
+      Ruhoh.config.env = opts[:env]
       Ruhoh::DB.update_all
-      Ruhoh::Watch.start if watch
+      Ruhoh::Watch.start if opts[:watch]
       Rack::Builder.new {
         use Rack::Lint
         use Rack::ShowExceptions
-        use Rack::Static, {:urls => ["/#{Ruhoh.folders.media}", "/#{Ruhoh.folders.templates}"]}
-        run Ruhoh::Previewer.new(Ruhoh::Page.new)
+
+        # Serve base media
+        map Ruhoh.urls.media do
+          run Rack::File.new(Ruhoh.paths.media)
+        end
+        
+        # Serve theme assets
+        map Ruhoh.urls.theme do
+          run Rack::File.new(Ruhoh.paths.theme)
+        end
+        
+        # Serve widget javascripts
+        map Ruhoh.urls.widgets do
+          run Rack::File.new(Ruhoh.paths.widgets)
+        end
+
+        map '/' do
+          run Ruhoh::Previewer.new(Ruhoh::Page.new)
+        end
       }
     end
     
+    # Public: A program for compiling to a static website.
+    # The compile environment should always be 'production' in order
+    # to properly omit drafts and other development-only settings.
+    def self.compile(target)
+      Ruhoh.setup
+      Ruhoh.config.env = 'production'
+      Ruhoh::DB.update_all
+      Ruhoh::Compiler.compile(target)
+    end
+    
   end #Program
 end #Ruhoh

data/lib/ruhoh/templaters/asset_helpers.rb

@@ -0,0 +1,66 @@
+class Ruhoh
+  module Templaters
+    module AssetHelpers
+
+      def assets
+        method = "assets_#{Ruhoh.config.env}"
+        return '' unless self.respond_to?(method)
+        self.__send__(method)
+      end
+      
+      def assets_development
+        buffer = ''
+        master_layout = self.context['page']['master_layout']
+        sub_layout = self.context['page']['sub_layout']
+        stylesheets = Ruhoh::DB.stylesheets[master_layout] || []
+        stylesheets += Ruhoh::DB.stylesheets[sub_layout] || []
+        stylesheets += Ruhoh::DB.stylesheets[Ruhoh.names.widgets] || []
+        stylesheets.each do |style|
+          buffer += "<link href=\"#{style['url']}?#{rand()}\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">\n"
+        end
+        buffer += "\n"
+        scripts = Ruhoh::DB.javascripts[master_layout] || []
+        scripts += Ruhoh::DB.javascripts[sub_layout] || []
+        scripts += Ruhoh::DB.javascripts[Ruhoh.names.widgets] || []
+        scripts.each do |script|
+          buffer += "<script src=\"#{script['url']}?#{rand()}\"></script>\n"
+        end
+        
+        buffer
+      end
+      
+      # TODO: Implement this for real.
+      def assets_production
+        self.assets_development
+      end
+      
+      # NOTICE: This is unfinished and not-implemented!
+      def assets_production_not_implemented
+        buffer = ''
+        master_layout = self.context['page']['master_layout']
+        sub_layout = self.context['page']['sub_layout']
+        stylesheets = []
+        stylesheets << master_layout if Ruhoh::DB.stylesheets[master_layout]
+        stylesheets << sub_layout if Ruhoh::DB.stylesheets[sub_layout]
+        
+        stylesheets.each do |name|
+          url = [Ruhoh.urls.theme_stylesheets, "#{name}.css"].join('/')
+          buffer += "<link href=\"#{url}\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">\n"
+        end
+        buffer += "\n"
+        
+        scripts = []
+        scripts << master_layout if Ruhoh::DB.javascripts[master_layout]
+        scripts << sub_layout if Ruhoh::DB.javascripts[sub_layout]
+        # Missing widgets
+        scripts.each do |name|
+          url = [Ruhoh.urls.theme_javascripts, "#{name}.js"].join('/')
+          buffer += "<script src=\"#{url}\"></script>\n"
+        end
+        
+        buffer
+      end
+    
+    end #AssetHelpers
+  end #Templaters
+end #Ruhoh

data/lib/ruhoh/templaters/base_helpers.rb

@@ -0,0 +1,143 @@
+class Ruhoh
+  module Templaters
+    module BaseHelpers
+      
+      def partial(name)
+        p = Ruhoh::DB.partials[name.to_s]
+        Ruhoh::Friend.say { yellow "partial not found: '#{name}'" } if p.nil?
+        p
+      end
+      
+      # Truncate the page content relative to a line_count limit.
+      # This is optimized for markdown files in which content is largely
+      # blocked into chunks and separating by blank lines.
+      # The line_limit truncates content based on # of content-based lines,
+      # so blank lines don't count toward the limit.
+      # Always break the content on a blank line only so result stays formatted nicely.
+      def summary
+        content, id = self.get_page_content
+        line_limit = self.context['site']['config']['posts']['summary_lines'].to_i rescue nil
+        line_limit ||= 20
+        line_count = 0
+        line_breakpoint = content.lines.count
+
+        content.lines.each_with_index do |line, i|
+          if line =~ /^\s*$/  # line with only whitespace
+            if line_count >= line_limit
+              line_breakpoint = i
+              break
+            end
+          else
+            line_count += 1
+          end
+        end
+        
+        content = content.lines.to_a[0, line_breakpoint].join
+        content = self.render(content)
+        Ruhoh::Converter.convert(content, id)
+      end
+      
+      def pages
+        pages = []
+        self.context['db']['pages'].each_value {|page| pages << page }
+        self.mark_active_page(pages)
+      end
+      
+      def posts
+        self.to_posts(self.context['db']['posts']['chronological'])
+      end
+      
+      def posts_latest
+        latest = self.context['site']['config']['posts']['latest'].to_i rescue nil
+        latest ||= 10
+        (latest.to_i > 0) ? self.posts[0, latest.to_i] : self.posts
+      end
+      
+      def categories
+        cats = []
+        self.context['db']['posts']['categories'].each_value { |cat| cats << cat }
+        cats
+      end
+      
+      def tags
+        tags = []
+        self.context['db']['posts']['tags'].each_value { |tag| tags << tag }
+        tags
+      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_posts(sub_context)
+        Array(sub_context).map { |id|
+          self.context['db']['posts']['dictionary'][id]
+        }.compact
+      end
+
+      def to_pages(sub_context)
+        pages = Array(sub_context).map { |id|
+          self.context['db']['pages'][id]
+        }.compact
+        self.mark_active_page(pages)
+      end
+      
+      def to_categories(sub_context)
+        Array(sub_context).map { |id|
+          self.context['db']['posts']['categories'][id] 
+        }.compact
+      end
+      
+      def to_tags(sub_context)
+        Array(sub_context).map { |id|
+          self.context['db']['posts']['tags'][id] 
+        }.compact
+      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['db']['posts']['chronological'].index(id)
+        return unless index && (index-1 >= 0)
+        next_id = self.context['db']['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['db']['posts']['chronological'].index(id)
+        return unless index && (index+1 >= 0)
+        prev_id = self.context['db']['posts']['chronological'][index+1]
+        return unless prev_id
+        self.to_posts(prev_id)
+      end
+            
+      # Marks the active page if exists in the given pages Array
+      def mark_active_page(pages)
+        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
+      
+    end #BaseHelpers
+  end #Templaters
+end #Ruhoh

data/lib/ruhoh/templaters/helpers.rb

@@ -1,155 +1,8 @@
-require 'pp'
-
 class Ruhoh
   module Templaters
+    # Interface for user-defined helper methods
     module Helpers
-      
-      def partial(name)
-        Ruhoh::DB.partials[name.to_s]
-      end
-      
-      def pages
-        pages = []
-        self.context['db']['pages'].each_value {|page| pages << page }
-        self.mark_active_page(pages)
-      end
-      
-      def posts
-        self.to_posts(self.context['db']['posts']['chronological'])
-      end
-      
-      def categories
-        cats = []
-        self.context['db']['posts']['categories'].each_value { |cat| cats << cat }
-        cats
-      end
-      
-      def tags
-        tags = []
-        self.context['db']['posts']['tags'].each_value { |tag| tags << tag }
-        tags
-      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_posts(sub_context)
-        Array(sub_context).map { |id|
-          self.context['db']['posts']['dictionary'][id]
-        }.compact
-      end
-
-      def to_pages(sub_context)
-        pages = Array(sub_context).map { |id|
-          self.context['db']['pages'][id]
-        }.compact
-        self.mark_active_page(pages)
-      end
-      
-      def to_categories(sub_context)
-        Array(sub_context).map { |id|
-          self.context['db']['posts']['categories'][id] 
-        }.compact
-      end
-      
-      def to_tags(sub_context)
-        Array(sub_context).map { |id|
-          self.context['db']['posts']['tags'][id] 
-        }.compact
-      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['db']['posts']['chronological'].index(id)
-        return unless index && (index-1 >= 0)
-        next_id = self.context['db']['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['db']['posts']['chronological'].index(id)
-        return unless index && (index+1 >= 0)
-        prev_id = self.context['db']['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
-      
-      # Marks the active page if exists in the given pages Array
-      def mark_active_page(pages)
-        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
-      
     end #Helpers
   end #Templaters
 end #Ruhoh

data/lib/ruhoh/templaters/rmustache.rb

@@ -1,8 +1,12 @@
-class Ruhoh
+require 'ruhoh/templaters/base_helpers'
+require 'ruhoh/templaters/asset_helpers'
+require 'ruhoh/templaters/helpers'
 
+class Ruhoh
   module Templaters  
-
     class RMustache < Mustache
+      include Ruhoh::Templaters::BaseHelpers
+      include Ruhoh::Templaters::AssetHelpers
       include Ruhoh::Templaters::Helpers
 
       class RContext < Context
@@ -21,9 +25,46 @@ class Ruhoh
       def context
         @context ||= RContext.new(self)
       end
+      
+      # Lazy-load the page body.
+      # When in a global scope (layouts, pages), the content is for the current page.
+      # May also be called in sub-contexts such as looping through posts.
+      #
+      #  {{# posts }}
+      #    {{{ content }}}
+      #  {{/ posts }}
+      def content
+        content, id = self.get_page_content
+        content = self.render(content)
+        Ruhoh::Converter.convert(content, id)
+      end
+      
+      def get_page_content
+        id = self.context['id']
+        id ||= self.context['page']['id']
+        return '' unless id
+        unless id =~ Regexp.new("^#{Ruhoh.names.posts}")
+          id = "#{Ruhoh.names.pages}/#{id}"
+        end
+        
+        [Ruhoh::Utils.parse_page_file(Ruhoh.paths.base, id)['content'], id]
+      end
+      
+      def widget(name)
+        return '' if self.context['page'][name.to_s].to_s == 'false'
+        Ruhoh::DB.widgets[name.to_s]['layout']
+      end
+      
+      def method_missing(name, *args, &block)
+        return self.widget(name.to_s) if Ruhoh::DB.widgets.has_key?(name.to_s)
+        super
+      end
 
+      def respond_to?(method)
+        return true if Ruhoh::DB.widgets.has_key?(method.to_s)
+        super
+      end
+      
     end #RMustache
-  
   end #Templaters
-
 end #Ruhoh

data/lib/ruhoh/urls.rb

@@ -0,0 +1,46 @@
+class Ruhoh
+  # Structured container for all pre-defined URLs in the system.
+  # These URLs are used primarily for static assets in development mode.
+  # When compiling, all urls are of course mapped literally to the asset filepaths.
+  module Urls
+    Urls = Struct.new(
+      :media,
+      :widgets,
+      :dashboard,
+      :theme,
+      :theme_media,
+      :theme_javascripts,
+      :theme_stylesheets,
+      :theme_widgets
+    )
+
+    def self.generate(config)
+      urls                      = Urls.new
+      urls.media                = self.to_url(Ruhoh.names.assets, Ruhoh.names.media)
+      urls.widgets              = self.to_url(Ruhoh.names.assets, Ruhoh.names.widgets)
+      urls.dashboard            = self.to_url(Ruhoh.names.dashboard_file.split('.')[0])
+
+      urls.theme                = self.to_url(Ruhoh.names.assets, config.theme)
+      urls.theme_media          = self.to_url(Ruhoh.names.assets, config.theme, Ruhoh.names.media)
+      urls.theme_javascripts    = self.to_url(Ruhoh.names.assets, config.theme, Ruhoh.names.javascripts)
+      urls.theme_stylesheets    = self.to_url(Ruhoh.names.assets, config.theme, Ruhoh.names.stylesheets)
+      urls.theme_widgets        = self.to_url(Ruhoh.names.assets, config.theme, Ruhoh.names.widgets)
+      urls
+    end
+    
+    def self.to_url(*args)
+      args.unshift(nil).join('/')
+    end
+    
+    def self.to_url_slug(title)
+      CGI::escape self.to_slug(title)
+    end
+    
+    # My Post Title ===> my-post-title
+    def self.to_slug(title)
+      title = title.to_s.downcase.strip.gsub(/[^\p{Word}+]/u, '-')
+      title.gsub(/^\-+/, '').gsub(/\-+$/, '').gsub(/\-+/, '-')
+    end
+    
+  end #Urls
+end #Ruhoh