radiant 1.1.0.beta → 1.1.0.rc1

data/spec/dummy/public/javascripts/rails.js

@@ -0,0 +1,202 @@
+(function() {
+  Ajax.Responders.register({
+    onCreate: function(request) {
+      var token = $$('meta[name=csrf-token]')[0];
+      if (token) {
+        if (!request.options.requestHeaders) request.options.requestHeaders = {};
+        request.options.requestHeaders['X-CSRF-Token'] = token.readAttribute('content');
+      }
+    }
+  });
+
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM';
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase();
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA';
+    }
+    else return false;
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change');
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback);
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName;
+        }
+      }
+    );
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true);
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault();
+        });
+        form.store('emulated:submit', true);
+      }
+    });
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, textarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true);
+        });
+        input.store('emulated:change', true);
+      }
+    });
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      // serialize the form with respect to the submit button that was pressed
+      params = element.serialize({ submit: element.retrieve('rails:submit-button') });
+      // clear the pressed submit button information
+      element.store('rails:submit-button', null);
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onCreate:   function(response) { element.fire("ajax:create",   response); },
+      onComplete: function(response) { element.fire("ajax:complete", response); },
+      onSuccess:  function(response) { element.fire("ajax:success",  response); },
+      onFailure:  function(response) { element.fire("ajax:failure",  response); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function insertHiddenField(form, name, value) {
+    form.insert(new Element('input', { type: 'hidden', name: name, value: value }));
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    $(element.parentNode).insert(form);
+
+    if (method !== 'post') {
+      insertHiddenField(form, '_method', method);
+    }
+
+    if (csrf_param) {
+      insertHiddenField(form, csrf_param.readAttribute('content'), csrf_token.readAttribute('content'));
+    }
+
+    form.submit();
+  }
+
+  function disableFormElements(form) {
+    form.select('input[type=submit][data-disable-with]').each(function(input) {
+      input.store('rails:original-value', input.getValue());
+      input.setValue(input.readAttribute('data-disable-with')).disable();
+    });
+  }
+  
+  function enableFormElements(form) {
+    form.select('input[type=submit][data-disable-with]').each(function(input) {
+      input.setValue(input.retrieve('rails:original-value')).enable();
+    });
+  }
+
+  function allowAction(element) {
+    var message = element.readAttribute('data-confirm');
+    return !message || confirm(message);
+  }
+
+  document.on('click', 'a[data-confirm], a[data-remote], a[data-method]', function(event, link) {
+    if (!allowAction(link)) {
+      event.stop();
+      return false;
+    }
+
+    if (link.readAttribute('data-remote')) {
+      handleRemote(link);
+      event.stop();
+    } else if (link.readAttribute('data-method')) {
+      handleMethod(link);
+      event.stop();
+    }
+  });
+
+  document.on("click", "form input[type=submit], form button[type=submit], form button:not([type])", function(event, button) {
+    // register the pressed submit button
+    event.findElement('form').store('rails:submit-button', button.name || false);
+  });
+
+  document.on("submit", function(event) {
+    var form = event.findElement();
+
+    if (!allowAction(form)) {
+      event.stop();
+      return false;
+    }
+
+    if (form.readAttribute('data-remote')) {
+      handleRemote(form);
+      event.stop();
+    } else {
+      disableFormElements(form);
+    }
+  });
+
+  document.on('ajax:create', 'form', function(event, form) {
+    if (form == event.findElement()) disableFormElements(form);
+  });
+  
+  document.on('ajax:complete', 'form', function(event, form) {
+    if (form == event.findElement()) enableFormElements(form);
+  });
+})();

data/spec/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/fixtures/example_extension/example_extension.rb

@@ -6,10 +6,6 @@ class ExampleExtension < Radiant::Extension
   description "Describe your extension here"
   url "http://example.com/example"
   
-  # define_routes do |map|
-  #   map.connect 'admin/example/:action', :controller => 'admin/example'
-  # end
-  
   def activate
     # admin.tabs.add "Example", "/admin/example", :after => "Layouts", :visibility => [:all]
   end

data/spec/lib/radiant/extension_spec.rb

@@ -46,14 +46,6 @@ describe Radiant::Extension do
     SuperExtension.extension_name.should == "Super"
   end
   
-  it "should store route definitions defined in a block" do
-    Radiant::Extension.should respond_to(:define_routes)
-    my_block = proc {|map| map.stuff "stuff", :controller => "admin/pages" }
-    Radiant::Extension.define_routes(&my_block)
-    Radiant::Extension.route_definitions.should be_instance_of(Array)
-    Radiant::Extension.route_definitions.first.should == my_block
-  end
-
   it "should expose configuration object" do
     SuperExtension.extension_config do |config|
       config.should eql(Rails.configuration)

data/spec/lib/task_support_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
-describe TaskSupport do
+describe Radiant::TaskSupport do
   describe "self.config_export" do
     before do
       @yaml_file = "#{Rails.root}/tmp/config/radiant_config.yml"
@@ -9,11 +9,11 @@ describe TaskSupport do
       File.exist?(@yaml_file).should be_false
     end
     it "should create a YAML file in config/radiant_config.yml" do
-      TaskSupport.config_export(@yaml_file)
+      described_class.config_export(@yaml_file)
       File.exist?(@yaml_file).should be_true
     end
     it "should create YAML equal to Radiant::Config.to_hash" do
-      TaskSupport.config_export(@yaml_file)
+      described_class.config_export(@yaml_file)
       YAML.load_file(@yaml_file).should == Radiant::Config.to_hash.to_yaml
     end
   end
@@ -24,7 +24,7 @@ describe TaskSupport do
     end
     it "should delete all Radiant::Config when the clear parameter is set to true" do
       Radiant::Config['testing_clear'] = 'true'
-      TaskSupport.config_import(@yaml_file, true)
+      described_class.config_import(@yaml_file, true)
       Radiant::Config['testing_clear'].should be_nil
     end
     it "should load from the given YAML path" do
@@ -32,17 +32,17 @@ describe TaskSupport do
       @hash = {}
       YAML.stub!(:load_file).and_return(@yaml)
       YAML.should_receive(:load).with(@yaml).and_return(@hash)
-      TaskSupport.config_import(@yaml_file)
+      described_class.config_import(@yaml_file)
     end
     it "should update Radiant::Config with the settings from the given YAML" do
       Radiant::Config.delete_all
-      TaskSupport.config_import(@yaml_file)
+      described_class.config_import(@yaml_file)
       Radiant::Config.to_hash.should == YAML.load(YAML.load_file(@yaml_file))
     end
     it "should roll back if an invalid config setting is imported" do
       Radiant.config_definitions['defaults.page.status'].stub!(:select_from).and_return(['Draft'])
       Radiant::Config['defaults.page.status'] = "Draft"
-      lambda{TaskSupport.config_import(@bad_yaml_file)}.should_not raise_error
+      lambda{described_class.config_import(@bad_yaml_file)}.should_not raise_error
       Radiant::Config['defaults.page.status'].should == "Draft"
     end
   end
@@ -63,7 +63,7 @@ describe TaskSupport do
     end
 
     it "should create a cache file containing the contents of the specified files" do
-      TaskSupport.cache_files(@dir, @files, @cache_file)
+      described_class.cache_files(@dir, @files, @cache_file)
       cache_path = File.join(@dir, @cache_file)
       File.should exist(cache_path)
       File.read(cache_path).should == "Contents of 'a.txt'\n\nContents of 'b.txt'"
@@ -72,7 +72,7 @@ describe TaskSupport do
 
   describe "self.find_admin_js" do
     it "should return an array of JS files" do
-      js_files = TaskSupport.find_admin_js
+      js_files = described_class.find_admin_js
       js_files.should_not be_empty
       js_files.each { |f| f.should =~ /^[^\/]+.js$/ }
     end
@@ -81,14 +81,14 @@ describe TaskSupport do
   describe "self.cache_admin_js" do
     before do
       @js_files = [ 'a.js','b.js' ]
-      TaskSupport.stub!(:find_admin_js).and_return(@js_files)
-      TaskSupport.stub!(:cache_files)
+      described_class.stub!(:find_admin_js).and_return(@js_files)
+      described_class.stub!(:cache_files)
     end
 
     it "should cache all admin JS files as 'all.js'" do
-      TaskSupport.should_receive(:cache_files).with(
+      described_class.should_receive(:cache_files).with(
         "#{Rails.root}/public/javascripts/admin", @js_files, 'all.js')
-      TaskSupport.cache_admin_js
+      described_class.cache_admin_js
     end
   end
 end

data/spec/models/deprecated_tags_spec.rb

@@ -105,6 +105,13 @@ describe DeprecatedTags do
       end
     end
   end
+
+  describe "<r:rfc1123_date>" do
+    it 'should render an RFC1123-compatible date' do
+      @page.published_at = DateTime.new 2006, 1, 11
+      @page.should render('<r:rfc1123_date />').as('Wed, 11 Jan 2006 00:00:00 GMT')
+    end
+  end
   
   describe "<r:navigation>" do
       it "should render with deprecated url attribute" do
@@ -121,4 +128,4 @@ describe DeprecatedTags do
       end
     end
   end
-end
+end

data/spec/models/radiant/page_response_cache_director_spec.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Radiant::PageResponseCacheDirector do
+  it 'initializes with a page and a listener' do
+    lambda { described_class.new(Object.new, Object.new) }.should_not raise_error
+  end
+
+  it 'errors without a page and a listener' do
+    lambda { described_class.new }.should raise_error
+  end
+
+  it 'has a default cache timeout' do
+    described_class.cache_timeout.should == 5.minutes
+  end
+
+  it 'sets the cache timeout' do
+    old_timeout = described_class.cache_timeout
+    described_class.cache_timeout = 30.days
+    described_class.cache_timeout.should == 30.days
+    described_class.cache_timeout.should_not == old_timeout
+  end
+
+  let(:non_cacheable_params){ {:private => true, "no-cache" => true} }
+  let(:cacheable_params){ {:public => true, :private => false} }
+  let(:listener){ l = OpenStruct.new()
+    l.stub!(:set_etag)
+    l.stub!(:set_expiry)
+    l
+  }
+  let(:page){ OpenStruct.new }
+
+  it 'sets the non-cacheable response' do
+    director = described_class.new(page, listener)
+    listener.should_receive(:set_expiry).with(nil, non_cacheable_params)
+    director.set_cache_control
+  end
+
+  it 'clears the etag' do
+    director = described_class.new(page, listener)
+    listener.should_receive(:set_etag).with('')
+    director.set_cache_control
+  end
+
+  it 'sets the cacheable response to the default timeout' do
+    listener.stub!(:cacheable_request?).and_return(true)
+    page.stub!(:cache?).and_return(true)
+
+    director = described_class.new(page, listener)
+
+    listener.should_receive(:set_expiry).with(described_class.cache_timeout, cacheable_params)
+    director.set_cache_control
+  end
+
+  it 'sets the cacheable response to the page timeout' do
+    listener.stub!(:cacheable_request?).and_return(true)
+    page.stub!(:cache?).and_return(true)
+    page.stub!(:cache_timeout).and_return(14.days)
+
+    director = described_class.new(page, listener)
+
+    listener.should_receive(:set_expiry).with(14.days, cacheable_params)
+    director.set_cache_control
+  end
+
+  it 'is not cacheable if the listener request is not cacheable' do
+    listener.stub!(:cacheable_request?).and_return(false)
+    director = described_class.new(page, listener)
+
+    listener.should_receive(:set_expiry).with(nil, non_cacheable_params)
+    director.set_cache_control
+  end
+
+  it 'is not cacheable if the page is not cacheable' do
+    listener.stub!(:cacheable_request?).and_return(true)
+    page.stub!(:cache?).and_return(false)
+    director = described_class.new(page, listener)
+
+    listener.should_receive(:set_expiry).with(nil, non_cacheable_params)
+    director.set_cache_control
+  end
+end

data/spec/models/standard_tags_spec.rb

@@ -580,11 +580,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&default=http://testhost.tld/images/admin/avatar_32x32.png')
+      page.should render('<r:gravatar />').as('//gravatar.com/avatar/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&default=http://testhost.tld/images/admin/avatar_32x32.png')
+      page.should render('<r:gravatar name="Admin" />').as('//gravatar.com/avatar/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
@@ -596,7 +596,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&default=http://testhost.tld/images/admin/avatar_32x32.png')
+      page.should render('<r:gravatar rating="X" />').as('//gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?rating=X&size=32&default=http://testhost.tld/images/admin/avatar_32x32.png')
     end
   end
 
@@ -822,10 +822,6 @@ describe "Standard Tags" do
     page.should render('<r:escape_html><strong>a bold move</strong></r:escape_html>').as('&lt;strong&gt;a bold move&lt;/strong&gt;')
   end
 
-  it '<r:rfc1123_date> should render an RFC1123-compatible date' do
-    page(:dated).should render('<r:rfc1123_date />').as('Wed, 11 Jan 2006 00:00:00 GMT')
-  end
-
   describe "<r:breadcrumbs>" do
     it "should render a series of breadcrumb links separated by &gt;" do
       expected = %{<a href="/">Home</a> &gt; <a href="/parent/">Parent</a> &gt; <a href="/parent/child/">Child</a> &gt; <a href="/parent/child/grandchild/">Grandchild</a> &gt; Great Grandchild}
@@ -1098,6 +1094,13 @@ describe "Standard Tags" do
     end
     
   end
+  
+  describe "Site tags" do
+    subject { page(:home) }
+    it { should render('<r:site:title />').as('Your site title')}
+    it { should render('<r:site:host />').as('www.example.com')}
+    it { should render('<r:site:dev_host />').as('')}
+  end
 
   private