by_star 0.6.3 → 0.6.4

data/lib/by_star.rb

@@ -7,18 +7,18 @@ require 'vanilla'
 Dir[File.dirname(__FILE__) + '/calculations/*.rb'].each { |file| require file }
 require 'calculations'
 module ByStar
-  
+
   def self.included(base)
     base.extend ClassMethods
   end
-  
+
   module ClassMethods
     include RangeCalculations
     include Shared
     include Vanilla
     include Calculations
   end
-  
+
   class ParseError < Exception; end
   class MonthNotFound < Exception; end
 end

data/lib/calculations.rb

@@ -2,7 +2,7 @@ module ByStar
   module Calculations
     include Count
     include Sum
-    
+
     private
       def work_out_month(time, year=Time.zone.now.year)
         year ||= Time.zone.now.year

data/lib/calculations/count.rb

@@ -7,7 +7,7 @@ module ByStar
           count(field, { :conditions => conditions_for_range(start_of_year(year), end_of_year(year), db_field) }.reverse_merge!(options))
         end
       end
-      
+
       def count_by_month(field=nil, month=Time.now.month, options={}, &block)
         db_field = options.delete(:field)
         year, month = work_out_month(month, options.delete(:year))

data/lib/calculations/sum.rb

@@ -13,7 +13,7 @@ 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)

data/lib/range_calculations.rb

@@ -2,22 +2,22 @@ module ByStar
   module RangeCalculations
 
     private
-    
+
     def start_of_year(year=Time.zone.now.year)
       Time.utc(year, 1, 1)
     end
-    
+
     def end_of_year(year=Time.zone.now.year)
       start_of_year(year).end_of_year
     end
-    
+
     def start_of_month(month, year=Timeow.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

@@ -3,7 +3,7 @@ module Shared
     field = table_name << '.' << (field ? field.to_s : "created_at")
     ["#{field} >= ? AND #{field} <= ?", start_time.utc, end_time.utc]
   end
-  
+
   private 
   def scoped_by(options=nil, &block)
     if options && scope = options.call

data/lib/time_ext.rb

@@ -11,7 +11,7 @@ class Time
     # 3pm, Friday.
     (friday + 15.hours)
   end
-  
+
   def end_of_weekend
     # 3am, Monday.
     # LOL I CHEATED.

data/lib/vanilla.rb

@@ -25,7 +25,7 @@ module ByStar
     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.delete(:year))
-  
+
       start_time = start_of_month(month, year)
       end_time = start_time.end_of_month
 
@@ -37,14 +37,14 @@ module ByStar
     #   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)
@@ -69,19 +69,19 @@ module ByStar
     #   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.delete(: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)
         weeks = time.strftime("%U").to_i
-        
+
         # Sunday defines the start of the week.
         # Finds the sunday that defines the starting week of the year.
         # This is because AS +*.weeks helper works off the given time, which could be any day.
@@ -109,7 +109,6 @@ module ByStar
       time = parse(time)
       start_time = time.beginning_of_weekend
       end_time = (start_time + 1.day).end_of_day
-      p start_time..end_time
       by_star(start_time, end_time, options, &block)
     end
 
@@ -185,36 +184,31 @@ module ByStar
     end
 
     private
-      
+
       def by_direction(condition, time, options = {}, &block)
-        field = options.delete(:field) || "created_at"
+        field = options.delete(:field) || "#{self.table_name}.created_at"
         ensure_valid_options(options)
-        scoping = { :conditions => ["#{field} #{condition} ?", time.utc] }.merge(options)
-        with_scope(:find => scoping) do
-          scoped_by(block) do
-            find(:all)
-          end
-        end
+        result = scoped({ :conditions => ["#{field} #{condition} ?", time.utc] }.merge(options))
+        result = result.scoped(block.call) if block_given?
+        result
       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
         field = options.delete(:field)
         ensure_valid_options(options)
-        
+
         scoping = { :conditions => conditions_for_range(start_time, end_time, field) }.merge(options)
-        with_scope(:find => scoping) do
-          scoped_by(block) do
-            find(:all)
-          end
-        end
+        result = scoped(scoping)
+        result = result.scoped(block.call) if block_given?
+        result
       end
-      
+
       def ensure_valid_options(options)
         if respond_to?(:validate_find_options)
           validate_find_options(options)
@@ -222,10 +216,10 @@ module ByStar
           options.assert_valid_keys(ActiveRecord::SpawnMethods::VALID_FIND_OPTIONS)
         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
@@ -241,12 +235,12 @@ module ByStar
           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"
@@ -262,7 +256,7 @@ module ByStar
         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
@@ -270,9 +264,9 @@ module ByStar
           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

data/spec/by_star_spec.rb

@@ -7,53 +7,58 @@ describe Post do
   # + 2 for today
   # + 2 for yesterday
   # + 2 for tomorrow
+  # + 1 for current week
   # + 1 for current weekend
   # + 1 for current fortnight
   # + 1 for the end of year
-  # = 21
+  # = 22
   def this_years_posts
-    21
+    22
   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 range_test(&block)
     (1..31).to_a.each do |d|
       stub_time(d, 07, 2009, 05, 05)
       block.call
     end
   end
-  
+
   def find(*args)
     method = description_args.first.sub(' ', '_')
     Post.send(method, *args)
   end
-  
+
   def size(*args)
     method = description_args.first.sub(' ', '_')
     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(this_years_posts.size)
+        size.should eql(this_years_posts)
       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)
+        size(Time.zone.now.year.to_s).should eql(this_years_posts)
       end
-    
+
       it "should be able to find a single post from last year" do
-        size(Time.zone.now.year-1).should eql(1)
+        size(Time.zone.now.year-1).should eql(2)
       end
-    
+
+      it "knows what last year's posts were" do
+        find(Time.zone.now.year-1).map(&:text).should eql(["Last year", "End of last year"])
+      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)
@@ -66,61 +71,68 @@ describe Post do
           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 (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 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
-    
+
       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)
+        # If it is January we'll have all the "current" posts in there.
+        # This makes the count 10.
+        # I'm sure you can guess what happens when it's not January.
+        size("January").should eql(Time.now.month == 1 ? 10 : 1)
       end
-  
+
       it "should be able to find two posts for the 2nd month" do
-        # This test is fundamentally broken.
-        # Sometimes the current month is #2, therefore this number is 10.
-        # When it is not it is 2.
-        size(2).should eql(2)
+        # If it is February we'll have all the "current" posts in there.
+        # This makes the count 10.
+        # I'm sure you can guess what happens when it's not February.
+        size(2).should eql(Time.now.month == 2 ? 10 : 1)
       end
-  
+
       it "should be able to find three posts for the 3rd month, using time instance" do
-        size(Time.local(Time.zone.now.year, 3, 1)).should eql(1)
+        # If it is March we'll have all the "current" posts in there.
+        # This makes the count 10.
+        # I'm sure you can guess what happens when it's not March.
+        time = Time.local(Time.zone.now.year, 3, 1)
+        size(time).should eql(Time.now.month == 3 ? 10 : 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 be able to take decimals" do
         size(1.5).should eql(1)
       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)
@@ -129,102 +141,107 @@ describe Post do
           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
-    
+
       it "should be able to find posts in the current fortnight" do
-        stub_time
-        size.should eql(4)
+        size.should eql(10)
       end
-    
+
       it "should be able to find posts in the 1st fortnight" do
         size(0).should eql(2)
       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 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(2)
       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 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 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 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 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)
+        case Time.zone.now.wday
+        when 5 # Friday
+          size.should eql(3)
+        when 6 # Saturday
+          size.should eql(5)
+        else
+          size.should eql(3)
+        end
       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
@@ -232,7 +249,7 @@ describe Post do
         end
       end
     end
-  
+
     describe "by current work week" do
       it "should work" do
         range_test do
@@ -240,19 +257,18 @@ describe Post do
         end
       end
     end
-  
+
     describe "by day" do
       it "should be able to find a post for today" do
         stub_time
-        p Post.by_day
         size.should eql(1)
       end
-    
+
       it "should be able to find a post by a given date" do
         stub_time
         size(Date.today).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
@@ -262,186 +278,186 @@ describe Post 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
     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 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
-    
+
       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
     end
-  
+
     describe "past" do
-    
+
       before do
         stub_time
       end
-    
+
       it "should show the correct number of posts in the past" do
         size.should eql(2)
       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 string" do
         size("next tuesday").should eql(3)
       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")
       end
-    
+
     end
-  
+
     describe "future" do
       before do
         stub_time
       end
-    
+
       it "should show the correct number of posts in the future" do
         size.should eql(21)
       end
-    
+
       it "should find for a given date" do
         size(Date.today - 2).should eql(23)
       end
-    
+
       it "should find for a given string" do
         size("next tuesday").should eql(21)
       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(2)
       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(3)
       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
     end
-  
+
     describe "between" do
       it "should find posts between last tuesday and next tuesday" do
         stub_time
         size("last tuesday", "next tuesday").should eql(2)
       end
-    
+
       it "should find between two times" do
         stub_time
         size(Time.zone.now - 5.days, Time.zone.now + 5.days).should eql(2)
       end
-    
+
       it "should find between two dates" do
         stub_time
         size(Date.today, Date.today + 5).should eql(1)
       end
     end
-  
+
     describe "up to" do
       it "should be able to find posts up to 6 weeks from now" do
         stub_time
         Post.up_to_6_weeks_from_now.size.should eql(2)
       end
-    
+
       it "should be able to find posts up to 6 weeks from a given time" do
         stub_time
         Post.up_to_6_weeks_from_now(Time.zone.now - 1.month).size.should eql(3)
       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
-      
+
     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
     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
@@ -449,10 +465,10 @@ describe Post do
         end }.should_not raise_error
       end
     end
-  
-  
+
+
     describe "nested find" do
-    
+
       it "should be able to find posts after right now" do
         stub_time
         # The post at the end of last year
@@ -463,85 +479,87 @@ describe Post 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 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 'fortnight'" 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 'week'" 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 pot from the last week of last year with the tag 'final'" do
         Post.by_week(52, :year => Time.zone.now.year - 1) do
           { :include => :tags, :conditions => ["tags.name = ?", 'final'] }
         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 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 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 work when block is empty" do
-        stub_time        
-        Post.future { }.size.should eql(this_years_posts)
+        stub_time
+        # This will not find the post on the 1st January.
+        # future uses > rather than >=.
+        Post.future { }.size.should eql(this_years_posts - 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
@@ -553,7 +571,7 @@ describe Post do
             Invoice.sum_by_year(:value).should eql(135500)
           end
         end
-      
+
         describe "by month" do
           it "current month" do
             stub_time
@@ -561,7 +579,7 @@ describe Post do
             Invoice.sum_by_month(:value).should eql(15500)
           end
         end
-        
+
         describe "by day" do
           it "current day" do
             stub_time(2, 1) # 2nd January
@@ -569,24 +587,24 @@ describe Post do
           end
         end
       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(14)
           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
             # 1 invoice from last year
             Invoice.count_by_year(:all, Time.zone.now.year-1).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
@@ -594,27 +612,27 @@ describe Post do
             end.should eql(1)
           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)
           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
             Post.count_by_month(:all, Time.zone.now) { }.should eql(10)
           end
@@ -623,6 +641,19 @@ describe Post do
 
     end
     
+    describe "chaining of methods" do
+      # a by_star and a by_direction method, in that order
+      it "should be able to chain today and past" do
+        Post.today.past.size.should eql(4)
+      end
+      
+      # a by_direction and by_star method, in that order
+      it "should be able to chain together past and today" do
+        Post.past.today.size.should eql(4)
+      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.
@@ -630,14 +661,14 @@ describe Post 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
       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")
@@ -645,5 +676,5 @@ describe Post do
       end
     end
   end
-  
+
 end