nanoc2 2.2.3

data/lib/nanoc2/extra/vcses.rb

@@ -0,0 +1,5 @@
+require 'nanoc2/extra/vcses/bazaar'
+require 'nanoc2/extra/vcses/dummy'
+require 'nanoc2/extra/vcses/git'
+require 'nanoc2/extra/vcses/mercurial'
+require 'nanoc2/extra/vcses/subversion'

data/lib/nanoc2/extra/vcses/bazaar.rb

@@ -0,0 +1,21 @@
+module Nanoc2::Extra::VCSes
+
+  class Bazaar < Nanoc2::Extra::VCS
+
+    identifiers :bazaar, :bzr
+
+    def add(filename)
+      system('bzr', 'add', filename)
+    end
+
+    def remove(filename)
+      system('bzr', 'rm', filename)
+    end
+
+    def move(src, dst)
+      system('bzr', 'mv', src, dst)
+    end
+
+  end
+
+end

data/lib/nanoc2/extra/vcses/dummy.rb

@@ -0,0 +1,20 @@
+module Nanoc2::Extra::VCSes
+
+  class Dummy < Nanoc2::Extra::VCS
+
+    identifiers :dummy
+
+    def add(filename)
+    end
+
+    def remove(filename)
+      FileUtils.rm_rf(filename)
+    end
+
+    def move(src, dst)
+      FileUtils.move(src, dst)
+    end
+
+  end
+
+end

data/lib/nanoc2/extra/vcses/git.rb

@@ -0,0 +1,21 @@
+module Nanoc2::Extra::VCSes
+
+  class Git < Nanoc2::Extra::VCS
+
+    identifiers :git
+
+    def add(filename)
+      system('git', 'add', filename)
+    end
+
+    def remove(filename)
+      system('git', 'rm', filename)
+    end
+
+    def move(src, dst)
+      system('git', 'mv', src, dst)
+    end
+
+  end
+
+end

data/lib/nanoc2/extra/vcses/mercurial.rb

@@ -0,0 +1,21 @@
+module Nanoc2::Extra::VCSes
+
+  class Mercurial < Nanoc2::Extra::VCS
+
+    identifiers :mercurial, :hg
+
+    def add(filename)
+      system('hg', 'add', filename)
+    end
+
+    def remove(filename)
+      system('hg', 'rm', filename)
+    end
+
+    def move(src, dst)
+      system('hg', 'mv', src, dst)
+    end
+
+  end
+
+end

data/lib/nanoc2/extra/vcses/subversion.rb

@@ -0,0 +1,21 @@
+module Nanoc2::Extra::VCSes
+
+  class Subversion < Nanoc2::Extra::VCS
+
+    identifiers :subversion, :svn
+
+    def add(filename)
+      system('svn', 'add', filename)
+    end
+
+    def remove(filename)
+      system('svn', 'rm', filename)
+    end
+
+    def move(src, dst)
+      system('svn', 'mv', src, dst)
+    end
+
+  end
+
+end

data/lib/nanoc2/filters.rb

@@ -0,0 +1,16 @@
+require 'nanoc2/filters/bluecloth'
+require 'nanoc2/filters/erb'
+require 'nanoc2/filters/erubis'
+require 'nanoc2/filters/haml'
+require 'nanoc2/filters/markaby'
+require 'nanoc2/filters/maruku'
+require 'nanoc2/filters/old'
+require 'nanoc2/filters/rainpress'
+require 'nanoc2/filters/rdiscount'
+require 'nanoc2/filters/rdoc'
+require 'nanoc2/filters/redcloth'
+require 'nanoc2/filters/relativize_paths'
+require 'nanoc2/filters/relativize_paths_in_css'
+require 'nanoc2/filters/relativize_paths_in_html'
+require 'nanoc2/filters/rubypants'
+require 'nanoc2/filters/sass'

data/lib/nanoc2/filters/bluecloth.rb

@@ -0,0 +1,13 @@
+module Nanoc2::Filters
+  class BlueCloth < Nanoc2::Filter
+
+    identifiers :bluecloth
+
+    def run(content)
+      require 'bluecloth'
+
+      ::BlueCloth.new(content).to_html
+    end
+
+  end
+end

data/lib/nanoc2/filters/erb.rb

@@ -0,0 +1,19 @@
+module Nanoc2::Filters
+  class ERB < Nanoc2::Filter
+
+    identifiers :erb
+
+    def run(content)
+      require 'erb'
+
+      # Create context
+      context = ::Nanoc2::Extra::Context.new(assigns)
+
+      # Get result
+      erb = ::ERB.new(content)
+      erb.filename = filename
+      erb.result(context.get_binding)
+    end
+
+  end
+end

data/lib/nanoc2/filters/erubis.rb

@@ -0,0 +1,14 @@
+module Nanoc2::Filters
+  class Erubis < Nanoc2::Filter
+
+    identifiers :erubis
+
+    def run(content)
+      require 'erubis'
+
+      # Get result
+      ::Erubis::Eruby.new(content).evaluate(assigns)
+    end
+
+  end
+end

data/lib/nanoc2/filters/haml.rb

@@ -0,0 +1,21 @@
+module Nanoc2::Filters
+  class Haml < Nanoc2::Filter
+
+    identifiers :haml
+
+    def run(content)
+      require 'haml'
+
+      # Get options
+      options = @obj_rep.attribute_named(:haml_options) || {}
+      options[:filename] = filename
+
+      # Create context
+      context = ::Nanoc2::Extra::Context.new(assigns)
+
+      # Get result
+      ::Haml::Engine.new(content, options).render(context, assigns)
+    end
+
+  end
+end

data/lib/nanoc2/filters/markaby.rb

@@ -0,0 +1,14 @@
+module Nanoc2::Filters
+  class Markaby < Nanoc2::Filter
+
+    identifiers :markaby
+
+    def run(content)
+      require 'markaby'
+
+      # Get result
+      ::Markaby::Builder.new(assigns).instance_eval(content).to_s
+    end
+
+  end
+end

data/lib/nanoc2/filters/maruku.rb

@@ -0,0 +1,14 @@
+module Nanoc2::Filters
+  class Maruku < Nanoc2::Filter
+
+    identifiers :maruku
+
+    def run(content)
+      require 'maruku'
+
+      # Get result
+      ::Maruku.new(content).to_html
+    end
+
+  end
+end

data/lib/nanoc2/filters/old.rb

@@ -0,0 +1,19 @@
+module Nanoc2::Filters
+  class Old < Nanoc2::Filter
+
+    identifiers :eruby, :markdown, :smartypants, :textile
+
+    def run(content)
+      raise Nanoc2::Error.new(
+        "The 'eruby', markdown', 'smartypants' and 'textile' filters no " +
+        "longer exist. Instead, use the following filters:\n" +
+        "\n" +
+        "* for Markdown:      bluecloth, rdiscount, redcloth\n" +
+        "* for Textile:       redcloth\n" +
+        "* for embedded Ruby: erb, erubis\n" +
+        "* for Smartypants:   rubypants"
+      )
+    end
+
+  end
+end

data/lib/nanoc2/filters/rainpress.rb

@@ -0,0 +1,13 @@
+module Nanoc2::Filters
+  class Rainpress < Nanoc2::Filter
+
+    identifier :rainpress
+
+    def run(content)
+      require 'rainpress'
+
+      ::Rainpress.compress(content)
+    end
+
+  end
+end

data/lib/nanoc2/filters/rdiscount.rb

@@ -0,0 +1,13 @@
+module Nanoc2::Filters
+  class RDiscount < Nanoc2::Filter
+
+    identifiers :rdiscount
+
+    def run(content)
+      require 'rdiscount'
+
+      ::RDiscount.new(content).to_html
+    end
+
+  end
+end

data/lib/nanoc2/filters/rdoc.rb

@@ -0,0 +1,23 @@
+module Nanoc2::Filters
+  class RDoc < Nanoc2::Filter
+
+    identifiers :rdoc
+
+    def run(content)
+      begin
+        # new RDoc
+        require 'rdoc/markup'
+        require 'rdoc/markup/to_html'
+        
+        ::RDoc::Markup.new.convert(content, ::RDoc::Markup::ToHtml.new)
+      rescue LoadError
+        # old RDoc
+        require 'rdoc/markup/simple_markup'
+        require 'rdoc/markup/simple_markup/to_html'
+
+        ::SM::SimpleMarkup.new.convert(content, ::SM::ToHtml.new)
+      end
+    end
+
+  end
+end

data/lib/nanoc2/filters/redcloth.rb

@@ -0,0 +1,14 @@
+module Nanoc2::Filters
+  class RedCloth < Nanoc2::Filter
+
+    identifiers :redcloth
+
+    def run(content)
+      require 'redcloth'
+
+      # Get result
+      ::RedCloth.new(content).to_html
+    end
+
+  end
+end

data/lib/nanoc2/filters/relativize_paths.rb

@@ -0,0 +1,16 @@
+module Nanoc2::Filters
+  class RelativizePaths < Nanoc2::Filter
+
+    identifier :relativize_paths
+
+    def run(content)
+      raise RuntimeError.new(
+        "The relativize_paths filter itself does not exist anymore. " +
+        "If you want to relativize paths in HTML, use the " +
+        "relativize_paths_in_html filter; if you want to relativize paths " +
+        "in CSS, use the relativize_paths_in_css filter."
+      )
+    end
+
+  end
+end

data/lib/nanoc2/filters/relativize_paths_in_css.rb

@@ -0,0 +1,16 @@
+module Nanoc2::Filters
+  class RelativizePathsInCSS < Nanoc2::Filter
+
+    identifier :relativize_paths_in_css
+
+    require 'nanoc2/helpers/link_to'
+    include Nanoc2::Helpers::LinkTo
+
+    def run(content)
+      content.gsub(/url\((['"]?)(\/.+?)\1\)/) do
+        'url(' + $1 + relative_path_to($2) + $1 + ')'
+      end
+    end
+
+  end
+end

data/lib/nanoc2/filters/relativize_paths_in_html.rb

@@ -0,0 +1,16 @@
+module Nanoc2::Filters
+  class RelativizePathsInHTML < Nanoc2::Filter
+
+    identifier :relativize_paths_in_html
+
+    require 'nanoc2/helpers/link_to'
+    include Nanoc2::Helpers::LinkTo
+
+    def run(content)
+      content.gsub(/(src|href)=(['"]?)(\/.+?)\2([ >])/) do
+        $1 + '=' + $2 + relative_path_to($3) + $2 + $4
+      end
+    end
+
+  end
+end

data/lib/nanoc2/filters/rubypants.rb

@@ -0,0 +1,14 @@
+module Nanoc2::Filters
+  class SmartyPants < Nanoc2::Filter
+
+    identifiers :rubypants
+
+    def run(content)
+      require 'rubypants'
+
+      # Get result
+      ::RubyPants.new(content).to_html
+    end
+
+  end
+end

data/lib/nanoc2/filters/sass.rb

@@ -0,0 +1,18 @@
+module Nanoc2::Filters
+  class Sass < Nanoc2::Filter
+
+    identifiers :sass
+
+    def run(content)
+      require 'sass'
+
+      # Get options
+      options = @obj_rep.attribute_named(:sass_options) || {}
+      options[:filename] = filename
+
+      # Get result
+      ::Sass::Engine.new(content, options).render
+    end
+
+  end
+end

data/lib/nanoc2/helpers.rb

@@ -0,0 +1,9 @@
+require 'nanoc2/helpers/blogging'
+require 'nanoc2/helpers/capturing'
+require 'nanoc2/helpers/filtering'
+require 'nanoc2/helpers/html_escape'
+require 'nanoc2/helpers/link_to'
+require 'nanoc2/helpers/render'
+require 'nanoc2/helpers/tagging'
+require 'nanoc2/helpers/text'
+require 'nanoc2/helpers/xml_sitemap'

data/lib/nanoc2/helpers/blogging.rb

@@ -0,0 +1,217 @@
+module Nanoc2::Helpers
+
+  # Nanoc2::Helpers::Blogging provides some functionality for building blogs,
+  # such as finding articles and constructing feeds.
+  #
+  # This helper has a few requirements. First, all blog articles should have
+  # the following attributes:
+  #
+  # * 'kind', set to 'article'.
+  #
+  # * 'created_at', set to the creation timestamp.
+  #
+  # Some functions in this blogging helper, such as the +atom_feed+ function,
+  # require additional attributes to be set; these attributes are described in
+  # the documentation for these functions.
+  #
+  # The two main functions are sorted_articles and atom_feed.
+  #
+  # To activate this helper, +include+ it, like this:
+  #
+  #   include Nanoc2::Helpers::Blogging
+  module Blogging
+
+    # Returns an unsorted list of articles.
+    def articles
+      @pages.select { |page| page.kind == 'article' }
+    end
+
+    # Returns a list of articles, sorted by descending creation date (so newer
+    # articles appear first).
+    def sorted_articles
+      articles.sort_by { |a| a.created_at }.reverse
+    end
+
+    # Returns a string representing the atom feed containing recent articles,
+    # sorted by descending creation date. +params+ is a hash where the
+    # following keys can be set:
+    #
+    # +limit+:: The maximum number of articles to show. Defaults to 5.
+    #
+    # +articles+:: A list of articles to include in the feed. Defaults to the
+    #              list of articles returned by the articles function.
+    #
+    # +content_proc+:: A proc that returns the content of the given article,
+    #                  passed as a parameter. By default, given the argument
+    #                  +article+, this proc will return +article.content+.
+    #                  This function may not return nil.
+    #
+    # +excerpt_proc+:: A proc that returns the excerpt of the given article,
+    #                  passed as a parameter. By default, given the argument
+    #                  +article+, this proc will return +article.excerpt+.
+    #                  This function may return nil.
+    #
+    # The following attributes must be set on blog articles:
+    #
+    # * 'title', containing the title of the blog post.
+    #
+    # * all other attributes mentioned above.
+    #
+    # The following attributes can optionally be set on blog articles to
+    # change the behaviour of the Atom feed:
+    #
+    # * 'excerpt', containing an excerpt of the article, usually only a few
+    #   lines long.
+    #
+    # * 'custom_path_in_feed', containing the path that will be used instead
+    #   of the normal path in the feed. This can be useful when including
+    #   non-outputted pages in a feed; such pages could have their custom feed
+    #   path set to the blog path instead, for example.
+    #
+    # The feed will also include dates on which the articles were updated.
+    # These are generated automatically; the way this happens depends on the
+    # used data source (the filesystem data source checks the file mtimes, for
+    # instance).
+    #
+    # The feed page will need to have the following attributes:
+    #
+    # * 'base_url', containing the URL to the site, without trailing slash.
+    #   For example, if the site is at "http://example.com/", the base_url
+    #   would be "http://example.com". It is probably a good idea to define
+    #   this in the page defaults, i.e. the 'meta.yaml' file (at least if the
+    #   filesystem data source is being used, which is probably the case).
+    #
+    # * 'title', containing the title of the feed, which is usually also the
+    #   title of the blog.
+    #
+    # * 'author_name', containing the name of the page's author. This will
+    #   likely be a global attribute, unless the site is managed by several
+    #   people/
+    #
+    # * 'author_uri', containing the URI for the page's author, such as the
+    #   author's web site URL. This will also likely be a global attribute.
+    #
+    # The feed page can have the following optional attributes:
+    #
+    # * 'feed_url', containing the custom URL of the feed. This can be useful
+    #   when the private feed URL shouldn't be exposed; for example, when
+    #   using FeedBurner this would be set to the public FeedBurner URL.
+    #
+    # To construct a feed, create a blank page with no layout, only the 'erb'
+    # (or 'erubis') filter, and an 'xml' extension. It may also be useful to
+    # set 'is_hidden' to true, so that helpers such as the sitemap helper will
+    # ignore the page. The content of the feed page should be:
+    #
+    #   <%= atom_feed %>
+    def atom_feed(params={})
+      require 'builder'
+
+      # Extract parameters
+      limit             = params[:limit] || 5
+      relevant_articles = params[:articles] || articles || []
+      content_proc      = params[:content_proc] || lambda { |a| a.content }
+      excerpt_proc      = params[:excerpt_proc] || lambda { |a| a.excerpt }
+
+      # Check feed page attributes
+      if @page.base_url.nil?
+        raise RuntimeError.new('Cannot build Atom feed: feed page has no base_url')
+      end
+      if @page.title.nil?
+        raise RuntimeError.new('Cannot build Atom feed: feed page has no title')
+      end
+      if @page.author_name.nil?
+        raise RuntimeError.new('Cannot build Atom feed: feed page has no author_name')
+      end
+      if @page.author_uri.nil?
+        raise RuntimeError.new('Cannot build Atom feed: feed page has no author_uri')
+      end
+
+      # Check article attributes
+      if relevant_articles.empty?
+        raise RuntimeError.new('Cannot build Atom feed: no articles')
+      end
+      if relevant_articles.any? { |a| a.created_at.nil? }
+        raise RuntimeError.new('Cannot build Atom feed: one or more articles lack created_at')
+      end
+
+      # Get sorted relevant articles
+      sorted_relevant_articles = relevant_articles.sort_by { |a| a.created_at }.reverse.first(limit)
+
+      # Get most recent article
+      last_article = sorted_relevant_articles.first
+
+      # Create builder
+      buffer = ''
+      xml = Builder::XmlMarkup.new(:target => buffer, :indent => 2)
+
+      # Build feed
+      xml.instruct!
+      xml.feed(:xmlns => 'http://www.w3.org/2005/Atom') do
+        # Add primary attributes
+        xml.id      @page.base_url + '/'
+        xml.title   @page.title
+
+        # Add date
+        xml.updated last_article.created_at.to_iso8601_time
+
+        # Add links
+        xml.link(:rel => 'alternate', :href => @page.base_url)
+        xml.link(:rel => 'self',      :href => feed_url)
+
+        # Add author information
+        xml.author do
+          xml.name  @page.author_name
+          xml.uri   @page.author_uri
+        end
+
+        # Add articles
+        sorted_relevant_articles.each do |a|
+          xml.entry do
+            # Add primary attributes
+            xml.id        atom_tag_for(a)
+            xml.title     a.title, :type => 'html'
+
+            # Add dates
+            xml.published a.created_at.to_iso8601_time
+            xml.updated   a.mtime.to_iso8601_time
+
+            # Add link
+            xml.link(:rel => 'alternate', :href => url_for(a))
+
+            # Add content
+            summary = excerpt_proc.call(a)
+            xml.content   content_proc.call(a), :type => 'html'
+            xml.summary   summary, :type => 'html' unless summary.nil?
+          end
+        end
+      end
+
+      buffer
+    end
+
+    # Returns the URL for the given page. It will return the URL containing
+    # the custom path in the feed if possible, otherwise the normal path.
+    def url_for(page)
+      @page.base_url + (page.custom_path_in_feed || page.path)
+    end
+
+    # Returns the URL of the feed. It will return the custom feed URL if set,
+    # or otherwise the normal feed URL.
+    def feed_url
+      @page[:feed_url] || @page.base_url + @page.path
+    end
+
+    # Returns an URI containing an unique ID for the given page. This will be
+    # used in the Atom feed to uniquely identify articles. These IDs are
+    # created using a procedure suggested by Mark Pilgrim in this blog post:
+    # http://diveintomark.org/archives/2004/05/28/howto-atom-id.
+    def atom_tag_for(page)
+      hostname        = @page.base_url.sub(/.*:\/\/(.+?)\/?$/, '\1')
+      formatted_date  = page.created_at.to_iso8601_date
+
+      'tag:' + hostname + ',' + formatted_date + ':' + page.path
+    end
+
+  end
+
+end