human_duration 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 102134bea90036b011d22347bc8f8470f4b4dd15772fd9b9cde82e99e2592245
-  data.tar.gz: 667534f6929deba4722e44a773f7420ea8eab1b35f02df893cac4b2b7e70952b
+  metadata.gz: 986006379227db9abe3115b6d5e8a60eec3db6a7c475227051174b7680d76074
+  data.tar.gz: cf362347d7a8277e96fc164a8a7fb5488376f988cdb0e3fd4cb83a776435687b
 SHA512:
-  metadata.gz: d79a19c23c24ae488e85a95a4d25303894e945575173f04fc1d754a5847aea58e96475bd36de0ba629a358367e1308aec8672a514ff17b686e539b3abdd6eda8
-  data.tar.gz: dee5232b143c5a3a6d24a0c764a3d9374e40cd0d1d0433ff88117804bb0e2ae5862f090c345bf02d553ee8c0d05bbc5ade3acd44ae96027a7c5421458c280574
+  metadata.gz: 18e9f783a647a76c66452ca017e638163d7b90680037e8c5a7185a457d81b611e0b867e2adc734a638a3bbc860316faba101cecab4b79572c066b993368796b2
+  data.tar.gz: e4966f937a6820d76b8cbd5494520bb66265c39024347e3bc9dad0bca4d7f2db270e895eb355a91664ceaa88e9961d0f9aebfb54a734b9d1f444ac8f1568b977

data/.gitignore

@@ -10,3 +10,5 @@
 
 # rspec failure tracking
 .rspec_status
+
+*.gem

data/.travis.yml

@@ -8,7 +8,7 @@ matrix:
   - language: ruby
     rvm: 2.4.4
     before_install:
-      - gem install bundler -v 1.16.1
+      - gem install bundler -v 1.17.3
   - language: ruby
     env: SKIP_INTERPRETER=true
 

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.0.0 (January 25, 2019)
+
+IMPROVEMENTS:
+
+* Move the code inside of a module namespace. ([@TGWolf][])
+* Extend the integer class so that int.human_duration works. ([@TGWolf][])
+* Update the documentation. ([@TGWolf][])
+* Renamed the internal function human_duration to match the module name. ([@TGWolf][])
+* Removed the old static and global access methods as they were a hack. ([@TGWolf][])
+
 ## 1.0.1  (January 17, 2019)
 
 CHANGES:

data/README.md

@@ -28,46 +28,22 @@ Or install it yourself as:
 
 ## Usage
 
-The main function that needs to be called is the 'humanize' function but there are 3 different ways to do this (as show in the code snippet below)
-
-* Class method access - `hd = HumanDuration.new` followed by `hd.humanize(x)` 
-* Static method access - `HumanDurationStatic.humanize(x)`
-* Direct method access - `humanize(x)`
-
-The first method is the main/original method for accessing this function, the other 2 are simple wrappers to the first.
-
 ```ruby
-#!/usr/bin/env ruby
-
-require 'human_duration'
-
-test_value = [-10, 0, 9, 98, 987, 987_6, 987_65, 987_654, 987_654_3, 987_654_32, 987_654_321]
+  require 'human_size'
 
-puts 'Class method access'
+  puts HumanDuration::Duration.human_duration(10)
 
-hd = HumanDuration.new
-test_value.each do |x|
-    puts hd.humanize(x)
-end
+  # or
 
-puts 'Static method access'
-
-puts 'Config: default'
-test_value.each do |x|
-    puts HumanDurationStatic.humanize(x)
-end
-
-puts 'Direct method access'
+  puts 10.human_duration
+```
 
-puts 'Config: default'
-test_value.each do |x|
-    puts humanize(x)
-end
+It is possible to configure the output using one of the options 'compact', 'small' and 'full', 'compact' is the default. For more detailed example please refer to [example/example.rb](https://github.com/WolfSoftware/human_duration/blob/master/example/example.rb)
 
+```ruby
+  HumanDuration::Duration.display_type(output_type)
 ```
 
-It is possible to configure the output using one of the options 'compact', 'small' and 'full', 'compact' isthe default. For more detailed example please refer to [example/example.rb](https://github.com/WolfSoftware/human_duration/blob/master/example/example.rb)
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/example/example.rb

@@ -4,55 +4,38 @@ require 'human_duration'
 
 test_value = [-10, 0, 9, 98, 987, 987_6, 987_65, 987_654, 987_654_3, 987_654_32, 987_654_321]
 
-puts 'Class method access'
+puts 'Class Accessor Method'
 printf "\tConfig: type = conpact [default]\n"
-hd = HumanDuration.new
-test_value.each do |x|
-    printf "\t\t%s\n", hd.humanize(x)
-end
-
-printf "\tConfig: type = short\n"
-hd = HumanDuration.new('type' => 'short')
-test_value.each do |x|
-    printf "\t\t%s\n", hd.humanize(x)
-end
 
-puts "\tConfig: type = full"
-hd = HumanDuration.new('type' => 'full')
-test_value.each do |x|
-    printf "\t\t%s\n", hd.humanize(x)
-end
-
-puts 'Static method access'
-
-printf "\tConfig: type = conpact [default]\n"
 test_value.each do |x|
-    printf "\t\t%s\n", HumanDurationStatic.humanize(x)
+    printf "\t\t%s\n", HumanDuration::Duration.human_duration(x)
 end
 
 printf "\tConfig: type = short\n"
+HumanDuration::Duration.display_type('short')
 test_value.each do |x|
-    printf "\t\t%s\n", HumanDurationStatic.humanize(x)
+    printf "\t\t%s\n", HumanDuration::Duration.human_duration(x)
 end
 
 puts "\tConfig: type = full"
+HumanDuration::Duration.display_type('full')
 test_value.each do |x|
-    printf "\t\t%s\n", HumanDurationStatic.humanize(x)
+    printf "\t\t%s\n", HumanDuration::Duration.human_duration(x)
 end
 
-puts 'Direct method access'
+puts 'String Accessor Method'
 
 printf "\tConfig: type = conpact [default]\n"
 test_value.each do |x|
-    printf "\t\t%s\n", humanize(x)
+    printf "\t\t%s\n", x.human_duration
 end
 
 printf "\tConfig: type = short\n"
 test_value.each do |x|
-    printf "\t\t%s\n", humanize(x)
+    printf "\t\t%s\n", x.human_duration('short')
 end
 
 puts "\tConfig: type = full"
 test_value.each do |x|
-    printf "\t\t%s\n", humanize(x)
+    printf "\t\t%s\n", x.human_duration('full')
 end

data/human_duration.gemspec

@@ -13,7 +13,12 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/WolfSoftware/human_duration"
   spec.license       = "MIT"
 
- spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($/)
+
+  #spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  #  `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  #end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/lib/human_duration/constants.rb

@@ -0,0 +1,5 @@
+module HumanDuration
+    SPLIT_TYPES = [[60, 'second'], [60, 'minute'], [24, 'hour'], [365, 'day'], [1000, 'year']].freeze
+    SHORT_NAME_MAP = { 'second' => 's', 'minute' => 'm', 'hour' => 'h', 'day' => 'd', 'year' => 'y' }.freeze
+    VALID_TYPES = ['compact', 'short', 'full'].freeze
+end

data/lib/human_duration/overloads.rb

@@ -0,0 +1,9 @@
+#
+# Overload the integer class
+#
+class Integer
+    def human_duration(type = 'compact')
+        HumanDuration::Duration.display_type(type)
+        HumanDuration::Duration.human_duration(self)
+    end
+end

data/lib/human_duration/version.rb

@@ -1,3 +1,3 @@
-class HumanDuration
-    VERSION = '1.0.1'.freeze
+module HumanDuration
+    VERSION = '2.0.0'.freeze
 end

data/lib/human_duration.rb

@@ -1,128 +1,107 @@
-require 'human_duration/version'
-
-# -------------------------------------------------------------------------------- #
-# Description                                                                      #
-# -------------------------------------------------------------------------------- #
-# Display elapsed time in a more human readable way.                               #
-# -------------------------------------------------------------------------------- #
-
-# -------------------------------------------------------------------------------- #
-# Description                                                                      #
-# -------------------------------------------------------------------------------- #
-# This is a simple global method to short cut the usage of the class below.        #
-# -------------------------------------------------------------------------------- #
-def humanize(seconds, config = { 'type' => 'compact' })
-    hd = HumanDuration.new(config)
-    hd.humanize(seconds)
-end
-
-# -------------------------------------------------------------------------------- #
-# Description                                                                      #
-# -------------------------------------------------------------------------------- #
-# This is a static access wrapper to the main HumanDuration class below.           #
-# -------------------------------------------------------------------------------- #
-class HumanDurationStatic
-    def self.humanize(seconds, config = { 'type' => 'compact' })
-        hd = HumanDuration.new(config)
-        hd.humanize(seconds)
-    end
-end
-
-# -------------------------------------------------------------------------------- #
-# Description                                                                      #
-# -------------------------------------------------------------------------------- #
-# This is the main class and the one that does all the real work and is called by  #
-# the static access class and the direct method access above.                      #
-# -------------------------------------------------------------------------------- #
-class HumanDuration
-    def initialize(config = { 'type' => 'compact' })
-        @config = config
-
-        @split_types = [[60, 'second'], [60, 'minute'], [24, 'hour'], [365, 'day'], [1000, 'year']]
-        @short_name_map = { 'second' => 's', 'minute' => 'm', 'hour' => 'h', 'day' => 'd', 'year' => 'y' }
-    end
-
-    def humanize(seconds)
-        reset
+require_relative 'human_duration/constants'
+require_relative 'human_duration/overloads'
+require_relative 'human_duration/version'
+
+#
+# docs to do
+#
+module HumanDuration
+    #
+    # docs to do
+    #
+    class Duration
+        $time_values = {}
+        $item_count = 0
+        $output_buffer = ''
+
+        $type = 'compact'
+
+        def self.display_type(type = 'compact')
+            raise ArgumentError.new('Invalid type - Valid options are:- compact, short and full') unless VALID_TYPES.include? type
+
+            $type = type
+        end
 
-        return 'negative' if seconds < 0
-        return 'now' if seconds.zero?
+        def self.human_duration(seconds)
+            reset
 
-        split_seconds(seconds)
-        count_items
-        generate_output
+            return 'negative' if seconds < 0
+            return 'now' if seconds.zero?
 
-        @output_buffer
-    end
+            split_seconds(seconds)
+            count_items
+            generate_output
 
-    private
+            $output_buffer
+        end
 
-    def reset
-        @time_values = {}
-        @item_count = 0
-        @output_buffer = ''
-    end
+        def self.reset
+            $time_values = {}
+            $item_count = 0
+            $output_buffer = ''
+        end
 
-    def pluralize(number)
-        return 's' unless number == 1
+        def self.pluralize(number)
+            return 's' unless number == 1
 
-        ''
-    end
+            ''
+        end
 
-    def comma_or_not(count)
-        return ', ' if count > 1
-        return ' & ' if count == 1 && @config['type'] == 'short'
-        return ' and ' if count == 1
+        def self.comma_or_not(count)
+            return ', ' if count > 1
+            return ' & ' if count == 1 && $type == 'short'
+            return ' and ' if count == 1
 
-        ''
-    end
+            ''
+        end
 
-    def add_time(value, name, plural = true)
-        return if value < 1 && @config['type'] != 'full'
+        def self.add_time(value, name, plural = true)
+            return if value < 1 && $type != 'full'
 
-        @output_buffer << if plural
-                              format('%<value>s %<name>s%<plural>s', value: value, name: name, plural: pluralize(value))
-                          else
-                              format('%<value>s %<name>s', value: value, name: name)
-                          end
-        @item_count -= 1
-        @output_buffer << comma_or_not(@item_count)
-    end
+            $output_buffer << if plural
+                                  format('%<value>s %<name>s%<plural>s', value: value, name: name, plural: pluralize(value))
+                              else
+                                  format('%<value>s %<name>s', value: value, name: name)
+                              end
+            $item_count -= 1
+            $output_buffer << comma_or_not($item_count)
+        end
 
-    def split_seconds(seconds)
-        @split_types.map do |count, name|
-            if seconds > 0
-                seconds, n = seconds.divmod(count)
-                @time_values[name] = n
-            else
-                @time_values[name] = 0
+        def self.split_seconds(seconds)
+            SPLIT_TYPES.map do |count, name|
+                if seconds > 0
+                    seconds, n = seconds.divmod(count)
+                    $time_values[name] = n
+                else
+                    $time_values[name] = 0
+                end
             end
         end
-    end
 
-    def count_items
-        @time_values.each do |_name, value|
-            @item_count += 1 if value > 0 || @config['type'] == 'full'
+        def self.count_items
+            $time_values.each do |_name, value|
+                $item_count += 1 if value > 0 || $type == 'full'
+            end
         end
-    end
 
-    def add_time_long
-        @time_values.reverse_each do |name, value|
-            add_time(value, name)
+        def self.add_time_long
+            $time_values.reverse_each do |name, value|
+                add_time(value, name)
+            end
         end
-    end
 
-    def add_time_short
-        @time_values.reverse_each do |name, value|
-            add_time(value, @short_name_map[name], false)
+        def self.add_time_short
+            $time_values.reverse_each do |name, value|
+                add_time(value, SHORT_NAME_MAP[name], false)
+            end
         end
-    end
 
-    def generate_output
-        if @config['type'] == 'short'
-            add_time_short
-        else
-            add_time_long
+        def self.generate_output
+            if $type == 'short'
+                add_time_short
+            else
+                add_time_long
+            end
         end
     end
 end

data/spec/human_duration_spec.rb

@@ -7,339 +7,235 @@ RSpec.describe HumanDuration do
         expect(HumanDuration::VERSION).not_to be nil
     end
 
-    context 'Class method access' do
+    context 'Class Accessor Method' do
         context 'Using default compact mode' do
             before(:each) do
-                @hd = HumanDuration.new
+                @hd = HumanDuration::Duration
             end
 
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1)).to eql('negative')
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(@hd.human_duration(-1)).to eql('negative')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0)).to eql('now')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(@hd.human_duration(0)).to eql('now')
             end
 
-            it 'says \'1 second\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1)).to eql('1 second')
+            it 'says "1 second" for 1 second (Singular test)' do
+                expect(@hd.human_duration(1)).to eql('1 second')
             end
 
-            it 'says \'10 seconds\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10)).to eql('10 seconds')
+            it 'says "10 seconds" for 10 second (Plural test)' do
+                expect(@hd.human_duration(10)).to eql('10 seconds')
             end
 
-            it 'says \'1 minute\' for 60 seconds' do
-                expect(@hd.humanize(60)).to eql('1 minute')
+            it 'says "1 minute" for 60 seconds' do
+                expect(@hd.human_duration(60)).to eql('1 minute')
             end
 
-            it 'says \'1 hour\' for 3600 seconds' do
-                expect(@hd.humanize(360_0)).to eql('1 hour')
+            it 'says "1 hour" for 3600 seconds' do
+                expect(@hd.human_duration(360_0)).to eql('1 hour')
             end
 
-            it 'says \'1 year\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00)).to eql('1 year')
+            it 'says "1 year" for 31536000 seconds' do
+                expect(@hd.human_duration(315_360_00)).to eql('1 year')
             end
 
-            it 'says \'1 year, 2 hours and 13 seconds\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13)).to eql('1 year, 2 hours and 13 seconds')
+            it 'says "1 year, 2 hours and 13 seconds" for 31543213 seconds' do
+                expect(@hd.human_duration(315_432_13)).to eql('1 year, 2 hours and 13 seconds')
             end
         end
 
         context 'Using short mode' do
             before(:each) do
-                @hd = HumanDuration.new('type' => 'short')
+                @hd = HumanDuration::Duration
+                @hd.display_type('short')
             end
 
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1)).to eql('negative')
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(@hd.human_duration(-1)).to eql('negative')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0)).to eql('now')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(@hd.human_duration(0)).to eql('now')
             end
 
-            it 'says \'1 s\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1)).to eql('1 s')
+            it 'says "1 s" for 1 second (Singular test)' do
+                expect(@hd.human_duration(1)).to eql('1 s')
             end
 
-            it 'says \'10 s\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10)).to eql('10 s')
+            it 'says "10 s" for 10 second (Plural test)' do
+                expect(@hd.human_duration(10)).to eql('10 s')
             end
 
-            it 'says \'1 m\' for 60 seconds' do
-                expect(@hd.humanize(60)).to eql('1 m')
+            it 'says "1 m" for 60 seconds' do
+                expect(@hd.human_duration(60)).to eql('1 m')
             end
 
-            it 'says \'1 h\' for 3600 seconds' do
-                expect(@hd.humanize(360_0)).to eql('1 h')
+            it 'says "1 h" for 3600 seconds' do
+                expect(@hd.human_duration(360_0)).to eql('1 h')
             end
 
-            it 'says \'1 y\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00)).to eql('1 y')
+            it 'says "1 y" for 31536000 seconds' do
+                expect(@hd.human_duration(315_360_00)).to eql('1 y')
             end
 
-            it 'says \'1 y, 2 h & 13 s\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13)).to eql('1 y, 2 h & 13 s')
+            it 'says "1 y, 2 h & 13 s" for 31543213 seconds' do
+                expect(@hd.human_duration(315_432_13)).to eql('1 y, 2 h & 13 s')
             end
         end
 
         context 'Using full mode' do
             before(:each) do
-                @hd = HumanDuration.new('type' => 'full')
+                @hd = HumanDuration::Duration
+                @hd.display_type('full')
             end
 
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1)).to eql('negative')
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(@hd.human_duration(-1)).to eql('negative')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0)).to eql('now')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(@hd.human_duration(0)).to eql('now')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 1 second\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1)).to eql('0 years, 0 days, 0 hours, 0 minutes and 1 second')
+            it 'says "0 years, 0 days, 0 hours, 0 minutes and 1 second" for 1 second (Singular test)' do
+                expect(@hd.human_duration(1)).to eql('0 years, 0 days, 0 hours, 0 minutes and 1 second')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 10 seconds\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10)).to eql('0 years, 0 days, 0 hours, 0 minutes and 10 seconds')
+            it 'says "0 years, 0 days, 0 hours, 0 minutes and 10 seconds" for 10 second (Plural test)' do
+                expect(@hd.human_duration(10)).to eql('0 years, 0 days, 0 hours, 0 minutes and 10 seconds')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 1 minute and 0 seconds\' for 60 seconds' do
-                expect(@hd.humanize(60)).to eql('0 years, 0 days, 0 hours, 1 minute and 0 seconds')
+            it 'says "0 years, 0 days, 0 hours, 1 minute and 0 seconds" for 60 seconds' do
+                expect(@hd.human_duration(60)).to eql('0 years, 0 days, 0 hours, 1 minute and 0 seconds')
             end
 
-            it 'says \'0 years, 0 days, 1 hour, 0 minutes and 0 seconds\' for 3600 seconds' do
-                expect(@hd.humanize(360_0)).to eql('0 years, 0 days, 1 hour, 0 minutes and 0 seconds')
+            it 'says "0 years, 0 days, 1 hour, 0 minutes and 0 seconds" for 3600 seconds' do
+                expect(@hd.human_duration(360_0)).to eql('0 years, 0 days, 1 hour, 0 minutes and 0 seconds')
             end
 
-            it 'says \'1 year, 0 days, 0 hours, 0 minutes and 0 seconds\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00)).to eql('1 year, 0 days, 0 hours, 0 minutes and 0 seconds')
+            it 'says "1 year, 0 days, 0 hours, 0 minutes and 0 seconds" for 31536000 seconds' do
+                expect(@hd.human_duration(315_360_00)).to eql('1 year, 0 days, 0 hours, 0 minutes and 0 seconds')
             end
 
-            it 'says \'1 year, 0 days, 2 hours, 0 minutes and 13 seconds\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13)).to eql('1 year, 0 days, 2 hours, 0 minutes and 13 seconds')
+            it 'says "1 year, 0 days, 2 hours, 0 minutes and 13 seconds" for 31543213 seconds' do
+                expect(@hd.human_duration(315_432_13)).to eql('1 year, 0 days, 2 hours, 0 minutes and 13 seconds')
             end
         end
     end
 
-    context 'Static method access' do
+    context 'String Accessor Method' do
         context 'Using default compact mode' do
-            before(:each) do
-                @hd = HumanDurationStatic
-            end
-
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1)).to eql('negative')
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(-1.human_duration).to eql('negative')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0)).to eql('now')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(0.human_duration).to eql('now')
             end
 
-            it 'says \'1 second\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1)).to eql('1 second')
+            it 'says "1 second" for 1 second (Singular test)' do
+                expect(1.human_duration).to eql('1 second')
             end
 
-            it 'says \'10 seconds\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10)).to eql('10 seconds')
+            it 'says "10 seconds" for 10 second (Plural test)' do
+                expect(10.human_duration).to eql('10 seconds')
             end
 
-            it 'says \'1 minute\' for 60 seconds' do
-                expect(@hd.humanize(60)).to eql('1 minute')
+            it 'says "1 minute" for 60 seconds' do
+                expect(60.human_duration).to eql('1 minute')
             end
 
-            it 'says \'1 hour\' for 3600 seconds' do
-                expect(@hd.humanize(360_0)).to eql('1 hour')
+            it 'says "1 hour" for 3600 seconds' do
+                expect(360_0.human_duration).to eql('1 hour')
             end
 
-            it 'says \'1 year\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00)).to eql('1 year')
+            it 'says "1 year" for 31536000 seconds' do
+                expect(315_360_00.human_duration).to eql('1 year')
             end
 
-            it 'says \'1 year, 2 hours and 13 seconds\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13)).to eql('1 year, 2 hours and 13 seconds')
+            it 'says "1 year, 2 hours and 13 seconds" for 31543213 seconds' do
+                expect(315_432_13.human_duration).to eql('1 year, 2 hours and 13 seconds')
             end
         end
 
         context 'Using short mode' do
-            before(:each) do
-                @hd = HumanDurationStatic
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(-1.human_duration('short')).to eql('negative')
             end
 
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1, 'type' => 'short')).to eql('negative')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(0.human_duration('short')).to eql('now')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0, 'type' => 'short')).to eql('now')
+            it 'says "1 s" for 1 second (Singular test)' do
+                expect(1.human_duration('short')).to eql('1 s')
             end
 
-            it 'says \'1 s\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1, 'type' => 'short')).to eql('1 s')
+            it 'says "10 s" for 10 second (Plural test)' do
+                expect(10.human_duration('short')).to eql('10 s')
             end
 
-            it 'says \'10 s\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10, 'type' => 'short')).to eql('10 s')
+            it 'says "1 m" for 60 seconds' do
+                expect(60.human_duration('short')).to eql('1 m')
             end
 
-            it 'says \'1 m\' for 60 seconds' do
-                expect(@hd.humanize(60, 'type' => 'short')).to eql('1 m')
+            it 'says "1 h" for 3600 seconds' do
+                expect(360_0.human_duration('short')).to eql('1 h')
             end
 
-            it 'says \'1 h\' for 3600 seconds' do
-                expect(@hd.humanize(360_0, 'type' => 'short')).to eql('1 h')
+            it 'says "1 y" for 31536000 seconds' do
+                expect(315_360_00.human_duration('short')).to eql('1 y')
             end
 
-            it 'says \'1 y\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00, 'type' => 'short')).to eql('1 y')
-            end
-
-            it 'says \'1 y, 2 h & 13 s\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13, 'type' => 'short')).to eql('1 y, 2 h & 13 s')
+            it 'says "1 y, 2 h & 13 s" for 31543213 seconds' do
+                expect(315_432_13.human_duration('short')).to eql('1 y, 2 h & 13 s')
             end
         end
 
         context 'Using full mode' do
-            before(:each) do
-                @hd = HumanDurationStatic
+            it 'says "negative" for seconds < 0 (Negative value test)' do
+                expect(-1.human_duration('full')).to eql('negative')
             end
 
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(@hd.humanize(-1, 'type' => 'full')).to eql('negative')
+            it 'says "now" for 0 seconds (Zero second test)' do
+                expect(0.human_duration('full')).to eql('now')
             end
 
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(@hd.humanize(0, 'type' => 'full')).to eql('now')
+            it 'says "0 years, 0 days, 0 hours, 0 minutes and 1 second" for 1 second (Singular test)' do
+                expect(1.human_duration('full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 1 second')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 1 second\' for 1 second (Singular test)' do
-                expect(@hd.humanize(1, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 1 second')
+            it 'says "0 years, 0 days, 0 hours, 0 minutes and 10 seconds" for 10 second (Plural test)' do
+                expect(10.human_duration('full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 10 seconds')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 10 seconds\' for 10 second (Plural test)' do
-                expect(@hd.humanize(10, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 10 seconds')
+            it 'says "0 years, 0 days, 0 hours, 1 minute and 0 seconds" for 60 seconds' do
+                expect(60.human_duration('full')).to eql('0 years, 0 days, 0 hours, 1 minute and 0 seconds')
             end
 
-            it 'says \'0 years, 0 days, 0 hours, 1 minute and 0 seconds\' for 60 seconds' do
-                expect(@hd.humanize(60, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 1 minute and 0 seconds')
+            it 'says "0 years, 0 days, 1 hour, 0 minutes and 0 seconds" for 3600 seconds' do
+                expect(360_0.human_duration('full')).to eql('0 years, 0 days, 1 hour, 0 minutes and 0 seconds')
             end
 
-            it 'says \'0 years, 0 days, 1 hour, 0 minutes and 0 seconds\' for 3600 seconds' do
-                expect(@hd.humanize(360_0, 'type' => 'full')).to eql('0 years, 0 days, 1 hour, 0 minutes and 0 seconds')
+            it 'says "1 year, 0 days, 0 hours, 0 minutes and 0 seconds" for 31536000 seconds' do
+                expect(315_360_00.human_duration('full')).to eql('1 year, 0 days, 0 hours, 0 minutes and 0 seconds')
             end
 
-            it 'says \'1 year, 0 days, 0 hours, 0 minutes and 0 seconds\' for 31536000 seconds' do
-                expect(@hd.humanize(315_360_00, 'type' => 'full')).to eql('1 year, 0 days, 0 hours, 0 minutes and 0 seconds')
-            end
-
-            it 'says \'1 year, 0 days, 2 hours, 0 minutes and 13 seconds\' for 31543213 seconds' do
-                expect(@hd.humanize(315_432_13, 'type' => 'full')).to eql('1 year, 0 days, 2 hours, 0 minutes and 13 seconds')
+            it 'says "1 year, 0 days, 2 hours, 0 minutes and 13 seconds" for 31543213 seconds' do
+                expect(315_432_13.human_duration('full')).to eql('1 year, 0 days, 2 hours, 0 minutes and 13 seconds')
             end
         end
     end
 
-    context 'Direct method access' do
-        context 'Using default compact mode' do
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(humanize(-1)).to eql('negative')
-            end
-
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(humanize(0)).to eql('now')
-            end
-
-            it 'says \'1 second\' for 1 second (Singular test)' do
-                expect(humanize(1)).to eql('1 second')
-            end
-
-            it 'says \'10 seconds\' for 10 second (Plural test)' do
-                expect(humanize(10)).to eql('10 seconds')
-            end
-
-            it 'says \'1 minute\' for 60 seconds' do
-                expect(humanize(60)).to eql('1 minute')
-            end
-
-            it 'says \'1 hour\' for 3600 seconds' do
-                expect(humanize(360_0)).to eql('1 hour')
-            end
-
-            it 'says \'1 year\' for 31536000 seconds' do
-                expect(humanize(315_360_00)).to eql('1 year')
-            end
-
-            it 'says \'1 year, 2 hours and 13 seconds\' for 31543213 seconds' do
-                expect(humanize(315_432_13)).to eql('1 year, 2 hours and 13 seconds')
-            end
+    context 'Test Error Handling' do
+        it 'Test invalid display type raises an exception direct call' do
+            expect { HumanDuration::Duration.display_type('invalid') }.to raise_error(ArgumentError, 'Invalid type - Valid options are:- compact, short and full')
         end
 
-        context 'Using short mode' do
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(humanize(-1, 'type' => 'short')).to eql('negative')
-            end
-
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(humanize(0, 'type' => 'short')).to eql('now')
-            end
-
-            it 'says \'1 s\' for 1 second (Singular test)' do
-                expect(humanize(1, 'type' => 'short')).to eql('1 s')
-            end
-
-            it 'says \'10 s\' for 10 second (Plural test)' do
-                expect(humanize(10, 'type' => 'short')).to eql('10 s')
-            end
-
-            it 'says \'1 m\' for 60 seconds' do
-                expect(humanize(60, 'type' => 'short')).to eql('1 m')
-            end
-
-            it 'says \'1 h\' for 3600 seconds' do
-                expect(humanize(360_0, 'type' => 'short')).to eql('1 h')
-            end
-
-            it 'says \'1 y\' for 31536000 seconds' do
-                expect(humanize(315_360_00, 'type' => 'short')).to eql('1 y')
-            end
-
-            it 'says \'1 y, 2 h & 13 s\' for 31543213 seconds' do
-                expect(humanize(315_432_13, 'type' => 'short')).to eql('1 y, 2 h & 13 s')
-            end
-        end
-
-        context 'Using full mode' do
-            it 'says negative for seconds < 0 (Negative value test)' do
-                expect(humanize(-1, 'type' => 'full')).to eql('negative')
-            end
-
-            it 'says now for 0 seconds (Zero second test)' do
-                expect(humanize(0, 'type' => 'full')).to eql('now')
-            end
-
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 1 second\' for 1 second (Singular test)' do
-                expect(humanize(1, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 1 second')
-            end
-
-            it 'says \'0 years, 0 days, 0 hours, 0 minutes and 10 seconds\' for 10 second (Plural test)' do
-                expect(humanize(10, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 0 minutes and 10 seconds')
-            end
-
-            it 'says \'0 years, 0 days, 0 hours, 1 minute and 0 seconds\' for 60 seconds' do
-                expect(humanize(60, 'type' => 'full')).to eql('0 years, 0 days, 0 hours, 1 minute and 0 seconds')
-            end
-
-            it 'says \'0 years, 0 days, 1 hour, 0 minutes and 0 seconds\' for 3600 seconds' do
-                expect(humanize(360_0, 'type' => 'full')).to eql('0 years, 0 days, 1 hour, 0 minutes and 0 seconds')
-            end
-
-            it 'says \'1 year, 0 days, 0 hours, 0 minutes and 0 seconds\' for 31536000 seconds' do
-                expect(humanize(315_360_00, 'type' => 'full')).to eql('1 year, 0 days, 0 hours, 0 minutes and 0 seconds')
-            end
-
-            it 'says \'1 year, 0 days, 2 hours, 0 minutes and 13 seconds\' for 31543213 seconds' do
-                expect(humanize(315_432_13, 'type' => 'full')).to eql('1 year, 0 days, 2 hours, 0 minutes and 13 seconds')
-            end
+        it 'Test invalid display type raises an exception indirect call' do
+            expect { 0.human_duration('invalid') }.to raise_error(ArgumentError, 'Invalid type - Valid options are:- compact, short and full')
         end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: human_duration
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Tim Gurney aka Wolf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-17 00:00:00.000000000 Z
+date: 2019-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,8 @@ files:
 - example/example.rb
 - human_duration.gemspec
 - lib/human_duration.rb
+- lib/human_duration/constants.rb
+- lib/human_duration/overloads.rb
 - lib/human_duration/version.rb
 - spec/human_duration_spec.rb
 - spec/spec_helper.rb