by_star 2.0.0.beta1 → 2.1.0.beta2

data/lib/by_star/by_week.rb

@@ -14,11 +14,13 @@ module ByStar
 
     private
 
-    def by_week_Time_or_Date(time, options={})
+    def by_week_Time(time, options={})
       between(time.beginning_of_week, time.end_of_week, options)
     end
-    alias_method :by_week_Time, :by_week_Time_or_Date
-    alias_method :by_week_Date, :by_week_Time_or_Date
+
+    def by_week_Date(date, options={})
+      by_week_Time(date.to_time, options)
+    end
 
     def by_week_Fixnum(week, options={})
       time = Time.zone.local(options[:year], 1, 1) if options[:year]

data/lib/by_star/by_weekend.rb

@@ -13,5 +13,8 @@ module ByStar
       between(time.beginning_of_weekend, time.end_of_weekend)
     end
 
+    def by_weekend_Date(date, options={})
+      by_weekend_Time(date.to_time, options)
+    end
   end
 end

data/lib/by_star/by_year.rb

@@ -30,11 +30,13 @@ module ByStar
 
     private
 
-    def by_year_Time_or_Date(time, options={})
+    def by_year_Time(time, options={})
       between(time.beginning_of_year, time.end_of_year, options)
     end
-    alias_method :by_year_Time, :by_year_Time_or_Date
-    alias_method :by_year_Date, :by_year_Time_or_Date
+
+    def by_year_Date(date, options={})
+      by_year_Time(date.to_time, options)
+    end
 
     def by_year_String_or_Fixnum(year, options={})
       by_year_Time("#{work_out_year(year)}-01-01".to_time, options)

data/lib/by_star/version.rb

@@ -1,3 +1,3 @@
 module ByStar
-  VERSION = "2.0.0.beta1"
+  VERSION = "2.1.0.beta2"
 end

data/lib/mongoid/by_star.rb

@@ -0,0 +1,83 @@
+module Mongoid::ByStar
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    include ByStar
+
+    def by_star_field(field=nil)
+      @by_star_field ||= field
+      @by_star_field || :created_at
+    end
+
+    # override ByStar method
+    def between(start, finish, options={})
+      field = by_star_field_class(options)
+      scope = gte(field => start).lte(field => finish)
+      scope = scope.order_by(field => options[:order]) if options[:order]
+      scope
+    end
+    alias_method :between_times, :between
+
+    # override private methods in ByStar::ByDirection
+    def before_Time_or_Date(time_or_date, options={})
+      field = by_star_field_class(options)
+      lte(field => time_or_date)
+    end
+    alias_method :before_Time, :before_Time_or_Date
+    alias_method :before_Date, :before_Time_or_Date
+
+    def before_String(string, options={})
+      field = by_star_field_class(options)
+      if time = Chronic.parse(string)
+        lte(field => time)
+      else
+        raise ParseError, "Chronic couldn't understand #{string.inspect}. Please try something else."
+      end
+    end
+
+    def after_Time_or_Date(time_or_date, options={})
+      field = by_star_field_class(options)
+      gte(field => time_or_date)
+    end
+    alias_method :after_Time, :after_Time_or_Date
+    alias_method :after_Date, :after_Time_or_Date
+
+    def after_String(string, options={})
+      field = by_star_field_class(options)
+      if time = Chronic.parse(string)
+        gte(field => time)
+      else
+        raise ParseError, "Chronic couldn't understand #{string.inspect}. Please try something else."
+      end
+    end
+
+    protected
+
+    def by_star_field_class(options={})
+      field = options[:field] || by_star_field
+      field = aliased_fields[field.to_s] if aliased_fields.has_key?(field.to_s)
+      field.to_sym
+    end
+  end
+
+  include ByStar::InstanceMethods
+
+  # override ByStar::InstanceMethods methods
+  def previous(options={})
+    field = by_star_field_instance(options)
+    self.class.lt(field => self.send(field)).desc(field).first
+  end
+
+  def next(options={})
+    field = by_star_field_instance(options)
+    self.class.gt(field => self.send(field)).asc(field).first
+  end
+
+  protected
+
+  def by_star_field_instance(options={})
+    field = options[:field] || self.class.by_star_field
+    field = self.class.aliased_fields[field.to_s] if self.class.aliased_fields.has_key?(field.to_s)
+    field.to_sym
+  end
+end

data/spec/by_star/active_record/active_record_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+Dir[File.dirname(__FILE__) + '/../shared/*.rb'].each {|file| require file }
+
+describe ActiveRecord do
+  before(:all) do
+    ActiveRecord::Base.default_timezone = :utc
+
+    db_config = YAML::load_file(File.dirname(__FILE__) + "/../../database.yml")
+    if db_config.has_key?('sqlite') && db_config['sqlite'].has_key?('database')
+      db_config['sqlite']['database'] = File.dirname(__FILE__) + '/../../tmp/' + db_config['sqlite']['database']
+    end
+
+    ActiveRecord::Base.configurations = db_config
+    ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite")
+    load File.dirname(__FILE__) + "/../../fixtures/active_record/schema.rb"
+    load File.dirname(__FILE__) + "/../../fixtures/active_record/models.rb"
+    load File.dirname(__FILE__) + "/../../fixtures/shared/seeds.rb"
+
+    ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/../../tmp/activerecord.log")
+  end
+
+  it_behaves_like "by day"
+  it_behaves_like "by direction"
+  it_behaves_like "by fortnight"
+  it_behaves_like "by month"
+  it_behaves_like "by quarter"
+  it_behaves_like "by week"
+  it_behaves_like "by weekend"
+  it_behaves_like "by year"
+
+  it "should be able to order the result set" do
+    scope = Post.by_year(Time.zone.now.year, :order => "created_at DESC")
+    scope.order_values.should == ["created_at DESC"]
+  end
+
+  describe "#between" do
+    it "should return an ActiveRecord::Relation object" do
+      Post.between(Date.today - 2, Date.today).class.should == ActiveRecord::Relation
+    end
+    it "should return a result set between two times" do
+      Post.between(Date.today - 2, Date.today).count.should == 1
+    end
+  end
+
+  describe "#between_times" do
+    it "should be an alias of #between" do
+      Post.between_times(Date.today - 2, Date.today).should == Post.between(Date.today - 2, Date.today)
+    end
+  end
+end

data/spec/by_star/mongoid/mongoid_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+Dir[File.dirname(__FILE__) + '/../shared/*.rb'].each {|file| require file }
+
+describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3') do
+
+  before(:all) do
+    DATABASE_NAME = "mongoid_#{Process.pid}"
+
+    Mongoid.configure do |config|
+      config.connect_to DATABASE_NAME
+    end
+
+    load File.dirname(__FILE__) + "/../../fixtures/mongoid/models.rb"
+    load File.dirname(__FILE__) + "/../../fixtures/shared/seeds.rb"
+  end
+
+  after(:all) do
+    Mongoid.purge!
+  end
+
+  it_behaves_like "by day"
+  it_behaves_like "by direction"
+  it_behaves_like "by fortnight"
+  it_behaves_like "by month"
+  it_behaves_like "by quarter"
+  it_behaves_like "by week"
+  it_behaves_like "by weekend"
+  it_behaves_like "by year"
+
+  describe "#between" do
+    it "should return a Mongoid::Critera object" do
+      Post.between(Date.today - 2, Date.today).class.should == Mongoid::Criteria
+    end
+    it "should return a result set between two times" do
+      Post.between(Date.today - 2, Date.today).count.should == 1
+    end
+  end
+
+  describe "#between_times" do
+    it "should be an alias of #between" do
+      Post.between_times(Date.today - 2, Date.today).should == Post.between(Date.today - 2, Date.today)
+    end
+  end
+end

data/spec/by_star/shared/by_day.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+shared_examples_for "by day" do
+  describe "by day" do
+    def posts_count(*args)
+      Post.by_day(*args).count
+    end
+
+    it "should be able to find a post for today" do
+      posts_count.should eql(4)
+    end
+
+    it "should be able to find a post by a given date in last year" do
+      posts_count(:year => Time.zone.now.year - 1).should eql(1)
+    end
+
+    it "should be able to use an alternative field" do
+      Event.by_day(Time.now.yesterday, :field => "start_time").size.should eql(1)
+    end
+
+    it "should be able to use a date" do
+      posts_count(Date.today).should eql(4)
+    end
+
+    it "should be able to use a String" do
+      posts_count(Date.today.to_s).should eql(4)
+    end
+  end
+
+  describe "today" do
+    it "should show the post for today" do
+      Post.today.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.
+      Event.today(:field => "start_time").size.should eql(1)
+    end
+  end
+
+  describe "yesterday" do
+
+    it "should show the post for yesterday" do
+      Post.yesterday.map(&:text).should include("Yesterday's post")
+    end
+
+    it "should be able to use an alternative field" do
+      Event.yesterday(:field => "start_time").size.should eql(1)
+    end
+
+  end
+
+  describe "tomorrow" do
+    it "should show the post for tomorrow" do
+      Post.tomorrow.map(&:text).should include("Tomorrow's post")
+    end
+
+    it "should be able to use an alternative field" do
+      Event.tomorrow(:field => "start_time").size.should eql(1)
+    end
+  end
+end

data/spec/by_star/shared/by_direction.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+shared_examples_for "by direction" do
+  describe "before" do
+    def posts_count(*args)
+      Post.before(*args).count
+    end
+
+    it "should show the correct number of posts in the past" do
+      posts_count.should == 5
+    end
+
+    it "is aliased as before_now" do
+      Post.before_now.count.should == 5
+    end
+
+    it "should find for a given time" do
+      posts_count(Time.zone.now - 2.days).should eql(2)
+    end
+
+    it "should find for a given date" do
+      posts_count(Date.today - 2).should eql(2)
+    end
+
+    it "should find for a given string" do
+      posts_count("next tuesday").should eql(8)
+    end
+
+    it "raises an exception when Chronic can't parse" do
+      lambda { posts_count(";aosdjbjisdabdgofbi") }.should raise_error(ByStar::ParseError)
+    end
+
+    it "should be able to find all events before Ryan's birthday using a non-standard field" do
+      Event.before(Time.local(Time.zone.now.year+2), :field => "start_time").count.should eql(8)
+    end
+  end
+
+  describe "future" do
+    def posts_count(*args)
+      Post.after(*args).count
+    end
+
+    it "should show the correct number of posts in the future" do
+      Post.after.count.should eql(posts_count)
+      Post.after_now.count.should eql(posts_count)
+    end
+
+    it "should find for a given date" do
+      posts_count(Date.today - 2).should eql(19)
+    end
+
+    it "should find for a given string" do
+      posts_count("next tuesday").should eql(13)
+    end
+
+    it "should be able to find all events before Dad's birthday using a non-standard field" do
+      Event.after(Time.zone.local(Time.zone.now.year, 7, 5), :field => "start_time").count.should eql(3)
+    end
+  end
+
+  describe "previous and next" do
+    let(:current_post)  { Post.find_by_text("post 1") }
+    let(:current_event) { Event.find_by_name("Mum's birthday!") }
+
+    context "previous" do
+      it "can find the previous post" do
+        current_post.previous.text.should == "Yesterday's post"
+      end
+
+      it "takes the field option" do
+        current_event.previous(:field => "start_time").name.should == "Dad's birthday!"
+      end
+    end
+
+    context "next" do
+      it "can find the next post" do
+        current_post.next.text.should == "Today's post"
+      end
+
+      it "takes the field option" do
+        current_event.next(:field => "start_time").name.should == "Ryan's birthday!"
+      end
+    end
+  end
+end

data/spec/by_star/shared/by_fortnight.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+shared_examples_for "by fortnight" do
+  describe "by fortnight" do
+    def find_posts(*args)
+      Post.by_fortnight(*args)
+    end
+
+    def posts_count(*args)
+      find_posts(*args).count
+    end
+
+    it "should be able to find posts in the current fortnight" do
+      posts_count.should eql(6)
+    end
+
+    it "should be able to find posts in the 1st fortnight of the current year" do
+      posts_count(0).should eql(6)
+      posts_count("0").should eql(6)
+      # There was previously a situation where incorrect time zone math
+      # caused the 'post 1' post to NOT appear, so count would be 7, rather than 8.
+      # So this line simply regression tests that problem.
+      Post.by_fortnight(0).map(&:text).should include("post 1")
+    end
+
+    it "should be able to find posts for a fortnight ago" do
+      posts_count(2.weeks.ago).should eql(2)
+    end
+
+    it "should be able to find posts for a given fortnight in a year" do
+      posts_count(0, :year => Time.zone.now.year - 1).should eql(1)
+    end
+
+    it "should be able to find posts for the current fortnight in a specific year" do
+      posts_count(:year => Time.zone.now.year - 1).should eql(1)
+    end
+
+    it "should raise an error when given an invalid argument" do
+      lambda { find_posts(27) }.should raise_error(ByStar::ParseError, "by_fortnight takes only a Time, Date or a Fixnum (less than or equal to 26).")
+    end
+
+    it "should be able to use an alternative field" do
+      Event.by_fortnight(nil, :field => "start_time").count.should eql(2)
+    end
+  end
+end
+

data/spec/by_star/shared/by_month.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+shared_examples_for "by month" do
+  describe "by month" do
+    def find_posts(time=Time.zone.now, options={})
+      Post.by_month(time, options)
+    end
+
+    def posts_count(time=Time.zone.now, options={})
+      find_posts(time, options).count
+    end
+
+    it "should be able to find posts for the current month" do
+      posts_count.should eql(6)
+    end
+
+    it "should be able to find a single post for January" do
+      # 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.
+      posts_count("January").should eql(6)
+    end
+
+    it "should be able to find two posts for the 2nd month" do
+      # 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.
+      posts_count(2).should eql(1)
+    end
+
+    it "should be able to find three posts for the 3rd month, using time instance" do
+      # 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)
+      posts_count(time).should eql(1)
+    end
+
+    it "should be able to find a single post from January last year" do
+      posts_count("January", :year => Time.zone.now.year - 1).should eql(1)
+    end
+
+    it "should fail when given incorrect months" do
+      lambda { find_posts(0) }.should raise_error(ByStar::ParseError)
+      lambda { find_posts(13) }.should raise_error(ByStar::ParseError)
+      lambda { find_posts("Ryan") }.should raise_error(ByStar::ParseError)
+      # LOL arrays
+      lambda { find_posts([1,2,3]) }.should raise_error(NoMethodError)
+    end
+
+    it "should be able to use an alternative field" do
+      Timecop.freeze(Time.zone.local(Time.zone.now.year, 12, 1, 0, 0, 0)) do
+        Event.by_month(:field => "start_time").size.should eql(1)
+      end
+    end
+
+    it "should be able to specify the year as a string" do
+      posts_count(1, :year => (Time.zone.now.year - 1).to_s).should eql(1)
+    end
+
+    it "should be able to accept time datatype" do
+      posts_count(Time.now - 1.year).should eql(1)
+    end
+
+    it "should be able to accept date datatype" do
+      posts_count(Date.today - 1.year).should eql(1)
+    end
+  end
+
+  describe "by calendar month" do
+    def find_posts(time=Time.zone.now, options={})
+      Post.by_calendar_month(time, options)
+    end
+
+    def posts_count(time=Time.zone.now, options={})
+      find_posts(time, options).count
+    end
+
+    it "should be able to find posts for the current calendar month" do
+      posts_count.should eql(8)
+    end
+
+    it "should be able to find a single post for January calendar month" do
+      # 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.
+      posts_count("January").should eql(8)
+    end
+
+    it "should be able to find two posts for the 2nd calendar month" do
+      # 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.
+      posts_count(2).should eql(2)
+    end
+
+    it "should be able to find three posts for the 3rd calendar month, using time instance" do
+      # 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)
+      posts_count(time).should eql(1)
+    end
+
+    it "should be able to find a single post from January last year" do
+      posts_count("January", :year => Time.zone.now.year - 1).should eql(1)
+    end
+  end
+end