couch_scheduler 0.1.0 → 0.2.0

data/features/step_definitions/scheduling.rb

@@ -1,107 +1,23 @@
-Given /^an instance of a model that includes CouchScheduler$/ do
-  class Model < CouchRest::Model::Base
-    include CouchScheduler
-  end
-  @instance = Model.new
+Given /^an.*:$/ do |code|
+  eval code
 end
 
-When /^I set "([^"]*)" to now$/ do |property|
-  @instance.send "#{property}=", Time.now
+When /^I (?:set|wait) .*:$/ do |code|
+  eval code
 end
 
-When /^I set "([^"]*)" to a day from now$/ do |property|
-  @instance.send "#{property}=", 1.day.from_now
+Then /^.*should.*:$/ do |code|
+  eval code
 end
 
-Then /^I should be able to save my document$/ do
-  @instance.save
-  @instance.errors.empty?.should be(true)
+Given /^there are.*:$/ do |code|
+  eval code
 end
 
-When /^I set "([^"]*)" to yesterday$/ do |property|
-  @instance.send "#{property}=", 1.day.ago
+Given /^a model that includes CouchScheduler:$/ do |code|
+  eval code
 end
 
-Then /^I should not be able to save my document$/ do
-  @instance.save
-  @instance.errors.empty?.should be(false)
+Given /^the date is .*:$/ do |code|
+  eval code
 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

@@ -15,4 +15,10 @@ end
 Before do
   CouchRest::Model::Config.default_database.recreate!
   Timecop.return
+
+  Object.class_eval do
+    if defined? Article
+      remove_const "Article"
+    end
+  end
 end

data/lib/couch_scheduler.rb

@@ -1,7 +1,7 @@
-require 'couchrest_model'
-require 'couch_scheduler/options'
+require 'couch_view'
 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'
+require 'couch_scheduler/conditions'

data/lib/couch_scheduler/conditions.rb

@@ -0,0 +1,23 @@
+module Published
+  def conditions
+    "#{super} && doc.milestone_memories.length > 0"
+  end
+end
+
+module Unpublished
+  def conditions
+    "#{super} && doc.milestone_memories.length == 0"
+  end
+end
+
+module Shown
+  def conditions
+    "#{super} && doc.couch_visible == true"
+  end
+end
+
+module Hidden
+  def conditions
+    "#{super} && doc.couch_visible == false"
+  end
+end

data/lib/couch_scheduler/couch_publish_and_couch_visible_integration.rb

@@ -1,24 +1,9 @@
 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(options={})
-        shown       = options[:shown]
-        hidden      = options[:hidden]
-        published   = options[:published]
-        unpublished = options[:unpublished]
-
-        if shown == true && published == true
-          by_couch_schedule_and_published_and_shown CouchScheduler::Options.new(options).to_hash
-        elsif hidden == true && published == true
-          by_couch_schedule_and_published_and_hidden CouchScheduler::Options.new(options).to_hash
-        else
-          super
+      base.couch_view :within_couch_schedule do
+        map CouchScheduler::Map do
+          conditions ::Published, ::Unpublished, ::Hidden, ::Shown
         end
       end
     end

data/lib/couch_scheduler/couch_publish_integration.rb

@@ -1,24 +1,12 @@
 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(options={})
-        published   = options[:published]
-        unpublished = options[:unpublished]
-
-        if published == true || unpublished == false
-          by_couch_schedule_and_published CouchScheduler::Options.new(options).to_hash
-        elsif unpublished == true || published == false
-          by_couch_schedule_and_unpublished CouchScheduler::Options.new(options).to_hash
-        else
-          super
+      base.couch_view :within_couch_schedule do
+        map CouchScheduler::Map do
+          conditions ::Published, ::Unpublished
         end
       end
     end
   end
 end
+

data/lib/couch_scheduler/couch_scheduler.rb

@@ -1,37 +1,43 @@
 module CouchScheduler
   def self.included(base)
-    base.property :start, Time
-    base.property :end, Time
+    unless base.ancestors.include?(CouchView)
+      base.send :include, CouchView
+    end
+
+    base.property :start, Date
+    base.property :end, Date
     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)
+    if defined?(CouchVisible) && base.ancestors.include?(CouchVisible) && defined?(CouchPublish) && base.ancestors.include?(CouchPublish)
+      base.send :include, CouchVisibleCouchPublishIntegration
+    elsif defined?(CouchPublish) && base.ancestors.include?(CouchPublish)
       base.send :include, CouchPublishIntegration
-    end
-
-    if defined?(CouchVisible) && base.ancestors.include?(CouchVisible)
+    elsif defined?(CouchVisible) && base.ancestors.include?(CouchVisible)
       base.send :include, CouchVisibleIntegration
+    else
+      base.couch_view :within_couch_schedule do
+        map CouchScheduler::Map
+      end
     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::Options.new(options).to_hash
+    def map_within_schedule!
+      map_within_schedule.get!
+    end
+
+    def count_within_schedule!
+      count_within_schedule.get!
     end
 
-    def count_schedule(options={})
-      count_by_map :by_schedule, options
+    def map_within_schedule
+      map_within_couch_schedule.key(Time.now.to_date)
     end
 
-    private
-    def count_by_map(map, options)
-      result = self.send(map, options.merge(:reduce => true))['rows'].first
-      result ? result['value'] : 0
+    def count_within_schedule
+      count_within_couch_schedule.key(Time.now.to_date)
     end
   end
 

data/lib/couch_scheduler/couch_visible_integration.rb

@@ -1,22 +1,9 @@
 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(options={})
-        shown = options.delete :shown
-        hidden = options.delete :hidden
-
-        if shown == true || hidden == false
-          by_couch_schedule_and_shown CouchScheduler::Options.new(options).to_hash
-        elsif hidden == true || shown == false
-          by_couch_schedule_and_hidden CouchScheduler::Options.new(options).to_hash
-        else
-          super
+      base.couch_view :within_couch_schedule do
+        map CouchScheduler::Map do
+          conditions ::Shown, ::Hidden
         end
       end
     end

data/lib/couch_scheduler/map.rb

@@ -1,27 +1,40 @@
 module CouchScheduler
   class Map
-    def initialize(original_base, *args)
-      @base     = original_base
-      @options  = [:base_check] + args
-    end
+    include CouchView::Map
 
-    def to_s
+    def map
       %{
         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)
+            if (doc.start){
+              startDate = doc.start.replace(/-/g, '/')
+              var start = new Date(startDate)
+            } else {
+              var start = new Date()
+            }
+
+            if (doc.end){
+              endDate = doc.end.replace(/-/g, '/')
+              var end = new Date(endDate)
+            } else {
+              var end = new Date("2025/01/01")
+            }
             
             while(start < end){
+              year  = start.getFullYear()
+              
+              month = start.getMonth() + 1
+              if (month < 10)
+                month = "0" + month.toString()
+              
+              day  = start.getDate()
+              if (day < 10)
+                day = "0" + day.toString()
+
               emit(
-                [
-                  start.getFullYear(), 
-                  start.getMonth(), 
-                  start.getDate(), 
-                  0, 
-                  0,
-                  0
-                ], 
+                year + "-" + 
+                month + "-" + 
+                day, 
                 null
               );
               start.setDate(start.getDate() + 1)
@@ -30,32 +43,5 @@ module CouchScheduler
         }
       }
     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/readme.markdown

@@ -48,28 +48,30 @@ Let's imagine that you only to display this article on your website between the
 
     @article.within_schedule? #==> false
 
-### Query (.by_schedule)
+### Query (.map_within_schedule)
 
-You can also query the databases for all of the articles currently within their schedule via `by_schedule`:
+You can also query the databases for all of the articles currently within their schedule via `map_within_schedule`:
 
-    Article.by_schedule
+    Article.map_within_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`:
+`map_within_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
+    Article.map_within_schedule.key(10.days.from_now.to_date).get!
       #==> 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
+    Article.map_within_schedule.startkey(Time.now.to_date).endkey(10.days.from_now.to_date).get!
+      #==> all the articles active between today and 10 days from now
 
-`CouchVisible` also provides you with a convenience method for getting the count of the `by_schedule` map/reduce:
+If you're coming from a regular `CouchRest::Model::Base` background, you've likely not seen this lazy, chainable API before. `CouchScheduler` utilizes `CouchView` to create this functionality. Checkout the `couch_view` gem at http://github.com/moonmaster9000/couch_view
+
+`CouchScheduler` also provides you with a convenience method for getting the count of the `map_within_schedule` map/reduce:
     
-    Article.count_schedule
+    Article.count_within_schedule!
       #==> the number of documents that are currently within their schedule
 
-Like `by_schedule`, `count_schedule` supports all the usual map/reduce options:
+Like `map_within_schedule`, `count_within_schedule` supports all the usual map/reduce options:
 
-    Article.count_schedule :key => 10.days.from_now
+    Article.count_within_schedule.key(10.days.from_now).get!
       #==> the count of all articles that are within their start/end dates 10 days from now
 
 
@@ -86,37 +88,37 @@ If you include `CouchScheduler` into a model that already includes `CouchPublish
     end
 
     # you can query for all published and currently scheduled documents like this:
-    Article.by_schedule :published => true
+    Article.map_within_schedule.published.get!
       #==> 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 :unpublished => true
+    Article.map_within_schedule.unpublished.get!
 
-You can also pass `:published => true` and `:unpublished => true` to the `count_schedule` method.
+You can also pass use the "published" and "unpublished" query proxy methods on the `count_within_schedule` method.
 
 
 ## 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 :shown => true
+    Article.map_within_schedule.shown.get!
       #==> all articles that are currently within their start and end dates and are shown
 
-    Article.by_schedule :hidden => true
+    Article.map_within_schedule.hidden.get!
       #==> all articles that are currently within their start and end dates and are hidden
 
-    Article.count_schedule :shown  => true
-    Article.count_schedule :hidden => true
+    Article.count_within_schedule.shown.get!
+    Article.count_within_schedule.hidden.get!
 
 
 ## CouchPublish/CouchVisible integration
 
 If you include `CouchScheduler` into a model that includes both `CouchVisible` and `CouchPublish`, you can pass `:published => true`, `:unpublished => true`, `:shown => true`, `:hidden => true` to your schedule query methods:
 
-    Article.by_schedule    :published   => true, :shown  => true
-    Article.by_schedule    :unpublished => true, :hidden => true
-    Article.count_schedule :published   => true, :shown  => true
-    Article.count_schedule :unpublished => true, :hidden => true 
+    Article.map_within_schedule.published.shown.get!
+    Article.map_within_schedule.unpublished.hidden.get!
+    Article.count_within_schedule.published.shown.get!
+    Article.count_within_schedule.unpublished.hidden.get!
  
 
 ## LICENSE