radiant-scheduler-extension 1.0.0

data/README.md

@@ -0,0 +1,18 @@
+# Radiant Scheduler Extension
+
+[![Build Status](https://secure.travis-ci.org/radiant/radiant-scheduler-extension.png?branch=master)](http://travis-ci.org/radiant/radiant-scheduler-extension)
+
+Created by: Sean Cribbs, September 2007
+
+The Scheduler extension creates publish and expiration dates (or
+appearance and disappearance) that are configurable by the content
+editor.  These may be set in the "meta" area of the page editing
+screen, and include a calendar-style date picker, thanks to Dan Webb's
+wonderful LowPro library (and his date_selector behavior).  These
+dates only affect what may be found from the 'live' site.  All pages
+are accessible when in 'dev' or 'preview' mode.
+   
+## Acknowledgments
+
+Thanks to Digital Pulp, Inc. for funding the initial development of this
+extension as part of the Redken.com project.

data/Rakefile

@@ -0,0 +1,109 @@
+# Determine where the RSpec plugin is by loading the boot
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["RADIANT_ENV_FILE"]
+    require File.dirname(ENV["RADIANT_ENV_FILE"]) + "/boot"
+  when File.dirname(__FILE__) =~ %r{vendor/radiant/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../")}/config/boot"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../")}/config/boot"
+  end
+end
+
+require 'rake'
+require 'rdoc/task'
+require 'rake/testtask'
+
+rspec_base = File.expand_path(RADIANT_ROOT + '/vendor/plugins/rspec/lib')
+$LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base)
+require 'spec/rake/spectask'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+# Cleanup the RADIANT_ROOT constant so specs will load the environment
+Object.send(:remove_const, :RADIANT_ROOT)
+
+extension_root = File.expand_path(File.dirname(__FILE__))
+
+task :default => [:spec, :features]
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :features => 'spec:integration'
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec', '--rails']
+  end
+  
+  desc "Print Specdoc for all specs"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  [:models, :controllers, :views, :helpers].each do |sub|
+    desc "Run the specs under spec/#{sub}"
+    Spec::Rake::SpecTask.new(sub) do |t|
+      t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+      t.spec_files = FileList["spec/#{sub}/**/*_spec.rb"]
+    end
+  end
+  
+  desc "Run the Cucumber features"
+  Cucumber::Rake::Task.new(:integration) do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+    # t.feature_pattern = "#{extension_root}/features/**/*.feature"
+    t.profile = "default"
+  end
+
+  # Setup specs for stats
+  task :statsetup do
+    require 'code_statistics'
+    ::STATS_DIRECTORIES << %w(Model\ specs spec/models)
+    ::STATS_DIRECTORIES << %w(View\ specs spec/views)
+    ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers)
+    ::STATS_DIRECTORIES << %w(Helper\ specs spec/views)
+    ::CodeStatistics::TEST_TYPES << "Model specs"
+    ::CodeStatistics::TEST_TYPES << "View specs"
+    ::CodeStatistics::TEST_TYPES << "Controller specs"
+    ::CodeStatistics::TEST_TYPES << "Helper specs"
+    ::STATS_DIRECTORIES.delete_if {|a| a[0] =~ /test/}
+  end
+
+  namespace :db do
+    namespace :fixtures do
+      desc "Load fixtures (from spec/fixtures) into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+      task :load => :environment do
+        require 'active_record/fixtures'
+        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'spec', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+          Fixtures.create_fixtures('spec/fixtures', File.basename(fixture_file, '.*'))
+        end
+      end
+    end
+  end
+end
+
+desc 'Generate documentation for the scheduler extension.'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SchedulerExtension'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Load any custom rakefiles for extension
+Dir[File.dirname(__FILE__) + '/tasks/*.rake'].sort.each { |f| require f }

data/app/views/admin/pages/_edit_scheduler_meta.html.haml

@@ -0,0 +1,48 @@
+%tr
+  %td{:class=>"label"} Scheduler
+  %td{:class => "field", :style => "text-align: center"}
+    %label{:for => "page_appears_on", :style => "padding: 0 10px;"} Publish date
+    = text_field "page", "appears_on", :size => 15
+    %label{:for => "page_expires_on", :style => "padding: 0 10px;"} Expiration date
+    = text_field "page", "expires_on", :size => 15
+- include_javascript 'lowpro'
+- include_javascript 'date_selector'
+- content_for :page_scripts do
+  :plain
+    Event.addBehavior({
+      '#page_appears_on, #page_expires_on': DateSelector
+    });
+- content_for :page_css do
+  :sass
+    #page_expires_on, #page_appears_on
+      :position relative
+    table.calendar
+      :background white
+      :border 1px solid black
+      td
+        :padding 2px
+        :border 1px solid #eee
+        :background white
+        :text-align right
+        &.today
+          a
+            color: red
+        &.selected
+          :background #ddd
+          :font-weight bold
+          :border-color black
+          :border-width 2px
+      .back, .forward
+        :background #ddd
+      th
+        :background #eee
+      a
+        :text-decoration none
+        :color black
+      tbody
+        tr:last-child td
+          :border-bottom 1px solid black
+        td:first-child
+          :border-left 1px solid black
+        td:last-child
+          :border-right 1px solid black

data/cucumber.yml

@@ -0,0 +1 @@
+default: --format progress features --tags ~@proposed,~@in_progress

data/db/migrate/001_add_schedule_fields.rb

@@ -0,0 +1,11 @@
+class AddScheduleFields < ActiveRecord::Migration
+  def self.up
+    add_column :pages, :appears_on, :date
+    add_column :pages, :expires_on, :date
+  end
+  
+  def self.down
+    remove_column :pages, :appears_on
+    remove_column :pages, :expires_on
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,16 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] = "test"
+# Extension root
+extension_env = File.expand_path(File.dirname(__FILE__) + '/../../../../../config/environment')
+require extension_env+'.rb'
+
+Dir.glob(File.join(RADIANT_ROOT, "features", "**", "*.rb")).each {|step| require step}
+ 
+Cucumber::Rails::World.class_eval do
+  include Dataset
+  datasets_directory "#{RADIANT_ROOT}/spec/datasets"
+  Dataset::Resolver.default = Dataset::DirectoryResolver.new("#{RADIANT_ROOT}/spec/datasets", File.dirname(__FILE__) + '/../../spec/datasets', File.dirname(__FILE__) + '/../datasets')
+  self.datasets_database_dump_path = "#{Rails.root}/tmp/dataset"
+  
+  # dataset :scheduler
+end

data/features/support/paths.rb

@@ -0,0 +1,14 @@
+def path_to(page_name)
+  case page_name
+  
+  when /the homepage/i
+    root_path
+  
+  when /login/i
+    login_path
+  # Add more page name => path mappings here
+  
+  else
+    raise "Can't find mapping from \"#{page_name}\" to a path."
+  end
+end

data/lib/radiant-scheduler-extension.rb

@@ -0,0 +1,8 @@
+module RadiantSchedulerExtension
+  VERSION     = "1.0.0"
+  SUMMARY     = "Scheduler extension for Radiant CMS"
+  DESCRIPTION = "Allows setting of appearance and expiration dates for pages."
+  URL         = "https://github.com/radiant/radiant-scheduler-extension"
+  AUTHORS     = ["Sean Cribbs"]
+  EMAIL       = ["sean@basho.com"]
+end

data/lib/scheduler/controller_extensions.rb

@@ -0,0 +1,10 @@
+module Scheduler::ControllerExtensions
+  def self.included(base)
+    base.class_eval { around_filter :filter_with_scheduler, :if => :live? }
+  end
+
+  protected
+  def filter_with_scheduler
+    Page.with_published_only { yield }
+  end
+end

data/lib/scheduler/page_extensions.rb

@@ -0,0 +1,58 @@
+module Scheduler::PageExtensions
+  include Radiant::Taggable
+
+  def self.included(base)
+    base.extend ClassMethods
+    class << base
+      alias_method_chain :find_by_path, :scheduling
+    end
+  end
+
+  module ClassMethods
+    def find_by_path_with_scheduling(url, live=true)
+      if live
+        self.with_published_only do
+          find_by_path_without_scheduling(url, live)
+        end
+      else
+        find_by_path_without_scheduling(url, live)
+      end
+    end
+
+    def with_published_only
+      if @with_published
+        yield
+      else
+        @with_published = true
+        result = with_scope(:find => {:conditions => ["(appears_on IS NULL OR appears_on <= ?) AND (expires_on IS NULL OR expires_on > ?)", Date.today, Date.today]}) do
+          yield
+        end
+        @with_published = false
+        result
+      end
+    end
+  end
+
+  def visible?
+    published? && appeared? && !expired?
+  end
+
+  def appeared?
+    appears_on.blank? || appears_on <= Date.today
+  end
+
+  def expired?
+    !expires_on.blank? && self.expires_on < Date.today
+  end
+
+  tag 'children' do |tag|
+    tag.locals.children = tag.locals.page.children
+    if dev?(tag.globals.page.request)
+      tag.expand
+    else
+      Page.with_published_only do
+        tag.expand
+      end
+    end
+  end
+end

data/lib/tasks/scheduler_extension_tasks.rake

@@ -0,0 +1,28 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :scheduler do
+      
+      desc "Runs the migration of the Scheduler extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          SchedulerExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          SchedulerExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copies public assets of the Scheduler to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from SchedulerExtension"
+        Dir[SchedulerExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(SchedulerExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory, :verbose => false
+          cp file, RAILS_ROOT + path, :verbose => false
+        end
+      end  
+    end
+  end
+end

data/public/javascripts/date_selector.js

@@ -0,0 +1,181 @@
+
+/* http://svn.danwebb.net/external/lowpro/trunk/behaviours/date_selector.js */
+DateSelector = Behavior.create({
+  initialize: function(options) {
+    this.element.addClassName('date_selector');
+    this.calendar = null;
+    this.options = Object.extend(DateSelector.DEFAULTS, options || {});
+    this.date = this.getDate();
+    this._createCalendar();
+  },
+  setDate : function(value) {
+    this.date = value;
+    this.element.value = this.options.setter(this.date);
+    
+    if (this.calendar)
+      setTimeout(this.calendar.element.hide.bind(this.calendar.element), 500);
+  }, 
+  _createCalendar : function() {
+    var calendar = $div({ 'class' : 'date_selector' });
+    document.body.appendChild(calendar);
+    calendar.setStyle({
+      position : 'absolute',
+      zIndex : '500'
+    });
+    this.calendar = new Calendar(calendar, this);
+  },
+  onclick : function(e) {
+    this.calendar.element.setStyle({  
+      top : Position.cumulativeOffset(this.element)[1] + this.element.getHeight() + 'px',
+      left : Position.cumulativeOffset(this.element)[0] + 'px'
+    });
+    this.calendar.show();
+    Event.stop(e);
+  },
+  onfocus : function(e) {
+    this.onclick(e);
+  },
+  getDate : function() {
+    return this.options.getter(this.element.value) || new Date;
+  }
+});
+
+Calendar = Behavior.create({
+  initialize : function(selector) {
+    this.selector = selector;
+    this.element.hide();
+    Event.observe(document, 'click', this.element.hide.bind(this.element));
+  },
+  show : function() {
+    Calendar.instances.invoke('hide');
+    this.date = this.selector.getDate();
+    this.redraw();
+    this.element.show();
+    this.active = true;
+  },
+  hide : function() {
+    this.element.hide();
+    this.active = false;
+  },
+  redraw : function() {
+    var html = '<table class="calendar">' +
+               '  <thead>' +
+               '    <tr><th class="back"><a href="#">&larr;</a></th>' +
+               '        <th colspan="5" class="month_label">' + this._label() + '</th>' +
+               '        <th class="forward"><a href="#">&rarr;</a></th></tr>' +
+               '    <tr class="day_header">' + this._dayRows() + '</tr>' +
+               '  </thead>' +
+               '  <tbody>';
+    html +=    this._buildDateCells();
+    html +=    '</tbody></table>';
+    this.element.innerHTML = html;
+  },
+  onclick : function(e) {
+    var source = Event.element(e);
+    Event.stop(e);
+    
+    if ($(source.parentNode).hasClassName('day')) return this._setDate(source);
+    if ($(source.parentNode).hasClassName('back')) return this._backMonth();
+    if ($(source.parentNode).hasClassName('forward')) return this._forwardMonth();
+  },
+  _setDate : function(source) {
+    if (source.innerHTML.strip() != '') {
+      this.date.setDate(parseInt(source.innerHTML));
+      this.selector.setDate(this.date);
+      this.element.getElementsByClassName('selected').invoke('removeClassName', 'selected');
+      source.parentNode.addClassName('selected');
+    }
+  },
+  _backMonth : function() {
+    this.date.setMonth(this.date.getMonth() - 1);
+    this.redraw();
+    return false;
+  },
+  _forwardMonth : function() {
+    this.date.setMonth(this.date.getMonth() + 1);
+    this.redraw();
+    return false;
+  },
+  _getDateFromSelector : function() {
+    this.date = new Date(this.selector.date.getTime());
+  },
+  _firstDay : function(month, year) {
+    return new Date(year, month, 1).getDay();
+  },
+  _monthLength : function(month, year) {
+    var length = Calendar.MONTHS[month].days;
+    return (month == 1 && (year % 4 == 0) && (year % 100 != 0)) ? 29 : length;
+  },
+  _label : function() {
+    return Calendar.MONTHS[this.date.getMonth()].label + ' ' + this.date.getFullYear();
+  },
+  _dayRows : function() {
+    for (var i = 0, html='', day; day = Calendar.DAYS[i]; i++)
+      html += '<th>' + day + '</th>';
+    return html;
+  },
+  _buildDateCells : function() {
+    var month = this.date.getMonth(), year = this.date.getFullYear();
+    var day = 1, monthLength = this._monthLength(month, year), firstDay = this._firstDay(month, year);
+    
+    for (var i = 0, html = '<tr>'; i < 9; i++) {
+      for (var j = 0; j <= 6; j++) {
+        
+        if (day <= monthLength && (i > 0 || j >= firstDay)) { 
+          var classes = ['day'];
+          
+          if (this._compareDate(new Date, year, month, day)) classes.push('today');
+          if (this._compareDate(this.selector.date, year, month, day)) classes.push('selected');
+          
+          html += '<td class="' + classes.join(' ') + '">' + 
+                  '<a href="#">' + day++ + '</a>' + 
+                  '</td>';
+        } else html += '<td></td>';
+      }
+      
+      if (day > monthLength) break;
+      else html += '</tr><tr>';
+    }
+    
+    return html + '</tr>';
+  },
+  _compareDate : function(date, year, month, day) {
+    return date.getFullYear() == year &&
+           date.getMonth() == month &&
+           date.getDate() == day;
+  }
+});
+
+DateSelector.DEFAULTS = {
+  setter: function(date) {
+    return [
+      date.getFullYear(), 
+      date.getMonth() + 1,
+      date.getDate()
+    ].join('/');
+  },
+  getter: function(value) {
+    var parsed = Date.parse(value);
+    
+    if (!isNaN(parsed)) return new Date(parsed);
+    else return null;
+  }
+}
+
+Object.extend(Calendar, {
+  DAYS : $w('S M T W T F S'),
+  MONTHS : [
+    { label : 'January', days : 31 },
+    { label : 'February', days : 28 },
+    { label : 'March', days : 31 },
+    { label : 'April', days : 30 },
+    { label : 'May', days : 31 },
+    { label : 'June', days : 30 },
+    { label : 'July', days : 31 },
+    { label : 'August', days : 31 },
+    { label : 'September', days : 30 },
+    { label : 'October', days : 31 },
+    { label : 'November', days : 30 },
+    { label : 'December', days : 31 }
+  ]
+});

data/public/javascripts/lowpro.js

@@ -0,0 +1,338 @@
+LowPro = {};
+LowPro.Version = '0.5';
+LowPro.CompatibleWithPrototype = '1.6';
+
+if (Prototype.Version.indexOf(LowPro.CompatibleWithPrototype) != 0 && window.console && window.console.warn)
+  console.warn("This version of Low Pro is tested with Prototype " + LowPro.CompatibleWithPrototype + 
+                  " it may not work as expected with this version (" + Prototype.Version + ")");
+
+if (!Element.addMethods) 
+  Element.addMethods = function(o) { Object.extend(Element.Methods, o) };
+
+// Simple utility methods for working with the DOM
+DOM = {};
+
+// DOMBuilder for prototype
+DOM.Builder = {
+	tagFunc : function(tag) {
+    return function() {
+     var attrs, children;
+     if (arguments.length>0) {
+       if (arguments[0].constructor == Object) {
+         attrs = arguments[0];
+         children = Array.prototype.slice.call(arguments, 1);
+       } else {
+         children = arguments;
+       };
+       children = $A(children).flatten()
+     }
+     return DOM.Builder.create(tag, attrs, children);
+    };
+  },
+	create : function(tag, attrs, children) {
+		attrs = attrs || {}; children = children || []; tag = tag.toLowerCase();
+		var el = new Element(tag, attrs);
+	  
+		for (var i=0; i<children.length; i++) {
+			if (typeof children[i] == 'string') 
+			  children[i] = document.createTextNode(children[i]);
+			el.appendChild(children[i]);
+		}
+		return $(el);
+	}
+};
+
+// Automatically create node builders as $tagName.
+(function() { 
+	var els = ("p|div|span|strong|em|img|table|tr|td|th|thead|tbody|tfoot|pre|code|" + 
+				     "h1|h2|h3|h4|h5|h6|ul|ol|li|form|input|textarea|legend|fieldset|" + 
+				     "select|option|blockquote|cite|br|hr|dd|dl|dt|address|a|button|abbr|acronym|" +
+				     "script|link|style|bdo|ins|del|object|param|col|colgroup|optgroup|caption|" + 
+				     "label|dfn|kbd|samp|var").split("|");
+  var el, i=0;
+	while (el = els[i++]) 
+	  window['$' + el] = DOM.Builder.tagFunc(el);
+})();
+
+DOM.Builder.fromHTML = function(html) {
+  var root;
+  if (!(root = arguments.callee._root))
+    root = arguments.callee._root = document.createElement('div');
+  root.innerHTML = html;
+  return root.childNodes[0];
+};
+
+
+
+// Wraps the 1.6 contentloaded event for backwards compatibility
+//
+// Usage:
+//
+// Event.onReady(callbackFunction);
+Object.extend(Event, {
+  onReady : function(f) {
+    if (document.body) f();
+    else document.observe('dom:loaded', f);
+  }
+});
+
+// Based on event:Selectors by Justin Palmer
+// http://encytemedia.com/event-selectors/
+//
+// Usage:
+//
+// Event.addBehavior({
+//      "selector:event" : function(event) { /* event handler.  this refers to the element. */ },
+//      "selector" : function() { /* runs function on dom ready.  this refers to the element. */ }
+//      ...
+// });
+//
+// Multiple calls will add to exisiting rules.  Event.addBehavior.reassignAfterAjax and
+// Event.addBehavior.autoTrigger can be adjusted to needs.
+Event.addBehavior = function(rules) {
+  var ab = this.addBehavior;
+  Object.extend(ab.rules, rules);
+  
+  if (!ab.responderApplied) {
+    Ajax.Responders.register({
+      onComplete : function() { 
+        if (Event.addBehavior.reassignAfterAjax) 
+          setTimeout(function() { ab.reload() }, 10);
+      }
+    });
+    ab.responderApplied = true;
+  }
+  
+  if (ab.autoTrigger) {
+    this.onReady(ab.load.bind(ab, rules));
+  }
+  
+};
+
+Event.delegate = function(rules) {
+  return function(e) {
+      var element = $(e.element());
+      for (var selector in rules)
+        if (element.match(selector)) return rules[selector].apply(this, $A(arguments));
+    }
+}
+
+Object.extend(Event.addBehavior, {
+  rules : {}, cache : [],
+  reassignAfterAjax : false,
+  autoTrigger : true,
+  
+  load : function(rules) {
+    for (var selector in rules) {
+      var observer = rules[selector];
+      var sels = selector.split(',');
+      sels.each(function(sel) {
+        var parts = sel.split(/:(?=[a-z]+$)/), css = parts[0], event = parts[1];
+        $$(css).each(function(element) {
+          if (event) {
+            var wrappedObserver = Event.addBehavior._wrapObserver(observer);
+            $(element).observe(event, wrappedObserver);
+            Event.addBehavior.cache.push([element, event, wrappedObserver]);
+          } else {
+            if (!element.$$assigned || !element.$$assigned.include(observer)) {
+              if (observer.attach) observer.attach(element);
+              
+              else observer.call($(element));
+              element.$$assigned = element.$$assigned || [];
+              element.$$assigned.push(observer);
+            }
+          }
+        });
+      });
+    }
+  },
+  
+  unload : function() {
+    this.cache.each(function(c) {
+      Event.stopObserving.apply(Event, c);
+    });
+    this.cache = [];
+  },
+  
+  reload: function() {
+    var ab = Event.addBehavior;
+    ab.unload(); 
+    ab.load(ab.rules);
+  },
+  
+  _wrapObserver: function(observer) {
+    return function(event) {
+      if (observer.call(this, event) === false) event.stop(); 
+    }
+  }
+  
+});
+
+Event.observe(window, 'unload', Event.addBehavior.unload.bind(Event.addBehavior));
+
+// A silly Prototype style shortcut for the reckless
+$$$ = Event.addBehavior.bind(Event);
+
+// Behaviors can be bound to elements to provide an object orientated way of controlling elements
+// and their behavior.  Use Behavior.create() to make a new behavior class then use attach() to
+// glue it to an element.  Each element then gets it's own instance of the behavior and any
+// methods called onxxx are bound to the relevent event.
+// 
+// Usage:
+// 
+// var MyBehavior = Behavior.create({
+//   onmouseover : function() { this.element.addClassName('bong') } 
+// });
+//
+// Event.addBehavior({ 'a.rollover' : MyBehavior });
+// 
+// If you need to pass additional values to initialize use:
+//
+// Event.addBehavior({ 'a.rollover' : MyBehavior(10, { thing : 15 }) })
+//
+// You can also use the attach() method.  If you specify extra arguments to attach they get passed to initialize.
+//
+// MyBehavior.attach(el, values, to, init);
+//
+// Finally, the rawest method is using the new constructor normally:
+// var draggable = new Draggable(element, init, vals);
+//
+// Each behaviour has a collection of all its instances in Behavior.instances
+//
+var Behavior = {
+  create: function() {
+    var parent = null, properties = $A(arguments);
+    if (Object.isFunction(properties[0]))
+      parent = properties.shift();
+
+      var behavior = function() { 
+        if (!this.initialize) {
+          var args = $A(arguments);
+
+          return function() {
+            var initArgs = [this].concat(args);
+            behavior.attach.apply(behavior, initArgs);
+          };
+        } else {
+          var args = (arguments.length == 2 && arguments[1] instanceof Array) ? 
+                      arguments[1] : Array.prototype.slice.call(arguments, 1);
+
+          this.element = $(arguments[0]);
+          this.initialize.apply(this, args);
+          behavior._bindEvents(this);
+          behavior.instances.push(this);
+        }
+      };
+
+    Object.extend(behavior, Class.Methods);
+    Object.extend(behavior, Behavior.Methods);
+    behavior.superclass = parent;
+    behavior.subclasses = [];
+    behavior.instances = [];
+
+    if (parent) {
+      var subclass = function() { };
+      subclass.prototype = parent.prototype;
+      behavior.prototype = new subclass;
+      parent.subclasses.push(behavior);
+    }
+
+    for (var i = 0; i < properties.length; i++)
+      behavior.addMethods(properties[i]);
+
+    if (!behavior.prototype.initialize)
+      behavior.prototype.initialize = Prototype.emptyFunction;
+
+    behavior.prototype.constructor = behavior;
+
+    return behavior;
+  },
+  Methods : {
+    attach : function(element) {
+      return new this(element, Array.prototype.slice.call(arguments, 1));
+    },
+    _bindEvents : function(bound) {
+      for (var member in bound) {
+        var matches = member.match(/^on(.+)/);
+        if (matches && typeof bound[member] == 'function')
+          bound.element.observe(matches[1], Event.addBehavior._wrapObserver(bound[member].bindAsEventListener(bound)));
+      }
+    }
+  }
+};
+
+
+
+Remote = Behavior.create({
+  initialize: function(options) {
+    if (this.element.nodeName == 'FORM') new Remote.Form(this.element, options);
+    else new Remote.Link(this.element, options);
+  }
+});
+
+Remote.Base = {
+  initialize : function(options) {
+    this.options = Object.extend({
+      evaluateScripts : true
+    }, options || {});
+    
+    this._bindCallbacks();
+  },
+  _makeRequest : function(options) {
+    if (options.update) new Ajax.Updater(options.update, options.url, options);
+    else new Ajax.Request(options.url, options);
+    return false;
+  },
+  _bindCallbacks: function() {
+    $w('onCreate onComplete onException onFailure onInteractive onLoading onLoaded onSuccess').each(function(cb) {
+      if (Object.isFunction(this.options[cb]))
+        this.options[cb] = this.options[cb].bind(this);
+    }.bind(this));
+  }
+}
+
+Remote.Link = Behavior.create(Remote.Base, {
+  onclick : function() {
+    var options = Object.extend({ url : this.element.href, method : 'get' }, this.options);
+    return this._makeRequest(options);
+  }
+});
+
+
+Remote.Form = Behavior.create(Remote.Base, {
+  onclick : function(e) {
+    var sourceElement = e.element();
+    
+    if (['input', 'button'].include(sourceElement.nodeName.toLowerCase()) && 
+        sourceElement.type == 'submit')
+      this._submitButton = sourceElement;
+  },
+  onsubmit : function() {
+    var options = Object.extend({
+      url : this.element.action,
+      method : this.element.method || 'get',
+      parameters : this.element.serialize({ submit: this._submitButton.name })
+    }, this.options);
+    this._submitButton = null;
+    return this._makeRequest(options);
+  }
+});
+
+Observed = Behavior.create({
+  initialize : function(callback, options) {
+    this.callback = callback.bind(this);
+    this.options = options || {};
+    this.observer = (this.element.nodeName == 'FORM') ? this._observeForm() : this._observeField();
+  },
+  stop: function() {
+    this.observer.stop();
+  },
+  _observeForm: function() {
+    return (this.options.frequency) ? new Form.Observer(this.element, this.options.frequency, this.callback) :
+                                      new Form.EventObserver(this.element, this.callback);
+  },
+  _observeField: function() {
+    return (this.options.frequency) ? new Form.Element.Observer(this.element, this.options.frequency, this.callback) :
+                                      new Form.Element.EventObserver(this.element, this.callback);
+  }
+});

data/radiant-scheduler-extension.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "radiant-scheduler-extension"
+
+Gem::Specification.new do |s|
+  s.name        = "radiant-scheduler-extension"
+  s.version     = RadiantSchedulerExtension::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = RadiantSchedulerExtension::AUTHORS
+  s.email       = RadiantSchedulerExtension::EMAIL
+  s.homepage    = RadiantSchedulerExtension::URL
+  s.summary     = RadiantSchedulerExtension::SUMMARY
+  s.description = RadiantSchedulerExtension::DESCRIPTION
+
+  # Define gem dependencies here.
+  # Don't include a dependency on radiant itself: it causes problems when radiant is in vendor/radiant.
+  # s.add_dependency "something", "~> 1.0.0"
+  # s.add_dependency "radiant-some-extension", "~> 1.0.0"
+
+  ignores = if File.exist?('.gitignore')
+    File.read('.gitignore').split("\n").inject([]) {|a,p| a + Dir[p] }
+  else
+    []
+  end
+  s.files         = Dir['**/*'] - ignores
+  s.test_files    = Dir['test/**/*','spec/**/*','features/**/*'] - ignores
+  # s.executables   = Dir['bin/*'] - ignores
+  s.require_paths = ["lib"]
+end

data/scheduler_extension.rb

@@ -0,0 +1,16 @@
+# Uncomment this if you reference any of your controllers in activate
+require_dependency 'application_controller'
+
+require 'radiant-scheduler-extension'
+
+class SchedulerExtension < Radiant::Extension
+  version RadiantSchedulerExtension::VERSION
+  description RadiantSchedulerExtension::DESCRIPTION
+  url RadiantSchedulerExtension::URL
+    
+  def activate
+    Page.send :include, Scheduler::PageExtensions
+    SiteController.send :include, Scheduler::ControllerExtensions
+    admin.pages.edit.add :extended_metadata, "edit_scheduler_meta"
+  end
+end

data/spec/ci/before_script

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+cd ~
+git clone git://github.com/radiant/radiant.git
+cd ~/radiant
+if [[ $RADIANT_VERSION != "master" ]]
+then
+  git checkout -b $RADIANT_VERSION $RADIANT_VERSION
+fi
+cp -r ~/builds/*/radiant-scheduler-extension vendor/extensions/scheduler
+bundle install
+
+case $DB in
+  "mysql" )
+    mysql -e 'create database radiant_test;'
+    cp spec/ci/database.mysql.yml config/database.yml;;
+  "postgres" )
+    psql -c 'create database radiant_test;' -U postgres
+    cp spec/ci/database.postgresql.yml config/database.yml;;
+esac
+
+bundle exec rake db:migrate
+bundle exec rake db:migrate:extensions

data/spec/ci/script

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+cd ~/radiant
+bundle exec rake spec:extensions EXT=scheduler

data/spec/controllers/controller_extensions_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path '../../spec_helper', __FILE__
+
+describe "Scheduler::ControllerExtensions", :type => :controller do
+  dataset :pages_with_scheduling
+  controller_name :site
+  
+  it "should not render invisible pages in live mode" do
+    get :show_page, :url => ['expired']
+    response.should_not be_success
+  end
+
+  it "should render invisible pages in dev mode" do
+    request.host = "dev.example.com"
+    get :show_page, :url => ['expired']
+    response.should be_success
+  end
+end

data/spec/datasets/pages_with_scheduling_dataset.rb

@@ -0,0 +1,14 @@
+class PagesWithSchedulingDataset < Dataset::Base
+  uses :pages
+  
+  def load
+    create_page "Expired", :appears_on => 2.days.ago.to_date, :expires_on => Date.yesterday
+    create_page "Expired blank start", :expires_on => Date.yesterday
+    create_page "Blank schedule"
+    create_page "Visible blank start", :expires_on => Date.tomorrow
+    create_page "Visible", :appears_on => Date.yesterday, :expires_on => Date.tomorrow
+    create_page "Visible blank end", :appears_on => Date.yesterday
+    create_page "Unappeared blank end", :appears_on => Date.tomorrow
+    create_page "Unappeared", :appears_on => Date.tomorrow, :expires_on => 2.days.from_now.to_date
+  end
+end

data/spec/models/page_extensions_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path '../../spec_helper', __FILE__
+
+describe "Scheduler::PageExtensions" do
+  dataset :pages_with_scheduling
+
+  describe "finding pages" do
+    it "should wrap the find_by_path method" do
+      Page.should respond_to(:find_by_path_with_scheduling)
+    end
+
+    it "should find visible pages in both modes" do
+      [true, false].each do |live|
+        [:blank_schedule, :visible, :visible_blank_start, :visible_blank_end].each do |page|
+          Page.find_by_path(pages(page).url, live).should == pages(page)
+        end
+      end
+    end
+
+    it "should not find pages scheduled outside the window when live" do
+      [:expired, :expired_blank_start, :unappeared, :unappeared_blank_end].each do |page|
+        Page.find_by_path(pages(page).url).should_not == pages(page)
+      end
+    end
+
+    it "should find pages scheduled outside the window when dev" do
+      [:expired, :expired_blank_start, :unappeared, :unappeared_blank_end].each do |page|
+        Page.find_by_path(pages(page).url, false).should == pages(page)
+      end
+    end
+  end
+
+  describe "scheduling interrogators" do
+    before :each do
+      @page = Page.new
+    end
+
+    describe "appeared?" do
+      it "should be true when the page has no limits" do
+        @page.should be_appeared
+      end
+
+      it "should be true when the page has no start date" do
+        @page.appears_on = nil
+        @page.expires_on = Date.tomorrow
+        @page.should be_appeared
+      end
+
+      it "should be true when the start date is in the past" do
+        @page.appears_on = Date.yesterday
+        @page.expires_on = Date.tomorrow
+        @page.should be_appeared
+      end
+
+      it "should be false when the start date is in the future" do
+        @page.appears_on = Date.tomorrow
+        @page.should_not be_appeared
+      end
+    end
+
+    describe "expired?" do
+      it "should be false when the page has no limits" do
+        @page.should_not be_expired
+      end
+
+      it "should be false when the page has no end date" do
+        @page.appears_on = Date.yesterday
+        @page.expires_on = nil
+        @page.should_not be_expired
+      end
+
+      it "should be false when the end date is in the future" do
+        @page.expires_on = Date.tomorrow
+        @page.should_not be_expired
+      end
+
+      it "should be true when the end date is in the past" do
+        @page.expires_on = Date.yesterday
+        @page.should be_expired
+      end
+    end
+
+    describe "visible?" do
+      before :each do
+        @page.stub!(:published?).and_return(true)
+      end
+
+      it "should be true when the page is appeared and not expired" do
+        @page.stub!(:appeared?).and_return(true)
+        @page.stub!(:expired?).and_return(false)
+        @page.should be_visible
+      end
+      it "should be false when the page has not appeared" do
+        @page.stub!(:appeared?).and_return(false)
+        @page.stub!(:expired?).and_return(false)
+        @page.should_not be_visible
+      end
+      it "should be false when the page has expired" do
+        @page.stub!(:appeared?).and_return(true)
+        @page.stub!(:expired?).and_return(true)
+        @page.should_not be_visible
+      end
+      it "should be false when the page is unpublished" do
+        @page.stub!(:published?).and_return(false)
+        @page.should_not be_visible
+      end
+    end
+  end
+
+  describe "<r:children>" do
+    before :each do
+      raise "dev site configured" if Radiant::Config['dev.site']
+    end
+
+    it "should render only visible children in live mode" do
+      pages(:home).should render("<r:children:each><r:title /> </r:children:each>").matching(%r{^((?!expired)(?!unappeared).)*$}i)
+    end
+
+    it "should render all children in dev mode" do
+      pages(:home).should render("<r:children:each><r:title /> </r:children:each>").matching(%r{expired}i).on("dev.example.com")
+      pages(:home).should render("<r:children:each><r:title /> </r:children:each>").matching(%r{unappeared}i).on("dev.example.com")
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["RADIANT_ENV_FILE"]
+    require ENV["RADIANT_ENV_FILE"]
+  when File.dirname(__FILE__) =~ %r{vendor/radiant/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../../")}/config/environment"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../")}/config/environment"
+  end
+end
+require "#{RADIANT_ROOT}/spec/spec_helper"
+
+Dataset::Resolver.default << (File.dirname(__FILE__) + "/datasets")
+
+if File.directory?(File.dirname(__FILE__) + "/matchers")
+  Dir[File.dirname(__FILE__) + "/matchers/*.rb"].each {|file| require file }
+end
+
+Spec::Runner.configure do |config|
+  # config.use_transactional_fixtures = true
+  # config.use_instantiated_fixtures  = false
+  # config.fixture_path = RAILS_ROOT + '/spec/fixtures'
+
+  # You can declare fixtures for each behaviour like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so here, like so ...
+  #
+  #   config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: radiant-scheduler-extension
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Sean Cribbs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-29 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Allows setting of appearance and expiration dates for pages.
+email: 
+- sean@basho.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/views/admin/pages/_edit_scheduler_meta.html.haml
+- cucumber.yml
+- db/migrate/001_add_schedule_fields.rb
+- features/support/env.rb
+- features/support/paths.rb
+- lib/radiant-scheduler-extension.rb
+- lib/scheduler/controller_extensions.rb
+- lib/scheduler/page_extensions.rb
+- lib/tasks/scheduler_extension_tasks.rake
+- public/javascripts/date_selector.js
+- public/javascripts/lowpro.js
+- radiant-scheduler-extension.gemspec
+- Rakefile
+- README.md
+- scheduler_extension.rb
+- spec/ci/before_script
+- spec/ci/script
+- spec/controllers/controller_extensions_spec.rb
+- spec/datasets/pages_with_scheduling_dataset.rb
+- spec/models/page_extensions_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/radiant/radiant-scheduler-extension
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.9.3
+signing_key: 
+specification_version: 3
+summary: Scheduler extension for Radiant CMS
+test_files: 
+- spec/ci/before_script
+- spec/ci/script
+- spec/controllers/controller_extensions_spec.rb
+- spec/datasets/pages_with_scheduling_dataset.rb
+- spec/models/page_extensions_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- features/support/env.rb
+- features/support/paths.rb