dtg 4.0.1 → 5.0.0

data/spec/dtg/date_time_ext_spec.rb

@@ -0,0 +1,175 @@
+RSpec.describe DateTime do
+  # Set Time Zone before tests
+  before { Time.zone = 'UTC' }
+
+  let(:time) { described_class.now { include DateTimeGroup } }
+
+  describe '#to_dtg' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'converts and formats as dtg' do
+          (:a..:z).to_set.delete(:j).each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone]).strftime(
+                "%d%H%M#{zone.upcase.to_s} %b %y"
+              )
+            )
+          end
+          # :j is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg(:j)).to eq(time.format(:j))
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'converts and formats as dtg' do
+          (:A..:Z).to_set.delete(:J).each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase]).strftime(
+                "%d%H%M#{zone.to_s} %b %y"
+              )
+            )
+          end
+          # :J is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg(:J)).to eq(time.format(:j))
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'converts and formats as dtg' do
+          ('a'..'z').to_set.delete('j').each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.to_sym]).strftime(
+                "%d%H%M#{zone.upcase} %b %y"
+              )
+            )
+          end
+          # 'j' is separate because there is no local timezone identifier
+          # it just gets returned and formatted
+          expect(time.to_dtg('j')).to eq(time.format(:j))
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'converts and formats as dtg' do
+          ('A'..'Z').to_set.delete('J').each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase.to_sym])
+                .strftime("%d%H%M#{zone} %b %y")
+            )
+          end
+          # 'J' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg('J')).to eq(time.format(:j))
+        end
+      end
+    end
+  end
+
+  describe '#format' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'formats to dtg standard' do
+          (:a..:z).each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.upcase.to_s} %b %y")
+            )
+          end
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'formats to dtg standard' do
+          (:A..:Z).each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.to_s} %b %y")
+            )
+          end
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'formats to dtg standard' do
+          ('a'..'z').each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.upcase} %b %y")
+            )
+          end
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'formats to dtg standard' do
+          ('A'..'Z').each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone} %b %y")
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe '#convert' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'returns converted time to new zone' do
+          (:a..:z).to_set.delete(:j).each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone])
+            )
+          end
+          # :j is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert(:j)).to eq(time)
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'returns converted time to new zone' do
+          (:A..:Z).to_set.delete(:J).each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase])
+            )
+          end
+          # :J is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert(:J)).to eq(time)
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'returns converted time to new zone' do
+          ('a'..'z').to_set.delete('j').each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.to_sym])
+            )
+          end
+          # 'j' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert('j')).to eq(time)
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'returns converted time to new zone' do
+          ('A'..'Z').to_set.delete('J').each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase.to_sym])
+            )
+          end
+          # 'J' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert('J')).to eq(time)
+        end
+      end
+    end
+  end
+end

data/spec/dtg/date_time_group_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe DateTimeGroup do
+  # Set Time Zone before tests: ActiveSupport::TimeWithZone needs this or will nil:nilObject (e.g. Time.zone.now)
+  before do
+    # UTC is a fair zone right?
+    Time.zone = 'UTC'
+  end
+
+  describe '#dtg' do
+    context 'when the object is a DateTime' do
+      let(:dummy) { DateTime.new { include described_class } }
+
+      it 'returns datetime in a string' do
+        expect(dummy.dtg).to eq(
+          "DTG gem is natively integrated with this class: #{dummy.class}"
+        )
+      end
+    end
+
+    context 'when the object is a Time' do
+      let(:dummy) { Time.new { include described_class } }
+
+      it 'returns time in a string' do
+        expect(dummy.dtg).to eq(
+          "DTG gem is natively integrated with this class: #{dummy.class}"
+        )
+      end
+    end
+
+    context 'when the object is an ActiveSupport::TimeWithZone' do
+      # ActiveSupport::TimeWithZone.new is not allowed to instantiate empty class
+      let(:dummy) { Time.zone.now { include described_class } }
+
+      it 'returns the ActiveSupport::TimeWithZone in a string' do
+        expect(dummy.dtg).to eq(
+          "DTG gem is natively integrated with this class: #{dummy.class}"
+        )
+      end
+    end
+  end
+
+  describe '.parse' do
+    it 'parses a dtg into its parts' do
+      time = Time.now.convert(:z)
+      dtg = time.to_dtg(:z)
+      parsed = described_class.parse(dtg)
+      expect(parsed[:day]).to eq(time.strftime('%d').to_s)
+      expect(parsed[:hour]).to eq(time.strftime('%H').to_s)
+      expect(parsed[:minute]).to eq(time.strftime('%M').to_s)
+      expect(parsed[:zone]).to eq('Z')
+      expect(parsed[:month]).to eq(time.strftime('%b'))
+      expect(parsed[:year]).to eq(time.strftime('%y'))
+    end
+  end
+
+  describe '.from_dtg' do
+    it 'converts from a dtg into the proper time' do
+      time = Time.now.convert(:z)
+      dtg = time.to_dtg(:z)
+      # anything less than minutes is lost in a DTG
+      time = time.change(usec: 0)
+      time = time.change(sec: 0)
+      expect(described_class.from_dtg(dtg)).to eq(time)
+    end
+  end
+
+  describe '.convert' do
+    it 'converts a dtg into a different zoned dtg' do
+      time = Time.now.convert(:z)
+      dtg = time.to_dtg(:z)
+      expect(described_class.convert(dtg, :w)).to eq(time.to_dtg(:w))
+    end
+  end
+end

data/spec/dtg/format_spec.rb

@@ -0,0 +1,99 @@
+RSpec.describe Format do
+  describe 'FORMAT' do
+    it 'shows a complete DTG size' do
+      expect(Format::FORMAT[:size]).to eq(14)
+    end
+
+    it 'shows the day field size' do
+      expect(Format::FORMAT[:size_day]).to eq(2)
+    end
+
+    it 'shows the hour field size' do
+      expect(Format::FORMAT[:size_hour]).to eq(2)
+    end
+
+    it 'shows the zone field size' do
+      expect(Format::FORMAT[:size_zone]).to eq(1)
+    end
+
+    it 'shows the month field size' do
+      expect(Format::FORMAT[:size_month]).to eq(3)
+    end
+
+    it 'shows the year field size' do
+      expect(Format::FORMAT[:size_year]).to eq(2)
+    end
+
+    it 'shows the day field start position' do
+      expect(Format::FORMAT[:day_start]).to eq(0)
+    end
+
+    it 'shows the day field end position' do
+      expect(Format::FORMAT[:day_end]).to eq(1)
+    end
+
+    it 'shows the day field position range' do
+      expect(Format::FORMAT[:day_range]).to eq(0..1)
+    end
+
+    it 'shows the hour field start position' do
+      expect(Format::FORMAT[:hour_start]).to eq(2)
+    end
+
+    it 'shows the hour field end position' do
+      expect(Format::FORMAT[:hour_end]).to eq(3)
+    end
+
+    it 'shows the hour field position range' do
+      expect(Format::FORMAT[:hour_range]).to eq(2..3)
+    end
+
+    it 'shows the minute field start position' do
+      expect(Format::FORMAT[:minute_start]).to eq(4)
+    end
+
+    it 'shows the minute field end position' do
+      expect(Format::FORMAT[:minute_end]).to eq(5)
+    end
+
+    it 'shows the minute field position range' do
+      expect(Format::FORMAT[:minute_range]).to eq(4..5)
+    end
+
+    it 'shows the zone field start position' do
+      expect(Format::FORMAT[:zone_start]).to eq(6)
+    end
+
+    it 'shows the zone field end position' do
+      expect(Format::FORMAT[:zone_end]).to eq(6)
+    end
+
+    it 'shows the zone field position range' do
+      expect(Format::FORMAT[:zone_range]).to eq(6..6)
+    end
+
+    it 'shows the month field start position' do
+      expect(Format::FORMAT[:month_start]).to eq(8)
+    end
+
+    it 'shows the month field end position' do
+      expect(Format::FORMAT[:month_end]).to eq(10)
+    end
+
+    it 'shows the month field position range' do
+      expect(Format::FORMAT[:month_range]).to eq(8..10)
+    end
+
+    it 'shows the year field start position' do
+      expect(Format::FORMAT[:year_start]).to eq(12)
+    end
+
+    it 'shows the year field end position' do
+      expect(Format::FORMAT[:year_end]).to eq(13)
+    end
+
+    it 'shows the year field position range' do
+      expect(Format::FORMAT[:year_range]).to eq(12..13)
+    end
+  end
+end

data/spec/dtg/time_ext_spec.rb

@@ -0,0 +1,175 @@
+RSpec.describe Time do
+  # Set Time Zone before tests
+  before { described_class.zone = 'UTC' }
+
+  let(:time) { described_class.now { include DateTimeGroup } }
+
+  describe '#to_dtg' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'converts and formats as dtg' do
+          (:a..:z).to_set.delete(:j).each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone]).strftime(
+                "%d%H%M#{zone.upcase.to_s} %b %y"
+              )
+            )
+          end
+          # :j is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg(:j)).to eq(time.format(:j))
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'converts and formats as dtg' do
+          (:A..:Z).to_set.delete(:J).each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase]).strftime(
+                "%d%H%M#{zone.to_s} %b %y"
+              )
+            )
+          end
+          # :J is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg(:J)).to eq(time.format(:j))
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'converts and formats as dtg' do
+          ('a'..'z').to_set.delete('j').each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.to_sym]).strftime(
+                "%d%H%M#{zone.upcase} %b %y"
+              )
+            )
+          end
+          # 'j' is separate because there is no local timezone identifier
+          # it just gets returned and formatted
+          expect(time.to_dtg('j')).to eq(time.format(:j))
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'converts and formats as dtg' do
+          ('A'..'Z').to_set.delete('J').each do |zone|
+            expect(time.to_dtg(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase.to_sym])
+                .strftime("%d%H%M#{zone} %b %y")
+            )
+          end
+          # 'J' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.to_dtg('J')).to eq(time.format(:j))
+        end
+      end
+    end
+  end
+
+  describe '#format' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'formats to dtg standard' do
+          (:a..:z).each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.upcase.to_s} %b %y")
+            )
+          end
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'formats to dtg standard' do
+          (:A..:Z).each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.to_s} %b %y")
+            )
+          end
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'formats to dtg standard' do
+          ('a'..'z').each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone.upcase} %b %y")
+            )
+          end
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'formats to dtg standard' do
+          ('A'..'Z').each do |zone|
+            expect(time.format(zone)).to eq(
+              time.strftime("%d%H%M#{zone} %b %y")
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe '#convert' do
+    context 'when zone is a symbol' do
+      context 'when symbol is lowercase' do
+        it 'returns converted time to new zone' do
+          (:a..:z).to_set.delete(:j).each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone])
+            )
+          end
+          # :j is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert(:j)).to eq(time)
+        end
+      end
+
+      context 'when symbol is uppercase' do
+        it 'returns converted time to new zone' do
+          (:A..:Z).to_set.delete(:J).each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase])
+            )
+          end
+          # :J is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert(:J)).to eq(time)
+        end
+      end
+    end
+
+    context 'when zone is a single character string' do
+      context 'when string is lowercase' do
+        it 'returns converted time to new zone' do
+          ('a'..'z').to_set.delete('j').each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.to_sym])
+            )
+          end
+          # 'j' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert('j')).to eq(time)
+        end
+      end
+
+      context 'when string is uppercase' do
+        it 'returns converted time to new zone' do
+          ('A'..'Z').to_set.delete('J').each do |zone|
+            expect(time.convert(zone)).to eq(
+              time.in_time_zone(Zones::UTC_ZONES[zone.downcase.to_sym])
+            )
+          end
+          # 'J' is separate because there is no local timezone identifier,
+          # it just gets returned and formatted
+          expect(time.convert('J')).to eq(time)
+        end
+      end
+    end
+  end
+end