number_to 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0a68f0393aaa50be1a3f8252373cae857d42068
+  data.tar.gz: 1966aa6f80a2de113df09b88b3361b21ce90366a
+SHA512:
+  metadata.gz: 257dd29a7ab46c33499bd7577f4580266c6d40fa2cad09ea75cf4bffe85e3ac6feb23a182899f8ae41384f7a2bc5ea73d6020ccb98fd5d623ee92858ad4ad0e4
+  data.tar.gz: ef633b1dbf356e0164cd5e63b55f41e59bc1731e621c32a9b220824cd1bb9a4e8de2703fe5f0248ca680c9fbe114c6110743c6f532db2ccda8768e64284b035d

data/lib/modules/alphabetics.rb

@@ -0,0 +1,23 @@
+module Alphabetics
+  def to_upper_alpha(num)
+    to_lower_alpha(num).upcase
+  end
+
+  def to_lower_alpha(num)
+    num_to_alph(num)
+  end
+
+  ALPH = ("a" .. "z").to_a
+
+  def num_to_alph(num)
+    num = num.to_i
+    repetition = num > 26 ? calc_repetition(num) : 1
+    real_num = num > 26 ? num % 26 : num
+    real_num = 26 if real_num == 0
+    ALPH[real_num - 1] * repetition
+  end
+
+  def calc_repetition(num)
+    num % 26 == 0 ? num / 26 : (num / 26) + 1
+  end
+end

data/lib/modules/number_words.rb

@@ -0,0 +1,168 @@
+module NumberWords
+
+  WORDS = {
+    '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'
+  }
+  LARGE_NUMS = {
+    1 => 'thousand',
+    2 => 'million',
+    3 => 'billion',
+    4 => 'trillion'
+  }
+  ORDINALS = {
+    'one' => 'first',
+    'two' => 'second',
+    'three' => 'third',
+    'four' => 'fourth',
+    'five' => 'fifth',
+    'six' => 'sixth',
+    'seven' => 'seventh',
+    'eight' => 'eighth',
+    'nine' => 'ninth',
+    'One' => 'First',
+    'Two' => 'Second',
+    'Three' => 'Third',
+    'Four' => 'Fourth',
+    'Five' => 'Fifth',
+    'Six' => 'Sixth',
+    'Seven' => 'Seventh',
+    'Eight' => 'Eighth',
+    'Nine' => 'Ninth'
+  }
+
+  def to_words(num, options = {})
+    NumbersToWords.new(num, options).to_words
+  end
+
+  def to_word_ordinal(num, options = {})
+    text = NumbersToWords.new(num, options).to_words
+    change_last_word(text)
+  end
+
+  def change_last_word(text)
+    words = text.split(/(\W)/)
+    last = words[words.size - 1]
+    new_last = ordinal_word(last)
+    words[words.size - 1] = new_last
+    words.join
+  end
+
+  def ordinal_word(word)
+    ORDINALS[word] || word += 'th'
+  end
+
+  class NumbersToWords
+    attr_reader :num, :options
+    attr_reader :hundred, :large_nums
+    DEFAULTS = {styled: false, case: 'lower', space: ' '}
+
+    def initialize(num, options = {})
+      @num = num.to_s
+      @options = DEFAULTS.merge(options)
+      set_style_opts
+    end
+
+    def set_style_opts
+      @hundred = options[:styled] ? 'hundred and' : 'hundred'
+      @large_nums = options[:styled] ? large_nums_with_commas : LARGE_NUMS
+    end
+
+    def large_nums_with_commas
+      large_nums = LARGE_NUMS.dup
+      large_nums.each { |k,v| large_nums[k] = "#{v}," }
+      large_nums
+    end
+
+    def to_words
+      arr = num.each_char.to_a
+      groups = arr.reverse.each_slice(3).to_a
+      collector = words_for_groups(groups)
+      formatted_words(collector)
+    end
+
+    def formatted_words(collector)
+      words = collector.reverse.join(options[:space]).gsub(/,$/,'')
+      return words unless options[:case] == 'upper'
+      words.split(/(\W)/).map(&:capitalize).join.gsub(/ and/i, ' and')
+    end
+
+    def words_for_groups(groups)
+      collector = []
+      groups.each_with_index do |group, i|
+        next if group.all? { |e| e == '0' }
+        rearrange_group(group)
+        words = word_group(group, i)
+        collector << words
+      end
+      collector
+    end
+
+    def rearrange_group(group)
+      group.reverse!
+      group.shift while group.first == '0'
+    end
+
+    def word_group(group, i)
+      words = basic_word_group(group)
+      words += options[:space] + large_nums[i] if large_nums[i]
+      words
+    end
+
+    def basic_word_group(group)
+      case group.size
+        when 0; ''
+        when 1; WORDS[group[0]]
+        when 2; tenner(group[0], group[1])
+        when 3; hundreder(group)
+      end
+    end
+
+    def hundreder(group)
+      tens = tenner(group[1], group[2])
+      hundred_joiner = tens.empty? ? 'hundred' : hundred
+      [WORDS[group[0]],
+       hundred_joiner,
+       tens
+      ].reject { |n| n.empty? }.join(options[:space])
+    end
+
+    def tenner(first, second)
+      return '' if first == '0' and second == '0'
+      return WORDS[second] if first == '0' and second != '0'
+      return WORDS[first + second] if first == '1' or second == '0'
+      joined_tenner(first, second)
+    end
+
+    def joined_tenner(first, second)
+      joiner = options[:styled] ? '-' : options[:space]
+      WORDS[first + '0'] + joiner + WORDS[second]
+    end
+  end
+end

data/lib/modules/ordinals.rb

@@ -0,0 +1,20 @@
+# taken straight from activesupport/lib/active_support/inflector/methods.rb
+module Ordinals
+  def to_ordinal(num)
+    "#{num}#{ordinal(num)}"
+  end
+
+  def ordinal(number)
+    abs_number = number.to_i.abs
+    if (11..13).include?(abs_number % 100)
+      "th"
+    else
+      case abs_number % 10
+        when 1; "st"
+        when 2; "nd"
+        when 3; "rd"
+        else "th"
+      end
+    end
+  end
+end

data/lib/modules/roman_numerals.rb

@@ -0,0 +1,33 @@
+# adapted without any substanial changes from https://github.com/AndrewVos/roman-numerals
+module RomanNumerals
+  BASE_DIGITS = {
+    1 => 'I',
+    4 => 'IV',
+    5 => 'V',
+    9 => 'IX',
+    10 => 'X',
+    40 => 'XL',
+    50 => 'L',
+    90 => 'XC',
+    100 => 'C',
+    400 => 'CD',
+    500 => 'D',
+    900 => 'CM',
+    1000 => 'M'
+  }
+
+  def to_upper_roman(value)
+    result = ''
+    BASE_DIGITS.keys.reverse.each do |decimal|
+      while value >= decimal
+        value -= decimal
+        result += BASE_DIGITS[decimal]
+      end
+    end
+    result
+  end
+
+  def to_lower_roman(value)
+    to_upper_roman(value).downcase
+  end
+end

data/lib/number_to/fixnum.rb

@@ -0,0 +1,24 @@
+class Fixnum
+  def to_upper_roman
+    NumberTo.to_upper_roman(self)
+  end
+  def to_lower_roman
+    NumberTo.to_lower_roman(self)
+  end
+  def to_upper_alpha
+    NumberTo.to_upper_alpha(self)
+  end
+  def to_lower_alpha
+    NumberTo.to_lower_alpha(self)
+  end
+  def to_ordinal
+    NumberTo.to_ordinal(self)
+  end
+  def to_words(options = {})
+    NumberTo.to_words(self, options)
+  end
+  def to_word_ordinal(options = {})
+    NumberTo.to_word_ordinal(self, options)
+  end
+end
+

data/lib/number_to.rb

@@ -0,0 +1,11 @@
+require 'modules/roman_numerals'
+require 'modules/alphabetics'
+require 'modules/ordinals'
+require 'modules/number_words'
+
+module NumberTo
+  extend RomanNumerals
+  extend Alphabetics
+  extend Ordinals
+  extend NumberWords
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: number_to
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Dan Corrigan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Convenience methods for converting fixnums to various string equivalents.
+  (Alphabetic, roman numerals, ordinals, words.)
+email: dcorrigan@scribenet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/number_to.rb
+- lib/modules/roman_numerals.rb
+- lib/modules/number_words.rb
+- lib/modules/ordinals.rb
+- lib/modules/alphabetics.rb
+- lib/number_to/fixnum.rb
+homepage: http://www.scribenet.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Convenience methods for converting fixnums to various string equivalents.
+test_files: []