octopress 3.0.0.alpha1

data/lib/octopress/generators/sitemap_generator.rb

@@ -0,0 +1,308 @@
+# Sitemap.xml Generator is a Jekyll plugin that generates a sitemap.xml file by
+# traversing all of the available posts and pages.
+#
+# How To Use:
+#   1) Copy source file into your _plugins folder within your Jekyll project.
+#   2) Change modify the url variable in _config.yml to reflect your domain name.
+#   3) Run Jekyll: jekyll build to re-generate your site.
+#
+# Variables:
+#   * Change SITEMAP_FILE_NAME if you want your sitemap to be called something
+#     other than sitemap.xml.
+#   * Change the PAGES_INCLUDE_POSTS list to include any pages that are looping
+#     through your posts (e.g. "index.html", "archive.html", etc.). This will
+#     ensure that right after you make a new post, the last modified date will
+#     be updated to reflect the new post.
+#   * A sitemap.xml should be included in your _site folder.
+#   * If there are any files you don't want included in the sitemap, add them
+#     to the EXCLUDED_FILES list. The name should match the name of the source
+#     file.
+#   * If you want to include the optional changefreq and priority attributes,
+#     simply include custom variables in the YAML Front Matter of that file.
+#     The names of these custom variables are defined below in the
+#     CHANGE_FREQUENCY_CUSTOM_VARIABLE_NAME and PRIORITY_CUSTOM_VARIABLE_NAME
+#     constants.
+#
+# Notes:
+#   * The last modified date is determined by the latest from the following:
+#     system modified date of the page or post, system modified date of
+#     included layout, system modified date of included layout within that
+#     layout, ...
+#
+# Author: Michael Levin
+# Site: http://www.kinnetica.com
+# Distributed Under A Creative Commons License
+#   - http://creativecommons.org/licenses/by/3.0/
+#
+# Modified for Octopress by John W. Long
+#
+require 'colorator'
+require 'rexml/document'
+require 'fileutils'
+
+module Jekyll
+
+  # Change SITEMAP_FILE_NAME if you would like your sitemap file
+  # to be called something else
+  SITEMAP_FILE_NAME = "sitemap.xml"
+
+  # Any files to exclude from being included in the sitemap.xml
+  EXCLUDED_FILES = ["atom.xml", "404.markdown"]
+
+  # Any files that include posts, so that when a new post is added, the last
+  # modified date of these pages should take that into account
+  PAGES_INCLUDE_POSTS = ["index.html"]
+
+  # Custom variable names for changefreq and priority elements
+  # These names are used within the YAML Front Matter of pages or posts
+  # for which you want to include these properties
+  CHANGE_FREQUENCY_CUSTOM_VARIABLE_NAME = "change_frequency"
+  PRIORITY_CUSTOM_VARIABLE_NAME = "priority"
+
+  class Post
+    attr_accessor :name
+
+    def full_path_to_source
+      File.join(@base, @name)
+    end
+
+    def location_on_server
+      "#{site.config['url']}#{url}"
+    end
+  end
+
+  class Page
+    attr_accessor :name
+
+    def full_path_to_source
+      File.join(@base, @dir, @name)
+    end
+
+    def location_on_server
+      location = "#{site.config['url']}#{@dir}#{url}"
+      location.gsub(/index.html$/, "")
+    end
+  end
+
+  class Layout
+    def full_path_to_source
+      File.join(@base, @name)
+    end
+  end
+
+  # Recover from strange exception when starting server without --auto
+  class SitemapFile < StaticFile
+    def write(dest)
+      begin
+        super(dest)
+      rescue
+      end
+
+      true
+    end
+  end
+
+  class SitemapGenerator < Generator
+
+    # Valid values allowed by sitemap.xml spec for change frequencies
+    VALID_CHANGE_FREQUENCY_VALUES = ["always", "hourly", "daily", "weekly",
+      "monthly", "yearly", "never"]
+
+    # Goes through pages and posts and generates sitemap.xml file
+    #
+    # Returns nothing
+    def generate(site)
+      sitemap = REXML::Document.new << REXML::XMLDecl.new("1.0", "UTF-8")
+
+      urlset = REXML::Element.new "urlset"
+      urlset.add_attribute("xmlns",
+        "http://www.sitemaps.org/schemas/sitemap/0.9")
+
+      @last_modified_post_date = fill_posts(site, urlset)
+      fill_pages(site, urlset)
+
+      sitemap.add_element(urlset)
+
+      # File I/O: create sitemap.xml file and write out pretty-printed XML
+      unless File.exists?(site.dest)
+        FileUtils.mkdir_p(site.dest)
+      end
+      file = File.new(File.join(site.dest, SITEMAP_FILE_NAME), "w")
+      formatter = REXML::Formatters::Pretty.new(4)
+      formatter.compact = true
+      formatter.write(sitemap, file)
+      file.close
+
+      # Keep the sitemap.xml file from being cleaned by Jekyll
+      site.static_files << Jekyll::SitemapFile.new(site, site.dest, "/", SITEMAP_FILE_NAME)
+    end
+
+    # Create url elements for all the posts and find the date of the latest one
+    #
+    # Returns last_modified_date of latest post
+    def fill_posts(site, urlset)
+      last_modified_date = nil
+      site.posts.each do |post|
+        if !excluded?(post.name)
+          url = fill_url(site, post)
+          urlset.add_element(url)
+        end
+
+        path = post.full_path_to_source
+        date = File.mtime(path)
+        last_modified_date = date if last_modified_date == nil or date > last_modified_date
+      end
+
+      last_modified_date
+    end
+
+    # Create url elements for all the normal pages and find the date of the
+    # index to use with the pagination pages
+    #
+    # Returns last_modified_date of index page
+    def fill_pages(site, urlset)
+      site.pages.each do |page|
+        if !excluded?(page.name)
+          path = page.full_path_to_source
+          if File.exists?(path)
+            url = fill_url(site, page)
+            urlset.add_element(url)
+          end
+        end
+      end
+    end
+
+    # Fill data of each URL element: location, last modified,
+    # change frequency (optional), and priority.
+    #
+    # Returns url REXML::Element
+    def fill_url(site, page_or_post)
+      url = REXML::Element.new "url"
+
+      loc = fill_location(page_or_post)
+      url.add_element(loc)
+
+      lastmod = fill_last_modified(site, page_or_post)
+      url.add_element(lastmod) if lastmod
+
+      if (page_or_post.data[CHANGE_FREQUENCY_CUSTOM_VARIABLE_NAME])
+        change_frequency =
+          page_or_post.data[CHANGE_FREQUENCY_CUSTOM_VARIABLE_NAME].downcase
+
+        if (valid_change_frequency?(change_frequency))
+          changefreq = REXML::Element.new "changefreq"
+          changefreq.text = change_frequency
+          url.add_element(changefreq)
+        else
+          $stderr.puts "ERROR: Invalid Change Frequency In #{page_or_post.name}".red
+        end
+      end
+
+      if (page_or_post.data[PRIORITY_CUSTOM_VARIABLE_NAME])
+        priority_value = page_or_post.data[PRIORITY_CUSTOM_VARIABLE_NAME]
+        if valid_priority?(priority_value)
+          priority = REXML::Element.new "priority"
+          priority.text = page_or_post.data[PRIORITY_CUSTOM_VARIABLE_NAME]
+          url.add_element(priority)
+        else
+          $stderr.puts "ERROR: Invalid Priority In #{page_or_post.name}".red
+        end
+      end
+
+      url
+    end
+
+    # Get URL location of page or post
+    #
+    # Returns the location of the page or post
+    def fill_location(page_or_post)
+      loc = REXML::Element.new "loc"
+      loc.text = page_or_post.location_on_server
+
+      loc
+    end
+
+    # Fill lastmod XML element with the last modified date for the page or post.
+    #
+    # Returns lastmod REXML::Element or nil
+    def fill_last_modified(site, page_or_post)
+      path = page_or_post.full_path_to_source
+
+      lastmod = REXML::Element.new "lastmod"
+      date = File.mtime(path)
+      latest_date = find_latest_date(date, site, page_or_post)
+
+      if @last_modified_post_date == nil
+        # This is a post
+        lastmod.text = latest_date.iso8601
+      else
+        # This is a page
+        if posts_included?(page_or_post.name)
+          # We want to take into account the last post date
+          final_date = greater_date(latest_date, @last_modified_post_date)
+          lastmod.text = final_date.iso8601
+        else
+          lastmod.text = latest_date.iso8601
+        end
+      end
+      lastmod
+    end
+
+    # Go through the page/post and any implemented layouts and get the latest
+    # modified date
+    #
+    # Returns formatted output of latest date of page/post and any used layouts
+    def find_latest_date(latest_date, site, page_or_post)
+      layouts = site.layouts
+      layout = layouts[page_or_post.data["layout"]]
+      while layout
+        path = layout.full_path_to_source
+        date = File.mtime(path)
+
+        latest_date = date if (date > latest_date)
+
+        layout = layouts[layout.data["layout"]]
+      end
+
+      latest_date
+    end
+
+    # Which of the two dates is later
+    #
+    # Returns latest of two dates
+    def greater_date(date1, date2)
+      [date1, date2].max
+    end
+
+    # Is the page or post listed as something we want to exclude?
+    #
+    # Returns boolean
+    def excluded?(name)
+      EXCLUDED_FILES.include? name
+    end
+
+    def posts_included?(name)
+      PAGES_INCLUDE_POSTS.include? name
+    end
+
+    # Is the change frequency value provided valid according to the spec
+    #
+    # Returns boolean
+    def valid_change_frequency?(change_frequency)
+      VALID_CHANGE_FREQUENCY_VALUES.include? change_frequency
+    end
+
+    # Is the priority value provided valid according to the spec
+    #
+    # Returns boolean
+    def valid_priority?(priority)
+      begin
+        priority_val = Float(priority)
+        return true if priority_val >= 0.0 and priority_val <= 1.0
+      rescue ArgumentError
+      end
+
+      false
+    end
+  end
+end

data/lib/octopress/guardfile

@@ -0,0 +1,43 @@
+$:.unshift File.expand_path("../", File.dirname(__FILE__))
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+require 'octopress'
+require 'guard/jekyll'
+
+stylesheets_dir    = "stylesheets"
+javascripts_dir    = "javascripts"
+
+configurator   = Octopress::Configuration.new
+configuration  = configurator.read_configuration
+js_assets      = Octopress::JSAssetsManager.new if Dir.exists? javascripts_dir
+
+if Dir.exists? stylesheets_dir
+  guard :compass do
+    watch %r{^#{stylesheets_dir}/(.*)\.s[ac]ss$}
+  end
+end
+
+guard :jekyll do
+  # If a template file changes, trigger a Jekyll build
+  watch /^#{configuration[:source]}\/.+\.(md|markdown|textile|html|haml|slim|xml)/
+end
+
+guard :shell do
+  # If a non template file changes, copy it to destination
+  watch /^#{configuration[:source]}\/.+\.[^(md|markdown|textile|html|haml|slim|xml)]/ do |m|
+    if File.exists?(m.first)
+      file = File.basename(m.first)
+      path = m.first.sub /^#{configuration[:source]}/, "#{configuration[:destination]}"
+      FileUtils.mkdir_p path.sub /#{file}/,''
+      FileUtils.cp m.first, path
+      "Copied #{m.first} -> #{path}"
+    end
+  end
+
+  if Dir.exists? javascripts_dir
+    watch /^#{javascripts_dir}\/.+\.(js|coffee|mustache|eco|tmpl)/ do |change|
+      puts js_assets.compile
+    end
+  end
+end

data/lib/octopress/helpers/titlecase.rb

@@ -0,0 +1,37 @@
+class String
+  def titlecase
+    small_words = %w(a an and as at but by en for if in of on or the to v v. via vs vs.)
+
+    x = split(" ").map do |word|
+      # note: word could contain non-word characters!
+      # downcase all small_words, capitalize the rest
+      small_words.include?(word.gsub(/\W/, "").downcase) ? word.downcase! : word.smart_capitalize!
+      word
+    end
+    # capitalize first and last words
+    x.first.to_s.smart_capitalize!
+    x.last.to_s.smart_capitalize!
+    # small words are capitalized after colon, period, exclamation mark, question mark
+    x.join(" ").gsub(/(:|\.|!|\?)\s?(\W*#{small_words.join("|")}\W*)\s/) { "#{$1} #{$2.smart_capitalize} " }
+  end
+
+  def titlecase!
+    replace(titlecase)
+  end
+
+  def smart_capitalize
+    # ignore any leading crazy characters and capitalize the first real character
+    if self =~ /^['"\(\[']*([a-z])/
+      i = index($1)
+      x = self[i,self.length]
+      # word with capitals and periods mid-word are left alone
+      self[i,1] = self[i,1].upcase unless x =~ /[A-Z]/ or x =~ /\.\w+/
+    end
+    self
+  end
+
+  def smart_capitalize!
+    replace(smart_capitalize)
+  end
+end
+

data/lib/octopress/ink.rb

@@ -0,0 +1,12 @@
+require 'logger'
+
+module Octopress
+  class Ink < Logger
+    def self.build
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::INFO
+      logger.formatter = Formatters::BaseFormatter.new
+      logger
+    end
+  end
+end

data/lib/octopress/inquirable_string.rb

@@ -0,0 +1,12 @@
+module Octopress
+  class InquirableString < String
+    def method_missing(name, *args, &block)
+      if(name =~ /^.*\?$/)
+        val = name.to_s.sub(/\?$/, '')
+        return self == val
+      else
+        super
+      end
+    end
+  end
+end

data/lib/octopress/installer.rb

@@ -0,0 +1,92 @@
+module Octopress
+  class Installer
+
+    OCTO_DIRS = {
+      "configs"  => "config",
+      "includes" => "source/_includes",
+      "layouts"  => "source/_layouts",
+      "javascripts/lib"     => "javascripts/lib",
+      "javascripts/modules" => "javascripts/modules",
+      "source"      => "source",
+      "stylesheets" => "stylesheets",
+      "plugins"     => "plugins"
+    }
+
+    def initalize(plugin_name)
+      begin
+        require "#{plugin_name}"
+      rescue LoadError
+        Octopress.logger.error "We can't load the plugin '#{plugin_name}'. Please add it" +
+                               " to your Gemfile and run 'bundle install' and try" +
+                               " installing the plugin again."
+        raise LoadError
+      end
+
+      @plugin_name  = plugin_name
+      @class_name   = plugin_name.gsub(/-_\ /, "_").split("_").map(&:capitalize).join("")
+      @plugin_class = Object.const_get(@class_name)
+      @verbose      = Octopress.logger.level == Logger::DEBUG
+    end
+
+    def type
+      manifest_yml.fetch('type') || "plugin"
+    end
+
+    def theme?
+      type == "theme"
+    end
+
+    def plugin?
+      type == "plugin"
+    end
+
+    def plugin_slug
+      plugin? ? manifest_yml.fetch('slug') : "theme"
+    end
+
+    ####################
+    # Fetchers
+    ####################
+
+    def namespace?(subdir)
+      plugin? && !%w[javascripts/lib source].include?(subdir)
+    end
+
+    def source(*subdirs)
+      File.join(@plugin_class.root, *subdirs, ".")
+    end
+
+    def local(subdir)
+      dir = File.join(Octopress.root, subdir)
+      dir = File.join(dir, "plugins") if subdir == "stylesheets" && plugin?
+      dir = File.join(dir, "theme") if subdir == "stylesheets" && theme?
+      dir = File.join(dir, plugin_slug) if namespace?
+      dir
+    end
+
+    ###################
+    # Installers
+    ###################
+
+    def install
+      OCTO_DIRS.each do |source_dir, local_dir|
+        install(source_dir, local_dir)
+      end
+    end
+
+    def install(source_dir, local_dir)
+      FileUtils.mkdir_p local(local_dir), verbose: @verbose
+      FileUtils.cp_r source(source_dir), local(local_dir), verbose: @verbose
+    end
+
+    private
+    def manifest_yml
+      @manifest ||= YAML.safe_load_file(File.join(@plugin_class.root, "MANIFEST.yml"))
+    rescue Errno::ENOENT
+      Octopress.logger.error "The plugin '#{@plugin_name}' doesn't seem to have a " +
+        "MANIFEST.yml file and thus isn't a valid Octopress plugin."
+      raise StandardError
+    end
+
+  end
+end