jekyll 2.0.0.alpha.2 → 2.0.0.alpha.3

data/lib/jekyll/renderer.rb

@@ -0,0 +1,132 @@
+module Jekyll
+  class Renderer
+
+    attr_reader :document, :site
+
+    def initialize(site, document)
+      @site     = site
+      @document = document
+    end
+
+    # Determine which converters to use based on this document's
+    # extension.
+    #
+    # Returns an array of Converter instances.
+    def converters
+      @converters ||= site.converters.select { |c| c.matches(document.extname) }
+    end
+
+    # Determine the extname the outputted file should have
+    #
+    # Returns the output extname including the leading period.
+    def output_ext
+      converters.first.output_ext(document.extname)
+    end
+
+    ######################
+    ## DAT RENDER THO
+    ######################
+
+    def run
+      payload = Utils.deep_merge_hashes({
+        "page" => document.to_liquid
+      }, site.site_payload)
+
+      info = {
+        filters:   [Jekyll::Filters],
+        registers: { :site => site, :page => payload['page'] }
+      }
+
+      # render and transform content (this becomes the final content of the object)
+      payload["highlighter_prefix"] = converters.first.highlighter_prefix
+      payload["highlighter_suffix"] = converters.first.highlighter_suffix
+
+      output = document.content
+
+      if document.render_with_liquid?
+        output = render_liquid(output, payload, info)
+      end
+
+      place_in_layouts(
+        convert(output),
+        payload,
+        info
+      )
+    end
+
+    # Convert the given content using the converters which match this renderer's document.
+    #
+    # content - the raw, unconverted content
+    #
+    # Returns the converted content.
+    def convert(content)
+      converters.reduce(content) do |output, converter|
+        begin
+          converter.convert output
+        rescue => e
+          Jekyll.logger.error "Conversion error:", "#{converter.class} encountered an error converting '#{document.relative_path}'."
+          raise e
+        end
+      end
+    end
+
+    # Render the given content with the payload and info
+    #
+    # content -
+    # payload -
+    # info    -
+    # path    - (optional) the path to the file, for use in ex
+    #
+    # Returns the content, rendered by Liquid.
+    def render_liquid(content, payload, info, path = nil)
+      Liquid::Template.parse(content).render!(payload, info)
+    rescue Tags::IncludeTagError => e
+      Jekyll.logger.error "Liquid Exception:", "#{e.message} in #{e.path}, included in #{path || document.relative_path}"
+      raise e
+    rescue Exception => e
+      Jekyll.logger.error "Liquid Exception:", "#{e.message} in #{path || document.relative_path}"
+      raise e
+    end
+
+    # Render layouts and place given content inside.
+    #
+    # content - the content to be placed in the layout
+    #
+    #
+    # Returns the content placed in the Liquid-rendered layouts
+    def place_in_layouts(content, payload, info)
+      output = content.dup
+      layout = site.layouts[document.data["layout"]]
+      used   = Set.new([layout])
+
+      while layout
+        payload = Utils.deep_merge_hashes(
+          payload,
+          {
+            "content" => output,
+            "page"    => document.to_liquid,
+            "layout"  => layout.data
+          }
+        )
+
+        output = render_liquid(
+          layout.content,
+          payload,
+          info,
+          File.join(site.config['layouts'], layout.name)
+        )
+
+        if layout = site.layouts[layout.data["layout"]]
+          if used.include?(layout)
+            layout = nil # avoid recursive chain
+          else
+            used << layout
+          end
+        end
+      end
+
+      output
+    end
+
+  end
+end

data/lib/jekyll/site.rb

@@ -1,9 +1,10 @@
 module Jekyll
   class Site
     attr_accessor :config, :layouts, :posts, :pages, :static_files,
-                  :categories, :exclude, :include, :source, :dest, :lsi, :highlighter,
-                  :permalink_style, :tags, :time, :future, :safe, :plugins, :limit_posts,
-                  :show_drafts, :keep_files, :baseurl, :data, :file_read_opts, :gems
+                  :exclude, :include, :source, :dest, :lsi, :highlighter,
+                  :permalink_style, :time, :future, :unpublished, :safe, :plugins, :limit_posts,
+                  :show_drafts, :keep_files, :baseurl, :data, :file_read_opts, :gems,
+                  :plugin_manager, :collections
 
     attr_accessor :converters, :generators
 
@@ -13,15 +14,18 @@ module Jekyll
     def initialize(config)
       self.config = config.clone
 
-      %w[safe lsi highlighter baseurl exclude include future show_drafts limit_posts keep_files gems].each do |opt|
+      %w[safe lsi highlighter baseurl exclude include future unpublished
+        show_drafts limit_posts keep_files gems].each do |opt|
         self.send("#{opt}=", config[opt])
       end
 
-      self.source = File.expand_path(config['source'])
-      self.dest = File.expand_path(config['destination'])
-      self.plugins = plugins_path
+      self.source          = File.expand_path(config['source'])
+      self.dest            = File.expand_path(config['destination'])
       self.permalink_style = config['permalink'].to_sym
 
+      self.plugin_manager = Jekyll::PluginManager.new(self)
+      self.plugins        = plugin_manager.plugins_path
+
       self.file_read_opts = {}
       self.file_read_opts[:encoding] = config['encoding'] if config['encoding']
 
@@ -50,8 +54,6 @@ module Jekyll
       self.posts = []
       self.pages = []
       self.static_files = []
-      self.categories = Hash.new { |hash, key| hash[key] = [] }
-      self.tags = Hash.new { |hash, key| hash[key] = [] }
       self.data = {}
 
       if limit_posts < 0
@@ -65,17 +67,7 @@ module Jekyll
     def setup
       ensure_not_in_dest
 
-      # If safe mode is off, load in any Ruby files under the plugins
-      # directory.
-      unless safe
-        plugins.each do |plugins|
-          Dir[File.join(plugins, "**/*.rb")].sort.each do |f|
-            require f
-          end
-        end
-      end
-
-      require_gems
+      plugin_manager.conscientious_require
 
       self.converters = instantiate_subclasses(Jekyll::Converter)
       self.generators = instantiate_subclasses(Jekyll::Generator)
@@ -92,31 +84,24 @@ module Jekyll
       end
     end
 
-    def require_gems
-      gems.each do |gem|
-        if plugin_allowed?(gem)
-          require gem
-        end
+    # The list of collections and their corresponding Jekyll::Collection instances.
+    # If config['collections'] is set, a new instance is created for each item in the collection.
+    # If config['collections'] is not set, a new hash is returned.
+    #
+    # Returns a Hash containing collection name-to-instance pairs.
+    def collections
+      @collections ||= if config['collections']
+        Hash[config['collections'].map { |coll| [coll, Jekyll::Collection.new(self, coll)] } ]
+      else
+        Hash.new
       end
     end
 
-    def plugin_allowed?(gem_name)
-      whitelist.include?(gem_name) || !safe
-    end
-
-    def whitelist
-      @whitelist ||= Array[config['whitelist']].flatten
-    end
-
-    # Internal: Setup the plugin search path
+    # The list of collections to render.
     #
-    # Returns an Array of plugin search paths
-    def plugins_path
-      if (config['plugins'] == Jekyll::Configuration::DEFAULTS['plugins'])
-        [File.join(source, config['plugins'])]
-      else
-        Array(config['plugins']).map { |d| File.expand_path(d) }
-      end
+    # The array of collection labels to render.
+    def to_render
+      @to_render ||= (config['render'] || Array.new)
     end
 
     # Read Site data from disk and load it into internal data structures.
@@ -126,6 +111,7 @@ module Jekyll
       self.layouts = LayoutReader.new(self).read
       read_directories
       read_data(config['data_source'])
+      read_collections
     end
 
     # Recursively traverse directories to find posts, pages and static files
@@ -151,7 +137,7 @@ module Jekyll
           read_directories(f_rel) unless dest.sub(/\/$/, '') == f_abs
         elsif has_yaml_header?(f_abs)
           page = Page.new(self, source, dir, f)
-          pages << page if page.published?
+          pages << page if publisher.publish?(page)
         else
           static_files << StaticFile.new(self, source, dir, f)
         end
@@ -170,11 +156,9 @@ module Jekyll
       posts = read_content(dir, '_posts', Post)
 
       posts.each do |post|
-        if post.published? && (future || post.date <= time)
-          aggregate_post_info(post)
-        end
+        aggregate_post_info(post) if publisher.publish?(post)
       end
-   end
+    end
 
     # Read all the files in <source>/<dir>/_drafts and create a new Post
     # object with each one.
@@ -204,21 +188,27 @@ module Jekyll
     #
     # Returns nothing
     def read_data(dir)
-      base = File.join(source, dir)
-      return unless File.directory?(base) && (!safe || !File.symlink?(base))
-
-      entries = Dir.chdir(base) { Dir['*.{yaml,yml}'] }
-      entries.delete_if { |e| File.directory?(File.join(base, e)) }
+      unless dir.to_s.eql?("_data")
+        Jekyll.logger.error "Error:", "Data source directories other than '_data' have been removed.\n" +
+          "Please move your YAML files to `_data` and remove the `data_source` key from your `_config.yml`."
+      end
 
-      entries.each do |entry|
-        path = File.join(source, dir, entry)
-        next if File.symlink?(path) && safe
+      collections['data'] = Jekyll::Collection.new(self, "data")
+      collections['data'].read
 
-        key = sanitize_filename(File.basename(entry, '.*'))
-        self.data[key] = SafeYAML.load_file(path)
+      collections['data'].docs.each do |doc|
+        key = sanitize_filename(doc.basename(".*"))
+        self.data[key] = doc.data
       end
     end
 
+    # Read in all collections specified in the configuration
+    #
+    # Returns nothing.
+    def read_collections
+      collections.each { |_, collection| collection.read }
+    end
+
     # Run each of the Generators.
     #
     # Returns nothing.
@@ -234,13 +224,16 @@ module Jekyll
     def render
       relative_permalinks_deprecation_method
 
+      to_render.each do |label|
+        collections[label].docs.each do |document|
+          document.output = Jekyll::Renderer.new(self, document).run
+        end
+      end
+
       payload = site_payload
       [posts, pages].flatten.each do |page_or_post|
         page_or_post.render(layouts, payload)
       end
-
-      categories.values.map { |ps| ps.sort! { |a, b| b <=> a } }
-      tags.values.map { |ps| ps.sort! { |a, b| b <=> a } }
     rescue Errno::ENOENT => e
       # ignore missing layout dir
     end
@@ -275,12 +268,20 @@ module Jekyll
     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] = [] }
+      hash = Hash.new { |h, key| h[key] = [] }
       posts.each { |p| p.send(post_attr.to_sym).each { |t| hash[t] << p } }
-      hash.values.map { |sortme| sortme.sort! { |a, b| b <=> a } }
+      hash.values.each { |posts| posts.sort!.reverse! }
       hash
     end
 
+    def tags
+      post_attr_hash('tags')
+    end
+
+    def categories
+      post_attr_hash('categories')
+    end
+
     # Prepare site data for site payload. The method maintains backward compatibility
     # if the key 'data' is already used in _config.yml.
     #
@@ -304,7 +305,8 @@ module Jekyll
     #                  See Site#post_attr_hash for type info.
     def site_payload
       {"jekyll" => { "version" => Jekyll::VERSION },
-       "site" => config.merge({
+       "site"   => Utils.deep_merge_hashes(config,
+         Utils.deep_merge_hashes(collections, {
           "time"         => time,
           "posts"        => posts.sort { |a, b| b <=> a },
           "pages"        => pages,
@@ -312,7 +314,9 @@ module Jekyll
           "html_pages"   => pages.reject { |page| !page.html? },
           "categories"   => post_attr_hash('categories'),
           "tags"         => post_attr_hash('tags'),
-          "data"         => site_data})}
+          "data"         => site_data
+        }))
+      }
     end
 
     # Filter out any files/directories that are hidden or backup files (start
@@ -364,7 +368,7 @@ module Jekyll
     # Returns the list of entries to process
     def get_entries(dir, subfolder)
       base = File.join(source, dir, subfolder)
-      return [] unless File.exists?(base)
+      return [] unless File.exist?(base)
       entries = Dir.chdir(base) { filter_entries(Dir['**/*'], base) }
       entries.delete_if { |e| File.directory?(File.join(base, e)) }
     end
@@ -376,8 +380,6 @@ module Jekyll
     # Returns nothing
     def aggregate_post_info(post)
       posts << post
-      post.categories.each { |c| categories[c] << post }
-      post.tags.each { |c| tags[c] << post }
     end
 
     def relative_permalinks_deprecation_method
@@ -392,8 +394,18 @@ module Jekyll
       end
     end
 
+    def documents
+      collections.reduce(Set.new) do |docs, (label, coll)|
+        if to_render.include?(label)
+          docs.merge(coll.docs)
+        else
+          docs
+        end
+      end
+    end
+
     def each_site_file
-      %w(posts pages static_files).each do |type|
+      %w(posts pages static_files documents).each do |type|
         send(type).each do |item|
           yield item
         end
@@ -407,7 +419,7 @@ module Jekyll
     end
 
     def has_yaml_header?(file)
-      "---" == File.open(file) { |fd| fd.read(3) }
+      !!(File.open(file).read =~ /\A---\r?\n/)
     end
 
     def limit_posts!
@@ -424,5 +436,9 @@ module Jekyll
       name.gsub!(/(^|\b\s)\s+($|\s?\b)/, '\\1\\2')
       name.gsub(/\s+/, '_')
     end
+
+    def publisher
+      @publisher ||= Publisher.new(self)
+    end
   end
 end

data/lib/jekyll/tags/highlight.rb

@@ -41,14 +41,15 @@ eos
       end
 
       def render(context)
+        code = super.to_s.strip
         case context.registers[:site].highlighter
         when 'pygments'
-          render_pygments(context, super)
+          render_pygments(context, code)
         when 'rouge'
-          render_rouge(context, super)
+          render_rouge(context, code)
         else
-          render_codehighlighter(context, super)
-        end
+          render_codehighlighter(context, code)
+        end.strip
       end
 
       def render_pygments(context, code)
@@ -106,8 +107,9 @@ eos
 
       def add_code_tags(code, lang)
         # Add nested <code> tags to code blocks
-        code = code.sub(/<pre>/,'<pre><code class="' + lang.to_s.gsub("+", "-") + '">')
-        code = code.sub(/<\/pre>/,"</code></pre>")
+        code = code.sub(/<pre>\n*/,'<pre><code class="' + lang.to_s.gsub("+", "-") + '">')
+        code = code.sub(/\n*<\/pre>/,"</code></pre>")
+        code.strip
       end
 
     end