realityforge-jekyll 0.7.1-java

data/lib/jekyll/converters/markdown.rb

@@ -0,0 +1,80 @@
+module Jekyll
+
+  class MarkdownConverter < Converter
+    safe true
+
+    pygments_prefix "\n"
+    pygments_suffix "\n"
+
+    def setup
+      return if @setup
+      # Set the Markdown interpreter (and Maruku self.config, if necessary)
+      case @config['markdown']
+        when 'rdiscount'
+          begin
+            require 'rdiscount'
+
+            # Load rdiscount extensions
+            @rdiscount_extensions = @config['rdiscount']['extensions'].map { |e| e.to_sym }
+          rescue LoadError
+            STDERR.puts 'You are missing a library required for Markdown. Please run:'
+            STDERR.puts '  $ [sudo] gem install rdiscount'
+            raise FatalException.new("Missing dependency: rdiscount")
+          end
+        when 'maruku'
+          begin
+            require 'maruku'
+
+            if @config['maruku']['use_divs']
+              require 'maruku/ext/div'
+              STDERR.puts 'Maruku: Using extended syntax for div elements.'
+            end
+
+            if @config['maruku']['use_tex']
+              require 'maruku/ext/math'
+              STDERR.puts "Maruku: Using LaTeX extension. Images in `#{@config['maruku']['png_dir']}`."
+
+              # Switch off MathML output
+              MaRuKu::Globals[:html_math_output_mathml] = false
+              MaRuKu::Globals[:html_math_engine] = 'none'
+
+              # Turn on math to PNG support with blahtex
+              # Resulting PNGs stored in `images/latex`
+              MaRuKu::Globals[:html_math_output_png] = true
+              MaRuKu::Globals[:html_png_engine] =  @config['maruku']['png_engine']
+              MaRuKu::Globals[:html_png_dir] = @config['maruku']['png_dir']
+              MaRuKu::Globals[:html_png_url] = @config['maruku']['png_url']
+            end
+          rescue LoadError
+            STDERR.puts 'You are missing a library required for Markdown. Please run:'
+            STDERR.puts '  $ [sudo] gem install maruku'
+            raise FatalException.new("Missing dependency: maruku")
+          end
+        else
+          STDERR.puts "Invalid Markdown processor: #{@config['markdown']}"
+          STDERR.puts "  Valid options are [ maruku | rdiscount ]"
+          raise FatalException.new("Invalid Markdown process: #{@config['markdown']}")
+      end
+      @setup = true
+    end
+
+    def matches(ext)
+      ext =~ /(markdown|mkdn?|md)/i
+    end
+
+    def output_ext(ext)
+      ".html"
+    end
+
+    def convert(content)
+      setup
+      case @config['markdown']
+        when 'rdiscount'
+          RDiscount.new(content, *@rdiscount_extensions).to_html
+        when 'maruku'
+          Maruku.new(content).to_html
+      end
+    end
+  end
+
+end

data/lib/jekyll/converters/textile.rb

@@ -0,0 +1,33 @@
+module Jekyll
+
+  class TextileConverter < Converter
+    safe true
+
+    pygments_prefix '<notextile>'
+    pygments_suffix '</notextile>'
+
+    def setup
+      return if @setup
+      require 'redcloth'
+      @setup = true
+    rescue LoadError
+      STDERR.puts 'You are missing a library required for Textile. Please run:'
+      STDERR.puts '  $ [sudo] gem install RedCloth'
+      raise FatalException.new("Missing dependency: RedCloth")
+    end
+
+    def matches(ext)
+      ext =~ /textile/i
+    end
+
+    def output_ext(ext)
+      ".html"
+    end
+
+    def convert(content)
+      setup
+      RedCloth.new(content).to_html
+    end
+  end
+
+end

data/lib/jekyll/convertible.rb

@@ -0,0 +1,82 @@
+# Convertible provides methods for converting a pagelike item
+# from a certain type of markup into actual content
+#
+# Requires
+#   self.site -> Jekyll::Site
+#   self.content
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
+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 + $2.size)..-1]
+
+        self.data = YAML.load($1)
+      end
+
+      self.data ||= {}
+    end
+
+    # Transform the contents based on the content type.
+    #
+    # Returns nothing
+    def transform
+      self.content = converter.convert(self.content)
+    end
+
+    # Determine the extension depending on content_type
+    #
+    # Returns the extensions for the output file
+    def output_ext
+      converter.output_ext(self.ext)
+    end
+
+    # Determine which converter to use based on this convertible's
+    # extension
+    def converter
+      @converter ||= self.site.converters.find { |c| c.matches(self.ext) }
+    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["pygments_prefix"] = converter.pygments_prefix
+      payload["pygments_suffix"] = converter.pygments_suffix
+      self.content = Liquid::Template.parse(self.content).render(payload, info)
+      self.transform
+
+      # 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})
+        self.output = Liquid::Template.parse(layout.content).render(payload, info)
+
+        layout = layouts[layout.data["layout"]]
+      end
+    end
+  end
+end

data/lib/jekyll/core_ext.rb

@@ -0,0 +1,52 @@
+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
+
+  # Read array from the supplied hash favouring the singular key
+  # and then the plural key, and handling any nil entries.
+  #   +hash+ the hash to read from
+  #   +singular_key+ the singular key
+  #   +plural_key+ the singular key
+  #
+  # Returns an array
+  def pluralized_array(singular_key, plural_key)
+    hash = self
+    if hash.has_key?(singular_key)
+      array = [hash[singular_key]] if hash[singular_key]
+    elsif hash.has_key?(plural_key)
+      case hash[plural_key]
+      when String
+        array = hash[plural_key].split
+      when Array
+        array = hash[plural_key].compact
+      end
+    end
+    array || []
+  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

data/lib/jekyll/errors.rb

@@ -0,0 +1,6 @@
+module Jekyll
+
+  class FatalException < StandardError
+  end
+
+end

data/lib/jekyll/filters.rb

@@ -0,0 +1,47 @@
+module Jekyll
+
+  module Filters
+    def textilize(input)
+      TextileConverter.new.convert(input)
+    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 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/generator.rb

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

data/lib/jekyll/generators/pagination.rb

@@ -0,0 +1,87 @@
+module Jekyll
+
+  class Pagination < Generator
+    safe true
+
+    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, ie: page2/index.html, page3/index.html, etc and adds more
+    # site-wide data.
+    #   +page+ is 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
+
+    def self.calculate_pages(all_posts, per_page)
+      num_pages = all_posts.size / per_page.to_i
+      num_pages = num_pages + 1 if all_posts.size % per_page.to_i != 0
+      num_pages
+    end
+
+    def self.pagination_enabled?(config, file)
+      file == 'index.html' && !config['paginate'].nil?
+    end
+
+    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
+
+    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,36 @@
+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)
+    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/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