radiantcms-couchrest_model 0.1.3 → 0.1.4

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,44 +105,9 @@ 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 = get_config(key)
+    setting = Radiant::Config.find_by_key(key)
     setting.destroy if setting
     Radiant::Config.create!(:key => key, :value => value)
   end

data/spec/models/radiant/exporter_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Radiant::Exporter do
+  dataset :pages_with_layouts, :users_and_pages, :snippets
+
+  before :each do
+    @exporter = Radiant::Exporter
+    @output = @exporter.export
+    @hash = YAML::load(@output)
+    @classes  = ['Radiant::Configs', 'Users', 'Pages', 'PageParts', 'Snippets', 'Layouts']
+  end
+  
+  it "should output a string" do
+    @output.should be_kind_of(String)
+  end
+  
+  it "should output all Radiant models" do
+    @classes.all? { |c| @hash.has_key?(c) }.should be_true
+  end
+  
+  it "should output the models by id as hashes" do
+    @hash['Pages'][page_id(:home)]['title'].should == pages(:home).title
+    @hash['Users'][user_id(:admin)]['name'].should == users(:admin).name
+  end
+end

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 path="/radius"><r:title /> | <r:page:title /></r:find>}).as('Radius | Home')
+    page.should render(%{<r:find url="/radius"><r:title /> | <r:page:title /></r:find>}).as('Radius | Home')
   end
 
-  [:breadcrumb, :slug, :title, :path].each do |attr|
+  [:breadcrumb, :slug, :title, :url].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:path> with a nil relative URL root should scope to the relative root of /" do
+  it "<r:url> 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:path />").as("/")
+    page(:home).should render("<r:url />").as("/")
   end
 
-  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/")
+  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/")
   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 path="/assorted"><r:children:each paginated="true"><r:slug /> </r:children:each></r:find>').matching(%r{href="/another})
+        page.should render('<r:find url="/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)
@@ -334,7 +334,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 one of: true, false})
+        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"})
       end
 
       it "should render parts with respect to the current contextual page" do
@@ -494,47 +494,47 @@ describe "Standard Tags" do
   end
 
   describe "<r:aggregate>" do
-    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.")
+    it "should raise an error when given no 'urls' attribute" do
+      pages(:home).should render('<r:aggregate></r:aggregate>').with_error("`urls' attribute required")
     end
-    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')
+    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')
     end
   end
   
   describe "<r:aggregate:children>" do
     it "should expand its contents" do
-      pages(:home).should render('<r:aggregate paths="/parent/child; /first;"><r:children>true</r:children></r:aggregate>').as('true') 
+      pages(:home).should render('<r:aggregate urls="/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 paths="/news; /assorted"><r:children:count /></r:aggregate>').as('14')
+      pages(:home).should render('<r:aggregate urls="/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 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 ')
+    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 ')
     end
     it "should sort the children by the given 'by' attribute" do
-      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 ')
+      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 ')
     end
     it "should order the children by the given 'order' attribute when used with 'by'" do
-      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 ')
+      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 ')
     end
     it "should limit the number of results with the given 'limit' attribute" do
-      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 ')
+      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 ')
     end
   end
   
   describe "<r:aggregate:each>" do
-    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 ')
+    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 ')
     end
     it "should display it's contents in the scope of the individually aggregated page" do
-      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 ')
+      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 ')
     end
   end
 
@@ -583,10 +583,6 @@ 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"))
@@ -655,7 +651,7 @@ describe "Standard Tags" do
     end
 
     it "should render an error when not given a 'name' attribute" do
-      page.should render('<r:snippet />').with_error("`snippet' tag must contain a `name' attribute.")
+      page.should render('<r:snippet />').with_error("`snippet' tag must contain `name' attribute")
     end
 
     it "should filter the snippet with its assigned filter" do
@@ -715,24 +711,18 @@ 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 paths="Home: / | Assorted: /assorted/ | Parent: /parent/">
+      tags = %{<r:navigation urls="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 paths that match the current page" do
-      tags = %{<r:navigation paths="Home: / | Assorted: /assorted/ | Parent: /parent/ | Radius: /radius/">
+    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/">
                  <r:normal><r:title /></r:normal>
                  <r:selected><strong><r:title/></strong></r:selected>
                </r:navigation>}
@@ -740,11 +730,11 @@ describe "Standard Tags" do
       page(:parent).should render(tags).as(expected)
     end
 
-    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>
+    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>
                  <r:here><strong><r:title /></strong></r:here>
-                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong></r:selected>
+                 <r:selected><strong><a href="<r:url />"><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>}
@@ -752,7 +742,7 @@ describe "Standard Tags" do
     end
 
     it "should render the nested <r:between> tag between each link" do
-      tags = %{<r:navigation paths="Home: / | Assorted: /assorted/ | Parent: /parent/">
+      tags = %{<r:navigation urls="Home: / | Assorted: /assorted/ | Parent: /parent/">
                  <r:normal><r:title /></r:normal>
                  <r:between> :: </r:between>
                </r:navigation>}
@@ -760,16 +750,16 @@ describe "Standard Tags" do
       page.should render(tags).as(expected)
     end
 
-    it 'without paths should render nothing' do
+    it 'without urls 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 paths="something:here"></r:navigation>}).with_error( "`navigation' tag must include a `normal' tag")
+      page.should render(%{<r:navigation urls="something:here"></r:navigation>}).with_error( "`navigation' tag must include a `normal' tag")
     end
 
-    it 'with paths without trailing slashes should match corresponding pages' do
-      tags = %{<r:navigation paths="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
+    it 'with urls without trailing slashes should match corresponding pages' do
+      tags = %{<r:navigation urls="Home: / | Assorted: /assorted | Parent: /parent | Radius: /radius">
                  <r:normal><r:title /></r:normal>
                  <r:here><strong><r:title /></strong></r:here>
                </r:navigation>}
@@ -778,10 +768,10 @@ describe "Standard Tags" do
     end
 
     it 'should prune empty blocks' do
-      tags = %{<r:navigation paths="Home: Boy: / | Archives: /archive/ | Radius: /radius/ | Docs: /documentation/">
-                 <r:normal><a href="<r:path />"><r:title /></a></r:normal>
+      tags = %{<r:navigation urls="Home: Boy: / | Archives: /archive/ | Radius: /radius/ | Docs: /documentation/">
+                 <r:normal><a href="<r:url />"><r:title /></a></r:normal>
                  <r:here></r:here>
-                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong></r:selected>
+                 <r:selected><strong><a href="<r:url />"><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>}
@@ -789,30 +779,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 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>
+      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>
                  <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:path />"><r:title /></a></strong><r:if_last>)</r:if_last></r:selected>
+                 <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: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 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>
+      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>
                  <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:path />"><r:title /></a></strong></r:selected>
+                 <r:selected><r:unless_first>&gt; </r:unless_first><strong><a href="<r:url />"><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 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>
+      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>
                  <r:here><r:title /><r:unless_last> &gt;</r:unless_last></r:here>
-                 <r:selected><strong><a href="<r:path />"><r:title /></a></strong><r:unless_last> &gt;</r:unless_last></r:selected>
+                 <r:selected><strong><a href="<r:url />"><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)
@@ -820,28 +810,28 @@ describe "Standard Tags" do
   end
 
   describe "<r:find>" do
-    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')
+    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')
     end
 
-    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.")
+    it "should render an error without the 'url' attribute" do
+      page.should render(%{<r:find />}).with_error("`find' tag must contain `url' attribute")
     end
 
-    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('')
+    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('')
     end
 
-    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('')
+    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('')
     end
 
     it "should scope contained tags to the found page" do
-      page.should render(%{<r:find path="/parent/"><r:children:each><r:slug /> </r:children:each></r:find>}).as('child child-2 child-3 ')
+      page.should render(%{<r:find url="/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 path="../../../child-2"><r:title/></r:find>}).as("Child 2")
+      page(:great_grandchild).should render(%{<r:find url="../../../child-2"><r:title/></r:find>}).as("Child 2")
     end
   end
 
@@ -875,71 +865,71 @@ describe "Standard Tags" do
     end
   end
 
-  describe "<r:if_path>" do
+  describe "<r:if_url>" do
     describe "with 'matches' attribute" do
       it "should render the contained block if the page URL matches" do
-        page.should render('<r:if_path matches="a.sorted/$">true</r:if_path>').as('true')
+        page.should render('<r:if_url matches="a.sorted/$">true</r:if_url>').as('true')
       end
 
       it "should not render the contained block if the page URL does not match" do
-        page.should render('<r:if_path matches="fancypants">true</r:if_path>').as('')
+        page.should render('<r:if_url matches="fancypants">true</r:if_url>').as('')
       end
 
       it "set to a malformatted regexp should render an error" do
-        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\\/$/")
+        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\\/$/")
       end
 
       it "without 'ignore_case' attribute should ignore case by default" do
-        page.should render('<r:if_path matches="asSorted/$">true</r:if_path>').as('true')
+        page.should render('<r:if_url matches="asSorted/$">true</r:if_url>').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_path matches="asSorted/$" ignore_case="true">true</r:if_path>').as('true')
+          page.should render('<r:if_url matches="asSorted/$" ignore_case="true">true</r:if_url>').as('true')
         end
 
         it "set to 'false' should use a case-sensitive match" do
-          page.should render('<r:if_path matches="asSorted/$" ignore_case="false">true</r:if_path>').as('')
+          page.should render('<r:if_url matches="asSorted/$" ignore_case="false">true</r:if_url>').as('')
         end
       end
     end
 
     it "with no attributes should render an error" do
-      page.should render('<r:if_path>test</r:if_path>').with_error("`if_path' tag must contain a `matches' attribute.")
+      page.should render('<r:if_url>test</r:if_url>').with_error("`if_url' tag must contain a `matches' attribute.")
     end
   end
 
-  describe "<r:unless_path>" do
+  describe "<r:unless_url>" do
     describe "with 'matches' attribute" do
       it "should not render the contained block if the page URL matches" do
-        page.should render('<r:unless_path matches="a.sorted/$">true</r:unless_path>').as('')
+        page.should render('<r:unless_url matches="a.sorted/$">true</r:unless_url>').as('')
       end
 
       it "should render the contained block if the page URL does not match" do
-        page.should render('<r:unless_path matches="fancypants">true</r:unless_path>').as('true')
+        page.should render('<r:unless_url matches="fancypants">true</r:unless_url>').as('true')
       end
 
       it "set to a malformatted regexp should render an error" do
-        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\\/$/")
+        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\\/$/")
       end
 
       it "without 'ignore_case' attribute should ignore case by default" do
-        page.should render('<r:unless_path matches="asSorted/$">true</r:unless_path>').as('')
+        page.should render('<r:unless_url matches="asSorted/$">true</r:unless_url>').as('')
       end
 
       describe "with 'ignore_case' attribute" do
         it "set to 'true' should use a case-insensitive match" do
-          page.should render('<r:unless_path matches="asSorted/$">true</r:unless_path>').as('')
+          page.should render('<r:unless_url matches="asSorted/$">true</r:unless_url>').as('')
         end
 
         it "set to 'false' should use a case-sensitive match" do
-          page.should render('<r:unless_path matches="asSorted/$" ignore_case="false">true</r:unless_path>').as('true')
+          page.should render('<r:unless_url matches="asSorted/$" ignore_case="false">true</r:unless_url>').as('true')
         end
       end
     end
 
     it "with no attributes should render an error" do
-      page.should render('<r:unless_path>test</r:unless_path>').with_error("`unless_path' tag must contain a `matches' attribute.")
+      page.should render('<r:unless_url>test</r:unless_url>').with_error("`unless_url' tag must contain a `matches' attribute.")
     end
   end
 
@@ -984,11 +974,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 path="/devtags/"><r:content part="if_dev" /></r:find>-').as('-dev-').on('dev.site.com')
+        page.should render('-<r:find url="/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 path="/devtags/"><r:content part="if_dev" /></r:find>-').as('--')
+        page.should render('-<r:find url="/devtags/"><r:content part="if_dev" /></r:find>-').as('--')
       end
     end
   end
@@ -1008,11 +998,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 path="/devtags/"><r:content part="unless_dev" /></r:find>-').as('--').on('dev.site.com')
+        page.should render('-<r:find url="/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 path="/devtags/"><r:content part="unless_dev" /></r:find>-').as('-not dev-')
+        page.should render('-<r:find url="/devtags/"><r:content part="unless_dev" /></r:find>-').as('-not dev-')
       end
     end
   end
@@ -1037,82 +1027,102 @@ 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 path="/"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('true')
+      page(:radius).should render(%{<r:find url="/"><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 path="/radius"><r:if_ancestor_or_self>true</r:if_ancestor_or_self></r:find>}).as('')
+      page(:parent).should render(%{<r:find url="/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 path="/radius"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('true')
+      page(:parent).should render(%{<r:find url="/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 path="/"><r:unless_ancestor_or_self>true</r:unless_ancestor_or_self></r:find>}).as('')
+      page(:radius).should render(%{<r:find url="/"><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 path="/"><r:if_self>true</r:if_self></r:find>}).as('true')
+      page(:home).should render(%{<r:find url="/"><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 path="/"><r:if_self>true</r:if_self></r:find>}).as('')
+      page(:radius).should render(%{<r:find url="/"><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 path="/"><r:unless_self>true</r:unless_self></r:find>}).as('true')
+      page(:radius).should render(%{<r:find url="/"><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 path="/"><r:unless_self>true</r:unless_self></r:find>}).as('')
+      page(:home).should render(%{<r:find url="/"><r:unless_self>true</r:unless_self></r:find>}).as('')
     end
   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') }
+  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
     end
-    
   end
 
   private