by_star 1.0.1 → 2.0.0.beta1

data/by_star.gemspec

@@ -15,6 +15,12 @@ Gem::Specification.new do |s|
   s.rubyforge_project         = "by_star"
 
   s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "pg"
+  s.add_development_dependency "mysql2"
+  s.add_development_dependency "rspec-rails", "~> 2.8"
+  s.add_development_dependency "timecop", "~> 0.3"
+
   s.add_dependency "activerecord", ">= 2.0.0"
   s.add_dependency "chronic"
 

data/lib/by_star.rb

@@ -1,43 +1,63 @@
 require 'chronic'
 
-require 'by_star/shared'
-require 'by_star/range_calculations'
 require 'by_star/time_ext'
-require 'by_star/vanilla'
-require 'by_star/neighbours'
+require 'by_star/instance_methods'
 
-require 'by_star/calculations/count'
-require 'by_star/calculations/sum'
-
-require 'by_star/calculations'
+require 'by_star/by_direction'
+require 'by_star/by_year'
+require 'by_star/by_month'
+require 'by_star/by_fortnight'
+require 'by_star/by_week'
+require 'by_star/by_weekend'
+require 'by_star/by_day'
 
 module ByStar
 
-  def self.included(base)
-    base.extend ClassMethods
-    base.send(:include, InstanceMethods)
-    base.class_eval do
-      def self.by_star_field(value=nil)
-        @by_star_field ||= value
-        @by_star_field || "#{self.table_name}.created_at"
-      end
-    end
+  def by_star_field(field=nil)
+    @by_star_field ||= field
+    @by_star_field || "created_at"
+  end
+
+  include ByDirection
+  include ByYear
+  include ByMonth
+  include ByFortnight
+  include ByWeek
+  include ByWeekend
+  include ByDay
+
+  class ParseError < StandardError
+
   end
 
-  module ClassMethods
-    include RangeCalculations
-    include Shared
-    include Vanilla
-    include Calculations
+  # Returns all records between a given start and finish time.
+  #
+  # Currently only supports Time objects.
+  def between(start, finish, options={})
+    field = options[:field] || by_star_field
+    scope = where("#{field} >= ? AND #{field} <= ?",
+              start, finish)
+    scope = scope.order(options[:order]) if options[:order]
+    scope
   end
 
-  module InstanceMethods
-    include Neighbours
+  private
+
+  # Used inside the by_* methods to determine what kind of object "time" is.
+  # These methods take the result of the time_klass method, and call other methods
+  # using it, such as by_year_Time and by_year_String.
+  def time_klass(time)
+    case time
+    when ActiveSupport::TimeWithZone
+      Time
+    else
+      time.class
+    end
   end
 
-  class ParseError < Exception; end
-  class MonthNotFound < Exception; end
 end
 
-ActiveRecord::Base.send :include, ByStar
-ActiveRecord::Relation.send :include, ByStar if ActiveRecord.const_defined?("Relation")
+ActiveRecord::Base.send :extend, ByStar
+ActiveRecord::Relation.send :extend, ByStar
+
+ActiveRecord::Base.send :include, ByStar::InstanceMethods

data/lib/by_star/by_day.rb

@@ -0,0 +1,30 @@
+module ByStar
+  module ByDay
+    def by_day(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first
+      time ||= Time.zone.local(options[:year], 1, 1) if options[:year]
+      time ||= Time.zone.now
+      send("by_day_#{time_klass(time)}", time, options)
+    end
+
+    def today(options={})
+      by_day_Time(Time.zone.now, options)
+    end
+
+    def yesterday(options={})
+      by_day_Time(Time.zone.now.yesterday, options)
+    end
+
+    def tomorrow(options={})
+      by_day_Time(Time.zone.now.tomorrow, options)
+    end
+
+    private
+
+    def by_day_Time(time, options)
+      between(time.beginning_of_day, time.end_of_day, options)
+    end
+
+  end
+end

data/lib/by_star/by_direction.rb

@@ -0,0 +1,52 @@
+module ByStar
+  module ByDirection
+    def before(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first || Time.zone.now
+      send("before_#{time_klass(time)}", time, options)
+    end
+    alias_method :before_now, :before
+
+    def after(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first || Time.zone.now
+      send("after_#{time_klass(time)}", time, options)
+    end
+    alias_method :after_now, :after
+
+    private
+
+    def before_Time_or_Date(time_or_date, options={})
+      field = options[:field] || by_star_field
+      where("#{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 = options[:field] || by_star_field
+      if time = Chronic.parse(string)
+        where("#{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 = options[:field] || by_star_field
+      where("#{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 = options[:field] || by_star_field
+      if time = Chronic.parse(string)
+        where("#{field} >= ?", time)
+      else
+        raise ParseError, "Chronic couldn't understand #{string.inspect}. Please try something else."
+      end
+    end
+
+  end
+end

data/lib/by_star/by_fortnight.rb

@@ -0,0 +1,54 @@
+module ByStar
+  module ByFortnight
+    # For reasoning why I use *args rather than variables here,
+    # please see the by_year method comments in lib/by_star/by_year.rb
+
+    def by_fortnight(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first
+      time ||= Time.local(options[:year], 1, 1) if options[:year]
+      time ||= Time.zone.now
+      send("by_fortnight_#{time_klass(time)}", time, options)
+    end
+
+    private
+
+    def by_fortnight_Time(time, options={})
+      # We want to get the current fortnight and so...
+      # We need to find the current week number and take one from it,
+      # so that we are correctly offset from the start of the year.
+      # The first fortnight of the year should of course start on the 1st January,
+      # and not the beginning of that week.
+      start_time = time.beginning_of_year + (time.strftime("%U").to_i - 1).weeks
+      between(start_time, (start_time + 2.weeks).end_of_day, options)
+    end
+
+    def by_fortnight_String_or_Fixnum(weeks, options={})
+      weeks = weeks.to_i
+      current_time = Time.zone.local(options[:year] || Time.zone.now.year)
+      if weeks <= 26
+        start_time = current_time + (weeks * 2).weeks
+        between(start_time, (start_time + 2.weeks).end_of_day, options)
+      else
+        raise ParseError, "by_fortnight takes only a Time, Date or a Fixnum (less than or equal to 26)."
+      end
+    end
+    alias_method :by_fortnight_String, :by_fortnight_String_or_Fixnum
+    alias_method :by_fortnight_Fixnum, :by_fortnight_String_or_Fixnum
+
+
+
+    # def omg 
+    #   time.beginning_of_year + (time.strftime("%U").to_i).weeks
+    #   if 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
+
+    #   between(start_time.beginning_of_week, start_time + 2.weeks)
+    # end
+
+
+  end
+end

data/lib/by_star/by_month.rb

@@ -0,0 +1,35 @@
+module ByStar
+  module ByMonth
+    # For reasoning why I use *args rather than variables here,
+    # please see the by_year method comments in lib/by_star/by_year.rb
+
+    def by_month(*args)
+      options = args.extract_options!
+      time = args.first || Time.zone.now
+      send("by_month_#{time_klass(time)}", time, options)
+    end
+
+    private
+
+    def by_month_Time(time, options={})
+      between(time.beginning_of_month, time.end_of_month, options)
+    end
+
+    def by_month_String_or_Fixnum(month, options={})
+      if valid_month?(month)
+        year = options[:year] || Time.zone.now.year
+        by_month_Time("#{year}-#{month}-01".to_time, options)
+      else
+        raise ParseError, "Month must be a number between 1 and 12 or the full month name (e.g. 'January', 'Feburary', etc.)"
+      end
+    end
+    alias_method :by_month_String, :by_month_String_or_Fixnum
+    alias_method :by_month_Fixnum, :by_month_String_or_Fixnum
+
+
+    def valid_month?(month)
+      (1..12).include?(month) || Date::MONTHNAMES.include?(month)
+    end
+
+  end
+end

data/lib/by_star/by_week.rb

@@ -0,0 +1,30 @@
+module ByStar
+  module ByWeek
+
+    # For reasoning why I use *args rather than variables here,
+    # please see the by_year method comments in lib/by_star/by_year.rb
+
+    def by_week(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first
+      time ||= Time.zone.local(options[:year], 1, 1) if options[:year]
+      time ||= Time.zone.now
+      send("by_week_#{time_klass(time)}", time, options)
+    end
+
+    private
+
+    def by_week_Time_or_Date(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_Fixnum(week, options={})
+      time = Time.zone.local(options[:year], 1, 1) if options[:year]
+      time ||= Time.zone.now
+      start_time = time.beginning_of_year + week.to_i.weeks
+      between(start_time, (start_time + 1.week).end_of_day, options)
+    end
+  end
+end

data/lib/by_star/by_weekend.rb

@@ -0,0 +1,17 @@
+module ByStar
+  module ByWeekend
+    def by_weekend(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first
+      time ||= Time.zone.now
+      send("by_weekend_#{time_klass(time)}", time, options)
+    end
+
+    private
+
+    def by_weekend_Time(time, options={})
+      between(time.beginning_of_weekend, time.end_of_weekend)
+    end
+
+  end
+end

data/lib/by_star/by_year.rb

@@ -0,0 +1,60 @@
+module ByStar
+  module ByYear
+
+    # NOTE: We would define this as this:
+    #
+    #  def by_year(time=Time.zone.now, options={})
+    #
+    # But, there's a potential situation where people want to just pass options.
+    # Like this:
+    #
+    #   Post.by_year(:field => "published_at")
+    #
+    # And so, we support any number of arguments and just parse them as necessary.
+    # By doing it this way, we can support *both* this:
+    #
+    #   Post.by_year(2012, :field => "published_at")
+    #
+    # And this:
+    #
+    #   Post.by_year(:field => "published_at")
+    #
+    # This is because the time variable is going to be defaulting to the current time.
+
+    def by_year(*args)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first || Time.zone.now
+
+      send("by_year_#{time_klass(time)}", time, options)
+    end
+
+    private
+
+    def by_year_Time_or_Date(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_String_or_Fixnum(year, options={})
+      by_year_Time("#{work_out_year(year)}-01-01".to_time, options)
+    end
+    alias_method :by_year_String, :by_year_String_or_Fixnum
+    alias_method :by_year_Fixnum, :by_year_String_or_Fixnum
+
+    def work_out_year(value)
+      case value.to_i
+      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
+  end
+end

data/lib/by_star/instance_methods.rb

@@ -0,0 +1,13 @@
+module ByStar
+  module InstanceMethods
+    def previous(options={})
+      field = options[:field] || self.class.by_star_field
+      self.class.where("#{field} < ?", self.send(field)).reorder("#{field} DESC").first
+    end
+
+    def next(options={})
+      field = options[:field] || self.class.by_star_field
+      self.class.where("#{field} > ?", self.send(field)).reorder("#{field} ASC").first
+    end
+  end
+end

data/lib/by_star/time_ext.rb

@@ -17,4 +17,5 @@ class Time
     # LOL I CHEATED.
     beginning_of_weekend + 3.days - 12.hours
   end
-end
+end
+

data/lib/by_star/version.rb

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

data/spec/by_star/by_day_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+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
+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