semanticgap_date_time_form 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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

@@ -0,0 +1,50 @@
+SemanticGapDateTimeForm
+========================
+
+This provides extends Rails' FormBuilder to have a #datetime_form method
+which is more awesome than the standard #datetime_select.
+
+
+Dependencies
+=============
+
+* ActiveForm
+  * git://github.com/zaczheng/activeform.git
+  * http://github.com/nayutaya/active_form.git
+
+
+Installation
+=============
+
+  $ cd RAILS_ROOT
+  $ ./script/plugin install git://github.com/zaczheng/activeform.git
+  $ ./script/plugin install http://git.oss.semanticgap.com/ruby/semanticgap_date_time_form.git
+
+
+Usage
+======
+
+Model
+------
+
+class Record < ActiveRecord::Base
+  datetime_fields_for :created_at
+  datetime_fields_for :published_at, :allow_blank => true
+end
+
+View
+-----
+
+<% form_for @record do |f| -%>
+  <%= f.label :published_at %>
+  <%= f.datetime_form :published_at %>
+
+  <%= f.label :created_at %>
+  <%= f.datetime_form :created_at %>
+<% end -%>
+
+
+Legal
+======
+
+Copyright (c) 2010 SemanticGap(R), released under the MIT license

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+require 'spec/rake/spectask'
+
+desc "Run the specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = [ '-fprogress', '-fhtml:doc/spec.html' ]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run the specs with rcov"
+  Spec::Rake::SpecTask.new(:coverage) do |t|
+    t.spec_opts = [ '-fprogress', '-fhtml:doc/spec.html' ]
+    t.rcov = true
+    t.rcov_opts = [ '--rails', '--exclude', 'spec/*,gems/*' ]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+end
+
+desc 'Generate documentation for the semanticgap_datetime_fields plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SemanticgapDatetimeFields'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/semanticgap_date_time_form.rb

@@ -0,0 +1,6 @@
+require 'semanticgap_date_time_form/form'
+require 'semanticgap_date_time_form/active_record_mixin'
+require 'semanticgap_date_time_form/form_builder_mixin'
+
+ActionView::Helpers::FormBuilder.send(:include, SemanticGap::DateTimeForm::FormBuilderMixin)
+ActiveRecord::Base.send(:include, SemanticGap::DateTimeForm::ActiveRecordMixin)

data/lib/semanticgap_date_time_form/active_record_mixin.rb

@@ -0,0 +1,42 @@
+module SemanticGap
+  module DateTimeForm
+    module ActiveRecordMixin
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def datetime_fields_for(attr, options = Hash.new)
+          method_name = "#{attr}_fields"
+          define_method(method_name) do
+            fields = instance_variable_get("@#{method_name}")
+            unless fields
+              instance_variable_set("@#{method_name}", Form.new(send(attr), options))
+              
+            end
+            instance_variable_get("@#{method_name}")
+          end
+
+          define_method("#{method_name}=") do |params|
+            fields = send(method_name)
+            fields.attributes = params
+            send("#{attr}=", fields.to_datetime)
+          end
+
+          define_method("validate_#{method_name}") do
+            form = send(method_name)
+            errors.add(attr, "is invalid") unless form.valid?
+          end
+
+          validate "validate_#{method_name}"
+
+          define_method("update_#{attr}") do
+            send("#{attr}=", send(method_name).to_datetime) if send(attr).nil?
+          end
+
+          before_save "update_#{attr}"
+        end
+      end
+    end
+  end
+end

data/lib/semanticgap_date_time_form/form.rb

@@ -0,0 +1,117 @@
+require 'active_form'
+
+module SemanticGap
+  module DateTimeForm
+    class Form < ActiveForm
+      def initialize(*args)
+        super()
+
+        options = args.extract_options!
+        date = args.first
+
+        @time_zone = options.fetch(:time_zone) { Time.zone || ActiveSupport::TimeZone.new('UTC') }
+        @allow_blank = options.fetch(:allow_blank) { false }
+
+        self.date = date if date.respond_to?(:strftime)
+      end
+
+      def date=(d)
+        d = time_zone.utc_to_local(d.to_datetime.utc)
+
+        self.attributes = {
+          :year => d.year, :month => d.month, :day => d.day,
+          :hour => d.strftime("%I"), :minute => d.strftime("%M"), :ampm => d.strftime("%p")
+        }
+      end
+
+      attr_accessor :year, :month, :day, :hour, :minute, :ampm, :time_zone
+
+      validate :validate_time
+      validate :validate_date
+
+      def month
+        if @month.kind_of? Symbol
+          @month
+        elsif @month
+          @month.to_i
+        end
+      end
+
+      def time_zone_name
+        time_zone.name
+      end
+
+      def time_zone_name=(str)
+        tz = ActiveSupport::TimeZone.new(str)
+
+        if tz
+          self.time_zone = tz
+          time_zone_name
+        end
+      end
+
+      def allow_blank?
+        @allow_blank
+      end
+
+      def validate_time
+        return if allow_blank? && time_blank?
+
+        errors.add(:hour, "is invalid") unless hour.to_s =~ /\d+/ && (0..23).include?(hour.to_i)
+        errors.add(:minute, "is invalid") unless minute.to_s =~ /\d+/ && (0..59).include?(minute.to_i)
+        errors.add(:ampm, "must be AM or PM") unless %W(AM PM am pm).include?(ampm)
+      end
+
+      def validate_date
+        return if allow_blank? && date_blank?
+
+        errors.add(:year, "#{year} is not a valid year") unless year.to_s =~ /\d+/
+        errors.add(:month, "#{month} is not a valid month") unless (1..12).include?(month.to_i)
+        errors.add(:day, "#{day} is not a valid day") unless day.to_s =~ /\d+/ && (1..31).include?(day.to_i)
+
+        if errors[:month].blank? && errors[:month].blank?
+          begin
+            build_datetime
+          rescue ArgumentError
+            errors.add(:day, "is invalid")
+          end
+        end
+      end
+
+      def pm?
+        ampm[0, 1].downcase == 'p' unless ampm.blank?
+      end
+
+      def blank?
+        time_blank? && date_blank?
+      end
+
+      def to_datetime
+        return nil if (allow_blank? && blank?) || !valid?
+
+        time_zone.local_to_utc(build_datetime)
+      end
+
+      private
+
+      def build_datetime
+        DateTime.new(year.to_i, month, day.to_i, adjusted_hour, minute.to_i)
+      end
+
+      def adjusted_hour
+        h = hour.to_i
+        h = h + 12 if h < 12 && pm?
+        h = 0 if h == 12 && !pm?
+        h
+      end
+
+      def time_blank?
+        hour.blank? && minute.blank?
+      end
+
+      def date_blank?
+        year.blank? && @month.blank? && day.blank?
+      end
+    end
+  end
+end

data/lib/semanticgap_date_time_form/form_builder_mixin.rb

@@ -0,0 +1,26 @@
+module SemanticGap
+  module DateTimeForm
+    module FormBuilderMixin
+      def datetime_form(attr, value = nil)
+        value ||= @object.try(datetime_param(attr))
+        form = fields_for(datetime_param(attr), value) do |f|
+          f.text_field(:year, :size => 4) + "/" +
+            @template.select_month(value, :prefix => f.object_name, :include_blank => value.allow_blank?) + "/" +
+            f.text_field(:day, :size => 2) + "—" +
+            f.text_field(:hour, :size => 2) + ":" +
+            f.text_field(:minute, :size => 2) +
+            f.select(:ampm, %W(AM PM)) +
+            @template.content_tag('span', value.time_zone.name, :class => 'timezone')
+            # @template.time_zone_select(f.object_name, :time_zone_name, ActiveSupport::TimeZone.us_zones, :default => Time.zone.name)
+        end
+
+        @template.content_tag('div', form, :class => 'sg-datetime-form')
+      end
+
+      private
+      def datetime_param(attr)
+        "#{attr}_fields"
+      end
+    end
+  end
+end

data/lib/semanticgap_date_time_form/spec.rb

@@ -0,0 +1,127 @@
+module SemanticGap
+  module DateTimeForm
+    module Spec
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def it_has_datetime_fields_for(attr, options = Hash.new)
+          attr_fields = "#{attr}_fields"
+
+          describe "\##{attr_fields}" do
+            context 'first call' do
+              before(:each) do
+                subject.send("#{attr}=", Time.now)
+              end
+
+              it "creates a datetime form initialized with the value @#{attr} and the options #{options.inspect}" do
+                SemanticGap::DateTimeForm::Form.should_receive(:new).
+                  with(subject.send(attr), options)
+
+                subject.send(attr_fields)
+              end
+
+              it "returns the form" do
+                SemanticGap::DateTimeForm::Form.should_receive(:new).and_return(:form)
+                subject.send(attr_fields).should == :form
+              end
+            end
+
+            context 'subsequent calls' do
+              before(:each) do
+                @form = subject.send(attr_fields)
+              end
+
+              it "does not create a new datetime form" do
+                SemanticGap::DateTimeForm::Form.should_not_receive(:new)
+                subject.send(attr_fields)
+              end
+
+              it "returns the form" do
+                subject.send(attr_fields).should == @form
+              end
+            end
+          end
+
+          describe "\##{attr_fields}=" do
+            it "updates the fields' attributes with the value" do
+              @params = { :year => 2010, :month => 5, :day => 6 }
+              subject.send(attr_fields).should_receive(:attributes=).with(@params)
+
+              subject.send("#{attr_fields}=", @params)
+            end
+
+            context 'with valid fields' do
+              it "updates @#{attr} to the fields' datetime" do
+                @params = { :year => 2010, :month => 5, :day => 6, :hour => 12, :minute => 0, :ampm => 'PM' }
+                
+                lambda { subject.send("#{attr_fields}=", @params) }.
+                  should change(subject, attr).to(DateTime.new(2010, 5, 6, 12, 0))
+              end
+            end
+
+            context 'with invalid fields' do
+              before(:each) do
+                subject.send("#{attr}=", Time.now)
+              end
+
+              it "updates @#{attr} to nil" do
+                lambda { subject.send("#{attr_fields}=", { :month => 13 } ) }.
+                  should change(subject, attr).to(nil)
+              end
+            end
+          end
+
+          describe '#valid?' do
+            context 'when #{attr_fields} are valid' do
+              before(:each) do
+                subject.send(attr_fields).stub!(:valid?).and_return(true)
+              end
+
+              it "does NOT add errors for #{attr}" do
+                subject.should_not have(:any).errors_on(attr)
+              end
+            end
+
+            context 'when #{attr_fields} are invalid' do
+              before(:each) do
+                subject.send(attr_fields).stub!(:valid?).and_return(false)
+              end
+
+              it "adds errors for :published_at" do
+                subject.should have_at_least(1).error_on(attr)
+              end
+            end
+          end
+
+          describe '#save!' do
+            context "when #{attr} is nil" do
+              before(:each) do
+                subject.send("#{attr}=", nil)
+              end
+
+              it "updates #{attr} with the #{attr_fields} datetime" do
+                @time = DateTime.now
+                subject.send(attr_fields).should_receive(:to_datetime).and_return(@time)
+                subject.send(attr_fields).stub!(:valid?).and_return(true)
+
+                lambda { subject.save! }.should change(subject, attr).to(@time)
+              end
+            end
+
+            context "when #{attr} is not nil" do
+              before(:each) do
+                subject.send("#{attr}=", Time.now)
+              end
+
+              it "does NOT change #{attr}" do
+                lambda { subject.save! }.should_not change(subject, attr)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/public/stylesheets/semanticgap_date_time_form.css

@@ -0,0 +1,3 @@
+.sg-datetime-form > DIV {
+  display: inline;
+}

data/rails/init.rb

@@ -0,0 +1 @@
+require 'semanticgap_date_time_form'

data/rails/install.rb

@@ -0,0 +1,8 @@
+# Install hook code here
+File.copy("public/stylesheets/semanticgap_date_time_form.css",
+          File.join(Rails.root, "public", "stylesheets", "semanticgap_date_time_form.css"))
+
+puts
+puts "Remember to add the following to your layout:"
+puts "  <%= stylesheet_link_tag 'semanticgap_date_time_form' %>"
+puts