numbers_in_words 0.2.0 → 0.5.1

data/lib/numbers_in_words/english/constants.rb

@@ -1,93 +0,0 @@
-module NumbersInWords
-  module English
-    def self.exceptions
-      {
-        0 => "zero",
-        1 => "one",
-        2 => "two",
-        3 => "three",
-        4 => "four",
-        5 => "five",
-        6 => "six",
-        7 => "seven",
-        8 => "eight",
-        9 => "nine",
-
-        10 => "ten",
-        11 => "eleven",
-        12 => "twelve",
-
-        13 => "thirteen",
-        14 => "fourteen",
-        15 => "fifteen",
-        16 => "sixteen" ,
-        17 => "seventeen",
-        18 => "eighteen",
-        19 => "nineteen",
-
-        20 => "twenty",
-        30 => "thirty",
-        40 => "forty",
-        50 => "fifty",
-        60 => "sixty",
-        70 => "seventy",
-        80 => "eighty",
-        90 => "ninety"
-      }
-    end
-
-    def self.swap_keys hsh
-      hsh.inject({}){|h,(k,v)| h[v]=k; h}
-    end
-
-    def self.powers_of_ten
-      {
-        0   => "one",
-        1   => "ten",
-        2   => "hundred",
-        3   => "thousand",
-        6   => "million",
-        9   => "billion",
-        12  => "trillion",
-        15  => "quadrillion",
-        18  => "quintillion",
-        21  => "sextillion",
-        24  => "septillion",
-        27  => "octillion",
-        30  => "nonillion",
-        33  => "decillion",
-        36  => "undecillion",
-        39  => "duodecillion",
-        42  => "tredecillion",
-        45  => "quattuordecillion",
-        48  => "quindecillion",
-        51  => "sexdecillion",
-        54  => "septendecillion",
-        57  => "octodecillion",
-        60  => "novemdecillion",
-        63  => "vigintillion",
-        66  => "unvigintillion",
-        69  => "duovigintillion",
-        72  => "trevigintillion",
-        75  => "quattuorvigintillion",
-        78  => "quinvigintillion",
-        81  => "sexvigintillion",
-        84  => "septenvigintillion",
-        87  => "octovigintillion",
-        90  => "novemvigintillion",
-        93  => "trigintillion",
-        96  => "untrigintillion",
-        99  => "duotrigintillion",
-        100 => "googol"
-      }
-    end
-
-    def self.exceptions_to_i
-      swap_keys exceptions
-    end
-
-    def self.powers_of_ten_to_i
-      swap_keys powers_of_ten
-    end
-  end
-end

data/lib/numbers_in_words/english/language_writer_english.rb

@@ -1,107 +0,0 @@
-module NumbersInWords
-  module English
-    class LanguageWriterEnglish < LanguageWriter
-      delegate :to_i, to: :that
-
-      def initialize that
-        super that
-        @language = "English"
-      end
-
-      def negative
-        "minus " + (-@that).in_words
-      end
-
-      def in_words
-        v = handle_exception
-        return v if v
-
-        in_decimals = decimals
-        return in_decimals if in_decimals
-
-        number = to_i
-
-        return negative() if number < 0
-
-        length = number.to_s.length
-        output = ""
-
-        if length == 2 #20-99
-          tens = (number/10).round*10 #write the tens
-
-          output << exceptions[tens] # e.g. eighty
-
-          digit = number - tens       #write the digits
-
-          output << " " + digit.in_words unless digit==0
-        else
-          output << write() #longer numbers
-        end
-
-        output.strip
-
-      end
-
-      def handle_exception
-        exceptions[@that] if @that.is_a?(Integer) and exceptions[@that]
-      end
-
-
-      def write
-        length = @that.to_s.length
-        output =
-          if length == 3
-            #e.g. 113 splits into "one hundred" and "thirteen"
-            write_groups(2)
-
-            #more than one hundred less than one googol
-          elsif length < LENGTH_OF_GOOGOL
-            write_groups(3)
-
-          elsif length >= LENGTH_OF_GOOGOL
-            write_googols
-          end
-        output.strip
-      end
-
-      def decimals
-        int, decimals = NumberGroup.new(@that).split_decimals
-        if int
-          out = int.in_words + " point "
-          decimals.each do |decimal|
-            out << decimal.to_i.in_words + " "
-          end
-          out.strip
-        end
-      end
-
-      private
-      def write_googols
-        googols, remainder = NumberGroup.new(@that).split_googols
-        output = ""
-        output << " " + googols.in_words + " googol"
-        if remainder > 0
-          prefix = " "
-          prefix << "and " if remainder < 100
-          output << prefix + remainder.in_words
-        end
-        output
-      end
-
-      def write_groups group
-        #e.g. 113 splits into "one hundred" and "thirteen"
-        output = ""
-        group_words(group) do |power, name, digits|
-          if digits > 0
-            prefix = " "
-            #no and between thousands and hundreds
-            prefix << "and " if power == 0  and digits < 100
-            output << prefix + digits.in_words
-            output << prefix + name unless power == 0
-          end
-        end
-        output
-      end
-    end
-  end
-end

data/lib/numbers_in_words/language_writer.rb

@@ -1,31 +0,0 @@
-module NumbersInWords
-  class LanguageWriter
-    attr_reader :that
-    delegate :exceptions, :powers_of_ten, to: :language
-
-    def initialize that
-      @that = that
-    end
-
-    def language
-      if @language.is_a? Module
-        @language
-      else
-        @language = NumbersInWords.const_get(@language)
-      end
-    end
-
-
-    def group_words size
-      #1000 and over Numbers are split into groups of three
-      groups = NumberGroup.groups_of @that, size
-      powers = groups.keys.sort.reverse #put in descending order
-
-      powers.each do |power|
-        name = powers_of_ten[power]
-        digits = groups[power]
-        yield power, name, digits
-      end
-    end
-  end
-end

data/lib/numbers_in_words/number_parser.rb

@@ -1,81 +0,0 @@
-module NumbersInWords::NumberParser
-  # Example: 364,895,457,898
-  #three hundred and sixty four billion eight hundred and ninety five million
-  #four hundred and fifty seven thousand eight hundred and ninety eight
-  #
-  #3 100 60 4 10^9, 8 100 90 5 10^6, 4 100 50 7 1000, 8 100 90 8
-  #                                                                    memory answer
-  #x1. 3 add to memory because answer and memory are zero                 3     0
-  #x2. memory * 100 (because memory<100)                                  300   0
-  #x3. 60 add to memory because memory > 60                               360   0
-  #x3. 4 add to memory because memory > 4                                364    0
-  #x4. multiply memory by 10^9 because memory < power of ten          364*10^9  0
-  #x5. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364*10^9
-  #x6. 8 add to memory because not finished                                8    ''
-  #x7. multiply memory by 100 because memory < 100                        800   ''
-  #x8. add 90 to memory because memory > 90                               890   ''
-  #x9. add 5 to memory because memory > 5                                 895   ''
-  #x10. multiply memory by 10^6 because memory < power of ten        895*10^6    ''
-  #x11. add memory to answer (and reset) because memory power ten > 2       0    364895 * 10^6
-  #x12. 4 add to memory because not finished                                4    ''
-  #x13. memory * 100 because memory < 100                                 400    ''
-  #x14. memory + 50 because memory > 50                                   450    ''
-  #x15. memory + 7  because memory > 7                                    457    ''
-  #x16. memory * 1000 because memory < 1000                            457000    ''
-  #x17. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364895457000
-  #x18. 8 add to memory because not finished                                8    ''
-  #x19. memory * 100 because memory < 100                                 800    ''
-  #x14. memory + 90 because memory > 90                                   890    ''
-  #x15. memory + 8  because memory > 8                                    898    ''
-  #16. finished so add memory to answer
-
-  #Example
-  #2001
-  #two thousand and one
-  #2 1000 1
-  #                                                        memory answer
-  #1. add 2 to memory because first                          2       0
-  #2. multiply memory by 1000 because memory < 1000        2000      0
-  #3. add memory to answer,reset,  because power of ten>2    0      2000
-  #4. add 1 to memory                                        1      2000
-  #5. finish - add memory to answer                          0      2001
-  def parse(integers)
-    memory = 0
-    answer = 0
-    reset = true #reset each time memory is reset
-    integers.each_with_index do |integer, index|
-      if reset
-        reset = false
-        memory += integer
-      else
-        #x4. multiply memory by 10^9 because memory < power of ten
-        if power_of_ten?(integer)
-          if power_of_ten(integer)> 2
-            memory *= integer
-            #17. add memory to answer  (and reset) (memory pow of ten > 2)
-            answer += memory
-            memory = 0
-            reset = true
-          end
-        end
-
-        if memory < integer
-          memory *= integer
-        else
-          memory += integer
-        end
-      end
-    end
-    answer += memory
-  end
-
-  def power_of_ten integer
-    Math.log10(integer)
-  end
-
-  def power_of_ten? integer
-    power_of_ten(integer) == power_of_ten(integer).to_i
-  end
-
-  extend self
-end

data/lib/numbers_in_words/to_number.rb

@@ -1,82 +0,0 @@
-class NumbersInWords::ToNumber
-  delegate :to_s, to: :that
-  delegate :powers_of_ten_to_i, :exceptions_to_i, to: :language
-  attr_reader :that, :language
-
-  def initialize that, language=NumbersInWords.language
-    @that = that
-    @language = language
-  end
-
-  def language
-    if @language.is_a? Module
-      @language
-    else
-      @language = NumbersInWords.const_get(@language)
-    end
-  end
-
-  def handle_negative text
-    -1 * (text.gsub(/^minus /, "")).in_numbers if text =~ /^minus /
-  end
-
-  def in_numbers
-    text = to_s
-
-    text = strip_punctuation text
-    i = handle_negative text
-    return i if i
-
-    h = handle_decimals text
-    return h if h
-
-    integers = word_array_to_integers text.split(" ")
-
-    NumbersInWords::NumberParser.parse integers
-  end
-
-  def strip_punctuation text
-    text = text.downcase.gsub(/[^a-z ]/, " ")
-    to_remove = true
-
-    to_remove = text.gsub! "  ", " " while to_remove
-
-    text
-  end
-
-  def handle_decimals text
-    match = text.match(/\spoint\s/)
-    if match
-      integer = match.pre_match.in_numbers
-
-      decimal = decimal_portion match.post_match
-
-      integer + decimal
-    end
-  end
-
-
-  def decimal_portion text
-    words    = text.split " "
-    integers = word_array_to_integers words
-    decimal  = "0." + integers.join()
-    decimal.to_f
-  end
-
-  #handles simple single word numbers
-  #e.g. one, seven, twenty, eight, thousand etc
-  def word_to_integer word
-    text = word.to_s.chomp.strip
-
-    exception = exceptions_to_i[text]
-    return exception if exception
-
-    power = powers_of_ten_to_i[text]
-    return 10 ** power if power
-  end
-
-  def word_array_to_integers words
-    words.map { |i| word_to_integer i }.compact
-  end
-end
-

data/spec/language_writer_spec.rb

@@ -1,23 +0,0 @@
-require './spec/spec_helper'
-
-describe NumbersInWords::English::LanguageWriterEnglish do
-  it "should display numbers grouped" do
-    count = 0
-    @writer = NumbersInWords::English::LanguageWriterEnglish.new(2111)
-    @writer.group_words(3) do |power, name, digits|
-      case count
-      when 0
-        power.should == 3
-        name.should == "thousand"
-        digits.should == 2
-      when 1
-        power.should == 0
-        name.should == "one"
-        digits.should == 111
-      end
-      count += 1
-    end
-  end
-end
-
-