crnixon-jekyll 0.5.1

data/lib/jekyll/converters/csv.rb

@@ -0,0 +1,26 @@
+module Jekyll
+  module CSV
+    #Reads a csv with title, permalink, body, published_at, and filter.
+    #It creates a post file for each row in the csv
+    def self.process(file = "posts.csv")
+      FileUtils.mkdir_p "_posts"
+      posts = 0
+      FasterCSV.foreach(file) do |row|
+        next if row[0] == "title"
+        posts += 1
+        name = row[3].split(" ")[0]+"-"+row[1]+(row[4] =~ /markdown/ ? ".markdown" : ".textile")
+        File.open("_posts/#{name}", "w") do |f|
+          f.puts <<-HEADER
+---
+layout: post
+title: #{row[0]}
+---
+
+          HEADER
+          f.puts row[2]
+        end
+      end
+      "Created #{posts} posts!"
+    end
+  end
+end

data/lib/jekyll/converters/mephisto.rb

@@ -0,0 +1,79 @@
+# Quickly hacked together my Michael Ivey
+# Based on mt.rb by Nick Gerakines, open source and publically
+# available under the MIT license. Use this module at your own risk.
+
+require 'rubygems'
+require 'sequel'
+require 'fastercsv'
+require 'fileutils'
+require File.join(File.dirname(__FILE__),"csv.rb")
+
+# 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 Mephisto
+    #Accepts a hash with database config variables, exports mephisto posts into a csv
+    #export PGPASSWORD if you must
+    def self.postgres(c)
+      sql = <<-SQL
+      BEGIN;
+      CREATE TEMP TABLE jekyll AS
+        SELECT title, permalink, body, published_at, filter FROM contents
+        WHERE user_id = 1 AND type = 'Article' ORDER BY published_at;
+      COPY jekyll TO STDOUT WITH CSV HEADER;
+      ROLLBACK;
+      SQL
+      command = %Q(psql -h #{c[:host] || "localhost"} -c "#{sql.strip}" #{c[:database]} #{c[:username]} -o #{c[:filename] || "posts.csv"})
+      puts command
+      `#{command}`
+      CSV.process
+    end
+
+    # This query will pull blog posts from all entries across all blogs. If
+    # you've got unpublished, deleted or otherwise hidden posts please sift
+    # through the created posts to make sure nothing is accidently published.
+
+    QUERY = "SELECT id, permalink, body, published_at, title FROM contents WHERE user_id = 1 AND type = 'Article' AND published_at IS NOT NULL ORDER BY published_at"
+
+    def self.process(dbname, user, pass, host = 'localhost')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host)
+
+      FileUtils.mkdir_p "_posts"
+
+      db[QUERY].each do |post|
+        title = post[:title]
+        slug = post[:permalink]
+        date = post[:published_at]
+        content = post[:body]
+#         more_content = ''
+
+        # Be sure to include the body and extended body.
+#         if more_content != nil
+#           content = content + " \n" + more_content
+#         end
+
+        # Ideally, this script would determine the post format (markdown, html
+        # , etc) and create files with proper extensions. At this point it
+        # just assumes that markdown will be acceptable.
+        name = [date.year, date.month, date.day, slug].join('-') + ".markdown"
+
+        data = {
+           'layout' => 'post',
+           'title' => title.to_s,
+           'mt_id' => post[:entry_id],
+         }.delete_if { |k,v| v.nil? || v == ''}.to_yaml
+
+        File.open("_posts/#{name}", "w") do |f|
+          f.puts data
+          f.puts "---"
+          f.puts content
+        end
+      end
+
+    end
+  end
+end

data/lib/jekyll/converters/mt.rb

@@ -0,0 +1,59 @@
+# Created by Nick Gerakines, open source and publically available under the
+# MIT license. Use this module at your own risk.
+# I'm an Erlang/Perl/C++ guy so please forgive my dirty ruby.
+
+require 'rubygems'
+require 'sequel'
+require 'fileutils'
+
+# 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 MT
+    # This query will pull blog posts from all entries across all blogs. If
+    # you've got unpublished, deleted or otherwise hidden posts please sift
+    # through the created posts to make sure nothing is accidently published.
+    QUERY = "SELECT entry_id, entry_basename, entry_text, entry_text_more, entry_created_on, entry_title FROM mt_entry"
+
+    def self.process(dbname, user, pass, host = 'localhost')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host)
+
+      FileUtils.mkdir_p "_posts"
+
+      db[QUERY].each do |post|
+        title = post[:entry_title]
+        slug = post[:entry_basename]
+        date = post[:entry_created_on]
+        content = post[:entry_text]
+        more_content = post[:entry_text_more]
+
+        # Be sure to include the body and extended body.
+        if more_content != nil
+          content = content + " \n" + more_content
+        end
+
+        # Ideally, this script would determine the post format (markdown, html
+        # , etc) and create files with proper extensions. At this point it
+        # just assumes that markdown will be acceptable.
+        name = [date.year, date.month, date.day, slug].join('-') + ".markdown"
+
+        data = {
+           'layout' => 'post',
+           'title' => title.to_s,
+           'mt_id' => post[:entry_id],
+         }.delete_if { |k,v| v.nil? || v == ''}.to_yaml
+
+        File.open("_posts/#{name}", "w") do |f|
+          f.puts data
+          f.puts "---"
+          f.puts content
+        end
+      end
+
+    end
+  end
+end

data/lib/jekyll/converters/textpattern.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'sequel'
+require 'fileutils'
+
+# 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 TextPattern
+    # Reads a MySQL database via Sequel and creates a post file for each post.
+    # The only posts selected are those with a status of 4 or 5, which means "live"
+    # and "sticky" respectively.
+    # Other statuses is 1 => draft, 2 => hidden and 3 => pending
+    QUERY = "select Title, url_title, Posted, Body, Keywords from textpattern where Status = '4' or Status = '5'"
+
+    def self.process(dbname, user, pass, host = 'localhost')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host)
+
+      FileUtils.mkdir_p "_posts"
+
+      db[QUERY].each do |post|
+        # Get required fields and construct Jekyll compatible name
+        title = post[:Title]
+        slug = post[:url_title]
+        date = post[:Posted]
+        content = post[:Body]
+
+        name = [date.strftime("%Y-%m-%d"), slug].join('-') + ".textile"
+
+        # Get the relevant fields as a hash, delete empty fields and convert
+        # to YAML for the header
+        data = {
+           'layout' => 'post',
+           'title' => title.to_s,
+           'tags' => post[:Keywords].split(',')
+         }.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
+    end
+  end
+end

data/lib/jekyll/converters/typo.rb

@@ -0,0 +1,49 @@
+# Author: Toby DiPasquale <toby@cbcg.net>
+require 'fileutils'
+require 'rubygems'
+require 'sequel'
+
+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
+      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   # module Typo
+end   # module Jekyll

data/lib/jekyll/converters/wordpress.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'sequel'
+require 'fileutils'
+
+# 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
+
+    # Reads a MySQL database via Sequel and creates a post file for each
+    # post in wp_posts that has post_status = 'publish'.
+    # This restriction is made because 'draft' posts are not guaranteed to
+    # have valid dates.
+    QUERY = "select post_title, post_name, post_date, post_content, post_excerpt, ID, guid from wp_posts where post_status = 'publish' and post_type = 'post'"
+
+    def self.process(dbname, user, pass, host = 'localhost')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host)
+
+      FileUtils.mkdir_p "_posts"
+
+      db[QUERY].each do |post|
+        # Get required fields and construct Jekyll compatible name
+        title = post[:post_title]
+        slug = post[:post_name]
+        date = post[:post_date]
+        content = post[:post_content]
+        name = "%02d-%02d-%02d-%s.markdown" % [date.year, date.month, date.day,
+                                               slug]
+
+        # Get the relevant fields as a hash, delete empty fields and convert
+        # to YAML for the header
+        data = {
+           'layout' => 'post',
+           'title' => title.to_s,
+           'excerpt' => post[:post_excerpt].to_s,
+           'wordpress_id' => post[:ID],
+           'wordpress_url' => post[:guid]
+         }.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
+
+    end
+  end
+end

data/lib/jekyll/convertible.rb

@@ -0,0 +1,117 @@
+# Convertible provides methods for converting a pagelike item
+# from a certain type of markup into actual content
+#
+# Requires
+#   self.site -> Jekyll::Site
+module Jekyll
+  module Convertible
+    # Return the contents as a string
+    def to_s
+      self.content || ''
+    end
+
+    # Read the YAML frontmatter
+    #   +base+ is the String path to the dir containing the file
+    #   +name+ is the String filename of the file
+    #
+    # Returns nothing
+    def read_yaml(base, name)
+      self.content = File.read(File.join(base, name))
+
+      if self.content =~ /^(---\s*\n.*?)\n---\s*\n/m
+        self.content = self.content[($1.size + 5)..-1]
+
+        self.data ||= {}
+        self.data = self.data.merge(YAML.load($1))
+      end
+    end
+
+    # Transform the contents based on the file extension.
+    #
+    # Returns nothing
+    def transform
+      case self.content_type
+      when 'textile'
+        self.ext = ".html"
+        self.content = self.site.textile(self.content)
+      when 'markdown'
+        self.ext = ".html"
+        self.content = self.site.markdown(self.content)
+      when 'haml'
+        self.ext = ".html"
+        # Actually rendered in do_layout.
+        self.content = Haml::Engine.new(self.content, :attr_wrapper => %{"})
+      end
+    end
+
+    # Determine which formatting engine to use based on this convertible's
+    # extension
+    #
+    # Returns one of :textile, :markdown or :unknown
+    def content_type
+      case self.ext[1..-1]
+      when /textile/i
+        return 'textile'
+      when /markdown/i, /mkdn/i, /md/i
+        return 'markdown'
+      when /haml/i
+        return 'haml'
+      end
+      return 'unknown'
+    end
+    
+    # Sets up a context for Haml and renders in it. The context has accessors
+    # matching the passed-in hash, e.g. "site", "page" and "content", and has
+    # helper modules mixed in.
+    #
+    # Returns String.
+    def render_haml_in_context(haml_engine, params={})
+      context = ClosedStruct.new(params)
+      context.extend(HamlHelpers)
+      context.extend(::Helpers) if defined?(::Helpers)
+      haml_engine.render(context)
+    end
+
+    # Add any necessary layouts to this convertible document
+    #   +layouts+ is a Hash of {"name" => "layout"}
+    #   +site_payload+ is the site payload hash
+    #
+    # Returns nothing
+    def do_layout(payload, layouts)
+      info = { :filters => [Jekyll::Filters], :registers => { :site => self.site } }
+
+      # render and transform content (this becomes the final content of the object)
+      payload["content_type"] = self.content_type
+      
+      if self.content_type == "haml"
+        self.transform
+        self.content = render_haml_in_context(self.content,
+          :site => self.site,
+          :page => ClosedStruct.new(payload["page"]))
+      else
+        self.content = Liquid::Template.parse(self.content).render(payload, info)
+        self.transform
+      end
+
+      # output keeps track of what will finally be written
+      self.output = self.content
+
+      # recursively render layouts
+      layout = layouts[self.data["layout"]]
+      while layout
+        payload = payload.deep_merge({"content" => self.output, "page" => layout.data})
+        
+        if site.config['haml'] && layout.content.is_a?(Haml::Engine)
+          self.output = render_haml_in_context(layout.content, 
+            :site => self.site,
+            :page => ClosedStruct.new(payload["page"]),
+            :content => payload["content"])
+        else
+          self.output = Liquid::Template.parse(layout.content).render(payload, info)
+        end
+
+        layout = layouts[layout.data["layout"]]
+      end
+    end
+  end
+end

data/lib/jekyll/core_ext.rb

@@ -0,0 +1,29 @@
+class Hash
+  # Merges self with another hash, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = dup
+
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+
+      target[key] = hash[key]
+    end
+
+    target
+  end
+end
+
+require 'ostruct'
+class ClosedStruct < OpenStruct
+  def method_missing(symbol, *args)
+    raise(NoMethodError, "undefined method `#{symbol}' for #{self}")
+  end
+end