by_star 2.1.0.beta2 → 2.2.0.rc1

data/Rakefile

@@ -1,2 +1,18 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+
+def orm_test(orm)
+  RSpec::Core::RakeTask.new(orm) do |task|
+    task.pattern = "./spec/{unit,integration/#{orm}}/{,/*/**}/*_spec.rb"
+  end
+end
+
+namespace :spec do
+  orm_test 'active_record'
+  orm_test 'mongoid'
+end
+
+task default: :spec

data/UPGRADING

@@ -0,0 +1,10 @@
+Upgrading to ByStar 2.2.0
+-------------------------
+
+* For Mongoid only, ByStar's `.between` method has been removed and replaced with `.between_times`
+(previously `.between_times` was an alias to `.between`). Mongoid already provides a native `.between`
+finder method that we do not want to mask. ActiveRecord users may continue to use either method.
+
+* Chronic gem (used for time string parsing) has been removed as a hard dependency for ByStar,
+however it is still supported. If you would like to use Chronic with ByStar, please explicitly
+include `gem chronic` into your Gemfile.

data/by_star.gemspec

@@ -1,31 +1,32 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path("../lib/by_star/version", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = "by_star"
-  s.version     = ByStar::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ryan Bigg"]
-  s.email       = ["radarlistener@gmail.com"]
-  s.homepage    = "http://github.com/radar/by_star"
-  s.summary     = "ActiveRecord extension for easier date scopes and time ranges"
-  s.description = "ActiveRecord extension for easier date scopes and time ranges"
-
-  s.required_rubygems_version = ">= 1.3.6"
-  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_development_dependency "mongoid", "~> 3.0" if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
-
-  s.add_dependency "activerecord", "~> 3.0"
-  s.add_dependency "chronic"
-
-  s.files        = `git ls-files`.split("\n")
-  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
-  s.require_path = 'lib'
-end
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/by_star/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "by_star"
+  s.version     = ByStar::VERSION
+  s.authors     = ["Ryan Bigg", "Johnny Shields"]
+  s.email       = ["radarlistener@gmail.com"]
+  s.homepage    = "http://github.com/radar/by_star"
+  s.summary     = "ActiveRecord and Mongoid extension for easier date scopes and time ranges"
+  s.description = "ActiveRecord and Mongoid extension for easier date scopes and time ranges"
+
+  s.post_install_message = File.read('UPGRADING') if File.exists?('UPGRADING')
+
+  s.add_dependency "activesupport"
+
+  s.add_development_dependency "chronic"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "activerecord"
+  s.add_development_dependency "mongoid"
+  s.add_development_dependency "pg"
+  s.add_development_dependency "mysql2"
+  s.add_development_dependency "rspec-rails", "~> 2.14"
+  s.add_development_dependency "timecop", "~> 0.3"
+  s.add_development_dependency "pry"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+end

data/cleaner.rb

@@ -1,25 +1,25 @@
-files = Dir["**/*"]
-ignored_files = [
-  /log\/.*/,
-]
-
-files.delete_if do |file|
-  if File.directory?(file)
-    true
-  else
-    ignored_files.any? do |condition|
-      if condition.is_a?(String)
-        file == condition
-      else
-        condition.match(file)
-      end
-    end || false
-  end
-end
-
-for file in files - ignored_files
-  if File.file?(file)
-    lines = File.readlines(file).map { |line| line.gsub(/^\s+$/, "\n") }
-    File.open(file, "w+") { |f| f.write(lines.join) }
-  end
+files = Dir["**/*"]
+ignored_files = [
+  /log\/.*/,
+]
+
+files.delete_if do |file|
+  if File.directory?(file)
+    true
+  else
+    ignored_files.any? do |condition|
+      if condition.is_a?(String)
+        file == condition
+      else
+        condition.match(file)
+      end
+    end || false
+  end
+end
+
+for file in files - ignored_files
+  if File.file?(file)
+    lines = File.readlines(file).map { |line| line.gsub(/^\s+$/, "\n") }
+    File.open(file, "w+") { |f| f.write(lines.join) }
+  end
 end

data/lib/by_star.rb

@@ -1,71 +1,15 @@
-require 'chronic'
-
-require 'by_star/time_ext'
-require 'by_star/instance_methods'
-
-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'
-require 'by_star/by_quarter'
-
-module ByStar
-
-  def by_star_field(field=nil)
-    @by_star_field ||= field
-    @by_star_field || "#{self.table_name}.created_at"
-  end
-
-  include ByDirection
-  include ByYear
-  include ByMonth
-  include ByFortnight
-  include ByWeek
-  include ByWeekend
-  include ByDay
-  include ByQuarter
-
-  class ParseError < StandardError
-
-  end
-
-  # 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
-  alias_method :between_times, :between
-
-  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
-
-end
-
-if defined?(ActiveRecord)
-  ActiveRecord::Base.send :extend, ByStar
-  ActiveRecord::Relation.send :extend, ByStar
-  ActiveRecord::Base.send :include, ByStar::InstanceMethods
-end
-
-if defined?(Mongoid)
-  require 'mongoid/by_star'
-end
+require 'by_star/kernel'
+require 'by_star/normalization'
+require 'by_star/between'
+require 'by_star/directional'
+require 'by_star/base'
+
+if defined?(ActiveRecord)
+  require 'by_star/orm/active_record/by_star'
+  ActiveRecord::Base.send :include, ByStar::ActiveRecord
+  ActiveRecord::Relation.send :extend, ByStar::ActiveRecord::ClassMethods
+end
+
+if defined?(Mongoid)
+  require 'by_star/orm/mongoid/by_star'
+end

data/lib/by_star/base.rb

@@ -0,0 +1,53 @@
+module ByStar
+
+  module Base
+
+    include ByStar::Between
+    include ByStar::Directional
+
+    def by_star_field(start_field = nil, end_field = nil, options = {})
+      @by_star_start_field ||= start_field
+      @by_star_end_field   ||= end_field
+      @by_star_offset      ||= options[:offset]
+    end
+
+    def by_star_offset(options = {})
+      (options[:offset] || @by_star_offset || 0).seconds
+    end
+
+    def by_star_start_field(options={})
+      field = options[:field] ||
+          options[:start_field] ||
+          @by_star_start_field ||
+          by_star_default_field
+      field.to_s
+    end
+
+    def by_star_end_field(options={})
+      field = options[:field] ||
+          options[:end_field] ||
+          @by_star_end_field ||
+          by_star_start_field
+      field.to_s
+    end
+
+    protected
+
+    # Wrapper function which extracts time and options for each by_star query.
+    # Note the following syntax examples are valid:
+    #
+    #   Post.by_month                      # defaults to current time
+    #   Post.by_month(2, :year => 2004)    # February, 2004
+    #   Post.by_month(Time.now)
+    #   Post.by_month(Time.now, :field => "published_at")
+    #   Post.by_month(:field => "published_at")
+    #
+    def with_by_star_options(*args, &block)
+      options = args.extract_options!.symbolize_keys!
+      time = args.first
+      time ||= Time.zone.local(options[:year]) if options[:year]
+      time ||= Time.zone.now
+      block.call(time, options)
+    end
+  end
+end

data/lib/by_star/between.rb

@@ -0,0 +1,80 @@
+module ByStar
+
+  module Between
+
+    def between_times(start, finish, options={})
+      offset = by_star_offset(options)
+      between_times_query(start + offset, finish + offset, options)
+    end
+
+    def by_day(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.time(time)
+        between_times(time.beginning_of_day, time.end_of_day, options)
+      end
+    end
+
+    def today(options={})
+      by_day(Time.zone.now, options)
+    end
+
+    def yesterday(options={})
+      by_day(Time.zone.now.yesterday, options)
+    end
+
+    def tomorrow(options={})
+      by_day(Time.zone.now.tomorrow, options)
+    end
+
+    def by_week(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.week(time, options)
+        start_day = Array(options[:start_day])
+        between_times(time.beginning_of_week(*start_day), time.end_of_week(*start_day), options)
+      end
+    end
+
+    def by_weekend(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.week(time, options)
+        between_times(time.beginning_of_weekend, time.end_of_weekend, options)
+      end
+    end
+
+    def by_fortnight(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.fortnight(time, options)
+        between_times(time.beginning_of_fortnight, time.end_of_fortnight, options)
+      end
+    end
+
+    def by_month(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.month(time, options)
+        between_times(time.beginning_of_month, time.end_of_month, options)
+      end
+    end
+
+    def by_calendar_month(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.month(time, options)
+        start_day = Array(options[:start_day])
+        between_times(time.beginning_of_calendar_month(*start_day), time.end_of_calendar_month(*start_day), options)
+      end
+    end
+
+    def by_quarter(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.quarter(time, options)
+        between_times(time.beginning_of_quarter, time.end_of_quarter, options)
+      end
+    end
+
+    def by_year(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.year(time, options)
+        between_times(time.beginning_of_year, time.end_of_year, options)
+      end
+    end
+  end
+end

data/lib/by_star/directional.rb

@@ -0,0 +1,21 @@
+module ByStar
+
+  module Directional
+
+    def before(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.time(time)
+        before_query(time, options)
+      end
+    end
+    alias_method :before_now, :before
+
+    def after(*args)
+      with_by_star_options(*args) do |time, options|
+        time = ByStar::Normalization.time(time)
+        after_query(time, options)
+      end
+    end
+    alias_method :after_now, :after
+  end
+end

data/lib/by_star/kernel.rb

@@ -0,0 +1,41 @@
+module ByStar
+
+  module Kernel
+
+    module Time
+
+      # A "Weekend" is defined as the 60-hour period from 15:00 Friday to 03:00 Monday.
+      # The weekend for a given date will be the the next weekend if the day Mon-Thurs,
+      # otherwise the current weekend if the day is Fri-Sun.
+      def beginning_of_weekend
+        beginning_of_week(:monday).advance(:days => 4) + 15.hours
+      end
+
+      def end_of_weekend
+        (beginning_of_weekend + 59.hours).end_of_hour
+      end
+
+      # A "Fortnight" is defined as a two week period, with the first fortnight of the
+      # year beginning on 1st January.
+      def beginning_of_fortnight
+        beginning_of_year + ((self - beginning_of_year) / 2.weeks).to_i * 2.weeks
+      end
+
+      def end_of_fortnight
+        (beginning_of_fortnight + 13.days).end_of_day
+      end
+
+      # A "Calendar Month" is defined as a month as it appears on a calendar, including days
+      # previous/following months which are part of the first/last weeks of the given month.
+      def beginning_of_calendar_month(*args)
+        beginning_of_month.beginning_of_week(*args)
+      end
+
+      def end_of_calendar_month(*args)
+        end_of_month.end_of_week(*args)
+      end
+    end
+  end
+end
+
+::Time.__send__(:include, ByStar::Kernel::Time)

data/lib/by_star/normalization.rb

@@ -0,0 +1,118 @@
+module ByStar
+
+  class ParseError < StandardError; end
+
+  module Normalization
+
+    class << self
+
+      def time(value)
+        case value
+          when String then time_string(value)
+          when DateTime then value.to_time
+          when Date then value.to_time_in_current_zone
+          else value
+        end
+      end
+
+      def time_string(value)
+        defined?(Chronic) ? time_string_chronic(value) : time_string_fallback(value)
+      end
+
+      def time_string_chronic(value)
+        Chronic.time_class = Time.zone
+        Chronic.parse(value) || raise(ByStar::ParseError, "Chronic could not parse String #{value.inspect}")
+      end
+
+      def time_string_fallback(value)
+        Time.zone.parse(value) || raise(ByStar::ParseError, "Cannot parse String #{value.inspect}")
+      end
+
+      def week(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Fixnum then week_fixnum(value, options)
+          else time(value)
+        end
+      end
+
+      def week_fixnum(value, options={})
+        raise ParseError, 'Week number must be between 0 and 52' unless value.in?(0..52)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time.beginning_of_year + value.to_i.weeks
+      end
+
+      def fortnight(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Fixnum then fortnight_fixnum(value, options)
+          else time(value)
+        end
+      end
+
+      def fortnight_fixnum(value, options={})
+        raise ParseError, 'Fortnight number must be between 0 and 26' unless value.in?(0..26)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time + (value * 2).weeks
+      end
+
+      def quarter(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Fixnum then quarter_fixnum(value, options)
+          else time(value)
+        end
+      end
+
+      def quarter_fixnum(value, options={})
+        raise ParseError, 'Quarter number must be between 1 and 4' unless value.in?(1..4)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time.beginning_of_year + ((value - 1) * 3).months
+      end
+
+      def month(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Fixnum, String then month_fixnum(value, options)
+          else time(value)
+        end
+      end
+
+      def month_fixnum(value, options={})
+        year = options[:year] || Time.zone.now.year
+        Time.zone.parse "#{year}-#{value}-01"
+      rescue
+        raise ParseError, 'Month must be a number between 1 and 12 or a month name'
+      end
+
+      def year(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Fixnum then year_fixnum(value)
+          else time(value)
+        end
+      end
+
+      def year_fixnum(value)
+        Time.zone.local(extrapolate_year(value))
+      end
+
+      def extrapolate_year(value)
+        case value.to_i
+          when 0..69
+            2000 + value
+          when 70..99
+            1900 + value
+          else
+            value.to_i
+        end
+      end
+
+      def try_string_to_int(value)
+        value.is_a?(String) ? Integer(value) : value
+      rescue
+        value
+      end
+    end
+  end
+end