Class: Jekyll::Site

### Home Classes Methods

### In Files

- lib/jekyll/cleaner.rb
- lib/jekyll/site.rb

### Parent

Object

### Namespace

- CLASS Jekyll::Site::Cleaner

### Methods

- ::new
- #aggregate_post_info
- #cleanup
- #each_site_file
- #filter_entries
- #generate
- #getConverterImpl
- #get_entries
- #instantiate_subclasses
- #plugins_path
- #post_attr_hash
- #process
- #read
- #read_directories
- #read_drafts
- #read_layouts
- #read_posts
- #relative_permalinks_deprecation_method
- #render
- #reset
- #setup
- #site_payload
- #write

### Files

- LICENSE

### Class/Module Index

Quicksearch

- Jekyll
- Jekyll::Command
- Jekyll::Commands
- Jekyll::Commands::Build
- Jekyll::Commands::Doctor
- Jekyll::Commands::New
- Jekyll::Commands::Serve
- Jekyll::Configuration
- Jekyll::Converter
- Jekyll::Converters
- Jekyll::Converters::Identity
- Jekyll::Converters::Markdown
- Jekyll::Converters::Markdown::KramdownParser
- Jekyll::Converters::Markdown::MarukuParser
- Jekyll::Converters::Markdown::RDiscountParser
- Jekyll::Converters::Markdown::RedcarpetParser
- Jekyll::Converters::Markdown::RedcarpetParser::CommonMethods
- Jekyll::Converters::Markdown::RedcarpetParser::WithPygments
- Jekyll::Converters::Markdown::RedcarpetParser::WithoutPygments
- Jekyll::Converters::Textile
- Jekyll::Convertible
- Jekyll::Deprecator
- Jekyll::Draft
- Jekyll::Excerpt
- Jekyll::FatalException
- Jekyll::Filters
- Jekyll::Generator
- Jekyll::Generators
- Jekyll::Generators::Pagination
- Jekyll::GistTag
- Jekyll::Layout
- Jekyll::Page
- Jekyll::Pager
- Jekyll::Plugin
- Jekyll::Post
- Jekyll::RelatedPosts
- Jekyll::Site
- Jekyll::Site::Cleaner
- Jekyll::StaticFile
- Jekyll::Stevenson
- Jekyll::Tags
- Jekyll::Tags::HighlightBlock
- Jekyll::Tags::IncludeTag
- Jekyll::Tags::PostComparer
- Jekyll::Tags::PostUrl
- Jekyll::URL
- Date
- Enumerable
- Hash
- Object

No matching classes.

# Jekyll::Site

### Attributes

baseurl[RW]
categories[RW]
config[RW]
converters[RW]
dest[RW]
exclude[RW]
future[RW]
generators[RW]
include[RW]
keep_files[RW]
layouts[RW]
limit_posts[RW]
lsi[RW]
pages[RW]
permalink_style[RW]
plugins[RW]
posts[RW]
pygments[RW]
safe[RW]
show_drafts[RW]
source[RW]
static_files[RW]
tags[RW]
time[RW]

### Public Class Methods

new(config) click to toggle source

Public: Initialize a new Site.

config - A Hash containing site configuration details.

    # File lib/jekyll/site.rb, line 13
    def initialize(config)
      self.config          = config.clone

      ]safe lsi pygments baseurl exclude include future show_drafts limit_posts keep_files].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.permalink_style = config['permalink'].to_sym

      self.reset
      self.setup
    end

### Public Instance Methods

aggregate_post_info(post) click to toggle source

Aggregate post information

post - The Post object to aggregate information for

Returns nothing

    # File lib/jekyll/site.rb, line 345
    def aggregate_post_info(post)
      self.posts << post
      post.categories.each { |c| self.categories[c] << post }
      post.tags.each { |c| self.tags[c] << post }
    end

cleanup() click to toggle source

Remove orphaned files and empty directories in destination.

Returns nothing.

    # File lib/jekyll/site.rb, line 222
    def cleanup
      site_cleaner.cleanup!
    end

each_site_file() click to toggle source

    # File lib/jekyll/site.rb, line 364
    def each_site_file
      %(posts pages static_files).each do |type|
        self.send(type).each do |item|
          yield item
        end
      end
    end

filter_entries(entries) click to toggle source

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'.

entries - The Array of String file/directory entries to filter.

Returns the Array of filtered entries.

    # File lib/jekyll/site.rb, line 287
    def filter_entries(entries)
      entries.reject do |e|
        unless self.include.glob_include?(e)
          ['.', '_', '#'].include?(e[0..0]) ||
          e[-1..-1] == '~' ||
          self.exclude.glob_include?(e) ||
          (File.symlink?(e) && self.safe)
        end
      end
    end

generate() click to toggle source

Run each of the Generators.

Returns nothing.

    # File lib/jekyll/site.rb, line 193
    def generate
      self.generators.each do |generator|
        generator.generate(self)
      end
    end

getConverterImpl(klass) click to toggle source

Get the implementation class for the given Converter.

klass - The Class of the Converter to fetch.

Returns the Converter instance implementing the given Converter.

    # File lib/jekyll/site.rb, line 303
    def getConverterImpl(klass)
      matches = self.converters.select { |c| c.class == klass }
      if impl = matches.first
        impl
      else
        raise "Converter implementation not found for #{klass}"
      end
    end

get_entries(dir, subfolder) click to toggle source

Read the entries from a particular directory for processing

dir - The String relative path of the directory to read subfolder - The String directory to read

Returns the list of entries to process

    # File lib/jekyll/site.rb, line 333
    def get_entries(dir, subfolder)
      base = File.join(self.source, dir, subfolder)
      return [] unless File.exists?(base)
      entries = Dir.chdir(base) { filter_entries(Dir['**/*']) }
      entries.delete_if { |e| File.directory?(File.join(base, e)) }
    end

instantiate_subclasses(klass) click to toggle source

Create array of instances of the subclasses of the class or module

    passed in as argument.

klass - class or module containing the subclasses which should be

    instantiated

Returns array of instances of subclasses of parameter

    # File lib/jekyll/site.rb, line 319
    def instantiate_subclasses(klass)
      klass.subclasses.select do |c|
        !self.safe || c.safe
      end.sort.map do |c|
        c.new(self.config)
      end
    end

plugins_path() click to toggle source

Internal: Setup the plugin search path

Returns an Array of plugin search paths

    # File lib/jekyll/site.rb, line 89
    def plugins_path
      if (config['plugins'] == Jekyll::Configuration::DEFAULTS['plugins'])
        [File.join(self.source, config['plugins'])]
      else
        Array(config['plugins']).map { |d| File.expand_path(d) }
      end
    end

post_attr_hash(post_attr) click to toggle source

Construct a Hash of Posts indexed by the specified Post attribute.

post_attr - The String name of the Post attribute.

Examples

    post_attr_hash('categories')
    # => { 'tech' => [<Post A>, <Post B>],
    #      'ruby' => [<Post B>] }

Returns the Hash: { attr => posts } where

    attr  - One of the values for the requested attribute.
    posts - The Array of Posts with the given attr value.

    # File lib/jekyll/site.rb, line 246
    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 { |hsh, key| hsh[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 } }
      hash
    end

process() click to toggle source

Public: Read, process, and write this Site to output.

Returns nothing.

    # File lib/jekyll/site.rb, line 32
    def process
      self.reset
      self.read
      self.generate
      self.render
      self.cleanup
      self.write
    end

read() click to toggle source

Read Site data from disk and load it into internal data structures.

Returns nothing.

    # File lib/jekyll/site.rb, line 100
    def read
      self.read_layouts
      self.read_directories
    end

read_directories(dir = '') click to toggle source

Recursively traverse directories to find posts, pages and static files that will become part of the site according to the rules in filter_entries.

dir - The String relative path of the directory to read. Default: ".

Returns nothing.

    # File lib/jekyll/site.rb, line 128
    def read_directories(dir = '')
      base = File.join(self.source, dir)
      entries = Dir.chdir(base) { filter_entries(Dir.entries('.')) }

      self.read_posts(dir)
      self.read_drafts(dir) if self.show_drafts
      self.posts.sort!
      limit_posts! if limit_posts > 0 # limit the posts if :limit_posts option is set

      entries.each do |f|
        f_abs = File.join(base, f)
        if File.directory?(f_abs)
          f_rel = File.join(dir, f)
          read_directories(f_rel) unless self.dest.sub(/\/$/, '') == f_abs
        elsif has_yaml_header?(f_abs)
          pages << Page.new(self, self.source, dir, f)
        else
          static_files << StaticFile.new(self, self.source, dir, f)
        end
      end
    end

read_drafts(dir) click to toggle source

Read all the files in <source>/<dir>/_drafts and create a new Post object with each one.

dir - The String relative path of the directory to read.

Returns nothing.

    # File lib/jekyll/site.rb, line 177
    def read_drafts(dir)
      entries = get_entries(dir, '_drafts')

      # first pass processes, but does not yet render draft content
      entries.each do |f|
        if Draft.valid?(f)
          draft = Draft.new(self, self.source, dir, f)

          aggregate_post_info(draft)
        end
      end
    end

read_layouts() click to toggle source

Read all the files in <source>/<layouts> and create a new Layout object with each one.

Returns nothing.

    # File lib/jekyll/site.rb, line 109
    def read_layouts
      base = File.join(self.source, self.config['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_posts(dir) click to toggle source

Read all the files in <source>/<dir>/_posts and create a new Post object with each one.

dir - The String relative path of the directory to read.

Returns nothing.

    # File lib/jekyll/site.rb, line 156
    def read_posts(dir)
      entries = get_entries(dir, '_posts')

      # 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)
            aggregate_post_info(post)
          end
        end
      end
    end

relative_permalinks_deprecation_method() click to toggle source

    # File lib/jekyll/site.rb, line 351
    def relative_permalinks_deprecation_method
      if config['relative_permalinks'] && !@deprecated_relative_permalinks
        $stderr.puts # Places newline after "Generating..."
        Jekyll.logger.warn "Deprecation:", "Starting in 1.1, permalinks for pages" +
                                            " in subfolders must be relative to the" +
                                            " site source directory, not the parent" +
                                            " directory. Check http://jekyllrb.com/docs/upgrading/"+
                                            " for more info."
        $stderr.print Jekyll.logger.formatted_topic("") + "..." # for "done."
        @deprecated_relative_permalinks = true
      end
    end

render() click to toggle source

Render the site to the destination.

Returns nothing.

    # File lib/jekyll/site.rb, line 202
    def render
      payload = site_payload
      self.posts.each do |post|
        post.render(self.layouts, payload)
      end

      self.pages.each do |page|
        relative_permalinks_deprecation_method if page.uses_relative_permalinks
        page.render(self.layouts, 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

reset() click to toggle source

Reset Site details.

Returns nothing

    # File lib/jekyll/site.rb, line 44
    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] = [] }

      if self.limit_posts < 0
        raise ArgumentError, "limit_posts must be a non-negative number"
      end
    end

setup() click to toggle source

Load necessary libraries, plugins, converters, and generators.

Returns nothing.

    # File lib/jekyll/site.rb, line 65
    def setup
      # Check that the destination dir isn't the source dir or a directory
      # parent to the source dir.
      if self.source =~ /^#{self.dest}/
        raise FatalException.new "Destination directory cannot be or contain the Source directory."
      end

      # If safe mode is off, load in any Ruby files under the plugins
      # directory.
      unless self.safe
        self.plugins.each do |plugins|
            Dir[File.join(plugins, "**/*.rb")].each do |f|
              require f
            end
        end
      end

      self.converters = instantiate_subclasses(Jekyll::Converter)
      self.generators = instantiate_subclasses(Jekyll::Generator)
    end

site_payload() click to toggle source

The Hash payload containing site-wide data.

Returns the Hash: { "site" => data } where data is a Hash with keys:

    "time"       - The Time as specified in the configuration or the
                   current time if none was specified.
    "posts"      - The Array of Posts, sorted chronologically by post date
                   and then title.
    "pages"      - The Array of all Pages.
    "html_pages" - The Array of HTML Pages.
    "categories" - The Hash of category values and Posts.
                   See Site#post_attr_hash for type info.
    "tags"       - The Hash of tag values and Posts.
                   See Site#post_attr_hash for type info.

    # File lib/jekyll/site.rb, line 268
    def site_payload
      {"jekyll" => { "version" => Jekyll::VERSION },
       "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

write() click to toggle source

Write static files, pages, and posts.

Returns nothing.

    # File lib/jekyll/site.rb, line 229
    def write
      each_site_file { |item| item.write(self.dest) }
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.