jekyll 1.0.4 → 1.1.1

data/lib/jekyll.rb

@@ -36,6 +36,7 @@ require 'jekyll/convertible'
 require 'jekyll/layout'
 require 'jekyll/page'
 require 'jekyll/post'
+require 'jekyll/excerpt'
 require 'jekyll/draft'
 require 'jekyll/filters'
 require 'jekyll/static_file'
@@ -57,7 +58,7 @@ require_all 'jekyll/tags'
 SafeYAML::OPTIONS[:suppress_warnings] = true
 
 module Jekyll
-  VERSION = '1.0.4'
+  VERSION = '1.1.1'
 
   # Public: Generate a Jekyll configuration Hash by merging the default
   # options with anything in _config.yml, and adding the given options on top.

data/lib/jekyll/commands/new.rb

@@ -13,14 +13,26 @@ module Jekyll
           exit(1)
         end
 
-        create_sample_files new_blog_path
+        if options[:blank]
+          create_blank_site new_blog_path
+        else
+          create_sample_files new_blog_path
 
-        File.open(File.expand_path(self.initialized_post_name, new_blog_path), "w") do |f|
-          f.write(self.scaffold_post_content(site_template))
+          File.open(File.expand_path(self.initialized_post_name, new_blog_path), "w") do |f|
+            f.write(self.scaffold_post_content(site_template))
+          end
         end
+
         puts "New jekyll site installed in #{new_blog_path}."
       end
 
+      def self.create_blank_site(path)
+        Dir.chdir(path) do
+          FileUtils.mkdir(%w(_layouts _posts _drafts))
+          FileUtils.touch("index.html")
+        end
+      end
+
       def self.scaffold_post_content(template_site)
         ERB.new(File.read(File.expand_path(scaffold_path, site_template))).result
       end

data/lib/jekyll/configuration.rb

@@ -29,7 +29,7 @@ module Jekyll
       'baseurl'       => '/',
       'include'       => ['.htaccess'],
       'exclude'       => [],
-      'paginate_path' => 'page:num',
+      'paginate_path' => '/page:num',
 
       'markdown_ext'  => 'markdown,mkd,mkdn,md',
       'textile_ext'   => 'textile',
@@ -102,7 +102,10 @@ module Jekyll
     def config_files(override)
       # Get configuration from <source>/_config.yml or <source>/<config_file>
       config_files = override.delete('config')
-      config_files = File.join(source(override), "_config.yml") if config_files.to_s.empty?
+      if config_files.to_s.empty?
+        config_files = File.join(source(override), "_config.yml")
+        @default_config_file = true
+      end
       config_files = [config_files] unless config_files.is_a? Array
       config_files
     end
@@ -114,9 +117,17 @@ module Jekyll
     # Returns this configuration, overridden by the values in the file
     def read_config_file(file)
       next_config = YAML.safe_load_file(file)
-      raise "Configuration file: (INVALID) #{file}".yellow if !next_config.is_a?(Hash)
+      raise ArgumentError.new("Configuration file: (INVALID) #{file}".yellow) if !next_config.is_a?(Hash)
       Jekyll.logger.info "Configuration file:", file
       next_config
+    rescue SystemCallError
+      if @default_config_file
+        Jekyll.logger.warn "Configuration file:", "none"
+        {}
+      else
+        Jekyll.logger.error "Fatal:", "The configuration file '#{file}' could not be found."
+        raise LoadError
+      end
     end
 
     # Public: Read in a list of configuration files and merge with this hash
@@ -133,10 +144,7 @@ module Jekyll
           new_config = read_config_file(config_file)
           configuration = configuration.deep_merge(new_config)
         end
-      rescue SystemCallError
-        # Errno:ENOENT = file not found
-        Jekyll.logger.warn "Configuration file:", "none"
-      rescue => err
+      rescue ArgumentError => err
         Jekyll.logger.warn "WARNING:", "Error reading configuration. " +
                      "Using defaults (and options)."
         $stderr.puts "#{err}"
@@ -185,22 +193,15 @@ module Jekyll
         config.delete('server_port')
       end
 
-      if config.has_key?('exclude') && config['exclude'].is_a?(String)
-        Jekyll.logger.warn "Deprecation:", "The 'exclude' configuration option" +
-                               " must now be specified as an array, but you specified" +
-                               " a string. For now, we've treated the string you provided" +
-                               " as a list of comma-separated values."
-        config['exclude'] = csv_to_array(config['exclude'])
-      end
-
-      if config.has_key?('include') && config['include'].is_a?(String)
-        Jekyll.logger.warn "Deprecation:", "The 'include' configuration option" +
-                               " must now be specified as an array, but you specified" +
-                               " a string. For now, we've treated the string you provided" +
-                               " as a list of comma-separated values."
-        config['include'] = csv_to_array(config['include'])
+      %w[include exclude].each do |option|
+        if config.fetch(option, []).is_a?(String)
+          Jekyll.logger.warn "Deprecation:", "The '#{option}' configuration option" +
+            " must now be specified as an array, but you specified" +
+            " a string. For now, we've treated the string you provided" +
+            " as a list of comma-separated values."
+          config[option] = csv_to_array(config[option])
+        end
       end
-
       config
     end
 

data/lib/jekyll/converters/markdown/kramdown_parser.rb

@@ -13,8 +13,8 @@ module Jekyll
 
         def convert(content)
           # Check for use of coderay
-          kramdown_configs = if @config['kramdown']['use_coderay']
-            base_kramdown_configs.merge({
+          if @config['kramdown']['use_coderay']
+            @config['kramdown'].merge!({
               :coderay_wrap               => @config['kramdown']['coderay']['coderay_wrap'],
               :coderay_line_numbers       => @config['kramdown']['coderay']['coderay_line_numbers'],
               :coderay_line_number_start  => @config['kramdown']['coderay']['coderay_line_number_start'],
@@ -22,22 +22,11 @@ module Jekyll
               :coderay_bold_every         => @config['kramdown']['coderay']['coderay_bold_every'],
               :coderay_css                => @config['kramdown']['coderay']['coderay_css']
             })
-          else
-            # not using coderay
-            base_kramdown_configs
           end
-          Kramdown::Document.new(content, kramdown_configs).to_html
-        end
 
-        def base_kramdown_configs
-          {
-            :auto_ids      => @config['kramdown']['auto_ids'],
-            :footnote_nr   => @config['kramdown']['footnote_nr'],
-            :entity_output => @config['kramdown']['entity_output'],
-            :toc_levels    => @config['kramdown']['toc_levels'],
-            :smart_quotes  => @config['kramdown']['smart_quotes']
-          }
+          Kramdown::Document.new(content, @config["kramdown"].symbolize_keys).to_html
         end
+
       end
     end
   end

data/lib/jekyll/convertible.rb

@@ -48,6 +48,10 @@ module Jekyll
     # Returns nothing.
     def transform
       self.content = converter.convert(self.content)
+    rescue => e
+      Jekyll.logger.error "Conversion error:", "There was an error converting" +
+        " '#{self.path}'."
+      raise e
     end
 
     # Determine the extension depending on content_type.

data/lib/jekyll/core_ext.rb

@@ -41,6 +41,17 @@ class Hash
     end
     array || []
   end
+
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
 end
 
 # Thanks, ActiveSupport!

data/lib/jekyll/excerpt.rb

@@ -0,0 +1,113 @@
+module Jekyll
+  class Excerpt
+    include Convertible
+
+    attr_accessor :post
+    attr_accessor :content, :output, :ext
+
+    # Initialize this Post instance.
+    #
+    # site       - The Site.
+    # base       - The String path to the dir containing the post file.
+    # name       - The String filename of the post file.
+    #
+    # Returns the new Post.
+    def initialize(post)
+      self.post = post
+      self.content = extract_excerpt(post.content)
+    end
+
+    %w[site name ext].each do |meth|
+      define_method(meth) do
+        post.send(meth)
+      end
+    end
+
+    def to_liquid
+      post.to_liquid(Post::EXCERPT_ATTRIBUTES_FOR_LIQUID)
+    end
+
+    # Fetch YAML front-matter data from related post, without layout key
+    #
+    # Returns Hash of post data
+    def data
+      @data ||= post.data.dup
+      @data.delete("layout")
+      @data
+    end
+
+    # 'Path' of the excerpt.
+    # 
+    # Returns the path for the post this excerpt belongs to with #excerpt appended
+    def path
+      File.join(post.path, "#excerpt")
+    end
+
+    # Check if excerpt includes a string
+    #
+    # Returns true if the string passed in 
+    def include?(something)
+      (self.output && self.output.include?(something)) || self.content.include?(something)
+    end
+
+    # The UID for this post (useful in feeds).
+    # e.g. /2008/11/05/my-awesome-post
+    #
+    # Returns the String UID.
+    def id
+      File.join(post.dir, post.slug, "#excerpt")
+    end
+
+    def to_s
+      self.output || self.content
+    end
+
+    # Returns the shorthand String identifier of this Post.
+    def inspect
+      "<Excerpt: #{self.id}>"
+    end
+
+    protected
+
+    # Internal: Extract excerpt from the content
+    #
+    # By default excerpt is your first paragraph of a post: everything before
+    # the first two new lines:
+    #
+    #     ---
+    #     title: Example
+    #     ---
+    #
+    #     First paragraph with [link][1].
+    #
+    #     Second paragraph.
+    #
+    #     [1]: http://example.com/
+    #
+    # This is fairly good option for Markdown and Textile files. But might cause
+    # problems for HTML posts (which is quite unusual for Jekyll). If default
+    # excerpt delimiter is not good for you, you might want to set your own via
+    # configuration option `excerpt_separator`. For example, following is a good
+    # alternative for HTML posts:
+    #
+    #     # file: _config.yml
+    #     excerpt_separator: "<!-- more -->"
+    #
+    # Notice that all markdown-style link references will be appended to the
+    # excerpt. So the example post above will have this excerpt source:
+    #
+    #     First paragraph with [link][1].
+    #
+    #     [1]: http://example.com/
+    #
+    # Excerpts are rendered same time as content is rendered.
+    #
+    # Returns excerpt String
+    def extract_excerpt(post_content)
+      separator     = site.config['excerpt_separator']
+      head, _, tail = post_content.partition(separator)
+
+      "" << head << "\n\n" << tail.scan(/^\[[^\]]+\]:.+$/).join("\n")
+    end
+  end
+end

data/lib/jekyll/generators/pagination.rb

@@ -10,8 +10,13 @@ module Jekyll
       #
       # Returns nothing.
       def generate(site)
-        site.pages.dup.each do |page|
-          paginate(site, page) if Pager.pagination_enabled?(site.config, page)
+        if Pager.pagination_enabled?(site)
+          if template = template_page(site)
+            paginate(site, template)
+          else
+            Jekyll.logger.warn "Pagination:", "Pagination is enabled, but I couldn't find" +
+            "an index.html page to use as the pagination template. Skipping pagination."
+          end
         end
       end
 
@@ -33,11 +38,11 @@ module Jekyll
         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)
+          pager = Pager.new(site, 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, Pager.paginate_path(site.config, num_page))
+            newpage.dir = Pager.paginate_path(site, num_page)
             site.pages << newpage
           else
             page.pager = pager
@@ -45,6 +50,32 @@ module Jekyll
         end
       end
 
+      # Static: Fetch the URL of the template page. Used to determine the
+      #         path to the first pager in the series.
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns the url of the template page
+      def self.first_page_url(site)
+        if page = Pagination.new.template_page(site)
+          page.url
+        else
+          nil
+        end
+      end
+
+      # Public: Find the Jekyll::Page which will act as the pager template
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns the Jekyll::Page which will act as the pager template
+      def template_page(site)
+        site.pages.dup.select do |page|
+          Pager.pagination_candidate?(site.config, page)
+        end.sort do |one, two|
+          two.path.size <=> one.path.size
+        end.first
+      end
     end
   end
 
@@ -62,39 +93,78 @@ module Jekyll
       (all_posts.size.to_f / per_page.to_i).ceil
     end
 
-    # Determine if pagination is enabled for a given file.
+    # Determine if pagination is enabled the site.
     #
-    # config - The configuration Hash.
-    # page   - The Jekyll::Page with which to paginate
+    # site - the Jekyll::Site object
     #
     # Returns true if pagination is enabled, false otherwise.
-    def self.pagination_enabled?(config, page)
-     !config['paginate'].nil? &&
-        page.name == 'index.html' &&
-        subdirectories_identical(config['paginate_path'], page.dir)
+    def self.pagination_enabled?(site)
+     !site.config['paginate'].nil? &&
+       site.pages.size > 0
+    end
+
+    # Static: Determine if a page is a possible candidate to be a template page.
+    #         Page's name must be `index.html` and exist in any of the directories
+    #         between the site source and `paginate_path`.
+    #
+    # config - the site configuration hash
+    # page   - the Jekyll::Page about which we're inquiring
+    #
+    # Returns true if the
+    def self.pagination_candidate?(config, page)
+      page_dir = File.dirname(File.expand_path(remove_leading_slash(page.path), config['source']))
+      paginate_path = remove_leading_slash(config['paginate_path'])
+      paginate_path = File.expand_path(paginate_path, config['source'])
+      page.name == 'index.html' &&
+        in_hierarchy(config['source'], page_dir, File.dirname(paginate_path))
     end
 
     # Determine if the subdirectories of the two paths are the same relative to source
     #
-    # paginate_path - the paginate_path configuration setting
+    # source        - the site source
     # page_dir      - the directory of the Jekyll::Page
+    # paginate_path - the absolute paginate path (from root of FS)
     #
     # Returns whether the subdirectories are the same relative to source
-    def self.subdirectories_identical(paginate_path, page_dir)
-      File.dirname(paginate_path).gsub(/\A\./, '') == page_dir.gsub(/\/\z/, '')
+    def self.in_hierarchy(source, page_dir, paginate_path)
+      return false if paginate_path == File.dirname(paginate_path)
+      return false if paginate_path == Pathname.new(source).parent
+      page_dir == paginate_path ||
+        in_hierarchy(source, page_dir, File.dirname(paginate_path))
     end
 
     # Static: Return the pagination path of the page
     #
-    # site_config - the site config
+    # site     - the Jekyll::Site object
     # num_page - the pagination page number
     #
     # Returns the pagination path as a string
-    def self.paginate_path(site_config, num_page)
-      return nil if num_page.nil? || num_page <= 1
-      format = site_config['paginate_path']
+    def self.paginate_path(site, num_page)
+      return nil if num_page.nil?
+      return Generators::Pagination.first_page_url(site) if num_page <= 1
+      format = site.config['paginate_path']
       format = format.sub(':num', num_page.to_s)
-      File.basename(format)
+      ensure_leading_slash(format)
+    end
+
+    # Static: Return a String version of the input which has a leading slash.
+    #         If the input already has a forward slash in position zero, it will be
+    #         returned unchanged.
+    #
+    # path - a String path
+    #
+    # Returns the path with a leading slash
+    def self.ensure_leading_slash(path)
+      path[0..0] == "/" ? path : "/#{path}"
+    end
+
+    # Static: Return a String version of the input without a leading slash.
+    #
+    # path - a String path
+    #
+    # Returns the input without the leading slash
+    def self.remove_leading_slash(path)
+      ensure_leading_slash(path)[1..-1]
     end
 
     # Initialize a new Pager.
@@ -104,9 +174,9 @@ module Jekyll
     # all_posts - The Array of all the site's Posts.
     # num_pages - The Integer number of pages or nil if you'd like the number
     #             of pages calculated.
-    def initialize(config, page, all_posts, num_pages = nil)
+    def initialize(site, page, all_posts, num_pages = nil)
       @page = page
-      @per_page = config['paginate'].to_i
+      @per_page = site.config['paginate'].to_i
       @total_pages = num_pages || Pager.calculate_pages(all_posts, @per_page)
 
       if @page > @total_pages
@@ -119,9 +189,9 @@ module Jekyll
       @total_posts = all_posts.size
       @posts = all_posts[init..offset]
       @previous_page = @page != 1 ? @page - 1 : nil
-      @previous_page_path = Pager.paginate_path(config, @previous_page)
+      @previous_page_path = Pager.paginate_path(site, @previous_page)
       @next_page = @page != @total_pages ? @page + 1 : nil
-      @next_page_path = Pager.paginate_path(config, @next_page)
+      @next_page_path = Pager.paginate_path(site, @next_page)
     end
 
     # Convert this Pager's data to a Hash suitable for use by Liquid.