numbers_in_words 0.4.0 → 1.0.1

data/lib/numbers_in_words/language_writer.rb

@@ -1,30 +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,135 +0,0 @@
-module NumbersInWords::NumberParser
-  SCALES_N = [100, 1000, 1000000, 1000000000, 1000000000000, 10**100]
-  # 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_ints(integers)
-    memory = 0
-    answer = 0
-    reset = true #reset each time memory is reset
-    integers.each do |integer|
-      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 parse(integers, only_compress = false)
-    if integers.length < 2
-      return integers if only_compress
-      return integers.empty? ? 0 : integers[0]
-    end
-    if [] == (SCALES_N & integers)
-      return pair_parse(integers, only_compress)
-    end
-
-    parse_ints(integers)
-  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
-
-  # 15,16
-  # 85,16
-  def pair_parse(ints, only_compress = false)
-    ints = compress(ints)
-    return ints if only_compress
-    return ints[0] if ints.length == 1
-    sum = 0
-    ints.each do |n|
-      sum *= n >= 10 ? 100 : 10
-      sum += n
-    end
-    sum
-  end
-
-  # [40, 2] => [42]
-  def compress(ints)
-    res = []
-    i = 0
-    return [] if ints.empty?
-    while i < ints.length - 1
-      int, jump = compress_int(ints[i], ints[i + 1])
-      res << int
-      i += jump
-    end
-    if i < ints.length
-      res << ints[-1]
-    else
-      res
-    end
-  end
-
-  def compress_int(int, sequel)
-    tens = int % 10 == 0 && int > 10
-    if tens && sequel < 10
-      return [int + sequel, 2]
-    else
-      return [int, 1]
-    end
-
-    [res, jump]
-  end
-
-  extend self
-end

data/lib/numbers_in_words/to_number.rb

@@ -1,88 +0,0 @@
-class NumbersInWords::ToNumber
-  delegate :to_s, to: :that
-  delegate :powers_of_ten_to_i, :exceptions_to_i, :canonize, \
-    :check_mixed, :check_one, :strip_minus, :check_decimal, 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, only_compress)
-    stripped = strip_minus text
-    if stripped
-      stripped_n = NumbersInWords.in_numbers(stripped, language, only_compress)
-      only_compress ? stripped_n.map{ |k| k * -1 } : -1 * stripped_n
-    end
-  end
-
-  def in_numbers(only_compress = false)
-    text = to_s.strip
-    return text.to_f if text =~ /^-?\d+(.\d+)?$/
-
-    text = strip_punctuation text
-
-    i = handle_negative(text, only_compress)
-    return i if i
-
-    mixed = check_mixed text
-    return mixed if mixed
-
-    one = check_one text
-    if one
-      res = NumbersInWords.in_numbers(one[1], language)
-      return only_compress ? [res] : res
-    end
-
-    h = handle_decimals text
-    return h if h
-
-    integers = word_array_to_integers text.split(" ")
-
-    NumbersInWords::NumberParser.parse integers, only_compress
-  end
-
-  def strip_punctuation text
-    text = text.downcase.gsub(/[^a-z 0-9]/, " ")
-    to_remove = true
-
-    to_remove = text.gsub! "  ", " " while to_remove
-
-    text
-  end
-
-  def handle_decimals text
-    match = check_decimal text
-    if match
-      integer = NumbersInWords.in_numbers(match.pre_match)
-      decimal = NumbersInWords.in_numbers(match.post_match)
-      integer +=  "0.#{decimal}".to_f
-    end
-  end
-
-  #handles simple single word numbers
-  #e.g. one, seven, twenty, eight, thousand etc
-  def word_to_integer word
-    text = canonize(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
-        expect(power).to eq(3)
-        expect(name).to eq("thousand")
-        expect(digits).to eq(2)
-      when 1
-        expect(power).to eq(0)
-        expect(name).to eq("one")
-        expect(digits).to eq(111)
-      end
-      count += 1
-    end
-  end
-end
-
-