dtg 3.0.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47fcb47b9cfc284a3b42dbcc6d24c0410aa118ecd2042927a03d257a603fd418
-  data.tar.gz: 74290a6d0acbe433ba776eb30a54276a3cff61e3d7c9bf940777d8b6278e0800
+  metadata.gz: 9baca4fefe520ca79708b64acb9ff54caa9dc5f5e4757af1da08040afe1310cd
+  data.tar.gz: 366d56c174427106189bfcbf316b1b366bdb47de0f7319a5fb7685d907e17cbb
 SHA512:
-  metadata.gz: '0559e9975d5cba18e10097ba63781ce6db455724d8c8d1b40f4c03811a27279c04aaef16a4e58e8545b34fe384410d5f02a3e81666ec9e7fec2c6b0edb8a1b0c'
-  data.tar.gz: f76fa8ab12623ddfe75a047705b8d3deae5999408eda1c0ef12cd29b5a0c3f81cec2f510b4bfe0d317b1787cdaab9a2ed8bc9c6bc1763b5c2465f9d3f0a0798c
+  metadata.gz: 2d90ad0ef678fe647a554bb38ad1f1b4ccfe7acd4b4005855422259f1d4c5ae8690ff385c949109bf8f0480dbf37d8c5ffd4d647e897f9313f7f3886988e07b5
+  data.tar.gz: c228294640713a51dcc3c1d5f63af0106643b29b38afe0e8e1c1c3cc07aa2f796caacfa4543077782cc4f738212b06792cf5cada51cc9cfd3ab22f1b92c62eaa

data/Gemfile

@@ -0,0 +1,49 @@
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+# Declare your gem's dependencies in dtg.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# Used to test this gem for compatability and functionality
+group :development, :test do
+  gem "cadre"
+
+  # Used for test suite reporting
+  gem 'coveralls', require: false
+
+  # Find places where code can be sped up
+  gem "fasterer"
+
+  # Code quality
+  gem "guard"
+  gem "guard-reek"
+  gem "guard-rspec"
+  gem "guard-rubocop"
+
+  # Check code quality extensions on git actions
+  gem "overcommit"
+
+  # Detect code smells for bad/strage code
+  gem "reek"
+
+  # RSpec for testing suite
+  gem "rspec"
+  gem "rspec-core"
+  gem "rspec-expectations"
+  gem "rspec-mocks"
+  gem "rspec-support"
+
+  # Code quality enforcer
+  gem "rubocop", "0.65.0"
+  gem "rubocop-rspec"
+
+  # StandardRB checks for consistent ruby conventions
+  gem "standard"
+end

data/Rakefile

@@ -1,27 +1,4 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Dtg'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-require 'bundler/gem_tasks'
-
-# RSpec rake task to run rspec on default - needed by travis
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-
-  task :default => :spec
-rescue LoadError
-  # no rspec available
-end
+# desc "Explaining what the task does"
+# task :dtg do
+#   # Task goes here
+# end

data/dtg.gemspec

@@ -0,0 +1,47 @@
+# Ensure all of library added to gem
+$:.push File.expand_path("lib", __dir__)
+
+# Maintain your gem's version:
+require "dtg/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |spec|
+  spec.name        = "dtg"
+  spec.version     = Dtg::VERSION
+  spec.authors     = ["SolarisFlare"]
+  spec.email       = ["shadowbomb20@gmail.com"]
+  spec.homepage    = "https://github.com/SolarisFlare/dtg/"
+  spec.summary     = "DTG converts from a DateTime to a DTG"
+  spec.description = "A DTG is a DateTimeGroup which is used in the military to save time.  DTG 
+                      are saved in the format DDHHMML MMM YY, where D is day, H is hour, L is 
+                      letter, M is month, and Y is year.  The Month is the 3 character 
+                      representation such as JAN for January, MAY for May, DEC for December and so 
+                      on.  Year is only the last two digits of the year e.g. 2019 is just 19.  The 
+                      letter is the zone code such as W for whiskey which is HST, Z for zulu which 
+                      is GMT, A-Z are the zones used."
+  spec.license     = "MIT"
+  spec.required_rubygems_version = Gem::Requirement.new(">= 0") if spec.respond_to? \
+                                                                  :required_rubygems_version=
+  spec.files = Dir["Gemfile", "dtg.gemspec", "Rakefile", "lib/**/*"]
+  spec.test_files = Dir["spec/**/*"]
+  spec.rubygems_version = %q{1.6.2}
+
+  # Active support is necessary for ActiveSupport::TimeWithZone integration
+  spec.add_dependency "activesupport"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  if spec.respond_to? :specification_version then
+    spec.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    end
+  end
+end

data/lib/dtg.rb

@@ -1,35 +1,15 @@
-require "dtg/railtie"
-require "dtg/zones"
-require "dtg/date_time_ext"
-require "dtg/time_ext"
-require "dtg/active_support/time_with_zone_ext"
+require_relative "dtg/version"
+require_relative "dtg/date_time_group"
+require_relative "dtg/zones"
+require_relative "dtg/time_ext"
+require_relative "dtg/date_time_ext"
+require_relative "dtg/active_support/time_with_zone_ext"
 
 module Dtg
-  # Zones module has timezones (UTC_Zones) as dtg listings
-  include Zones
+  # Time zone safety setting
+  Time.zone ||= 'UTC'
 
-  # DTG Test to determine if was injected properly into class
-  def dtg
-    "DTG gem is natively integrated with this class: #{self.class}"
-  end
-
-  # Convert the object to the proper zone and then format as dtg in zone
-  def to_dtg(zone = :z)
-    convert(zone).format(zone)
-  end
-
-  # Format the object into specified zone (as dtg)
-  def format(zone = :z)
-    key = zone.downcase.to_sym
-    raise "Error: #{zone} is not a valid zone" unless UTC_ZONES.key?(key)
-    dtg = "%d%H%M#{key.upcase.to_s} %b %y"
-    strftime(dtg)
-  end
-
-  # Convert the object into the proper zone specified
-  def convert(zone = :z)
-    key = zone.downcase.to_sym
-    raise "Error: #{zone} is not a valid zone" unless UTC_ZONES.key?(key)
-    key == :j ? self.dup : self.in_time_zone(UTC_ZONES[key])
+  def self.dtg
+    "DTG gem is active"
   end
 end

data/lib/dtg/active_support/time_with_zone_ext.rb

@@ -1,6 +1,7 @@
-require 'dtg'
+require_relative "../date_time_group"
+require "active_support/time"
 
 class ActiveSupport::TimeWithZone
   # Insert DTG Methods into this class
-  include Dtg
+  include DateTimeGroup
 end

data/lib/dtg/date_time_ext.rb

@@ -1,6 +1,9 @@
-require 'dtg'
+require_relative "date_time_group"
+require "date"
+require "active_support/core_ext/date"
+# require "active_support/core_ext/date_and_time"
 
 class DateTime
   # Insert DTG Methods into this class
-  include Dtg
+  include DateTimeGroup
 end

data/lib/dtg/date_time_group.rb

@@ -0,0 +1,31 @@
+require_relative "zones"
+
+module DateTimeGroup
+  # Zones module has timezones (UTC_Zones) as dtg listings
+  include Zones
+
+  # Convert the object to the proper zone and then format as dtg in zone
+  def to_dtg(zone = :z)
+    convert(zone).format(zone)
+  end
+
+  # DTG Test to determine if was injected properly into class
+  def dtg
+    "DTG gem is natively integrated with this class: #{self.class}"
+  end
+
+  # Format the object into specified zone (as dtg)
+  def format(zone = :z)
+    key = zone.downcase.to_sym
+    raise "Error: #{zone} is not a valid zone" unless UTC_ZONES.key?(key)
+    dtg = "%d%H%M#{key.upcase.to_s} %b %y"
+    strftime(dtg)
+  end
+
+  # Convert the object into the proper zone specified
+  def convert(zone = :z)
+    key = zone.downcase.to_sym
+    raise "Error: #{zone} is not a valid zone" unless UTC_ZONES.key?(key)
+    key == :j ? self.dup : self.in_time_zone(UTC_ZONES[key])
+  end
+end

data/lib/dtg/time_ext.rb

@@ -1,6 +1,7 @@
-require 'dtg'
+require_relative "date_time_group"
+require "active_support/core_ext/time"
 
 class Time
   # Insert DTG Methods into this class
-  include Dtg
+  include DateTimeGroup
 end

data/lib/dtg/version.rb

@@ -1,4 +1,4 @@
 module Dtg
   # DTG version of gem
-  VERSION = "3.0.2"
+  VERSION = "4.0.0"
 end

data/spec/lib/dtg/active_support/time_with_zone_ext_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+RSpec.describe ActiveSupport::TimeWithZone do
+  # ActiveSupport::TimeWithZone preferred method of instantiation is with Time.zone.now, not new
+  let(:time) { Time.zone.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/lib/dtg/date_time_ext_spec.rb

@@ -0,0 +1,163 @@
+require "spec_helper"
+
+RSpec.describe DateTime do
+  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