ruhoh 0.3.0 → 1.0.0.alpha

data/lib/ruhoh/parsers/javascripts.rb

@@ -0,0 +1,67 @@
+class Ruhoh
+  module Parsers
+    # Collect all the javascripts.
+    # Themes explicitly define which javascripts to load via theme.yml.
+    # Additionally, widgets may register javascript dependencies, which are resolved here.
+    module Javascripts
+
+      # Generates mappings to all registered javascripts.
+      # Returns Hash with layout names as keys and Array of asset Objects as values
+      def self.generate
+        theme_config = self.theme_config
+        assets = self.theme_javascripts(theme_config)
+        assets[Ruhoh.names.widgets] = self.widget_javascripts(theme_config)
+        assets
+      end
+
+      def self.theme_javascripts(theme_config)
+        return {} unless theme_config[Ruhoh.names.javascripts].is_a? Hash
+        assets = {}
+        theme_config[Ruhoh.names.javascripts].each do |key, value|
+          next if key == Ruhoh.names.widgets # Widgets are handled separately.
+          assets[key] = Array(value).map { |v|
+            {
+              "url" => "#{Ruhoh.urls.theme_javascripts}/#{v}",
+              "id" => File.join(Ruhoh.paths.theme_javascripts, v)
+            }
+          }
+        end
+        
+        assets
+      end
+      
+      # Notes:
+      #   The automatic script inclusion is currently handled within the widget parser.
+      #   This differs from the auto-stylesheet inclusion relative to themes, 
+      #   which is handled in the stylesheet parser.
+      #   Make sure there are some standards with this.
+      def self.widget_javascripts(theme_config)
+        assets = []
+        Ruhoh::DB.widgets.each_value do |widget|
+          next unless widget[Ruhoh.names.javascripts]
+          assets += Array(widget[Ruhoh.names.javascripts]).map {|path|
+            {
+              "url" => [Ruhoh.urls.widgets, widget['name'], Ruhoh.names.javascripts, path].join('/'),
+              "id"  => File.join(Ruhoh.paths.widgets, widget['name'], Ruhoh.names.javascripts, path)
+            }
+          }
+        end
+        
+        assets
+      end
+      
+      def self.theme_config
+        theme_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.theme_config_data)
+        if theme_config.nil?
+          Ruhoh::Friend.say{ 
+            yellow "WARNING: theme.yml config file not found:"
+            yellow "  #{Ruhoh.paths.theme_config_data}"
+          }
+          return {}
+        end
+        return {} unless theme_config.is_a? Hash
+        theme_config
+      end
+    end #Javascripts
+  end #Parsers
+end #Ruhoh

data/lib/ruhoh/parsers/layouts.rb

@@ -5,23 +5,20 @@ class Ruhoh
       # Generate layouts only from the active theme.
       def self.generate
         layouts = {}
-        invalid = []
         self.files.each do |filename|
           id = File.basename(filename, File.extname(filename))
-          layouts[id] = Ruhoh::Utils.parse_file(Ruhoh.paths.layouts, filename)
-
-          if layouts[id].empty?
-            error = "Invalid YAML Front Matter. Ensure this page has valid YAML, even if it's empty."
-            invalid << [filename, error]
-          end
+          data = Ruhoh::Utils.parse_layout_file(Ruhoh.paths.theme_layouts, filename)
+          data['id'] = id
+          layouts[id] = data
         end
         
-        Ruhoh::Utils.report('Layouts', layouts, invalid)
+        Ruhoh::Utils.report('Layouts', layouts, [])
         layouts
       end
 
       def self.files
-        FileUtils.cd(Ruhoh.paths.layouts) {
+        return [] unless FileTest.directory?(Ruhoh.paths.theme_layouts)
+        FileUtils.cd(Ruhoh.paths.theme_layouts) {
           return Dir["**/*.*"].select { |filename|
             next if FileTest.directory?(filename)
             next if ['_','.'].include? filename[0]
@@ -30,7 +27,6 @@ class Ruhoh
         }
       end
       
-      
     end #Layouts
   end #Parsers
 end #Ruhoh

data/lib/ruhoh/parsers/pages.rb

@@ -8,32 +8,30 @@ class Ruhoh
         Ruhoh.ensure_setup
 
         pages = self.files
-        invalid = []
         dictionary = {}
 
         pages.each do |filename|
           id = self.make_id(filename)
           parsed_page = ''
-          FileUtils.cd(Ruhoh.paths.site_source) { 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
+          FileUtils.cd(Ruhoh.paths.base) { parsed_page = Ruhoh::Utils.parse_page_file(filename) }
           
           parsed_page['data']['id']     = id
           parsed_page['data']['url']    = self.permalink(parsed_page['data'])
           parsed_page['data']['title']  = parsed_page['data']['title'] || self.to_title(filename)
-
+          if parsed_page['data']['layout'].nil?
+            parsed_page['data']['layout'] = Ruhoh.config.pages_layout
+          end
+          
           dictionary[id] = parsed_page['data']
         end
           
-        Ruhoh::Utils.report('Pages', dictionary, invalid)  
+        Ruhoh::Utils.report('Pages', dictionary, [])  
         dictionary 
       end
 
       def self.files
-        FileUtils.cd(Ruhoh.paths.site_source) {
-          return Dir["#{Ruhoh.folders.pages}/**/*.*"].select { |filename|
+        FileUtils.cd(Ruhoh.paths.base) {
+          return Dir["#{Ruhoh.names.pages}/**/*.*"].select { |filename|
             next unless self.is_valid_page?(filename)
             true
           }
@@ -43,40 +41,35 @@ class Ruhoh
       def self.is_valid_page?(filepath)
         return false if FileTest.directory?(filepath)
         return false if ['.'].include? filepath[0]
-        Ruhoh.filters.pages.each {|regex| return false if filepath =~ regex }
+        Ruhoh.config.pages_exclude.each {|regex| return false if filepath =~ regex }
         true
       end
     
       def self.make_id(filename)
-        filename.gsub(Regexp.new("^#{Ruhoh.folders.pages}/"), '')
+        filename.gsub(Regexp.new("^#{Ruhoh.names.pages}/"), '')
       end
       
       def self.to_title(filename)
         name = File.basename( filename, File.extname(filename) )
         name = filename.split('/')[-2] if name == 'index' && !filename.index('/').nil?
-        name.gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
+        name.gsub(/[^\p{Word}+]/u, ' ').gsub(/\b\w/){$&.upcase}
       end
     
       # Build the permalink for the given page.
-      # Only recognize 'convertable' extensions for Markdown at the moment.
+      # Only recognize extensions registered from a 'convertable' module.
       # This means 'non-convertable' extensions should pass-through.
       #
       # Returns [String] the permalink for this page.
       def self.permalink(page)
-        url = '/'
         ext = File.extname(page['id'])
-        url += if ['.md', '.markdown'].include?(ext)
-          page['id'].gsub(Regexp.new("#{ext}$"), '.html')
-        else
-          page['id']
-        end
-        
-        url = url.split('/').reject{ |part| part[0] == '.' }.join('/')
-        url = url.gsub(/\/index.html$/, '')
+        name = page['id'].gsub(Regexp.new("#{ext}$"), '')
+        ext = '.html' if Ruhoh::Converter.extensions.include?(ext)
+        url = name.split('/').map {|p| Ruhoh::Urls.to_url_slug(p) }.join('/')
+        url = "/#{url}#{ext}".gsub(/\/index.html$/, '')
         if page['permalink'] == 'pretty' || Ruhoh.config.pages_permalink == 'pretty'
           url = url.gsub(/\.html$/, '') 
         end
-        url = "/" if url.empty?
+        url = '/' if url.empty?
 
         url
       end

data/lib/ruhoh/parsers/partials.rb

@@ -1,25 +1,19 @@
 class Ruhoh
-
   module Parsers
-    
     module Partials
     
       def self.generate
-        self.system_partials.merge(self.global_partials).merge(self.theme_partials)
+        self.global_partials.merge(self.theme_partials)
       end
-
+      
       def self.theme_partials
-        self.process(Ruhoh.paths.partials)
+        self.process(Ruhoh.paths.theme_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'))
+        self.process(Ruhoh.paths.partials)
       end
-
+      
       def self.process(path)
         return {} unless File.exist?(path)
       
@@ -28,14 +22,12 @@ class Ruhoh
           Dir.glob("**/*").each { |filename|
             next if FileTest.directory?(filename)
             next if ['.'].include? filename[0]
-            File.open(filename) { |f| partials[filename] = f.read }
+            File.open(filename, 'r:UTF-8') { |f| partials[filename] = f.read }
           }
         }
         partials
       end
     
     end #Partials
-  
   end #Parsers
-  
 end #Ruhoh

data/lib/ruhoh/parsers/payload.rb

@@ -0,0 +1,47 @@
+class Ruhoh
+  module Parsers
+    module Payload
+      
+      def self.generate
+        {
+          "db" => {
+            "pages" =>  Ruhoh::DB.pages,
+            "posts" => self.determine_category_and_tag_urls,
+          },
+          "site" => Ruhoh::DB.site,
+          'page' => {},
+          "urls" => {
+            "theme_stylesheets" => Ruhoh.urls.theme_stylesheets,
+            "theme_javascripts" => Ruhoh.urls.theme_javascripts,
+            "theme_media" => Ruhoh.urls.theme_media,
+            "media" => Ruhoh.urls.media,
+          }
+        }
+      end
+      
+      # This is an ugly hack to determine the proper category and tag urls.
+      # TODO: Refactor this out.
+      def self.determine_category_and_tag_urls
+        return nil unless Ruhoh::DB.routes && Ruhoh::DB.posts
+        categories_url = nil
+        ['/categories', '/categories.html'].each { |url|
+          categories_url = url and break if Ruhoh::DB.routes.key?(url)
+        }
+        Ruhoh::DB.posts['categories'].each do |key, value|
+          Ruhoh::DB.posts['categories'][key]['url'] = "#{categories_url}##{value['name']}-ref"
+        end
+        
+        tags_url = nil
+        ['/tags', '/tags.html'].each { |url|
+          tags_url = url and break if Ruhoh::DB.routes.key?(url)
+        }
+        Ruhoh::DB.posts['tags'].each do |key, value|
+          Ruhoh::DB.posts['tags'][key]['url'] = "#{tags_url}##{value['name']}-ref"
+        end
+        
+        Ruhoh::DB.posts
+      end
+      
+    end #Payload
+  end #Parsers
+end #Ruhoh

data/lib/ruhoh/parsers/posts.rb

@@ -30,14 +30,10 @@ class Ruhoh
 
         self.files.each do |filename|
           parsed_page = ''
-          FileUtils.cd(Ruhoh.paths.site_source) { 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
+          FileUtils.cd(Ruhoh.paths.base) { parsed_page = Ruhoh::Utils.parse_page_file(filename) }
           data = parsed_page['data']
           
-          filename_data = self.parse_filename(filename)
+          filename_data = self.parse_page_filename(filename)
           if filename_data.empty?
             error = "Invalid Filename Format. Format should be: my-post-title.ext"
             invalid << [filename, error] ; next
@@ -59,6 +55,7 @@ class Ruhoh
           data['id']            = filename
           data['title']         = data['title'] || filename_data['title']
           data['url']           = self.permalink(data)
+          data['layout']        = Ruhoh.config.posts_layout if data['layout'].nil?
           dictionary[filename]  = data
         end
         
@@ -77,8 +74,8 @@ class Ruhoh
       end
       
       def self.files
-        FileUtils.cd(Ruhoh.paths.site_source) {
-          return Dir["#{Ruhoh.folders.posts}/**/*.*"].select { |filename|
+        FileUtils.cd(Ruhoh.paths.base) {
+          return Dir["#{Ruhoh.names.posts}/**/*.*"].select { |filename|
             next unless self.is_valid_page?(filename)
             true
           }
@@ -88,7 +85,7 @@ class Ruhoh
       def self.is_valid_page?(filepath)
         return false if FileTest.directory?(filepath)
         return false if ['.'].include? filepath[0]
-        Ruhoh.filters.posts.each {|regex| return false if filepath =~ regex }
+        Ruhoh.config.posts_exclude.each {|regex| return false if filepath =~ regex }
         true
       end
       
@@ -102,7 +99,7 @@ class Ruhoh
         ordered_posts
       end
       
-      def self.parse_filename(filename)
+      def self.parse_page_filename(filename)
         data = *filename.match(DateMatcher)
         data = *filename.match(Matcher) if data.empty?
         return {} if data.empty?
@@ -127,41 +124,44 @@ class Ruhoh
       
       # my-post-title ===> My Post Title
       def self.to_title(file_slug)
-        file_slug.gsub(/[\W\_]/, ' ').gsub(/\b\w/){$&.upcase}
+        file_slug.gsub(/[^\p{Word}+]/u, ' ').gsub(/\b\w/){$&.upcase}
       end
     
-      # My Post Title ===> my-post-title
-      def self.to_slug(title)
-        title.downcase.strip.gsub(/\s/, '-').gsub(/[^\w-]/, '')
-      end
-        
       # Used in the client implementation to turn a draft into a post.  
       def self.to_filename(data)
-        File.join(Ruhoh.paths.posts, "#{self.to_slug(data['title'])}.#{data['ext']}")
+        File.join(Ruhoh.paths.posts, "#{Ruhoh::Urls.to_slug(data['title'])}.#{data['ext']}")
       end
       
       # Another blatently stolen method from Jekyll
+      # The category is only the first one if multiple categories exist.
       def self.permalink(post)
         date = Date.parse(post['date'])
-        title = post['title'].downcase.gsub(' ', '-').gsub('.','')
-        format = post['permalink'] || Ruhoh.config.permalink  || "/:categories/:year/:month/:day/:title.html"
+        title = Ruhoh::Urls.to_url_slug(post['title'])
+        format = post['permalink'] || Ruhoh.config.posts_permalink  || "/:categories/:year/:month/:day/:title.html"
+        
+        # Use the literal permalink if it is a non-tokenized string.
+        unless format.include?(':')
+          url = format.gsub(/^\//, '').split('/').map {|p| CGI::escape(p) }.join('/')
+          return "/#{url}"
+        end  
+
+        filename = File.basename(post['id'], File.extname(post['id']))
+        category = Array(post['categories'])[0]
+        category = category.split('/').map {|c| Ruhoh::Urls.to_url_slug(c) }.join('/') if category
         
         url = {
           "year"       => date.strftime("%Y"),
           "month"      => date.strftime("%m"),
           "day"        => date.strftime("%d"),
-          "title"      => CGI::escape(title),
+          "title"      => title,
+          "filename"   => filename,
           "i_day"      => date.strftime("%d").to_i.to_s,
           "i_month"    => date.strftime("%m").to_i.to_s,
-          "categories" => Array(post['categories'])[0] || '',
-          "output_ext" => 'html' # what's this for?
+          "categories" => category || '',
         }.inject(format) { |result, token|
           result.gsub(/:#{Regexp.escape token.first}/, token.last)
-        }.gsub(/\/\//, "/")
+        }.gsub(/\/+/, "/")
 
-        # sanitize url
-        url = url.split('/').reject{ |part| part =~ /^\.+$/ }.join('/')
-        url += "/" if url =~ /\/$/
         url
       end
     
@@ -223,7 +223,6 @@ class Ruhoh
               tags[tag] = { 
                 'count' => 1, 
                 'name' => tag,
-                'url'  => "/tags.html##{tag}-ref",
                 'posts' => [] 
               }
             end 
@@ -236,7 +235,7 @@ class Ruhoh
 
       def self.parse_categories(ordered_posts)
         categories = {}
-
+        
         ordered_posts.each do |post|
           Array(post['categories']).each do |cat|
             cat = Array(cat).join('/')
@@ -246,7 +245,6 @@ class Ruhoh
               categories[cat] = { 
                 'count' => 1, 
                 'name' => cat, 
-                'url'  => "/categories.html##{cat}-ref",
                 'posts' => []
               }
             end 

data/lib/ruhoh/parsers/site.rb

@@ -6,8 +6,8 @@ class Ruhoh
     module Site
       
       def self.generate
-        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 = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.site_data) || {}
+        config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.config_data)
         site['config'] = config
         site
       end

data/lib/ruhoh/parsers/stylesheets.rb

@@ -0,0 +1,75 @@
+class Ruhoh
+  module Parsers
+    # Collect all registered stylesheets.
+    # Themes explicitly define which stylesheets to load via theme.yml.
+    # All styling is managed by the theme, including widget styles.
+    # If the theme provides widget stylesheets they will load automatically.
+    # theme.yml may also specify an explicit widget stylesheet to load.
+    module Stylesheets
+
+      # Generates mappings to all registered stylesheets.
+      # Returns Hash with layout names as keys and Array of asset Objects as values
+      def self.generate
+        theme_config = self.theme_config
+        assets = self.theme_stylesheets(theme_config)
+        assets[Ruhoh.names.widgets] = self.widget_stylesheets(theme_config)
+        assets
+      end
+      
+      # Create mappings for stylesheets registered to the theme layouts.
+      # Themes register stylesheets relative to their layouts.
+      # Returns Hash with layout names as keys and Array of asset Objects as values.
+      def self.theme_stylesheets(theme_config)
+        return {} unless theme_config[Ruhoh.names.stylesheets].is_a? Hash
+        assets = {}
+        theme_config[Ruhoh.names.stylesheets].each do |key, value|
+          next if key == Ruhoh.names.widgets # Widgets are handled separately.
+          assets[key] = Array(value).map { |v|
+            {
+              "url" => "#{Ruhoh.urls.theme_stylesheets}/#{v}",
+              "id" => File.join(Ruhoh.paths.theme_stylesheets, v)
+            }
+          }
+        end
+        
+        assets
+      end
+      
+      # Create mappings for stylesheets registered to a given widget.
+      # A theme may provide widget stylesheets which will load automatically,
+      # provided they adhere to the default naming rules.
+      # Themes may also specify an explicit widget stylesheet to load.
+      # 
+      # Returns Array of asset objects.
+      def self.widget_stylesheets(theme_config)
+        assets = []
+        Ruhoh::DB.widgets.each_key do |name|
+          default_name = "#{name}.css"
+          stylesheet = theme_config[Ruhoh.names.stylesheets][Ruhoh.names.widgets][name] rescue default_name
+          stylesheet ||=  default_name
+          file = File.join(Ruhoh.paths.theme_widgets, name, Ruhoh.names.stylesheets, stylesheet)
+          next unless File.exists?(file)
+          assets << {
+            "url" => [Ruhoh.urls.theme_widgets, name, Ruhoh.names.stylesheets, stylesheet].join('/'),
+            "id" => file
+          }
+        end
+
+        assets
+      end
+      
+      def self.theme_config
+        theme_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.theme_config_data)
+        if theme_config.nil?
+          Ruhoh::Friend.say{ 
+            yellow "WARNING: theme.yml config file not found:"
+            yellow "  #{Ruhoh.paths.theme_config_data}"
+          }
+          return {}
+        end
+        return {} unless theme_config.is_a? Hash
+        theme_config
+      end
+    end #Stylesheets
+  end #Parsers
+end #Ruhoh

data/lib/ruhoh/parsers/widgets.rb

@@ -0,0 +1,104 @@
+class Ruhoh
+  module Parsers
+    module Widgets
+      WidgetStructure = Struct.new(
+        :name,
+        :config,
+        :javascripts,
+        :layout
+      )
+
+      # Process available widgets into widget dictionary.
+      #
+      # Returns Dictionary of widget data.
+      def self.generate
+        widgets = {}
+        self.widgets.each do |name|
+          config = self.process_config(name)
+          widgets[name] = WidgetStructure.new(
+            name,
+            config,
+            self.process_javascripts(config, name),
+            self.process_layout(config, name)
+          )
+        end
+        Ruhoh::Utils.report('Widgets', widgets, [])
+
+        widgets
+      end
+
+      # Find the widgets.
+      #
+      # Returns Array of widget names.
+      def self.widgets
+        names = []
+        if FileTest.directory?(Ruhoh.paths.widgets)
+          FileUtils.cd(Ruhoh.paths.widgets) { names += Dir["*"] }
+        end
+        if FileTest.directory?(Ruhoh.paths.system_widgets)
+          FileUtils.cd(Ruhoh.paths.system_widgets) { names += Dir["*"] }
+        end
+        names.uniq!
+        names
+      end
+      
+      # Process the widget configuration params.
+      #
+      # Returns Hash of configuration params.
+      def self.process_config(widget_name)
+        system_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.system_widgets, widget_name, Ruhoh.names.config_data) || {}
+        user_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.widgets, widget_name, Ruhoh.names.config_data) || {}
+        config = Ruhoh::Utils.deep_merge(system_config, user_config)
+        config['layout'] ||= widget_name
+        config['stylesheet'] ||= widget_name
+        config
+      end
+      
+      # Process widget script dependencies.
+      # Script dependencies may be set in the config.
+      # Look for default script at: scripts/{widget_name}.js if no config.
+      # If found, we include it, else no javascripts will load.
+      #
+      # Returns Array of script filenames to load.
+      def self.process_javascripts(config, widget_name)
+        scripts = config[Ruhoh.names.javascripts] ? Array(config[Ruhoh.names.javascripts]) : []
+        
+        # Try for the default script if no config.
+        if scripts.empty?
+          script_file = File.join(Ruhoh.paths.widgets, widget_name, Ruhoh.names.javascripts, "#{widget_name}.js")
+          if File.exist?(script_file)
+            scripts << "#{widget_name}.js"
+          else
+            script_file = File.join(Ruhoh.paths.system_widgets, widget_name, Ruhoh.names.javascripts, "#{widget_name}.js")
+            scripts << "#{widget_name}.js" if File.exist?(script_file)
+          end
+        end
+        
+        scripts
+      end
+      
+      # Determine and process the correct widget layout.
+      # The layout may be manually configured by the user,
+      # else system defaults will be used.
+      # Layouts cascade from: theme -> blog -> system
+      #
+      # Returns String of rendered layout content.
+      def self.process_layout(config, widget_name)
+        layout = nil
+        layout_path = File.join(widget_name, 'layouts', "#{config['layout']}.html")
+        [
+          File.join(Ruhoh.paths.theme_widgets, layout_path),
+          File.join(Ruhoh.paths.widgets, layout_path),
+          File.join(Ruhoh.paths.system_widgets, layout_path)
+        ].each do |path|
+          layout = path and break if File.exist?(path)
+        end
+
+        return '' unless layout
+        content = File.open(layout, 'r:UTF-8') { |f| f.read }
+        Mustache.render(content, {'config' => config})
+      end
+      
+    end #Widgets
+  end #Parsers
+end #Ruhoh