lonnon-jekyll 0.6.0

data/lib/jekyll/converters/wordpress.rb

@@ -0,0 +1,61 @@
+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, ID, guid from wp_posts where post_status = 'publish' and post_type = 'post'"
+
+    def self.process(dbname, user, pass, host = 'localhost', format = 'markdown')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host)
+
+      FileUtils.mkdir_p "_posts"
+
+      db[:wp_posts].where(:post_status => 'publish',
+                          :post_type => 'post').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]
+        excerpt = post[:post_excerpt]
+        name = "%02d-%02d-%02d-%s.#{format}" % [date.year, date.month,
+                                                date.day, slug]
+        
+        tags = db[:wp_terms].join(:wp_term_taxonomy, :term_id => :term_id).join(:wp_term_relationships, :term_taxonomy_id => :term_taxonomy_id).where(:object_id => post[:ID], :taxonomy => 'post_tag').map(:name).join(' ').split
+        
+        # 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' => tags,
+           'excerpt' => excerpt,
+           'wordpress_id' => post[:ID],
+           'wordpress_url' => post[:guid]
+        }.delete_if { |k,v| v.nil? ||
+                            v == '' ||
+                            v =~ /\A[[:space:]]+\z/}.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,139 @@
+# 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?)(---.*?\n)/m
+        self.content = self.content[($1.size + $2.size)..-1]
+        self.data = YAML.load($1)
+      end
+      self.data ||= {}
+
+      if self.is_a? Jekyll::Post
+        divider = /<!--\s*[Mm][Oo][Rr][Ee]\s*-->\s*\n/
+        if self.content =~ divider
+          self.data['excerpt'], self.data['remainder'] = self.content.split($&, 2)
+          self.content = self.data['excerpt'] +
+                         "\n" + '<div id="more"></div>' + "\n" +
+                         self.data['remainder']
+        end
+      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)
+        if self.is_a? Jekyll::Post and self.data['excerpt']
+          self.data['excerpt'] = self.site.textile(self.data['excerpt'])
+          self.data['remainder'] = self.site.textile(self.data['remainder'])
+        end
+      when 'markdown'
+        self.ext = ".html"
+        self.content = self.site.markdown(self.content)
+        if self.is_a? Jekyll::Post and self.data['excerpt']
+          self.data['excerpt'] = self.site.markdown(self.data['excerpt'])
+          self.data['remainder'] = self.site.markdown(self.data['remainder'])
+        end
+      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, :haml, 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
+      if self.is_a? Jekyll::Post
+        payload["page"].merge!({"content" => self.content,
+                                "excerpt" => self.data['excerpt'],
+                                "remainder" => self.data['remainder']})
+      end
+
+      # 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 => ClosedStruct.new(payload["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,37 @@
+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
+
+# Thanks, ActiveSupport!
+class Date
+  # Converts datetime to an appropriate format for use in XML
+  def xmlschema
+    strftime("%Y-%m-%dT%H:%M:%S%Z")
+  end if RUBY_VERSION < '1.9'
+end
+
+require 'ostruct'
+class ClosedStruct < OpenStruct
+  def method_missing(symbol, *args)
+    raise(NoMethodError, "undefined method `#{symbol}' for #{self}")
+  end
+end

data/lib/jekyll/filters.rb

@@ -0,0 +1,56 @@
+module Jekyll
+
+  module Filters
+    def textilize(input)
+      RedCloth.new(input).to_html
+    end
+    
+    def markdownize(input)
+      require 'rdiscount'
+      RDiscount.new(input).to_html
+    end
+
+    def date_to_string(date)
+      date.strftime("%d %b %Y")
+    end
+
+    def date_to_long_string(date)
+      date.strftime("%d %B %Y")
+    end
+
+    def date_to_xmlschema(date)
+      date.xmlschema
+    end
+
+    def date_to_utc(date)
+      date.utc
+    end
+
+    def xml_escape(input)
+      CGI.escapeHTML(input)
+    end
+
+    def cgi_escape(input)
+      CGI::escape(input)
+    end
+
+    def number_of_words(input)
+      input.split.length
+    end
+
+    def array_to_sentence_string(array)
+      connector = "and"
+      case array.length
+      when 0
+        ""
+      when 1
+        array[0].to_s
+      when 2
+        "#{array[0]} #{connector} #{array[1]}"
+      else
+        "#{array[0...-1].join(', ')}, #{connector} #{array[-1]}"
+      end
+    end
+
+  end
+end

data/lib/jekyll/haml_helpers.rb

@@ -0,0 +1,15 @@
+require 'cgi'
+
+module Jekyll
+  module HamlHelpers
+    
+    def h(text)
+      CGI.escapeHTML(text)
+    end
+    
+    def link_to(text, url)
+      %{<a href="#{h url}">#{text}</a>}
+    end
+    
+  end
+end

data/lib/jekyll/layout.rb

@@ -0,0 +1,37 @@
+module Jekyll
+
+  class Layout
+    include Convertible
+
+    attr_accessor :site
+    attr_accessor :ext
+    attr_accessor :data, :content
+
+    # Initialize a new Layout.
+    #   +site+ is the Site
+    #   +base+ is the String path to the <source>
+    #   +name+ is the String filename of the post file
+    #
+    # Returns <Page>
+    def initialize(site, base, name)
+      @site = site
+      @base = base
+      @name = name
+
+      self.data = {}
+
+      self.process(name)
+      self.read_yaml(base, name)
+      self.transform
+    end
+
+    # Extract information from the layout filename
+    #   +name+ is the String filename of the layout file
+    #
+    # Returns nothing
+    def process(name)
+      self.ext = File.extname(name)
+    end
+  end
+
+end

data/lib/jekyll/page.rb

@@ -0,0 +1,112 @@
+module Jekyll
+
+  class Page
+    include Convertible
+
+    attr_accessor :site
+    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>
+    def initialize(site, base, dir, name)
+      @site = site
+      @base = base
+      @dir  = dir
+      @name = name
+
+      self.process(name)
+      self.read_yaml(File.join(base, dir), 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, set to '/'
+    #
+    # Returns <String>
+    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)
+    #
+    # Returns <String>
+    def permalink
+      self.data && self.data['permalink']
+    end
+
+    def template
+      if self.site.permalink_style == :pretty && !index?
+        "/:name/"
+      else
+        "/:name.html"
+      end
+    end
+
+    # The generated relative url of this page
+    # e.g. /about.html
+    #
+    # Returns <String>
+    def url
+      return permalink if permalink
+
+      @url ||= (ext == '.html') ? template.gsub(':name', basename) : "/#{name}"
+    end
+
+    # Extract information from the page filename
+    #   +name+ is the String filename of the page file
+    #
+    # Returns nothing
+    def process(name)
+      self.ext = File.extname(name)
+      self.basename = name.split('.')[0..-2].first
+    end
+
+    # Add any necessary layouts to this post
+    #   +layouts+ is a Hash of {"name" => "layout"}
+    #   +site_payload+ is the site payload hash
+    #
+    # Returns nothing
+    def render(layouts, site_payload)
+      payload = {"page" => self.data}.deep_merge(site_payload)
+      do_layout(payload, layouts)
+    end
+
+    # Write the generated page file to the destination directory.
+    #   +dest_prefix+ is the String path to the destination dir
+    #   +dest_suffix+ is a suffix path to the destination dir
+    #
+    # Returns nothing
+    def write(dest_prefix, dest_suffix = nil)
+      dest = File.join(dest_prefix, @dir)
+      dest = File.join(dest, dest_suffix) if dest_suffix
+      FileUtils.mkdir_p(dest)
+
+      # The url needs to be unescaped in order to preserve the correct filename
+      path = File.join(dest, CGI.unescape(self.url))
+      if self.ext == '.html' && self.url[/\.html$/].nil?
+        FileUtils.mkdir_p(path)
+        path = File.join(path, "index.html")
+      end
+
+      File.open(path, 'w') do |f|
+        f.write(self.output)
+      end
+    end
+
+    private
+
+      def index?
+        basename == 'index'
+      end
+
+  end
+
+end