fagiani-jekyll 0.10.1

data/lib/jekyll/site.rb

@@ -0,0 +1,273 @@
+module Jekyll
+
+  class Site
+    attr_accessor :config, :layouts, :posts, :pages, :static_files,
+                  :categories, :exclude, :source, :dest, :lsi, :pygments,
+                  :permalink_style, :tags, :time, :future, :safe, :plugins, :limit_posts
+
+    attr_accessor :converters, :generators
+
+    # Initialize the site
+    #   +config+ is a Hash containing site configurations details
+    #
+    # Returns <Site>
+    def initialize(config)
+      self.config          = config.clone
+
+      self.safe            = config['safe']
+      self.source          = File.expand_path(config['source'])
+      self.dest            = File.expand_path(config['destination'])
+      self.plugins         = File.expand_path(config['plugins'])
+      self.lsi             = config['lsi']
+      self.pygments        = config['pygments']
+      self.permalink_style = config['permalink'].to_sym
+      self.exclude         = config['exclude'] || []
+      self.future          = config['future']
+      self.limit_posts     = config['limit_posts'] || nil
+
+      self.reset
+      self.setup
+    end
+
+    def reset
+      self.time            = if self.config['time']
+                               Time.parse(self.config['time'].to_s)
+                             else
+                               Time.now
+                             end
+      self.layouts         = {}
+      self.posts           = []
+      self.pages           = []
+      self.static_files    = []
+      self.categories      = Hash.new { |hash, key| hash[key] = [] }
+      self.tags            = Hash.new { |hash, key| hash[key] = [] }
+
+      raise ArgumentError, "Limit posts must be nil or >= 1" if !self.limit_posts.nil? && self.limit_posts < 1
+    end
+
+    def setup
+      require 'classifier' if self.lsi
+
+      # If safe mode is off, load in any ruby files under the plugins
+      # directory.
+      unless self.safe
+        Dir[File.join(self.plugins, "**/*.rb")].each do |f|
+          require f
+        end
+      end
+
+      self.converters = Jekyll::Converter.subclasses.select do |c|
+        !self.safe || c.safe
+      end.map do |c|
+        c.new(self.config)
+      end
+
+      self.generators = Jekyll::Generator.subclasses.select do |c|
+        !self.safe || c.safe
+      end.map do |c|
+        c.new(self.config)
+      end
+    end
+
+    # Do the actual work of processing the site and generating the
+    # real deal.  5 phases; reset, read, generate, render, write.  This allows
+    # rendering to have full site payload available.
+    #
+    # Returns nothing
+    def process
+      self.reset
+      self.read
+      self.generate
+      self.render
+      self.cleanup
+      self.write
+    end
+
+    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(dir = '')
+      base = File.join(self.source, dir, "_layouts")
+      return unless File.exists?(base)
+      entries = []
+      Dir.chdir(base) { entries = filter_entries(Dir['*.*']) }
+
+      entries.each do |f|
+        name = f.split(".")[0..-2].join(".")
+        self.layouts[name] = Layout.new(self, base, f)
+      end
+    end
+
+    # 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')
+      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|
+        if Post.valid?(f)
+          post = Post.new(self, self.source, dir, f)
+
+          if post.published && (self.future || post.date <= self.time)
+            self.posts << post
+            post.categories.each { |c| self.categories[c] << post }
+            post.tags.each { |c| self.tags[c] << post }
+          end
+        end
+      end
+
+      self.posts.sort!
+
+      # limit the posts if :limit_posts option is set
+      self.posts = self.posts[-limit_posts, limit_posts] if limit_posts
+    end
+
+    def generate
+      self.generators.each do |generator|
+        generator.generate(self)
+      end
+    end
+
+    def render
+      self.posts.each do |post|
+        post.render(self.layouts, site_payload)
+      end
+
+      self.pages.each do |page|
+        page.render(self.layouts, site_payload)
+      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
+    
+    # Remove orphaned files and empty directories in destination
+    #
+    # Returns nothing
+    def cleanup
+      # all files and directories in destination, including hidden ones
+      dest_files = []
+      Dir.glob(File.join(self.dest, "**", "*"), File::FNM_DOTMATCH) do |file|
+        dest_files << file unless file =~ /\/\.{1,2}$/
+      end
+
+      # files to be written
+      files = []
+      self.posts.each do |post|
+        files << post.destination(self.dest)
+      end
+      self.pages.each do |page|
+        files << page.destination(self.dest)
+      end
+      self.static_files.each do |sf|
+        files << sf.destination(self.dest)
+      end
+      
+      # adding files' parent directories
+      files.each { |file| files << File.dirname(file) unless files.include? File.dirname(file) }
+      
+      obsolete_files = dest_files - files
+      
+      FileUtils.rm_rf(obsolete_files)
+    end
+
+    # Write static files, pages and posts
+    #
+    # Returns nothing
+    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
+
+    # 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 read_directories(dir = '')
+      base = File.join(self.source, dir)
+      entries = filter_entries(Dir.entries(base))
+
+      self.read_posts(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
+            # otherwise treat it as a static file
+            static_files << StaticFile.new(self, self.source, dir, f)
+          end
+        end
+      end
+    end
+
+    # Constructs a hash map of Posts indexed by the specified Post attribute
+    #
+    # Returns {post_attr => [<Post>]}
+    def post_attr_hash(post_attr)
+      # Build a hash map based on the specified post attribute ( post attr => array of posts )
+      # then sort each array in reverse order
+      hash = Hash.new { |hash, key| hash[key] = Array.new }
+      self.posts.each { |p| p.send(post_attr.to_sym).each { |t| hash[t] << p } }
+      hash.values.map { |sortme| sortme.sort! { |a, b| b <=> a} }
+      return hash
+    end
+
+    # The Hash payload containing site-wide data
+    #
+    # Returns {"site" => {"time" => <Time>,
+    #                     "posts" => [<Post>],
+    #                     "pages" => [<Page>],
+    #                     "categories" => [<Post>]}
+    def site_payload
+      {"site" => self.config.merge({
+          "time"       => self.time,
+          "posts"      => self.posts.sort { |a,b| b <=> a },
+          "pages"      => self.pages,
+          "html_pages" => self.pages.reject { |page| !page.html? },
+          "categories" => post_attr_hash('categories'),
+          "tags"       => post_attr_hash('tags')})}
+    end
+
+    # Filter out any files/directories that are hidden or backup files (start
+    # 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 ['.htaccess'].include?(e)
+          ['.', '_', '#'].include?(e[0..0]) || e[-1..-1] == '~' || self.exclude.include?(e)
+        end
+      end
+    end
+
+  end
+end

data/lib/jekyll/static_file.rb

@@ -0,0 +1,75 @@
+module Jekyll
+
+  class StaticFile
+    @@mtimes = Hash.new # the cache of last modification times [path] -> mtime
+
+    # Initialize a new StaticFile.
+    #   +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 <StaticFile>
+    def initialize(site, base, dir, name)
+      @site = site
+      @base = base
+      @dir  = dir
+      @name = name
+    end
+
+    # Obtains source file path.
+    #
+    # Returns source file path.
+    def path
+      File.join(@base, @dir, @name)
+    end
+
+    # Obtain destination path.
+    #   +dest+ is the String path to the destination dir
+    #
+    # Returns destination file path.
+    def destination(dest)
+      File.join(dest, @dir, @name)
+    end
+
+    # Obtain mtime of the source path.
+    #
+    # Returns last modifiaction time for this file.
+    def mtime
+      File.stat(path).mtime.to_i
+    end
+
+    # Is source path modified?
+    #
+    # Returns true if modified since last write.
+    def modified?
+      @@mtimes[path] != mtime
+    end
+
+    # Write the static file to the destination directory (if modified).
+    #   +dest+ is the String path to the destination dir
+    #
+    # Returns false if the file was not modified since last time (no-op).
+    def write(dest)
+      dest_path = destination(dest)
+
+      return false if File.exist? dest_path and !modified?
+      @@mtimes[path] = mtime
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.cp(path, dest_path)
+
+      true
+    end
+
+    # Reset the mtimes cache (for testing purposes).
+    #
+    # Returns nothing.
+    def self.reset_cache
+      @@mtimes = Hash.new
+
+      nil
+    end
+  end
+
+end

data/lib/jekyll/tags/highlight.rb

@@ -0,0 +1,73 @@
+module Jekyll
+
+  class HighlightBlock < Liquid::Block
+    include Liquid::StandardFilters
+
+    # we need a language, but the linenos argument is optional.
+    SYNTAX = /(\w+)\s?([\w\s=]+)*/
+
+    def initialize(tag_name, markup, tokens)
+      super
+      if markup =~ SYNTAX
+        @lang = $1
+        if defined? $2
+          tmp_options = {}
+          $2.split.each do |opt|
+            key, value = opt.split('=')
+            if value.nil?
+              if key == 'linenos'
+                value = 'inline'
+              else
+                value = true
+              end
+            end
+            tmp_options[key] = value
+          end
+          tmp_options = tmp_options.to_a.collect { |opt| opt.join('=') }
+          # additional options to pass to Albino.
+          @options = { 'O' => tmp_options.join(',') }
+        else
+          @options = {}
+        end
+      else
+        raise SyntaxError.new("Syntax Error in 'highlight' - Valid syntax: highlight <lang> [linenos]")
+      end
+    end
+
+    def render(context)
+      if context.registers[:site].pygments
+        render_pygments(context, super.join)
+      else
+        render_codehighlighter(context, super.join)
+      end
+    end
+
+    def render_pygments(context, code)
+      output = add_code_tags(Albino.new(code, @lang).to_s(@options), @lang)
+      output = context["pygments_prefix"] + output if context["pygments_prefix"]
+      output = output + context["pygments_suffix"] if context["pygments_suffix"]
+      output
+    end
+
+    def render_codehighlighter(context, code)
+    #The div is required because RDiscount blows ass
+      <<-HTML
+<div>
+  <pre>
+    <code class='#{@lang}'>#{h(code).strip}</code>
+  </pre>
+</div>
+      HTML
+    end
+    
+    def add_code_tags(code, lang)
+      # Add nested <code> tags to code blocks
+      code = code.sub(/<pre>/,'<pre><code class="' + lang + '">')
+      code = code.sub(/<\/pre>/,"</code></pre>")
+    end
+    
+  end
+
+end
+
+Liquid::Template.register_tag('highlight', Jekyll::HighlightBlock)

data/lib/jekyll/tags/include.rb

@@ -0,0 +1,37 @@
+module Jekyll
+
+  class IncludeTag < Liquid::Tag
+    def initialize(tag_name, file, tokens)
+      super
+      @file = file.strip
+    end
+
+    def render(context)
+      includes_dir = File.join(context.registers[:site].source, '_includes')
+
+      if File.symlink?(includes_dir)
+        return "Includes directory '#{includes_dir}' cannot be a symlink"
+      end
+
+      if @file !~ /^[a-zA-Z0-9_\/\.-]+$/ || @file =~ /\.\// || @file =~ /\/\./
+        return "Include file '#{@file}' contains invalid characters or sequences"
+      end
+
+      Dir.chdir(includes_dir) do
+        choices = Dir['**/*'].reject { |x| File.symlink?(x) }
+        if choices.include?(@file)
+          source = File.read(@file)
+          partial = Liquid::Template.parse(source)
+          context.stack do
+            partial.render(context)
+          end
+        else
+          "Included file '#{@file}' not found in _includes directory"
+        end
+      end
+    end
+  end
+
+end
+
+Liquid::Template.register_tag('include', Jekyll::IncludeTag)