zone_ranger 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.rbenv*
+.DS_Store
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    zone_ranger (0.0.1)
+      activesupport (~> 3.0.20)
+      i18n
+      tzinfo (~> 0.3.35)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.0.20)
+    diff-lcs (1.2.4)
+    i18n (0.6.5)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    timecop (0.3.5)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  rspec
+  timecop (~> 0.3.5)
+  zone_ranger!

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Rigor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+zone-ranger
+===========
+
+To determine if a time falls between two points

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/zone_ranger/core.rb

@@ -0,0 +1,182 @@
+require 'active_support/all'
+
+module ZoneRanger
+  class Core
+
+    attr_reader :start_time_string, :repeat_type
+    attr_reader :duration_in_minutes
+
+    def initialize start_date_time, duration_in_minutes, timezone, options={}
+
+      @start_time_string = start_date_time
+      @duration_in_minutes = duration_in_minutes
+      @timezone = timezone
+
+      @ending = options.fetch(:ending, nil)
+
+      @repeat_type = options.fetch(:repeat, nil)
+
+    end
+
+    def repeat?
+      !!@repeat_type
+    end
+
+    def daily?
+      @repeat_type == :daily
+    end
+
+    def weekly?
+      @repeat_type == :weekly
+    end
+
+    def monthly_by_day_of_week?
+      @repeat_type == :monthly_by_day_of_week
+    end
+
+    def monthly_by_day_of_month?
+      @repeat_type == :monthly_by_day_of_month
+    end
+
+    def timezone_object
+      ActiveSupport::TimeZone.new((@timezone || "UTC"))
+    end
+    
+    def includes? time_point=Time.now.utc
+      return false if not_started_yet?(time_point) || expired?(time_point)
+
+      if repeat?
+        included_in_repeating_timeframe? time_point
+      else
+        static_include? time_point
+      end
+    end
+
+    def static_include? time_point
+      zoned_time(time_point).between?(*time_range(time_point))
+    end
+
+    def expired? time=Time.now.utc
+      return false unless @ending
+      zoned_time(time) > zoned_end_date
+    end
+
+    def zoned_time time=nil
+      tzone = timezone_object
+      if time.nil?
+        tzone.now
+      else
+        time.in_time_zone(tzone)
+      end
+    end
+
+    def zoned_date time=Time.now.utc
+      zoned_time(time).to_date
+    end
+
+    def zoned_end_date
+      timezone_object.parse("#{@ending} 23:59:59 #{utc_offset}")
+    end
+
+    def utc_offset
+      ActiveSupport::TimeZone.seconds_to_utc_offset(zoned_time.utc_offset)
+    end
+
+    def not_started_yet? time
+      start_on > zoned_date
+    end
+
+    def start_on
+      parsed_time_string.to_date
+    end
+
+    def started?
+      !not_started_yet?
+    end
+
+    def time_range current_day=Time.now.utc, options={}
+      
+      offset = options.fetch(:offset, 0)
+
+      start_date = if repeat?
+        #if daily?
+        # shift to the day being checked
+        start_time = zoned_time(current_day + offset.days)
+        start_time.to_date
+        #end
+      else
+        parsed_time_string.to_date
+      end
+
+      b_start = timezone_object.parse(parsed_time_string.strftime("#{start_date} %H:%M")).in_time_zone(timezone_object)
+      b_end = b_start + duration_in_minutes.minutes
+
+      [b_start, b_end]
+    end
+
+    def parsed_time_string
+      timezone_object.parse(start_time_string)
+    end
+
+    protected
+
+    def included_in_repeating_timeframe? time_point
+      repeat? && (daily? && include_for_daily?(time_point) ||
+            weekly? && include_for_weekly?(time_point) ||
+            monthly_by_day_of_week? && include_for_monthly_dow?(time_point) ||
+            monthly_by_day_of_month? && include_for_monthly_dom?(time_point))
+    end
+
+    def include_for_daily? time_point
+      zoned_time(time_point).between?(*time_range(time_point, :offset => -1)) || zoned_time(time_point).between?(*time_range(time_point))
+    end
+
+    def include_for_weekly? time_point
+      start_date = zoned_time(time_point).to_date
+      start_at, end_at = time_range(time_point)
+
+      if crosses_midnight?
+        wday1 = parsed_time_string.wday
+        wday2 = parsed_time_string.tomorrow.wday
+
+        case start_date.wday
+        when wday1
+          zoned_time(time_point).between?(start_at, end_at)
+        when wday2
+          yesterday_start, yesterday_end = time_range(zoned_time(time_point), :offset => -1)
+          zoned_time(time_point).between?(yesterday_start, yesterday_end)
+        else false
+        end
+      else
+        Util.wday_match?(start_at, parsed_time_string) && zoned_time(time_point).between?(start_at, end_at)
+      end
+    end
+
+    def include_for_monthly_dow? time_point
+      start_date = parsed_time_string.to_date
+
+      start_week = Util.week_of_month(start_date)
+      time_week = Util.week_of_month(zoned_time(time_point))
+
+      start_week == time_week && include_for_weekly?(time_point)
+    end
+
+    def include_for_monthly_dom? time_point
+      original_day = parsed_time_string.day
+      today_day = zoned_time(time_point).day
+
+      if today_day == original_day
+        static_include? time_point
+      elsif (today_day == parsed_time_string.tomorrow.day) && crosses_midnight?
+        zoned_time(time_point).between?(*time_range(time_point, :offset => -1))
+      else
+        false
+      end
+    end
+
+    def crosses_midnight?
+      Util.crosses_one_utc_midnight?(parsed_time_string, @duration_in_minutes)
+    end
+
+  end
+end

data/lib/zone_ranger/util.rb

@@ -0,0 +1,47 @@
+module ZoneRanger
+  class Util
+
+    def self.week_of_month time
+      day_num = time.day
+      days_in_month = Time.days_in_month(time.month)
+      
+      if day_num < 8
+        1
+      elsif day_num < 15
+        2
+      elsif day_num < 22
+        3
+      elsif day_num < days_in_month - 7
+        4 # fourth but not last
+      else
+        :last # last
+      end
+    end
+
+    def self.crosses_one_utc_midnight? start, duration
+      # a utc midnight is when the start day is different the blackout ends on
+      day1 = start.utc.to_date
+      day2 = (start + duration.minutes).utc.to_date
+      day1 != day2
+    end
+
+    def self.wday_match? date1, date2
+      date1.wday == date2.wday
+    end
+
+    def self.calculate_duration_in_minutes starting, ending
+      start_hour = starting.strftime("%H")
+      start_minutes = starting.strftime("%M")
+      start_in_minutes = (start_hour.to_i * 60) + start_minutes.to_i
+
+      finish_hour = ending.strftime("%H").to_i
+      finish_minutes = (finish_hour * 60) + ending.strftime("%M").to_i
+
+      d = finish_minutes - start_in_minutes
+      d += 1440 if d < 0
+
+      d
+    end
+
+  end
+end

data/lib/zone_ranger/version.rb

@@ -0,0 +1,3 @@
+module ZoneRanger
+  VERSION = "0.0.1"
+end

data/lib/zone_ranger.rb

@@ -0,0 +1,3 @@
+require "zone_ranger/version"
+require 'zone_ranger/util'
+require 'zone_ranger/core'

data/spec/core_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+describe ZoneRanger::Core do
+
+  def timeize t_or_s
+    t_or_s.is_a?(Time) ? t_or_s : Time.parse(t_or_s)
+  end
+
+  def validate_active zr, time
+    Timecop.freeze(timeize(time))
+    zr.includes?(timeize(time)).should(be_true, "#{time.to_s} expected ACTIVE")
+    Timecop.return
+  end
+
+  def validate_inactive zr, time
+    Timecop.freeze(timeize(time))
+    zr.includes?(timeize(time)).should(be_false, "#{time.to_s} expected INACTIVE")
+    Timecop.return
+  end
+
+  describe "standard operation" do
+    it "should require a start time, duration, and timezone" do
+      expect{ ZoneRanger::Core.new.includes? Time.now, 30 }.to raise_error ArgumentError
+      expect{ ZoneRanger::Core.new.includes? Time.now }.to raise_error ArgumentError
+    end
+
+    it "should not throw error if all fields are supplied" do
+      ZoneRanger::Core.new("#{Time.now - 300}", 30, "Eastern Time (US & Canada)").includes?
+    end
+
+    it "should accept a Time parameter" do
+      ZoneRanger::Core.new("#{Time.now - 300}", 30, "Eastern Time (US & Canada)").includes? Time.now.utc
+    end
+
+    it "should repeat? if told" do
+      zr = ZoneRanger::Core.new('2013-04-01 06:00 -04:00', 30, "Eastern Time (US & Canada)", :repeat => :daily)
+      zr.repeat?.should be_true
+    end
+
+    it "should have a timezone" do
+      zr = ZoneRanger::Core.new('2013-04-01 06:00 -04:00', 30, "Eastern Time (US & Canada)")
+      zr.timezone_object.should be_a ActiveSupport::TimeZone
+    end
+  end
+
+  describe "#time_range" do
+    context "no repeat" do
+      it "should return the correct time range - same day" do
+        zr = ZoneRanger::Core.new('2013-04-01 06:00 -04:00', 30, "Eastern Time (US & Canada)")
+        zr.time_range.should eql([Time.parse('2013-04-01 06:00 -04:00'), Time.parse('2013-04-01 06:30 -04:00')])
+      end
+
+      it "should return the correct time range - crossing midnight in user's timezone" do
+        zr = ZoneRanger::Core.new('2013-04-01 23:01 -04:00', 60, "Eastern Time (US & Canada)")
+        zr.time_range.should eql([Time.parse('2013-04-01 23:01 -04:00'), Time.parse('2013-04-02 00:01 -04:00')])
+      end
+
+      it "should work with other time zones" do
+        zr = ZoneRanger::Core.new('2013-04-01 23:01 -07:00', 60, "Pacific Time (US & Canada)")
+        zr.time_range.should eql([Time.parse('2013-04-01 23:01 -07:00'), Time.parse('2013-04-02 00:01 -07:00')])
+      end
+    end
+
+    context "repeat daily" do
+      it "should return the correct time range - same day" do
+        zr = ZoneRanger::Core.new('2013-04-01 06:00 -04:00', 30, "Eastern Time (US & Canada)", :repeat => :daily)
+        zr.time_range(Time.parse('2013-04-02 06:00 -04:00')).should eql([Time.parse('2013-04-02 06:00 -04:00'), Time.parse('2013-04-02 06:30 -04:00')])
+      end
+
+      it "should return the correct time range - crossing midnight in user's timezone" do
+        zr = ZoneRanger::Core.new('2013-04-01 23:01 -04:00', 60, "Eastern Time (US & Canada)", :repeat => :daily)
+        zr.time_range(Time.parse('2013-04-02 06:00 -04:00')).should eql([Time.parse('2013-04-02 23:01 -04:00'), Time.parse('2013-04-03 00:01 -04:00')])
+      end
+
+      it "should work with other time zones" do
+        zr = ZoneRanger::Core.new('2013-04-01 23:01 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :daily)
+        zr.time_range(Time.parse('2013-04-02 06:00 -07:00')).should eql([Time.parse('2013-04-02 23:01 -07:00'), Time.parse('2013-04-03 00:01 -07:00')])
+      end
+    end
+  end
+
+  describe "#expired?" do
+    let(:zr_daily) { ZoneRanger::Core.new('2013-04-01 23:01 -04:00', 60, "Eastern Time (US & Canada)", :repeat => :daily, :ending => '2013-06-01')}
+    let(:zr_weekly) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :ending => '2013-06-01', :repeat => :weekly)}
+    let(:zr_monthly_by_day_of_month) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :ending => '2013-06-01', :repeat => :monthly_by_day_of_month)}
+    let(:zr_monthly_by_day_of_week) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :ending => '2013-06-01', :repeat => :monthly_by_day_of_week)}
+
+    it "should return true if the checked time is past the expired time" do
+      [zr_daily, zr_weekly, zr_monthly_by_day_of_month, zr_monthly_by_day_of_week].each do |zr|
+        zr.expired?(Time.parse('2013-06-02 00:00:00 -07:00')).should(be_true, "#{zr.repeat_type} expected EXPIRED")
+      end
+    end
+
+    it "should be false if the checked time is before the expired time" do
+      [zr_daily, zr_weekly, zr_monthly_by_day_of_month, zr_monthly_by_day_of_week].each do |zr|
+        zr.expired?(Time.parse('2013-06-01 00:00:00 -07:00')).should(be_false, "#{zr.repeat_type} expected ACTIVE")
+        zr.expired?(Time.parse('2013-05-01 00:00:00 -07:00')).should(be_false, "#{zr.repeat_type} expected ACTIVE")
+      end
+    end
+  end
+
+  describe "#includes?" do
+
+    context "expired" do
+      let(:daily_with_end) { ZoneRanger::Core.new("09:58 -04:00", 841, "Eastern Time (US & Canada)", :repeat => :daily, :ending => '2013-07-17') }
+
+      it "should never return true after the end date - not near UTC midnight" do
+        validate_inactive daily_with_end, "Fri Jul 19 11:57:22 -0400 2013"
+        validate_active daily_with_end, "Fri Jul 16 11:57:22 -0400 2013"
+        validate_active daily_with_end, "Fri Jul 17 23:58:22 -0400 2013"
+      end
+    end
+
+    context "giving a time" do # does the present time fall in the given timeframe?
+
+      let(:zr) { ZoneRanger::Core.new('2013-04-01 23:01:00 -07:00', 60, "Pacific Time (US & Canada)") }
+
+      context "in timeframe" do # present time is inside timeframe
+        it "should be active" do
+          validate_active(zr, '2013-04-01 23:01:01 -07:00')
+          validate_active(zr, '2013-04-02 00:00:00 -07:00')
+        end
+      end
+      context "outside timeframe" do # present time is outside timeframe
+        it "should not be active" do
+          validate_inactive(zr, '2013-04-01 23:00:01 -07:00')
+          validate_inactive(zr, '2013-04-02 00:02:00 -07:00')
+        end
+      end
+
+      context "over utc midnight" do
+        let(:set_timeframe_over_two_days){ ZoneRanger::Core.new("2013-07-24 23:01 UTC", 120, "UTC", :repeat => :weekly, :ending => Time.parse("2013-07-25 UTC")) }
+
+        it "should be active in timeframe" do
+          validate_active(set_timeframe_over_two_days, "2013-07-24 23:02 UTC")
+          validate_active(set_timeframe_over_two_days, "2013-07-25 01:00 UTC")
+        end
+
+        it "should not be active in timeframe" do
+          validate_inactive(set_timeframe_over_two_days, "2013-07-24 23:00 UTC")
+          validate_inactive(set_timeframe_over_two_days, "2013-07-25 01:02 UTC")
+        end
+      end
+
+      context "repeated" do
+        context "daily" do
+          let(:zr_daily) { ZoneRanger::Core.new('2013-04-01 23:01:00 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :daily) }
+          let(:zr_daily_no_start_date) { ZoneRanger::Core.new('23:01:00 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :daily) }
+
+          it "should cover until midnight every day" do
+            (1..8).each do |i|
+              validate_active(zr_daily, "2013-04-0#{i} 23:59:01 -07:00")
+              validate_active(zr_daily_no_start_date, "2013-04-0#{i} 23:59:01 -07:00")
+            end
+          end
+
+          it "should cover after midnight every day" do
+            (1..8).each do |i|
+              validate_active(zr_daily, "2013-04-0#{i+1} 00:00:00 -07:00")
+              validate_active(zr_daily_no_start_date, "2013-04-0#{i+1} 00:00:00 -07:00")
+            end
+          end
+
+          it "should not cover after midnight from the day before if before starting time" do
+            validate_inactive(zr_daily, "2013-03-31 00:00:00 -07:00")
+            validate_active(zr_daily_no_start_date, "2013-03-31 00:00:00 -07:00")
+          end
+        end
+
+        context "weekly" do
+          let(:zr_weekly) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :weekly) }
+          
+          it "should cover only on the day of week, and in time range" do
+            validate_active(zr_weekly, '2013-04-01 00:01:01 -07:00')
+            validate_active(zr_weekly, '2013-04-01 00:59:59 -07:00')
+
+            # next week
+            validate_active(zr_weekly, '2013-04-08 00:01:01 -07:00')
+            validate_active(zr_weekly, '2013-04-08 00:59:59 -07:00')
+          end
+
+          it "should not cover if on the day of week, but not in time range" do
+            validate_inactive(zr_weekly, '2013-04-08 00:00:59 -07:00')
+            validate_inactive(zr_weekly, '2013-04-08 01:02:59 -07:00')
+          end
+
+          it "should not cover if not on the day of week and in time range" do
+            validate_inactive(zr_weekly, '2013-04-07 00:01:01 -07:00')
+            validate_inactive(zr_weekly, '2013-04-07 00:59:59 -07:00')
+          end
+        end
+
+        context "monthly" do
+          context "day of the month" do
+
+            let(:zr_monthly_dom) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :monthly_by_day_of_month) }
+            let(:zr_monthly_dom2) { ZoneRanger::Core.new("2013-07-17 09:58 -04:00", 120, "Eastern Time (US & Canada)", :repeat => :monthly_by_day_of_month) }
+            
+            it "should be active if on the day of the month of start_date and within the timeframe" do
+              validate_active(zr_monthly_dom, '2013-05-01 00:02:00 -07:00')
+              validate_active(zr_monthly_dom, '2013-05-01 00:59:00 -07:00')
+              validate_active(zr_monthly_dom, '2013-06-01 00:02:00 -07:00')
+              validate_active(zr_monthly_dom, '2013-06-01 00:59:00 -07:00')
+            end
+              
+            it "should not be active if on the day of the month of start_date and within the timeframe but start_date is in the future" do
+              validate_inactive(zr_monthly_dom, '2013-03-01 00:02:00 -07:00')
+              validate_inactive(zr_monthly_dom, '2013-03-01 00:59:00 -07:00')
+            end
+            
+            it "should not be active if within the timeframe but not on the day of the month" do
+              validate_inactive(zr_monthly_dom, '2013-04-03 00:02:00 -07:00')
+              validate_inactive(zr_monthly_dom, '2013-04-03 00:59:00 -07:00')
+              validate_inactive(zr_monthly_dom2, "Thu Jul 18 9:59:22 -0400 2013")
+            end
+
+
+
+          end
+
+          context "day of the week" do
+            let(:zr_monthly_dow) { ZoneRanger::Core.new('2013-04-01 00:01:00 -07:00', 60, "Pacific Time (US & Canada)", :repeat => :monthly_by_day_of_week) }
+
+            it "should be active if on the same weekday and xth week and inside timeframe" do
+              validate_active(zr_monthly_dow, "2013-04-01 00:02:00 -07:00")
+              validate_active(zr_monthly_dow, "2013-04-01 01:00:00 -07:00")
+
+              # next period
+              validate_active(zr_monthly_dow, "2013-05-06 00:02:00 -07:00")
+              validate_active(zr_monthly_dow, "2013-05-06 01:00:00 -07:00")
+            end
+            
+            it "should not be active if on xth week and inside timeframe but not on same weekday" do
+              validate_inactive(zr_monthly_dow, "2013-05-05 00:02:00 -07:00")
+              validate_inactive(zr_monthly_dow, "2013-05-05 01:00:00 -07:00")
+            end
+            
+            it "should not be active if on the same weekday and inside timeframe but not on xth week" do
+              validate_inactive(zr_monthly_dow, "2013-04-08 00:02:00 -07:00")
+              validate_inactive(zr_monthly_dow, "2013-04-08 01:00:00 -07:00")
+            end
+            
+            it "should not be active if on the same weekday and xth week but outside timeframe" do
+              validate_inactive(zr_monthly_dow, "2013-04-01 00:00:00 -07:00")
+              validate_inactive(zr_monthly_dow, "2013-04-01 01:02:00 -07:00")
+
+              # next period
+              validate_inactive(zr_monthly_dow, "2013-05-06 00:00:00 -07:00")
+              validate_inactive(zr_monthly_dow, "2013-05-06 01:02:00 -07:00")
+            end
+          end
+
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'zone_ranger'
+require 'bundler/setup'
+
+require 'timecop'

data/spec/util_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ZoneRanger::Util do
+  it "should pass" do
+  end
+
+  describe '#crosses_one_utc_midnight?' do
+    #   let(:does_cross) { Factory(:check_blackout_period, 
+    #         :repeat_type => "daily",
+    #         :start_time => "19:58", :end_time => "1:38", :start_date => nil)}
+    #   let(:does_not_cross) { Factory(:check_blackout_period, 
+    #         :repeat_type => "daily",
+    #         :start_time => "10:58", :end_time => "11:38", :start_date => nil)}
+    #   let(:crossing_utc_weekly_blackout) { Factory(:check_blackout_period, :repeat_type => "weekly",
+    #     :start_time => "19:58", :end_time => "1:30", :start_date => Date.parse('2013-07-17'))}
+
+    #   it "should cross one midnight" do
+    #     does_cross.send(:crosses_one_utc_midnight?).should be_true
+    #     does_not_cross.send(:crosses_one_utc_midnight?).should be_false
+    #     crossing_utc_weekly_blackout.send(:crosses_one_utc_midnight?).should be_true
+    #   end
+    # end
+  end
+end

data/zone_ranger.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zone_ranger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zone_ranger"
+  spec.version       = ZoneRanger::VERSION
+  spec.authors       = ["Hubert Liu"]
+  spec.email         = ["hubert.liu@rigor.com"]
+  spec.description   = "Time Zone Ranger"
+  spec.summary       = "Time Zone Ranger"
+  spec.homepage      = "https://github.com/Rigor/zone_ranger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "timecop", "~> 0.3.5"
+
+  spec.add_runtime_dependency "activesupport", "~> 3.0.20"
+  spec.add_runtime_dependency 'i18n' # required by active_support
+  spec.add_runtime_dependency 'tzinfo', '~> 0.3.35'
+  #spec.add_runtime_dependency 'tzinfo-data'
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification 
+name: zone_ranger
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Hubert Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-09-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 3
+        - 5
+        version: 0.3.5
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 3
+        - 0
+        - 20
+        version: 3.0.20
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 85
+        segments: 
+        - 0
+        - 3
+        - 35
+        version: 0.3.35
+  type: :runtime
+  version_requirements: *id007
+description: Time Zone Ranger
+email: 
+- hubert.liu@rigor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/zone_ranger.rb
+- lib/zone_ranger/core.rb
+- lib/zone_ranger/util.rb
+- lib/zone_ranger/version.rb
+- spec/core_spec.rb
+- spec/spec_helper.rb
+- spec/util_spec.rb
+- zone_ranger.gemspec
+homepage: https://github.com/Rigor/zone_ranger
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Time Zone Ranger
+test_files: 
+- spec/core_spec.rb
+- spec/spec_helper.rb
+- spec/util_spec.rb