by_star 0.6.1 → 0.6.2

data/README.markdown

@@ -222,6 +222,19 @@ You can also pass a string:
    
 This will return all posts for the given day.
 
+## Sum By Day (`sum_by_day`)
+
+
+To sum records for the current day:
+
+    Event.sum_by_day
+
+The `sum_by_day` method's second argument works in the same was as `by_day`, accepting Time, String, Date and chronicable strings:
+
+    Event.sum_by_day(:value, Time.now)
+    Event.sum_by_day(:value, Date.today)
+
+
 ## Current Weekend (`by_current_weekend`)
 
 If you are currently in a weekend (between 3pm Friday and 3am Monday) this will find all records starting at 3pm the previous Friday up until 3am, Monday.

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.6.2

data/by_star.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{by_star}
-  s.version = "0.6.1"
+  s.version = "0.6.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Bigg", "Mislav Marohni\304\207"]
-  s.date = %q{2010-01-29}
+  s.date = %q{2010-02-19}
   s.description = %q{ActiveRecord extension for easier date scopes and time ranges}
   s.email = %q{radarlistener@gmail.com}
   s.extra_rdoc_files = [

data/lib/calculations/count.rb

@@ -1,7 +1,7 @@
 module ByStar
   module Calculations
     module Count
-      def count_by_year(field=nil, year=Time.now.year, options={}, &block)
+      def count_by_year(field=nil, year=Time.zone.now.year, options={}, &block)
         db_field = options.delete(:field)
         scoped_by(block) do
           count(field, { :conditions => conditions_for_range(start_of_year(year), end_of_year(year), db_field) }.reverse_merge!(options))

data/lib/calculations/sum.rb

@@ -13,6 +13,13 @@ module ByStar
           sum(field, { :conditions => conditions_for_range(start_of_month(month, year), end_of_month(month, year), options.delete(:field)) }.reverse_merge!(options))
         end
       end
+      
+      def sum_by_day(field, day=Time.zone.now, options={}, &block)
+        scoped_by(block) do
+          day = parse(day)
+          sum(field, { :conditions => conditions_for_range(day.beginning_of_day, day.end_of_day, options.delete(:field)) }.reverse_merge!(options))
+        end
+      end
     end
   end
 end

data/spec/by_star_spec.rb

@@ -1,627 +1,639 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'by_star'
 
-for zone in ['UTC', 'Eastern Time (US & Canada)']
-  # Define time zone before loading test_helper
-  Time.zone = zone
-  ActiveRecord::Base.default_timezone = zone
-
-  YAML::load_file(File.dirname(__FILE__) + "/database.yml").each do |key, connection|
-    ActiveRecord::Base.establish_connection(connection)
-    load File.dirname(__FILE__) + "/fixtures/schema.rb"
-    load File.dirname(__FILE__) + "/fixtures/models.rb"
+describe Post do
+  # Posts from the 1st January this year.
+  # 12 posts for the year.
+  # + 2 for today
+  # + 2 for yesterday
+  # + 2 for tomorrow
+  # + 1 for current weekend
+  # + 1 for current fortnight
+  # + 1 for the end of year
+  # = 21
+  def this_years_posts
+    21
   end
-
-  describe Post do
-    def stub_time(day=1, month=1, year=Time.zone.now.year, hour=0, minute=0)
-      stub = "#{day}-#{month}-#{year} #{hour}:#{minute}".to_time
-      Time.stub!(:now).and_return(stub)
-      Time.zone.stub!(:now).and_return(stub)
-    end
   
-    def range_test(&block)
-      (1..31).to_a.each do |d|
-        stub_time(d, 07, 2009, 05, 05)
-        block.call
-      end
-    end
+  def stub_time(day=1, month=1, year=Time.zone.now.year, hour=0, minute=0)
+    stub = "#{day}-#{month}-#{year} #{hour}:#{minute}".to_time
+    Time.stub!(:now).and_return(stub)
+    Time.zone.stub!(:now).and_return(stub)
+  end
   
-    def find(*args)
-      method = description_args.first.sub(' ', '_')
-      Post.send(method, *args)
+  def range_test(&block)
+    (1..31).to_a.each do |d|
+      stub_time(d, 07, 2009, 05, 05)
+      block.call
     end
+  end
   
-    def size(*args)
-      method = description_args.first.sub(' ', '_')
-      Post.send(method, *args).size
-    end
+  def find(*args)
+    method = description_args.first.sub(' ', '_')
+    Post.send(method, *args)
+  end
   
-    ["mysql", "sqlite3"].each do |adapter|
-      ActiveRecord::Base.establish_connection(YAML::load_file(File.dirname(__FILE__) + "/database.yml")[adapter])
+  def size(*args)
+    method = description_args.first.sub(' ', '_')
+    Post.send(method, *args).size
+  end
   
-      describe "by year" do
-        it "should be able to find all the posts in the current year" do
-          size.should eql(Post.count - 1)
-        end
+  ["mysql", "sqlite3"].each do |adapter|
+    ActiveRecord::Base.establish_connection(YAML::load_file(File.dirname(__FILE__) + "/database.yml")[adapter])
+  
+    describe "by year" do
+      it "should be able to find all the posts in the current year" do
+        size.should eql(this_years_posts.size)
+      end
     
-        it "should be able to find if given a string" do
-          size(Time.zone.now.year.to_s).should eql(Post.count - 1)
-        end
+      it "should be able to find if given a string" do
+        size(Time.zone.now.year.to_s).should eql(@this_years_post.size)
+      end
     
-        it "should be able to find a single post from last year" do
-          size(Time.zone.now.year-1).should eql(1)
-        end
+      it "should be able to find a single post from last year" do
+        size(Time.zone.now.year-1).should eql(1)
+      end
     
-        it "should error when given an invalid year" do
-          # This is broken on 1.8.6 (and previous versions), any patchlevel after & before 111
-          major, minor, trivial = RUBY_VERSION.split(".").map(&:to_i)
-          if major == 1 && ((minor == 8 && trivial <= 6) || (minor <= 8)) && RUBY_PATCHLEVEL.to_i > 111
-            lambda { find(1901) }.should raise_error(ByStar::ParseError, "Invalid arguments detected, year may possibly be outside of valid range (1902-2039)")
-            lambda { find(2039) }.should raise_error(ByStar::ParseError, "Invalid arguments detected, year may possibly be outside of valid range (1902-2039)")
-          else
-            find(1456).should be_empty
-            find(1901).should be_empty
-            find(2039).should be_empty
-          end
+      it "should error when given an invalid year" do
+        # This is broken on 1.8.6 (and previous versions), any patchlevel after & before 111
+        major, minor, trivial = RUBY_VERSION.split(".").map(&:to_i)
+        if major == 1 && ((minor == 8 && trivial <= 6) || (minor <= 8)) && RUBY_PATCHLEVEL.to_i > 111
+          lambda { find(1901) }.should raise_error(ByStar::ParseError, "Invalid arguments detected, year may possibly be outside of valid range (1902-2039)")
+          lambda { find(2039) }.should raise_error(ByStar::ParseError, "Invalid arguments detected, year may possibly be outside of valid range (1902-2039)")
+        else
+          find(1456).should be_empty
+          find(1901).should be_empty
+          find(2039).should be_empty
         end
+      end
     
-        it "should be able to use an alternative field (string)" do
-          Event.by_year(nil, :field => "start_time").size.should eql(8)
-        end
+      it "should be able to use an alternative field (string)" do
+        Event.by_year(nil, :field => "start_time").size.should eql(8)
+      end
       
-        it "should be able to use an alternative field (symbol)" do
-          Event.by_year(nil, :field => :start_time).size.should eql(8)
-        end
+      it "should be able to use an alternative field (symbol)" do
+        Event.by_year(nil, :field => :start_time).size.should eql(8)
+      end
       
-        it "should be able to use an alternative field (symbol) with directional searching" do
-          stub_time
-          Event.past(nil, :field => :start_time).size.should eql(1)
-        end
+      it "should be able to use an alternative field (symbol) with directional searching" do
+        stub_time
+        Event.past(nil, :field => :start_time).size.should eql(1)
+      end
       
-        it "should be able to order the result set" do
-          find(Time.zone.now.year, :order => "created_at DESC").first.text.should eql("That's it!")
-        end
+      it "should be able to order the result set" do
+        find(Time.zone.now.year, :order => "created_at DESC").first.text.should eql("That's it!")
       end
+    end
   
-      describe "by month" do
+    describe "by month" do
     
-        it "should be able to find posts for the current month" do
-          stub_time
-          size.should eql(10)
-        end
+      it "should be able to find posts for the current month" do
+        size.should eql(10)
+      end
       
-        it "should be able to find a single post for January" do
-          size("January").should eql(10)
-        end
+      it "should be able to find a single post for January" do
+        size("January").should eql(10)
+      end
   
-        it "should be able to find two posts for the 2nd month" do
-          size(2).should eql(2)
-        end
+      it "should be able to find two posts for the 2nd month" do
+        size(2).should eql(2)
+      end
   
-        it "should be able to find three posts for the 3rd month, using time instance" do
-          # Hack... if we're running this test during march there's going to be more posts than usual.
-          # This is due to the #today, #yesterday and #tomorrow methods.
+      it "should be able to find three posts for the 3rd month, using time instance" do
+        # Hack... if we're running this test during march there's going to be more posts than usual.
+        # This is due to the #today, #yesterday and #tomorrow methods.
       
-          size(Time.local(Time.zone.now.year, 3, 1)).should eql(3)
-        end
+        size(Time.local(Time.zone.now.year, 3, 1)).should eql(3)
+      end
   
-        it "should be able to find a single post from January last year" do
-          size("January", :year => Time.zone.now.year - 1).should eql(1)
-        end
-    
-        it "should fail when given incorrect months" do
-          lambda { find(0) }.should raise_error(ByStar::ParseError)
-          lambda { find(13) }.should raise_error(ByStar::ParseError)
-          lambda { find("Ryan") }.should raise_error(ByStar::ParseError)
-          lambda { find([1,2,3]) }.should raise_error(ByStar::ParseError)
-        end
+      it "should be able to find a single post from January last year" do
+        size("January", :year => Time.zone.now.year - 1).should eql(1)
+      end
     
-        it "should be able to take decimals" do
-          size(1.5).should eql(10)
-        end
+      it "should fail when given incorrect months" do
+        lambda { find(0) }.should raise_error(ByStar::ParseError)
+        lambda { find(13) }.should raise_error(ByStar::ParseError)
+        lambda { find("Ryan") }.should raise_error(ByStar::ParseError)
+        lambda { find([1,2,3]) }.should raise_error(ByStar::ParseError)
+      end
     
-        it "should be able to use an alternative field" do
-          if Time.zone.now.month == 12
-            Event.by_month(nil, :field => "start_time").size.should eql(4)
-          else
-            stub_time(1, 12)
-            Event.by_month(nil, :field => "start_time").size.should eql(1)
-          end
-        end
+      it "should be able to take decimals" do
+        size(1.5).should eql(10)
+      end
     
-        it "should be able to specify the year as a string" do
-          size(1, :year => (Time.zone.now.year - 1).to_s).should eql(1)
+      it "should be able to use an alternative field" do
+        if Time.zone.now.month == 12
+          Event.by_month(nil, :field => "start_time").size.should eql(4)
+        else
+          stub_time(1, 12)
+          Event.by_month(nil, :field => "start_time").size.should eql(1)
         end
+      end
     
+      it "should be able to specify the year as a string" do
+        size(1, :year => (Time.zone.now.year - 1).to_s).should eql(1)
       end
+    
+    end
   
-      describe "by fortnight" do
+    describe "by fortnight" do
     
-        it "should be able to find posts in the current fortnight" do
-          stub_time
-          size.should eql(4)
-        end
+      it "should be able to find posts in the current fortnight" do
+        stub_time
+        size.should eql(4)
+      end
     
-        it "should be able to find posts in the 1st fortnight" do
-          size(0).should eql(4)
-        end
+      it "should be able to find posts in the 1st fortnight" do
+        size(0).should eql(4)
+      end
     
-        it "should be able to find posts for a fortnight ago" do
-          stub_time
-          size(2.weeks.ago).should eql(0)
-        end
+      it "should be able to find posts for a fortnight ago" do
+        stub_time
+        size(2.weeks.ago).should eql(0)
+      end
     
-        it "should raise an error when given an invalid argument" do
-          lambda { find(27) }.should raise_error(ByStar::ParseError, "by_fortnight takes only a Time or Date object, a Fixnum (less than or equal to 26) or a Chronicable string.")
-        end
+      it "should raise an error when given an invalid argument" do
+        lambda { find(27) }.should raise_error(ByStar::ParseError, "by_fortnight takes only a Time or Date object, a Fixnum (less than or equal to 26) or a Chronicable string.")
+      end
     
-        it "should be able to use an alternative field" do
-          stub_time
-          Event.by_fortnight(nil, :field => "start_time").size.should eql(0)
-        end
+      it "should be able to use an alternative field" do
+        stub_time
+        Event.by_fortnight(nil, :field => "start_time").size.should eql(0)
       end
+    end
   
-      describe "by week" do
-    
-        it "should be able to find posts in the current week" do
-          stub_time
-          size.should eql(4)
-        end
+    describe "by week" do
     
-        it "should be able to find posts in the 1st week" do
-          size(0).should eql(4)
-        end
+      it "should be able to find posts in the current week" do
+        stub_time
+        size.should eql(4)
+      end
     
-        it "should be able to find posts in the 1st week of last year" do
-          size(0, :year => Time.zone.now.year-1).should eql(1)
-        end
+      it "should be able to find posts in the 1st week" do
+        size(0).should eql(4)
+      end
     
-        it "should not find any posts from a week ago" do  
-          stub_time
-          size(1.week.ago).should eql(0)
-        end
+      it "should be able to find posts in the 1st week of last year" do
+        size(0, :year => Time.zone.now.year-1).should eql(1)
+      end
     
-        it "should be able to find posts by a given date" do
-          stub_time
-          size(1.week.ago.to_date).should eql(0)
-        end
+      it "should not find any posts from a week ago" do  
+        stub_time
+        size(1.week.ago).should eql(0)
+      end
     
-        it "should find, not size the posts for the current week" do
-          stub_time
-          find.map(&:text).include?("The 'Current' Week")
-          find.map(&:text).include?("Weekend of May")
-        end
+      it "should be able to find posts by a given date" do
+        stub_time
+        size(1.week.ago.to_date).should eql(0)
+      end
     
-        it "should raise an error when given an invalid argument" do
-          lambda { find(54) }.should raise_error(ByStar::ParseError, "by_week takes only a Time or Date object, a Fixnum (less than or equal to 53) or a Chronicable string.")
-        end
+      it "should find, not size the posts for the current week" do
+        stub_time
+        find.map(&:text).include?("The 'Current' Week")
+        find.map(&:text).include?("Weekend of May")
+      end
     
-        it "should be able to use an alternative field" do
-          stub_time
-          Event.by_week(nil, :field => "start_time").size.should eql(0)
-        end
+      it "should raise an error when given an invalid argument" do
+        lambda { find(54) }.should raise_error(ByStar::ParseError, "by_week takes only a Time or Date object, a Fixnum (less than or equal to 53) or a Chronicable string.")
+      end
     
-        it "should find posts at the start of the year" do
-          size(0).should eql(4)
-        end
+      it "should be able to use an alternative field" do
+        stub_time
+        Event.by_week(nil, :field => "start_time").size.should eql(0)
+      end
     
-        it "should find posts at the end of the year" do
-          size(Time.zone.now.end_of_year).should eql(1)
-        end
+      it "should find posts at the start of the year" do
+        size(0).should eql(4)
+      end
     
+      it "should find posts at the end of the year" do
+        size(Time.zone.now.end_of_year).should eql(1)
       end
+    
+    end
   
-      describe "by weekend" do
-        it "should be able to find the posts on the weekend of the 1st of January" do
-          stub_time
-          size.should eql(1)
-        end
+    describe "by weekend" do
+      it "should be able to find the posts on the weekend of the 1st of January" do
+        stub_time
+        size.should eql(1)
+      end
     
-        it "should be able to use an alternative field" do
-          year = Time.zone.now.year
-          stub_time(1, 8)
-          Event.by_weekend(nil, :field => "start_time").size.should eql(0)
-        end
+      it "should be able to use an alternative field" do
+        year = Time.zone.now.year
+        stub_time(1, 8)
+        Event.by_weekend(nil, :field => "start_time").size.should eql(0)
       end
+    end
   
-      describe "by current weekend" do
-        it "should work" do
-          range_test do
-            Post.by_current_weekend
-          end
+    describe "by current weekend" do
+      it "should work" do
+        range_test do
+          Post.by_current_weekend
         end
       end
+    end
   
-      describe "by current work week" do
-        it "should work" do
-          range_test do
-            Post.by_current_work_week
-          end
+    describe "by current work week" do
+      it "should work" do
+        range_test do
+          Post.by_current_work_week
         end
       end
+    end
   
-      describe "by day" do
-        it "should be able to find a post for today" do
-          stub_time
-          size.should eql(3)
-        end
+    describe "by day" do
+      it "should be able to find a post for today" do
+        stub_time
+        size.should eql(3)
+      end
     
-        it "should be able to find a post by a given date" do
-          stub_time
-          size(Date.today).should eql(3)
-        end
+      it "should be able to find a post by a given date" do
+        stub_time
+        size(Date.today).should eql(3)
+      end
     
-        it "should be able to use an alternative field" do
-          Event.by_day(Time.now - 1.day, :field => "start_time").size.should eql(1)
-        end
+      it "should be able to use an alternative field" do
+        Event.by_day(Time.now - 1.day, :field => "start_time").size.should eql(1)
       end
+    end
 
-      describe "today" do
-        it "should show the post for today" do
-          find.map(&:text).should include("Today's post")
-        end
-    
-        it "should be able to use an alternative field" do
-          # Test may occur on an event day.
-          stub_time
-          Event.today(nil, :field => "start_time").size.should eql(0)
-        end
+    describe "today" do
+      it "should show the post for today" do
+        find.map(&:text).should include("Today's post")
+      end
     
+      it "should be able to use an alternative field" do
+        # Test may occur on an event day.
+        stub_time
+        Event.today(nil, :field => "start_time").size.should eql(0)
       end
+    
+    end
   
-      describe "tomorrow" do
-        it "should show the post for tomorrow" do
-          find.map(&:text).should include("Tomorrow's post")
-        end
+    describe "tomorrow" do
+      it "should show the post for tomorrow" do
+        find.map(&:text).should include("Tomorrow's post")
       end
+    end
     
-      describe "yesterday" do
-        it "should show the post for yesterday" do
-          find.map(&:text).should include("Yesterday's post")
-        end
-    
-        it "should be able find yesterday, given a Date" do
-          find(Time.now).map(&:text).should include("Yesterday's post")
-        end
+    describe "yesterday" do
+      it "should show the post for yesterday" do
+        find.map(&:text).should include("Yesterday's post")
+      end
     
-        it "should be able to use an alternative field" do
-          # Test may occur on an event day.
-          stub_time
-          Event.yesterday(nil, :field => "start_time").size.should eql(0)
-        end
+      it "should be able find yesterday, given a Date" do
+        find(Time.now).map(&:text).should include("Yesterday's post")
+      end
     
+      it "should be able to use an alternative field" do
+        # Test may occur on an event day.
+        stub_time
+        Event.yesterday(nil, :field => "start_time").size.should eql(0)
       end
+    
+    end
   
-      describe "tomorrow" do
-        it "should show the post for tomorrow" do
-          find.map(&:text).should include("Tomorrow's post")
-        end
+    describe "tomorrow" do
+      it "should show the post for tomorrow" do
+        find.map(&:text).should include("Tomorrow's post")
+      end
     
-        it "should be able find tomorrow, given a Date" do
-          find(Time.now).map(&:text).should include("Tomorrow's post")
-        end
+      it "should be able find tomorrow, given a Date" do
+        find(Time.now).map(&:text).should include("Tomorrow's post")
+      end
     
-        it "should be able to use an alternative field" do
-          # Test may occur on an event day.
-          stub_time
-          Event.tomorrow(nil, :field => "start_time").size.should eql(0)
-        end
+      it "should be able to use an alternative field" do
+        # Test may occur on an event day.
+        stub_time
+        Event.tomorrow(nil, :field => "start_time").size.should eql(0)
       end
+    end
   
-      describe "past" do
+    describe "past" do
     
-        before do
-          stub_time
-        end
+      before do
+        stub_time
+      end
     
-        it "should show the correct number of posts in the past" do
-          size.should eql(1)
-        end
+      it "should show the correct number of posts in the past" do
+        size.should eql(1)
+      end
     
-        it "should find for a given time" do
-          size(Time.zone.now - 2.days).should eql(1)
-        end
+      it "should find for a given time" do
+        size(Time.zone.now - 2.days).should eql(1)
+      end
     
-        it "should find for a given date" do
-          size(Date.today - 2).should eql(1)
-        end
+      it "should find for a given date" do
+        size(Date.today - 2).should eql(1)
+      end
     
-        it "should find for a given string" do
-          size("next tuesday").should eql(5)
-        end
+      it "should find for a given string" do
+        size("next tuesday").should eql(5)
+      end
     
-        it "should be able to find all events before Ryan's birthday using a non-standard field" do
-          Event.past("01-01-#{Time.zone.now.year+2}".to_time, :field => "start_time").size.should eql(9)
-        end 
+      it "should be able to find all events before Ryan's birthday using a non-standard field" do
+        Event.past("01-01-#{Time.zone.now.year+2}".to_time, :field => "start_time").size.should eql(9)
+      end 
       
-        it "should be able to order the find" do
-          stub_time(2,1)
-          find(Date.today, :order => "created_at ASC").first.text.should eql("Last year")
-          find(Date.today, :order => "created_at DESC").first.text.should eql("post 1-0")
-        end
-    
+      it "should be able to order the find" do
+        stub_time(2,1)
+        find(Date.today, :order => "created_at ASC").first.text.should eql("Last year")
+        find(Date.today, :order => "created_at DESC").first.text.should eql("post 1-0")
       end
+    
+    end
   
-      describe "future" do
-        before do
-          stub_time
-        end
+    describe "future" do
+      before do
+        stub_time
+      end
     
-        it "should show the correct number of posts in the future" do
-          size.should eql(85)
-        end
+      it "should show the correct number of posts in the future" do
+        size.should eql(85)
+      end
     
-        it "should find for a given date" do
-          size(Date.today - 2).should eql(88)
-        end
+      it "should find for a given date" do
+        size(Date.today - 2).should eql(88)
+      end
     
-        it "should find for a given string" do
-          size("next tuesday").should eql(84)
-        end
+      it "should find for a given string" do
+        size("next tuesday").should eql(84)
+      end
     
-        it "should be able to find all events before Dad's birthday using a non-standard field" do
-          # TODO: This will change in May. Figure out how to fix.
-          Event.past("05-07-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(5)
-        end
+      it "should be able to find all events before Dad's birthday using a non-standard field" do
+        # TODO: This will change in May. Figure out how to fix.
+        Event.past("05-07-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(5)
       end
+    end
   
-      describe "as of" do
-        it "should be able to find posts as of 2 weeks ago" do
-          stub_time
-          Post.as_of_2_weeks_ago.size.should eql(3)
-        end
+    describe "as of" do
+      it "should be able to find posts as of 2 weeks ago" do
+        stub_time
+        Post.as_of_2_weeks_ago.size.should eql(3)
+      end
     
-        it "should be able to find posts as of 2 weeks before a given time" do
-          stub_time
-          Post.as_of_2_weeks_ago(Time.zone.now + 1.month).size.should eql(12)
-        end
+      it "should be able to find posts as of 2 weeks before a given time" do
+        stub_time
+        Post.as_of_2_weeks_ago(Time.zone.now + 1.month).size.should eql(12)
+      end
     
-        it "should error if given a date in the past far enough back" do
-          lambda { Post.as_of_6_weeks_ago(Time.zone.now - 2.months) }.should raise_error(ByStar::ParseError, "End time is before start time, searching like this will return no results.")
-        end
+      it "should error if given a date in the past far enough back" do
+        lambda { Post.as_of_6_weeks_ago(Time.zone.now - 2.months) }.should raise_error(ByStar::ParseError, "End time is before start time, searching like this will return no results.")
+      end
     
-        it "should not do anything if given an invalid date" do
-          lambda { Post.as_of_ryans_birthday }.should raise_error(ByStar::ParseError, "Chronic couldn't work out \"Ryans birthday\"; please be more precise.")
-        end
+      it "should not do anything if given an invalid date" do
+        lambda { Post.as_of_ryans_birthday }.should raise_error(ByStar::ParseError, "Chronic couldn't work out \"Ryans birthday\"; please be more precise.")
       end
+    end
   
-      describe "between" do
-        it "should find posts between last tuesday and next tuesday" do
-          stub_time
-          size("last tuesday", "next tuesday").should eql(4)
-        end
+    describe "between" do
+      it "should find posts between last tuesday and next tuesday" do
+        stub_time
+        size("last tuesday", "next tuesday").should eql(4)
+      end
     
-        it "should find between two times" do
-          stub_time
-          size(Time.zone.now - 5.days, Time.zone.now + 5.days).should eql(4)
-        end
+      it "should find between two times" do
+        stub_time
+        size(Time.zone.now - 5.days, Time.zone.now + 5.days).should eql(4)
+      end
     
-        it "should find between two dates" do
-          stub_time
-          size(Date.today, Date.today + 5).should eql(4)
-        end
+      it "should find between two dates" do
+        stub_time
+        size(Date.today, Date.today + 5).should eql(4)
       end
+    end
   
-      describe "up to" do
-        it "should be able to find posts up to 2 weeks from now" do
-          stub_time
-          Post.up_to_6_weeks_from_now.size.should eql(12)
-        end
+    describe "up to" do
+      it "should be able to find posts up to 2 weeks from now" do
+        stub_time
+        Post.up_to_6_weeks_from_now.size.should eql(12)
+      end
     
-        it "should be able to find posts up to 2 weeks from a given time" do
-          stub_time
-          Post.up_to_6_weeks_from_now(Time.zone.now - 1.month).size.should eql(12)
-        end
+      it "should be able to find posts up to 2 weeks from a given time" do
+        stub_time
+        Post.up_to_6_weeks_from_now(Time.zone.now - 1.month).size.should eql(12)
+      end
     
-        it "should error if given a date in the past" do
-          lambda { Post.up_to_6_weeks_from_now(Time.zone.now + 2.months) }.should raise_error(ByStar::ParseError, "End time is before start time, searching like this will return no results.")
-        end
+      it "should error if given a date in the past" do
+        lambda { Post.up_to_6_weeks_from_now(Time.zone.now + 2.months) }.should raise_error(ByStar::ParseError, "End time is before start time, searching like this will return no results.")
+      end
     
-        it "should not do anything if given an invalid date" do
-          lambda { Post.up_to_ryans_birthday }.should raise_error(ByStar::ParseError, "Chronic couldn't work out \"Ryans birthday\"; please be more precise.")
-        end
-      
+      it "should not do anything if given an invalid date" do
+        lambda { Post.up_to_ryans_birthday }.should raise_error(ByStar::ParseError, "Chronic couldn't work out \"Ryans birthday\"; please be more precise.")
       end
+      
+    end
   
-      # Because we override method_missing, we ensure that it still works as it should with this test.
-      describe "method_missing" do
-        it "should still work" do
-          Post.find_by_text("Today's post").should_not be_nil
-        end
+    # Because we override method_missing, we ensure that it still works as it should with this test.
+    describe "method_missing" do
+      it "should still work" do
+        Post.find_by_text("Today's post").should_not be_nil
+      end
     
-        it "should raise a proper NoMethodError" do
-          lambda { Post.idontexist }.should raise_error(NoMethodError, %r(^undefined method `idontexist'))
-        end
+      it "should raise a proper NoMethodError" do
+        lambda { Post.idontexist }.should raise_error(NoMethodError, %r(^undefined method `idontexist'))
       end
+    end
   
-      describe "named_scopes" do
-        it "should be compatible" do
-          Event.secret.by_year(nil, :field => "start_time").size.should eql(1)
-        end
+    describe "named_scopes" do
+      it "should be compatible" do
+        Event.secret.by_year(nil, :field => "start_time").size.should eql(1)
       end
+    end
   
-      describe "joins" do
-        it "should not have ambiguous column names" do
-          lambda { Post.by_month do
-            { :joins => :tags }
-          end }.should_not raise_error
-        end
+    describe "joins" do
+      it "should not have ambiguous column names" do
+        lambda { Post.by_month do
+          { :joins => :tags }
+        end }.should_not raise_error
       end
+    end
   
   
-      describe "nested find" do
-    
-        it "should be able to find posts after right now" do
-          stub_time
-          Post.by_current_work_week.size.should eql(3)
-          Post.by_current_work_week do
-            { :conditions => ["created_at > ?", Time.now] }
-          end.size.should eql(0)
-        end
+    describe "nested find" do
+    
+      it "should be able to find posts after right now" do
+        stub_time
+        Post.by_current_work_week.size.should eql(3)
+        Post.by_current_work_week do
+          { :conditions => ["created_at > ?", Time.now] }
+        end.size.should eql(0)
+      end
   
-        it "should be able to find a single post from last year with the tag 'ruby'" do
-          Post.by_year(Time.zone.now.year - 1) do
-            { :include => :tags, :conditions => ["tags.name = ?", 'ruby'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from last year with the tag 'ruby'" do
+        Post.by_year(Time.zone.now.year - 1) do
+          { :include => :tags, :conditions => ["tags.name = ?", 'ruby'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from January last year with the tag 'ruby'" do
-          Post.by_month("January", :year => Time.zone.now.year - 1) do
-            { :include => :tags, :conditions => ["tags.name = ?", 'ruby'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from January last year with the tag 'ruby'" do
+        Post.by_month("January", :year => Time.zone.now.year - 1) do
+          { :include => :tags, :conditions => ["tags.name = ?", 'ruby'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the current fortnight with the tag 'may2'" do
-          stub_time
-          Post.by_fortnight do
-            { :include => :tags, :conditions => ["tags.name = ?", 'may2'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the current fortnight with the tag 'may2'" do
+        Post.by_fortnight do
+          { :include => :tags, :conditions => ["tags.name = ?", 'fortnight'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the current week with the tag 'may2'" do
-          stub_time
-          Post.by_week do
-            { :include => :tags, :conditions => ["tags.name = ?", 'may2'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the current week with the tag 'may2'" do
+        Post.by_week do
+          { :include => :tags, :conditions => ["tags.name = ?", 'week'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the current weekend with the tag 'weekend'" do
-          stub_time
-          Post.by_weekend do
-            { :include => :tags, :conditions => ["tags.name = ?", 'weekend'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the current weekend with the tag 'weekend'" do
+        Post.by_weekend do
+          { :include => :tags, :conditions => ["tags.name = ?", 'weekend'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the current day with the tag 'today'" do
-          Post.by_day do
-            { :include => :tags, :conditions => ["tags.name = ?", 'today'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the current day with the tag 'today'" do
+        Post.by_day do
+          { :include => :tags, :conditions => ["tags.name = ?", 'today'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from yesterday with the tag 'yesterday'" do
-          Post.yesterday do
-            { :include => :tags, :conditions => ["tags.name = ?", 'yesterday'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from yesterday with the tag 'yesterday'" do
+        Post.yesterday do
+          { :include => :tags, :conditions => ["tags.name = ?", 'yesterday'] }
+        end.size.should eql(1)
+      end
     
     
-        it "should be able to find a single post from tomorrow with the tag 'tomorrow'" do
-          Post.tomorrow do
-            { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from tomorrow with the tag 'tomorrow'" do
+        Post.tomorrow do
+          { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the past with the tag 'yesterday'" do
-          Post.past do
-            { :include => :tags, :conditions => ["tags.name = ?", 'yesterday'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the past with the tag 'yesterday'" do
+        Post.past do
+          { :include => :tags, :conditions => ["tags.name = ?", 'yesterday'] }
+        end.size.should eql(1)
+      end
     
-        it "should be able to find a single post from the future with the tag 'tomorrow'" do
-          Post.future do
-            { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
-          end.size.should eql(1)
-        end
+      it "should be able to find a single post from the future with the tag 'tomorrow'" do
+        Post.future do
+          { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
+        end.size.should eql(1)
+      end
       
-        it "should work when block is empty" do
-          stub_time
-          Post.future { }.size.should eql(85)
-        end
+      it "should work when block is empty" do
+        stub_time        
+        Post.future { }.size.should eql(this_years_posts)
+      end
       
-        it "should be able to find a single post from the future with the tag 'tomorrow' (redux)" do
-          Post.future(Time.zone.now, :include => :tags, :conditions => ["tags.name = ?", 'tomorrow']).size.should eql(1)
-        end
-    
+      it "should be able to find a single post from the future with the tag 'tomorrow' (redux)" do
+        Post.future(Time.zone.now, :include => :tags, :conditions => ["tags.name = ?", 'tomorrow']).size.should eql(1)
       end
+    
+    end
   
-      describe "Calculations" do
-        describe "Sum" do
-          describe "by year" do
-            it "current year" do
-              stub_time
-              Invoice.sum_by_year(:value).should eql(374000)
-            end
+    describe "Calculations" do
+      describe "Sum" do
+        describe "by year" do
+          it "current year" do
+            stub_time
+            # 13 invoices, all of them $10000.
+            # +1 of $5500 (2nd January)
+            # = $13550
+            Invoice.sum_by_year(:value).should eql(135500)
           end
+        end
       
-          describe "by month" do
-            it "current month" do
-              stub_time
-              Invoice.sum_by_month(:value).should eql(11000)
-            end
+        describe "by month" do
+          it "current month" do
+            stub_time
+            # 1 invoice per month, just $10000.
+            Invoice.sum_by_month(:value).should eql(15500)
+          end
+        end
+        
+        describe "by day" do
+          it "current day" do
+            stub_time(2, 1) # 2nd January
+            Invoice.sum_by_day(:value).should eql(5500)
           end
         end
+      end
     
-        describe "Count" do
-          describe "by year" do
-            it "current year" do
-              Invoice.count_by_year.should eql(79)
-            end
+      describe "Count" do
+        describe "by year" do
+          it "current year" do
+            # 13 invoices, 1 for every month + 1 for this month.
+            Invoice.count_by_year.should eql(13)
+          end
         
-            it "using a field" do
-              Invoice.count_by_year(:number).should eql(Invoice.by_year.size-1)
-            end
+          it "using a field" do
+            # 12 invoices, as we have a single invoice without a number.
+            Invoice.count_by_year(:number).should eql(Invoice.by_year.size-1)
+          end
         
-            it "different year" do
-              Invoice.count_by_year(:all, 2008)
-            end
+          it "different year" do
+            # 1 invoice from last year
+            Invoice.count_by_year(:all, Time.now.year-1).should eql(1)
+          end
           
-            it "current year with the given tag" do
-              Post.count_by_year do
-                { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
-              end.should eql(1)
-            end
+          it "current year with the given tag" do
+            # BROKEN: Due to time range looking up from beginning of current year to end of next
+            Post.count_by_year do
+              { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
+            end.should eql(1)
           end
+        end
       
-          describe "by month" do
-            it "current month" do
-              Invoice.count_by_month
-            end
+        describe "by month" do
+          it "current month" do
+            Invoice.count_by_month
+          end
         
-            it "using a field" do
-              Invoice.count_by_month(:number).should eql(Invoice.by_month.size-1)
-            end
+          it "using a field" do
+            Invoice.count_by_month(:number).should eql(Invoice.by_month.size-1)
+          end
         
-            it "different month" do
-              stub_time
-              Invoice.count_by_month(:all, 9)
-            end
+          it "different month" do
+            stub_time
+            Invoice.count_by_month(:all, 9)
+          end
           
-            it "current month with the given tag" do
-              Post.count_by_month(:all, Time.zone.now) do
-                { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
-              end.should eql(1)
-            end
+          it "current month with the given tag" do
+            Post.count_by_month(:all, Time.zone.now) do
+              { :include => :tags, :conditions => ["tags.name = ?", 'tomorrow'] }
+            end.should eql(1)
+          end
           
-            it "current month with blank block" do
-              stub_time
-              Post.count_by_month(:all, Time.zone.now) { }.should eql(10)
-            end
+          it "current month with blank block" do
+            Post.count_by_month(:all, Time.zone.now) { }.should eql(10)
           end
         end
-
       end
+
+    end
     
-      describe "edge cases" do
-        # This method previously generated sql like: `day_entries`.`spent_at`.`spent_at`.`spent_at`.`spent_at`
-        # Which is *obviously* incorrect and #omg worthy.
-        it "should not spam the field name when using a different field" do
-          Invoice.first.day_entries.between((Time.zone.now - 3.days).to_date, Time.zone.now.to_date, :field => "spent_at")
-        end
+    describe "edge cases" do
+      # This method previously generated sql like: `day_entries`.`spent_at`.`spent_at`.`spent_at`.`spent_at`
+      # Which is *obviously* incorrect and #omg worthy.
+      it "should not spam the field name when using a different field" do
+        Invoice.first.day_entries.between((Time.zone.now - 3.days).to_date, Time.zone.now.to_date, :field => "spent_at")
       end
+    end
   
-      describe Time do
-        it "should work out the beginning of a weekend (Friday 3pm)" do
-          range_test do 
-            Time.now.beginning_of_weekend.strftime("%A %I:%M%p").should eql("Friday 03:00PM")
-          end
+    describe Time do
+      it "should work out the beginning of a weekend (Friday 3pm)" do
+        range_test do 
+          Time.now.beginning_of_weekend.strftime("%A %I:%M%p").should eql("Friday 03:00PM")
         end
+      end
     
-        it "should work out the end of a weekend (Monday 3am)" do
-          range_test do
-            Time.now.end_of_weekend.strftime("%A %I:%M%p").should eql("Monday 03:00AM")
-          end
+      it "should work out the end of a weekend (Monday 3am)" do
+        range_test do
+          Time.now.end_of_weekend.strftime("%A %I:%M%p").should eql("Monday 03:00AM")
         end
       end
     end
   end
+  
 end