activerecord-time 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.idea
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-time.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Uwe Kubosch
+
+MIT License
+
+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,70 @@
+# activerecord-time
+
+A handler for storing TimeOfDay objects in ActiveRecord objects as sql time values.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-time'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-time
+
+## Usage
+
+Create your tables with fields with type :time and you will be able to access them as
+TimeOfDay objects.
+
+```Ruby
+create_table :schedules do |t|
+  ...
+  t.column :start_at, :time
+  ...
+end
+```
+
+or
+
+```Ruby
+create_table :schedules do |table|
+  ...
+  t.time :start_at
+  ...
+end
+```
+
+or
+
+```Ruby
+add_column :schedule, :start_time, :time
+```
+
+The value of the column will be a TimeOfDay object:
+
+```Ruby
+schedule = Schedule.new
+schedule.start_time = TimeOfDay.parse('08:34')
+```
+
+or
+
+```Ruby
+schedule = Schedule.new
+schedule.start_time = '08:34'
+```
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require 'rubygems'
+require "bundler/gem_tasks"

data/activerecord-time.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-time/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "activerecord-time"
+  gem.version       = Activerecord::Time::VERSION
+  gem.authors       = ["Uwe Kubosch"]
+  gem.email         = ["uwe@kubosch.no"]
+  gem.description   = %q{A handler for storing TimeOfDay objects in ActiveRecord objects as sql time values.}
+  gem.summary       = %q{A handler for storing TimeOfDay objects in ActiveRecord objects as sql time values.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/activerecord-time.rb

@@ -0,0 +1,3 @@
+require 'activerecord-time/version'
+require 'time_of_day'
+require 'activerecord-time/extension'

data/lib/activerecord-time/extension.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class Column
+      def klass_with_time_of_day
+        return TimeOfDay if :time === type
+        klass_without_time_of_day
+      end
+      alias_method_chain :klass, :time_of_day
+      
+      def self.string_to_dummy_time(string)
+        return string if string.is_a? TimeOfDay
+        return nil if string.empty?
+        TimeOfDay.parse(string)
+      end
+    end
+    module Quoting
+      def quote_with_time_of_day(value, column = nil)
+        return "'#{quoted_time(value)}'" if TimeOfDay === value
+        quote_without_time_of_day(value, column)
+      end
+      alias_method_chain :quote, :time_of_day
+      
+      def quoted_time(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/activerecord-time/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module Time
+    VERSION = "0.0.1"
+  end
+end

data/lib/time_of_day.rb

@@ -0,0 +1,117 @@
+class TimeOfDay
+  yaml_as "tag:yaml.org,2002:timestamp#hms"
+  yaml_as "tag:yaml.org,2002:time"
+  yaml_as "tag:ruby.yaml.org,2002:time"
+
+  attr_accessor :hour # 0 - 23
+  attr_accessor :minute # 0 - 59
+  attr_accessor :second # 0 - 59
+
+  def initialize(hour, minute, second = 0)
+    raise "Invalid hour: #{hour}" unless hour >= 0 && hour <= 23
+    raise "Invalid minute: #{minute}" unless minute >= 0 && minute <= 59
+    raise "Invalid second: #{second}" unless second >= 0 && hour <= 59
+    @hour, @minute, @second = hour, minute, second
+  end
+
+  def init_with(coder)
+    parts = self.class.parse_parts(coder.scalar)
+    initialize(*parts)
+  end
+
+  def self.now
+    Time.now.time_of_day
+  end
+
+  def self.parse(string)
+    return nil if string.blank?
+    self.new(*parse_parts(string))
+  end
+
+  def self.parse_parts(string)
+    string.strip!
+    raise "Illegal time format: '#{string}'" unless string =~ /^(\d{1,2}):?(\d{2})?(?::(\d{1,2}))?$/
+    [$1.to_i, $2.to_i, $3.to_i]
+  end
+
+  def on(date)
+    Time.local(date.year, date.month, date.day, hour, minute, second)
+  end
+
+  def -(seconds)
+    raise "Illegal argument: #{seconds.inspect}" unless seconds.is_a? Numeric
+    t = Time.local(0, 1, 1, hour, minute, second)
+    t -= seconds
+    self.class.new(t.hour, t.min, t.sec)
+  end
+
+  def <=>(other)
+    [@hour, @minute, @second] <=> [other.hour, other.minute, other.second]
+  end
+
+  def ==(other)
+    return false unless other.is_a? TimeOfDay
+    (self <=> other) == 0
+  end
+
+  def <(other)
+    return false unless other.is_a? TimeOfDay
+    (self <=> other) < 0
+  end
+
+  def <=(other)
+    return false unless other.is_a? TimeOfDay
+    (self <=> other) <= 0
+  end
+
+  def >(other)
+    return false unless other.is_a? TimeOfDay
+    (self <=> other) > 0
+  end
+
+  def >=(other)
+    return false unless other.is_a? TimeOfDay
+    (self <=> other) >= 0
+  end
+
+  def strftime(format)
+    on(Date.today).strftime(format)
+  end
+
+  def to_s(with_seconds = true)
+    if with_seconds
+      "%02d:%02d:%02d" % [@hour, @minute, @second]
+    else
+      "%02d:%02d" % [@hour, @minute]
+    end
+  end
+
+  def self.yaml_new(klass, tag, val)
+    if String === val
+      self.parse val
+    else
+      raise YAML::TypeError, "Invalid Time: " + val.inspect
+    end
+  end
+
+  def to_yaml(opts = {})
+    YAML::quick_emit(nil, opts) do |out|
+      out.scalar('tag:yaml.org,2002:time', self.to_s, :plain)
+    end
+  end
+
+end
+
+class Time
+  def time_of_day
+    TimeOfDay.new(hour, min, sec)
+  end
+
+end
+
+class Date
+  def at(time_of_day)
+    Time.local(year, month, day, time_of_day.hour, time_of_day.minute, time_of_day.second)
+  end
+
+end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: ":memory:"
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: plugin_test

data/test/rails_time_test.rb

@@ -0,0 +1,122 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Thing < ActiveRecord::Base
+end
+
+def thing
+  Thing.new(:name => "Thing One",:price_in_cents=> 125)
+end
+
+class RailsMoneyTest < Test::Unit::TestCase
+  
+  def test_should_return_price_as_money_object
+    price = thing.price
+    assert_kind_of Money, price
+    assert_equal "$1.25", thing.price.to_s
+  end
+  
+  def test_should_set_price_from_money_object
+    thing1 = thing 
+    thing1.price = Money.new(1095)
+    assert_equal 109500, thing1.price_in_cents
+    assert_equal "$1,095.00", thing1.price.to_s
+  end
+
+  def test_should_set_price_from_fixnum
+    thing1 = thing
+    thing1.price = 1095
+    assert_equal 109500, thing1.price_in_cents
+  end
+
+  def test_should_set_price_from_float
+    thing1 = thing
+    thing1.price = 10.95
+    assert_equal 1095, thing1.price_in_cents
+  end
+  
+  def test_should_set_price_from_string
+    thing1 = thing
+    thing1.price = "$10.95"
+    assert_equal 1095, thing1.price_in_cents
+    thing1.price = "10"
+    assert_equal 1000, thing1.price_in_cents
+  end
+
+  def test_should_format_correctly
+    assert_equal "$12.40", Money.new(12.40).to_s
+  end
+
+  def test_should_raise_exception_setting_invalid_price
+    assert_raise(MoneyError) { thing.price = [] }
+  end
+end
+
+class MoneyTest < Test::Unit::TestCase
+   
+  def test_should_create_money_object
+    assert cash_money = Money.new(1290)
+    assert_equal 129000, cash_money.cents
+    assert_equal 1290, cash_money.dollars
+    assert_equal "$1,290.00", cash_money.to_s
+    assert_equal false, cash_money.free?
+    assert_equal 0, Money.new(nil).cents
+  end
+
+  def test_should_create_money_object_from_float_with_proper_rounding
+    money =  Money.new(12.196)
+    assert_equal 1220, money.cents
+    assert_instance_of Fixnum, money.cents 
+  end
+  
+  def test_should_raise_exception_if_invalid_type_passed_to_initialize
+    assert_raise(MoneyError) { Money.new([]) }
+  end
+
+  def test_should_return_free_on_to_s_if_cents_is_zero
+    cash_money = Money.new(0)
+    assert_equal 'free', cash_money.to_s
+    assert_equal true, cash_money.free?
+    assert_equal true, cash_money.zero?
+  end
+
+  def test_should_be_comparable
+    assert Money.include?(Comparable)
+    assert Money.new(0) == Money.new(0)
+  end
+
+  def test_should_add_money
+    assert_equal Money.new(20.95), Money.new(10) + Money.new(10.95)
+    assert_equal Money.new(2000), Money.new(1000) + 1000
+    assert_equal Money.new(20.06), Money.new(10.00) + 10.056
+  end
+
+  def test_should_subtract_money
+    assert_equal Money.new(500), Money.new(1000) - Money.new(500)
+    assert_equal Money.new(500),  Money.new(1000) - 500
+    assert_equal Money.new(4.60),  Money.new(10) - 5.40
+  end
+
+  def test_should_multiply_money
+    assert_equal Money.new(500), Money.new(100) * 5
+    assert_equal Money.new(9.99), Money.new(3.33) * 3
+    assert_equal Money.new(11.99), Money.new(3.33) * 3.6 # 1198.9
+  end
+
+  def test_should_divide_money_and_retur_array_of_monies
+    money_array = [Money.new(3.34), Money.new(3.33), Money.new(3.33)]
+    assert_equal money_array, Money.new(10.00) / 3
+    assert_equal [Money.new(2.00), Money.new(2.00)], Money.new(4.00) / 2
+    assert_raises(MoneyError) { Money.new(4.00) / 2.2 }
+  end
+
+  def test_should_implement_to_money
+    assert_equal Money.new(10), Money.new(10).to_money
+    assert_equal Money.new(100.00), 100.00.to_money
+    assert_equal Money.new(100.96), 100.956.to_money
+  end
+  
+  def test_should_create_from_cents
+    assert_equal Money.new(1.50), Money.create_from_cents(150)
+  end
+
+end

data/test/schema.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Schema.define(:version => 1) do
+  
+  # Create tables for testing your plugin
+
+   create_table :things do |t|
+     t.column :name,   :string
+     t.column :price_in_cents, :integer
+   end
+    
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require "#{File.dirname(__FILE__)}/../init"
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
+
+
+
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-time
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Uwe Kubosch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-04 00:00:00 Z
+dependencies: []
+
+description: A handler for storing TimeOfDay objects in ActiveRecord objects as sql time values.
+email: 
+- uwe@kubosch.no
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-time.gemspec
+- lib/activerecord-time.rb
+- lib/activerecord-time/extension.rb
+- lib/activerecord-time/version.rb
+- lib/time_of_day.rb
+- test/database.yml
+- test/rails_time_test.rb
+- test/schema.rb
+- test/test_helper.rb
+homepage: ""
+licenses: []
+
+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.24
+signing_key: 
+specification_version: 3
+summary: A handler for storing TimeOfDay objects in ActiveRecord objects as sql time values.
+test_files: 
+- test/database.yml
+- test/rails_time_test.rb
+- test/schema.rb
+- test/test_helper.rb