jekyll 0.10.0 → 0.11.0

data/lib/jekyll/migrators/wordpressdotcom.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require 'rubygems'
+require 'hpricot'
+require 'fileutils'
+require 'yaml'
+require 'time'
+
+module Jekyll
+  # This importer takes a wordpress.xml file, which can be exported from your
+  # wordpress.com blog (/wp-admin/export.php).
+  module WordpressDotCom
+    def self.process(filename = "wordpress.xml")
+      import_count = Hash.new(0)
+      doc = Hpricot::XML(File.read(filename))
+
+      (doc/:channel/:item).each do |item|
+        title = item.at(:title).inner_text.strip
+        permalink_title = item.at('wp:post_name').inner_text
+        # Fallback to "prettified" title if post_name is empty (can happen)
+        if permalink_title == ""
+          permalink_title = title.downcase.split.join('-')
+        end
+
+        date = Time.parse(item.at('wp:post_date').inner_text)
+        status = item.at('wp:status').inner_text
+
+        if status == "publish" 
+          published = true
+        else
+          published = false
+        end
+
+        type = item.at('wp:post_type').inner_text
+        tags = (item/:category).map{|c| c.inner_text}.reject{|c| c == 'Uncategorized'}.uniq
+
+        metas = Hash.new
+        item.search("wp:postmeta").each do |meta|
+          key = meta.at('wp:meta_key').inner_text
+          value = meta.at('wp:meta_value').inner_text
+          metas[key] = value;
+        end
+
+        name = "#{date.strftime('%Y-%m-%d')}-#{permalink_title}.html"
+        header = {
+          'layout' => type,
+          'title'  => title,
+          'tags'   => tags,
+          'status'   => status,
+          'type'   => type,
+          'published' => published,
+          'meta'   => metas
+        }
+
+        FileUtils.mkdir_p "_#{type}s"
+        File.open("_#{type}s/#{name}", "w") do |f|
+          f.puts header.to_yaml
+          f.puts '---'
+          f.puts item.at('content:encoded').inner_text
+        end
+
+        import_count[type] += 1
+      end
+
+      import_count.each do |key, value|
+        puts "Imported #{value} #{key}s"
+      end
+    end
+  end
+end

data/lib/jekyll/page.rb

@@ -3,17 +3,17 @@ module Jekyll
   class Page
     include Convertible
 
+    attr_writer :dir
     attr_accessor :site, :pager
-    attr_accessor :name, :ext, :basename, :dir
+    attr_accessor :name, :ext, :basename
     attr_accessor :data, :content, :output
 
     # Initialize a new Page.
-    #   +site+ is the Site
-    #   +base+ is the String path to the <source>
-    #   +dir+ is the String path between <source> and the file
-    #   +name+ is the String filename of the file
     #
-    # Returns <Page>
+    # site - The Site object.
+    # base - The String path to the source.
+    # dir  - The String path between the source and the file.
+    # name - The String filename of the file.
     def initialize(site, base, dir, name)
       @site = site
       @base = base
@@ -26,22 +26,24 @@ module Jekyll
 
     # The generated directory into which the page will be placed
     # upon generation. This is derived from the permalink or, if
-    # permalink is absent, set to '/'
+    # permalink is absent, we be '/'
     #
-    # Returns <String>
+    # Returns the String destination directory.
     def dir
       url[-1, 1] == '/' ? url : File.dirname(url)
     end
 
-    # The full path and filename of the post.
-    # Defined in the YAML of the post body
-    # (Optional)
+    # The full path and filename of the post. Defined in the YAML of the post
+    # body.
     #
-    # Returns <String>
+    # Returns the String permalink or nil if none has been set.
     def permalink
       self.data && self.data['permalink']
     end
 
+    # The template of the permalink.
+    #
+    # Returns the template String.
     def template
       if self.site.permalink_style == :pretty && !index? && html?
         "/:basename/"
@@ -50,35 +52,45 @@ module Jekyll
       end
     end
 
-    # The generated relative url of this page
-    # e.g. /about.html
+    # The generated relative url of this page. e.g. /about.html.
     #
-    # Returns <String>
+    # Returns the String url.
     def url
-      return permalink if permalink
-
-      @url ||= {
-        "basename"   => self.basename,
-        "output_ext" => self.output_ext,
-      }.inject(template) { |result, token|
-        result.gsub(/:#{token.first}/, token.last)
-      }.gsub(/\/\//, "/")
+      return @url if @url
+
+      url = if permalink
+        permalink
+      else
+        {
+          "basename"   => self.basename,
+          "output_ext" => self.output_ext,
+        }.inject(template) { |result, token|
+          result.gsub(/:#{token.first}/, token.last)
+        }.gsub(/\/\//, "/")
+      end
+
+      # sanitize url
+      @url = url.split('/').reject{ |part| part =~ /^\.+$/ }.join('/')
+      @url += "/" if url =~ /\/$/
+      @url
     end
 
-    # Extract information from the page filename
-    #   +name+ is the String filename of the page file
+    # Extract information from the page filename.
+    #
+    # name - The String filename of the page file.
     #
-    # Returns nothing
+    # Returns nothing.
     def process(name)
       self.ext = File.extname(name)
       self.basename = name[0 .. -self.ext.length-1]
     end
 
     # Add any necessary layouts to this post
-    #   +layouts+ is a Hash of {"name" => "layout"}
-    #   +site_payload+ is the site payload hash
     #
-    # Returns nothing
+    # layouts      - The Hash of {"name" => "layout"}.
+    # site_payload - The site payload Hash.
+    #
+    # Returns nothing.
     def render(layouts, site_payload)
       payload = {
         "page" => self.to_liquid,
@@ -88,27 +100,33 @@ module Jekyll
       do_layout(payload, layouts)
     end
 
+    # Convert this Page's data to a Hash suitable for use by Liquid.
+    #
+    # Returns the Hash representation of this Page.
     def to_liquid
       self.data.deep_merge({
         "url"        => File.join(@dir, self.url),
         "content"    => self.content })
     end
-    
+
     # Obtain destination path.
-    #   +dest+ is the String path to the destination dir
     #
-    # Returns destination file path.
+    # dest - The String path to the destination dir.
+    #
+    # Returns the destination file path String.
     def destination(dest)
-      # The url needs to be unescaped in order to preserve the correct filename
+      # The url needs to be unescaped in order to preserve the correct
+      # filename.
       path = File.join(dest, @dir, CGI.unescape(self.url))
       path = File.join(path, "index.html") if self.url =~ /\/$/
       path
     end
 
     # Write the generated page file to the destination directory.
-    #   +dest+ is the String path to the destination dir
     #
-    # Returns nothing
+    # dest - The String path to the destination dir.
+    #
+    # Returns nothing.
     def write(dest)
       path = destination(dest)
       FileUtils.mkdir_p(File.dirname(path))
@@ -117,14 +135,17 @@ module Jekyll
       end
     end
 
+    # Returns the object as a debug String.
     def inspect
       "#<Jekyll:Page @name=#{self.name.inspect}>"
     end
 
+    # Returns the Boolean of whether this Page is HTML or not.
     def html?
       output_ext == '.html'
     end
 
+    # Returns the Boolean of whether this Page is an index file or not.
     def index?
       basename == 'index'
     end

data/lib/jekyll/plugin.rb

@@ -34,6 +34,7 @@ module Jekyll
     #
     # Returns the Symbol priority.
     def self.priority(priority = nil)
+      @priority ||= nil
       if priority && PRIORITIES.has_key?(priority)
         @priority = priority
       end

data/lib/jekyll/post.rb

@@ -78,6 +78,8 @@ module Jekyll
       self.date = Time.parse(date)
       self.slug = slug
       self.ext = ext
+    rescue ArgumentError
+      raise FatalException.new("Post #{name} does not have a valid date.")
     end
 
     # The generated directory into which the post will be placed
@@ -117,20 +119,29 @@ module Jekyll
     #
     # Returns <String>
     def url
-      return permalink if permalink
-
-      @url ||= {
-        "year"       => date.strftime("%Y"),
-        "month"      => date.strftime("%m"),
-        "day"        => date.strftime("%d"),
-        "title"      => CGI.escape(slug),
-        "i_day"      => date.strftime("%d").to_i.to_s,
-        "i_month"    => date.strftime("%m").to_i.to_s,
-        "categories" => categories.join('/'),
-        "output_ext" => self.output_ext
-      }.inject(template) { |result, token|
-        result.gsub(/:#{Regexp.escape token.first}/, token.last)
-      }.gsub(/\/\//, "/")
+      return @url if @url
+
+      url = if permalink
+        permalink
+      else
+        {
+          "year"       => date.strftime("%Y"),
+          "month"      => date.strftime("%m"),
+          "day"        => date.strftime("%d"),
+          "title"      => CGI.escape(slug),
+          "i_day"      => date.strftime("%d").to_i.to_s,
+          "i_month"    => date.strftime("%m").to_i.to_s,
+          "categories" => categories.join('/'),
+          "output_ext" => self.output_ext
+        }.inject(template) { |result, token|
+          result.gsub(/:#{Regexp.escape token.first}/, token.last)
+        }.gsub(/\/\//, "/")
+      end
+
+      # sanitize url
+      @url = url.split('/').reject{ |part| part =~ /^\.+$/ }.join('/')
+      @url += "/" if url =~ /\/$/
+      @url
     end
 
     # The UID for this post (useful in feeds)

data/lib/jekyll/site.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Jekyll
 
   class Site
@@ -7,10 +9,9 @@ module Jekyll
 
     attr_accessor :converters, :generators
 
-    # Initialize the site
-    #   +config+ is a Hash containing site configurations details
+    # Public: Initialize a new Site.
     #
-    # Returns <Site>
+    # config - A Hash containing site configuration details.
     def initialize(config)
       self.config          = config.clone
 
@@ -29,6 +30,21 @@ module Jekyll
       self.setup
     end
 
+    # Public: Read, process, and write this Site to output.
+    #
+    # Returns nothing.
+    def process
+      self.reset
+      self.read
+      self.generate
+      self.render
+      self.cleanup
+      self.write
+    end
+
+    # Reset Site details.
+    #
+    # Returns nothing
     def reset
       self.time            = if self.config['time']
                                Time.parse(self.config['time'].to_s)
@@ -42,13 +58,18 @@ module Jekyll
       self.categories      = Hash.new { |hash, key| hash[key] = [] }
       self.tags            = Hash.new { |hash, key| hash[key] = [] }
 
-      raise ArgumentError, "Limit posts must be nil or >= 1" if !self.limit_posts.nil? && self.limit_posts < 1
+      if !self.limit_posts.nil? && self.limit_posts < 1
+        raise ArgumentError, "Limit posts must be nil or >= 1"
+      end
     end
 
+    # Load necessary libraries, plugins, converters, and generators.
+    #
+    # Returns nothing.
     def setup
       require 'classifier' if self.lsi
 
-      # If safe mode is off, load in any ruby files under the plugins
+      # If safe mode is off, load in any Ruby files under the plugins
       # directory.
       unless self.safe
         Dir[File.join(self.plugins, "**/*.rb")].each do |f|
@@ -69,29 +90,18 @@ module Jekyll
       end
     end
 
-    # Do the actual work of processing the site and generating the
-    # real deal.  5 phases; reset, read, generate, render, write.  This allows
-    # rendering to have full site payload available.
+    # Read Site data from disk and load it into internal data structures.
     #
-    # Returns nothing
-    def process
-      self.reset
-      self.read
-      self.generate
-      self.render
-      self.cleanup
-      self.write
-    end
-
+    # Returns nothing.
     def read
-      self.read_layouts # existing implementation did this at top level only so preserved that
+      self.read_layouts
       self.read_directories
     end
 
     # Read all the files in <source>/<dir>/_layouts and create a new Layout
     # object with each one.
     #
-    # Returns nothing
+    # Returns nothing.
     def read_layouts(dir = '')
       base = File.join(self.source, dir, "_layouts")
       return unless File.exists?(base)
@@ -104,10 +114,44 @@ module Jekyll
       end
     end
 
+    # Recursively traverse directories to find posts, pages and static files
+    # that will become part of the site according to the rules in
+    # filter_entries.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_directories(dir = '')
+      base = File.join(self.source, dir)
+      entries = Dir.chdir(base) { filter_entries(Dir['*']) }
+
+      self.read_posts(dir)
+
+      entries.each do |f|
+        f_abs = File.join(base, f)
+        f_rel = File.join(dir, f)
+        if File.directory?(f_abs)
+          next if self.dest.sub(/\/$/, '') == f_abs
+          read_directories(f_rel)
+        elsif !File.symlink?(f_abs)
+          first3 = File.open(f_abs) { |fd| fd.read(3) }
+          if first3 == "---"
+            # file appears to have a YAML header so process it as a page
+            pages << Page.new(self, self.source, dir, f)
+          else
+            # otherwise treat it as a static file
+            static_files << StaticFile.new(self, self.source, dir, f)
+          end
+        end
+      end
+    end
+
     # Read all the files in <source>/<dir>/_posts and create a new Post
     # object with each one.
     #
-    # Returns nothing
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
     def read_posts(dir)
       base = File.join(self.source, dir, '_posts')
       return unless File.exists?(base)
@@ -132,12 +176,18 @@ module Jekyll
       self.posts = self.posts[-limit_posts, limit_posts] if limit_posts
     end
 
+    # Run each of the Generators.
+    #
+    # Returns nothing.
     def generate
       self.generators.each do |generator|
         generator.generate(self)
       end
     end
 
+    # Render the site to the destination.
+    #
+    # Returns nothing.
     def render
       self.posts.each do |post|
         post.render(self.layouts, site_payload)
@@ -147,24 +197,24 @@ module Jekyll
         page.render(self.layouts, site_payload)
       end
 
-      self.categories.values.map { |ps| ps.sort! { |a, b| b <=> a} }
-      self.tags.values.map { |ps| ps.sort! { |a, b| b <=> a} }
+      self.categories.values.map { |ps| ps.sort! { |a, b| b <=> a } }
+      self.tags.values.map { |ps| ps.sort! { |a, b| b <=> a } }
     rescue Errno::ENOENT => e
       # ignore missing layout dir
     end
-    
-    # Remove orphaned files and empty directories in destination
+
+    # Remove orphaned files and empty directories in destination.
     #
-    # Returns nothing
+    # Returns nothing.
     def cleanup
       # all files and directories in destination, including hidden ones
-      dest_files = []
+      dest_files = Set.new
       Dir.glob(File.join(self.dest, "**", "*"), File::FNM_DOTMATCH) do |file|
         dest_files << file unless file =~ /\/\.{1,2}$/
       end
 
       # files to be written
-      files = []
+      files = Set.new
       self.posts.each do |post|
         files << post.destination(self.dest)
       end
@@ -174,18 +224,20 @@ module Jekyll
       self.static_files.each do |sf|
         files << sf.destination(self.dest)
       end
-      
+
       # adding files' parent directories
-      files.each { |file| files << File.dirname(file) unless files.include? File.dirname(file) }
-      
+      dirs = Set.new
+      files.each { |file| dirs << File.dirname(file) }
+      files.merge(dirs)
+
       obsolete_files = dest_files - files
-      
-      FileUtils.rm_rf(obsolete_files)
+
+      FileUtils.rm_rf(obsolete_files.to_a)
     end
 
-    # Write static files, pages and posts
+    # Write static files, pages, and posts.
     #
-    # Returns nothing
+    # Returns nothing.
     def write
       self.posts.each do |post|
         post.write(self.dest)
@@ -198,59 +250,45 @@ module Jekyll
       end
     end
 
-    # Reads the directories and finds posts, pages and static files that will
-    # become part of the valid site according to the rules in +filter_entries+.
-    #   The +dir+ String is a relative path used to call this method
-    #            recursively as it descends through directories
+    # Constructs a Hash of Posts indexed by the specified Post attribute.
     #
-    # Returns nothing
-    def read_directories(dir = '')
-      base = File.join(self.source, dir)
-      entries = filter_entries(Dir.entries(base))
-
-      self.read_posts(dir)
-
-      entries.each do |f|
-        f_abs = File.join(base, f)
-        f_rel = File.join(dir, f)
-        if File.directory?(f_abs)
-          next if self.dest.sub(/\/$/, '') == f_abs
-          read_directories(f_rel)
-        elsif !File.symlink?(f_abs)
-          first3 = File.open(f_abs) { |fd| fd.read(3) }
-          if first3 == "---"
-            # file appears to have a YAML header so process it as a page
-            pages << Page.new(self, self.source, dir, f)
-          else
-            # otherwise treat it as a static file
-            static_files << StaticFile.new(self, self.source, dir, f)
-          end
-        end
-      end
-    end
-
-    # Constructs a hash map of Posts indexed by the specified Post attribute
+    # post_attr - The String name of the Post attribute.
     #
-    # Returns {post_attr => [<Post>]}
+    # Examples
+    #
+    #   post_attr_hash('categories')
+    #   # => { 'tech' => [<Post A>, <Post B>],
+    #   #      'ruby' => [<Post B>] }
+    #
+    # Returns the Hash: { attr => posts } where
+    #   attr  - One of the values for the requested attribute.
+    #   posts - The Array of Posts with the given attr value.
     def post_attr_hash(post_attr)
-      # Build a hash map based on the specified post attribute ( post attr => array of posts )
-      # then sort each array in reverse order
-      hash = Hash.new { |hash, key| hash[key] = Array.new }
+      # Build a hash map based on the specified post attribute ( post attr =>
+      # array of posts ) then sort each array in reverse order.
+      hash = Hash.new { |hsh, key| hsh[key] = Array.new }
       self.posts.each { |p| p.send(post_attr.to_sym).each { |t| hash[t] << p } }
-      hash.values.map { |sortme| sortme.sort! { |a, b| b <=> a} }
-      return hash
+      hash.values.map { |sortme| sortme.sort! { |a, b| b <=> a } }
+      hash
     end
 
-    # The Hash payload containing site-wide data
+    # The Hash payload containing site-wide data.
     #
-    # Returns {"site" => {"time" => <Time>,
-    #                     "posts" => [<Post>],
-    #                     "pages" => [<Page>],
-    #                     "categories" => [<Post>]}
+    # Returns the Hash: { "site" => data } where data is a Hash with keys:
+    #   "time"       - The Time as specified in the configuration or the
+    #                  current time if none was specified.
+    #   "posts"      - The Array of Posts, sorted chronologically by post date
+    #                  and then title.
+    #   "pages"      - The Array of all Pages.
+    #   "html_pages" - The Array of HTML Pages.
+    #   "categories" - The Hash of category values and Posts.
+    #                  See Site#post_attr_hash for type info.
+    #   "tags"       - The Hash of tag values and Posts.
+    #                  See Site#post_attr_hash for type info.
     def site_payload
       {"site" => self.config.merge({
           "time"       => self.time,
-          "posts"      => self.posts.sort { |a,b| b <=> a },
+          "posts"      => self.posts.sort { |a, b| b <=> a },
           "pages"      => self.pages,
           "html_pages" => self.pages.reject { |page| !page.html? },
           "categories" => post_attr_hash('categories'),
@@ -260,14 +298,34 @@ module Jekyll
     # Filter out any files/directories that are hidden or backup files (start
     # with "." or "#" or end with "~"), or contain site content (start with "_"),
     # or are excluded in the site configuration, unless they are web server
-    # files such as '.htaccess'
+    # files such as '.htaccess'.
+    #
+    # entries - The Array of file/directory entries to filter.
+    #
+    # Returns the Array of filtered entries.
     def filter_entries(entries)
       entries = entries.reject do |e|
         unless ['.htaccess'].include?(e)
-          ['.', '_', '#'].include?(e[0..0]) || e[-1..-1] == '~' || self.exclude.include?(e)
+          ['.', '_', '#'].include?(e[0..0]) ||
+          e[-1..-1] == '~' ||
+          self.exclude.include?(e) ||
+          File.symlink?(e)
         end
       end
     end
 
+    # Get the implementation class for the given Converter.
+    #
+    # klass - The Class of the Converter to fetch.
+    #
+    # Returns the Converter instance implementing the given Converter.
+    def getConverterImpl(klass)
+      matches = self.converters.select { |c| c.class == klass }
+      if impl = matches.first
+        impl
+      else
+        raise "Converter implementation not found for #{klass}"
+      end
+    end
   end
 end