couch_scheduler 0.0.1

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/features/couch_publish_integration.feature

@@ -0,0 +1,35 @@
+Feature: CouchPublish Integration
+  As a programmer
+  I want to integrate CouchScheduler with CouchPublish
+  So that I can query my database for published documents within a schedule
+
+  Scenario: Query for published documents within a schedule
+    Given an Article model that includes CouchPublish and CouchVisible
+    When I create several published articles scheduled now and in the future
+    And I create several unpublished articles scheduled now and in the future
+    When I call "Article.by_schedule_and_published"
+    Then I should receive the published documents scheduled now
+    When I call "Article.by_schedule_and_unpublished"
+    Then I should receive the unpublished documents scheduled now
+    When I wait till the future
+    And I call "Article.by_schedule_and_published"
+    Then I should receive the published documents scheduled in the future
+    When I call "Article.by_schedule_and_unpublished"
+    Then I should receive the unpublished documents scheduled in the future
+ 
+  @focus
+  Scenario: Count of published and unpublished documents within a schedule
+    Given an Article model that includes CouchPublish and CouchVisible
+    When I create 2 published articles scheduled now
+    And I create 3 published articles schedule in the future
+    And I create 4 unpublished articles scheduled now
+    And I create 7 unpublished articles schedule in the future
+    When I call "Article.count_schedule_and_published"
+    Then I should receive 2
+    When I call "Article.count_schedule_and_unpublished"
+    Then I should receive 4
+    When I wait till the future
+    And I call "Article.count_schedule_and_published"
+    Then I should receive 3
+    When I call "Article.count_schedule_and_unpublished"
+    Then I should receive 7   

data/features/couch_visible_and_couch_publish_integration.feature

@@ -0,0 +1,35 @@
+Feature: CouchVisible and CouchPublish Integration
+  As a programmer
+  I want to integrate CouchScheduler and CouchPublish with CouchVisible
+  So that I can query my database for shown, published documents within a schedule
+
+  Scenario: Query for shown, published documents within a schedule
+    Given a Slide model that includes CouchVisible, CouchPublish and CouchScheduler
+    When I create several shown, published slides scheduled now and in the future
+    And I create several hidden, published slides scheduled now and in the future
+    When I call "Slide.by_schedule_and_published_and_shown"
+    Then I should receive the shown, published documents scheduled now
+    When I call "Slide.by_schedule_and_published_and_hidden"
+    Then I should receive the hidden, published documents scheduled now
+    When I wait till the future
+    And I call "Slide.by_schedule_and_published_and_shown"
+    Then I should receive the shown, published documents scheduled in the future
+    When I call "Slide.by_schedule_and_published_and_hidden"
+    Then I should receive the hidden, published documents scheduled in the future
+ 
+  @focus
+  Scenario: Count of shown and hidden documents within a schedule
+    Given a Slide model that includes CouchVisible, CouchPublish and CouchScheduler
+    When I create 2 shown, published slides scheduled now
+    And I create 3 shown, published slides schedule in the future
+    And I create 4 hidden, published slides scheduled now
+    And I create 7 hidden, published slides schedule in the future
+    When I call "Slide.count_schedule_and_published_and_shown"
+    Then I should receive 2
+    When I call "Slide.count_schedule_and_published_and_hidden"
+    Then I should receive 4
+    When I wait till the future
+    And I call "Slide.count_schedule_and_published_and_shown"
+    Then I should receive 3
+    When I call "Slide.count_schedule_and_published_and_hidden"
+    Then I should receive 7

data/features/couch_visible_integration.feature

@@ -0,0 +1,35 @@
+Feature: CouchVisible Integration
+  As a programmer
+  I want to integrate CouchScheduler with CouchVisible
+  So that I can query my database for shown documents within a schedule
+
+  Scenario: Query for shown documents within a schedule
+    Given an Post model that includes CouchVisible and CouchScheduler
+    When I create several shown posts scheduled now and in the future
+    And I create several hidden posts scheduled now and in the future
+    When I call "Post.by_schedule_and_shown"
+    Then I should receive the shown documents scheduled now
+    When I call "Post.by_schedule_and_hidden"
+    Then I should receive the hidden documents scheduled now
+    When I wait till the future
+    And I call "Post.by_schedule_and_shown"
+    Then I should receive the shown documents scheduled in the future
+    When I call "Post.by_schedule_and_hidden"
+    Then I should receive the hidden documents scheduled in the future
+  
+  @focus 
+  Scenario: Count of shown and hidden documents within a schedule
+    Given an Post model that includes CouchVisible and CouchScheduler
+    When I create 2 shown posts scheduled now
+    And I create 3 shown posts schedule in the future
+    And I create 4 hidden posts scheduled now
+    And I create 7 hidden posts schedule in the future
+    When I call "Post.count_schedule_and_shown"
+    Then I should receive 2
+    When I call "Post.count_schedule_and_hidden"
+    Then I should receive 4
+    When I wait till the future
+    And I call "Post.count_schedule_and_shown"
+    Then I should receive 3
+    When I call "Post.count_schedule_and_hidden"
+    Then I should receive 7   

data/features/scheduling.feature

@@ -0,0 +1,55 @@
+Feature: Scheduling
+  As a programmer
+  I want the ability to schedule my documents
+  So that I can control when they are accessible
+
+  Scenario: Setting valid start and end dates
+    Given an instance of a model that includes CouchScheduler
+    When I set "start" to now
+    And I set "end" to a day from now
+    Then I should be able to save my document
+  
+  Scenario: Setting invalid start and end dates
+    Given an instance of a model that includes CouchScheduler
+    When I set "start" to now
+    And I set "end" to yesterday
+    Then I should not be able to save my document
+    And I should get an error message that the end "must be greater than start"
+
+  Scenario: Determining if a document is within it's schedule 
+    Given an instance of a model that includes CouchScheduler
+    When I set "start" to now
+    And I set "end" to a day from now
+    Then "within_schedule?" should return true on my instance
+    When I wait two days
+    Then "within_schedule?" should return false on my instance
+  
+  Scenario: Determining if a document is within it's schedule for a document that has only a start date
+    Given an instance of a model that includes CouchScheduler
+    When I set "start" to a day from now
+    Then "within_schedule?" should return false on my instance
+    When I wait two days
+    Then "within_schedule?" should return true on my instance
+
+  Scenario: Determining if a document is within it's schedule for a document that has only an end date
+    Given an instance of a model that includes CouchScheduler
+    When I set "end" to a day from now
+    Then "within_schedule?" should return true on my instance
+    When I wait two days
+    Then "within_schedule?" should return false on my instance
+  
+  Scenario: Getting all documents that are within schedule on a given date 
+    Given there are several documents currently scheduled
+    And there are several documents scheduled in the future
+    Then "by_schedule" should return the documents currently within schedule
+    And "by_schedule" should not return the documents scheduled in the future
+
+  Scenario: Counting documents
+    Given there are 3 documents scheduled between now and tomorrow
+    And ther are 10 documents scheduled between tomorrow and two days from now
+    Then "count_schedule" should return 3
+    And "count_schedule :key => 1.day.from_now" should return 10
+    When I wait a day
+    Then "count_schedule" should return 10
+    When I wait another day
+    Then "count_schedule" should return 0

data/features/step_definitions/couch_publish_integration.rb

@@ -0,0 +1,74 @@
+Given /^an Article model that includes CouchPublish and CouchVisible$/ do
+  unless defined?(Article)
+    class Article < CouchRest::Model::Base
+      include CouchPublish
+      include CouchScheduler
+    end
+  end
+end
+
+When /^I create several published articles scheduled now and in the future$/ do
+  @published_now = []
+  @published_future = []
+
+  5.times { @published_now << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish! } }
+  5.times { @published_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish! } }
+end
+
+When /^I create several unpublished articles scheduled now and in the future$/ do
+  @unpublished_now = []
+  @unpublished_future = []
+
+  5.times { @unpublished_now << Article.create(:start => Time.now, :end => 1.day.from_now) }
+  5.times { @unpublished_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now) }
+end
+
+When /^I call "([^"]*)"$/ do |code|
+  @result = eval code
+end
+
+Then /^I should receive the published documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @published_now.collect(&:id).sort
+end
+
+Then /^I should receive the unpublished documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @unpublished_now.collect(&:id).sort
+end
+
+When /^I wait till the future$/ do
+  Timecop.freeze 1.day.from_now
+end
+
+Then /^I should receive the published documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @published_future.collect(&:id).sort
+end
+
+Then /^I should receive the unpublished documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @unpublished_future.collect(&:id).sort
+end
+
+When /^I create (\d+) published articles scheduled now$/ do |num|
+  @published_now = []
+  num.to_i.times { @published_now << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!}}
+end
+
+When /^I create (\d+) published articles schedule in the future$/ do |num|
+  @published_future = []
+  num.to_i.times { @published_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!}}
+end
+
+When /^I create (\d+) unpublished articles scheduled now$/ do |num|
+  @unpublished_now = []
+  num.to_i.times { @unpublished_now << Article.create(:start => Time.now, :end => 1.day.from_now)}
+end
+
+When /^I create (\d+) unpublished articles schedule in the future$/ do |num|
+  @unpublished_future = []
+  num.to_i.times { @unpublished_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+end
+
+Then /^I should receive (\d+)$/ do |count|
+  @result.should == count.to_i
+end
+
+

data/features/step_definitions/couch_visible_and_couch_publish_integration.rb

@@ -0,0 +1,61 @@
+Given /^a Slide model that includes CouchVisible, CouchPublish and CouchScheduler$/ do
+  unless defined? Slide
+    class Slide < CouchRest::Model::Base
+      include CouchVisible
+      include CouchPublish
+      include CouchScheduler
+    end
+  end
+end
+
+When /^I create several shown, published slides scheduled now and in the future$/ do
+  @published_shown_now = []
+  @published_shown_future = []
+
+  5.times { @published_shown_now << Slide.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.publish! } }
+  5.times { @published_shown_future << Slide.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.publish! } }
+end
+
+When /^I create several hidden, published slides scheduled now and in the future$/ do
+  @published_hidden_now = []
+  @published_hidden_future = []
+
+  5.times { @published_hidden_now    << Slide.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.hide!; a.publish! } }
+  5.times { @published_hidden_future << Slide.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.hide!; a.publish! } }
+end
+
+Then /^I should receive the shown, published documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @published_shown_now.collect(&:id).sort
+end
+
+Then /^I should receive the hidden, published documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @published_hidden_now.collect(&:id).sort
+end
+
+Then /^I should receive the shown, published documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @published_shown_future.collect(&:id).sort
+end
+
+Then /^I should receive the hidden, published documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @published_hidden_future.collect(&:id).sort
+end
+
+When /^I create (\d+) shown, published slides scheduled now$/ do |num|
+  @published_shown_now = []
+  num.to_i.times { @published_shown_now << Slide.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.publish!}}
+end
+
+When /^I create (\d+) shown, published slides schedule in the future$/ do |num|
+  @published_shown_future = []
+  num.to_i.times { @published_shown_future << Slide.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.publish!}}
+end
+
+When /^I create (\d+) hidden, published slides scheduled now$/ do |num|
+  @published_hidden_now = []
+  num.to_i.times { @published_hidden_now << Slide.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.hide!; a.publish!}}
+end
+
+When /^I create (\d+) hidden, published slides schedule in the future$/ do |num|
+  @published_hidden_future = []
+  num.to_i.times { @published_hidden_future << Slide.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.hide!; a.publish!}}
+end

data/features/step_definitions/couch_visible_integration.rb

@@ -0,0 +1,60 @@
+Given /^an Post model that includes CouchVisible and CouchScheduler$/ do
+  unless defined? Post
+    class Post < CouchRest::Model::Base 
+      include CouchVisible
+      include CouchScheduler
+    end
+  end
+end
+
+When /^I create several shown posts scheduled now and in the future$/ do
+  @shown_now = []
+  @shown_future = []
+
+  5.times { @shown_now    << Post.create(:start => Time.now,       :end => 1.day.from_now ).tap {|a| a.show!; a.save }}
+  5.times { @shown_future << Post.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save }}
+end
+
+When /^I create several hidden posts scheduled now and in the future$/ do
+  @hidden_now = []
+  @hidden_future = []
+
+  5.times { @hidden_now    << Post.create(:start => Time.now,       :end => 1.day.from_now ).tap {|a| a.hide!; a.save }}
+  5.times { @hidden_future << Post.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.hide!; a.save }}
+end
+
+Then /^I should receive the shown documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @shown_now.collect(&:id).sort
+end
+
+Then /^I should receive the hidden documents scheduled now$/ do
+  @result.collect(&:id).sort.should == @hidden_now.collect(&:id).sort
+end
+
+Then /^I should receive the shown documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @shown_future.collect(&:id).sort
+end
+
+Then /^I should receive the hidden documents scheduled in the future$/ do
+  @result.collect(&:id).sort.should == @hidden_future.collect(&:id).sort
+end
+
+When /^I create (\d+) shown posts scheduled now$/ do |num|
+  @shown_now = []
+  num.to_i.times { @shown_now    << Post.create(:start => Time.now,       :end => 1.day.from_now ).tap {|a| a.show!; a.save }}
+end
+
+When /^I create (\d+) shown posts schedule in the future$/ do |num|
+  @shown_future = []
+  num.to_i.times { @shown_future << Post.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save }}
+end
+
+When /^I create (\d+) hidden posts scheduled now$/ do |num|
+  @hidden_now = []
+  num.to_i.times { @hidden_now << Post.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.hide!; a.save }}
+end
+
+When /^I create (\d+) hidden posts schedule in the future$/ do |num|
+  @hidden_future = []
+  num.to_i.times { @hidden_future << Post.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.hide!; a.save }}
+end

data/features/step_definitions/scheduling.rb

@@ -0,0 +1,107 @@
+Given /^an instance of a model that includes CouchScheduler$/ do
+  class Model < CouchRest::Model::Base
+    include CouchScheduler
+  end
+  @instance = Model.new
+end
+
+When /^I set "([^"]*)" to now$/ do |property|
+  @instance.send "#{property}=", Time.now
+end
+
+When /^I set "([^"]*)" to a day from now$/ do |property|
+  @instance.send "#{property}=", 1.day.from_now
+end
+
+Then /^I should be able to save my document$/ do
+  @instance.save
+  @instance.errors.empty?.should be(true)
+end
+
+When /^I set "([^"]*)" to yesterday$/ do |property|
+  @instance.send "#{property}=", 1.day.ago
+end
+
+Then /^I should not be able to save my document$/ do
+  @instance.save
+  @instance.errors.empty?.should be(false)
+end
+
+Then /^I should get an error message that the end "([^"]*)"$/ do |end_message|
+  @instance.errors[:end].should == [end_message]
+end
+
+Then /^"([^"]*)" should return true on my instance$/ do |method|
+  @instance.send(method).should be(true)
+end
+
+When /^I set "([^"]*)" to a week from now$/ do |property|
+  @instance.send "#{property}=", 1.week.from_now
+end
+
+Then /^"([^"]*)" should return false on my instance$/ do |method|
+  @instance.send(method).should be(false)
+end
+
+When /^I wait two days$/ do
+  tomorrow = 2.days.from_now.beginning_of_day
+  Timecop.freeze tomorrow
+end
+
+Then /^"([^"]*)" should return the documents currently within schedule$/ do |method|
+  @result = Document.send(method).collect &:id
+  @currently_scheduled.collect(&:id).sort.should == @result.sort
+end
+
+Then /^"([^"]*)" should not return the documents scheduled in the future$/ do |method|
+  @result = Document.send(method)
+  (@future_scheduled.collect(&:id) - @result.collect(&:id)).should == @future_scheduled.collect(&:id)
+end
+
+Given /^there are several documents currently scheduled$/ do
+  unless defined? Document
+    class Document < CouchRest::Model::Base
+      include CouchScheduler
+    end
+  end
+
+  @currently_scheduled = []
+  4.times { @currently_scheduled << Document.create(:start => Time.now, :end => 4.days.from_now) }
+end
+
+Given /^there are several documents scheduled in the future$/ do
+  unless defined? Document
+    class Document < CouchRest::Model::Base
+      include CouchScheduler
+    end
+  end
+
+  @future_scheduled = []
+  10.times { @future_scheduled << Document.create(:start => 1.day.from_now, :end => 4.days.from_now) }
+end
+
+Given /^there are (\d+) documents scheduled between now and tomorrow$/ do |num|
+  unless defined? Document
+    class Document < CouchRest::Model::Base
+      include CouchScheduler
+    end
+  end
+  num.to_i.times { Document.create :start => Time.now, :end => 1.day.from_now }
+end
+
+Given /^ther are (\d+) documents scheduled between tomorrow and two days from now$/ do |num|
+  num.to_i.times { Document.create :start => 1.day.from_now, :end => 2.days.from_now }
+end
+
+Then /^"([^"]*)" should return (\d+)$/ do |code, num|
+  eval("Document.#{code}").should == num.to_i
+end
+
+When /^I wait a day$/ do
+  Timecop.freeze 1.day.from_now
+end
+
+When /^I wait another day$/ do
+  Timecop.freeze 1.day.from_now
+end
+

data/features/support/env.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift './lib'
+
+require 'couch_scheduler'
+require 'couchrest_model_config'
+require 'couch_publish'
+require 'couch_visible'
+require 'timecop'
+
+CouchRest::Model::Config.edit do
+  database do
+    default "http://admin:password@localhost:5984/couch_scheduler_test"
+  end
+end
+
+Before do
+  CouchRest::Model::Config.default_database.recreate!
+  Timecop.return
+end

data/lib/couch_scheduler.rb

@@ -0,0 +1,7 @@
+require 'couchrest_model'
+require 'couch_scheduler/time_massager'
+require 'couch_scheduler/map'
+require 'couch_scheduler/couch_visible_integration'
+require 'couch_scheduler/couch_publish_integration'
+require 'couch_scheduler/couch_publish_and_couch_visible_integration'
+require 'couch_scheduler/couch_scheduler'

data/lib/couch_scheduler/couch_publish_and_couch_visible_integration.rb

@@ -0,0 +1,27 @@
+module CouchScheduler
+  module CouchVisibleCouchPublishIntegration
+    def self.included(base)
+      base.extend ClassMethods
+      base.view_by :couch_schedule_and_published_and_shown, :map => Map.new(base, :published, :shown).to_s, :reduce => '_count'
+      base.view_by :couch_schedule_and_published_and_hidden, :map => Map.new(base, :published, :hidden).to_s, :reduce => '_count'
+    end
+
+    module ClassMethods
+      def by_schedule_and_published_and_shown(options={})
+        by_couch_schedule_and_shown CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def by_schedule_and_published_and_hidden(options={})
+        by_couch_schedule_and_hidden CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def count_schedule_and_published_and_shown(options={})
+        count_by_map :by_schedule_and_published_and_shown, options
+      end
+
+      def count_schedule_and_published_and_hidden(options={})
+        count_by_map :by_schedule_and_published_and_hidden, options
+      end
+    end
+  end
+end

data/lib/couch_scheduler/couch_publish_integration.rb

@@ -0,0 +1,27 @@
+module CouchScheduler
+  module CouchPublishIntegration
+    def self.included(base)
+      base.extend ClassMethods
+      base.view_by :couch_schedule_and_unpublished, :map => Map.new(base, :unpublished).to_s, :reduce => '_count'
+      base.view_by :couch_schedule_and_published, :map => Map.new(base, :published).to_s, :reduce => '_count'
+    end
+
+    module ClassMethods
+      def by_schedule_and_published(options={})
+        by_couch_schedule_and_published CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def by_schedule_and_unpublished(options={})
+        by_couch_schedule_and_unpublished CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def count_schedule_and_published(options={})
+        count_by_map :by_schedule_and_published, options
+      end
+
+      def count_schedule_and_unpublished(options={})
+        count_by_map :by_schedule_and_unpublished, options
+      end
+    end
+  end
+end

data/lib/couch_scheduler/couch_scheduler.rb

@@ -0,0 +1,54 @@
+module CouchScheduler
+  def self.included(base)
+    base.property :start, Time
+    base.property :end, Time
+    base.validate :validate_start_and_end
+    base.view_by :couch_schedule, :map => Map.new(base).to_s, :reduce => '_count'
+    base.extend ClassMethods
+
+    if defined?(CouchPublish) && base.ancestors.include?(CouchPublish)
+      base.send :include, CouchPublishIntegration
+    end
+
+    if defined?(CouchVisible) && base.ancestors.include?(CouchVisible)
+      base.send :include, CouchVisibleIntegration
+    end
+
+    if defined?(CouchVisible) && base.ancestors.include?(CouchVisible) && defined?(CouchPublish) && base.ancestors.include?(CouchPublish)
+      base.send :include, CouchVisibleCouchPublishIntegration
+    end
+  end
+
+  module ClassMethods
+    def by_schedule(options={})
+      by_couch_schedule CouchScheduler::TimeMassager.massage(options)
+    end
+
+    def count_schedule(options={})
+      count_by_map :by_schedule, options
+    end
+
+    private
+    def count_by_map(map, options)
+      result = self.send(map, options.merge(:reduce => true))['rows'].first
+      result ? result['value'] : 0
+    end
+  end
+
+  def within_schedule?
+    start_valid = true
+    end_valid   = true
+
+    start_valid = Time.now >= self.start  if self.start
+    end_valid   = Time.now < self.end     if self.end
+
+    start_valid && end_valid
+  end
+
+  private
+  def validate_start_and_end
+    if self.end && self.start && self.end < self.start
+      errors[:end] = "must be greater than start"
+    end
+  end
+end

data/lib/couch_scheduler/couch_visible_integration.rb

@@ -0,0 +1,27 @@
+module CouchScheduler
+  module CouchVisibleIntegration
+    def self.included(base)
+      base.extend ClassMethods
+      base.view_by :couch_schedule_and_shown, :map => Map.new(base, :shown).to_s, :reduce => '_count'
+      base.view_by :couch_schedule_and_hidden, :map => Map.new(base, :hidden).to_s, :reduce => '_count'
+    end
+
+    module ClassMethods
+      def by_schedule_and_shown(options={})
+        by_couch_schedule_and_shown CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def by_schedule_and_hidden(options={})
+        by_couch_schedule_and_hidden CouchScheduler::TimeMassager.massage(options)
+      end
+
+      def count_schedule_and_shown(options={})
+        count_by_map :by_schedule_and_shown, options
+      end
+
+      def count_schedule_and_hidden(options={})
+        count_by_map :by_schedule_and_hidden, options
+      end
+    end
+  end
+end

data/lib/couch_scheduler/map.rb

@@ -0,0 +1,61 @@
+module CouchScheduler
+  class Map
+    def initialize(original_base, *args)
+      @base     = original_base
+      @options  = [:base_check] + args
+    end
+
+    def to_s
+      %{
+        function(doc){
+          if (#{conditions}){
+            var start = doc.start ? new Date(doc.start) : new Date(2011, 0, 1, 0, 0, 0, 0)
+            var end   = doc.end   ? new Date(doc.end  ) : new Date(2025, 0, 1, 0, 0, 0, 0)
+            
+            while(start < end){
+              emit(
+                [
+                  start.getFullYear(), 
+                  start.getMonth(), 
+                  start.getDate(), 
+                  0, 
+                  0,
+                  0
+                ], 
+                null
+              );
+              start.setDate(start.getDate() + 1)
+            }
+          }
+        }
+      }
+    end
+    
+    private
+    def conditions
+      @options.map do |option|
+        self.send option
+      end.join " && "
+    end
+
+    def base_check
+      "doc['couchrest-type'] == '#{@base.to_s}'"
+    end
+
+    def shown
+      "doc.couch_visible === true"
+    end
+
+    def hidden
+      "doc.couch_visible === false"
+    end
+
+    def published
+      "doc.milestone_memories.length > 0"
+    end
+
+    def unpublished
+      "doc.milestone_memories.length == 0"
+    end
+  end
+end

data/lib/couch_scheduler/time_massager.rb

@@ -0,0 +1,22 @@
+module CouchScheduler
+  module TimeMassager
+    extend self
+
+    def massage(options)
+      if !options[:startkey] && !options[:key]
+        options = {:key => format_time(Time.now), :reduce => false}.merge options
+      end
+      
+      [:key, :startkey, :endkey].each do |option|
+        options[option] = format_time options[option] if options[option].kind_of?(Time)
+      end
+
+      options
+    end
+
+    private
+    def format_time(t)
+      [t.year, t.month - 1, t.day, 0, 0, 0]
+    end
+  end
+end

data/readme.markdown

@@ -0,0 +1,122 @@
+# Couch Scheduler
+
+Schedule your `CouchRest::Model::Base` documents with start and end dates. What those start and end dates signify is up to you.
+
+## Installation
+
+It's a gem called `couch_scheduler`. Install it in whatever way is appropriate to you.
+
+## Basics
+
+The gem includes a module, `CouchScheduler`, that you can mix into your documents.
+
+For example, let's imagine that the we have an Article model:
+
+    class Article < CouchRest::Model::Base
+      include CouchScheduler
+
+      property :title
+    end
+
+You can now provide start and end dates for your articles:
+    
+    @article = Article.create :title => "Couch Scheduler is simple and cool."
+    @article.start = Time.now
+    @article.end   = 6.days.from_now
+    @article.save
+
+## Validation
+
+`CouchSchedule` will use `ActiveModel` validation to ensure that your `end` is after your `start`:
+  
+    @article.start = Time.now
+    @article.end   = 2.days.ago
+    @article.save #==> false
+    @artile.errors #==> [:end, " must be greater than start"]
+
+## Uses?
+
+Now what can you do with these start and end dates? One use: publishing. 
+
+Let's imagine that you only to display this article on your website between the start and end dates. You can use the `within_schedule?` method to determine if an article is available for viewing given the current time:
+
+    @article.within_schedule? #==> true
+
+    # wait 6 days....
+
+    @article.within_schedule? #==> false
+
+You can also query the databases for all of the articles currently within their schedule via `by_schedule`:
+
+    Article.by_schedule
+
+`by_schedule` simply queries a map with a default key of `Time.now.start_of_day`. You can pass any options to it that you would normally pass to a map function in `CouchRest::Model::Base`:
+
+    Article.by_schedule :key => 10.days.from_now
+      #==> all the articles active 10 days from now
+
+    Article.by_schedule :startkey => Time.now, :endkey => 10.days.from_now
+      #==> all the articles active between now and 10 days from now
+
+`CouchVisible` also provides you with a convenience method for getting the count of the `by_schedule` map/reduce:
+    
+    Article.count_schedule
+      #==> the number of documents that are currently within their schedule
+
+Like `by_schedule`, `count_schedule` supports all the usual map/reduce options:
+
+    Article.count_schedule :key => 10.days.from_now
+      #==> the count of all articles that are within their start/end dates 10 days from now
+
+## CouchPublish Integration
+
+If you include `CouchScheduler` into a model that already includes `CouchPublish`, then you get a new map function for free, `by_schedule_and_published`:
+    
+    # with a class definition like this:
+    class Article < CouchRest::Model::Base
+      include CouchPublish
+      include CouchScheduler
+      property :title
+    end
+
+    # you can query for all published and currently scheduled documents like this:
+    Article.by_schedule_and_published
+      #==> returns all documents that are published and currently within their schedule
+    
+    # you can also query for the unpublished and currently scheduled documents like this:
+    Article.by_schedule_and_unpublished
+
+You'll also get `count_schedule_and_published` and `count_schedule_and_unpublished` for free.
+
+## CouchVisible Integration
+
+If you include `CouchScheduler` into a model that includes `CouchVisible`, you'll get the following map/reduce functions for free:
+
+    Article.by_schedule_and_shown
+      #==> all articles that are currently within their start and end dates and are shown
+
+    Article.by_schedule_and_hidden
+      #==> all articles that are currently within their start and end dates and are hidden
+
+    Article.count_schedule_and_shown
+    Article.count_schedule_and_hidden
+
+## CouchPublish/CouchVisible integration
+
+If you include `CouchScheduler` into a model that includes both `CouchVisible` and `CouchPublish`, you'll get the following map/reduce functions for free:
+
+    Article.by_schedule_and_published_and_shown
+    Article.by_schedule_and_published_and_hidden
+    Article.by_schedule_and_unpublished_and_shown
+    Article.by_schedule_and_unpublished_and_hidden
+
+And of course, all the corresponding `count` methods are available:
+
+    Article.count_schedule_and_published_and_shown
+    Article.count_schedule_and_published_and_hidden
+    Article.count_schedule_and_unpublished_and_shown
+    Article.count_schedule_and_unpublished_and_hidden
+
+## LICENSE
+
+This software is PUBLIC DOMAIN. By contributing to it, you agree to let your contribution enter the PUBLIC DOMAIN.

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification 
+name: couch_scheduler
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Matt Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: couchrest_model_config
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: couch_publish
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: couch_visible
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: couchrest_model
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id007
+description: Create a publishing system that allows you to schedule your documents for publication.
+email: moonmaster9000@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/couch_scheduler/couch_publish_and_couch_visible_integration.rb
+- lib/couch_scheduler/couch_publish_integration.rb
+- lib/couch_scheduler/couch_scheduler.rb
+- lib/couch_scheduler/couch_visible_integration.rb
+- lib/couch_scheduler/map.rb
+- lib/couch_scheduler/time_massager.rb
+- lib/couch_scheduler.rb
+- VERSION
+- readme.markdown
+- features/couch_publish_integration.feature
+- features/couch_visible_and_couch_publish_integration.feature
+- features/couch_visible_integration.feature
+- features/scheduling.feature
+- features/step_definitions/couch_publish_integration.rb
+- features/step_definitions/couch_visible_and_couch_publish_integration.rb
+- features/step_definitions/couch_visible_integration.rb
+- features/step_definitions/scheduling.rb
+- features/support/env.rb
+homepage: http://github.com/moonmaster9000/couch_scheduler
+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.8.5
+signing_key: 
+specification_version: 3
+summary: Schedule documents with start and end dates.
+test_files: 
+- features/couch_publish_integration.feature
+- features/couch_visible_and_couch_publish_integration.feature
+- features/couch_visible_integration.feature
+- features/scheduling.feature
+- features/step_definitions/couch_publish_integration.rb
+- features/step_definitions/couch_visible_and_couch_publish_integration.rb
+- features/step_definitions/couch_visible_integration.rb
+- features/step_definitions/scheduling.rb
+- features/support/env.rb