nanoc-toolbox 0.0.7 → 0.1.0

data/lib/nanoc/toolbox/helpers/navigation.rb

@@ -1,6 +1,6 @@
 require 'nanoc/toolbox/helpers/html_tag'
 
-module Nanoc::Toolbox::Helpers  
+module Nanoc::Toolbox::Helpers
   # NANOC Helper for the Navigation related stuff.
   #
   # This module contains functions for generating navigation menus for your
@@ -8,7 +8,7 @@ module Nanoc::Toolbox::Helpers
   #
   # @author Anouar ADLANI <anouar@adlani.com>
   module Navigation
-    include Nanoc3::Helpers::LinkTo
+    include Nanoc::Helpers::LinkTo
     include Nanoc::Toolbox::Helpers::HtmlTag
 
     # Generate a navigation menu for a given item.
@@ -34,39 +34,38 @@ module Nanoc::Toolbox::Helpers
       render_menu(sections, options)
     end
 
-
     # Generate a Table of Content for a given item. The toc will be generated
     # form the item content. The parsing is done with Nokogiri through XPath.
     #
-    # @param  [String]  item_rep - the representation of desired item
+    # @param  [Nanoc::ItemRep]  item_rep - the representation of desired item
     # @param  [Hash]    options - The Optional parameters
     # @option options (see #render_menu)
     # @option options [String] :path ('div[@class="section"]') Generic XPath for the sections
-    # 
+    #
     # @return [String] The output ready to be displayed by the caller
     #
     # @see http://nokogiri.org/
     def toc_for(item_rep, options={})
       require 'nokogiri'
+      item_rep = item_rep.rep_named(:default) if item_rep.is_a? Nanoc::Item
 
-      # Parse options or set to default values
       options[:path]             ||= 'div[@class="section"]'
 
       # Retreive the parsed content and init nokogiri
       compiled_content = item_rep.instance_eval { @content[:pre] }
       doc = Nokogiri::HTML(compiled_content)
       doc_root = doc.xpath('/html/body').first
+      return "" if doc_root.nil?
 
       # Find all sections, and render them
       sections = find_toc_sections(doc_root, options[:path])
-      render_menu(sections, options)
+      render_menu(sections, options) || ""
     end
 
-
     # Generate a Breadcrumb for a given item. The breadcrumbs, is starting with
     # the root item and ending with the item itself.
     #
-    # Requires the Helper: Nanoc3::Helpers::Breadcrumbs
+    # Requires the Helper: Nanoc::Helpers::Breadcrumbs
     #
     # @param  [String]  identifier - the identifier string of element
     # @param  [Hash]    options - The Optional parameters
@@ -74,12 +73,11 @@ module Nanoc::Toolbox::Helpers
     #
     # @return [String] The output ready to be displayed by the caller
     #
-    # @see Nanoc3::Helpers::Breadcrumbs#breadcrumbs_for_identifier
+    # @see Nanoc::Helpers::Breadcrumbs#breadcrumbs_for_identifier
     def breadcrumb_for(identifier, options={})
-
-      # Parse options or set to default values
       options[:collection_tag]   ||= 'ul'
-      
+      options[:collection_class] ||= 'breadcrumb'
+
       # Retreive the breadcrumbs trail and format them
       sections = find_breadcrumbs_trail(identifier)
       render_menu(sections, options)
@@ -118,24 +116,22 @@ module Nanoc::Toolbox::Helpers
     #
     # @return [String] The output ready to be displayed by the caller
     def render_menu(items, options={})
-
-      # Parse options or set to default values
       options[:depth]            ||= 3
       options[:collection_tag]   ||= 'ol'
+      options[:collection_class] ||= 'menu'
       options[:item_tag]         ||= 'li'
       options[:title_tag]        ||= 'h2'
       options[:title]            ||= nil
-      
+
       # Parse the title and remove it from the options
       title =  options[:title] ? content_tag(options[:title_tag], options[:title]) : ''
-      options.delete(:title_tag) 
-      options.delete(:title) 
-      
+      options.delete(:title_tag)
+      options.delete(:title)
+
       # Decrease the depth level
       options[:depth] -= 1
 
       rendered_menu = items.map do |item|
-
         # Render only if there is depth left
         if options[:depth].to_i  > 0 && item[:subsections]
           output = render_menu(item[:subsections], options)
@@ -146,60 +142,58 @@ module Nanoc::Toolbox::Helpers
 
       end.join()
 
-      
-      title + content_tag(options[:collection_tag], rendered_menu) unless rendered_menu.strip.empty?
+      title + content_tag(options[:collection_tag], rendered_menu, :class => options[:collection_class]) unless rendered_menu.strip.empty?
     end
 
-    private
-
-      # Recursive method that extract from an XPath pattern the document structure
-      # and return the "permalinks" to each sections in an Array of Hash that
-      # could be used by the rendering method. The structure is deducted by the
-      # H1-6 header within the html element defined by the XPATH
-      def find_toc_sections(section, section_xpath, title_level=1)
-        return {} unless section.xpath(section_xpath)
-
-        # For each section found call the find_toc_sections on it with an
-        # increased header level (ex: h1 => h2) and then generate the hash res
-        sections = section.xpath(section_xpath).map do |subsection|
-          header = subsection.css("h1, h2, h3, h4, h5, h6").first
-          sub_id = subsection['id']
-          sub_title = header ? header.inner_html : 'untitled'
-          subsections = {}
-
-          if subsection.xpath("#{section_xpath}") && title_level <= 6
-            subsections = find_toc_sections(subsection, "#{section_xpath}", title_level+1)
-          end
-          { :title => sub_title, :link => '#' + sub_id, :subsections =>  subsections }
+  private
+
+    # Recursive method that extract from an XPath pattern the document structure
+    # and return the "permalinks" to each sections in an Array of Hash that
+    # could be used by the rendering method. The structure is deducted by the
+    # H1-6 header within the html element defined by the XPATH
+    def find_toc_sections(section, section_xpath, title_level=1)
+      return {} unless section.xpath(section_xpath)
+
+      # For each section found call the find_toc_sections on it with an
+      # increased header level (ex: h1 => h2) and then generate the hash res
+      sections = section.xpath(section_xpath).map do |subsection|
+        header = subsection.css("h1, h2, h3, h4, h5, h6").first
+        sub_id = subsection['id']
+        sub_title = header ? header.inner_html : 'untitled'
+        subsections = {}
+
+        if subsection.xpath("#{section_xpath}") && title_level <= 6
+          subsections = find_toc_sections(subsection, "#{section_xpath}", title_level+1)
         end
+        { :title => sub_title, :link => '#' + sub_id, :subsections =>  subsections }
       end
+    end
 
-      # Recursive method that extract from an XPath pattern the document structure
-      # and return the "permalinks" in a Array of Hash that could be used by the
-      # rendering method
-      def find_item_tree(root, options={})
-        return nil unless root.children
-        
-        # filter the elements to contain only the kind requested
-        children = options[:kind] ? root.children.select { |item| item[:kind] == options[:kind] } : root.children
-        
-        # For each child call the find_item_tree on it and then generate the hash
-        sections = children.map do |child|
-          subsections = find_item_tree(child)
-
-          { :title        => (child[:title] || child.identifier),
-            :link         => relative_path_to(child),
-            :subsections  => subsections }
-        end
-      end
+    # Recursive method that extract from an XPath pattern the document structure
+    # and return the "permalinks" in a Array of Hash that could be used by the
+    # rendering method
+    def find_item_tree(root, options={})
+      return nil unless root.children
 
+      # filter the elements to contain only the kind requested
+      children = options[:kind] ? root.children.select { |item| item[:kind] == options[:kind] } : root.children
 
-      def find_breadcrumbs_trail(root)
-        sections = breadcrumbs_for_identifier(root).map do |child|
-          { :title        => (child[:title] || child.identifier),
-            :link         => relative_path_to(child),
-            :subsections  => nil }
-        end
+      # For each child call the find_item_tree on it and then generate the hash
+      sections = children.map do |child|
+        subsections = find_item_tree(child)
+
+        { :title        => (child[:title] || child.identifier),
+          :link         => relative_path_to(child),
+          :subsections  => subsections }
       end
+    end
+
+    def find_breadcrumbs_trail(root)
+      sections = breadcrumbs_for_identifier(root).map do |child|
+        { :title        => (child[:short_title] || child[:title] || child.identifier),
+          :link         => relative_path_to(child),
+          :subsections  => nil }
+      end
+    end
   end
 end

data/lib/nanoc/toolbox/helpers/tagging_extra.rb

@@ -0,0 +1,135 @@
+module Nanoc::Toolbox::Helpers
+
+  # NANOC Helper for added tagging functions
+  #
+  # This module contains functions for ...
+  #
+  # @see http://groups.google.com/group/nanoc/browse_thread/thread/caefcab791fd3c4b
+  module TaggingExtra
+    include Nanoc::Helpers::Blogging
+
+    # Returns all the tags present in a collection of items. The tags are
+    # only present once in the returned value. When called whithout
+    # parameters, all the site items are considered.
+    #
+    # @param [Array<Nanoc::Item>] items
+    # @return [Array<String>] An array of tags
+    def tag_set(items=nil)
+      items ||= @items
+      items.map { |i| i[:tags] }.flatten.uniq.delete_if{|t| t.nil?}
+    end
+
+    # Return true if an item has a specified tag
+    #
+    # @param [Nanoc::Item] item
+    # @param [String] tag
+    # @return [Boolean] true if the item contains the specified tag
+    def has_tag?(item, tag)
+      return false if item[:tags].nil?
+      item[:tags].include? tag
+    end
+
+    # Finds all the items having a specified tag. By default the method search
+    # in all the site items. Alternatively, an item collection can be passed as
+    # second (optional) parameter, to restrict the search in the collection.
+    #
+    # @param [Array<Nanoc::Item>] items
+    # @param [String] tag
+    # @param [Nanoc::Item] item
+    def items_with_tag(tag, items=nil)
+      items = sorted_articles if items.nil?
+      items.select { |item| has_tag?( item, tag ) }
+    end
+
+    # Count the tags in a given collection of items. By default, the method
+    # counts tags in all the site items. The result is an hash such as:
+    # { tag => count }.
+    #
+    # @param [Array<Nanoc::Item>] items
+    # @return [Hash] Hash indexed by tag name with the occurences as value
+    def count_tags(items=nil)
+      items ||= @items
+      tags = items.map { |i| i[:tags] }.flatten.delete_if{|t| t.nil?}
+      tags.inject(Hash.new(0)) {|h,i| h[i] += 1; h }
+    end
+
+    # Sort the tags of an item collection (defaults to all site items) in 'n'
+    # classes of rank. The rank 0 corresponds to the most frequent tags.
+    # The rank 'n-1' to the least frequents. The result is a hash such as:
+    # { tag => rank }
+    #
+    # @param [Integer] n number of rank
+    # @param [Array<Nanoc::Item>] items
+    def rank_tags(n, items=nil)
+      raise ArgumentError, 'the number of ranks should be > 1' if n < 2
+
+      items = @items if items.nil?
+      count = count_tags( items )
+      min, max = count.values.minmax
+
+      ranker = lambda { |num| n - 1 - (num - min) / (max - min) }
+
+      Hash[count.map {|tag,value| [tag, ranker.call(value) ] }]
+    end
+
+    # Returns an Array of links to tags in the item, optionally omits the
+    # given tags from the selection
+    #
+    # @param [Item] item the item from which to extract tags
+    # @param [Array<String>] omit_tags tags that should be excluded
+    # @param [Item] options the options for the links to be created
+    # @option options [String] :tag_pattern ("%%tag%%") The pattern to be replace by the tag name
+    # @option options [String] :title ("options[:tag_pattern]") The text that will be in the link
+    # @option options [String] :file_extension (".html") The file extension
+    # @option options [String] :url_format ("/tags/:tag_pattern:file_extension") The path pattern
+    #
+    # @return [Array<String>] An array of html links
+    #
+    # @example
+    #   omited = ['strange_tag']
+    #   options = { :tag_pattern => "%%TAGNAME%%",
+    #               :title       => "articles tagged with %%TAGNAME%%",
+    #               :url_format  => "/tags/tag_%%TAGNAME%%.html"}
+    #   tag_links_for(item, omited, options) # => ['<a href="/tags/tag_a.html">articles tagged with a</a>', '<a href="/tags/tag_b.html">articles tagged with b</a>']
+    def tag_links_for(item, omit_tags=[], options={})
+      tags = []
+      return tags unless item[:tags]
+
+      options[:tag_pattern]     ||= "%%tag%%"
+      options[:title]           ||= options[:tag_pattern]
+      options[:file_extension]  ||= ".html"
+      options[:url_format]      ||= "/tags/#{options[:tag_pattern]}#{options[:file_extension]}"
+
+      tags = item[:tags] - omit_tags
+
+      tags.map! do |tag|
+          title = options[:title].gsub(options[:tag_pattern], tag.downcase)
+          url = options[:url_format].gsub(options[:tag_pattern], tag.downcase)
+          content_tag('a', title, {:href => url})
+      end
+    end
+
+    # Creates in-memory tag pages from tags of the passed items or form all items
+    #
+    # @param [Array<Item>] item the item from which to extract tags
+    # @param [Item] options the options for the item to be created
+    # @option options [String] :tag_pattern ("%%tag%%") The pattern to be replace by the tag name
+    # @option options [String] :title ("options[:tag_pattern]") The text that will be in the link
+    # @option options [String] :identifier ("/tags/option[:tag_pattern]") The item identifer
+    # @option options [String] :template ("tag") The template/layout to use to render the tag
+    def create_tag_pages(items=nil, options={})
+      options[:tag_pattern]     ||= "%%tag%%"
+      options[:title]           ||= options[:tag_pattern]
+      options[:identifier]      ||= "/tags/#{options[:tag_pattern]}/"
+      options[:template]        ||= "tag"
+
+      tag_set(items).each do |tagname|
+        raw_content = "<%= render('#{options[:template]}', :tag => '#{tagname}') %>"
+        attributes  = { :title => options[:title].gsub(options[:tag_pattern], tagname) }
+        identifier  = options[:identifier].gsub(options[:tag_pattern], tagname)
+
+        @items << Nanoc::Item.new(raw_content, attributes, identifier, :binary => false)
+      end
+    end
+  end
+end

data/lib/nanoc/toolbox/helpers.rb

@@ -1,9 +1,12 @@
 require 'nanoc/toolbox/helpers/navigation'
 require 'nanoc/toolbox/helpers/gravatar'
 require 'nanoc/toolbox/helpers/html_tag'
+require 'nanoc/toolbox/helpers/disqus'
+require 'nanoc/toolbox/helpers/blogging_extra'
+require 'nanoc/toolbox/helpers/tagging_extra'
 require 'nanoc/toolbox/helpers/google_analytics'
 
 # This module will regroup all the helpers for nanoc
 module Nanoc::Toolbox::Helpers
 
-end
+end

data/lib/nanoc/toolbox/version.rb

@@ -3,8 +3,8 @@ module Nanoc
     # Holds information about library version.
     module Version
       MAJOR = 0
-      MINOR = 0
-      PATCH = 7
+      MINOR = 1
+      PATCH = 0
       BUILD = nil
 
       STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join(".")

data/nanoc-toolbox.gemspec

@@ -2,25 +2,26 @@
 require File.expand_path("../lib/nanoc/toolbox/version", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "nanoc-toolbox"
-  s.version     = Nanoc::Toolbox::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Anouar ADLANI"]
-  s.email       = ["anouar@adlani.com"]
-  s.homepage    = "http://aadlani.github.com/nanoc-toolbox/"
-  s.summary     = "A collection of helper and filters for nanoc"
-  s.description = "The nanoc-toolbox is a collection of filters and helpers for the static site generator tool nanoc"
+  s.name         = "nanoc-toolbox"
+  s.version      = Nanoc::Toolbox::VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Anouar ADLANI"]
+  s.email        = ["anouar@adlani.com"]
+  s.homepage     = "http://aadlani.github.com/nanoc-toolbox/"
+  s.summary      = "A collection of helper and filters for nanoc"
+  s.description  = "The nanoc-toolbox is a collection of filters and helpers for the static site generator tool nanoc"
   s.rdoc_options = ["--main", "README.rdoc"]
 
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
   s.required_rubygems_version = ">= 1.3.6"
 
-  s.add_dependency "nanoc", ">= 3.1.6"
-  s.add_dependency "nokogiri", ">= 1.4.4"
-  s.add_dependency "jsmin", ">= 1.0.1"
+  s.add_dependency "nanoc",    "~> 3.4"
+  s.add_dependency "nokogiri", "~> 1.4"
+  s.add_dependency "jsmin",    "~> 1.0"
   
-  s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "rspec", ">= 1.0.0"
-  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler", "~> 1.1"
+  s.add_development_dependency "rspec",   "~> 2.4"
+  s.add_development_dependency "rake",    "~> 0.9"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/spec/filters/add_sections_spec.rb

@@ -1,31 +1,4 @@
-# <div>
-#   <h1>Title</h1>
-#   
-#     <h2>Sub title1</h2>
-#     <p>Lorem Ipsum</p>
-#   
-#       <h3>Sub Sub Title1</h3>
-#       <p>Lorem Ipsum</p>
-# 
-#       <h3>Sub Sub Title2</h3>
-#       <p>Lorem Ipsum</p>
-# 
-#       <h3>Sub Sub Title3</h3>
-#       <p>Lorem Ipsum</p>
-# 
-#   
-#     <h2>Sub title2</h2>
-#     <p>Lorem Ipsum</p>
-# 
-#     <h2>Sub title3</h2>
-#     <p>Lorem Ipsum</p>
-#   
-#     <h2>Sub title4</h2>
-#     <p>Lorem Ipsum</p>
-# </div>
-
 require "spec_helper"
-require "nokogiri"
 
 describe Nanoc::Toolbox::Filters::AddSections do
   before(:each) do
@@ -33,6 +6,11 @@ describe Nanoc::Toolbox::Filters::AddSections do
   end
   
   describe ".run" do
-
+    it "minifies javascript" do
+      content = "<h1>A Title<h1/><h2>A Second Title<h2/>"
+      result = @filter.run(content)
+      result.should_not eq content
+      result.should =~ /"section"/
+    end
   end
-end
+end

data/spec/filters/js_minify_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Nanoc::Toolbox::Filters::JsMinify do
+  before(:each) do
+    @filter = described_class.new
+  end
+  
+  describe ".run" do
+    it "minifies javascript" do
+      content = "alert('Hello World!'); /*Print Hello world*/\n"
+      @filter.run(content).should_not eq content
+    end
+  end
+end

data/spec/helpers/blogging_extra_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+class BloggingExtraDummyClass
+  include Nanoc::Toolbox::Helpers::BloggingExtra
+  def initialize
+    @config = {}
+  end
+end
+
+describe Nanoc::Toolbox::Helpers::BloggingExtra do
+
+  subject { BloggingExtraDummyClass.new }
+
+  it { should respond_to(:add_post_attributes) }
+  it { should respond_to(:act_as_post) }
+  it { should respond_to(:slug_for) }
+  it { should respond_to(:recent_posts) }
+  it { should respond_to(:posts_by_date) }
+
+  describe ".slug_for" do
+    it "returns the slug set in the item if it's existing" do
+      item = { :slug => "abc-def-geh.html" }
+      subject.slug_for(item).should == "abc-def-geh.html"
+    end
+
+    it "generate the slug based on the item filename, by striping spaces" do
+      item = { :filename => "abc def geh.html" }
+      subject.slug_for(item).should == "abc-def-geh"
+    end
+  end
+
+  describe ".add_post_attributes" do
+    it "defines the items as posts when located in the defined folders" do
+      articles = [
+        Nanoc::Item.new("", { :extension => ".md", :created_at => "01/12/2012 22:14" }, "test-of-post2"),
+        Nanoc::Item.new("", { :filename => "_posts/test-of-post2", :extension => ".md", :created_at => "01/12/2012 22:14" }, "test-of-post2"),
+        Nanoc::Item.new("", { :filename => "_articles/test-of-post3", :extension => ".md", :created_at => "01/12/2010 22:13" }, "test-of-post3"),
+        Nanoc::Item.new("", { :filename => "test-of-post6", :extension => ".md", :created_at => "01/12/2008 22:10" }, "test-of-post6")]
+
+      subject.stub(:items).and_return(articles)
+      subject.should_receive(:act_as_post).with(an_instance_of(Nanoc::Item)).twice
+      subject.add_post_attributes
+    end
+  end
+
+  describe ".act_as_post" do
+    before do
+      @item = { :filename => "2011-02-12-test-of-post", :extension => ".md", :created_at => "01/12/2011 22:15" }
+      subject.act_as_post(@item)
+    end
+
+    it "forces the item kind to article" do
+      @item[:kind].should == 'article'
+    end
+
+    it "handles the date from the filename" do
+      @item[:created_at].should == Time.local(2011, 02, 12)
+      @item[:year].should  == "2011"
+      @item[:month].should == "02"
+      @item[:day].should   == "12"
+    end
+
+    it "do something when no date set in the filename" do
+      @item[:year].to_i.should  == @item[:created_at].year
+      @item[:month].to_i.should == @item[:created_at].month
+      @item[:day].to_i.should   == @item[:created_at].day
+    end
+
+    it "generates a slug from the filename" do
+      @item[:slug].should == "test-of-post"
+    end
+
+    it "enables by default the comments" do
+      @item[:comments].should be_true
+    end
+  end
+
+  describe ".recent_posts" do
+    before do
+      @last_articles = [
+        Nanoc::Item.new("", { :filename => "test-of-post1", :extension => ".md", :created_at => "01/12/2008 22:15" }, "test-of-post1"),
+        Nanoc::Item.new("", { :filename => "test-of-post2", :extension => ".md", :created_at => "01/12/2012 22:14" }, "test-of-post2"),
+        Nanoc::Item.new("", { :filename => "test-of-post3", :extension => ".md", :created_at => "01/12/2010 22:13" }, "test-of-post3"),
+        Nanoc::Item.new("", { :filename => "test-of-post4", :extension => ".md", :created_at => "01/12/2010 22:12" }, "test-of-post4"),
+        Nanoc::Item.new("", { :filename => "test-of-post5", :extension => ".md", :created_at => "01/11/2010 22:11" }, "test-of-post5"),
+        Nanoc::Item.new("", { :filename => "test-of-post6", :extension => ".md", :created_at => "01/12/2013 22:10" }, "test-of-post6")]
+
+      subject.stub(:sorted_articles).and_return(@last_articles)
+    end
+
+    it "returns the requested recent posts" do
+      posts = subject.recent_posts(3)
+      posts.length.should eq 3
+      posts.should_not include(@last_articles.last)
+      posts.should     include(@last_articles.first)
+    end
+
+    it "returns the existing posts when requesting more than" do
+      posts = subject.recent_posts(13)
+      posts.length.should eq @last_articles.length
+      posts.should eq(@last_articles)
+    end
+
+    it "excludes the current item when requested" do
+      posts = subject.recent_posts(6, @last_articles.last)
+      posts.should_not include(@last_articles.last)
+    end
+  end
+
+  describe ".posts_by_date" do
+    before do
+      @last_articles = []
+      articles = [
+        Nanoc::Item.new("", { :filename => "test-of-post1", :extension => ".md", :created_at => "01/12/2013 22:15" }, "test-of-post1"),
+        Nanoc::Item.new("", { :filename => "test-of-post2", :extension => ".md", :created_at => "01/12/2012 22:14" }, "test-of-post2"),
+        Nanoc::Item.new("", { :filename => "test-of-post3", :extension => ".md", :created_at => "01/12/2010 22:13" }, "test-of-post3"),
+        Nanoc::Item.new("", { :filename => "test-of-post4", :extension => ".md", :created_at => "01/12/2010 22:12" }, "test-of-post4"),
+        Nanoc::Item.new("", { :filename => "test-of-post5", :extension => ".md", :created_at => "01/02/2010 22:11" }, "test-of-post5"),
+        Nanoc::Item.new("", { :filename => "test-of-post6", :extension => ".md", :created_at => "01/12/2008 22:10" }, "test-of-post6")]
+
+      articles.each  do |article|
+        @last_articles << subject.act_as_post(article)
+      end
+      subject.stub(:sorted_articles).and_return(@last_articles)
+    end
+
+    it "returns the article grouped by years and months" do
+      grouped_article =  subject.posts_by_date
+      grouped_article.keys.should eq @last_articles.map {|i| i[:year]}.uniq
+      grouped_article[2010][12].should eq @last_articles[2..3]
+    end
+  end
+end
+

data/spec/helpers/disqus_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class DummyDisqusClass 
+  include Nanoc::Toolbox::Helpers::Disqus
+end
+
+describe Nanoc::Toolbox::Helpers::Disqus do
+  subject { DummyDisqusClass.new }
+
+  it { should respond_to :disqus_id_for }
+  it { should respond_to :disqus_js_snippet }
+  it { should respond_to :disqus_nojs_snippet }
+
+  describe ".disqus_id_for" do
+    it "calls slug_for to generate the id" do
+      subject.should_receive(:slug_for).once.and_return('hello-world')
+      subject.disqus_id_for({}).should eq 'hello_world'
+    end
+
+    it "prepends the disqus prefix id if passed in the options" do
+      subject.should_receive(:slug_for).once.and_return('hello-world')
+      subject.disqus_id_for({}, {:disqus_id_prefix => 'my_website_'}).should eq 'my_website_hello_world'
+    end
+  end
+
+  describe ".disqus_js_snippet" do
+    it "returns the JS snippet" do
+      subject.disqus_js_snippet.should =~/<script type="text\/javascript">/
+    end
+
+    it "declares prefixed variables passed in options" do
+      menu = subject.disqus_js_snippet({:name => "Anouar", :lastname => 'ADLANI'})
+      menu.should =~/var disqus_name = 'Anouar';/
+      menu.should =~/var disqus_lastname = 'ADLANI';/
+    end
+  end
+
+  describe ".disqus_nojs_snippet" do
+    it "returns the default noscript snippet" do
+      subject.disqus_nojs_snippet.should eq "<noscript>Please enable JavaScript to view the <a href=\"http://disqus.com/?ref_noscript\">comments powered by Disqus.</a></noscript>"
+    end
+
+    it "render the specified message" do
+      subject.disqus_nojs_snippet("No message").should eq "<noscript>No message</noscript>"
+    end
+  end
+end