ada_numbers 1.0.0

data/lib/ada_numbers/converters/en/words_to_number_converter.rb

@@ -0,0 +1,151 @@
+require_relative '../../utilities/integer_extensions'
+require_relative '../../utilities/hash_extensions'
+require_relative '../../utilities/string_extensions'
+require_relative '../../utilities/settings'
+require_relative '../../utilities/number_category'
+
+require_relative '../../constants/en/written_numbers'
+require_relative '../../constants/en/separators'
+require_relative '../../constants/message'
+
+module AdaNumbers
+  module WordsToNumberConverter
+    class En
+      @@use_short_scale = false
+
+      def self.convert(word)
+        select_scale
+
+        word = word.gsub(/\s+/, ' ').strip.
+          gsub(Separator::En::DASH, " #{Separator::En::NUMBERS_SEPARATOR} ").
+          gsub(Separator::En::COMMA, '').
+          title_case
+
+        words_to_convert = word.split " #{Separator::En::DECIMAL_SEPARATOR} "
+        words_to_convert = word.split " #{Separator::En::DECIMAL_SEPARATOR_ALTERNATIVE} " if words_to_convert.size == 1
+
+        case words_to_convert.size
+        when 1
+          return resolve_word word, @@use_short_scale
+        when 2
+          count_zeros = words_to_convert.last.split(' ').select { |w| w == WrittenNumber::En::ZERO }.size
+
+          whole_part = resolve_word words_to_convert.first, @@use_short_scale
+          decimal_part = resolve_word words_to_convert.last.gsub(WrittenNumber::En::ZERO, ""), @@use_short_scale
+
+          return Message::INVALID_NUMBER if whole_part == Message::INVALID_NUMBER || decimal_part == Message::INVALID_NUMBER
+
+          decimal_part = "#{'0' * count_zeros}#{decimal_part}" if count_zeros > 0
+          number = "#{whole_part}.#{decimal_part}"
+
+          return number.to_f
+        end
+
+        return Message::INVALID_NUMBER
+      end
+
+      private
+
+      def self.resolve_word(word, use_short_scale = false)
+        word = word.gsub /\s+/, ' '
+
+        # Try to get a direct match from the map
+        number = map_number_according_to_scale word, use_short_scale
+        return number unless number.nil?
+
+        # It was not found a direct match, so, let's find that bastard
+        string_tokens = word.split ' '
+        numeric_tokens = []
+
+        # The algorithm consists on iterating every token so that to find its direct match
+        # in the map and then stack it up. If the next number to be stacked requires a multiplier,
+        # we find it and stack it up after popping the later numbers. When all the matches are found
+        # The number is their sum
+        (0...string_tokens.size).each do |cursor|
+          token = string_tokens[cursor]
+
+          case token
+          when token == Separator::En::NUMBERS_SEPARATOR && (cursor == 0 || cursor == string_tokens.size - 1),
+            token == Separator::En::NUMBERS_SEPARATOR && WrittenNumber::En.numbers_that_ignore_separator.include?(string_tokens[cursor + 1]),
+            token == Separator::En::NUMBERS_SEPARATOR && cursor > 0 && string_tokens[cursor - 1] == Separator::En::NUMBERS_SEPARATOR
+            return Message::INVALID_NUMBER
+          when Separator::En::NUMBERS_SEPARATOR
+            next
+          end
+
+          number_has_incorrect_or_no_separator =
+            # cursor is valid for evaluation
+            cursor > 0 && (cursor + 1 < string_tokens.size - 1) &&
+            # number is not part of number that ignore separator nor its next neighbour
+            !WrittenNumber::En.numbers_that_ignore_separator.include?(token) &&
+            !WrittenNumber::En.numbers_that_ignore_separator.include?(string_tokens[cursor + 1]) &&
+            !WrittenNumber::En.unities_that_combine_with_separator.include?(token) &&
+            string_tokens[cursor - 1] != Separator::En::NUMBERS_SEPARATOR
+
+          number_is_in_incorrect_short_scale_format = use_short_scale && cursor > 0 &&
+            cursor < string_tokens.size - 1 && token == WrittenNumber::En::THOUSAND &&
+            WrittenNumber::En.not_to_combine_with_thousand.include?(string_tokens[cursor + 1])
+
+          return Message::INVALID_NUMBER if number_has_incorrect_or_no_separator || number_is_in_incorrect_short_scale_format
+
+          number = map_number_according_to_scale token, use_short_scale
+          return Message::INVALID_NUMBER if number.nil?
+
+          if compute_multiplier? token, numeric_tokens.size
+            multiplier, numeric_tokens = find_multiplier numeric_tokens
+            number *= multiplier
+          end
+
+          numeric_tokens.push number
+        end
+
+        numeric_tokens.sum
+      end
+
+      def self.map_number_according_to_scale(word, use_short_scale)
+        mapped_number = WrittenNumber::En.words_to_number_map.resolve(word)
+
+        number = if use_short_scale
+                   mapped_number.nil? ? WrittenNumber::En.words_to_number_map_short_scale.resolve(word) : mapped_number
+                 else
+                   mapped_number.nil? ? WrittenNumber::En.words_to_number_map_long_scale.resolve(word) : mapped_number
+                 end
+
+        number
+      end
+
+      def self.select_scale
+        @@use_short_scale = Settings.scale == Settings::Parameters::SCALES[:short]
+      end
+
+      def self.compute_multiplier?(token, number_of_numeric_tokes)
+         (token == WrittenNumber::En::HUNDRED ||
+          token == WrittenNumber::En::THOUSAND ||
+          token == WrittenNumber::En::MILLION ||
+          token == WrittenNumber::En::BILLION ||
+          token == WrittenNumber::En::TRILLION) &&
+          number_of_numeric_tokes != 0
+      end
+
+      def self.find_multiplier(numeric_tokens)
+        multiplier = numeric_tokens.pop
+
+        while numeric_tokens.size != 0
+          maybe_number = numeric_tokens.pop
+          break if maybe_number.nil?
+
+          number = maybe_number.to_i
+
+          if number.category > NumberCategory::HUNDRED
+            numeric_tokens.push(number)
+            break
+          end
+
+          multiplier += number
+        end
+
+        return multiplier, numeric_tokens
+      end
+    end
+  end
+end

data/lib/ada_numbers/converters/number_to_words_converter_extensions.rb

@@ -0,0 +1,32 @@
+require_relative './pt/number_to_words_converter'
+require_relative './en/number_to_words_converter'
+
+class Float
+  def to_words
+    case AdaNumbers::Settings.language
+    when AdaNumbers::Settings::Parameters::LANGUAGES[:en]
+      AdaNumbers::NumberToWordsConverter::En.convert self
+    else
+      AdaNumbers::NumberToWordsConverter::Pt.convert self
+    end
+  end
+
+  def to_w
+    to_words
+  end
+end
+
+class Integer
+  def to_words
+    case AdaNumbers::Settings.language
+    when AdaNumbers::Settings::Parameters::LANGUAGES[:en]
+      AdaNumbers::NumberToWordsConverter::En.convert self
+    else
+      AdaNumbers::NumberToWordsConverter::Pt.convert self
+    end
+  end
+
+  def to_w
+    to_words
+  end
+end

data/lib/ada_numbers/converters/pt/number_to_words_converter.rb

@@ -0,0 +1,179 @@
+require_relative '../../utilities/integer_extensions'
+require_relative '../../utilities/hash_extensions'
+require_relative '../../utilities/settings'
+require_relative '../../utilities/number_category'
+
+require_relative '../../constants/pt/written_numbers'
+require_relative '../../constants/pt/separators'
+require_relative '../../constants/message'
+
+module AdaNumbers
+  module NumberToWordsConverter
+    class Pt
+      @@use_short_scale = false
+      @@number_tokens   = []
+
+      def self.convert(number)
+        return convert_integer(number) if number.class == Integer
+        return convert_float(number)
+      end
+
+      private
+      def self.convert_integer(number)
+        return Message::UNSUPPORTED if number.number_of_digits > Settings::Parameters::DIGITS_LIMIT
+
+        select_scale
+        @@number_tokens.clear
+        return resolve_number number
+      end
+
+      def self.convert_float(number)
+        select_scale
+
+        str_number = number.to_s.split '.'
+
+        str_integer_part = str_number.first
+        str_decimal_part = str_number.size == 1? "0" : str_number.last
+
+        return Message::UNSUPPORTED if str_integer_part.size > Settings::Parameters::DIGITS_LIMIT || str_decimal_part.size > Settings::Parameters::DIGITS_LIMIT
+
+        whole_part   = str_integer_part.to_i
+        decimal_part = str_decimal_part.to_i
+
+        @@number_tokens.clear
+        result = resolve_number whole_part
+
+        return result if decimal_part == 0
+
+        result += " #{Separator::Pt::DECIMAL_SEPARATOR.downcase} "
+        # just aggregating the zeros
+        result += str_decimal_part.split('').
+          take_while { |c| c == "0"}.
+          collect { |c| WrittenNumber::Pt::ZERO}.
+          join ' '
+
+        @@number_tokens.clear
+        result += result[-1] == ' '? resolve_number(decimal_part) :
+                    " #{resolve_number(decimal_part)}"
+
+        return result
+      end
+
+      def self.select_scale
+        @@use_short_scale = Settings.scale == Settings::Parameters::SCALES[:short]
+      end
+
+      def self.resolve_number(number, flag = false)
+        result = ''
+        number_category = number.category
+
+        case number_category
+        when NumberCategory::UNITY
+          result = unities number
+        when NumberCategory::TEN
+          result = tens number
+        when NumberCategory::HUNDRED
+          result = hundreds number, flag
+        when NumberCategory::THOUSAND
+          result = thousands number
+        when NumberCategory::MILLION
+          result = millions number
+        when NumberCategory::THOUSAND_MILLIONS
+          result = thousand_millions number
+        when NumberCategory::BILLION
+          result = billions number
+        end
+
+        if result.empty?
+          str_number = number.to_s
+          bridge = number.bridge
+
+          flag_first_digits = (number_category == NumberCategory::HUNDRED ? number != 100 : false)
+
+          first_digits = (str_number[0...bridge] + '0'*number_category).to_i
+          other_digits = (str_number[bridge..-1]).to_i
+
+          flag_other_digits = other_digits != 100
+
+          resolve_number first_digits, flag_first_digits
+          resolve_number other_digits, flag_other_digits
+        else
+          @@number_tokens << result
+        end
+
+        add_separators_to_number @@number_tokens
+      end
+
+      def self.add_separators_to_number(number_tokens)
+        result = number_tokens.first
+
+        (1...number_tokens.size).each do |cursor|
+          current_token = number_tokens[cursor]
+
+          if WrittenNumber::Pt.numbers_that_ignore_separator.include? current_token
+            result += " #{current_token}"
+          else
+            result += " #{Separator::Pt::NUMBERS_SEPARATOR.downcase} #{current_token}"
+          end
+        end
+
+        return result
+      end
+
+      def self.unities(number)
+        WrittenNumber::Pt.numbers_to_words_map_unities.resolve number
+      end
+
+      def self.tens(number)
+        WrittenNumber::Pt.numbers_to_words_map_tens.resolve number
+      end
+
+      def self.hundreds(number, is_cent = false)
+        results = {
+          200 => WrittenNumber::Pt::TWO_HUNDRED,
+          300 => WrittenNumber::Pt::THREE_HUNDRED,
+          400 => WrittenNumber::Pt::FOUR_HUNDRED,
+          500 => WrittenNumber::Pt::FIVE_HUNDRED,
+          600 => WrittenNumber::Pt::SIX_HUNDRED,
+          700 => WrittenNumber::Pt::SEVEN_HUNDRED,
+          800 => WrittenNumber::Pt::EIGHT_HUNDRED,
+          900 => WrittenNumber::Pt::NINE_HUNDRED,
+          100 => (is_cent ? WrittenNumber::Pt::ONE_HUNDRED : WrittenNumber::Pt::ONE_HUNDRED_SINGLE)
+        }
+
+        return results.resolve number
+      end
+
+      def self.thousands(number)
+        evaluate_thousands_and_over number, 1e3.to_i, WrittenNumber::Pt::THOUSAND, WrittenNumber::Pt::THOUSAND
+      end
+
+      def self.millions(number)
+        evaluate_thousands_and_over number, 1e6.to_i, WrittenNumber::Pt::MILLION_SINGULAR, WrittenNumber::Pt::MILLION_PLURAL
+      end
+
+      def self.thousand_millions(number)
+        singular = (@@use_short_scale ? WrittenNumber::Pt::BILLION_SINGULAR : WrittenNumber::Pt::THOUSAND_MILLION)
+        plural   = (@@use_short_scale ? WrittenNumber::Pt::BILLION_PLURAL : WrittenNumber::Pt::THOUSAND_MILLION)
+
+        evaluate_thousands_and_over number, 1e9.to_i, singular, plural
+      end
+
+      def self.billions(number)
+        singular = (@@use_short_scale ? WrittenNumber::Pt::TRILLION_SINGULAR : WrittenNumber::Pt::BILLION_SINGULAR)
+        plural   = (@@use_short_scale ? WrittenNumber::Pt::TRILLION_PLURAL : WrittenNumber::Pt::BILLION_PLURAL)
+
+        evaluate_thousands_and_over number, 1e12.to_i, singular, plural
+      end
+
+      def self.evaluate_thousands_and_over(number, category_identifier, singular, plural)
+        return singular if number == category_identifier
+        return '' if number%category_identifier != 0
+
+        partial_number = number.to_s[0...number.bridge].to_i
+        resolve_number partial_number
+        return plural
+      end
+    end
+  end
+end

data/lib/ada_numbers/converters/pt/words_to_number_converter.rb

@@ -0,0 +1,143 @@
+require_relative '../../utilities/integer_extensions'
+require_relative '../../utilities/hash_extensions'
+require_relative '../../utilities/string_extensions'
+require_relative '../../utilities/settings'
+require_relative '../../utilities/number_category'
+
+require_relative '../../constants/pt/written_numbers'
+require_relative '../../constants/pt/separators'
+require_relative '../../constants/message'
+
+module AdaNumbers
+  module WordsToNumberConverter
+    class Pt
+      @@use_short_scale = false
+
+      def self.convert(word)
+        select_scale
+
+        word = word.gsub(/\s+/, ' ').strip.title_case
+
+        words_to_convert = word.split " #{Separator::Pt::DECIMAL_SEPARATOR} "
+        words_to_convert = word.split " #{Separator::Pt::DECIMAL_SEPARATOR_ALTERNATIVE} " if words_to_convert.size == 1
+
+        case words_to_convert.size
+        when 1
+          return resolve_word word, @@use_short_scale
+        when 2
+          count_zeros = words_to_convert.last.split(' ').select {|w| w == WrittenNumber::Pt::ZERO}.size
+
+          whole_part   = resolve_word words_to_convert.first, @@use_short_scale
+          decimal_part = resolve_word words_to_convert.last.gsub(WrittenNumber::Pt::ZERO, ""), @@use_short_scale
+
+          return Message::INVALID_NUMBER if whole_part == Message::INVALID_NUMBER || decimal_part == Message::INVALID_NUMBER
+
+          decimal_part = "#{'0'*count_zeros}#{decimal_part}" if count_zeros > 0
+          number = "#{whole_part}.#{decimal_part}"
+
+          return number.to_f
+        end
+
+        return Message::INVALID_NUMBER
+      end
+
+      private
+      def self.resolve_word(word, use_short_scale = false)
+        word = word.gsub /\s+/, ' '
+
+        # Try to get a direct match from the map
+        number = map_number_according_to_scale word, use_short_scale
+        return number unless number.nil?
+
+        # It was not found a direct match, so, let's find that bastard
+        string_tokens  = word.split ' '
+        numeric_tokens = []
+
+        # The algorithm consists on iterating every token so that to find its direct match
+        # in the map and then stack it up. If the next number to be stacked requires a multiplier,
+        # we find it and stack it up after popping the later numbers. When all the matches are found
+        # The number is their sum
+        (0...string_tokens.size).each do |cursor|
+          token = string_tokens[cursor]
+
+          case token
+          when token == Separator::Pt::NUMBERS_SEPARATOR && (cursor == 0 || cursor == string_tokens.size - 1),
+            token == Separator::Pt::NUMBERS_SEPARATOR && WrittenNumber::Pt.numbers_that_ignore_separator.include?(string_tokens[cursor + 1]),
+            token == Separator::Pt::NUMBERS_SEPARATOR && cursor > 0 && string_tokens[cursor - 1] == Separator::Pt::NUMBERS_SEPARATOR
+            return Message::INVALID_NUMBER
+          when Separator::Pt::NUMBERS_SEPARATOR
+            next
+          end
+
+          token = "#{WrittenNumber::Pt::ONE} #{token}" if join_one? token
+
+          number_has_incorrect_or_no_separator = cursor > 0 &&
+            !WrittenNumber::Pt.numbers_that_ignore_separator.include?(token) &&
+            string_tokens[cursor - 1] != Separator::Pt::NUMBERS_SEPARATOR
+
+          number_is_in_incorrect_short_scale_format = use_short_scale && cursor > 0 &&
+            cursor < string_tokens.size - 1 && token == WrittenNumber::Pt::THOUSAND &&
+            WrittenNumber::Pt.not_to_combine_with_thousand.include?(string_tokens[cursor + 1])
+
+          return Message::INVALID_NUMBER if number_has_incorrect_or_no_separator || number_is_in_incorrect_short_scale_format
+
+          number = map_number_according_to_scale token, use_short_scale
+          return Message::INVALID_NUMBER if number.nil?
+
+          if compute_multiplier? token, numeric_tokens.size
+            multiplier, numeric_tokens = find_multiplier numeric_tokens
+            number *= multiplier
+          end
+
+          numeric_tokens.push number
+        end
+
+        numeric_tokens.sum
+      end
+
+      def self.map_number_according_to_scale(word, use_short_scale)
+        mapped_number = WrittenNumber::Pt.words_to_number_map.resolve(word)
+
+        number = if use_short_scale
+                   mapped_number.nil? ? WrittenNumber::Pt.words_to_number_map_short_scale.resolve(word) : mapped_number
+                 else
+                   mapped_number.nil? ? WrittenNumber::Pt.words_to_number_map_long_scale.resolve(word) : mapped_number
+                 end
+
+        number
+      end
+
+      def self.select_scale
+        @@use_short_scale = Settings.scale == Settings::Parameters::SCALES[:short]
+      end
+
+      def self.join_one?(token)
+        token != WrittenNumber::Pt::ONE && token != WrittenNumber::Pt::THOUSAND &&
+          (WrittenNumber::Pt::MILLION_SINGULAR.include?(token) ||
+           WrittenNumber::Pt::BILLION_SINGULAR.include?(token) ||
+           WrittenNumber::Pt::TRILLION_SINGULAR.include?(token))
+      end
+
+      def self.compute_multiplier?(token, number_of_numeric_tokes)
+        (token == WrittenNumber::Pt::THOUSAND ||
+         token == WrittenNumber::Pt::MILLION_SINGULAR ||
+         token == WrittenNumber::Pt::MILLION_PLURAL ||
+         token == WrittenNumber::Pt::BILLION_SINGULAR ||
+         token == WrittenNumber::Pt::BILLION_PLURAL ||
+         token == WrittenNumber::Pt::TRILLION_SINGULAR ||
+         token == WrittenNumber::Pt::TRILLION_PLURAL) &&
+          number_of_numeric_tokes != 0
+      end
+
+      def self.find_multiplier(numeric_tokens)
+        multiplier = numeric_tokens.pop
+
+        while numeric_tokens.size != 0
+          multiplier += numeric_tokens.pop
+        end
+
+        return multiplier, numeric_tokens
+      end
+    end
+  end
+end

data/lib/ada_numbers/converters/words_to_number_converter_extensions.rb

@@ -0,0 +1,17 @@
+require_relative './pt/words_to_number_converter'
+require_relative './en/words_to_number_converter'
+
+class String
+  def to_number
+    case AdaNumbers::Settings.language
+    when AdaNumbers::Settings::Parameters::LANGUAGES[:en]
+      AdaNumbers::WordsToNumberConverter::En.convert self
+    else
+      AdaNumbers::WordsToNumberConverter::Pt.convert self
+    end
+  end
+
+  def to_n
+    to_number
+  end
+end

data/lib/ada_numbers/utilities/hash_extensions.rb

@@ -0,0 +1,15 @@
+class Hash
+  def resolve(value)
+    return resolve_for_int_str(value) if value.class == Integer
+    return resolve_for_str_int(value)
+  end
+
+  private
+  def resolve_for_int_str(number)
+    (self[number].nil?)? '' : self[number]
+  end
+
+  def resolve_for_str_int(words)
+    self[words]
+  end
+end

data/lib/ada_numbers/utilities/integer_extensions.rb

@@ -0,0 +1,39 @@
+class Integer
+  extend AdaNumbers
+  def number_of_digits
+    self.to_s.size
+  end
+
+  def category
+    case self.number_of_digits
+    when 2
+      return AdaNumbers::NumberCategory::TEN
+    when 3
+      return AdaNumbers::NumberCategory::HUNDRED
+    when 4..6
+      return AdaNumbers::NumberCategory::THOUSAND
+    when 7..9
+      return AdaNumbers::NumberCategory::MILLION
+    when 10..12
+      return AdaNumbers::NumberCategory::THOUSAND_MILLIONS
+    when 13..15
+      return AdaNumbers::NumberCategory::BILLION
+    end
+
+    AdaNumbers::NumberCategory::UNITY
+  end
+
+  def bridge
+    n_digits = self.number_of_digits
+
+    case n_digits
+    when 5, 8, 11, 14
+      return 2
+    when 6, 9, 12, 15
+      return 3
+    end
+
+    return 1
+  end
+end
+

data/lib/ada_numbers/utilities/number_category.rb

@@ -0,0 +1,11 @@
+module AdaNumbers
+  class NumberCategory
+    UNITY              = 0
+    TEN                = 1
+    HUNDRED            = 2
+    THOUSAND           = 3
+    MILLION            = 6
+    THOUSAND_MILLIONS  = 9
+    BILLION            = 12
+  end
+end

data/lib/ada_numbers/utilities/settings.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AdaNumbers
+  class Settings
+    class Parameters
+      LANGUAGES = {
+        en: :english,
+        pt: :portuguese
+      }
+
+      SCALES = {
+        short: :short,
+        long:  :long
+      }
+
+      DIGITS_LIMIT = 15
+
+      class << self
+        attr_accessor :hello
+      end
+    end
+
+    @language = Parameters::LANGUAGES[:pt]
+    @scale    = Parameters::SCALES[:long]
+
+    class << self
+      attr_accessor :language, :scale
+
+      def reset
+        @language = Parameters::LANGUAGES[:pt]
+        @scale    = Parameters::SCALES[:long]
+      end
+    end
+  end
+end

data/lib/ada_numbers/utilities/string_extensions.rb

@@ -0,0 +1,5 @@
+class String
+  def title_case
+    self.split(' ').map { |w| w.capitalize }.join ' '
+  end
+end

data/lib/ada_numbers/version.rb

@@ -0,0 +1,3 @@
+module AdaNumbers
+  VERSION = "1.0.0"
+end

data/lib/ada_numbers.rb

@@ -0,0 +1,13 @@
+require 'ada_numbers/version'
+
+require 'ada_numbers/converters/number_to_words_converter_extensions'
+require 'ada_numbers/converters/pt/number_to_words_converter'
+require 'ada_numbers/converters/en/number_to_words_converter'
+
+require 'ada_numbers/converters/words_to_number_converter_extensions'
+require 'ada_numbers/converters/pt/words_to_number_converter'
+
+module AdaNumbers
+  class Error < StandardError; end
+  # Your code goes here...
+end