jekyll-reloaded 0.12

data/lib/jekyll/migrators/typo.rb

@@ -0,0 +1,51 @@
+# Author: Toby DiPasquale <toby@cbcg.net>
+require 'fileutils'
+require 'rubygems'
+require 'sequel'
+require 'yaml'
+
+module Jekyll
+  module Typo
+    # This SQL *should* work for both MySQL and PostgreSQL, but I haven't
+    # tested PostgreSQL yet (as of 2008-12-16).
+    SQL = <<-EOS
+    SELECT c.id id,
+           c.title title,
+           c.permalink slug,
+           c.body body,
+           c.published_at date,
+           c.state state,
+           COALESCE(tf.name, 'html') filter
+      FROM contents c
+           LEFT OUTER JOIN text_filters tf
+                        ON c.text_filter_id = tf.id
+    EOS
+
+    def self.process dbname, user, pass, host='localhost'
+      FileUtils.mkdir_p '_posts'
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host, :encoding => 'utf8')
+      db[SQL].each do |post|
+        next unless post[:state] =~ /published/
+
+        name = [ sprintf("%.04d", post[:date].year),
+                 sprintf("%.02d", post[:date].month),
+                 sprintf("%.02d", post[:date].day),
+                 post[:slug].strip ].join('-')
+
+        # Can have more than one text filter in this field, but we just want
+        # the first one for this.
+        name += '.' + post[:filter].split(' ')[0]
+
+        File.open("_posts/#{name}", 'w') do |f|
+          f.puts({ 'layout'   => 'post',
+                   'title'    => post[:title].to_s,
+                   'typo_id'  => post[:id]
+                 }.delete_if { |k, v| v.nil? || v == '' }.to_yaml)
+          f.puts '---'
+          f.puts post[:body].delete("\r")
+        end
+      end
+    end
+
+  end
+end

data/lib/jekyll/migrators/wordpress.rb

@@ -0,0 +1,294 @@
+require 'rubygems'
+require 'sequel'
+require 'fileutils'
+require 'yaml'
+
+# NOTE: This converter requires Sequel and the MySQL gems.
+# The MySQL gem can be difficult to install on OS X. Once you have MySQL
+# installed, running the following commands should work:
+# $ sudo gem install sequel
+# $ sudo gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config
+
+module Jekyll
+  module WordPress
+
+    # Main migrator function. Call this to perform the migration.
+    # 
+    # dbname::  The name of the database
+    # user::    The database user name
+    # pass::    The database user's password
+    # host::    The address of the MySQL database host. Default: 'localhost'
+    # options:: A hash table of configuration options.
+    # 
+    # Supported options are:
+    # 
+    # :table_prefix::   Prefix of database tables used by WordPress.
+    #                   Default: 'wp_'
+    # :clean_entities:: If true, convert non-ASCII characters to HTML
+    #                   entities in the posts, comments, titles, and
+    #                   names. Requires the 'htmlentities' gem to
+    #                   work. Default: true.
+    # :comments::       If true, migrate post comments too. Comments
+    #                   are saved in the post's YAML front matter.
+    #                   Default: true.
+    # :categories::     If true, save the post's categories in its
+    #                   YAML front matter.
+    # :tags::           If true, save the post's tags in its
+    #                   YAML front matter.
+    # :more_excerpt::   If true, when a post has no excerpt but
+    #                   does have a <!-- more --> tag, use the
+    #                   preceding post content as the excerpt.
+    #                   Default: true.
+    # :more_anchor::    If true, convert a <!-- more --> tag into
+    #                   two HTML anchors with ids "more" and
+    #                   "more-NNN" (where NNN is the post number).
+    #                   Default: true.
+    # :status::         Array of allowed post statuses. Only
+    #                   posts with matching status will be migrated.
+    #                   Known statuses are :publish, :draft, :private,
+    #                   and :revision. If this is nil or an empty
+    #                   array, all posts are migrated regardless of
+    #                   status. Default: [:publish].
+    # 
+    def self.process(dbname, user, pass, host='localhost', options={})
+      options = {
+        :table_prefix   => 'wp_',
+        :clean_entities => true,
+        :comments       => true,
+        :categories     => true,
+        :tags           => true,
+        :more_excerpt   => true,
+        :more_anchor    => true,
+        :status         => [:publish] # :draft, :private, :revision
+      }.merge(options)
+
+      if options[:clean_entities]
+        begin
+          require 'htmlentities'
+        rescue LoadError
+          STDERR.puts "Could not require 'htmlentities', so the " +
+                      ":clean_entities option is now disabled."
+          options[:clean_entities] = false
+        end
+      end
+
+      FileUtils.mkdir_p("_posts")
+
+      db = Sequel.mysql(dbname, :user => user, :password => pass,
+                        :host => host, :encoding => 'utf8')
+
+      px = options[:table_prefix]
+
+      posts_query = "
+         SELECT
+           posts.ID            AS `id`,
+           posts.guid          AS `guid`,
+           posts.post_type     AS `type`,
+           posts.post_status   AS `status`,
+           posts.post_title    AS `title`,
+           posts.post_name     AS `slug`,
+           posts.post_date     AS `date`,
+           posts.post_content  AS `content`,
+           posts.post_excerpt  AS `excerpt`,
+           posts.comment_count AS `comment_count`,
+           users.display_name  AS `author`,
+           users.user_login    AS `author_login`,
+           users.user_email    AS `author_email`,
+           users.user_url      AS `author_url`
+         FROM #{px}posts AS `posts`
+           LEFT JOIN #{px}users AS `users`
+             ON posts.post_author = users.ID"
+
+      if options[:status] and not options[:status].empty?
+        status = options[:status][0]
+        posts_query << "
+         WHERE posts.post_status = '#{status.to_s}'"
+        options[:status][1..-1].each do |status|
+          posts_query << " OR
+           posts.post_status = '#{status.to_s}'"
+        end
+      end
+
+      db[posts_query].each do |post|
+        process_post(post, db, options)
+      end
+    end
+
+
+    def self.process_post(post, db, options)
+      px = options[:table_prefix]
+
+      title = post[:title]
+      if options[:clean_entities]
+        title = clean_entities(title)
+      end
+
+      slug = post[:slug]
+      if !slug or slug.empty?
+        slug = sluggify(title)
+      end
+
+      date = post[:date] || Time.now
+      name = "%02d-%02d-%02d-%s.markdown" % [date.year, date.month,
+                                             date.day, slug]
+      content = post[:content].to_s
+      if options[:clean_entities]
+        content = clean_entities(content)
+      end
+
+      excerpt = post[:excerpt].to_s
+
+      more_index = content.index(/<!-- *more *-->/)
+      more_anchor = nil
+      if more_index
+        if options[:more_excerpt] and
+            (post[:excerpt].nil? or post[:excerpt].empty?)
+          excerpt = content[0...more_index]
+        end
+        if options[:more_anchor]
+          more_link = "more"
+          content.sub!(/<!-- *more *-->/,
+                       "<a id=\"more\"></a>" + 
+                       "<a id=\"more-#{post[:id]}\"></a>")
+        end
+      end
+
+      categories = []
+      tags = []
+
+      if options[:categories] or options[:tags]
+
+        cquery =
+          "SELECT
+             terms.name AS `name`,
+             ttax.taxonomy AS `type`
+           FROM
+             #{px}terms AS `terms`,
+             #{px}term_relationships AS `trels`,
+             #{px}term_taxonomy AS `ttax`
+           WHERE
+             trels.object_id = '#{post[:id]}' AND
+             trels.term_taxonomy_id = ttax.term_taxonomy_id AND
+             terms.term_id = ttax.term_id"
+
+        db[cquery].each do |term|
+          if options[:categories] and term[:type] == "category"
+            if options[:clean_entities]
+              categories << clean_entities(term[:name])
+            else
+              categories << term[:name]
+            end
+          elsif options[:tags] and term[:type] == "post_tag"
+            if options[:clean_entities]
+              tags << clean_entities(term[:name])
+            else
+              tags << term[:name]
+            end
+          end
+        end
+      end
+
+      comments = []
+
+      if options[:comments] and post[:comment_count].to_i > 0
+        cquery =
+          "SELECT
+             comment_ID           AS `id`,
+             comment_author       AS `author`,
+             comment_author_email AS `author_email`,
+             comment_author_url   AS `author_url`,
+             comment_date         AS `date`,
+             comment_date_gmt     AS `date_gmt`,
+             comment_content      AS `content`
+           FROM #{px}comments
+           WHERE
+             comment_post_ID = '#{post[:id]}' AND
+             comment_approved != 'spam'"
+
+
+        db[cquery].each do |comment|
+
+          comcontent = comment[:content].to_s
+          if comcontent.respond_to?(:force_encoding)
+            comcontent.force_encoding("UTF-8")
+          end
+          if options[:clean_entities]
+            comcontent = clean_entities(comcontent)
+          end
+          comauthor = comment[:author].to_s
+          if options[:clean_entities]
+            comauthor = clean_entities(comauthor)
+          end
+
+          comments << {
+            'id'           => comment[:id].to_i,
+            'author'       => comauthor,
+            'author_email' => comment[:author_email].to_s,
+            'author_url'   => comment[:author_url].to_s,
+            'date'         => comment[:date].to_s,
+            'date_gmt'     => comment[:date_gmt].to_s,
+            'content'      => comcontent,
+          }
+        end
+
+        comments.sort!{ |a,b| a['id'] <=> b['id'] }
+      end
+
+      # Get the relevant fields as a hash, delete empty fields and
+      # convert to YAML for the header.
+      data = {
+        'layout'        => post[:type].to_s,
+        'status'        => post[:status].to_s,
+        'published'     => (post[:status].to_s == "publish"),
+        'title'         => title.to_s,
+        'author'        => post[:author].to_s,
+        'author_login'  => post[:author_login].to_s,
+        'author_email'  => post[:author_email].to_s,
+        'author_url'    => post[:author_url].to_s,
+        'excerpt'       => excerpt,
+        'more_anchor'   => more_anchor,
+        'wordpress_id'  => post[:id],
+        'wordpress_url' => post[:guid].to_s,
+        'date'          => date,
+        'categories'    => options[:categories] ? categories : nil,
+        'tags'          => options[:tags] ? tags : nil,
+        'comments'      => options[:comments] ? comments : nil,
+      }.delete_if { |k,v| v.nil? || v == '' }.to_yaml
+
+      # Write out the data and content to file
+      File.open("_posts/#{name}", "w") do |f|
+        f.puts data
+        f.puts "---"
+        f.puts content
+      end
+    end
+
+
+    def self.clean_entities( text )
+      if text.respond_to?(:force_encoding)
+        text.force_encoding("UTF-8")
+      end
+      text = HTMLEntities.new.encode(text, :named)
+      # We don't want to convert these, it would break all
+      # HTML tags in the post and comments.
+      text.gsub!("&amp;", "&")
+      text.gsub!("&lt;", "<")
+      text.gsub!("&gt;", ">")
+      text.gsub!("&quot;", '"')
+      text.gsub!("&apos;", "'")
+      text
+    end
+
+
+    def self.sluggify( title )
+      begin
+        require 'unidecode'
+        title = title.to_ascii
+      rescue LoadError
+        STDERR.puts "Could not require 'unidecode'. If your post titles have non-ASCII characters, you could get nicer permalinks by installing unidecode."
+      end
+      title.downcase.gsub(/[^0-9A-Za-z]+/, " ").strip.gsub(" ", "-")
+    end
+
+  end
+end

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

@@ -0,0 +1,160 @@
+module Jekyll
+
+  class Page
+    include Convertible
+
+    attr_writer :dir
+    attr_accessor :site, :pager
+    attr_accessor :name, :ext, :basename
+    attr_accessor :data, :content, :output
+
+    # Initialize a new Page.
+    #
+    # site   - The Site object.
+    # source - 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, source, dir, name)
+      @site = site
+      @dir  = dir
+      @base = File.join(source, @dir)
+      @name = name
+
+      self.process(name)
+      self.read_yaml(@base, name)
+    end
+
+    # The source filename for this page.
+    def filename
+      File.join(@base, name)
+    end
+
+    # The generated directory into which the page will be placed
+    # upon generation. This is derived from the permalink or, if
+    # permalink is absent, we be '/'
+    #
+    # 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.
+    #
+    # 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/"
+      else
+        "/:basename:output_ext"
+      end
+    end
+
+    # The generated relative url of this page. e.g. /about.html.
+    #
+    # Returns the String url.
+    def url
+      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 - The String filename of the page file.
+    #
+    # 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      - The Hash of {"name" => "layout"}.
+    # site_payload - The site payload Hash.
+    #
+    # Returns nothing.
+    def render(layouts, site_payload)
+      payload = {
+        "page" => self.to_liquid,
+        'paginator' => pager.to_liquid
+      }.deep_merge(site_payload)
+
+      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 - 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.
+      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 - The String path to the destination dir.
+    #
+    # Returns nothing.
+    def write(dest)
+      path = destination(dest)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') do |f|
+        f.write(self.output)
+      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
+
+  end
+
+end

data/lib/jekyll/plugin.rb

@@ -0,0 +1,77 @@
+module Jekyll
+
+  class Plugin
+    PRIORITIES = { :lowest => -100,
+                   :low => -10,
+                   :normal => 0,
+                   :high => 10,
+                   :highest => 100 }
+
+    # Install a hook so that subclasses are recorded. This method is only
+    # ever called by Ruby itself.
+    #
+    # base - The Class subclass.
+    #
+    # Returns nothing.
+    def self.inherited(base)
+      subclasses << base
+      subclasses.sort!
+    end
+
+    # The list of Classes that have been subclassed.
+    #
+    # Returns an Array of Class objects.
+    def self.subclasses
+      @subclasses ||= []
+    end
+
+    # Get or set the priority of this plugin. When called without an
+    # argument it returns the priority. When an argument is given, it will
+    # set the priority.
+    #
+    # priority - The Symbol priority (default: nil). Valid options are:
+    #            :lowest, :low, :normal, :high, :highest
+    #
+    # Returns the Symbol priority.
+    def self.priority(priority = nil)
+      @priority ||= nil
+      if priority && PRIORITIES.has_key?(priority)
+        @priority = priority
+      end
+      @priority || :normal
+    end
+
+    # Get or set the safety of this plugin. When called without an argument
+    # it returns the safety. When an argument is given, it will set the
+    # safety.
+    #
+    # safe - The Boolean safety (default: nil).
+    #
+    # Returns the safety Boolean.
+    def self.safe(safe = nil)
+      if safe
+        @safe = safe
+      end
+      @safe || false
+    end
+
+    # Spaceship is priority [higher -> lower]
+    #
+    # other - The class to be compared.
+    #
+    # Returns -1, 0, 1.
+    def self.<=>(other)
+      PRIORITIES[other.priority] <=> PRIORITIES[self.priority]
+    end
+
+    # Initialize a new plugin. This should be overridden by the subclass.
+    #
+    # config - The Hash of configuration options.
+    #
+    # Returns a new instance.
+    def initialize(config = {})
+      # no-op for default
+    end
+  end
+
+end