castwide_numbers_in_words 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d91888df88e8fc7610f529b7cbe3871f2d655094becfaf76ce0f20a520d1c22
+  data.tar.gz: 2071d799552a79eaa52c891e0508d0835832b9bea52d870391cd78bd0b17e535
+SHA512:
+  metadata.gz: 286ad2a50878696c6841879653f2ee86bc0e0f3b1a7e5dc5e46f0e962cbc29fbf26385fadfdab81088336e435aec658e7d3884d1bf1bab8c6e9e3434b7ab9bbf
+  data.tar.gz: 3e94b737d38930ab1fb5559c455d24207d7b6226133155bf9558252e2695018cb414018c38fe3ed866c2b0e648fcc8433e2d6c261ad385609bd112ff768ed644

data/.codeclimate.yml

@@ -0,0 +1,14 @@
+---
+engines:
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - Gemfile.lock
+  - "**.rb"
+exclude_paths:
+- spec/**/*
+- .codeclimate.yml
+- .rubocop.yml

data/.gitignore

@@ -0,0 +1,7 @@
+*.swp
+*.swo
+*.html
+tmp
+pkg/
+Gemfile.lock
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,58 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+Lint/RaiseException:
+  Enabled: true
+Lint/StructNewOverride:
+  Enabled: true
+Style/ExponentialNotation:
+  Enabled: true
+Style/HashEachMethods:
+  Enabled: true
+Style/HashTransformKeys:
+  Enabled: true
+Style/HashTransformValues:
+  Enabled: true
+Style/RedundantFetchBlock:
+  Enabled: true
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+Style/RedundantRegexpEscape:
+  Enabled: true
+Style/SlicingWithRange:
+  Enabled: true
+Lint/DuplicateElsifCondition:
+  Enabled: true
+Style/AccessorGrouping:
+  Enabled: true
+Style/ArrayCoercion:
+  Enabled: true
+Style/BisectedAttrAccessor:
+  Enabled: true
+Style/CaseLikeIf:
+  Enabled: true
+Style/Documentation:
+  Enabled: false
+Style/HashAsLastArrayItem:
+  Enabled: true
+Style/HashLikeCase:
+  Enabled: true
+Style/RedundantAssignment:
+  Enabled: true
+Style/RedundantFileExtensionInRequire:
+  Enabled: true

data/.travis.yml

@@ -0,0 +1,17 @@
+env:
+  global:
+    - CC_TEST_REPORTER_ID=9a548b48c1c0804d8fb9083ae8e9693a5d5197eb86e8cf1b63a89d18f33e0464
+sudo: false
+language: ruby
+rvm:
+ - "2.4.10"
+ - "2.5.8"
+ - "2.6.6"
+ - "2.7.1"
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+script: ./bin/spec
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'byebug'
+gem 'simplecov', '< 0.18.0', require: false, group: :test
+# Specify your gem's dependencies in numbers_in_words.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,74 @@
+PATH
+  remote: .
+  specs:
+    castwide_numbers_in_words (1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.3)
+    byebug (12.0.0)
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    json (2.13.2)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.4.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.10.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    rubocop (1.79.0)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      tsort (>= 0.2.0)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    ruby-progressbar (1.13.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    tsort (0.2.0)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+
+PLATFORMS
+  x64-mingw-ucrt
+
+DEPENDENCIES
+  byebug
+  castwide_numbers_in_words!
+  rspec (~> 3.4.0)
+  rubocop
+  simplecov (< 0.18.0)
+
+BUNDLED WITH
+   2.6.9

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Adapted from numbers_in_words by Mark Burns (see NUMBERS_IN_WORDS.txt)
+
+Copyright (c) 2025 by Fred Snyder
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/NUMBERS_IN_WORDS.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mark Burns
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+**This is a fork of the [numbers_in_words gem by Mark Burns](https://github.com/markburns/numbers_in_words).** The original license is reproduced in [NUMBERS_IN_WORDS.txt](NUMBERS_IN_WORDS.txt).
+
+Changes in this fork:
+* Compatibility with [Opal](https://github.com/opal/opal)
+* Updates for Ruby 3
+
+Installation
+============
+
+```ruby
+gem 'castwide_numbers_in_words'
+```
+
+Usage
+=========
+
+```ruby
+require 'numbers_in_words'
+
+NumbersInWords.in_words(112)
+#=> one hundred and twelve
+
+NumbersInWords.in_numbers("one googol")
+#=>10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+NumbersInWords.in_numbers("Seventy million, five-hundred and fifty six thousand point eight nine three")
+#=> 70556000.893
+
+NumbersInWords.in_numbers("nineteen sixty five")
+#=> 1965
+```
+
+
+Monkey patch version
+
+```ruby
+require 'numbers_in_words'
+require 'numbers_in_words/duck_punch'
+112.in_words
+#=> one hundred and twelve
+
+"one googol".in_numbers
+#=>10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+"Seventy million, five-hundred and fifty six thousand point eight nine three".in_numbers
+#=> 70556000.893
+```

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/bin/spec

@@ -0,0 +1,2 @@
+bundle exec rspec spec/non_monkey_patch_spec.rb
+bundle exec rspec spec

data/castwide_numbers_in_words.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numbers_in_words/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'castwide_numbers_in_words'
+  gem.description   = 'convert written numbers into Integers and vice-versa'
+  gem.summary       = 'Example: NumbersInWords.in_words(123) # => ' \
+    '"one hundred and twenty three", NumbersInWords.in_numbers("seventy-five point eight") # = > 75.8'
+
+  gem.version       = NumbersInWords::VERSION
+  gem.authors       = ['Fred Snyder']
+  gem.email         = ['castwide@gmail.com']
+  gem.homepage      = 'http://github.com/castwide/castwide_numbers_in_words'
+
+  gem.add_development_dependency 'rspec', '~> 3.4.0'
+  gem.add_development_dependency 'rubocop'
+
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

data/lib/numbers_in_words/duck_punch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  module NumericExtension
+    def in_words(fraction: false)
+      NumbersInWords::ToWord.new(self).in_words(fraction: fraction)
+    end
+  end
+
+  module StringExtension
+    def in_numbers(only_compress: false)
+      NumbersInWords::ToNumber.new(self, only_compress).call
+    end
+  end
+end
+
+class String
+  include NumbersInWords::StringExtension
+end
+
+class Numeric
+  include NumbersInWords::NumericExtension
+end

data/lib/numbers_in_words/exceptional_numbers.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'fraction'
+require_relative 'powers_of_ten'
+
+module NumbersInWords
+  class ExceptionalNumbers
+    extend Forwardable
+
+    DEFINITIONS = {
+      0 => { number: 'zero', ordinal: 'zeroth' },
+      1 => { number: 'one', ordinal: 'first' },
+      2 => { number: 'two', ordinal: 'second', fraction: { singular: 'half', plural: 'halves' } },
+      3 => { number: 'three', ordinal: 'third' },
+      4 => { number: 'four', ordinal: 'fourth', fraction: { singular: 'quarter', plural: 'quarters' } },
+      5 => { number: 'five', ordinal: 'fifth' },
+      6 => { number: 'six' },
+      7 => { number: 'seven' },
+      8 => { number: 'eight', ordinal: 'eighth' },
+      9 => { number: 'nine', ordinal: 'ninth' },
+      10 => { number: 'ten' },
+      11 => { number: 'eleven' },
+      12 => { number: 'twelve', ordinal: 'twelfth' },
+      13 => { number: 'thirteen' },
+      14 => { number: 'fourteen' },
+      15 => { number: 'fifteen' },
+      16 => { number: 'sixteen' },
+      17 => { number: 'seventeen' },
+      18 => { number: 'eighteen' },
+      19 => { number: 'nineteen' },
+      20 => { number: 'twenty', ordinal: 'twentieth' },
+      30 => { number: 'thirty', ordinal: 'thirtieth' },
+      40 => { number: 'forty', ordinal: 'fortieth' },
+      50 => { number: 'fifty', ordinal: 'fiftieth' },
+      60 => { number: 'sixty', ordinal: 'sixtieth' },
+      70 => { number: 'seventy', ordinal: 'seventieth' },
+      80 => { number: 'eighty', ordinal: 'eightieth' },
+      90 => { number: 'ninety', ordinal: 'ninetieth' }
+    }.freeze
+
+    def fraction_names
+      @fraction_names ||= determine_fraction_names
+    end
+
+    def lookup_fraction(words)
+      fraction_lookup[words]
+    end
+
+    def fraction_lookup
+      @fraction_lookup ||= generate_fraction_lookup
+    end
+
+    def lookup(number)
+      to_h[number]
+    end
+
+    def fraction(denominator: nil, numerator: nil, word: nil)
+      raise unless denominator || word
+
+      numerator ||= 1
+
+      denominator ||= NumbersInWords.in_numbers(word)
+
+      Fraction.new(denominator: denominator, numerator: numerator, attributes: DEFINITIONS[denominator])
+    end
+
+    def to_h
+      @to_h ||= DEFINITIONS.transform_values do |h|
+        h[:number]
+      end
+    end
+
+    private
+
+    def generate_fraction_lookup
+      named_fractions.each_with_object({}) do |f, result|
+        f.lookup_keys.each do |k|
+          key = k.split(' ').last
+          result[key] = 1.0 / f.denominator.to_f
+        end
+      end
+    end
+
+    def named_fractions
+      @named_fractions ||= numbers.flat_map do |n|
+        [
+          Fraction.new(denominator: n, numerator: 1),
+          Fraction.new(denominator: n, numerator: 2)
+        ]
+      end
+    end
+
+    def numbers
+      (2..100).to_a + powers_of_ten_skipping_googolplex.map { |p| 10**p }
+    end
+
+    def powers_of_ten_skipping_googolplex
+      POWERS_OF_TEN.keys[0..-2]
+    end
+
+    def determine_fraction_names
+      names = named_fractions.map(&:in_words)
+
+      words = names.map(&:split).map(&:last)
+      words += strip_punctuation(words)
+      words.uniq
+    end
+
+    def strip_punctuation(words)
+      words.map { |w| w.gsub(/^a-z/, ' ') }
+    end
+  end
+end

data/lib/numbers_in_words/fraction.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class Fraction
+    attr_reader :denominator, :numerator, :attributes
+
+    def self.in_words(that)
+      r = that.rationalize(EPSILON)
+
+      NumbersInWords
+        .fraction(denominator: r.denominator, numerator: r.numerator)
+        .in_words
+    end
+
+    def initialize(denominator:, numerator: 1, attributes: nil)
+      @denominator = denominator
+      @numerator = numerator
+      @attributes = attributes || NumbersInWords::ExceptionalNumbers::DEFINITIONS[denominator] || {}
+    end
+
+    def lookup_keys
+      key = in_words
+      key2 = strip_punctuation(key.split(' ')).join(' ')
+
+      key3 = "a #{key}"
+      key4 = "an #{key}"
+      key5 = "a #{key2}"
+      key6 = "an #{key2}"
+      [key, key2, key3, key4, key5, key6].uniq
+    end
+
+    def in_words
+      NumbersInWords.in_words(numerator) + ' ' + fraction
+    end
+
+    def ordinal
+      pluralize? ? pluralized_ordinal_in_words : singular_ordinal_in_words
+    end
+
+    def fraction
+      if denominator == Float::INFINITY
+        # We've reached the limits of ruby's number system
+        # by the time we get to a googolplex (10 ** (10 ** 100))
+        return pluralize? ? 'infinitieths' : 'infinitieth'
+      end
+
+      pluralize? ? pluralized_fraction : singular_fraction
+    end
+
+    private
+
+    def strip_punctuation(words)
+      words.map { |w| w.gsub(/^a-z/, ' ') }
+    end
+
+    def pluralized_fraction
+      fraction_plural || pluralized_ordinal_in_words
+    end
+
+    def singular_fraction
+      fraction_singular || singular_ordinal_in_words
+    end
+
+    def pluralized_ordinal_in_words
+      pluralized_ordinal || denominator_ordinal_in_words
+    end
+
+    def singular_ordinal_in_words
+      singular_ordinal || denominator_ordinal_in_words
+    end
+
+    def singular_ordinal
+      attributes[:ordinal]
+    end
+
+    def pluralized_ordinal
+      singular_ordinal && singular_ordinal + 's'
+    end
+
+    def pluralize?
+      numerator > 1
+    end
+
+    def denominator_ordinal_in_words
+      if denominator > 100
+        # one hundred and second
+        with_remainder(100, ' and ')
+      elsif denominator > 19
+        # two thirty-fifths
+        with_remainder(10, '-')
+      else
+        # one seventh
+        singular = NumbersInWords.in_words(denominator) + 'th'
+        pluralize? ? singular + 's' : singular
+      end
+    end
+
+    def with_remainder(mod, join_word)
+      rest = denominator % mod
+      main = denominator - rest
+      main = NumbersInWords.in_words(main)
+
+      main = main.gsub(/^one /, '') if pluralize?
+
+      rest_zero(rest, main) || joined(main, rest, join_word)
+    end
+
+    def joined(main, rest, join_word)
+      main +
+        join_word +
+        self.class.new(numerator: numerator, denominator: rest).ordinal
+    end
+
+    def rest_zero(rest, main)
+      return unless rest.zero?
+
+      if pluralize?
+        main + 'ths'
+      else
+        main + 'th'
+      end
+    end
+
+    def exception
+      attributes[:fraction]
+    end
+
+    def fraction_singular
+      exception && exception[:singular]
+    end
+
+    def fraction_plural
+      exception && exception[:plural]
+    end
+  end
+end

data/lib/numbers_in_words/number_group.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class NumberGroup
+    include Enumerable
+    attr_accessor :number
+
+    def self.groups_of(number, size)
+      new(number).groups(size)
+    end
+
+    def initialize(number)
+      @number = number
+    end
+
+    # split into groups this gives us 1234567 => 123 456 7
+    # so we need to reverse first
+    # in stages
+    def groups(size)
+      # 1234567   => %w(765 432 1)
+      @array = in_groups_of(@number.to_s.reverse.split(''), size)
+      # %w(765 432 1) => %w(1 432 765)
+      @array.reverse!
+
+      # %w(1 432 765) => [1, 234, 567]
+      @array.map! { |group| group.reverse.join('').to_i }
+      @array.reverse! # put in ascending order of power of ten
+
+      power = 0
+
+      # [1, 234, 567] => {6 => 1, 3 => 234, 0 => 567}
+      @array.each_with_object({}) do |digits, o|
+        o[power] = digits
+        power += size
+      end
+    end
+
+    def split_decimals
+      return unless @number.to_s.include?('.')
+
+      int, decimal = @number.to_s.split '.'
+
+      [int.to_i, decimal.split(//).map(&:to_i)]
+    end
+
+    def split_googols
+      googols   = @number.to_s[0..-LENGTH_OF_GOOGOL].to_i
+      remainder = @number.to_s[(1 - LENGTH_OF_GOOGOL)..-1].to_i
+      [googols, remainder]
+    end
+
+    private
+
+    def in_groups_of(array, number, fill_with = nil)
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - array.size % number) % number
+      collection = array.dup.concat(Array.new(padding, fill_with))
+
+      collection.each_slice(number).to_a
+    end
+  end
+end