jberkel-jekyll 0.5.4 → 0.5.7

data/lib/jekyll.rb

@@ -26,6 +26,7 @@ require 'jekyll/filters'
 require 'jekyll/tags/highlight'
 require 'jekyll/tags/include'
 require 'jekyll/albino'
+require 'jekyll/static_file'
 
 module Jekyll
   # Default options. Overriden by values in _config.yml or command-line opts.
@@ -68,10 +69,10 @@ module Jekyll
     begin
       config = YAML.load_file(config_file)
       raise "Invalid configuration - #{config_file}" if !config.is_a?(Hash)
-      STDOUT.puts "Configuration from #{config_file}"
+      $stdout.puts "Configuration from #{config_file}"
     rescue => err
-      STDERR.puts "WARNING: Could not read configuration. Using defaults (and options)."
-      STDERR.puts "\t" + err.to_s
+      $stderr.puts "WARNING: Could not read configuration. Using defaults (and options)."
+      $stderr.puts "\t" + err.to_s
       config = {}
     end
 

data/lib/jekyll/convertible.rb

@@ -3,6 +3,10 @@
 #
 # Requires
 #   self.site -> Jekyll::Site
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
 module Jekyll
   module Convertible
     # Return the contents as a string
@@ -20,7 +24,7 @@ module Jekyll
 
       self.data ||= {}
       
-      if self.content =~ /^(---\s*\n.*?\n?)(---.*?\n)/m
+      if self.content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
         self.content = self.content[($1.size + $2.size)..-1]
         self.data = self.data.deep_merge(YAML.load($1) || {})
       end
@@ -52,7 +56,7 @@ module Jekyll
       case self.ext[1..-1]
       when /textile/i
         return 'textile'
-      when /markdown/i, /mkdn/i, /md/i
+      when /markdown/i, /mkdn/i, /md/i, /mkd/i
         return 'markdown'
       when /haml/i
         return 'haml'

data/lib/jekyll/core_ext.rb

@@ -19,6 +19,28 @@ class Hash
 
     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
 
 

data/lib/jekyll/page.rb

@@ -4,7 +4,7 @@ module Jekyll
     include Convertible
 
     attr_accessor :site
-    attr_accessor :name, :ext, :basename
+    attr_accessor :name, :ext, :basename, :dir
     attr_accessor :data, :content, :output
 
     # Initialize a new Page.
@@ -101,6 +101,10 @@ module Jekyll
       end
     end
 
+    def inspect
+      "#<Jekyll:Page @name=#{self.name.inspect}>"
+    end
+
     private
 
       def index?

data/lib/jekyll/pager.rb

@@ -4,7 +4,7 @@ module Jekyll
     
     def self.calculate_pages(all_posts, per_page)
       num_pages = all_posts.size / per_page.to_i
-      num_pages.abs + 1 if all_posts.size % per_page.to_i != 0
+      num_pages = num_pages + 1 if all_posts.size % per_page.to_i != 0
       num_pages
     end
     

data/lib/jekyll/post.rb

@@ -20,12 +20,9 @@ module Jekyll
       name =~ MATCHER
     end
 
-    attr_accessor :site, :date, :slug, :ext, :published, :data, :content, :output, :tags
-    attr_writer :categories
-    
-    def categories
-      @categories ||= []
-    end
+    attr_accessor :site
+    attr_accessor :data, :content, :output, :ext
+    attr_accessor :date, :slug, :published, :tags, :categories
 
     # Initialize this Post instance.
     #   +site+ is the Site
@@ -46,6 +43,13 @@ module Jekyll
       self.read_yaml(@base, name)
 
       extract_title_from_first_header_or_slug
+      #
+      #If we've added a date and time to the yaml, use that instead of the filename date
+      #Means we'll sort correctly.
+      if self.data.has_key?('date')
+        # ensure Time via to_s and reparse
+        self.date = Time.parse(self.data["date"].to_s)
+      end
 
       if self.data.has_key?('published') && self.data['published'] == false
         self.published = false
@@ -53,26 +57,10 @@ module Jekyll
         self.published = true
       end
 
-      if self.data.has_key?("tag")
-        self.tags = [self.data["tag"]]
-      elsif self.data.has_key?("tags")
-        self.tags = self.data['tags']
-      else
-        self.tags = []
-      end
+      self.tags = self.data.pluralized_array("tag", "tags")
 
       if self.categories.empty?
-        if self.data.has_key?('category')
-          self.categories << self.data['category']
-        elsif self.data.has_key?('categories')
-          # Look for categories in the YAML-header, either specified as
-          # an array or a string.
-          if self.data['categories'].kind_of? String
-            self.categories = self.data['categories'].split
-          else
-            self.categories = self.data['categories']
-          end
-        end
+        self.categories = self.data.pluralized_array('category', 'categories')
       end
     end
 
@@ -143,7 +131,7 @@ module Jekyll
         "month"      => date.strftime("%m"),
         "day"        => date.strftime("%d"),
         "title"      => CGI.escape(slug),
-        "categories" => categories.sort.join('/')
+        "categories" => categories.join('/')
       }.inject(template) { |result, token|
         result.gsub(/:#{token.first}/, token.last)
       }.gsub("//", "/")

data/lib/jekyll/site.rb

@@ -1,9 +1,9 @@
 module Jekyll
 
   class Site
-    attr_accessor :config, :layouts, :posts, :categories, :exclude,
+    attr_accessor :config, :layouts, :posts, :pages, :static_files, :categories, :exclude,
                   :source, :dest, :lsi, :pygments, :permalink_style, :tags
-                  
+
     attr_accessor :sass, :post_defaults, :collated_posts
 
 
@@ -14,7 +14,7 @@ module Jekyll
     def initialize(config)
       self.config          = config.clone
 
-      self.source          = config['source']
+      self.source          = File.expand_path(config['source'])
       self.dest            = config['destination']
       self.lsi             = config['lsi']
       self.pygments        = config['pygments']
@@ -30,6 +30,8 @@ module Jekyll
       self.layouts         = {}
       self.posts           = []
       self.collated_posts  = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = [] } } }
+      self.pages           = []
+      self.static_files    = []
       self.categories      = Hash.new { |hash, key| hash[key] = [] }
       self.tags            = Hash.new { |hash, key| hash[key] = [] }
     end
@@ -37,7 +39,7 @@ module Jekyll
     def setup
       # Check to see if LSI is enabled.
       require 'classifier' if self.lsi
-      
+
       if self.config['sass']
         begin
           require 'sass'
@@ -47,7 +49,7 @@ module Jekyll
           puts 'You must have the haml gem installed first'
         end
       end
-      
+
       if self.config['haml']
         begin
           require 'haml'
@@ -55,11 +57,11 @@ module Jekyll
           helpers = File.join(source, '_helpers.rb')
           require helpers if File.exist?(helpers)
           puts 'Enabled Haml'
-        rescue LoadError => e
-          raise "You must have the haml gem installed first: #{e}"
+        rescue LoadError
+          puts 'You must have the haml gem installed first'
         end
       end
-      
+
       # Set the Markdown interpreter (and Maruku self.config, if necessary)
       case self.config['markdown']
         when 'rdiscount'
@@ -114,22 +116,30 @@ module Jekyll
     end
 
     # Do the actual work of processing the site and generating the
-    # real deal.
+    # real deal.  Now has 4 phases; reset, read, render, write.  This allows
+    # rendering to have full site payload available.
     #
     # Returns nothing
     def process
       self.reset
-      self.read_layouts
-      self.transform_pages
+      self.read
+      self.render
+      self.write
       self.transform_sass if self.sass
-      self.write_posts
     end
 
-    # Read all the files in <source>/_layouts into memory for later use.
+    def read
+      self.read_layouts # existing implementation did this at top level only so preserved that
+      self.read_directories
+    end
+
+    # Read all the files in <source>/<dir>/_layouts and create a new Layout
+    # object with each one.
     #
     # Returns nothing
-    def read_layouts
-      base = File.join(self.source, "_layouts")
+    def read_layouts(dir = '')
+      base = File.join(self.source, dir, "_layouts")
+      return unless File.exists?(base)
       entries = []
       Dir.chdir(base) { entries = filter_entries(Dir['*.*']) }
 
@@ -137,17 +147,16 @@ module Jekyll
         name = f.split(".")[0..-2].join(".")
         self.layouts[name] = Layout.new(self, base, f)
       end
-    rescue Errno::ENOENT => e
-      # ignore missing layout dir
     end
 
-    # Read all the files in <base>/_posts and create a new Post object with each one.
+    # Read all the files in <source>/<dir>/_posts and create a new Post
+    # object with each one.
     #
     # Returns nothing
     def read_posts(dir)
       base = File.join(self.source, dir, '_posts')
-      entries = []
-      Dir.chdir(base) { entries = filter_entries(Dir['**/*']) }
+      return unless File.exists?(base)
+      entries = Dir.chdir(base) { filter_entries(Dir['**/*']) }
 
       # first pass processes, but does not yet render post content
       entries.each do |f|
@@ -163,69 +172,69 @@ module Jekyll
       end
 
       self.posts.sort!
+    end
 
-      # second pass renders each post now that full site payload is available
+    def render
       self.posts.each do |post|
         post.render(self.layouts, site_payload)
         self.collated_posts[post.date.year][post.date.month][post.date.day].unshift(post)
       end
 
+      self.pages.dup.each do |page|
+        if Pager.pagination_enabled?(self.config, page.name)
+          paginate(page)
+        else
+          page.render(self.layouts, site_payload)
+        end
+      end
+
       self.categories.values.map { |ps| ps.sort! { |a, b| b <=> a} }
       self.tags.values.map { |ps| ps.sort! { |a, b| b <=> a} }
     rescue Errno::ENOENT => e
       # ignore missing layout dir
     end
 
-    # Write each post to <dest>/<year>/<month>/<day>/<slug>
+    # Write static files, pages and posts
     #
     # Returns nothing
-    def write_posts
+    def write
       self.posts.each do |post|
         post.write(self.dest)
       end
+      self.pages.each do |page|
+        page.write(self.dest)
+      end
+      self.static_files.each do |sf|
+        sf.write(self.dest)
+      end
     end
 
-    # Copy all regular files from <source> to <dest>/ ignoring
-    # any files/directories that are hidden or backup files (start
-    # with "." or "#" or end with "~") or contain site content (start with "_")
-    # unless they are "_posts" directories or web server files such as
-    # '.htaccess'
+    # Reads the directories and finds posts, pages and static files that will
+    # become part of the valid site according to the rules in +filter_entries+.
     #   The +dir+ String is a relative path used to call this method
     #            recursively as it descends through directories
     #
     # Returns nothing
-    def transform_pages(dir = '')
+    def read_directories(dir = '')
       base = File.join(self.source, dir)
       entries = filter_entries(Dir.entries(base))
-      directories = entries.select { |e| File.directory?(File.join(base, e)) }
-      files = entries.reject { |e| File.directory?(File.join(base, e)) || File.symlink?(File.join(base, e)) }
 
-      # we need to make sure to process _posts *first* otherwise they
-      # might not be available yet to other templates as {{ site.posts }}
-      if directories.include?('_posts')
-        directories.delete('_posts')
-        read_posts(dir)
-      end
+      self.read_posts(dir)
 
-      [directories, files].each do |entries|
-        entries.each do |f|
-          if File.directory?(File.join(base, f))
-            next if self.dest.sub(/\/$/, '') == File.join(base, f)
-            transform_pages(File.join(dir, f))
-          elsif Pager.pagination_enabled?(self.config, f)
-            paginate_posts(f, dir)
+      entries.each do |f|
+        f_abs = File.join(base, f)
+        f_rel = File.join(dir, f)
+        if File.directory?(f_abs)
+          next if self.dest.sub(/\/$/, '') == f_abs
+          read_directories(f_rel)
+        elsif !File.symlink?(f_abs)
+          first3 = File.open(f_abs) { |fd| fd.read(3) }
+          if first3 == "---"
+            # file appears to have a YAML header so process it as a page
+            pages << Page.new(self, self.source, dir, f)
           else
-            first3 = File.open(File.join(self.source, dir, f)) { |fd| fd.read(3) }
-            if first3 == "---"
-              # file appears to have a YAML header so process it as a page
-              page = Page.new(self, self.source, dir, f)
-              page.render(self.layouts, site_payload)
-              page.write(self.dest)
-            else
-              # otherwise copy the file without transforming it
-              FileUtils.mkdir_p(File.join(self.dest, dir))
-              FileUtils.cp(File.join(self.source, dir, f), File.join(self.dest, dir, f))
-            end
+            # otherwise treat it as a static file
+            static_files << StaticFile.new(self, self.source, dir, f)
           end
         end
       end
@@ -279,19 +288,21 @@ module Jekyll
     end
 
     # Filter out any files/directories that are hidden or backup files (start
-    # with "." or "#" or end with "~") or contain site content (start with "_")
-    # unless they are "_posts" directories or web server files such as
-    # '.htaccess'
+    # with "." or "#" or end with "~"), or contain site content (start with "_"),
+    # or are excluded in the site configuration, unless they are web server
+    # files such as '.htaccess'
     def filter_entries(entries)
       entries = entries.reject do |e|
-        unless ['_posts', '.htaccess'].include?(e)
+        unless ['.htaccess'].include?(e)
           ['.', '_', '#'].include?(e[0..0]) || e[-1..-1] == '~' || self.exclude.include?(e)
         end
       end
     end
 
-    # Paginates the blog's posts. Renders the index.html file into paginated directories, ie: page2, page3...
-    # and adds more wite-wide data
+    # 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>,
@@ -300,16 +311,19 @@ module Jekyll
     #                   "total_pages" => <Number>,
     #                   "previous_page" => <Number>,
     #                   "next_page" => <Number> }}
-    def paginate_posts(file, dir)
-      all_posts = self.posts.sort { |a,b| b <=> a }
+    def paginate(page)
+      all_posts = site_payload['site']['posts']
       pages = Pager.calculate_pages(all_posts, self.config['paginate'].to_i)
-      pages += 1
       (1..pages).each do |num_page|
         pager = Pager.new(self.config, num_page, all_posts, pages)
-        page = Page.new(self, self.source, dir, file)
-        page.render(self.layouts, site_payload.merge({'paginator' => pager.to_hash}))
-        suffix = "page#{num_page}" if num_page > 1
-        page.write(self.dest, suffix)
+        if num_page > 1
+          newpage = Page.new(self, self.source, page.dir, page.name)
+          newpage.render(self.layouts, site_payload.merge({'paginator' => pager.to_hash}))
+          newpage.dir = File.join(page.dir, "page#{num_page}")
+          self.pages << newpage
+        else
+          page.render(self.layouts, site_payload.merge({'paginator' => pager.to_hash}))
+        end
       end
     end
   end