multiparameter_date_time 0.3.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dbe4e334a2cdfcaffabfc6e283e801b6ec7a2c4
-  data.tar.gz: f1dc19849afde4d9ca07c7e8c0d11bbcb82a5ebd
+  metadata.gz: 3a7fd23d65051eaecbc7c17b18806daa43cd2f24
+  data.tar.gz: 15ef75bee0a75d0887bafab21198a2fe77a2dc78
 SHA512:
-  metadata.gz: 4246599e275e0200c000547dcbeffa5fa0be0731aaaba88c424311d80b63e0cbe4994cb41825cf49e0845a8393171571fe119fc3220cd7de77495bc64afafb4c
-  data.tar.gz: e0c95dcb0ddcfb50a5ef77b57fc108e15413720194dd191552fd8630a30cdf509605b3e997678bcb18cf9eb47dd9ab898d5c946e70c2e10b8b056ea44e074c6a
+  metadata.gz: 6772dcbcbffd2fd43250e041a4c1b9181efa09c2e6617fa927e3b9e9b778f9cd5c53963319ae488fa714e5025070234df93e78fffec44c291944875ce40a6f13
+  data.tar.gz: a9b1c7d94d95684354c515f8e9a3a4e1363863b9e505b0cca239fdd67010496f277f003dcbb73eea9acc621840a19c31eb5897044cfc118581f85ceafc5e2a14

data/lib/is_valid_multiparameter_date_time_validator.rb

@@ -2,27 +2,30 @@ require 'active_model/validator'
 
 class IsValidMultiparameterDateTimeValidator < ActiveModel::EachValidator
   def validate_each(record, attribute, value)
-    date_value = record.public_send(:"#{attribute}_date_part")
-    time_value = record.public_send(:"#{attribute}_time_part")
+    date_part_key = :"#{attribute}_date_part"
+    date_value = record.public_send(date_part_key)
 
-    return if date_value.blank? && time_value.blank?
+    time_part_key = :"#{attribute}_time_part"
+    time_value = record.public_send(time_part_key)
 
-    if date_invalid?(date_value) || time_invalid?(time_value)
+    return if !options[:required] && date_value.blank? && time_value.blank?
+
+    if date_value.blank? && time_value.blank?
+      message = "Please enter a date and time for the #{record.class.name.titleize.downcase}."
+      record.errors.add(attribute, message)
+    elsif date_invalid?(date_value) || time_invalid?(time_value)
       record.errors.add(attribute, self.class.invalid_format_error_message)
     elsif date_value.blank?
-      key = :"#{attribute}_date_part"
-      message = record.errors.generate_message(key, :blank, default: 'Please enter a date.')
+      message = record.errors.generate_message(date_part_key, :blank, default: 'Please enter a date.')
       record.errors.add(attribute, message)
     elsif time_value.blank?
-      key = :"#{attribute}_time_part"
-      message = record.errors.generate_message(key, :blank, default: 'Please enter a time.')
+      message = record.errors.generate_message(time_part_key, :blank, default: 'Please enter a time.')
       record.errors.add(attribute, message)
     else
-      attribute_value = record.public_send(:"#{attribute}_time_part")
       begin
         Date.parse(date_value)
         Time.zone.parse("#{date_value} #{time_value}")
-        Time.zone.parse(attribute_value)
+        Time.zone.parse(time_value)
       rescue ArgumentError
         record.errors.add(attribute, self.class.invalid_format_error_message)
       end

data/lib/multiparameter_date_time/version.rb

@@ -1,3 +1,3 @@
 module MultiparameterDateTime
-  VERSION = '0.3.6'
+  VERSION = '0.4.0'
 end

data/spec/is_valid_multiparameter_date_time_validator_spec.rb

@@ -16,7 +16,7 @@ describe IsValidMultiparameterDateTimeValidator do
     model do
       include MultiparameterDateTime
       multiparameter_date_time :foo
-      validates :foo, is_valid_multiparameter_date_time: true, allow_blank: true
+      validates :foo, is_valid_multiparameter_date_time: true
     end
   end
 
@@ -386,6 +386,52 @@ describe IsValidMultiparameterDateTimeValidator do
         end
       end
     end
+
+    context 'parameter specifying whether the field is required' do
+      context 'when nothing is set at all and the value is not required' do
+        with_model :ModelWithDatetimeRequired do
+          table do |t|
+            t.datetime :foo
+          end
+
+          model do
+            include MultiparameterDateTime
+            multiparameter_date_time :foo
+            validates :foo, is_valid_multiparameter_date_time: { required: false }
+          end
+        end
+
+        let(:record) { ModelWithDatetimeRequired.new }
+
+        it 'should show the missing datetime error' do
+          record.valid?
+          expect(record.errors[:foo]).to be_empty
+        end
+      end
+
+      context 'when nothing is set at all and a value is required' do
+        with_model :ModelWithDatetimeRequired do
+          table do |t|
+            t.datetime :foo
+          end
+
+          model do
+            include MultiparameterDateTime
+            multiparameter_date_time :foo
+            validates :foo, is_valid_multiparameter_date_time: { required: true }
+          end
+        end
+
+        let(:record) { ModelWithDatetimeRequired.new }
+
+        it 'should show the missing datetime error' do
+          record.valid?
+          expect(record.errors[:foo]).to eq [
+            'Please enter a date and time for the model with datetime required.'
+          ]
+        end
+      end
+    end
   end
 
   describe 'accepts dates in a variety of formats' do

data/spec/multiparameter_date_time_spec.rb

@@ -27,431 +27,424 @@ describe MultiparameterDateTime do
   end
 
   %w[ModelWithDateTime ActiveModelWithDateTime].each do |model_name|
-    let(:parent_model) { model_name.constantize }
-    let(:subclass_model) { Class.new(parent_model) }
+    context "for #{model_name}" do
+      let(:model) { model_name.constantize }
 
-    [false, true].each do |use_subclass|
-      let(:model) { use_subclass ? subclass_model : parent_model }
+      let(:record) do
+        model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
+      end
 
-      context "for #{"a subclass of " if use_subclass}#{model_name}" do
-        let(:record) do
-          model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
+      describe 'when a value is present' do
+        let(:record) { model.new(foo: Time.zone.parse('1/2/2003 04:05pm')) }
+        it 'assigns date_part' do
+          expect(record.foo_date_part).to eq '1/2/2003'
         end
 
-        subject { record }
+        it 'assigns time_part' do
+          expect(record.foo_time_part).to eq '4:05 pm'
+        end
+      end
 
-        describe 'when a value is present' do
-          let(:record) { model.new(foo: Time.zone.parse('1/2/2003 04:05pm')) }
-          it 'assigns date_part' do
-            expect(subject.foo_date_part).to eq '1/2/2003'
-          end
+      describe 'setting a valid date and time' do
+        let(:foo_date_part) { '01/02/2000' }
+        let(:foo_time_part) { '9:30 pm EST' }
 
-          it 'assigns time_part' do
-            expect(subject.foo_time_part).to eq '4:05 pm'
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
         end
 
-        describe 'setting a valid date and time' do
-          let(:foo_date_part) { '01/02/2000' }
-          let(:foo_time_part) { '9:30 pm EST' }
+        it 'sets the attribute to a DateTime object' do
+          expect(record.foo).to eq Time.zone.parse('1/2/2000 9:30 pm')
+        end
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'has the original date input' do
+          expect(record.foo_date_part).to eq '01/02/2000'
+        end
 
-          it 'sets the attribute to a DateTime object' do
-            expect(subject.foo).to eq Time.zone.parse('1/2/2000 9:30 pm')
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq '9:30 pm EST'
+        end
+      end
 
-          it 'has the original date input' do
-            expect(subject.foo_date_part).to eq '01/02/2000'
-          end
+      describe 'setting an invalid date' do
+        let(:foo_date_part) { 'bad input' }
+        let(:foo_time_part) { '9:30 pm' }
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq '9:30 pm EST'
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
+
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
         end
 
-        describe 'setting an invalid date' do
-          let(:foo_date_part) { 'bad input' }
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq 'bad input'
+        end
+
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq '9:30 pm'
+        end
+
+        context 'valid month but invalid day for the month' do
+          let(:foo_date_part) { '2/31/2015' }
           let(:foo_time_part) { '9:30 pm' }
 
           it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
+            expect { record }.not_to raise_exception
           end
 
           it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
+            expect(record.foo).to eq :incomplete
           end
 
           it 'has the original date' do
-            expect(subject.foo_date_part).to eq 'bad input'
+            expect(record.foo_date_part).to eq '2/31/2015'
           end
 
           it 'has the original time input' do
-            expect(subject.foo_time_part).to eq '9:30 pm'
+            expect(record.foo_time_part).to eq '9:30 pm'
           end
+        end
+      end
 
-          context 'valid month but invalid day for the month' do
-            let(:foo_date_part) { '2/31/2015' }
-            let(:foo_time_part) { '9:30 pm' }
+      describe 'setting an impossible date' do
+        let(:foo_date_part) { '99/99/9999' }
+        let(:foo_time_part) { '12:30 pm' }
 
-            it 'does not raise an exception' do
-              expect { subject }.not_to raise_exception
-            end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-            it 'sets the attribute to :incomplete' do
-              expect(subject.foo).to eq :incomplete
-            end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-            it 'has the original date' do
-              expect(subject.foo_date_part).to eq '2/31/2015'
-            end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq '99/99/9999'
+        end
 
-            it 'has the original time input' do
-              expect(subject.foo_time_part).to eq '9:30 pm'
-            end
-          end
+        it 'has the original time' do
+          expect(record.foo_time_part).to eq '12:30 pm'
         end
+      end
 
-        describe 'setting an impossible date' do
-          let(:foo_date_part) { '99/99/9999' }
-          let(:foo_time_part) { '12:30 pm' }
+      describe 'setting an invalid time' do
+        let(:foo_date_part) { '01/02/2000' }
+        let(:foo_time_part) { 'bad input' }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-          it 'has the original date' do
-            expect(subject.foo_date_part).to eq '99/99/9999'
-          end
+        it 'has the original date input' do
+          expect(record.foo_date_part).to eq '01/02/2000'
+        end
 
-          it 'has the original time' do
-            expect(subject.foo_time_part).to eq '12:30 pm'
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq 'bad input'
         end
+      end
 
-        describe 'setting an invalid time' do
-          let(:foo_date_part) { '01/02/2000' }
-          let(:foo_time_part) { 'bad input' }
+      describe 'setting a impossible time' do
+        let(:foo_date_part) { '01/02/2000' }
+        let(:foo_time_part) { '99:99pm' }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-          it 'has the original date input' do
-            expect(subject.foo_date_part).to eq '01/02/2000'
-          end
+        it 'has the original date input' do
+          expect(record.foo_date_part).to eq '01/02/2000'
+        end
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq 'bad input'
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq '99:99pm'
         end
+      end
 
-        describe 'setting a impossible time' do
-          let(:foo_date_part) { '01/02/2000' }
-          let(:foo_time_part) { '99:99pm' }
+      describe 'setting a date but not a time' do
+        let(:record) { model.new(foo_date_part: '01/01/2000') }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-          it 'has the original date input' do
-            expect(subject.foo_date_part).to eq '01/02/2000'
-          end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq '01/01/2000'
+        end
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq '99:99pm'
-          end
+        it 'has the nil for the time input' do
+          expect(record.foo_time_part).to eq nil
         end
+      end
 
-        describe 'setting a date but not a time' do
-          let(:record) { model.new(foo_date_part: '01/01/2000') }
+      describe 'setting a time but not a date' do
+        let(:record) { model.new(foo_time_part: '12:30 pm') }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-          it 'has the original date' do
-            expect(subject.foo_date_part).to eq '01/01/2000'
-          end
+        it 'has the nil for the date input' do
+          expect(record.foo_date_part).to eq nil
+        end
 
-          it 'has the nil for the time input' do
-            expect(subject.foo_time_part).to eq nil
-          end
+        it 'has the original time' do
+          expect(record.foo_time_part).to eq '12:30 pm'
         end
+      end
 
-        describe 'setting a time but not a date' do
-          let(:record) { model.new(foo_time_part: '12:30 pm') }
+      describe 'setting incorrect time and date' do
+        let(:record) { model.new(foo_time_part: 'qwer',
+                                 foo_date_part: 'asdf') }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'sets the attribute to :incomplete' do
+          expect(record.foo).to eq :incomplete
+        end
 
-          it 'has the nil for the date input' do
-            expect(subject.foo_date_part).to eq nil
-          end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq 'asdf'
+        end
 
-          it 'has the original time' do
-            expect(subject.foo_time_part).to eq '12:30 pm'
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq 'qwer'
         end
+      end
 
-        describe 'setting incorrect time and date' do
-          let(:record) { model.new(foo_time_part: 'qwer',
-                                   foo_date_part: 'asdf') }
+      describe 'setting neither time nor a date' do
+        let(:record) { model.new(foo_time_part: '',
+                                 foo_date_part: '') }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'sets the attribute to :incomplete' do
-            expect(subject.foo).to eq :incomplete
-          end
+        it 'has nil for the attribute' do
+          expect(record.foo).to eq nil
+        end
 
-          it 'has the original date' do
-            expect(subject.foo_date_part).to eq 'asdf'
-          end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq ''
+        end
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq 'qwer'
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq ''
         end
+      end
 
-        describe 'setting neither time nor a date' do
-          let(:record) { model.new(foo_time_part: '',
-                                   foo_date_part: '') }
+      describe 'setting a DateTime directly' do
+        let(:record) { model.new(foo: Time.zone.parse("#{foo_date_part} #{foo_time_part}")) }
+        let(:foo_date_part) { '01/02/2000' }
+        let(:foo_time_part) { '12:30 pm' }
 
-          it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
-          end
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
+        end
 
-          it 'has nil for the attribute' do
-            expect(subject.foo).to eq nil
-          end
+        it 'sets the attribute to a DateTime object' do
+          expect(record.foo).to eq Time.zone.parse('01/02/2000 12:30 pm')
+        end
 
-          it 'has the original date' do
-            expect(subject.foo_date_part).to eq ''
-          end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq '1/2/2000'
+        end
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq ''
-          end
+        it 'has the original time input' do
+          expect(record.foo_time_part).to eq '12:30 pm'
         end
+      end
 
-        describe 'setting a DateTime directly' do
-          let(:record) { model.new(foo: Time.zone.parse("#{foo_date_part} #{foo_time_part}")) }
-          let(:foo_date_part) { '01/02/2000' }
+      describe 'setting a String directly' do
+        context 'When the string contains a date and time' do
+          let(:record) { model.new(foo: "#{foo_date_part} #{foo_time_part}") }
+          let(:foo_date_part) { '01/01/2000' }
           let(:foo_time_part) { '12:30 pm' }
 
           it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
+            expect { record }.not_to raise_exception
           end
 
           it 'sets the attribute to a DateTime object' do
-            expect(subject.foo).to eq Time.zone.parse('01/02/2000 12:30 pm')
+            expect(record.foo).to eq Time.zone.parse('01/01/2000 12:30pm')
           end
 
           it 'has the original date' do
-            expect(subject.foo_date_part).to eq '1/2/2000'
+            expect(record.foo_date_part).to eq '01/01/2000'
           end
 
-          it 'has the original time input' do
-            expect(subject.foo_time_part).to eq '12:30 pm'
+          it 'has the original time' do
+            expect(record.foo_time_part).to eq '12:30 pm'
           end
         end
 
-        describe 'setting a String directly' do
-          context 'When the string contains a date and time' do
-            let(:record) { model.new(foo: "#{foo_date_part} #{foo_time_part}") }
-            let(:foo_date_part) { '01/01/2000' }
-            let(:foo_time_part) { '12:30 pm' }
+        context 'When the string contains an iso8601 datetime' do
+          let(:record) { model.new(foo: '2011-12-03T01:00:00Z') }
 
-            it 'does not raise an exception' do
-              expect { subject }.not_to raise_exception
-            end
-
-            it 'sets the attribute to a DateTime object' do
-              expect(subject.foo).to eq Time.zone.parse('01/01/2000 12:30pm')
-            end
-
-            it 'has the original date' do
-              expect(subject.foo_date_part).to eq '01/01/2000'
-            end
-
-            it 'has the original time' do
-              expect(subject.foo_time_part).to eq '12:30 pm'
-            end
+          it 'does not raise an exception' do
+            expect { record }.not_to raise_exception
           end
 
-          context 'When the string contains an iso8601 datetime' do
-            let(:record) { model.new(foo: '2011-12-03T01:00:00Z') }
-
-            it 'does not raise an exception' do
-              expect { subject }.not_to raise_exception
-            end
-
-            it 'sets the attribute to a DateTime object with the correct EST time' do
-              expect(subject.foo).to eq Time.zone.parse('12/2/2011 8:00 pm')
-            end
-
-            it 'has a date' do
-              expect(subject.foo_date_part).to eq '12/2/2011'
-            end
-
-            it 'has a time' do
-              expect(subject.foo_time_part).to eq '8:00 pm'
-            end
+          it 'sets the attribute to a DateTime object with the correct EST time' do
+            expect(record.foo).to eq Time.zone.parse('12/2/2011 8:00 pm')
           end
 
-          context 'When the string contains only a date' do
-            let(:record) { model.new(foo: "#{foo_date_part}") }
-            let(:foo_date_part) { '01/01/2000' }
-
-            it 'does not raise an exception' do
-              expect { subject }.not_to raise_exception
-            end
-
-            it 'sets the attribute to a DateTime object' do
-              expect(subject.foo).to eq Time.zone.parse('01/01/2000 12:00am')
-            end
-
-            it 'has the original date' do
-              expect(subject.foo_date_part).to eq '1/1/2000'
-            end
+          it 'has a date' do
+            expect(record.foo_date_part).to eq '12/2/2011'
+          end
 
-            it 'has midnight for the time input' do
-              expect(subject.foo_time_part).to eq '12:00 am'
-            end
+          it 'has a time' do
+            expect(record.foo_time_part).to eq '8:00 pm'
           end
         end
 
-        describe 'setting a Date directly' do
-          let(:record) { model.new(foo: Date.parse(foo_date_part)) }
-
+        context 'When the string contains only a date' do
+          let(:record) { model.new(foo: "#{foo_date_part}") }
           let(:foo_date_part) { '01/01/2000' }
 
           it 'does not raise an exception' do
-            expect { subject }.not_to raise_exception
+            expect { record }.not_to raise_exception
           end
 
-          it 'sets the attribute to a DateTime object in the current time zone' do
-            expect(subject.foo).to eq Time.zone.parse('01/01/2000 12:00 am')
+          it 'sets the attribute to a DateTime object' do
+            expect(record.foo).to eq Time.zone.parse('01/01/2000 12:00am')
           end
 
           it 'has the original date' do
-            expect(subject.foo_date_part).to eq '1/1/2000'
+            expect(record.foo_date_part).to eq '1/1/2000'
           end
 
           it 'has midnight for the time input' do
-            expect(subject.foo_time_part).to eq '12:00 am'
+            expect(record.foo_time_part).to eq '12:00 am'
           end
         end
+      end
 
-        describe 'setting to nil' do
-          it 'is nil' do
-            record = ModelWithDateTime.new
-            record.foo = Time.current
-            record.foo = nil
-            expect(record.foo).to eq nil
-          end
+      describe 'setting a Date directly' do
+        let(:record) { model.new(foo: Date.parse(foo_date_part)) }
+
+        let(:foo_date_part) { '01/01/2000' }
+
+        it 'does not raise an exception' do
+          expect { record }.not_to raise_exception
         end
 
-        describe 'configuring the datetime format' do
-          let(:record) { model.new(foo: Time.zone.parse('01/09/2000 1:30 pm')) }
+        it 'sets the attribute to a DateTime object in the current time zone' do
+          expect(record.foo).to eq Time.zone.parse('01/01/2000 12:00 am')
+        end
 
-          context 'when the date format is set' do
-            before do
-              MultiparameterDateTime.date_format = '%-m-%-e-%0y'
-            end
+        it 'has the original date' do
+          expect(record.foo_date_part).to eq '1/1/2000'
+        end
 
-            it 'formats the date properly' do
-              expect(subject.foo_date_part).to eq '1-9-00'
-            end
+        it 'has midnight for the time input' do
+          expect(record.foo_time_part).to eq '12:00 am'
+        end
+      end
 
-            it 'uses the default format for the time' do
-              expect(subject.foo_time_part).to eq '1:30 pm'
-            end
+      describe 'setting to nil' do
+        it 'is nil' do
+          record = ModelWithDateTime.new
+          record.foo = Time.current
+          record.foo = nil
+          expect(record.foo).to eq nil
+        end
+      end
 
-            after do
-              MultiparameterDateTime.date_format = MultiparameterDateTime::DEFAULT_DATE_FORMAT
-            end
+      describe 'configuring the datetime format' do
+        let(:record) { model.new(foo: Time.zone.parse('01/09/2000 1:30 pm')) }
+
+        context 'when the date format is set' do
+          before do
+            MultiparameterDateTime.date_format = '%-m-%-e-%0y'
           end
 
-          context 'when the time format is set' do
-            before do
-              MultiparameterDateTime.time_format = '%H%M hours'
-            end
+          it 'formats the date properly' do
+            expect(record.foo_date_part).to eq '1-9-00'
+          end
 
-            it 'formats the time properly' do
-              expect(subject.foo_time_part).to eq '1330 hours'
-            end
+          it 'uses the default format for the time' do
+            expect(record.foo_time_part).to eq '1:30 pm'
+          end
 
-            it 'uses the default format for the date' do
-              expect(subject.foo_date_part).to eq '1/9/2000'
-            end
+          after do
+            MultiparameterDateTime.date_format = MultiparameterDateTime::DEFAULT_DATE_FORMAT
+          end
+        end
 
-            after do
-              MultiparameterDateTime.time_format = MultiparameterDateTime::DEFAULT_TIME_FORMAT
-            end
+        context 'when the time format is set' do
+          before do
+            MultiparameterDateTime.time_format = '%H%M hours'
+          end
+
+          it 'formats the time properly' do
+            expect(record.foo_time_part).to eq '1330 hours'
+          end
+
+          it 'uses the default format for the date' do
+            expect(record.foo_date_part).to eq '1/9/2000'
+          end
+
+          after do
+            MultiparameterDateTime.time_format = MultiparameterDateTime::DEFAULT_TIME_FORMAT
           end
         end
+      end
 
-        describe 'using a custom date string formatter' do
-          let(:foo_date_part) { '1/12/15' }
-          let(:foo_time_part) { '9:30 pm EST' }
+      describe 'using a custom date string formatter' do
+        let(:foo_date_part) { '1/12/15' }
+        let(:foo_time_part) { '9:30 pm EST' }
 
-          context 'when the date string formatter is nil' do
-            it 'parses the unmodified date string' do
-              MultiparameterDateTime.date_string_formatter = nil
-              expect(Time.zone).to receive(:parse)
-                .with("#{foo_date_part} #{foo_time_part}")
+        context 'when the date string formatter is nil' do
+          it 'parses the unmodified date string' do
+            MultiparameterDateTime.date_string_formatter = nil
+            expect(Time.zone).to receive(:parse)
+              .with("#{foo_date_part} #{foo_time_part}")
 
-              model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
-            end
+            model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
           end
+        end
 
-          context 'when the date string formatter is present' do
-            before do
-              class TestFormatter
-                def self.format(date_string)
-                  '12/31/1995'
-                end
+        context 'when the date string formatter is present' do
+          before do
+            class TestFormatter
+              def self.format(date_string)
+                '12/31/1995'
               end
-
-              MultiparameterDateTime.date_string_formatter = TestFormatter
             end
 
-            after do
-              MultiparameterDateTime.date_string_formatter = nil
-            end
+            MultiparameterDateTime.date_string_formatter = TestFormatter
+          end
 
-            it 'uses a formatted date string' do
-              expect(Time.zone).to receive(:parse)
-                .with("#{'12/31/1995'} #{foo_time_part}")
+          after do
+            MultiparameterDateTime.date_string_formatter = nil
+          end
 
-              model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
-            end
+          it 'uses a formatted date string' do
+            expect(Time.zone).to receive(:parse)
+              .with("#{'12/31/1995'} #{foo_time_part}")
+
+            model.new(foo_date_part: foo_date_part, foo_time_part: foo_time_part)
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: multiparameter_date_time
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Case Commons, LLC
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: american_date