easy_to_dictate_numbers 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd9d609744cb38572a1749541f3dedcdb11b4bfd01f0287fb4169b76cd3897b5
-  data.tar.gz: 8b518d7a45d962c5f446bb115e59fa2fae07fe0b08a9f759b79b8e9e20c59065
+  metadata.gz: 780e66635c5b14977a37fbd6136d0f818aceab29d48753184e1e5b0285502a61
+  data.tar.gz: 81a6072f1e4f44c34babb9288e7a3c0250763a1f22e49f67a9fbe1fb89dea852
 SHA512:
-  metadata.gz: 1b33d240adb36083fb18526be8629854e7763a5b4a4d12ce75fc7635ebbe49584801bdeed70badc2c39e5f7b993910c54c0edb0bf80e8c2036d817ec3205f2ea
-  data.tar.gz: 90be7ee0755d5a25e8573c31876d495ca509be1fd923e70d9cdb3a74db32909f46a5d0b9dc543a5d37ba7be7f2f5fb616dd31aab92f7149a8881af49a442edac
+  metadata.gz: b36b50433deb8b0778bc81ccc1a08a55b4cf202c60af927a88858eed1b9e90611e4e4f0081ba8f079a168f87ff58107ecdc15bf65894a78036982d8f2f20fafc
+  data.tar.gz: 90f026f4a7f1df4ea53d18625b0632925b2f46e31c0353c906e97b332f8360cf9faa0ab21c2be7721943022c668c638258114ceb5ceda9fe6c68e5643f8ca491

data/CHANGELOG.md

@@ -11,3 +11,11 @@
 ## [0.1.2] - 2024-01-14
 
 - Moved extend primitives require to lib/easy_to_dictate_numbers.rb.
+
+## [0.1.3] - 2024-01-14
+
+- Refactored to cover special cases:
+  - 100  -> one hundred
+  - 1000 -> one thousand
+  - 2334 -> twenty three thirty four
+- Extended string with `to_dictable_number`

data/README.md

@@ -30,9 +30,29 @@ To use EasyToDictateNumbers, simply call the `to_dictable` method on any `Intege
 require 'easy_to_dictate_numbers'
 
 puts 123.to_dictable
-# Output: "one two three"
+# Output: "one twenty three"
+
+puts "1243".to_dictable_number
+# Output: "twelve forty three"
 ```
 
+## Example
+List of samples from specs:
+
+- `100` is converted to `one hundred`
+- `123` is converted to `one twenty three`
+- `'001'` is converted to `zero zero one`
+- `'010'` is converted to `zero ten`
+- `'0000'` is converted to `zero zero zero zero`
+- `1000` is converted to `one thousand`
+- `4321` is converted to `forty three twenty one`
+- `4300` is converted to `forty three hundred`
+- `'0001'` is converted to `zero zero zero one`
+- `'0010'` is converted to `zero zero ten`
+- `'0100'` is converted to `zero one hundred`
+
+Please note that the numbers in quotes are treated as strings, which allows leading zeroes to be preserved.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/easy_to_dictate_numbers.gemspec

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'lib/easy_to_dictate_numbers/version'
-require_relative 'lib/easy_to_dictate_numbers/extend_primitives'
 
 Gem::Specification.new do |spec|
   spec.name = 'easy_to_dictate_numbers'

data/lib/easy_to_dictate_numbers/easy_to_dictate_numbers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module EasyToDictateNumbers
+  class Error < StandardError; end
+
+  class NonNumberCharactersPresent < StandardError
+    def initialize
+      super('Non-number characters present')
+    end
+  end
+
+  class NumberToDictable
+    ONES = %w[zero one two three four five six seven eight nine].freeze
+    TEENS = %w[ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen].freeze
+    TENS = %w[twenty thirty forty fifty sixty seventy eighty ninety].freeze
+
+    class << self
+      def number_to_words(number_to_dictate)
+        number_as_string = number_to_dictate.to_s
+        validate_number(number_as_string)
+
+        leading_zeroes_words = leading_zeroes_to_words(number_as_string)
+
+        number_without_leading_zeroes = number_without_leading_zeroes(number_as_string)
+        number_without_leading_zeroes_words = number_without_leading_zeroes_to_words(number_without_leading_zeroes)
+
+        [leading_zeroes_words, number_without_leading_zeroes_words].reject(&:empty?).join(' ')
+      end
+
+      def validate_number(number_as_string)
+        raise NonNumberCharactersPresent if number_as_string.match?(/[^0-9]/)
+      end
+
+      def number_without_leading_zeroes_to_words(number_as_string)
+        case number_as_string.length
+        when 1 then one_digit_number_to_words(number_as_string)
+        when 2 then two_digit_number_to_words(number_as_string)
+        when 3 then three_digit_number_to_words(number_as_string)
+        when 4 then four_digit_number_to_words(number_as_string)
+        else large_number_to_words(number_as_string)
+        end
+      end
+
+      def repeat_zeroes(number_of_zeroes)
+        number_of_zeroes.times.map { ONES[0] }.join(' ')
+      end
+
+      def leading_zeroes_to_words(number_as_string)
+        leading_zeroes = number_as_string.match(/^0+/).to_s
+        leading_zeroes.empty? ? '' : repeat_zeroes(leading_zeroes.length)
+      end
+
+      def number_without_leading_zeroes(number_as_string)
+        number_as_string.sub(/^0+/, '')
+      end
+
+      def single_thousands_to_words(number_as_string)
+        number = number_as_string.to_i / 1000
+
+        [one_digit_number_to_words(number), 'thousand'].join(' ')
+      end
+
+      def one_digit_number_to_words(number_as_string)
+        number = number_as_string.to_i
+        return repeat_zeroes(1) if number.zero?
+
+        ONES[number]
+      end
+
+      def two_digit_number_to_words(number_as_string)
+        number = number_as_string.to_i
+
+        return repeat_zeroes(2) if number.zero?
+        return TEENS[number - 10] if number < 20
+
+        div, mod = number.divmod(10)
+        TENS[div - 2] + (mod.zero? ? '' : " #{ONES[mod]}")
+      end
+
+      def three_digit_number_to_words(number_as_string)
+        number = number_as_string.to_i
+        return repeat_zeroes(3) if number.zero?
+
+        first_digit, remainder = number.divmod(100)
+        words = [ONES[first_digit]]
+        words << (remainder.zero? ? 'hundred' : two_digit_number_to_words(remainder))
+        words.join(' ')
+      end
+
+      def four_digit_number_to_words(number_as_string)
+        number = number_as_string.to_i
+
+        return repeat_zeroes(4) if number.zero?
+        return single_thousands_to_words(number_as_string) if (number % 1000).zero?
+
+        high_pair = number_as_string[0..1]
+        low_pair = number_as_string[2..3]
+
+        [
+          two_digit_number_to_words(high_pair),
+          low_pair.to_i.zero? ? 'hundred' : two_digit_number_to_words(low_pair)
+        ].join(' ')
+      end
+
+      def large_number_to_words(number_as_string)
+        number_as_string.chars.map { |digit| ONES[digit.to_i] }.each_slice(3).map { |digit| digit.join(' ') }.join(', ')
+      end
+    end
+  end
+end

data/lib/easy_to_dictate_numbers/extend_primitives.rb

@@ -5,3 +5,9 @@ class Integer
     EasyToDictateNumbers::NumberToDictable.number_to_words(self)
   end
 end
+
+class String
+  def to_dictable_number
+    EasyToDictateNumbers::NumberToDictable.number_to_words(self)
+  end
+end

data/lib/easy_to_dictate_numbers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EasyToDictateNumbers
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/lib/easy_to_dictate_numbers.rb

@@ -3,55 +3,4 @@
 # lib/easy_to_dictate_numbers.rb
 require_relative 'easy_to_dictate_numbers/version'
 require_relative 'easy_to_dictate_numbers/extend_primitives'
-
-module EasyToDictateNumbers
-  class Error < StandardError; end
-
-  class NumberToDictable
-    ONES = %w[zero one two three four five six seven eight nine].freeze
-    TEENS = %w[ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen].freeze
-    TENS = %w[twenty thirty forty fifty sixty seventy eighty ninety].freeze
-
-    def self.number_to_words(number)
-      validate_number(number)
-
-      case number.digits.count
-      when 1, 2 then two_digit_number_to_words(number)
-      when 3 then three_digit_number_to_words(number)
-      when 4 then four_digit_number_to_words(number)
-      else large_number_to_words(number)
-      end
-    end
-
-    def self.validate_number(number)
-      raise Error, 'Please enter a non-negative number' if number.negative?
-    end
-
-    def self.two_digit_number_to_words(number)
-      return ONES[number] if number < 10
-      return TEENS[number - 10] if number < 20
-
-      div, mod = number.divmod(10)
-      TENS[div - 2] + (mod.zero? ? '' : " #{ONES[mod]}")
-    end
-
-    def self.three_digit_number_to_words(number)
-      first_digit, remainder = number.divmod(100)
-      words = [ONES[first_digit], 'hundred']
-      words << two_digit_number_to_words(remainder) unless remainder.zero?
-      words.join(' ')
-    end
-
-    def self.four_digit_number_to_words(number)
-      high_pair, low_pair = number.divmod(100)
-      words = []
-      words << "#{two_digit_number_to_words(high_pair)} hundred" unless high_pair.zero?
-      words << two_digit_number_to_words(low_pair) unless low_pair.zero? || high_pair.zero?
-      words.join(' ')
-    end
-
-    def self.large_number_to_words(number)
-      number.to_s.chars.map { |digit| ONES[digit.to_i] }.each_slice(3).map { |digit| digit.join(' ') }.join(', ')
-    end
-  end
-end
+require_relative 'easy_to_dictate_numbers/easy_to_dictate_numbers'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_to_dictate_numbers
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Matias Verges
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-14 00:00:00.000000000 Z
+date: 2024-01-15 00:00:00.000000000 Z
 dependencies: []
 description: Transform numbers into words to dictate them easily.For example 1234
   becomes twelve thirty four and 123456 becomes 'one two three, four five six'
@@ -26,6 +26,7 @@ files:
 - Rakefile
 - easy_to_dictate_numbers.gemspec
 - lib/easy_to_dictate_numbers.rb
+- lib/easy_to_dictate_numbers/easy_to_dictate_numbers.rb
 - lib/easy_to_dictate_numbers/extend_primitives.rb
 - lib/easy_to_dictate_numbers/version.rb
 - sig/easy_to_dictate_numbers.rbs