Separate core_ext

humanize.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "humanize"
-  s.version = "3.0.0"
+  s.version = "3.1.0"
 
   s.required_ruby_version = '>= 3.1'
   s.require_paths = ["lib"]

lib/humanize.rb

@@ -1,131 +1,4 @@
-require 'bigdecimal'
-require_relative 'humanize/locales'
+# frozen_string_literal: true
 
-module Humanize
-  SPACE = ' '.freeze
-  EMPTY = ''.freeze
-  # Big numbers are big: http://wiki.answers.com/Q/What_number_is_after_vigintillion&src=ansTT
-
-  def humanize(locale: Humanize.config.default_locale,
-               decimals_as: Humanize.config.decimals_as)
-    locale_class, spacer = Humanize.for_locale(locale)
-
-    return locale_class::SUB_ONE_GROUPING[0] if zero?
-
-    infinity = to_f.infinite?
-    if infinity
-      infinity_word = locale_class::INFINITY
-      return infinity == 1 ? infinity_word : "#{locale_class::NEGATIVE}#{spacer}#{infinity_word}"
-    elsif is_a?(Float) && nan?
-      return locale_class::UNDEFINED
-    end
-
-    sign = locale_class::NEGATIVE if negative?
-
-    parts = locale_class.new.humanize(abs)
-    process_decimals(locale_class, locale, parts, decimals_as, spacer)
-    Humanize.stringify(parts, sign, spacer)
-  end
-
-  def self.for_locale(locale)
-    case locale.to_sym
-    # NOTE: add locales here in ealphabetical order
-    when :az, :de, :en, :es, :fr, :id, :ms, :pt, :ru, :vi
-      [Object.const_get("Humanize::#{locale.capitalize}"), SPACE]
-    when :th
-      [Humanize::Th, EMPTY]
-    when :tr
-      [Humanize::Tr, SPACE]
-    when :jp
-      [Humanize::Jp, EMPTY]
-    when :'fr-CH'
-      [Humanize::FrCh, SPACE]
-    else
-      raise "Unsupported humanize locale: #{locale}"
-    end
-  end
-
-  def self.stringify(parts, sign, spacer)
-    output = parts.reverse.join(spacer).squeeze(spacer)
-    if locale_is?(:es) && sign
-      "#{output}#{spacer}#{sign}"
-    elsif sign
-      "#{sign}#{spacer}#{output}"
-    else
-      output
-    end
-  end
-
-  def self.locale_is?(locale)
-    Humanize.config.default_locale == locale
-  end
-
-  def process_decimals(locale_class, locale, parts, decimals_as, spacer)
-    return unless is_a?(Float) || is_a?(BigDecimal)
-
-    # Why 15?
-    # (byebug) BigDecimal.new(number, 15)
-    # 0.8000015e1
-    # (byebug) BigDecimal.new(number, 16)
-    # 0.8000014999999999e1
-    decimal = BigDecimal(self, 15) - BigDecimal(to_i)
-
-    _sign, significant_digits, _base, exponent = decimal.split
-    return if significant_digits == "0"
-
-    grouping = locale_class::SUB_ONE_GROUPING
-    leading_zeroes = [grouping[0]] * exponent.abs
-    decimals_as = :digits if leading_zeroes.any?
-
-    decimals_as_words =
-      case decimals_as
-      when :digits
-        digits = significant_digits.chars.map do |num|
-          grouping[num.to_i]
-        end
-
-        (leading_zeroes + digits).join(spacer)
-      when :number
-        significant_digits.to_i.humanize(locale:)
-      end
-
-    parts.insert(0, decimals_as_words, locale_class::POINT)
-  end
-
-  class << self
-    attr_writer :config
-  end
-
-  def self.config
-    @config ||= Configuration.new
-  end
-
-  def self.reset_config
-    @config = Configuration.new
-  end
-
-  def self.configure
-    yield(config)
-  end
-
-  class Configuration
-    attr_accessor :default_locale, :decimals_as
-
-    def initialize
-      @default_locale = :en
-      @decimals_as = :digits
-    end
-  end
-end
-
-class Integer
-  include Humanize
-end
-
-class Float
-  include Humanize
-end
-
-class BigDecimal
-  include Humanize
-end
+require "humanize/module" # require just this if you don't need the core_ext extensions to Integer, Float, BigDecimal
+require "humanize/core_ext"

lib/humanize/core_ext.rb

@@ -0,0 +1,20 @@
+module Humanize
+  def humanize(locale: Humanize.config.default_locale,
+               decimals_as: Humanize.config.decimals_as)
+    Humanize.format(self,
+                    locale: locale,
+                    decimals_as: decimals_as)
+  end
+end
+
+class Integer
+  include Humanize
+end
+
+class Float
+  include Humanize
+end
+
+class BigDecimal
+  include Humanize
+end

lib/humanize/module.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require_relative './locales'
+
+module Humanize
+  # Big numbers are big: http://wiki.answers.com/Q/What_number_is_after_vigintillion&src=ansTT
+
+  class << self
+    def format(number,
+               locale: Humanize.config.default_locale,
+               decimals_as: Humanize.config.decimals_as)
+      locale_class, spacer = Humanize.for_locale(locale)
+
+      return locale_class::SUB_ONE_GROUPING[0] if number.zero?
+
+      infinity = number.to_f.infinite?
+      if infinity
+        infinity_word = locale_class::INFINITY
+        return infinity == 1 ? infinity_word : "#{locale_class::NEGATIVE}#{spacer}#{infinity_word}"
+      elsif number.is_a?(Float) && number.nan?
+        return locale_class::UNDEFINED
+      end
+
+      sign = locale_class::NEGATIVE if number.negative?
+
+      parts = locale_class.new.humanize(number.abs)
+      Humanize.process_decimals(number, locale_class, locale, parts, decimals_as, spacer)
+      Humanize.stringify(parts, sign, spacer)
+    end
+
+    def for_locale(locale)
+      case locale.to_sym
+      # NOTE: add locales here in ealphabetical order
+      when :az, :de, :en, :es, :fr, :id, :ms, :pt, :ru, :vi
+        [Object.const_get("Humanize::#{locale.capitalize}"), ' ']
+      when :th
+        [Humanize::Th, '']
+      when :tr
+        [Humanize::Tr, ' ']
+      when :jp
+        [Humanize::Jp, '']
+      when :'fr-CH'
+        [Humanize::FrCh, ' ']
+      else
+        raise "Unsupported humanize locale: #{locale}"
+      end
+    end
+
+    def stringify(parts, sign, spacer)
+      output = parts.reverse.join(spacer).squeeze(spacer)
+      if locale_is?(:es) && sign
+        "#{output}#{spacer}#{sign}"
+      elsif sign
+        "#{sign}#{spacer}#{output}"
+      else
+        output
+      end
+    end
+
+    def locale_is?(locale)
+      Humanize.config.default_locale == locale
+    end
+
+    def process_decimals(number, locale_class, locale, parts, decimals_as, spacer)
+      return unless number.is_a?(Float) || number.is_a?(BigDecimal)
+
+      # Why 15?
+      # (byebug) BigDecimal.new(number, 15)
+      # 0.8000015e1
+      # (byebug) BigDecimal.new(number, 16)
+      # 0.8000014999999999e1
+      decimal = BigDecimal(number, 15) - BigDecimal(number.to_i)
+
+      _sign, significant_digits, _base, exponent = decimal.split
+      return if significant_digits == "0"
+
+      grouping = locale_class::SUB_ONE_GROUPING
+      leading_zeroes = [grouping[0]] * exponent.abs
+      decimals_as = :digits if leading_zeroes.any?
+
+      decimals_as_words =
+        case decimals_as
+        when :digits
+          digits = significant_digits.chars.map do |num|
+            grouping[num.to_i]
+          end
+
+          (leading_zeroes + digits).join(spacer)
+        when :number
+          significant_digits.to_i.humanize(locale:)
+        end
+
+      parts.insert(0, decimals_as_words, locale_class::POINT)
+    end
+
+    attr_writer :config
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def reset_config
+      @config = Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+  end
+
+  class Configuration
+    attr_accessor :default_locale, :decimals_as
+
+    def initialize
+      @default_locale = :en
+      @decimals_as = :digits
+    end
+  end
+end

spec/core_ext_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe "Humanize core extensions to Ruby" do
+  after do
+    Humanize.reset_config
+  end
+
+  describe 'both options work together' do
+    it 'work together' do
+      expect(
+        0.42.humanize(locale: :fr, decimals_as: :number)
+      ).to eql('zéro virgule quarante-deux')
+    end
+  end
+
+  describe 'when called on instances of Rational, Complex, and Date::Infinity' do
+    it 'will raise NoMethodError' do
+      expect { Rational(1, 3).humanize }.to raise_error(NoMethodError, /humanize/)
+      expect { Complex(1 + 2i).humanize }.to raise_error(NoMethodError, /humanize/)
+      if defined? Date::Infinity
+        expect do
+          Date::Infinity.new.humanize
+        end.to raise_error(NoMethodError, /humanize/)
+      end
+    end
+  end
+
+  describe 'when called on conceptual number' do
+    it 'reads correctly' do
+      inf = Float::INFINITY
+      neg_inf = -inf
+      nan = inf + neg_inf
+
+      expect(inf.humanize).to eql('infinity')
+      expect(neg_inf.humanize).to eql('negative infinity')
+      expect(nan.humanize).to eql('undefined')
+    end
+  end
+
+  describe 'when called on bigdecimal with decimal fractions' do
+    it 'reads the decimal digits' do
+      expect(BigDecimal('123').humanize).to eql('one hundred and twenty-three')
+      expect(BigDecimal('123.45').humanize).to eql('one hundred and twenty-three point four five')
+    end
+  end
+end