greenwich 0.0.5 → 1.0.0

data/.gitignore

@@ -1,4 +1,12 @@
 *.gem
+*.rbc
 .bundle
+.config
+.yardoc
 Gemfile.lock
-pkg/*
+_yardoc
+coverage
+lib/bundler/man
+pkg
+spec/reports
+tmp

data/.rvmrc

@@ -1 +1 @@
-rvm use --create ruby-1.9.2-p180@greenwich
+rvm use --create ruby-1.9.3-p125@greenwich

data/Gemfile

@@ -1,4 +1,6 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in greenwich.gemspec
+gem 'rake'
+
 gemspec
+

data/README.md

@@ -29,90 +29,95 @@ Initialization
 
 You add Greenwich to your models like so:
 
-    date_with_time_zone :field_name
+    time_with_time_zone :your_column_name_utc
 
-Meta-Programming Magic
---------------------------------
+By default, Greenwich removes the `_utc` from the column name and uses
+the resulting string as the composed field.
 
-By default Greenwich looks for a few different columns in your model depending on the
-field name you passed in.  Let's look at some examples.
+For example, the above call would result in a composed field called
+`your_column_name`.
 
-**DateTime Field Lookup**
+### Time Zones ###
 
-Greenwich will lookup `:field_name` based on a couple different standard column suffixes.
+Greenwich will try to use convention to choose a time zone column name
+based on the time field you choose.
 
-  * `_at`
-  * `_datetime`
+    time_with_time_zone :started_at_utc
 
-For example, if you specify:
+Will look for a column called `started_at_time_zone` which contains the
+time zone for the time field.
 
-    date_with_time_zone :start
+#### Custom Time Zone ####
 
-Greenwich will look for the columns `start_at` and `start_datetime` (in that order).
+If you want to use the same time zone for multiple time fields or just
+don't like the custom one we choose for you, you can pass a `:time_zone`
+option which will override our default.
 
-**Time Zone Field Lookup**
+    time_with_time_zone :started_at_utc, :time_zone => :started_at_zone
 
-Time Zone lookups default to a per-field or per-model specification.  If you specify:
+Will tell Greenwich that when the user accesses the `started_at` method,
+it will use the information from the `started_at_zone` column for its
+time zone.
 
-    date_with_time_zone :start
+### Convention... but missing a little configuration ###
 
-Greenwich will lookup the time zone from `:start_time_zone` first, and if it doesn't
-find a field by that name, it will use `:time_zone`.
+We're on `v1.0.0` and have more features planned in the future, however
+for now, all columns passed to `time_with_time_zone` _must_ end in `_utc`.
 
 Usage
 --------------------------------
-  * **Note:** _These examples assume the application's default time zone is set to UTC.
-    If you have modified the default time zone, directly accessing your DateTime field
-    will render it in _that_ time zone and not UTC._
+  **Note:** _These examples assume the application's default time zone is set to UTC.
+  If you have modified the default time zone, directly accessing your DateTime field
+  will render it in **that** time zone and not UTC._
 
 When working with your instances, Greenwich will convert to the proper time zone when
-you access it.  So if you've previously saved a DateTime like this:
+you access it.  So if you've defined a Greenwich time field like this:
+
+    time_with_time_zone :started_at_utc
 
-    my_model.start = Time.strptime('2011-07-04 13:00:00 -600 CST')
+And if you've previously saved a DateTime like this:
+
+    my_model.started_at_utc       = Time.utc(2011, 7, 4, 13, 0, 0)
+    my_model.started_at_time_zone = 'Alaska'
 
 Then that will result in your model returning the following values (assuming these
 particular columns exist in the database):
 
-    my_model.start_at           # => 2011-07-04 19:00:00 GMT
-    my_model.start_datetime     # => 2011-07-04 19:00:00 GMT
-    my_model.start_time_zone    # => 'Central Standard Time'
-    my_model.time_zone          # => 'Central Standard Time'
+    my_model.started_at_utc         # => ActiveSupport::TimeWithZone 2011-07-04 13:00:00 UTC
+    my_model.started_at_time_zone   # => ActiveSupport::TimeZone     'Alaska'
 
-Whereas asking Greenwich for the value of `start` will result in:
+Whereas asking Greenwich for the value of `started_at` will result in:
 
-    my_model.start              # => 2011-07-04 13:00:00 CST
+    my_model.started_at             # => ActiveSupport::TimeWithZone 2011-07-04 04:00:00 AKDT
 
 If you then change your time zone:
 
-    my_model.start_time_zone = 'Eastern Standard Time'
+    my_model.started_at_time_zone = 'Hawaii'
 
 Then calling the attributes on your model will result in the following:
 
-    my_model.start_at           # => 2011-07-04 19:00:00 GMT
-    my_model.start_datetime     # => 2011-07-04 19:00:00 GMT
-    my_model.start_time_zone    # => 'Eastern Standard Time'
-    my_model.time_zone          # => 'Eastern Standard Time'
+    my_model.started_at_utc         # => ActiveSupport::TimeWithZone 2011-07-04 13:00:00 UTC
+    my_model.started_at_time_zone   # => ActiveSupport::TimeZone 'Hawaii'
 
-And again, asking Greenwich for the value of `start` will result in:
+And again, asking Greenwich for the value of `started_at` will result in:
 
-    my_model.start              # => 2011-07-04 13:00:00 EST
+    my_model.started_at             # => ActiveSupport::TimeWithZone 2011-07-04 03:00:00 HADT
 
 Issues
 ------
 
-If you have problems, please create a [Github issue](https://github.com/jfelchner/greenwich/issues).
+If you have problems, please create a [Github issue](issues).
 
 Credits
 -------
 
-![thekompanee](http://www.thekompanee.com/public_files/kompanee-github-readme-logo.png)
+![chirrpy](https://dl.dropbox.com/s/f9s2qd0kmbc8nwl/github_logo.png?dl=1)
 
-greenwich is maintained by [The Kompanee, Ltd.](http://www.thekompanee.com)
+greenwich is maintained by [Chrrpy, LLC](http://chirrpy.com)
 
-The names and logos for The Kompanee are trademarks of The Kompanee, Ltd.
+The names and logos for Chirrpy are trademarks of Chrrpy, LLC
 
 License
 -------
 
-greenwich is Copyright © 2011 The Kompanee. It is free software, and may be redistributed under the terms specified in the LICENSE file.
-
+greenwich is Copyright © 2011 Chirrpy. It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/Rakefile

@@ -1 +1,2 @@
+#!/usr/bin/env rake
 require 'bundler/gem_tasks'

data/greenwich.gemspec

@@ -11,9 +11,9 @@ Gem::Specification.new do |s|
   s.version           = Greenwich::VERSION
   s.platform          = Gem::Platform::RUBY
 
-  s.authors           = ["thekompanee", "jfelchner"]
-  s.email             = ["support@thekompanee.com"]
-  s.homepage          = "http://github.com/jfelchner/greenwich"
+  s.authors           = ["jfelchner", "m5rk"]
+  s.email             = ["jeff+greenwich@chirrpy.com"]
+  s.homepage          = "http://github.com/chirrpy/greenwich"
 
   s.summary           = %q{Allowing users to select dates with custom time zones since 2011.}
   s.description       = %q{Store all of your times in the database as UTC but want to give your users the ability to choose a custom time zone for each instance of a DateTime field?}
@@ -28,9 +28,13 @@ Gem::Specification.new do |s|
   s.require_paths     = ["lib"]
   #= Manifest =#
 
-  s.add_dependency('activerecord', '~> 3.0')
+  s.add_dependency('activerecord',  '~> 3.0')
+  s.add_dependency('activesupport', '~> 3.0')
+  s.add_dependency('tzinfo',        '~> 0.3')
 
   s.add_development_dependency('bundler',   '~> 1.0')
   s.add_development_dependency('rspec',     '~> 2.6')
   s.add_development_dependency('yard',      '~> 0.7')
+  s.add_development_dependency('sqlite3',   '~> 1.3')
+  s.add_development_dependency('pry')
 end

data/lib/greenwich.rb

@@ -1,5 +1,7 @@
-require "greenwich/version"
-require "greenwich/utilities"
-require "greenwich/time_with_zone"
-require "greenwich/rails"
-
+require 'tzinfo'
+require 'active_record'
+require 'active_support/all'
+require 'greenwich/conversion'
+require 'greenwich/time_zone'
+require 'greenwich/utilities'
+require 'greenwich/version'

data/lib/greenwich/conversion.rb

@@ -0,0 +1,82 @@
+module Greenwich
+  module Conversion
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def time_with_time_zone(utc_time_field, options = {})
+        time_field      = utc_time_field.to_s.gsub /_utc$/, ''
+        time_zone_field = options[:time_zone] || "#{time_field}_time_zone"
+
+        class_eval do
+          columns_hash[time_field] = ActiveRecord::ConnectionAdapters::Column.new(time_field, nil, "datetime")
+        end
+
+        define_method "#{time_field}_utc=" do |value|
+          greenwich_time_fields_converted["#{time_field}_utc"] = true
+
+          super(value)
+        end
+
+        define_method time_field do
+          time_zone = Greenwich::Utilities.get_time_zone(self, time_zone_field)
+          time      = read_attribute(utc_time_field)
+          time      = time.in_time_zone(time_zone) if time && time_zone
+
+          time
+        end
+
+        define_method "#{time_field}=" do |value|
+          time_zone = Greenwich::Utilities.get_time_zone(self, time_zone_field)
+          time      = Greenwich::Utilities.coerce_to_time_without_zone(value)
+          time      = ActiveSupport::TimeWithZone.new(nil, time_zone, time) if time && time_zone
+
+          greenwich_time_fields_converted["#{time_field}_utc"] = true unless time_zone.nil?
+
+          write_attribute(utc_time_field, time)
+        end
+
+        time_zone time_zone_field.to_sym, :for => utc_time_field.to_sym
+      end
+
+      def time_zone(name, options = {})
+        associated_time_fields = Array.wrap(options[:for]).map {|f| f.to_s.gsub /_utc$/, ''}
+
+        define_method name do
+          time_zone_name = read_attribute(name)
+
+          Greenwich::Utilities.coerce_to_time_zone(time_zone_name)
+        end
+
+        define_method "#{name}=" do |value|
+          time_zone = Greenwich::Utilities.coerce_to_time_zone_name(value)
+          write_attribute(name, time_zone)
+
+          associated_time_fields.each do |time_field|
+            if greenwich_time_field_needs_conversion?(time_field, name)
+              send("#{time_field}=".to_sym, read_attribute("#{time_field}_utc"))
+
+              greenwich_time_fields_converted["#{time_field}_utc"] = true
+            end
+          end
+        end
+      end
+    end
+
+    def greenwich_time_fields_converted
+      @greenwich_time_fields_converted ||= {}
+    end
+
+    def greenwich_time_fields_converted=(value)
+      @greenwich_time_fields_converted = value
+    end
+
+  private
+    def greenwich_time_field_needs_conversion?(time_field, time_zone_field)
+      (send("#{time_zone_field}_was".to_sym).nil? || send("#{time_field}_utc_was").nil?) &&
+        read_attribute("#{time_field}_utc").present? &&
+        self.greenwich_time_fields_converted["#{time_field}_utc"].nil?
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Greenwich::Conversion

data/lib/greenwich/time_zone.rb

@@ -0,0 +1,7 @@
+module ActiveSupport
+  class TimeZone
+    def to_s
+      name
+    end
+  end
+end

data/lib/greenwich/utilities.rb

@@ -6,22 +6,34 @@ module Greenwich
       get_target_column(target_columns, columns)
     end
 
-    def self.get_time_field(name, columns)
-      target_columns = ["#{name}_at", "#{name}_datetime", "#{name}_time"]
+    def self.get_time_zone(object, time_zone_field_name)
+      begin
+        time_zone_name = object.send(time_zone_field_name.to_sym)
+      rescue
+        time_zone_name = ''
+      end
 
-      get_target_column(target_columns, columns)
+      Greenwich::Utilities.coerce_to_time_zone(time_zone_name)
     end
 
-    def self.get_time_zone_from(value)
-      return nil if [nil, ''].include? value
+    def self.coerce_to_time_zone(value)
+      return nil   if value.nil?
+      return value if value.is_a? ActiveSupport::TimeZone
 
-      begin
-        value = ActiveSupport::TimeZone.new(value) unless value.is_a? ActiveSupport::TimeZone
-      rescue ArgumentError
-        raise ArgumentError, "'#{value}' cannot be converted into a TimeZone."
-      end
+      ActiveSupport::TimeZone.new(value)
+    end
+
+    def self.coerce_to_time_zone_name(value)
+      coerce_to_time_zone(value).try(:name)
+    end
 
-      value
+    def self.coerce_to_time_without_zone(value)
+      return value if value.is_a?(Time)
+
+      value.gsub! /\s[-+]\d{4}$/, '' if value.respond_to? :gsub!
+      value.to_time                  if value.respond_to? :to_time
+    rescue ArgumentError
+      nil
     end
 
   private

data/lib/greenwich/version.rb

@@ -1,3 +1,3 @@
 module Greenwich
-  VERSION = "0.0.5"
+  VERSION = "1.0.0"
 end

data/spec/greenwich/conversion_spec.rb

@@ -0,0 +1,313 @@
+require 'spec_helper'
+require 'pry'
+
+root = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+db_root = File.join(root, 'db')
+
+Dir.mkdir(db_root) unless File.exists?(db_root)
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3',
+                                        :database => "#{db_root}/conversion.db")
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'model_with_time_zones'")
+ActiveRecord::Base.connection.create_table(:model_with_time_zones) do |t|
+  t.datetime :started_at_utc
+  t.datetime :ended_at_utc
+  t.string   :time_zone
+end
+
+class ModelWithTimeZone < ActiveRecord::Base
+  include Greenwich::Conversion
+
+  attr_accessible :started_at_utc,
+                  :ended_at_utc,
+                  :time_zone
+
+  time_with_time_zone :started_at_utc, :time_zone => :time_zone
+  time_with_time_zone :ended_at_utc,   :time_zone => :time_zone
+
+  time_zone :time_zone, :for => [:started_at_utc, :ended_at_utc]
+end
+
+describe Greenwich::Conversion do
+  describe '.time_with_time_zone' do
+    let(:model)             { ModelWithTimeZone.new }
+    let(:alaskan_time_zone) { ActiveSupport::TimeZone.new('Alaska') }
+
+    describe '.columns_hash' do
+      it 'adds the virtual column to the columns_hash for the time field' do
+        ModelWithTimeZone.columns_hash.keys.should include 'started_at'
+      end
+
+      it 'adds the virtual column with a `datetime` type' do
+        ModelWithTimeZone.columns_hash['started_at'].type.should eql :datetime
+      end
+    end
+
+    describe '#time_field_utc=' do
+      let(:model)             { ModelWithTimeZone.new }
+      let(:alaskan_time_zone) { ActiveSupport::TimeZone.new('Alaska') }
+      let(:raw_time_field)    { model.send(:read_attribute, :started_at_utc) }
+
+      context 'when the time field is set via the writer' do
+        before { model.started_at_utc = Time.utc(2012, 1, 2, 12, 59, 1) }
+
+        it 'is not changed' do
+          raw_time_field.should eql Time.utc(2012, 1, 2, 12, 59, 1)
+        end
+
+        it 'is not eligible for conversion' do
+          model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_false
+        end
+
+        context 'and the time zone is subsequently set' do
+          before { model.time_zone = alaskan_time_zone }
+
+          it 'is not changed' do
+            raw_time_field.should eql Time.utc(2012, 1, 2, 12, 59, 1)
+          end
+        end
+      end
+    end
+
+    describe '#time_field' do
+      context 'when it is nil' do
+        before { model.send :write_attribute, :started_at_utc, nil }
+
+        it 'is nil' do
+          model.started_at.should be_nil
+        end
+      end
+
+      context 'when there is no time zone' do
+        let(:raw_time_value) { Time.utc(2012, 1, 1, 12, 0, 0) }
+
+        before do
+          model.send :write_attribute, :started_at_utc, raw_time_value
+          model.stub(:time_zone).and_return nil
+        end
+
+        it 'returns the raw time field' do
+          model.started_at.should eql raw_time_value
+        end
+      end
+
+      context 'when it is something other than a Time' do
+        before { model.send :write_attribute, :started_at_utc, 5 }
+
+        it 'returns the raw value' do
+          model.started_at.should eql 5
+        end
+      end
+
+      context 'when the time zone is set properly' do
+        before { model.stub(:time_zone).and_return 'Alaska' }
+
+        context 'when it is a time' do
+          before { model.send :write_attribute, :started_at_utc, Time.utc(2012, 1, 2, 12, 59, 1) }
+
+          it 'returns the time in the time zone' do
+            model.started_at.should eql alaskan_time_zone.parse('2012-01-02 3:59:01')
+          end
+        end
+      end
+    end
+
+    describe '#time_field=' do
+      let(:raw_time_field) { model.started_at_utc }
+
+      context 'when the time zone is set' do
+        before { model.time_zone = alaskan_time_zone.name }
+
+        context 'and the field is set to nil' do
+          before { model.started_at = nil }
+
+          it 'the time field is nil' do
+            raw_time_field.should be_nil
+          end
+
+          it 'does not need to be converted' do
+            model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_false
+          end
+        end
+
+        context 'and the field is set to something which cannot be converted to a time' do
+          before { model.started_at = 'foo' }
+
+          it 'the time field is nil' do
+            raw_time_field.should be_nil
+          end
+
+          it 'does not need to be converted' do
+            model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_false
+          end
+        end
+
+        context 'and the field is set with UTC time' do
+          before { model.started_at = Time.utc(2012, 1, 2, 12, 59, 1) }
+
+          it 'the time field is adjusted for the time zone' do
+            raw_time_field.should eql Time.utc(2012, 1, 2, 21, 59, 1)
+          end
+
+          it 'does not need to be converted' do
+            model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_false
+          end
+        end
+      end
+
+      context 'when the time zone is not set' do
+        before { model.time_zone = nil }
+
+        context 'and the time field is set' do
+          before { model.started_at = Time.utc(2012, 1, 2, 12, 59, 1) }
+
+          it 'the time field is not adjusted' do
+            raw_time_field.should eql Time.utc(2012, 1, 2, 12, 59, 1)
+          end
+
+          it 'needs to be converted' do
+            model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_true
+          end
+        end
+
+        context 'and the time field is not set' do
+          before { model.started_at = nil }
+
+          it 'the time field is nil' do
+            raw_time_field.should be_nil
+          end
+
+          it 'does not need to be converted' do
+            model.send(:greenwich_time_field_needs_conversion?, 'started_at', 'time_zone').should be_false
+          end
+        end
+      end
+    end
+
+    context 'when it is saved to the database and reloaded' do
+      before do
+        model.started_at_utc = Time.utc(2012, 1, 2, 21, 59, 1)
+        model.time_zone      = 'Alaska'
+        model.save!
+
+        model.reload
+      end
+
+      context 'and the time zone is set' do
+        before { model.time_zone = 'Hawaii' }
+
+        it 'does not modify the UTC time' do
+          model.started_at_utc.should eql Time.utc(2012, 1, 2, 21, 59, 1)
+        end
+      end
+
+      it 'converts the time field to the local time' do
+        model.started_at.should_not be_utc
+        model.started_at.should eql alaskan_time_zone.parse('2012-01-02 12:59:01')
+      end
+
+      it 'converts the time field to a TimeWithZone' do
+        model.started_at.should be_a ActiveSupport::TimeWithZone
+      end
+    end
+  end
+
+  describe '.time_zone' do
+    let(:model)             { ModelWithTimeZone.new }
+    let(:alaskan_time_zone) { ActiveSupport::TimeZone.new('Alaska') }
+
+    context '#time_zone' do
+      context 'when the object does have a time zone' do
+        before { model.send(:write_attribute, :time_zone, alaskan_time_zone.name) }
+
+        it 'is the time zone' do
+          model.time_zone.should eql alaskan_time_zone
+        end
+      end
+
+      context 'when the object does not have a time zone' do
+        before { model.send(:write_attribute, :time_zone, nil) }
+
+        it 'is nil' do
+          model.time_zone.should be_nil
+        end
+      end
+    end
+
+    describe '#time_zone=' do
+      let(:model)             { ModelWithTimeZone.new }
+      let(:alaskan_time_zone) { ActiveSupport::TimeZone.new('Alaska') }
+      let(:hawaii_time_zone)  { ActiveSupport::TimeZone.new('Hawaii') }
+      let(:raw_time_field)    { model.started_at_utc }
+      let(:raw_time_zone)     { model.read_attribute(:time_zone) }
+
+      context 'when it is set after the time field is set' do
+        before do
+          model.send :write_attribute, :started_at_utc, Time.utc(2012, 1, 2, 12, 59, 1)
+          model.time_zone      = alaskan_time_zone
+        end
+
+        it 'triggers the time field to be converted' do
+          raw_time_field.should eql Time.utc(2012, 1, 2, 21, 59, 1)
+        end
+
+        context 'but when it is set subsequently' do
+          before do
+            model.time_zone.should_not      be_nil
+            model.started_at_utc.should_not be_nil
+            model.time_zone               = hawaii_time_zone
+          end
+
+          it 'does not convert the time field' do
+            raw_time_field.should eql Time.utc(2012, 1, 2, 21, 59, 1)
+          end
+
+          context 'if some other time field is then set' do
+            before do
+              model.send :write_attribute, :ended_at_utc, Time.utc(2012, 1, 2, 13, 59, 1)
+              model.time_zone    = alaskan_time_zone
+            end
+
+            it 'converts only the time fields that have not already been converted' do
+              raw_time_field.should eql     Time.utc(2012, 1, 2, 21, 59, 1)
+              model.ended_at_utc.should eql Time.utc(2012, 1, 2, 22, 59, 1)
+            end
+          end
+        end
+      end
+
+      context 'when it is set before the time field is set' do
+        before { model.time_zone = alaskan_time_zone }
+
+        it 'sets the time zone but does not touch the time' do
+          raw_time_field.should be_nil
+          raw_time_zone.should eql 'Alaska'
+        end
+      end
+
+      context 'when it is set to an ActiveSupport::TimeZone' do
+        before { model.time_zone = alaskan_time_zone }
+
+        it 'is set properly' do
+          raw_time_zone.should eql 'Alaska'
+        end
+      end
+
+      context 'when it is set to a time zone name' do
+        before { model.time_zone = 'Alaska' }
+
+        it 'is set properly' do
+          raw_time_zone.should eql 'Alaska'
+        end
+      end
+
+      context 'when it is set to an invalid time zone' do
+        before { model.time_zone = 'I am not a time zone' }
+
+        it 'is nil' do
+          raw_time_zone.should be_nil
+        end
+      end
+    end
+  end
+end