nesta 0.11.1 → 0.12.0

data/spec/commands/theme/create_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../../spec_helper', File.dirname(__FILE__))
-require File.expand_path('../../../lib/nesta/commands', File.dirname(__FILE__))
-
-describe "nesta:theme:create" do
-  include_context "temporary working directory"
-
-  def should_exist(file)
-    File.exist?(Nesta::Path.themes(@name, file)).should be_true
-  end
-
-  before(:each) do
-    Nesta::App.stub(:root).and_return(TempFileHelper::TEMP_DIR)
-    @name = 'my-new-theme'
-    Nesta::Commands::Theme::Create.new(@name).execute
-  end
-
-  it "should create the theme directory" do
-    File.directory?(Nesta::Path.themes(@name)).should be_true
-  end
-
-  it "should create a dummy README file" do
-    should_exist('README.md')
-    text = File.read(Nesta::Path.themes(@name, 'README.md'))
-    text.should match(/#{@name} is a theme/)
-  end
-
-  it "should create a default app.rb file" do
-    should_exist('app.rb')
-  end
-
-  it "should create public and views directories" do
-    should_exist("public/#{@name}")
-    should_exist('views')
-  end
-
-  it "should copy the default view templates into views" do
-    %w(layout.haml page.haml master.sass).each do |file|
-      should_exist("views/#{file}")
-    end
-  end
-end

data/spec/commands/theme/enable_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path('../../spec_helper', File.dirname(__FILE__))
-require File.expand_path('../../../lib/nesta/commands', File.dirname(__FILE__))
-
-describe "nesta:theme:enable" do
-  include_context "temporary working directory"
-
-  before(:each) do
-    config = temp_path('config.yml')
-    Nesta::Config.stub(:yaml_path).and_return(config)
-    @name = 'mytheme'
-    @command = Nesta::Commands::Theme::Enable.new(@name)
-  end
-
-  shared_examples_for "command that configures the theme" do
-    it "should enable the theme" do
-      @command.execute
-      File.read(Nesta::Config.yaml_path).should match(/^theme: #{@name}/)
-    end
-  end
-
-  describe "when theme config is commented out" do
-    before(:each) do
-      create_config_yaml('  # theme: blah')
-    end
-
-    it_should_behave_like "command that configures the theme"
-  end
-
-  describe "when another theme is configured" do
-    before(:each) do
-      create_config_yaml('theme: another')
-    end
-
-    it_should_behave_like "command that configures the theme"
-  end
-
-  describe "when no theme config exists" do
-    before(:each) do
-      create_config_yaml('# I have no theme config')
-    end
-
-    it_should_behave_like "command that configures the theme"
-  end
-end

data/spec/commands/theme/install_spec.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../../spec_helper', File.dirname(__FILE__))
-require File.expand_path('../../../lib/nesta/commands', File.dirname(__FILE__))
-
-describe "nesta:theme:install" do
-  include_context "temporary working directory"
-
-  before(:each) do
-    @repo_url = 'git://github.com/gma/nesta-theme-mine.git'
-    @theme_dir = 'themes/mine'
-    FileUtils.mkdir_p(File.join(@theme_dir, '.git'))
-    @command = Nesta::Commands::Theme::Install.new(@repo_url)
-    @command.stub(:enable)
-    @command.stub(:run_process)
-  end
-
-  after(:each) do
-    FileUtils.rm_r(@theme_dir)
-  end
-
-  it "should clone the repository" do
-    @command.should_receive(:run_process).with(
-      'git', 'clone', @repo_url, @theme_dir)
-    @command.execute
-  end
-
-  it "should remove the theme's .git directory" do
-    @command.execute
-    File.exist?(@theme_dir).should be_true
-    File.exist?(File.join(@theme_dir, '.git')).should be_false
-  end
-
-  it "should enable the freshly installed theme" do
-    @command.should_receive(:enable)
-    @command.execute
-  end
-
-  describe "when theme URL doesn't match recommended pattern" do
-    before(:each) do
-      @repo_url = 'git://foobar.com/path/to/mytheme.git'
-      @other_theme_dir = 'themes/mytheme'
-      FileUtils.mkdir_p(File.join(@other_theme_dir, '.git'))
-      @command = Nesta::Commands::Theme::Install.new(@repo_url)
-      @command.stub(:enable)
-    end
-
-    after(:each) do
-      FileUtils.rm_r(@other_theme_dir)
-    end
-
-    it "should use the basename as theme dir" do
-      @command.should_receive(:run_process).with(
-        'git', 'clone', @repo_url, @other_theme_dir)
-      @command.execute
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,127 +0,0 @@
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-
-describe "Config" do
-  after(:each) do
-    ENV.keys.each { |variable| ENV.delete(variable) if variable =~ /NESTA_/ }
-  end
-
-  it 'should return default value for "Read more"' do
-    Nesta::Config.read_more.should == 'Continue reading'
-  end
-
-  it 'should return nil for author when not defined' do
-    Nesta::Config.author.should == nil
-  end
-  
-  describe "when settings defined in ENV" do
-    before(:each) do
-      @title = "Title from ENV"
-      ENV["NESTA_TITLE"] = @title
-    end
-
-    it "should fallback to config.yml" do
-      stub_config_key("subtitle", "Subtitle in YAML file")
-      Nesta::Config.subtitle.should == "Subtitle in YAML file"
-    end
-
-    it "should override config.yml" do
-      stub_config_key("title", "Title in YAML file")
-      Nesta::Config.title.should == @title
-    end
-    
-    it "should know how to cope with boolean values" do
-      Nesta::Config.settings << 'a_boolean'
-      begin
-        ENV["NESTA_A_BOOLEAN"] = "true"
-        Nesta::Config.a_boolean.should be_true
-        ENV["NESTA_A_BOOLEAN"] = "false"
-        Nesta::Config.a_boolean.should be_false
-      ensure
-        Nesta::Config.settings.pop
-        ENV.delete('NESTA_A_BOOLEAN')
-      end
-    end
-
-    it 'should return configured value for "Read more"' do
-      ENV['NESTA_READ_MORE'] = 'Read on'
-      begin
-        Nesta::Config.read_more.should == 'Read on'
-      ensure
-        ENV.delete('NESTA_READ_MORE')
-      end
-    end
-    
-    it "should set author hash from ENV" do
-      name = "Name from ENV"
-      uri = "URI from ENV"
-      ENV["NESTA_AUTHOR__NAME"] = name
-      ENV["NESTA_AUTHOR__URI"] = uri
-      Nesta::Config.author["name"].should == name
-      Nesta::Config.author["uri"].should == uri
-      Nesta::Config.author["email"].should be_nil
-    end
-  end
-  
-  describe "when settings only defined in config.yml" do
-    before(:each) do
-      @title = "Title in YAML file"
-      stub_config_key("subtitle", @title)
-    end
-    
-    it "should read configuration from YAML" do
-      Nesta::Config.subtitle.should == @title
-    end
-
-    it "should set author hash from YAML" do
-      name = "Name from YAML"
-      uri = "URI from YAML"
-      stub_config_key("author", { "name" => name, "uri" => uri })
-      Nesta::Config.author["name"].should == name
-      Nesta::Config.author["uri"].should == uri
-      Nesta::Config.author["email"].should be_nil
-    end
-    
-    it "should override top level settings with environment specific settings" do
-      stub_config_key('content', 'general/path')
-      stub_config_key('content', 'rack_env/path', for_environment: true)
-      Nesta::Config.content.should == 'rack_env/path'
-    end
-  end
-
-  describe 'Nesta::Config.fetch' do
-    it 'should be retrieve settings from environment' do
-      ENV['NESTA_MY_SETTING'] = 'value in ENV'
-      begin
-        Nesta::Config.fetch('my_setting').should == 'value in ENV'
-        Nesta::Config.fetch(:my_setting).should == 'value in ENV'
-      ensure
-        ENV.delete('NESTA_MY_SETTING')
-      end
-    end
-
-    it 'should retrieved settings from YAML' do
-      stub_config_key('my_setting', 'value in YAML')
-      Nesta::Config.fetch('my_setting').should == 'value in YAML'
-      Nesta::Config.fetch(:my_setting).should == 'value in YAML'
-    end
-
-    it "should throw NotDefined if a setting isn't defined" do
-      lambda {
-        Nesta::Config.fetch('no such setting')
-      }.should raise_error(Nesta::Config::NotDefined)
-    end
-
-    it 'should allow default values to be set' do
-      Nesta::Config.fetch('no such setting', 'default').should == 'default'
-    end
-
-    it 'should cope with non-truthy boolean values' do
-      ENV['NESTA_SETTING'] = 'false'
-      begin
-        Nesta::Config.fetch('setting').should == false
-      ensure
-        ENV.delete('NESTA_SETTING')
-      end
-    end
-  end
-end

data/spec/model_factory.rb

@@ -1,92 +0,0 @@
-module ModelFactory
-  def create_page(options)
-    extension = options[:ext] || :mdown
-    path = filename(Nesta::Config.page_path, options[:path], extension)
-    create_file(path, options)
-    yield(path) if block_given?
-    Nesta::Page.new(path)
-  end
-
-  def create_article(options = {}, &block)
-    o = {
-      path: 'article-prefix/my-article',
-      heading: 'My article',
-      content: 'Content goes here',
-      metadata: {
-        'date' => '29 December 2008'
-      }.merge(options.delete(:metadata) || {})
-    }.merge(options)
-    create_page(o, &block)
-  end
-
-  def create_category(options = {}, &block)
-    o = {
-      path: 'category-prefix/my-category',
-      heading: 'My category',
-      content: 'Content goes here'
-    }.merge(options)
-    create_page(o, &block)
-  end
-
-  def write_menu_item(indent, file, menu_item)
-    if menu_item.is_a?(Array)
-      indent.sub!(/^/, '  ')
-      menu_item.each { |path| write_menu_item(indent, file, path) }
-      indent.sub!(/^  /, '')
-    else
-      file.write("#{indent}#{menu_item}\n")
-    end
-  end
-
-  def create_menu(menu_text)
-    file = filename(Nesta::Config.content_path, 'menu', :txt)
-    File.open(file, 'w') { |file| file.write(menu_text) }
-  end
-
-  def delete_page(type, permalink, extension)
-    file = filename(Nesta::Config.page_path, permalink, extension)
-    FileUtils.rm(file)
-  end
-
-  def create_content_directories
-    FileUtils.mkdir_p(Nesta::Config.page_path)
-    FileUtils.mkdir_p(Nesta::Config.attachment_path)
-  end
-
-  def mock_file_stat(method, filename, time)
-    stat = double(:stat)
-    stat.stub(:mtime).and_return(Time.parse(time))
-    File.send(method, :stat).with(filename).and_return(stat)
-  end
-
-  private
-    def filename(directory, basename, extension = :mdown)
-      File.join(directory, "#{basename}.#{extension}")
-    end
-
-    def heading(options)
-      prefix = case options[:ext]
-        when :haml
-          "%div\n  %h1"
-        when :textile
-          "<div>\nh1."
-        else
-          '# '
-        end
-      "#{prefix} #{options[:heading]}\n\n"
-    end
-
-    def create_file(path, options = {})
-      create_content_directories
-      metadata = options[:metadata] || {}
-      metatext = metadata.map { |key, value| "#{key}: #{value}" }.join("\n")
-      heading = options[:heading] ? heading(options) : ''
-      contents =<<-EOF
-#{metatext}
-
-#{heading}#{options[:content]}
-      EOF
-      FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, 'w') { |file| file.write(contents) }
-    end
-end

data/spec/models_spec.rb

@@ -1,700 +0,0 @@
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-require File.expand_path('model_factory', File.dirname(__FILE__))
-
-module ModelMatchers
-  class HavePage
-    def initialize(path)
-      @category = path
-    end
-
-    def matches?(article)
-      @article = article
-      article.categories.map { |c| c.path }.include?(@category)
-    end
-
-    def failure_message
-      "expected '#{@article.path}' to be assigned to #{@category}"
-    end
-
-    def negative_failure_message
-      "'#{@article.path}' should not be assigned to #{@category}"
-    end
-  end
-
-  def be_in_category(path)
-    HavePage.new(path)
-  end
-end
-
-shared_context "Page testing" do
-  include Webrat::Matchers
-
-  def create_page(options)
-    super(options.merge(ext: @extension))
-  end
-
-  before(:each) do
-    stub_configuration
-  end
-
-  after(:each) do
-    remove_temp_directory
-    Nesta::FileModel.purge_cache
-  end
-end
-
-shared_examples_for "Page" do
-  include ModelFactory
-  include ModelMatchers
-
-  it "should be findable" do
-    create_page(heading: 'Apple', path: 'the-apple')
-    Nesta::Page.find_all.should have(1).item
-  end
-
-  it "should return the filename for a path" do
-    create_page(heading: 'Banana', path: 'banana')
-    Nesta::Page.find_file_for_path('banana').should =~ /banana.#{@extension}$/
-  end
-
-  it "should return nil for files that don't exist" do
-    Nesta::Page.find_file_for_path('foobar').should be_nil
-  end
-
-  it "should find by path" do
-    create_page(heading: 'Banana', path: 'banana')
-    Nesta::Page.find_by_path('banana').heading.should == 'Banana'
-  end
-
-  it "should find index page by path" do
-    create_page(heading: 'Banana', path: 'banana/index')
-    Nesta::Page.find_by_path('banana').heading.should == 'Banana'
-  end
-
-  it "should respond to #parse_metadata, returning hash of key/value" do
-    page = create_page(heading: 'Banana', path: 'banana')
-    metadata = page.parse_metadata('My key: some value')
-    metadata['my key'].should == 'some value'
-  end
-
-  it "should be parseable if metadata is invalid" do
-    dodgy_metadata = "Key: value\nKey without value\nAnother key: value"
-    create_page(heading: 'Banana', path: 'banana') do |path|
-      text = File.read(path)
-      File.open(path, 'w') do |file|
-        file.puts(dodgy_metadata)
-        file.write(text)
-      end
-    end
-    Nesta::Page.find_by_path('banana')
-  end
-
-  describe "for home page" do
-    it "should set title to heading" do
-      create_page(heading: 'Home', path: 'index')
-      Nesta::Page.find_by_path('/').title.should == 'Home'
-    end
-
-    it "should respect title metadata" do
-      create_page(path: 'index', metadata: { 'title' => 'Specific title' })
-      Nesta::Page.find_by_path('/').title.should == 'Specific title'
-    end
-
-    it "should set title to site title by default" do
-      create_page(path: 'index')
-      Nesta::Page.find_by_path('/').title.should == 'My blog'
-    end
-
-    it "should set permalink to empty string" do
-      create_page(path: 'index')
-      Nesta::Page.find_by_path('/').permalink.should == ''
-    end
-
-    it "should set abspath to /" do
-      create_page(path: 'index')
-      Nesta::Page.find_by_path('/').abspath.should == '/'
-    end
-  end
-
-  it "should not find nonexistent page" do
-    Nesta::Page.find_by_path("no-such-page").should be_nil
-  end
-
-  it "should ensure file exists on instantiation" do
-    lambda {
-      Nesta::Page.new("no-such-file")
-    }.should raise_error(Sinatra::NotFound)
-  end
-
-  it "should reload cached files when modified" do
-    create_page(path: "a-page", heading: "Version 1")
-    now = Time.now
-    File.stub(:mtime).and_return(now - 1)
-    Nesta::Page.find_by_path("a-page")
-    create_page(path: "a-page", heading: "Version 2")
-    File.stub(:mtime).and_return(now)
-    Nesta::Page.find_by_path("a-page").heading.should == "Version 2"
-  end
-
-  it "should have default priority of 0 in category" do
-    page = create_page(metadata: { 'categories' => 'some-page' })
-    page.priority('some-page').should == 0
-    page.priority('another-page').should be_nil
-  end
-
-  it "should read priority from category metadata" do
-    page = create_page(metadata: {
-      'categories' => ' some-page:1, another-page , and-another :-1 '
-    })
-    page.priority('some-page').should == 1
-    page.priority('another-page').should == 0
-    page.priority('and-another').should == -1
-  end
-
-  describe "with assigned pages" do
-    before(:each) do
-      @category = create_category
-      create_article(heading: 'Article 1', path: 'article-1')
-      create_article(
-        heading: 'Article 2',
-        path: 'article-2',
-        metadata: {
-          'date' => '30 December 2008',
-          'categories' => @category.path
-        }
-      )
-      @article = create_article(
-        heading: 'Article 3',
-        path: 'article-3',
-        metadata: {
-          'date' => '31 December 2008',
-          'categories' => @category.path
-        }
-      )
-      @category1 = create_category(
-        path: 'category-1',
-        heading: 'Category 1',
-        metadata: { 'categories' => @category.path }
-      )
-      @category2 = create_category(
-        path: 'category-2',
-        heading: 'Category 2',
-        metadata: { 'categories' => @category.path }
-      )
-      @category3 = create_category(
-        path: 'category-3',
-        heading: 'Category 3',
-        metadata: { 'categories' => "#{@category.path}:1" }
-      )
-    end
-
-    it "should find articles" do
-      @category.articles.should have(2).items
-    end
-
-    it "should order articles by reverse chronological order" do
-      @category.articles.first.path.should == @article.path
-    end
-
-    it "should find pages" do
-      @category.pages.should have(3).items
-    end
-
-    it "should sort pages by priority" do
-      @category.pages.index(@category3).should == 0
-    end
-
-    it "should order pages by heading if priority not set" do
-      pages = @category.pages
-      pages.index(@category1).should < pages.index(@category2)
-    end
-
-    it "should not find pages scheduled in the future" do
-      future_date = (Time.now + 172800).strftime("%d %B %Y")
-      article = create_article(heading: "Article 4",
-                               path: "foo/article-4",
-                               metadata: { "date" => future_date })
-      Nesta::Page.find_articles.detect{|a| a == article}.should be_nil
-    end
-  end
-
-  describe "with pages in draft" do
-    before(:each) do
-      @category = create_category
-      @draft = create_page(heading: 'Forthcoming content',
-                           path: 'foo/in-draft',
-                           metadata: {
-        'categories' => @category.path,
-        'flags' => 'draft'
-      })
-      Nesta::App.stub(:production?).and_return(true)
-    end
-
-    it "should not find assigned drafts" do
-      @category.pages.should_not include(@draft)
-    end
-
-    it "should not find drafts by path" do
-      Nesta::Page.find_by_path('foo/in-draft').should be_nil
-    end
-  end
-
-  describe "when finding articles" do
-    before(:each) do
-      create_article(heading: "Article 1", path: "article-1")
-      create_article(heading: "Article 2",
-                     path: "article-2",
-                     metadata: { "date" => "31 December 2008" })
-      create_article(heading: "Article 3",
-                     path: "foo/article-3",
-                     metadata: { "date" => "30 December 2008" })
-    end
-
-    it "should only find pages with dates" do
-      articles = Nesta::Page.find_articles
-      articles.size.should > 0
-      Nesta::Page.find_articles.each { |page| page.date.should_not be_nil }
-    end
-
-    it "should return articles in reverse chronological order" do
-      article1, article2 = Nesta::Page.find_articles[0..1]
-      article1.date.should > article2.date
-    end
-  end
-
-  it "should be able to find parent page" do
-    category = create_category(path: 'parent')
-    article = create_article(path: 'parent/child')
-    article.parent.should == category
-  end
-
-  describe "(with deep index page)" do
-    it "should be able to find index parent" do
-      home = create_category(path: 'index', heading: 'Home')
-      category = create_category(path: 'parent')
-      category.parent.should == home
-      home.parent.should be_nil
-    end
-
-    it "should be able to find parent of index" do
-      category = create_category(path: "parent")
-      index = create_category(path: "parent/child/index")
-      index.parent.should == category
-    end
-
-    it "should be able to find permalink of index" do
-      index = create_category(path: "parent/child/index")
-      index.permalink.should == 'child'
-    end
-  end
-
-  describe "(with missing nested page)" do
-    it "should consider grandparent to be parent" do
-      grandparent = create_category(path: 'grandparent')
-      child = create_category(path: 'grandparent/parent/child')
-      child.parent.should == grandparent
-    end
-
-    it "should consider grandparent home page to be parent" do
-      home = create_category(path: 'index')
-      child = create_category(path: 'parent/child')
-      child.parent.should == home
-    end
-  end
-
-  describe "when assigned to categories" do
-    before(:each) do
-      create_category(heading: "Apple", path: "the-apple")
-      create_category(heading: "Banana", path: "banana")
-      @article = create_article(
-          metadata: { "categories" => "banana, the-apple" })
-    end
-
-    it "should be possible to list the categories" do
-      @article.categories.should have(2).items
-      @article.should be_in_category("the-apple")
-      @article.should be_in_category("banana")
-      @article.should_not be_in_category("orange")
-    end
-
-    it "should not be assigned to non-existant category" do
-      delete_page(:category, "banana", @extension)
-      @article.should_not be_in_category("banana")
-    end
-  end
-
-  it "should set parent to nil when at root" do
-    create_category(path: "top-level").parent.should be_nil
-  end
-
-  describe "when not assigned to category" do
-    it "should have empty category list" do
-      article = create_article
-      Nesta::Page.find_by_path(article.path).categories.should be_empty
-    end
-  end
-
-  describe "with no content" do
-    it "should produce no HTML output" do
-      create_article do |path|
-        file = File.open(path, 'w')
-        file.close
-      end
-      Nesta::Page.find_all.first.to_html.should match(/^\s*$/)
-    end
-  end
-
-  describe "without metadata" do
-    before(:each) do
-      create_article
-      @article = Nesta::Page.find_all.first
-    end
-
-    it "should use default layout" do
-      @article.layout.should == :layout
-    end
-
-    it "should use default template" do
-      @article.template.should == :page
-    end
-
-    it "should parse heading correctly" do
-      @article.to_html.should have_selector("h1", content: "My article")
-    end
-
-    it "should use heading as link text" do
-      @article.link_text.should == "My article"
-    end
-
-    it "should have default read more link text" do
-      @article.read_more.should == "Continue reading"
-    end
-
-    it "should not have description" do
-      @article.description.should be_nil
-    end
-
-    it "should not have keywords" do
-      @article.keywords.should be_nil
-    end
-  end
-
-  describe "with metadata" do
-    before(:each) do
-      @layout = 'my_layout'
-      @template = 'my_template'
-      @date = '07 September 2009'
-      @keywords = 'things, stuff'
-      @description = 'Page about stuff'
-      @summary = 'Multiline\n\nsummary'
-      @read_more = 'Continue at your leisure'
-      @skillz = 'ruby, guitar, bowstaff'
-      @link_text = 'Link to stuff page'
-      @article = create_article(metadata: {
-        'date' => @date.gsub('September', 'Sep'),
-        'description' => @description,
-        'flags' => 'draft, orange',
-        'keywords' => @keywords,
-        'layout' => @layout,
-        'read more' => @read_more,
-        'skillz' => @skillz,
-        'summary' => @summary,
-        'template' => @template,
-        'link text' => @link_text,
-      })
-    end
-
-    it "should override default layout" do
-      @article.layout.should == @layout.to_sym
-    end
-
-    it "should override default template" do
-      @article.template.should == @template.to_sym
-    end
-
-    it "should set permalink to basename of filename" do
-      @article.permalink.should == 'my-article'
-    end
-
-    it "should set path from filename" do
-      @article.path.should == 'article-prefix/my-article'
-    end
-
-    it "should retrieve heading" do
-      @article.heading.should == 'My article'
-    end
-
-    it "should be possible to convert an article to HTML" do
-      @article.to_html.should have_selector("h1", content: "My article")
-    end
-
-    it "should not include metadata in the HTML" do
-      @article.to_html.should_not have_selector("p:contains('Date')")
-    end
-
-    it "should not include heading in body markup" do
-      @article.body_markup.should_not include("My article")
-    end
-
-    it "should not include heading in body" do
-      @article.body.should_not have_selector("h1", content: "My article")
-    end
-
-    it "should retrieve description from metadata" do
-      @article.description.should == @description
-    end
-
-    it "should retrieve keywords from metadata" do
-      @article.keywords.should == @keywords
-    end
-
-    it "should retrieve date published from metadata" do
-      @article.date.strftime("%d %B %Y").should == @date
-    end
-
-    it "should retrieve read more link from metadata" do
-      @article.read_more.should == @read_more
-    end
-
-    it "should retrieve summary text from metadata" do
-      @article.summary.should match(/#{@summary.split('\n\n').first}/)
-    end
-
-    it "should treat double newline chars as paragraph break in summary" do
-      @article.summary.should match(/#{@summary.split('\n\n').last}/)
-    end
-
-    it "should allow access to metadata" do
-      @article.metadata('skillz').should == @skillz
-    end
-
-    it "should allow access to flags" do
-      @article.should be_flagged_as('draft')
-      @article.should be_flagged_as('orange')
-    end
-
-    it "should know whether or not it's a draft" do
-      @article.should be_draft
-    end
-
-    it "should allow link text to be specified explicitly" do
-      @article.link_text.should == @link_text
-    end
-  end
-
-  describe "when checking last modification time" do
-    before(:each) do
-      create_article
-      @article = Nesta::Page.find_all.first
-    end
-
-    it "should check filesystem" do
-      mock_file_stat(:should_receive, @article.filename, "3 January 2009")
-      @article.last_modified.should == Time.parse("3 January 2009")
-    end
-  end
-
-  describe "with no heading" do
-    before(:each) do
-      @no_heading_page = create_page(path: 'page-with-no-heading')
-    end
-
-    it "should raise a HeadingNotSet exception if you call heading" do
-      lambda do
-        @no_heading_page.heading
-      end.should raise_error(Nesta::HeadingNotSet, /page-with-no-heading/);
-    end
-
-    it "should raise a LinkTextNotSet exception if you call link_text" do
-      lambda do
-        @no_heading_page.link_text
-      end.should raise_error(Nesta::LinkTextNotSet, /page-with-no-heading/);
-    end
-  end
-end
-
-describe "All types of page" do
-  include ModelFactory
-
-  include_context "Page testing"
-
-  it "should still return top level menu items" do
-    # Page.menu_items is deprecated; we're keeping it for the moment so
-    # that we don't break themes or code in a local app.rb (just yet).
-    page1 = create_category(path: "page-1")
-    page2 = create_category(path: "page-2")
-    create_menu([page1.path, page2.path].join("\n"))
-    Nesta::Page.menu_items.should == [page1, page2]
-  end
-end
-
-describe "Markdown page" do
-  include ModelFactory
-
-  context "mdown extension" do
-    before(:each) do
-      @extension = :mdown
-    end
-
-    include_context "Page testing"
-    it_should_behave_like "Page"
-
-    it "should set heading from first h1 tag" do
-      page = create_page(
-        path: "a-page",
-        heading: "First heading",
-        content: "# Second heading"
-      )
-      page.heading.should == "First heading"
-    end
-
-    it "should ignore trailing # characters in headings" do
-      article = create_article(heading: 'With trailing #')
-      article.heading.should == 'With trailing'
-    end
-  end
-
-  context "md extension" do
-    before(:each) do
-      @extension = :md
-    end
-
-    include_context "Page testing"
-    it_should_behave_like "Page"
-
-    it "should set heading from first h1 tag" do
-      page = create_page(
-        path: "a-page",
-        heading: "First heading",
-        content: "# Second heading"
-      )
-      page.heading.should == "First heading"
-    end
-
-    it "should ignore trailing # characters in headings" do
-      article = create_article(heading: 'With trailing #')
-      article.heading.should == 'With trailing'
-    end
-  end
-end
-
-describe "Haml page" do
-  include ModelFactory
-
-  before(:each) do
-    @extension = :haml
-  end
-
-  include_context "Page testing"
-  it_should_behave_like "Page"
-
-  it "should set heading from first h1 tag" do
-    page = create_page(
-      path: "a-page",
-      heading: "First heading",
-      content: "%h1 Second heading"
-    )
-    page.heading.should == "First heading"
-  end
-
-  it "should wrap <p> tags around one line summary text" do
-    page = create_page(
-      path: "a-page",
-      heading: "First para",
-      metadata: { "Summary" => "Wrap me" }
-    )
-    page.summary.should include("<p>Wrap me</p>")
-  end
-
-  it "should wrap <p> tags around multiple lines of summary text" do
-    page = create_page(
-      path: "a-page",
-      heading: "First para",
-      metadata: { "Summary" => 'Wrap me\nIn paragraph tags' }
-    )
-    page.summary.should include("<p>Wrap me</p>")
-    page.summary.should include("<p>In paragraph tags</p>")
-  end
-end
-
-describe "Textile page" do
-  include ModelFactory
-
-  before(:each) do
-    @extension = :textile
-  end
-
-  include_context "Page testing"
-  it_should_behave_like "Page"
-
-  it "should set heading from first h1 tag" do
-    page = create_page(
-      path: "a-page",
-      heading: "First heading",
-      content: "h1. Second heading"
-    )
-    page.heading.should == "First heading"
-  end
-end
-
-describe "Menu" do
-  include ModelFactory
-
-  before(:each) do
-    stub_configuration
-    @page = create_page(path: "page-1")
-  end
-
-  after(:each) do
-    remove_temp_directory
-    Nesta::FileModel.purge_cache
-  end
-
-  it "should find top level menu items" do
-    text = ["no-such-page", @page.path].join("\n")
-    create_menu(text)
-    Nesta::Menu.top_level.should == [@page]
-  end
-
-  it "should find all items in the menu" do
-    create_menu(@page.path)
-    Nesta::Menu.full_menu.should == [@page]
-    Nesta::Menu.for_path('/').should == [@page]
-  end
-
-  describe "with nested sub menus" do
-    before(:each) do
-      (2..6).each do |i|
-        instance_variable_set("@page#{i}", create_page(path: "page-#{i}"))
-      end
-      text = <<-EOF
-#{@page.path}
-  #{@page2.path}
-    #{@page3.path}
-    #{@page4.path}
-    "no-such-page"
-"another-missing-page"
-#{@page5.path}
-  #{@page6.path}
-      EOF
-      create_menu(text)
-    end
-
-    it "should return top level menu items" do
-      Nesta::Menu.top_level.should == [@page, @page5]
-    end
-
-    it "should return full tree of menu items" do
-      Nesta::Menu.full_menu.should ==
-        [@page, [@page2, [@page3, @page4]], @page5, [@page6]]
-    end
-
-    it "should return part of the tree of menu items" do
-      Nesta::Menu.for_path(@page2.path).should == [@page2, [@page3, @page4]]
-    end
-
-    it "should deem menu for path that isn't in menu to be nil" do
-      Nesta::Menu.for_path('wibble').should be_nil
-    end
-  end
-end