by_star 0.2.5 → 0.3.0

data/lib/calculations.rb

@@ -0,0 +1,23 @@
+module ByStar
+  module Calculations
+    include Count
+    include Sum
+    
+    private
+      def work_out_month(time, options = {})
+        year = options[:year] ||= Time.zone.now.year
+        # Work out what actual month is.
+        month = if time.is_a?(Numeric) && (1..12).include?(time)
+          time
+        elsif valid_time_or_date?(time)
+          year = time.year
+          time.month
+        elsif time.is_a?(String) && Date::MONTHNAMES.include?(time)
+          Date::MONTHNAMES.index(time)
+        else
+          raise ParseError, "Value is not an integer (between 1 and 12), time object or string (make sure you typed the name right)."
+        end
+        [year, month]
+      end
+  end
+end

data/lib/calculations/count.rb

@@ -0,0 +1,15 @@
+module ByStar
+  module Calculations
+    module Count
+      def count_by_year(field=nil, year=Time.now.year, options={})
+        count(field, :conditions => conditions_for_range(start_of_year(year), end_of_year(year), options))
+      end
+      
+      def count_by_month(field=nil, month=Time.now.month, options={})
+        year, month = work_out_month(month, options)
+        count(field, :conditions => conditions_for_range(start_of_month(month, year), end_of_month(month, year), options))
+      end
+    end
+    
+  end
+end

data/lib/calculations/sum.rb

@@ -0,0 +1,14 @@
+module ByStar
+  module Calculations
+    module Sum
+      def sum_by_year(field, year=Time.zone.now.year, options={})
+        sum(field, :conditions => conditions_for_range(start_of_year(year), end_of_year(year), options))
+      end
+
+      def sum_by_month(field, month=Time.zone.now.month, options={})
+        year, month = work_out_month(month, options)
+        sum(field, :conditions => conditions_for_range(start_of_month(month, year), end_of_month(month, year), options))
+      end
+    end
+  end
+end

data/lib/range_calculations.rb

@@ -0,0 +1,23 @@
+module ByStar
+  module RangeCalculations
+
+    private
+    
+    def start_of_year(year=Time.now.year)
+      Time.utc(year, 1, 1)
+    end
+    
+    def end_of_year(year=Time.now.year)
+      start_of_year.end_of_year
+    end
+    
+    def start_of_month(month, year=Time.now.year)
+      Time.utc(year, month, 1)
+    end
+    
+    def end_of_month(month, year=Time.now.year)
+      start_of_month(month, year).end_of_month
+    end
+  end
+  
+end

data/lib/shared.rb

@@ -0,0 +1,6 @@
+module Shared
+  def conditions_for_range(start_time, end_time, options = {})
+    field = connection.quote_table_name(table_name) << '.' << connection.quote_column_name(options[:field] || "created_at")
+    ["#{field} >= ? AND #{field} <= ?", start_time.utc, end_time.utc]
+  end
+end

data/lib/time_ext.rb

@@ -0,0 +1,20 @@
+class Time
+  def beginning_of_weekend
+    friday = case self.wday
+    when 0
+      self.end_of_week.beginning_of_day.advance(:days => -2) 
+    when 5
+      self.beginning_of_day
+    else
+      self.beginning_of_week.advance(:days => 4)
+    end
+    # 3pm, Friday.
+    (friday + 15.hours)
+  end
+  
+  def end_of_weekend
+    # 3am, Monday.
+    # LOL I CHEATED.
+    beginning_of_weekend + 3.days - 12.hours
+  end
+end

data/lib/vanilla.rb

@@ -0,0 +1,273 @@
+module ByStar
+  module Vanilla
+    # Examples:
+    #   by_year(2010)
+    #   # 2-digit year:
+    #   by_year(10)
+    #   # Time or Date object:
+    #   by_year(time)
+    #   # String:
+    #   by_year("2010")
+    def by_year(time=Time.zone.now.year, options={}, &block)
+      year = work_out_year(time)
+      start_time = start_of_year(year)
+      end_time = start_time.end_of_year
+      by_star(start_time, end_time, options, &block)
+    rescue ArgumentError
+      raise ParseError, "Invalid arguments detected, year may possibly be outside of valid range (1902-2039). This is no longer a problem on Ruby versions >= 1.8.7, so we recommend you upgrade to at least 1.8.7."
+    end
+
+    # Examples:
+    #   by_month(1)
+    #   by_month("January")
+    #   by_month("January", :year => 2008)
+    #   by_month(time)
+    def by_month(time=Time.zone.now.month, options={}, &block)
+      time = Time.zone.now.month if time.nil?
+      year, month = work_out_month(time, options)
+  
+      start_time = start_of_month(month, year)
+      end_time = start_time.end_of_month
+
+      by_star(start_time, end_time, options, &block)
+    end
+
+    # Examples:
+    #   # 18th fortnight of 2004
+    #   Post.by_fortnight(18, :year => 2004)
+    def by_fortnight(time=Time.zone.now, options = {}, &block)
+      time = parse(time)
+  
+      # If options[:year] is passed in, use that year regardless.
+      year = work_out_year(options[:year]) if options[:year]
+      # If the first argument is a date or time, ask it for the year
+      year ||= time.year unless time.is_a?(Numeric)
+      # If the first argument is a fixnum, assume this year.
+      year ||= Time.zone.now.year
+  
+      # Dodgy!
+      # Surely there's a method in Rails to do this.
+      start_time = if valid_time_or_date?(time)
+        time.beginning_of_year + (time.strftime("%U").to_i).weeks
+      elsif time.is_a?(Numeric) && time <= 26
+        Time.utc(year, 1, 1) + ((time.to_i) * 2).weeks
+      else
+        raise ParseError, "by_fortnight takes only a Time or Date object, a Fixnum (less than or equal to 26) or a Chronicable string."
+      end
+      start_time = start_time.beginning_of_week
+      end_time = start_time + 2.weeks
+      by_star(start_time, end_time, options, &block)
+    end
+
+    # Examples:
+    #   # 36th week
+    #   Post.by_week(36)
+    #   Post.by_week(36.54)
+    #   Post.by_week(36, :year => 2004)
+    #   Post.by_week(<Time object>)
+    #   Post.by_week(<Date object>)
+    #   Post.by_week("next tuesday")
+    def by_week(time=Time.zone.now, options = {}, &block)
+      time = parse(time)
+  
+      # If options[:year] is passed in, use that year regardless.
+      year = work_out_year(options[:year]) if options[:year]
+      # If the first argument is a date or time, ask it for the year
+      year ||= time.year unless time.is_a?(Numeric)
+      # If the first argument is a fixnum, assume this year.
+      year ||= Time.now.year
+  
+      # Dodgy!
+      # Surely there's a method in Rails to do this.
+      start_time = if valid_time_or_date?(time)
+        weeks = time.strftime("%U").to_i
+        time.beginning_of_year
+      elsif time.is_a?(Numeric) && time < 53
+        weeks = time.to_i
+        Time.utc(year, 1, 1)
+      else
+        raise ParseError, "by_week takes only a Time or Date object, a Fixnum (less than or equal to 53) or a Chronicable string."
+      end
+      start_time += weeks.weeks
+      end_time = start_time + 1.week
+      by_star(start_time, end_time, options, &block)
+    end
+
+
+    # Examples:
+    #    Post.by_weekend
+    #    Post.by_weekend(Time.now + 5.days)
+    #    Post.by_weekend(Date.today + 5)
+    #    Post.by_weekend("next tuesday")
+    def by_weekend(time=Time.zone.now, options = {}, &block)
+      time = parse(time)
+      start_time = time.beginning_of_weekend
+      by_star(start_time, (start_time + 1.day).end_of_day, options, &block)
+    end
+
+
+    # Examples:
+    # Post.by_current_weekend
+    def by_current_weekend(options = {}, &block)
+      time = Time.zone.now
+      # Friday, 3pm
+      start_time = time.beginning_of_weekend
+      # Monday, 3am
+      end_time = time.end_of_weekend
+      by_star(start_time, end_time, options, &block)
+    end
+
+    # Examples:
+    # Post.by_current_work_week
+    def by_current_work_week(options = {}, &block)
+      time = Time.zone.now
+      # Monday, 3am
+      time = time + 1.week if time.wday == 6 || time.wday == 0
+      start_time = time.beginning_of_week + 3.hours
+      # Friday, 3pm
+      end_time = time.beginning_of_weekend
+      by_star(start_time, end_time, options, &block)
+    end
+
+
+    # Examples:
+    #   Post.by_day
+    #   Post.by_day(Time.yesterday)
+    #   Post.by_day("next tuesday")
+    def by_day(time = Time.zone.now, options = {}, &block)
+      time = parse(time)
+      by_star(time.beginning_of_day, time.end_of_day, options, &block)
+    end
+    alias_method :today, :by_day
+
+    # Examples:
+    #   Post.yesterday
+    #   # 2 days ago:
+    #   Post.yesterday(Time.yesterday)
+    #   # day before next tuesday
+    #   Post.yesterday("next tuesday")
+    def yesterday(time = Time.zone.now, options = {}, &block)
+      time = parse(time)
+      by_day(time.advance(:days => -1), options, &block)
+    end
+
+    # Examples:
+    #   Post.tomorrow
+    #   # 2 days from now:
+    #   Post.tomorrow(Time.tomorrow)
+    #   # day after next tuesday
+    #   Post.tomorrow("next tuesday")
+    def tomorrow(time = Time.zone.now, options = {}, &block)
+      time = parse(time)
+      by_day(time.advance(:days => 1), options, &block)
+    end
+
+    # Scopes to records older than current or given time
+    # Post.past
+    # Post.past()
+    def past(time = Time.zone.now, options = {}, &block)
+      time = parse(time)
+      by_direction("<", time, options, &block)
+    end
+
+    # Scopes to records newer than current or given time
+    def future(time = Time.zone.now, options = {}, &block)
+      time = parse(time)
+      by_direction(">", time, options, &block)
+    end
+
+    private
+      
+      def by_direction(condition, time, options = {}, &block)
+        field = connection.quote_table_name(table_name)
+        field << "." << connection.quote_column_name(options[:field] || "created_at")
+        with_scope(:find => { :conditions => ["#{field} #{condition} ?", time.utc] }) do
+          if block_given?
+            with_scope(:find => block.call) do
+              find(:all)
+            end
+          else
+            find(:all)
+          end
+        end
+      end
+  
+      # scopes results between start_time and end_time
+      def by_star(start_time, end_time, options = {}, &block)
+        start_time = parse(start_time) 
+        end_time = parse(end_time)
+    
+        raise ParseError, "End time is before start time, searching like this will return no results." if end_time < start_time
+    
+        with_scope(:find => { :conditions => conditions_for_range(start_time, end_time, options) }) do
+          if block_given?
+            with_scope(:find => block.call) do
+              find(:all)
+            end
+          else
+            find(:all)
+          end
+        end
+      end
+  
+      alias :between :by_star
+      public :between
+  
+      # This will work for the next 30 years (written in 2009)
+      def work_out_year(value)
+        case value
+        when 0..39
+          2000 + value
+        when 40..99
+          1900 + value
+        when nil
+          Time.zone.now.year
+        else
+          # We may be passed something that's not a straight out integer
+          # These things include: BigDecimals, Floats and Strings.
+          value.to_i
+        end
+      end
+  
+      # Checks if the object is a Time, Date or TimeWithZone object.
+      def valid_time_or_date?(value)
+        value.is_a?(Time) || value.is_a?(Date) || value.is_a?(ActiveSupport::TimeWithZone)
+      end
+  
+      def parse(object)
+        object = case object.class.to_s
+        when "NilClass"
+          o = Time.zone.now
+        when "String"
+          o = object
+          Chronic.parse(object, :now => Time.zone.now)
+        when "Date"
+          object.to_time(:utc)
+        else
+          object
+        end
+        raise ParseError, "Chronic couldn't work out #{o.inspect}; please be more precise." if object.nil?
+        object
+      end
+  
+      def method_missing(method, *args)
+        if method.to_s =~ /^(as_of|up_to)_(.+)$/
+          method = $1
+          expr = $2.humanize
+          unless time = parse(expr)
+            raise ParseError, "Chronic couldn't work out #{expr.inspect}; please be more precise."
+          end
+      
+          reference = args.first || Time.now
+      
+          if "as_of" == method
+            between(time, reference)
+          else
+            between(reference, time)
+          end
+        else
+          super
+        end
+    end
+  end
+end

data/spec/by_star_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'by_star'
 
 describe Post do
-  
+    
   def stub_time(day=15, month=5, year=Time.zone.now.year, hour=0, minute=0)
     stub = "#{day}-#{month}-#{year} #{hour}:#{minute}".to_time
     Time.stub!(:now).and_return(stub)
@@ -26,479 +26,532 @@ describe Post do
     Post.send(method, *args).size
   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(Post.count - 1)
-    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
     
-    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(Post.count - 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 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
+      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
-    end
     
-    it "should be able to use an alternative field" do
-      Event.by_year(nil, :field => "start_time").size.should eql(8)
+      it "should be able to use an alternative field" do
+        Event.by_year(nil, :field => "start_time").size.should eql(8)
+      end
     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(8)
-    end
+      it "should be able to find posts for the current month" do
+        stub_time
+        size.should eql(8)
+      end
       
-    it "should be able to find a single post for January" do
-      size("January").should eql(1)
-    end
+      it "should be able to find a single post for January" do
+        size("January").should eql(1)
+      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 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 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 take decimals" do
-      size(1.5).should eql(1)
-    end
+      it "should be able to take decimals" do
+        size(1.5).should eql(1)
+      end
     
-    it "should be able to use an alternative field" do
-      stub_time(1, 12)
-      Event.by_month(nil, :field => "start_time").size.should eql(1)
-    end
+      it "should be able to use an alternative field" do
+        stub_time(1, 12)
+        Event.by_month(nil, :field => "start_time").size.should eql(1)
+      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
+      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
+    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(3)
-    end
+      it "should be able to find posts in the current fortnight" do
+        stub_time
+        size.should eql(3)
+      end
     
-    it "should be able to find posts in the 1st fortnight" do
-      size(0).should eql(1)
-    end
+      it "should be able to find posts in the 1st fortnight" do
+        size(0).should eql(1)
+      end
     
-    it "should be able to find posts for a fortnight ago" do
-      stub_time
-      size(2.weeks.ago).should eql(5)
-    end
+      it "should be able to find posts for a fortnight ago" do
+        stub_time
+        size(2.weeks.ago).should eql(5)
+      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)
+      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
-  end
   
-  describe "by week" do
+    describe "by week" do
     
-    it "should be able to find posts in the current week" do
-      stub_time
-      size.should eql(3)
-    end
+      it "should be able to find posts in the current week" do
+        stub_time
+        size.should eql(3)
+      end
     
-    it "should be able to find posts in the 1st week" do
-      size(0).should eql(1)
-    end
+      it "should be able to find posts in the 1st week" do
+        size(0).should eql(1)
+      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 of last year" do
+        size(0, :year => Time.zone.now.year-1).should eql(1)
+      end
     
-    it "should not find any posts from a week ago" do  
-      stub_time
-      size(1.week.ago).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 be able to find posts by a given date" do
-      stub_time
-      size(1.week.ago.to_date).should eql(0)
-    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 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 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 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 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 be able to use an alternative field" do
-      stub_time
-      Event.by_week(nil, :field => "start_time").size.should eql(0)
-    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 start of the year" do
-      size(0).should eql(1)
-    end
+      it "should find posts at the start of the year" do
+        size(0).should eql(1)
+      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 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 May" do
-      stub_time(1, 8)
-      size.should eql(8)
     end
+  
+    describe "by weekend" do
+      it "should be able to find the posts on the weekend of the 1st May" do
+        stub_time(1, 8)
+        size.should eql(8)
+      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(1)
+      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(1)
+      end
     end
-  end
   
-  describe "by current weekend" do
-    it "should work" do
-      range_test do
-        Post.by_current_weekend
+    describe "by current weekend" do
+      it "should work" do
+        range_test do
+          Post.by_current_weekend
+        end
       end
     end
-  end
   
-  describe "by current work week" do
-    it "should work" do
-      range_test do
-        Post.by_current_work_week
+    describe "by current work week" do
+      it "should work" do
+        range_test do
+          Post.by_current_work_week
+        end
       end
     end
-  end
   
-  describe "by day" do
-    it "should be able to find a post for today" do
-      stub_time
-      size.should eql(2)
-    end
+    describe "by day" do
+      it "should be able to find a post for today" do
+        stub_time
+        size.should eql(2)
+      end
     
-    it "should be able to find a post by a given date" do
-      stub_time
-      size(Date.today).should eql(2)
-    end
+      it "should be able to find a post by a given date" do
+        stub_time
+        size(Date.today).should eql(2)
+      end
     
-    it "should be able to use an alternative field" do
-      Event.by_day(nil, :field => "start_time").size.should eql(1)
+      it "should be able to use an alternative field" do
+        Event.by_day(nil, :field => "start_time").size.should eql(1)
+      end
     end
-  end
 
-  describe "today" do
-    it "should show the post for today" do
-      find.map(&:text).should include("Today's post")
-    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
+      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
+    end
   
-  describe "tomorrow" do
-    it "should show the post for tomorrow" do
-      find.map(&:text).should include("Tomorrow's post")
+    describe "tomorrow" do
+      it "should show the post for tomorrow" do
+        find.map(&:text).should include("Tomorrow's post")
+      end
     end
-  end
     
-  describe "yesterday" do
-    it "should show the post for yesterday" do
-      find.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 find yesterday, given a Date" do
-      find(Time.now).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
     
-    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 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)
+      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
-  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(16)
-    end
+      it "should show the correct number of posts in the past" do
+        size.should eql(16)
+      end
     
-    it "should find for a given time" do
-      size(Time.zone.now - 2.days).should eql(16)
-    end
+      it "should find for a given time" do
+        size(Time.zone.now - 2.days).should eql(16)
+      end
     
-    it "should find for a given date" do
-      size(Date.today - 2).should eql(16)
-    end
+      it "should find for a given date" do
+        size(Date.today - 2).should eql(16)
+      end
     
-    it "should find for a given string" do
-      size("next tuesday").should eql(19)
-    end
+      it "should find for a given string" do
+        size("next tuesday").should eql(19)
+      end
     
-    it "should be able to find all events before Ryan's birthday using a non-standard field" do
-      Event.past("04-12-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(7)
-    end 
+      it "should be able to find all events before Ryan's birthday using a non-standard field" do
+        Event.past("04-12-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(7)
+      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(71)
-    end
+      it "should show the correct number of posts in the future" do
+        size.should eql(71)
+      end
     
-    it "should find for a given date" do
-      size(Date.today - 2).should eql(73)
-    end
+      it "should find for a given date" do
+        size(Date.today - 2).should eql(73)
+      end
     
-    it "should find for a given string" do
-      size("next tuesday").should eql(70)
-    end
+      it "should find for a given string" do
+        size("next tuesday").should eql(70)
+      end
     
-    it "should be able to find all events after Dad's birthday using a non-standard field" do
-      Event.past("05-07-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(1)
+      it "should be able to find all events after Dad's birthday using a non-standard field" do
+        Event.past("05-07-#{Time.zone.now.year}".to_time, :field => "start_time").size.should eql(1)
+      end
     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(7)
-    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(7)
+      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(14)
-    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(14)
+      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.")
+      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
-  end
   
-  describe "between" do
-    it "should find posts between last tuesday and next tuesday" do
-      stub_time
-      size("last tuesday", "next tuesday").should eql(3)
-    end
+    describe "between" do
+      it "should find posts between last tuesday and next tuesday" do
+        stub_time
+        size("last tuesday", "next tuesday").should eql(3)
+      end
     
-    it "should find between two times" do
-      stub_time
-      size(Time.zone.now - 5.days, Time.zone.now + 5.days).should eql(3)
-    end
+      it "should find between two times" do
+        stub_time
+        size(Time.zone.now - 5.days, Time.zone.now + 5.days).should eql(3)
+      end
     
-    it "should find between two dates" do
-      stub_time
-      size(Date.today, Date.today + 5).should eql(3)
+      it "should find between two dates" do
+        stub_time
+        size(Date.today, Date.today + 5).should eql(3)
+      end
     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(9)
-    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(9)
+      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(14)
-    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(14)
+      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'))
+      it "should raise a proper NoMethodError" do
+        lambda { Post.idontexist }.should raise_error(NoMethodError, %r(^undefined method `idontexist'))
+      end
     end
-  end
   
-  describe "named_scopes" do
-    it "should be compatible" do
-      Event.private.by_year(nil, :field => "start_time").size.should eql(1)
+    describe "named_scopes" do
+      it "should be compatible" do
+        Event.private.by_year(nil, :field => "start_time").size.should eql(1)
+      end
     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
+    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
-  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(2)
-      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(2)
+        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
+        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 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
+        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 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
+        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 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
     
-  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")
+    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
+        end
+      
+        describe "by month" do
+          it "current month" do
+            stub_time
+            Invoice.sum_by_month(:value).should eql(15000)
+          end
+        end
       end
+    
+      describe "Count" do
+        describe "by year" do
+          it "current year" do
+            Invoice.count_by_year.should eql(79)
+          end
+        
+          it "using a field" do
+            Invoice.count_by_year(:number).should eql(Invoice.by_year.size-1)
+          end
+        
+          it "different year" do
+            Invoice.count_by_year(:all, 2008)
+          end
+        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 "different month" do
+            stub_time
+            Invoice.count_by_month(:all, 9).should eql(9)
+          end
+        end
+      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
+      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")
+      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