ruhoh 1.1 → 2.1

data/spec/db_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-module DB
-  describe Ruhoh::DB do
-    include_context "write_default_theme"
-    include_context "default_setup"
-    
-    let(:whitelist){ Ruhoh::DB::WhiteList }
-    context "database has not been updated" do
-      it "should return nil for all whitelisted variables except payload" do
-        whitelist.each do |var|
-          result = Ruhoh::DB.__send__(var)
-          next if var == :payload
-          result.should be_nil
-        end
-      end
-    end
-    
-    describe "#update" do
-      it "should raise an exception when updating a variable not whitelisted" do
-        lambda { Ruhoh::DB.update(:table) }.should raise_error
-      end
-      
-      it "should run the site parser when updating :site, then set the variable to the result" do
-        Ruhoh::Parsers::Site.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:site)
-        Ruhoh::DB.site.should == {'test' => 'hi'}
-      end
-      
-      it "should run the routes parser when updating :routes" do
-        Ruhoh::Parsers::Routes.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:routes)
-        Ruhoh::DB.routes.should == {'test' => 'hi'}
-      end
-      
-      it "should run the posts parser when updating :posts" do
-        Ruhoh::Parsers::Posts.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:posts)
-        Ruhoh::DB.posts.should == {'test' => 'hi'}
-      end
-      
-      it "should run the pages parser when updating :pages" do
-        Ruhoh::Parsers::Pages.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:pages)
-        Ruhoh::DB.pages.should == {'test' => 'hi'}
-      end
-      
-      it "should run the layouts parser when updating :layouts" do
-        Ruhoh::Parsers::Layouts.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:layouts)
-        Ruhoh::DB.layouts.should == {'test' => 'hi'}
-      end
-      
-      it "should run the partials parser when updating :partials" do
-        Ruhoh::Parsers::Partials.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:partials)
-        Ruhoh::DB.partials.should == {'test' => 'hi'}
-      end
-      
-      it "should run the widgets parser when updating :widgets" do
-        Ruhoh::Parsers::Widgets.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:widgets)
-        Ruhoh::DB.widgets.should == {'test' => 'hi'}
-      end
-      
-      it "should run the stylesheets parser when updating :stylesheets" do
-        Ruhoh::Parsers::Stylesheets.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:stylesheets)
-        Ruhoh::DB.stylesheets.should == {'test' => 'hi'}
-      end
-
-      it "should run the scripts parser when updating :javascripts" do
-        Ruhoh::Parsers::Javascripts.should_receive(:generate).and_return({'test' => 'hi'})
-        Ruhoh::DB.update(:javascripts)
-        Ruhoh::DB.javascripts.should == {'test' => 'hi'}
-      end
-      
-    end
-    
-    describe "#update_all" do
-      it "should call update for all WhiteListed variables." do
-        whitelist.each do |name|
-          Ruhoh::DB.should_receive(:update).with(name).ordered
-        end
-        Ruhoh::DB.update_all
-      end
-    end
-    
-  end
-  
-end

data/spec/page_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-module Page
-  
-  describe Ruhoh::Page do
-    
-    before(:each) do
-      Ruhoh::Utils.stub(:parse_yaml_file).and_return({'theme' => "twitter"})
-      Ruhoh::Paths.stub(:theme_is_valid?).and_return(true)
-      
-    end
-    
-    describe "Page initialization" do
-      it "should setup default templater and converter" do
-        page = Ruhoh::Page.new
-        
-        page.templater.should == Ruhoh::Templaters::RMustache
-      end
-    end
-
-    describe "#change" do
-      let(:page){ Ruhoh::Page.new }
-      let(:posts) {
-        {
-          "dictionary" => {
-            "#{Ruhoh.names.posts}/sample-id.md" => {"title" => "a cool title"}
-          } 
-        }
-      }
-      let(:pages) {
-        {
-          "about/index.md" => {"title" => "about me =)"}
-        }
-      }
-      
-      context "A page with invalid id" do
-        it "should raise error" do
-          lambda { page.change('some-id.md') }.should raise_error
-        end
-      end
-      
-      context "A page with valid id" do
-        context "belonging to a post" do
-          before(:all) do
-            Ruhoh::Parsers::Posts.stub(:generate).and_return(posts)
-            Ruhoh::DB.update(:posts)
-            page.change("#{Ruhoh.names.posts}/sample-id.md")
-          end
-          it "should query the posts dictionary and set @data to result" do
-            page.data.should == {"title" => "a cool title"}
-          end
-          it "should set @id to the valid id" do
-            page.id.should == "#{Ruhoh.names.posts}/sample-id.md"
-          end
-        end
-        
-        context "belonging to a page" do
-          before(:all) do
-            Ruhoh::Parsers::Pages.stub(:generate).and_return(pages)
-            Ruhoh::DB.update(:pages)
-            page.change("about/index.md")
-          end
-          it "should query the pages dictionary and set @data to result." do
-            page.data.should == {"title" => "about me =)"}
-          end
-          it "should set @id to the valid id" do
-            page.id.should == "about/index.md"
-          end
-        end
-        
-      end
-
-    end
-
-    describe "#render" do
-      let(:page){ Ruhoh::Page.new }
-      it "should raise error if id not set" do
-        lambda{ page.render }.should raise_error
-      end
-      
-      it "should process layouts, then render using the @templater" do
-        Ruhoh::DB.stub(:pages).and_return({"blah.md" => {}})
-        page.change('blah.md')
-        layout = "{{{content}}}"
-        payload = {}
-        page.should_receive(:process_layouts)
-        page.should_receive(:expand_layouts).and_return(layout)
-        page.should_receive(:payload).and_return(payload)
-        page.templater.should_receive(:render).with(layout, payload)
-        page.render
-      end
-    end
-    
-    pending "#process_layouts"
-
-    pending "#expand_layouts"
-
-    pending "#payload"
-    
-    pending "#content" do
-      let(:page){ Ruhoh::Page.new }
-
-      it "should raise error if id not set" do
-        lambda{ page.content }.should raise_error
-      end
-      
-      context "Id has been set" do
-        # Set the id
-        before(:all) do
-          Ruhoh::DB.stub(:pages).and_return({"blah.md" => {}})
-          page.change('blah.md')
-        end
-
-        it "should raise an error if the page file is malformed" do
-          Ruhoh::Utils.should_receive(:parse_page_file).and_return({})
-          lambda { page.content }.should raise_error
-        end
-      
-        it "should send the files content to the templater" do
-          Ruhoh::Utils.should_receive(:parse_page_file).and_return({"content" => "meep"})
-          page.templater.should_receive(:parse).with("meep", page)
-          page.converter.stub(:convert)
-          page.content
-        end
-      
-        it "should send the page to the converter, then set the result as @content" do
-          Ruhoh::Utils.should_receive(:parse_page_file).and_return({"content" => "meep"})
-          page.templater.stub(:parse)
-          page.converter.should_receive(:convert).with(page).and_return("yay")
-          page.content
-          page.content.should == "yay"
-        end
-      end
-    end
-  
-    describe "#compiled_path" do
-      let(:page){ Ruhoh::Page.new }
-      
-      it "should raise error if id not set" do
-        lambda{ page.compiled_path }.should raise_error
-      end
-      
-      it "should return a relative filepath (no leading slash)" do
-        Ruhoh::DB.stub(:pages).and_return({"blah.md" => {"url" => "/super/cool/blah-post.html"}})
-        page.change('blah.md')
-        page.compiled_path.should == "super/cool/blah-post.html"
-      end
-      
-      it "should CGI.unescape the url ensure the filepath is correct." do
-        Ruhoh::DB.stub(:pages).and_return({"blah.md" => {"url" => "/super/cool/%21blah-post%3D%29.html"}})
-        page.change('blah.md')
-        page.compiled_path.should == "super/cool/!blah-post=).html"
-      end
-      
-      it "should specify an index.html file if url does not end in an .html extension" do
-        Ruhoh::DB.stub(:pages).and_return({"blah.md" => {"url" => "/super/cool/blah-post"}})
-        page.change('blah.md')
-        page.compiled_path.should == "super/cool/blah-post/index.html"
-      end
-    end
-  
-  end
-  
-end

data/spec/parsers/layouts_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-module Layouts
-  describe Ruhoh::Parsers::Layouts do
-    
-    before(:each) do
-      expected_theme = "twitter"
-      the_layouts_dir = File.join(SampleSitePath, Ruhoh.names.themes, expected_theme, Ruhoh.names.layouts)
-      FileUtils.makedirs the_layouts_dir
-      expected_layouts.each do |layout_name| 
-        full_file_name = File.join(the_layouts_dir, layout_name)
-        
-        File.open full_file_name, "w+" do |file|
-          file.puts <<-TEXT
----
-title: #{layout_name} (test)
----  
-          TEXT
-        end
-      end
-    end
-
-    let(:expected_layouts) { %w{default.html page.html post.html} }
-    
-    describe "#generate" do
-      let(:layouts){
-        Ruhoh::Parsers::Layouts.generate
-      }
-      
-      it 'should extract the correct layouts from a theme.' do
-        layouts.keys.sort.should == ['default', 'page', 'post']
-      end
-      
-      it 'should return a hash for each layout containing the keys "data" and "content"' do
-        layouts.each_value { |value|
-          value.should have_key("data")
-          value.should have_key("content")
-        }
-      end
-    end
-  end
-end

data/spec/parsers/pages_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-module Pages
-  describe Ruhoh::Parsers::Pages do
-    describe "#generate" do
-      include_context "write_default_theme"
-      include_context "default_setup"
-      
-      before(:each) do
-        the_pages_dir = File.join(SampleSitePath, Ruhoh.names.pages)
-        Dir.mkdir the_pages_dir
-        expected_pages.each do |page_name| 
-          full_file_name = File.join(the_pages_dir, page_name)
-          File.open full_file_name, "w+" do |file|
-            file.puts <<-TEXT
----
-title: #{page_name} (test)
----  
-            TEXT
-          end
-        end
-      end
-      
-      let(:expected_pages) {
-        %w{about.md archive.html categories.html index.html pages.html sitemap.txt tags.html}.sort
-      }
-
-      let(:pages){
-        Ruhoh::Parsers::Pages.generate
-      }
-      
-      it 'should extract valid pages from source directory.' do
-        pages.keys.sort.should == expected_pages
-      end
-      
-      it 'should return a properly formatted hash for each page' do
-        pages.each_value { |value|
-          value.should have_key("id")
-          value.should have_key("url")
-          value.should have_key("title")
-        }
-      end
-
-    end
-    
-    describe "#is_valid_page?" do
-      context "No user specified exclusions in config." do
-        it "should return true for a valid page filepath" do
-          filepath = 'about.md'
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == true
-        end
-      
-        it "should return false for a filepath beginning with ." do
-          filepath = '.vim'
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == false
-        end
-
-      end
-      
-      context "Exclude array is passed into config." do
-        before(:each){
-          Dir.mkdir SampleSitePath
-          theme = "twitter"
-          # Create base config.yml + base theme
-          File.open(File.join(SampleSitePath, Ruhoh.names.config_data), "w+") { |file|
-            file.puts <<-TEXT
----
-theme: '#{theme}'
-pages:
-  exclude: ['^test', 'blah']
----  
-  TEXT
-          }
-          theme_dir = File.join(SampleSitePath, Ruhoh.names.themes, theme)
-          FileUtils.makedirs theme_dir
-        }
-        include_context "default_setup"
-        
-        it "should return false for a page filepath matching a regular expression in pages exclude array" do
-          filepath1 = 'test/about.md'
-          filepath2 = 'test/yay.md'
-          filepath3 = 'vest/yay.md'
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath1).should == false
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath2).should == false
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath3).should == true
-        end
-      end
-      
-      context "Exclude string is passed into config." do
-        let(:filepath){'about.md'}
-        before(:each){
-          Dir.mkdir SampleSitePath
-          theme = "twitter"
-          # Create base config.yml + base theme
-          File.open(File.join(SampleSitePath, Ruhoh.names.config_data), "w+") { |file|
-            file.puts <<-TEXT
----
-theme: '#{theme}'
-pages:
-  exclude: '#{filepath}$'
----  
-  TEXT
-          }
-          theme_dir = File.join(SampleSitePath, Ruhoh.names.themes, theme)
-          FileUtils.makedirs theme_dir
-        }
-        include_context "default_setup"
-        
-        it "should return false for a page whose filepath matches a page exclude regular expression." do
-          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == false
-        end
-      end
-    end
-
-    describe "#to_title"
-    describe "#permalink"
-    
-  end
-  
-end

data/spec/parsers/posts_spec.rb

@@ -1,309 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-module Posts
-  describe Ruhoh::Parsers::Posts do
-    include_context "write_default_theme"
-    include_context "default_setup"
-    
-    pending "#generate" do
-      
-      it 'should return a valid data structures for core API' do
-        posts = Ruhoh::Parsers::Posts.generate
-        
-        posts['dictionary'].should be_a_kind_of(Hash)
-        posts['chronological'].should be_a_kind_of(Array)
-        posts['collated'].should be_a_kind_of(Array)
-        posts['tags'].should be_a_kind_of(Hash)
-        posts['categories'].should be_a_kind_of(Hash)
-      end
-      
-    end
-  
-    describe "#process" do
-      
-      context "A valid post" do
-        pending 'should extract valid posts from source directory.' do
-          Ruhoh::Parsers::Posts.process
-          dictionary.keys.sort.should ==  ['_posts/2012-01-01-hello-world.md']
-        end
-        
-        pending 'should return a properly formatted hash for each post' do
-          dictionary = Ruhoh::Parsers::Posts.process
-
-          dictionary.each_value { |value|
-            value.should have_key("id")
-            value.should have_key("url")
-            value.should have_key("title")
-          }
-        end
-      end
-      
-      context "A post with an invalid filename format" do
-        it "should omit the post file and record it as invalid post" do
-          post_path = 'test/hello-world.md'
-          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
-          Ruhoh::Utils.stub(:parse_page_file).and_return({"data" => {"date" => "2012-01-01"}})
-          
-          dictionary = Ruhoh::Parsers::Posts.process
-          
-          dictionary.should_not include(post_path)
-        end
-      end
-      
-      context "A post with an invalid date in the filename" do
-        it "should omit the post file and record it as invalid post" do
-          post_path = 'test/2012-51-01-hello-world.md'
-          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
-          Ruhoh::Utils.stub(:parse_page_file).and_return({"data" => {"title" => "meep"}})
-          
-          dictionary = Ruhoh::Parsers::Posts.process
-          
-          dictionary.should_not include(post_path)
-        end
-      end
-      
-      context "A post with an invalid date in the YAML Front Matter" do
-        it "should omit the post file and record it as invalid post" do
-          post_path = 'test/2012-01-01-hello-world.md'
-          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
-          Ruhoh::Utils.stub(:parse_page_file).and_return({"data" => {"date" => "2012-51-01"}})
-          
-          dictionary = Ruhoh::Parsers::Posts.process
-          
-          dictionary.should_not include(post_path)
-        end
-      end
-    end
-    
-    describe "#parse_page_filename" do
-      it "should parse a post filename with DATE into corresponding metadata" do
-        filename = '_posts/2011-10-10-my-post-title.md'
-        data = Ruhoh::Parsers::Posts.parse_page_filename(filename)
-
-        data['path'].should == "_posts/"
-        data['date'].should == "2011-10-10"
-        data['slug'].should == "my-post-title"
-        data['extension'].should == ".md"
-      end
-      
-      it "should parse a post filename without DATE into corresponding metadata" do
-        filename = '_posts/my-post-title.md'
-        data = Ruhoh::Parsers::Posts.parse_page_filename(filename)
-        data['path'].should == "_posts/"
-        data['date'].should == nil
-        data['slug'].should == "my-post-title"
-        data['extension'].should == ".md"
-      end
-      
-      it "should return a blank hash if the filename has no extension and therefore invalid" do
-        filename = '_posts/my-post-title'
-        data = Ruhoh::Parsers::Posts.parse_page_filename(filename)
-        data.should == {}
-      end
-    end
-    
-    describe "#permalink" do
-      it "should return the default permalink style (/:categories/:year/:month/:day/:title.html)" do
-        post = {"date" => "2012-01-02", "title" => "My Blog Post", "id" => "my-blog-post.md"}
-        permalink = Ruhoh::Parsers::Posts.permalink(post)
-        permalink.should == '/2012/01/02/my-blog-post.html'
-      end
-      
-      it "should return the post specific permalink style" do
-        post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "My Blog Post", 'permalink' => '/:categories/:title' }
-        permalink = Ruhoh::Parsers::Posts.permalink(post)
-        permalink.should == '/my-blog-post'
-      end
-      
-      context "A post with one category" do
-        it "should include the category path in the permalink." do
-          post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "My Blog Post", 'categories'=> 'ruby/lessons/beginner', 'permalink' => '/:categories/:title' }
-          permalink = Ruhoh::Parsers::Posts.permalink(post)
-          permalink.should == '/ruby/lessons/beginner/my-blog-post'
-        end
-      end
-      
-      context "A post belonging in two separate categories" do  
-        it "should include the first category path in the permalink." do
-          post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "My Blog Post", 'categories'=> ['web', 'ruby/lessons/beginner'], 'permalink' => '/:categories/:title' }
-          permalink = Ruhoh::Parsers::Posts.permalink(post)
-          permalink.should == '/web/my-blog-post'
-        end
-      end
-      
-      context "A post with a literal permalink" do  
-        it "should use the literal permalink" do
-          post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "=) My Blog Post!", 'permalink' => '/dogs/and/cats/summer-pictures' }
-          permalink = Ruhoh::Parsers::Posts.permalink(post)
-          permalink.should == '/dogs/and/cats/summer-pictures'
-        end
-      end
-      
-      context "A post having special characters in the title" do  
-        it "should omit those characters." do
-          post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "=) My Blog Post!", 'permalink' => '/:title' }
-          permalink = Ruhoh::Parsers::Posts.permalink(post)
-          permalink.should_not == '/=)-my-blog-post-!'
-          permalink.should == '/my-blog-post'
-        end
-      end
-      
-      context "A post having international characters in the title" do
-        it "should omit those characters." do
-          post = {"id" => "my-blog-post.md", "date" => "2012-01-02", "title" => "=) My Blog Post!", 'permalink' => '/:title' }
-          post = {"id" => '안녕하세요-sérieux-è_é-三只熊.md', "date" => "2012-01-02", "title" => '안녕하세요-sérieux è_é-三只熊', 'permalink' => '/:title' }
-          permalink = Ruhoh::Parsers::Posts.permalink(post)
-          permalink.should == ('/'+CGI::escape('안녕하세요-sérieux-è_é-三只熊'))
-        end
-      end
-    end
-    
-    describe "#to_title" do
-      it "should prettify a filename slug for use as a title/header" do
-        file_slug = 'my-post-title'
-        title = Ruhoh::Parsers::Posts.to_title(file_slug)
-        title.should == "My Post Title"
-      end
-    end
-    
-    describe "helpers" do
-      let(:dictionary_stub) {
-        {
-          "a" => {"date"=>"2011-01-01", "id" => "a"},
-          "b" => {"date"=>"2011-02-01", "id" => "b"},
-          "c" => {"date"=>"2012-01-01", "id" => "c"},
-          "d" => {"date"=>"2010-08-01", "id" => "d"},
-        }
-      }
-      let(:ordered_posts_stub) {
-        [
-          {"date"=>"2012-01-01", "id" => "c"},
-          {"date"=>"2011-02-01", "id" => "b"},
-          {"date"=>"2011-01-01", "id" => "a"},
-          {"date"=>"2010-08-01", "id" => "d"},
-        ]
-      }
-      let(:collated_stub) {
-        [
-          {"year"=>"2012", "months"=>[{"month"=>"January", "posts"=>["c"]}]},
-          {"year"=>"2011", "months"=>[{"month"=>"February", "posts"=>["b"]}, {"month"=>"January", "posts"=>["a"]}]},
-          {"year"=>"2010", "months"=>[{"month"=>"August", "posts"=>["d"]}]}
-        ]
-      }
-      
-      describe "#ordered_posts" do
-        it "should order a dictionary hash by date descending and return an Array" do
-          ordered_posts = Ruhoh::Parsers::Posts.ordered_posts(dictionary_stub)
-
-          ordered_posts.should be_a_kind_of(Array)
-          ordered_posts.should == ordered_posts_stub
-        end
-      end
-
-      describe "#build_chronology" do
-        it 'should return an array of ids ordered by date descending' do
-          chrono = Ruhoh::Parsers::Posts.build_chronology(ordered_posts_stub)
-          chrono.should == ['c', 'b', 'a', 'd']
-        end
-      end
-      
-      describe "#collate" do
-        it 'should return an array of years with nested months and nested, ordered post ids for each month.' do
-          collated = Ruhoh::Parsers::Posts.collate(ordered_posts_stub)
-          collated.should == collated_stub
-        end
-      end
-      
-    end
-    
-    describe "#parse_tags" do
-      let(:ordered_posts_stub) {
-        [
-          {"id" => "c", "tags" => ['apple', 'orange']},
-          {"id" => "b", "tags" => ['apple', 'pear']},
-          {"id" => "a", "tags" => ['banana']},
-          {"id" => "d", "tags" => 'kiwi' },
-        ]
-      }
-      let(:tags){
-        Ruhoh::Parsers::Posts.parse_tags(ordered_posts_stub)
-      }
-      
-      it 'should return a dictionary of all tags on posts' do
-        tags.keys.sort.should == ['apple', 'banana', 'kiwi', 'orange', 'pear']
-      end
-      
-      it 'should return a dictionary containing tag objects having name, count and posts' do
-        tags.each_value { |tag|
-          tag.should have_key("name")
-          tag.should have_key("count")
-          tag.should have_key("posts")
-        }
-      end
-      
-      it 'should return a dictionary with tag objects having correct post id references.' do
-        tags['apple']['posts'].should == ['c', 'b']
-        tags['banana']['posts'].should == ['a']
-        tags['kiwi']['posts'].should == ['d']
-        tags['orange']['posts'].should == ['c']
-        tags['pear']['posts'].should == ['b']
-      end
-      
-      it 'should return a dictionary containing correct tag counts' do
-        tags['apple']['count'].should == 2
-        tags['banana']['count'].should == 1
-        tags['kiwi']['count'].should == 1
-        tags['orange']['count'].should == 1
-        tags['pear']['count'].should == 1
-      end
-      
-    end
-    
-    describe "#parse_categories" do
-      let(:ordered_posts_stub) {
-        [
-          {"id" => "c", "categories" => ['web', ['ruby', 'tutorials']] },
-          {"id" => "b", "categories" => ['web', ['ruby']] },
-          {"id" => "a", "categories" => ['web', 'python'] },
-          {"id" => "d", "categories" => 'erlang' },
-        ]
-      }
-
-      let(:categories) {
-        categories = Ruhoh::Parsers::Posts.parse_categories(ordered_posts_stub)
-      }
-
-      it 'should return a dictionary of all post categories' do
-        categories.keys.sort.should == ['erlang', 'python', 'ruby', 'ruby/tutorials', 'web']
-      end
-      
-      it 'should return a dictionary containing category objects having name, count and posts' do
-        categories.each_value { |cat|
-          cat.should have_key("name")
-          cat.should have_key("count")
-          cat.should have_key("posts")
-        }
-      end
-      
-      it 'should return a dictionary with category objects having correct post id references.' do
-        categories['erlang']['posts'].should == ['d']
-        categories['python']['posts'].should == ['a']
-        categories['ruby']['posts'].should == ['b']
-        categories['ruby/tutorials']['posts'].should == ['c']
-        categories['web']['posts'].should == ['c','b','a']
-      end
-      
-      it 'should return a dictionary containing correct tag counts' do
-        categories['erlang']['count'].should == 1
-        categories['python']['count'].should == 1
-        categories['ruby']['count'].should == 1
-        categories['ruby/tutorials']['count'].should == 1
-        categories['web']['count'].should == 3
-      end
-      
-    end
-    
-  end
-  
-end