radiant 0.9.1 → 1.0.0.rc1

data/spec/models/radiant/config_spec.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + "/../../spec_helper"
 
 describe Radiant::Config do
   before :each do
-    Radiant::Config.initialize_cache
-    @config = Radiant::Config
+    Radiant.config.initialize_cache
+    @config = Radiant.config
     set('test', 'cool')
     set('foo', 'bar')
   end
@@ -105,9 +105,44 @@ describe Radiant::Config do
       @config['junk?'].should be_false
     end
   end
+    
+  describe "where no definition exists" do
+    it "should create a blank definition" do
+      get_config("ad.hoc.setting").definition.should be_kind_of(Radiant::Config::Definition)
+    end
+    
+    it "should not protect or constrain" do
+      c = get_config("impromptu.storage")
+      c.allow_blank?.should be_true
+      c.visible?.should be_true
+      c.settable?.should be_true
+    end
+  end
+  
+  describe "where a definition exists" do
+    before do
+      @config.clear_definitions!
+      load(SPEC_ROOT + "/fixtures/more_settings.rb")
+    end
+    
+    it "should validate against the definition" do
+      definition = get_config('testing.validated')
+      lambda{ @config['testing.validated'] = "pig" }.should raise_error(ActiveRecord::RecordInvalid)
+    end
+    
+    it "should protect when the definition requires it" do
+      definition = get_config('testing.protected')
+      definition.settable?.should be_false
+      lambda { definition.value = "something else" }.should raise_error(Radiant::Config::ConfigError)
+    end
+  end
+    
+  def get_config(key)
+    setting = Radiant::Config.find_or_create_by_key(key)
+  end
 
   def set(key, value)
-    setting = Radiant::Config.find_by_key(key)
+    setting = get_config(key)
     setting.destroy if setting
     Radiant::Config.create!(:key => key, :value => value)
   end

data/spec/models/snippet_spec.rb

@@ -5,8 +5,26 @@ describe Snippet do
   test_helper :validations
   
   before :each do
+    @original_filter = Radiant::Config['defaults.snippet.filter']
     @snippet = @model = Snippet.new(snippet_params)
   end
+
+  after :each do
+    Radiant::Config['defaults.snippet.filter'] = @original_filter
+  end
+
+  it "should take the filter from the default filter" do
+    Radiant::Config['defaults.snippet.filter'] = "Textile"
+    snippet = Snippet.new :name => 'new-snippet'
+    snippet.filter_id.should == "Textile"
+  end
+
+  it "shouldn't override existing snippets filters with the default filter" do
+    snippet = Snippet.find(:first, :conditions => {:filter_id => nil})
+    Radiant::Config['defaults.snippet.filter'] = "Textile"
+    snippet.reload
+    snippet.filter_id.should_not == "Textile"
+  end
   
   it 'should validate length of' do
     {

data/spec/models/standard_tags_spec.rb

@@ -6,23 +6,23 @@ describe "Standard Tags" do
   it '<r:page> should allow access to the current page' do
     page(:home)
     page.should render('<r:page:title />').as('Home')
-    page.should render(%{<r:find url="/radius"><r:title /> | <r:page:title /></r:find>}).as('Radius | Home')
+    page.should render(%{<r:find path="/radius"><r:title /> | <r:page:title /></r:find>}).as('Radius | Home')
   end
 
-  [:breadcrumb, :slug, :title, :url].each do |attr|
+  [:breadcrumb, :slug, :title, :path].each do |attr|
     it "<r:#{attr}> should render the '#{attr}' attribute" do
       value = page.send(attr)
       page.should render("<r:#{attr} />").as(value.to_s)
     end
   end
 
-  it "<r:url> with a nil relative URL root should scope to the relative root of /" do
+  it "<r:path> with a nil relative URL root should scope to the relative root of /" do
     ActionController::Base.relative_url_root = nil
-    page(:home).should render("<r:url />").as("/")
+    page(:home).should render("<r:path />").as("/")
   end
 
-  it '<r:url> with a relative URL root should scope to the relative root' do
-    page(:home).should render("<r:url />").with_relative_root("/foo").as("/foo/")
+  it '<r:path> with a relative URL root should scope to the relative root' do
+    page(:home).should render("<r:path />").with_relative_root("/foo").as("/foo/")
   end
 
   it '<r:parent> should change the local context to the parent page' do
@@ -90,7 +90,7 @@ describe "Standard Tags" do
       it 'should link to the correct paginated page' do
         page(:another)
         page.pagination_parameters = {:page => 1, :per_page => 1}
-        page.should render('<r:find url="/assorted"><r:children:each paginated="true"><r:slug /> </r:children:each></r:find>').matching(%r{href="/another})
+        page.should render('<r:find path="/assorted"><r:children:each paginated="true"><r:slug /> </r:children:each></r:find>').matching(%r{href="/another})
       end
       it 'should pass through selected will_paginate parameters' do
         page(:assorted)
@@ -103,17 +103,15 @@ describe "Standard Tags" do
     end
     
     it 'should error with invalid "limit" attribute' do
-      message = "`limit' attribute of `each' tag must be a positive number between 1 and 4 digits"
+      message = "`limit' attribute must be a positive number"
       page.should render(page_children_each_tags(%{limit="a"})).with_error(message)
       page.should render(page_children_each_tags(%{limit="-10"})).with_error(message)
-      page.should render(page_children_each_tags(%{limit="50000"})).with_error(message)
     end
 
     it 'should error with invalid "offset" attribute' do
-      message = "`offset' attribute of `each' tag must be a positive number between 1 and 4 digits"
+      message = "`offset' attribute must be a positive number"
       page.should render(page_children_each_tags(%{offset="a"})).with_error(message)
       page.should render(page_children_each_tags(%{offset="-10"})).with_error(message)
-      page.should render(page_children_each_tags(%{offset="50000"})).with_error(message)
     end
 
     it 'should error with invalid "by" attribute' do
@@ -334,7 +332,7 @@ describe "Standard Tags" do
       end
 
       it "set to an erroneous value should render an error" do
-        page.should render('<r:content part="sidebar" inherit="weird value" />').with_error(%{`inherit' attribute of `content' tag must be set to either "true" or "false"})
+        page.should render('<r:content part="sidebar" inherit="weird value" />').with_error(%{`inherit' attribute of `content' tag must be one of: true, false})
       end
 
       it "should render parts with respect to the current contextual page" do
@@ -494,47 +492,73 @@ describe "Standard Tags" do
   end
 
   describe "<r:aggregate>" do
-    it "should raise an error when given no 'urls' attribute" do
-      pages(:home).should render('<r:aggregate></r:aggregate>').with_error("`urls' attribute required")
+    it "should raise an error when given no 'paths' attribute" do
+      pages(:home).should render('<r:aggregate></r:aggregate>').with_error("`aggregate' tag must contain a `paths' or `urls' attribute.")
     end
-    it "should expand its contents with a given 'urls' attribute formatted as '/url1; /url2;'" do
-      pages(:home).should render('<r:aggregate urls="/parent/child; /first;">true</r:aggregate>').as('true')
+    it "should expand its contents with a given 'paths' attribute formatted as '/path1; /path2;'" do
+      pages(:home).should render('<r:aggregate paths="/parent/child; /first;">true</r:aggregate>').as('true')
     end
   end
   
   describe "<r:aggregate:children>" do
     it "should expand its contents" do
-      pages(:home).should render('<r:aggregate urls="/parent/child; /first;"><r:children>true</r:children></r:aggregate>').as('true') 
+      pages(:home).should render('<r:aggregate paths="/parent/child; /first;"><r:children>true</r:children></r:aggregate>').as('true') 
     end
   end
   
   describe "<r:aggregate:children:count>" do
     it "should display the number of aggregated children" do
-      pages(:home).should render('<r:aggregate urls="/news; /assorted"><r:children:count /></r:aggregate>').as('14')
+      pages(:home).should render('<r:aggregate paths="/news; /assorted"><r:children:count /></r:aggregate>').as('14')
     end
   end
   
   describe "<r:aggregate:children:each>" do
-    it "should loop through each child from the given urls" do
-      pages(:home).should render('<r:aggregate urls="/parent; /news"><r:children:each><r:title/> </r:children:each></r:aggregate>').as('Article Article 2 Article 3 Article 4 Child Child 2 Child 3 ')
+    it "should loop through each child from the given paths" do
+      pages(:home).should render('<r:aggregate paths="/parent; /news"><r:children:each by="title"><r:title/> </r:children:each></r:aggregate>').as('Article Article 2 Article 3 Article 4 Child Child 2 Child 3 ')
     end
     it "should sort the children by the given 'by' attribute" do
-      pages(:home).should render('<r:aggregate urls="/assorted; /news"><r:children:each by="slug"><r:slug /> </r:children:each></r:aggregate>').as('a article article-2 article-3 article-4 b c d e f g h i j ')
+      pages(:home).should render('<r:aggregate paths="/assorted; /news"><r:children:each by="slug"><r:slug /> </r:children:each></r:aggregate>').as('a article article-2 article-3 article-4 b c d e f g h i j ')
     end
     it "should order the children by the given 'order' attribute when used with 'by'" do
-      pages(:home).should render('<r:aggregate urls="/assorted; /news"><r:children:each by="slug" order="desc"><r:slug /> </r:children:each></r:aggregate>').as('j i h g f e d c b article-4 article-3 article-2 article a ')
+      pages(:home).should render('<r:aggregate paths="/assorted; /news"><r:children:each by="slug" order="desc"><r:slug /> </r:children:each></r:aggregate>').as('j i h g f e d c b article-4 article-3 article-2 article a ')
     end
     it "should limit the number of results with the given 'limit' attribute" do
-      pages(:home).should render('<r:aggregate urls="/assorted; /news"><r:children:each by="slug" order="desc" limit="3"><r:slug /> </r:children:each></r:aggregate>').as('j i h ')
+      pages(:home).should render('<r:aggregate paths="/assorted; /news"><r:children:each by="slug" order="desc" limit="3"><r:slug /> </r:children:each></r:aggregate>').as('j i h ')
+    end
+    
+
+    describe 'with paginated="true"' do
+      it 'should limit correctly the result set' do
+        page.pagination_parameters = {:page => 1, :per_page => 10}
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" per_page="10"><r:slug /> </r:children:each></r:aggregate>').matching(/article article-2 article-3 article-4 a b c d e f /)
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" per_page="2"><r:slug /> </r:children:each></r:aggregate>').not_matching(/article article-2 article-3/)
+      end
+      it 'should display a pagination control block' do
+        page.pagination_parameters = {:page => 1, :per_page => 1}
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true"><r:slug /> </r:children:each></r:aggregate>').matching(/div class="pagination"/)
+      end
+      it 'should link to the correct paginated page' do
+        page(:another)
+        page.pagination_parameters = {:page => 1, :per_page => 1}
+        page.should render('<r:find path="/assorted"><r:children:each paginated="true"><r:slug /> </r:children:each></r:find>').matching(%r{href="/another})
+      end
+      it 'should pass through selected will_paginate parameters' do
+        page(:assorted)
+        page.pagination_parameters = {:page => 5, :per_page => 1}
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" separator="not that likely a choice"><r:slug /> </r:children:each></r:aggregate>').matching(/not that likely a choice/)
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" previous_label="before"><r:slug /> </r:children:each></r:aggregate>').matching(/before/)
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" next_label="after"><r:slug /> </r:children:each></r:aggregate>').matching(/after/)
+        page.should render('<r:aggregate paths="/assorted; /news"><r:children:each paginated="true" inner_window="1" outer_window="0"><r:slug /> </r:children:each></r:aggregate>').not_matching(/\?p=2/)
+      end
     end
   end
   
   describe "<r:aggregate:each>" do
-    it "should loop through each of the given aggregate urls" do
-      pages(:home).should render('<r:aggregate urls="/parent/child; /first; /assorted;"><r:each><r:title /> </r:each></r:aggregate>').as('Child First Assorted ')
+    it "should loop through each of the given aggregate paths" do
+      pages(:home).should render('<r:aggregate paths="/parent/child; /first; /assorted;"><r:each><r:title /> </r:each></r:aggregate>').as('Child First Assorted ')
     end
     it "should display it's contents in the scope of the individually aggregated page" do
-      pages(:home).should render('<r:aggregate urls="/parent; /news; /assorted;"><r:each><r:children:each><r:title /> </r:children:each></r:each></r:aggregate>').as('Child Child 2 Child 3 Article Article 2 Article 3 Article 4 a b c d e f g h i j ')
+      pages(:home).should render('<r:aggregate paths="/parent; /news; /assorted;"><r:each><r:children:each><r:title /> </r:children:each></r:each></r:aggregate>').as('Child Child 2 Child 3 Article Article 2 Article 3 Article 4 a b c d e f g h i j ')
     end
   end
 
@@ -550,11 +574,11 @@ describe "Standard Tags" do
 
   describe "<r:gravatar>" do
     it "should render the Gravatar URL of author of the current page" do
-      page.should render('<r:gravatar />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=G&size=32')
+      page.should render('<r:gravatar />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=G&size=32&default=http://testhost.tld/images/admin/avatar_32x32.png')
     end
 
     it "should render the Gravatar URL of the name user" do
-      page.should render('<r:gravatar name="Admin" />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=G&size=32')
+      page.should render('<r:gravatar name="Admin" />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=G&size=32&default=http://testhost.tld/images/admin/avatar_32x32.png')
     end
 
     it "should render the default avatar when the user has not set an email address" do
@@ -566,7 +590,7 @@ describe "Standard Tags" do
     end
 
     it "should render the specified rating" do
-      page.should render('<r:gravatar rating="X" />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=X&size=32')
+      page.should render('<r:gravatar rating="X" />').as('http://www.gravatar.com/avatar.php?gravatar_id=e64c7d89f26bd1972efa854d13d7dd61&rating=X&size=32&default=http://testhost.tld/images/admin/avatar_32x32.png')
     end
   end
 
@@ -583,6 +607,10 @@ describe "Standard Tags" do
       page.should render('<r:date format="%d %b %Y" />').as('11 Jan 2006')
     end
 
+    it "should format the published date according to localized format" do
+      page.should render('<r:date format="short" />').as(I18n.l(page.published_at, :format => :short))
+    end
+
     describe "with 'for' attribute" do
       it "set to 'now' should render the current date in the current Time.zone" do
         page.should render('<r:date for="now" />').as(Time.zone.now.strftime("%A, %B %d, %Y"))
@@ -647,11 +675,11 @@ describe "Standard Tags" do
     end
 
     it "should render an error when the snippet does not exist" do
-      page.should render('<r:snippet name="non-existant" />').with_error('snippet not found')
+      page.should render('<r:snippet name="non-existant" />').with_error("snippet 'non-existant' not found")
     end
 
     it "should render an error when not given a 'name' attribute" do
-      page.should render('<r:snippet />').with_error("`snippet' tag must contain `name' attribute")
+      page.should render('<r:snippet />').with_error("`snippet' tag must contain a `name' attribute.")
     end
 
     it "should filter the snippet with its assigned filter" do
@@ -711,18 +739,24 @@ describe "Standard Tags" do
   it '<r:comment> should render nothing it contains' do
     page.should render('just a <r:comment>small </r:comment>test').as('just a test')
   end
+  
+  describe '<r:hide>' do
+    it "should not display it's contents" do
+      page.should render('just a <r:hide>small </r:hide>test').as('just a test')
+    end
+  end
 
   describe "<r:navigation>" do
     it "should render the nested <r:normal> tag by default" do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted/ | Parent: /parent/">
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted/ | Parent: /parent/">
                  <r:normal><r:title /></r:normal>
                </r:navigation>}
       expected = %{Home Assorted Parent}
       page.should render(tags).as(expected)
     end
 
-    it "should render the nested <r:selected> tag for URLs that match the current page" do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted/ | Parent: /parent/ | Radius: /radius/">
+    it "should render the nested <r:selected> tag for paths that match the current page" do
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted/ | Parent: /parent/ | Radius: /radius/">
                  <r:normal><r:title /></r:normal>
                  <r:selected><strong><r:title/></strong></r:selected>
                </r:navigation>}
@@ -730,11 +764,11 @@ describe "Standard Tags" do
       page(:parent).should render(tags).as(expected)
     end
 
-    it "should render the nested <r:here> tag for URLs that exactly match the current page" do
-      tags = %{<r:navigation urls="Home: Boy: / | Assorted: /assorted/ | Parent: /parent/">
-                 <r:normal><a href="<r:url />"><r:title /></a></r:normal>
+    it "should render the nested <r:here> tag for paths that exactly match the current page" do
+      tags = %{<r:navigation paths="Home: Boy: / | Assorted: /assorted/ | Parent: /parent/">
+                 <r:normal><a href="<r:path />"><r:title /></a></r:normal>
                  <r:here><strong><r:title /></strong></r:here>
-                 <r:selected><strong><a href="<r:url />"><r:title /></a></strong></r:selected>
+                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong></r:selected>
                  <r:between> | </r:between>
                </r:navigation>}
       expected = %{<strong><a href="/">Home: Boy</a></strong> | <strong>Assorted</strong> | <a href="/parent/">Parent</a>}
@@ -742,7 +776,7 @@ describe "Standard Tags" do
     end
 
     it "should render the nested <r:between> tag between each link" do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted/ | Parent: /parent/">
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted/ | Parent: /parent/">
                  <r:normal><r:title /></r:normal>
                  <r:between> :: </r:between>
                </r:navigation>}
@@ -750,16 +784,16 @@ describe "Standard Tags" do
       page.should render(tags).as(expected)
     end
 
-    it 'without urls should render nothing' do
+    it 'without paths should render nothing' do
       page.should render(%{<r:navigation><r:normal /></r:navigation>}).as('')
     end
 
     it 'without a nested <r:normal> tag should render an error' do
-      page.should render(%{<r:navigation urls="something:here"></r:navigation>}).with_error( "`navigation' tag must include a `normal' tag")
+      page.should render(%{<r:navigation paths="something:here"></r:navigation>}).with_error( "`navigation' tag must include a `normal' tag")
     end
 
-    it 'with urls without trailing slashes should match corresponding pages' do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
+    it 'with paths without trailing slashes should match corresponding pages' do
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
                  <r:normal><r:title /></r:normal>
                  <r:here><strong><r:title /></strong></r:here>
                </r:navigation>}
@@ -768,10 +802,10 @@ describe "Standard Tags" do
     end
 
     it 'should prune empty blocks' do
-      tags = %{<r:navigation urls="Home: Boy: / | Archives: /archive/ | Radius: /radius/ | Docs: /documentation/">
-                 <r:normal><a href="<r:url />"><r:title /></a></r:normal>
+      tags = %{<r:navigation paths="Home: Boy: / | Archives: /archive/ | Radius: /radius/ | Docs: /documentation/">
+                 <r:normal><a href="<r:path />"><r:title /></a></r:normal>
                  <r:here></r:here>
-                 <r:selected><strong><a href="<r:url />"><r:title /></a></strong></r:selected>
+                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong></r:selected>
                  <r:between> | </r:between>
                </r:navigation>}
       expected = %{<strong><a href="/">Home: Boy</a></strong> | <a href="/archive/">Archives</a> | <a href="/documentation/">Docs</a>}
@@ -779,30 +813,30 @@ describe "Standard Tags" do
     end
 
     it 'should render text under <r:if_first> and <r:if_last> only on the first and last item, respectively' do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
-                 <r:normal><r:if_first>(</r:if_first><a href="<r:url />"><r:title /></a><r:if_last>)</r:if_last></r:normal>
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
+                 <r:normal><r:if_first>(</r:if_first><a href="<r:path />"><r:title /></a><r:if_last>)</r:if_last></r:normal>
                  <r:here><r:if_first>(</r:if_first><r:title /><r:if_last>)</r:if_last></r:here>
-                 <r:selected><r:if_first>(</r:if_first><strong><a href="<r:url />"><r:title /></a></strong><r:if_last>)</r:if_last></r:selected>
+                 <r:selected><r:if_first>(</r:if_first><strong><a href="<r:path />"><r:title /></a></strong><r:if_last>)</r:if_last></r:selected>
                </r:navigation>}
       expected = %{(<strong><a href=\"/\">Home</a></strong> <a href=\"/assorted\">Assorted</a> <a href=\"/parent\">Parent</a> Radius)}
       page(:radius).should render(tags).as(expected)
     end
 
     it 'should render text under <r:unless_first> on every item but the first' do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
-                 <r:normal><r:unless_first>&gt; </r:unless_first><a href="<r:url />"><r:title /></a></r:normal>
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
+                 <r:normal><r:unless_first>&gt; </r:unless_first><a href="<r:path />"><r:title /></a></r:normal>
                  <r:here><r:unless_first>&gt; </r:unless_first><r:title /></r:here>
-                 <r:selected><r:unless_first>&gt; </r:unless_first><strong><a href="<r:url />"><r:title /></a></strong></r:selected>
+                 <r:selected><r:unless_first>&gt; </r:unless_first><strong><a href="<r:path />"><r:title /></a></strong></r:selected>
                </r:navigation>}
       expected = %{<strong><a href=\"/\">Home</a></strong> &gt; <a href=\"/assorted\">Assorted</a> &gt; <a href=\"/parent\">Parent</a> &gt; Radius}
       page(:radius).should render(tags).as(expected)
     end
 
     it 'should render text under <r:unless_last> on every item but the last' do
-      tags = %{<r:navigation urls="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
-                 <r:normal><a href="<r:url />"><r:title /></a><r:unless_last> &gt;</r:unless_last></r:normal>
+      tags = %{<r:navigation paths="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
+                 <r:normal><a href="<r:path />"><r:title /></a><r:unless_last> &gt;</r:unless_last></r:normal>
                  <r:here><r:title /><r:unless_last> &gt;</r:unless_last></r:here>
-                 <r:selected><strong><a href="<r:url />"><r:title /></a></strong><r:unless_last> &gt;</r:unless_last></r:selected>
+                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong><r:unless_last> &gt;</r:unless_last></r:selected>
                </r:navigation>}
       expected = %{<strong><a href=\"/\">Home</a></strong> &gt; <a href=\"/assorted\">Assorted</a> &gt; <a href=\"/parent\">Parent</a> &gt; Radius}
       page(:radius).should render(tags).as(expected)
@@ -810,28 +844,28 @@ describe "Standard Tags" do
   end
 
   describe "<r:find>" do
-    it "should change the local page to the page specified in the 'url' attribute" do
-      page.should render(%{<r:find url="/parent/child/"><r:title /></r:find>}).as('Child')
+    it "should change the local page to the page specified in the 'path' attribute" do
+      page.should render(%{<r:find path="/parent/child/"><r:title /></r:find>}).as('Child')
     end
 
-    it "should render an error without the 'url' attribute" do
-      page.should render(%{<r:find />}).with_error("`find' tag must contain `url' attribute")
+    it "should render an error without a 'path' or 'url' attribute" do
+      page.should render(%{<r:find />}).with_error("`find' tag must contain a `path' or `url' attribute.")
     end
 
-    it "should render nothing when the 'url' attribute does not point to a page" do
-      page.should render(%{<r:find url="/asdfsdf/"><r:title /></r:find>}).as('')
+    it "should render nothing when the 'path' attribute does not point to a page" do
+      page.should render(%{<r:find path="/asdfsdf/"><r:title /></r:find>}).as('')
     end
 
-    it "should render nothing when the 'url' attribute does not point to a page and a custom 404 page exists" do
-      page.should render(%{<r:find url="/gallery/asdfsdf/"><r:title /></r:find>}).as('')
+    it "should render nothing when the 'path' attribute does not point to a page and a custom 404 page exists" do
+      page.should render(%{<r:find path="/gallery/asdfsdf/"><r:title /></r:find>}).as('')
     end
 
     it "should scope contained tags to the found page" do
-      page.should render(%{<r:find url="/parent/"><r:children:each><r:slug /> </r:children:each></r:find>}).as('child child-2 child-3 ')
+      page.should render(%{<r:find path="/parent/"><r:children:each><r:slug /> </r:children:each></r:find>}).as('child child-2 child-3 ')
     end
 
     it "should accept a path relative to the current page" do
-      page(:great_grandchild).should render(%{<r:find url="../../../child-2"><r:title/></r:find>}).as("Child 2")
+      page(:great_grandchild).should render(%{<r:find path="../../../child-2"><r:title/></r:find>}).as("Child 2")
     end
   end
 
@@ -865,75 +899,76 @@ describe "Standard Tags" do
     end
   end
 
-  describe "<r:if_url>" do
+  describe "<r:if_path>" do
     describe "with 'matches' attribute" do
       it "should render the contained block if the page URL matches" do
-        page.should render('<r:if_url matches="a.sorted/$">true</r:if_url>').as('true')
+        page.should render('<r:if_path matches="a.sorted/$">true</r:if_path>').as('true')
       end
 
       it "should not render the contained block if the page URL does not match" do
-        page.should render('<r:if_url matches="fancypants">true</r:if_url>').as('')
+        page.should render('<r:if_path matches="fancypants">true</r:if_path>').as('')
       end
 
       it "set to a malformatted regexp should render an error" do
-        page.should render('<r:if_url matches="as(sorted/$">true</r:if_url>').with_error("Malformed regular expression in `matches' argument of `if_url' tag: unmatched (: /as(sorted\\/$/")
+        page.should render('<r:if_path matches="as(sorted/$">true</r:if_path>').with_error("Malformed regular expression in `matches' argument of `if_path' tag: unmatched (: /as(sorted\\/$/")
       end
 
       it "without 'ignore_case' attribute should ignore case by default" do
-        page.should render('<r:if_url matches="asSorted/$">true</r:if_url>').as('true')
+        page.should render('<r:if_path matches="asSorted/$">true</r:if_path>').as('true')
       end
 
       describe "with 'ignore_case' attribute" do
         it "set to 'true' should use a case-insensitive match" do
-          page.should render('<r:if_url matches="asSorted/$" ignore_case="true">true</r:if_url>').as('true')
+          page.should render('<r:if_path matches="asSorted/$" ignore_case="true">true</r:if_path>').as('true')
         end
 
         it "set to 'false' should use a case-sensitive match" do
-          page.should render('<r:if_url matches="asSorted/$" ignore_case="false">true</r:if_url>').as('')
+          page.should render('<r:if_path matches="asSorted/$" ignore_case="false">true</r:if_path>').as('')
         end
       end
     end
 
     it "with no attributes should render an error" do
-      page.should render('<r:if_url>test</r:if_url>').with_error("`if_url' tag must contain a `matches' attribute.")
+      page.should render('<r:if_path>test</r:if_path>').with_error("`if_path' tag must contain a `matches' attribute.")
     end
   end
 
-  describe "<r:unless_url>" do
+  describe "<r:unless_path>" do
     describe "with 'matches' attribute" do
       it "should not render the contained block if the page URL matches" do
-        page.should render('<r:unless_url matches="a.sorted/$">true</r:unless_url>').as('')
+        page.should render('<r:unless_path matches="a.sorted/$">true</r:unless_path>').as('')
       end
 
       it "should render the contained block if the page URL does not match" do
-        page.should render('<r:unless_url matches="fancypants">true</r:unless_url>').as('true')
+        page.should render('<r:unless_path matches="fancypants">true</r:unless_path>').as('true')
       end
 
       it "set to a malformatted regexp should render an error" do
-        page.should render('<r:unless_url matches="as(sorted/$">true</r:unless_url>').with_error("Malformed regular expression in `matches' argument of `unless_url' tag: unmatched (: /as(sorted\\/$/")
+        page.should render('<r:unless_path matches="as(sorted/$">true</r:unless_path>').with_error("Malformed regular expression in `matches' argument of `unless_path' tag: unmatched (: /as(sorted\\/$/")
       end
 
       it "without 'ignore_case' attribute should ignore case by default" do
-        page.should render('<r:unless_url matches="asSorted/$">true</r:unless_url>').as('')
+        page.should render('<r:unless_path matches="asSorted/$">true</r:unless_path>').as('')
       end
 
       describe "with 'ignore_case' attribute" do
         it "set to 'true' should use a case-insensitive match" do
-          page.should render('<r:unless_url matches="asSorted/$">true</r:unless_url>').as('')
+          page.should render('<r:unless_path matches="asSorted/$">true</r:unless_path>').as('')
         end
 
         it "set to 'false' should use a case-sensitive match" do
-          page.should render('<r:unless_url matches="asSorted/$" ignore_case="false">true</r:unless_url>').as('true')
+          page.should render('<r:unless_path matches="asSorted/$" ignore_case="false">true</r:unless_path>').as('true')
         end
       end
     end
 
     it "with no attributes should render an error" do
-      page.should render('<r:unless_url>test</r:unless_url>').with_error("`unless_url' tag must contain a `matches' attribute.")
+      page.should render('<r:unless_path>test</r:unless_path>').with_error("`unless_path' tag must contain a `matches' attribute.")
     end
   end
 
   describe "<r:cycle>" do
+    subject { page }
     it "should render passed values in succession" do
       page.should render('<r:cycle values="first, second" /> <r:cycle values="first, second" />').as('first second')
     end
@@ -942,6 +977,10 @@ describe "Standard Tags" do
       page.should render('<r:cycle values="first, second" /> <r:cycle values="first, second" /> <r:cycle values="first, second" />').as('first second first')
     end
 
+    it "should start at a given start value" do
+      page.should render('<r:cycle values="first, second, third" start="second" /> <r:cycle values="first, second, third" start="second" /> <r:cycle values="first, second, third" start="second" />').as('second third first')
+    end
+
     it "should use a default cycle name of 'cycle'" do
       page.should render('<r:cycle values="first, second" /> <r:cycle values="first, second" name="cycle" />').as('first second')
     end
@@ -953,10 +992,12 @@ describe "Standard Tags" do
     it "should reset the counter" do
       page.should render('<r:cycle values="first, second" /> <r:cycle values="first, second" reset="true"/>').as('first first')
     end
-
-    it "should require the values attribute" do
-      page.should render('<r:cycle />').with_error("`cycle' tag must contain a `values' attribute.")
-    end
+    
+    it { should render('<r:cycle /> <r:cycle />').as('0 1') }
+    it { should render('<r:cycle start="3" /> <r:cycle start="3" /> <r:cycle start="3" />').as('3 4 5') }
+    it { should render('<r:cycle start="3" /> <r:cycle name="other" /> <r:cycle start="3" />').as('3 0 4') }
+    it { should render('<r:cycle start="3" /> <r:cycle name="other" start="23" /> <r:cycle />').as('3 23 4') }
+    it { should render('<r:cycle start="3" /> <r:cycle name="other" start="23" /> <r:cycle reset="true" />').as('3 23 0') }
   end
 
   describe "<r:if_dev>" do
@@ -974,11 +1015,11 @@ describe "Standard Tags" do
 
     describe "on an included page" do
       it "should render the contained block when on the dev site" do
-        page.should render('-<r:find url="/devtags/"><r:content part="if_dev" /></r:find>-').as('-dev-').on('dev.site.com')
+        page.should render('-<r:find path="/devtags/"><r:content part="if_dev" /></r:find>-').as('-dev-').on('dev.site.com')
       end
 
       it "should not render the contained block when not on the dev site" do
-        page.should render('-<r:find url="/devtags/"><r:content part="if_dev" /></r:find>-').as('--')
+        page.should render('-<r:find path="/devtags/"><r:content part="if_dev" /></r:find>-').as('--')
       end
     end
   end
@@ -998,11 +1039,11 @@ describe "Standard Tags" do
 
     describe "on an included page" do
       it "should not render the contained block when not on the dev site" do
-        page.should render('-<r:find url="/devtags/"><r:content part="unless_dev" /></r:find>-').as('--').on('dev.site.com')
+        page.should render('-<r:find path="/devtags/"><r:content part="unless_dev" /></r:find>-').as('--').on('dev.site.com')
       end
 
       it "should render the contained block when not on the dev site" do
-        page.should render('-<r:find url="/devtags/"><r:content part="unless_dev" /></r:find>-').as('-not dev-')
+        page.should render('-<r:find path="/devtags/"><r:content part="unless_dev" /></r:find>-').as('-not dev-')
       end
     end
   end
@@ -1027,102 +1068,82 @@ describe "Standard Tags" do
 
   describe "<r:if_ancestor_or_self>" do
     it "should render the tag's content when the current page is an ancestor of tag.locals.page" do
-      page(:radius).should render(%{<r:find url="/"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('true')
+      page(:radius).should render(%{<r:find path="/"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('true')
     end
 
     it "should not render the tag's content when current page is not an ancestor of tag.locals.page" do
-      page(:parent).should render(%{<r:find url="/radius"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('')
+      page(:parent).should render(%{<r:find path="/radius"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('')
     end
   end
 
   describe "<r:unless_ancestor_or_self>" do
     it "should render the tag's content when the current page is not an ancestor of tag.locals.page" do
-      page(:parent).should render(%{<r:find url="/radius"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('true')
+      page(:parent).should render(%{<r:find path="/radius"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('true')
     end
 
     it "should not render the tag's content when current page is an ancestor of tag.locals.page" do
-      page(:radius).should render(%{<r:find url="/"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('')
+      page(:radius).should render(%{<r:find path="/"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('')
     end
   end
 
   describe "<r:if_self>" do
     it "should render the tag's content when the current page is the same as the local contextual page" do
-      page(:home).should render(%{<r:find url="/"><r:if_self>true</r:if_self></r:find>}).as('true')
+      page(:home).should render(%{<r:find path="/"><r:if_self>true</r:if_self></r:find>}).as('true')
     end
 
     it "should not render the tag's content when the current page is not the same as the local contextual page" do
-      page(:radius).should render(%{<r:find url="/"><r:if_self>true</r:if_self></r:find>}).as('')
+      page(:radius).should render(%{<r:find path="/"><r:if_self>true</r:if_self></r:find>}).as('')
     end
   end
 
   describe "<r:unless_self>" do
     it "should render the tag's content when the current page is not the same as the local contextual page" do
-      page(:radius).should render(%{<r:find url="/"><r:unless_self>true</r:unless_self></r:find>}).as('true')
+      page(:radius).should render(%{<r:find path="/"><r:unless_self>true</r:unless_self></r:find>}).as('true')
     end
 
     it "should not render the tag's content when the current page is the same as the local contextual page" do
-      page(:home).should render(%{<r:find url="/"><r:unless_self>true</r:unless_self></r:find>}).as('')
+      page(:home).should render(%{<r:find path="/"><r:unless_self>true</r:unless_self></r:find>}).as('')
     end
   end
 
-  describe "<r:meta>" do
-    it "should render <meta> tags for the description and keywords" do
-      page(:home).should render('<r:meta/>').as(%{<meta name="description" content="The homepage" /><meta name="keywords" content="Home, Page" />})
-    end
-
-    it "should render <meta> tags with escaped values for the description and keywords" do
-      page.should render('<r:meta/>').as(%{<meta name="description" content="sweet &amp; harmonious biscuits" /><meta name="keywords" content="sweet &amp; harmonious biscuits" />})
-    end
-
-    describe "with 'tag' attribute set to 'false'" do
-      it "should render the contents of the description and keywords" do
-        page(:home).should render('<r:meta tag="false" />').as(%{The homepageHome, Page})
-      end
-
-      it "should escape the contents of the description and keywords" do
-        page.should render('<r:meta tag="false" />').as("sweet &amp; harmonious biscuitssweet &amp; harmonious biscuits")
-      end
-    end
-  end
-
-  describe "<r:meta:description>" do
-    it "should render a <meta> tag for the description" do
-      page(:home).should render('<r:meta:description/>').as(%{<meta name="description" content="The homepage" />})
-    end
-
-    it "should render a <meta> tag with escaped value for the description" do
-      page.should render('<r:meta:description />').as(%{<meta name="description" content="sweet &amp; harmonious biscuits" />})
-    end
-
-    describe "with 'tag' attribute set to 'false'" do
-      it "should render the contents of the description" do
-        page(:home).should render('<r:meta:description tag="false" />').as(%{The homepage})
-      end
-
-      it "should escape the contents of the description" do
-        page.should render('<r:meta:description tag="false" />').as("sweet &amp; harmonious biscuits")
-      end
-    end
-  end
-
-  describe "<r:meta:keywords>" do
-    it "should render a <meta> tag for the keywords" do
-      page(:home).should render('<r:meta:keywords/>').as(%{<meta name="keywords" content="Home, Page" />})
-    end
-
-    it "should render a <meta> tag with escaped value for the keywords" do
-      page.should render('<r:meta:keywords />').as(%{<meta name="keywords" content="sweet &amp; harmonious biscuits" />})
-    end
-
-    describe "with 'tag' attribute set to 'false'" do
-      it "should render the contents of the keywords" do
-        page(:home).should render('<r:meta:keywords tag="false" />').as(%{Home, Page})
-      end
-
-      it "should escape the contents of the keywords" do
-        page.should render('<r:meta:keywords tag="false" />').as("sweet &amp; harmonious biscuits")
-      end
+  describe "Field tags" do
+    subject{
+      p = Page.new(:slug => "/", :parent_id => nil, :title => 'Home')
+      field = PageField.new(:name => 'Field', :content => "Sweet harmonious biscuits")
+      blank_field = PageField.new(:name => 'blank', :content => "")
+      p.fields = [field, blank_field]
+      p
+    }
+
+    describe '<r:field>' do
+      it { should render('<r:field name="field" />').as('Sweet harmonious biscuits') }
+      it { should render('<r:field name="bogus" />').as('') }
+    end
+
+    describe "<r:if_field>" do
+      it { should render('<r:if_field name="field">Ok</r:if_field>').as('Ok') }
+      it { should render('<r:if_field name="bogus">Ok</r:if_field>').as('') }
+      it { should render('<r:if_field name="field" equals="sweet harmonious biscuits">Ok</r:if_field>').as('Ok') }
+      it { should render('<r:if_field name="bogus" equals="sweet harmonious biscuits">Ok</r:if_field>').as('') }
+      it { should render('<r:if_field name="field" equals="sweet harmonious biscuits" ignore_case="false">Ok</r:if_field>').as('') }
+      it { should render('<r:if_field name="field" matches="^sweet\s">Ok</r:if_field>').as('Ok') }
+      it { should render('<r:if_field name="field" matches="^sweet\s" ignore_case="false">Ok</r:if_field>').as('') }
+      it { should render('<r:if_field name="blank" matches="[^\s]">Not here</r:if_field>').as('') }
+      it { should render('<r:if_field name="bogus" matches="something">Not here</r:if_field>').as('') }
+    end
+
+    describe "<r:unless_field>" do
+      it { should render('<r:unless_field name="field">Ok</r:unless_field>').as('') }
+      it { should render('<r:unless_field name="bogus">Ok</r:unless_field>').as('Ok') }
+      it { should render('<r:unless_field name="field" equals="sweet harmonious biscuits">Ok</r:unless_field>').as('') }
+      it { should render('<r:unless_field name="bogus" equals="sweet harmonious biscuits">Ok</r:unless_field>').as('Ok') }
+      it { should render('<r:unless_field name="field" equals="sweet harmonious biscuits" ignore_case="false">Ok</r:unless_field>').as('Ok') }
+      it { should render('<r:unless_field name="field" matches="^sweet\s">Ok</r:unless_field>').as('') }
+      it { should render('<r:unless_field name="field" matches="^sweet\s" ignore_case="false">Ok</r:unless_field>').as('Ok') }
+      it { should render('<r:unless_field name="blank" matches="[^\s]">Not here</r:unless_field>').as('Not here') }
+      it { should render('<r:unless_field name="bogus" matches="something">Not here</r:unless_field>').as('Not here') }
     end
+    
   end
 
   private