jekyll-reloaded 0.12

data/lib/jekyll/filters.rb

@@ -0,0 +1,118 @@
+require 'uri'
+
+module Jekyll
+
+  module Filters
+    # Convert a Textile string into HTML output.
+    #
+    # input - The Textile String to convert.
+    #
+    # Returns the HTML formatted String.
+    def textilize(input)
+      site = @context.registers[:site]
+      converter = site.getConverterImpl(Jekyll::TextileConverter)
+      converter.convert(input)
+    end
+
+    # Convert a Markdown string into HTML output.
+    #
+    # input - The Markdown String to convert.
+    #
+    # Returns the HTML formatted String.
+    def markdownify(input)
+      site = @context.registers[:site]
+      converter = site.getConverterImpl(Jekyll::MarkdownConverter)
+      converter.convert(input)
+    end
+
+    # Format a date in short format e.g. "27 Jan 2011".
+    #
+    # date - the Time to format.
+    #
+    # Returns the formatting String.
+    def date_to_string(date)
+      date.strftime("%d %b %Y")
+    end
+
+    # Format a date in long format e.g. "27 January 2011".
+    #
+    # date - The Time to format.
+    #
+    # Returns the formatted String.
+    def date_to_long_string(date)
+      date.strftime("%d %B %Y")
+    end
+
+    # Format a date for use in XML.
+    #
+    # date - The Time to format.
+    #
+    # Examples
+    #
+    #   date_to_xmlschema(Time.now)
+    #   # => "2011-04-24T20:34:46+08:00"
+    #
+    # Returns the formatted String.
+    def date_to_xmlschema(date)
+      date.xmlschema
+    end
+
+    def xml_escape(input)
+      CGI.escapeHTML(input)
+    end
+
+    # CGI escape a string for use in a URL. Replaces any special characters
+    # with appropriate %XX replacements.
+    #
+    # input - The String to escape.
+    #
+    # Examples
+    #
+    #   cgi_escape('foo,bar;baz?')
+    #   # => "foo%2Cbar%3Bbaz%3F"
+    #
+    # Returns the escaped String.
+    def cgi_escape(input)
+      CGI::escape(input)
+    end
+
+    def uri_escape(input)
+      URI.escape(input)
+    end
+
+    # Count the number of words in the input string.
+    #
+    # input - The String on which to operate.
+    #
+    # Returns the Integer word count.
+    def number_of_words(input)
+      input.split.length
+    end
+
+    # Join an array of things into a string by separating with commes and the
+    # word "and" for the last one.
+    #
+    # array - The Array of Strings to join.
+    #
+    # Examples
+    #
+    #   array_to_sentence_string(["apples", "oranges", "grapes"])
+    #   # => "apples, oranges, and grapes"
+    #
+    # Returns the formatted String.
+    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/generator.rb

@@ -0,0 +1,7 @@
+module Jekyll
+
+  class Generator < Plugin
+
+  end
+
+end

data/lib/jekyll/generators/pagination.rb

@@ -0,0 +1,113 @@
+module Jekyll
+
+  class Pagination < Generator
+    # This generator is safe from arbitrary code execution.
+    safe true
+
+    # Generate paginated pages if necessary.
+    #
+    # site - The Site.
+    #
+    # Returns nothing.
+    def generate(site)
+      site.pages.dup.each do |page|
+        paginate(site, page) if Pager.pagination_enabled?(site.config, page.name)
+      end
+    end
+
+    # Paginates the blog's posts. Renders the index.html file into paginated
+    # directories, e.g.: page2/index.html, page3/index.html, etc and adds more
+    # site-wide data.
+    #
+    # site - The Site.
+    # page - The index.html Page that requires pagination.
+    #
+    # {"paginator" => { "page" => <Number>,
+    #                   "per_page" => <Number>,
+    #                   "posts" => [<Post>],
+    #                   "total_posts" => <Number>,
+    #                   "total_pages" => <Number>,
+    #                   "previous_page" => <Number>,
+    #                   "next_page" => <Number> }}
+    def paginate(site, page)
+      all_posts = site.site_payload['site']['posts']
+      pages = Pager.calculate_pages(all_posts, site.config['paginate'].to_i)
+      (1..pages).each do |num_page|
+        pager = Pager.new(site.config, num_page, all_posts, pages)
+        if num_page > 1
+          newpage = Page.new(site, site.source, page.dir, page.name)
+          newpage.pager = pager
+          newpage.dir = File.join(page.dir, "page#{num_page}")
+          site.pages << newpage
+        else
+          page.pager = pager
+        end
+      end
+    end
+  end
+
+  class Pager
+    attr_reader :page, :per_page, :posts, :total_posts, :total_pages, :previous_page, :next_page
+
+    # Calculate the number of pages.
+    #
+    # all_posts - The Array of all Posts.
+    # per_page  - The Integer of entries per page.
+    #
+    # Returns the Integer number of pages.
+    def self.calculate_pages(all_posts, per_page)
+      (all_posts.size.to_f / per_page.to_i).ceil
+    end
+
+    # Determine if pagination is enabled for a given file.
+    #
+    # config - The configuration Hash.
+    # file   - The String filename of the file.
+    #
+    # Returns true if pagination is enabled, false otherwise.
+    def self.pagination_enabled?(config, file)
+      file == 'index.html' && !config['paginate'].nil?
+    end
+
+    # Initialize a new Pager.
+    #
+    # config    - The Hash configuration of the site.
+    # page      - The Integer page number.
+    # all_posts - The Array of all the site's Posts.
+    # num_pages - The Integer number of pages or nil if you'd like the number
+    #             of pages calculated.
+    def initialize(config, page, all_posts, num_pages = nil)
+      @page = page
+      @per_page = config['paginate'].to_i
+      @total_pages = num_pages || Pager.calculate_pages(all_posts, @per_page)
+
+      if @page > @total_pages
+        raise RuntimeError, "page number can't be greater than total pages: #{@page} > #{@total_pages}"
+      end
+
+      init = (@page - 1) * @per_page
+      offset = (init + @per_page - 1) >= all_posts.size ? all_posts.size : (init + @per_page - 1)
+
+      @total_posts = all_posts.size
+      @posts = all_posts[init..offset]
+      @previous_page = @page != 1 ? @page - 1 : nil
+      @next_page = @page != @total_pages ? @page + 1 : nil
+    end
+
+    # Convert this Pager's data to a Hash suitable for use by Liquid.
+    #
+    # Returns the Hash representation of this Pager.
+    def to_liquid
+      {
+        'page' => page,
+        'per_page' => per_page,
+        'posts' => posts,
+        'total_posts' => total_posts,
+        'total_pages' => total_pages,
+        'previous_page' => previous_page,
+        'next_page' => next_page
+      }
+    end
+  end
+
+end

data/lib/jekyll/layout.rb

@@ -0,0 +1,51 @@
+module Jekyll
+
+  class Layout
+    include Convertible
+
+    # Gets the Site object.
+    attr_reader :site
+
+    # Gets/Sets the extension of this layout.
+    attr_accessor :ext
+
+    # Gets/Sets the Hash that holds the metadata for this layout.
+    attr_accessor :data
+
+    # Gets/Sets the content of this layout.
+    attr_accessor :content
+
+    # Initialize a new Layout.
+    #
+    # site - The Site.
+    # base - The String path to the source.
+    # name - The String filename of the post file.
+    def initialize(site, base, name)
+      @site = site
+      @base = base
+      @name = name
+
+      self.process(name)
+      self.read_yaml(base, name)
+    end
+
+    # The source filename for this layout.
+    def filename
+      File.join(@base, @name)
+    end
+
+    def inspect
+      "<Layout: @name=#{@name.inspect}>"
+    end
+
+    # Extract information from the layout filename.
+    #
+    # name - The String filename of the layout file.
+    #
+    # Returns nothing.
+    def process(name)
+      self.ext = File.extname(name)
+    end
+  end
+
+end

data/lib/jekyll/live_site.rb

@@ -0,0 +1,216 @@
+require 'jekyll'
+require 'jekyll/site'
+
+module Jekyll
+
+class LiveSite < Site
+  def process_files files
+    pages = []
+    Array(files).each do |filename|
+      resolve_file(filename) { |page| pages << page }
+    end
+
+    return false if pages.empty?
+
+    payload = nil
+
+    for page in pages
+      if page.respond_to? :render
+        payload ||= self.site_payload
+        page.read_yaml('', page.filename)
+        # TODO: remove post if stopped being published?
+        page.render(self.layouts, payload)
+      end
+
+      if page.write(self.dest)
+        yield page.destination(self.dest)
+      end
+    end
+  end
+
+  def resolve_file filename
+    path = File.expand_path filename, self.source
+    file = ContentFile.new path, self.source, self.dest, self.method(:allow_file?)
+    unless file.valid?
+      warn "invalid file: #{file.path}"
+      return
+    end
+
+    case file.type
+    when :post
+      page = self.posts.find { |p| p.filename == file.path }
+      page ||= create_post(file.relative_dir, file.name)
+      yield page
+    when :layout
+      if pair = self.layouts.find { |_, p| p.filename == file.path }
+        layout_name = pair[0]
+      else
+        layout_name = file.name.sub(/\.[^.]+$/, '')
+        self.layouts[layout_name] = Layout.new(self, file.dir, file.name)
+      end
+      [self.posts, self.pages].each do |group|
+        group.each { |p| yield p if using_layout?(layout_name, p) }
+      end
+    when :file
+      page = nil
+      [self.pages, self.static_files].each do |group|
+        if page = group.find { |p| p.filename == file.path }
+          break
+        end
+      end
+
+      page ||= if has_yaml_header? file.path
+                 new_page = Page.new(self, self.source, file.dir, file.name)
+                 self.pages << new_page
+                 new_page
+               else
+                 new_file = StaticFile.new(self, self.source, file.dir, file.name)
+                 self.static_files << new_file
+                 new_file
+               end
+
+      yield page
+    else
+      raise "unknown file type: #{file.type}"
+    end
+  rescue InvalidPost => e
+    warn e.message
+  end
+
+  class ContentFile
+    attr_reader :path, :dir, :name
+    alias to_s path
+
+    TYPE_MAPPING = {
+      '_layouts'  => :layout,
+      '_includes' => :include,
+      '_posts'    => :post
+    }
+
+    def initialize path, source, dest, allowed_checker = nil
+      @path = path
+      @source = source
+      @destination = dest
+      @allowed_checker = allowed_checker || lambda {|f| true }
+      @dir, @name = File.split @path
+      @type = :file
+      @valid_dir = nil
+    end
+
+    def type
+      deep_check
+      @type
+    end
+
+    def relative_dir
+      @relative_dir ||= self.dir.sub(File.join(@source, ''), '')
+    end
+
+    def valid?
+      !File.symlink? path and
+        @allowed_checker.call(name) and
+          deep_check
+    end
+
+    def deep_check
+      return @valid_dir unless @valid_dir.nil?
+      @valid_dir = valid_dir? self.dir
+    end
+
+    def valid_dir? path
+      if path == '/'
+        false
+      elsif path == @destination
+        false
+      elsif path == @source
+        true
+      elsif File.symlink? path
+        false
+      else
+        dir, name = File.split path
+        if type = TYPE_MAPPING[name]
+          @type = type
+        elsif !@allowed_checker.call(name)
+          return false
+        end
+        valid_dir? dir
+      end
+    end
+  end
+
+  class InvalidPost < StandardError; end
+
+  def create_post dir, name
+    path = File.join dir, name
+    # TODO: hack
+    dir, name = path.split('/_posts/', 2)
+
+    if Post.valid? name
+      post = Post.new(self, self.source, dir, name)
+
+      if publish_post? post
+        self.posts << post
+        post.categories.each { |c| self.categories[c] << post }
+        post.tags.each { |c| self.tags[c] << post }
+        post
+      else
+        raise InvalidPost, "post not publishable: #{post.inspect}"
+      end
+    else
+      raise InvalidPost, "not a valid post: #{name.inspect}"
+    end
+  end
+
+  def publish_post? post
+    post.published && (self.future || post.date <= self.time)
+  end
+
+  def using_layout? name, page, seen = nil
+    if using = page.data['layout'] and (seen.nil? or !seen.include?(using))
+      using == name or using_layout?(name, self.layouts[using], (seen || []) << using)
+    end
+  end
+
+  def has_yaml_header? file
+    '---' == File.open(file) { |fd| fd.read(3) }
+  end
+
+  FILTER_PREFIXES = %w[ . _ # ]
+  FILTER_SUFFIXES = %w[ ~ ]
+
+  # Filter out any files/directories that are hidden or backup files (start
+  # with ".", "_", or "#", or end with "~"), or are excluded by the site
+  # configuration, unless they are whitelisted by the site configuration.
+  #
+  # To be able to check symlinks, this method expects to be run from the
+  # directory where entries originate.
+  #
+  # entries - The Array of file/directory entries to filter.
+  #
+  # Returns the Array of filtered entries.
+  def filter_entries(entries)
+    entries.select { |entry|
+      allow_file? entry and !File.symlink? entry
+    }
+  end
+
+  def allow_file? entry
+    whitelisted_file? entry or
+      (allow_file_name? entry and !blacklisted_file? entry)
+  end
+
+  def allow_file_name? entry
+    !(FILTER_PREFIXES.include? entry[0,1] or
+      FILTER_SUFFIXES.include? entry[-1,1])
+  end
+
+  def whitelisted_file? entry
+    self.include.include? entry
+  end
+
+  def blacklisted_file? entry
+    self.exclude.include? entry
+  end
+end
+
+end

data/lib/jekyll/migrators/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/migrators/drupal.rb

@@ -0,0 +1,103 @@
+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 Drupal
+    # 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 n.nid, \
+                    n.title, \
+                    nr.body, \
+                    n.created, \
+                    n.status \
+             FROM node AS n, \
+                  node_revisions AS nr \
+             WHERE (n.type = 'blog' OR n.type = 'story') \
+             AND n.vid = nr.vid"
+
+    def self.process(dbname, user, pass, host = 'localhost', prefix = '')
+      db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host, :encoding => 'utf8')
+
+      if prefix != ''
+        QUERY[" node "] = " " + prefix + "node "
+        QUERY[" node_revisions "] = " " + prefix + "node_revisions "
+      end
+
+      FileUtils.mkdir_p "_posts"
+      FileUtils.mkdir_p "_drafts"
+
+      # Create the refresh layout
+      # Change the refresh url if you customized your permalink config
+      File.open("_layouts/refresh.html", "w") do |f|
+        f.puts <<EOF
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" />
+<meta http-equiv="refresh" content="0;url={{ page.refresh_to_post_id }}.html" />
+</head>
+</html>
+EOF
+      end
+
+      db[QUERY].each do |post|
+        # Get required fields and construct Jekyll compatible name
+        node_id = post[:nid]
+        title = post[:title]
+        content = post[:body]
+        created = post[:created]
+        time = Time.at(created)
+        is_published = post[:status] == 1
+        dir = is_published ? "_posts" : "_drafts"
+        slug = title.strip.downcase.gsub(/(&|&amp;)/, ' and ').gsub(/[\s\.\/\\]/, '-').gsub(/[^\w-]/, '').gsub(/[-_]{2,}/, '-').gsub(/^[-_]/, '').gsub(/[-_]$/, '')
+        name = time.strftime("%Y-%m-%d-") + slug + '.md'
+
+        # Get the relevant fields as a hash, delete empty fields and convert
+        # to YAML for the header
+        data = {
+           'layout' => 'post',
+           'title' => title.to_s,
+           'created' => created,
+         }.delete_if { |k,v| v.nil? || v == ''}.to_yaml
+
+        # Write out the data and content to file
+        File.open("#{dir}/#{name}", "w") do |f|
+          f.puts data
+          f.puts "---"
+          f.puts content
+        end
+
+        # Make a file to redirect from the old Drupal URL
+        if is_published
+          aliases = db["SELECT dst FROM #{prefix}url_alias WHERE src = ?", "node/#{node_id}"].all
+
+          aliases.push(:dst => "node/#{node_id}")
+
+          aliases.each do |url_alias|
+            FileUtils.mkdir_p url_alias[:dst]
+            File.open("#{url_alias[:dst]}/index.md", "w") do |f|
+              f.puts "---"
+              f.puts "layout: refresh"
+              f.puts "refresh_to_post_id: /#{time.strftime("%Y/%m/%d/") + slug}"
+              f.puts "---"
+            end
+          end
+        end
+      end
+
+      # TODO: Make dirs & files for nodes of type 'page'
+        # Make refresh pages for these as well
+
+      # TODO: Make refresh dirs & files according to entries in url_alias table
+    end
+  end
+end

data/lib/jekyll/migrators/enki.rb

@@ -0,0 +1,49 @@
+# Adapted by Rodrigo Pinto <rodrigopqn@gmail.com>
+# Based on typo.rb by Toby DiPasquale
+
+require 'fileutils'
+require 'rubygems'
+require 'sequel'
+
+module Jekyll
+  module Enki
+    SQL = <<-EOS
+      SELECT p.id,
+             p.title,
+             p.slug,
+             p.body,
+             p.published_at as date,
+             p.cached_tag_list as tags
+      FROM posts p
+    EOS
+
+    # Just working with postgres, but can be easily adapted
+    # to work with both mysql and postgres.
+    def self.process(dbname, user, pass, host = 'localhost')
+      FileUtils.mkdir_p('_posts')
+      db = Sequel.postgres(:database => dbname,
+                           :user => user,
+                           :password => pass,
+                           :host => host,
+                           :encoding => 'utf8')
+
+      db[SQL].each do |post|
+        name = [ sprintf("%.04d", post[:date].year),
+                 sprintf("%.02d", post[:date].month),
+                 sprintf("%.02d", post[:date].day),
+                 post[:slug].strip ].join('-')
+        name += '.textile'
+
+        File.open("_posts/#{name}", 'w') do |f|
+          f.puts({ 'layout'   => 'post',
+                   'title'    => post[:title].to_s,
+                   'enki_id'  => post[:id],
+                   'categories'  => post[:tags]
+                 }.delete_if { |k, v| v.nil? || v == '' }.to_yaml)
+          f.puts '---'
+          f.puts post[:body].delete("\r")
+        end
+      end
+    end
+  end
+end