slovom 0.1.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## v. 0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slovom.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Svilen Vassilev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Slovom [![Build Status](https://secure.travis-ci.org/tarakanbg/slovom.png)](http://travis-ci.org/tarakanbg/slovom)
+
+A Ruby gem which converts decimal currency numbers into text in Bulgarian language. For use in financial applications, accounting documents, and all other instances requiring currency verbalization.
+
+Handles the specifics of verbally presenting numbers and prices in Bulgarian, including grammatical irregularities, differences due to gender, singularity and plurality and the logic of using or omitting the "and" conjunction from the resulting string.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'slovom'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install slovom
+
+## Usage
+
+Just append the `.slovom` method to the decimal (variable) you want to be presented verbally.
+
+This will return a text string with the currency ammount (in levs) expressed verbally.
+
+```ruby
+product1.price.to_s => "23.00"
+product1.price.slovom => "двадесет и три лева"
+
+product2.price.to_s => "1563.78"
+product2.price.slovom => "хиляда петстотин шестдесет и три лева и седемдесет и осем стотинки"
+
+product3.price.to_s => "0.75"
+product3.price.slovom => "седемдесет и пет стотинки"
+```
+
+It parses numbers of up to 1 quadrillion (1000000000000000), as higher numbers are not likely to be used in financial transactions and hence no need to be expressed verbally. It returns the string "много" if higher number is used.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/slovom.rb

@@ -0,0 +1,151 @@
+#encoding: utf-8
+require "slovom/version"
+require 'bigdecimal'
+
+class BigDecimal
+  def slovom
+    Slovom.slovom(self)
+  end
+end
+
+module Slovom
+  def self.slovom(input)
+    input = input.round(2)
+    levs = input.fix.to_i
+    stotinki = input.frac.to_s('F').gsub("0.", '')
+    stotinki = (stotinki+"0")[0..1].to_i
+    output = ""
+    output += levs_slovom(levs) + levs_title(levs) unless levs_slovom(levs).nil? || levs_slovom(levs) == "много"
+    output += " и " unless levs_slovom(levs).nil? || levs_slovom(levs) == "много" || levs_slovom(stotinki, feminine=true).nil? || levs_slovom(stotinki, feminine=true) == "много"
+    output += levs_slovom(stotinki, feminine=true) + stotinki_title(stotinki) unless levs_slovom(stotinki, feminine=true).nil? || levs_slovom(stotinki, feminine=true) == "много"
+    return output
+  end
+
+private
+  def self.too_big
+    "много"
+  end
+
+  def self.levs_title(levs)
+    levs == 1 ? " лев" : " лева"
+  end
+
+  def self.stotinki_title(stotinki)
+    stotinki == 1 ? " стотинка" : " стотинки"
+  end
+
+  def self.levs_slovom(levs, feminine=nil)
+    case levs
+      when 1..99 then below_hundred(levs, feminine)
+      when 100..999 then hundreds(levs, feminine)
+      when 1000..999999 then thousands(levs, feminine)
+      when 1000000..999999999999999 then gazillions(levs, feminine)
+      else
+        too_big
+    end
+  end
+
+  def self.below_hundred(digits, feminine=nil)
+    case digits
+    when 1..19 then basic_number(digits, feminine)
+    when 20..99 then round_ten(digits, feminine)
+    end
+  end
+
+  def self.basic_number(digits, feminine=nil)
+    case digits
+      when 1 then
+        feminine == true ? "една" : "един"
+      when 2 then
+        feminine == true ? "две" : "два"
+      when 3 then "три"
+      when 4 then "четири"
+      when 5 then "пет"
+      when 6 then "шест"
+      when 7 then "седем"
+      when 8 then "осем"
+      when 9 then "девет"
+      when 10 then "десет"
+      when 11 then "единадесет"
+      when 12 then "дванадесет"
+      when 13..19 then basic_number(digits.to_s[1].to_i)+"надесет"
+    end
+  end
+
+  def self.round_ten(digits, feminine=nil)
+    second_digit = digits.to_s.reverse.chr.to_i
+    output = basic_number(digits.to_s[0].to_i)+"десет"
+    output += " и " + basic_number(second_digit, feminine) unless second_digit == 0
+    return output
+  end
+
+  def self.hundreds(digits, feminine=nil)
+    final_digits = digits.to_s[1..3].to_i
+    first_digit = digits.to_s[0].to_i
+    case first_digit
+      when 1 then hh = "сто"
+      when 2 then hh = "двеста"
+      when 3 then hh = "триста"
+      when 4..9 then hh = basic_number(first_digit)+"стотин"
+    end
+    output = hh
+    case final_digits
+      when 1..20 then output += " и "
+    end
+    output += " " + levs_slovom(final_digits, feminine) unless final_digits == 0
+    return output.gsub(/\s+/, " ").strip
+  end
+
+  def self.thousands(digits, feminine=nil)
+    count = digits.to_s.length
+    case count
+      when 4 then
+        small = digits.to_s[0].to_i
+        small == 1 ? hh = "хиляда " : hh = levs_slovom(small, feminine = true) + " хиляди "
+        big = digits.to_s[1..3].to_i
+      when 5 then
+        small = digits.to_s[0..1].to_i
+        hh = levs_slovom(small, feminine = true) + " хиляди "
+        big = digits.to_s[2..4].to_i
+      when 6 then
+        small = digits.to_s[0..2].to_i
+        hh = levs_slovom(small, feminine = true) + " хиляди "
+        big = digits.to_s[3..5].to_i
+    end
+    output = hh
+    output += " и " unless (levs_slovom(big).include?(" и ") && big.to_s.length == 3) or levs_slovom(big) == "много"
+    output += levs_slovom(big) unless big == 0
+    return output.gsub(/\s+/, " ").strip
+  end
+
+  def self.gazillions(digits, feminine=nil)
+    count = digits.to_s.length
+    case count
+      when 7..9 then
+        base_count = 7
+        word_plural = " милиона "; word_singular = " милион "
+      when 10..12 then
+        base_count = 10
+        word_plural = " милиарда "; word_singular = " милиард "
+      when 13..15 then
+        base_count = 13
+        word_plural = " трилиона "; word_singular = " трилион "
+    end
+    if count == base_count
+      big_number = digits.to_s[0].to_i
+      small_number = digits.to_s[1..24].to_i
+    elsif count == base_count + 1
+      big_number = digits.to_s[0..1].to_i
+      small_number = digits.to_s[2..24].to_i
+    elsif count == base_count + 2
+      big_number = digits.to_s[0..2].to_i
+      small_number = digits.to_s[3..24].to_i
+    end
+    big_number == 1 ? word = word_singular : word = word_plural
+
+    output = levs_slovom(big_number) + word
+    output += " и " unless levs_slovom(small_number).include? " и " or levs_slovom(small_number) == "много"
+    output += levs_slovom(small_number) unless levs_slovom(small_number) == "много"
+    return output.gsub(/\s+/, " ").strip
+  end
+end

data/lib/slovom/version.rb

@@ -0,0 +1,3 @@
+module Slovom
+  VERSION = "0.1.1"
+end

data/slovom.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/slovom/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Svilen Vassilev"]
+  gem.email         = ["svilen@rubystudio.net"]
+  gem.description   = %q{Converts decimal currency numbers into text in Bulgarian language. For use in financial applications, documents, and all other instances requiring currency verbalization.}
+  gem.summary       = %q{Converts decimal currency numbers into text in Bulgarian language}
+  gem.homepage      = "https://github.com/tarakanbg/slovom"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "slovom"
+  gem.require_paths = ["lib"]
+  gem.version       = Slovom::VERSION
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+end

data/spec/slovom_spec.rb

@@ -0,0 +1,203 @@
+#encoding: utf-8
+require 'bigdecimal'
+require 'spec_helper.rb'
+#require 'string'
+#require 'integer'
+
+describe BigDecimal do
+
+  describe "input" do
+    it "rounds correctly" do
+      input = BigDecimal.new("10.202")
+      input.round(2).should eq(BigDecimal.new("10.20"))
+      input.round(2).to_s.should eq(BigDecimal.new("10.20").to_s)
+    end
+
+    it "splits levs" do
+      input = BigDecimal.new("10.20")
+      levs = input.fix.to_i
+      levs.should eq(10)
+    end
+
+    it "splits stotinki" do
+      input = BigDecimal.new("10.20")
+      stotinki = input.frac.to_s('F').gsub("0.", '')
+      stotinki.should eq("2")
+      stotinki = stotinki+"0" if stotinki.length == 1
+      stotinki.should eq("20")
+      stotinki = stotinki.to_i
+      stotinki.should eq(20)
+    end
+  end
+
+  describe ".slovom" do
+    it "converts stotinki into a valid string" do
+      number = BigDecimal.new("00.56")
+      number.slovom.should eq("петдесет и шест стотинки")
+
+      number = BigDecimal.new("00.05")
+      number.slovom.should eq("пет стотинки")
+
+      number = BigDecimal.new("00.12")
+      number.slovom.should eq("дванадесет стотинки")
+
+      number = BigDecimal.new("00.23")
+      number.slovom.should eq("двадесет и три стотинки")
+
+      number = BigDecimal.new("00.99")
+      number.slovom.should eq("деветдесет и девет стотинки")
+    end
+
+    it "converts levs and stotinki combo into a valid string" do
+      number = BigDecimal.new("1.56")
+      number.slovom.should eq("един лев и петдесет и шест стотинки")
+
+      number = BigDecimal.new("3.05")
+      number.slovom.should eq("три лева и пет стотинки")
+
+      number = BigDecimal.new("10.20")
+      number.slovom.should eq("десет лева и двадесет стотинки")
+
+      number = BigDecimal.new("20.30")
+      number.slovom.should eq("двадесет лева и тридесет стотинки")
+
+      number = BigDecimal.new("14.12")
+      number.slovom.should eq("четиринадесет лева и дванадесет стотинки")
+
+      number = BigDecimal.new("71.23")
+      number.slovom.should eq("седемдесет и един лева и двадесет и три стотинки")
+
+      number = BigDecimal.new("101.99")
+      number.slovom.should eq("сто и един лева и деветдесет и девет стотинки")
+
+      number = BigDecimal.new("514.76")
+      number.slovom.should eq("петстотин и четиринадесет лева и седемдесет и шест стотинки")
+
+      number = BigDecimal.new("1264.34")
+      number.slovom.should eq("хиляда двеста шестдесет и четири лева и тридесет и четири стотинки")
+
+      number = BigDecimal.new("5317.04")
+      number.slovom.should eq("пет хиляди триста и седемнадесет лева и четири стотинки")
+
+      number = BigDecimal.new("14000.15")
+      number.slovom.should eq("четиринадесет хиляди лева и петнадесет стотинки")
+
+      number = BigDecimal.new("78381.92")
+      number.slovom.should eq("седемдесет и осем хиляди триста осемдесет и един лева и деветдесет и две стотинки")
+
+      number = BigDecimal.new("132011.16")
+      number.slovom.should eq("сто тридесет и две хиляди и единадесет лева и шестнадесет стотинки")
+
+      number = BigDecimal.new("1783085.21")
+      number.slovom.should eq("един милион седемстотин осемдесет и три хиляди и осемдесет и пет лева и двадесет и една стотинки")
+
+      number = BigDecimal.new("11316081.07")
+      number.slovom.should eq("единадесет милиона триста и шестнадесет хиляди и осемдесет и един лева и седем стотинки")
+
+      number = BigDecimal.new("159354101.33")
+      number.slovom.should eq("сто петдесет и девет милиона триста петдесет и четири хиляди сто и един лева и тридесет и три стотинки")
+
+      number = BigDecimal.new("56237203102.71")
+      number.slovom.should eq("петдесет и шест милиарда двеста тридесет и седем милиона двеста и три хиляди сто и два лева и седемдесет и една стотинки")
+
+      number = BigDecimal.new("31804319906444.10")
+      number.slovom.should eq("тридесет и един трилиона осемстотин и четири милиарда триста и деветнадесет милиона деветстотин и шест хиляди четиристотин четиридесет и четири лева и десет стотинки")
+
+      number = BigDecimal.new("1.01")
+      number.slovom.should eq("един лев и една стотинка")
+    end
+
+    it "converts levs into a valid string" do
+      number = BigDecimal.new("1.00")
+      number.slovom.should eq("един лев")
+
+      number = BigDecimal.new("2.00")
+      number.slovom.should eq("два лева")
+
+      number = BigDecimal.new("14.00")
+      number.slovom.should eq("четиринадесет лева")
+
+      number = BigDecimal.new("17.00")
+      number.slovom.should eq("седемнадесет лева")
+
+      number = BigDecimal.new("18.00")
+      number.slovom.should eq("осемнадесет лева")
+
+      number = BigDecimal.new("20.00")
+      number.slovom.should eq("двадесет лева")
+
+      number = BigDecimal.new("30.00")
+      number.slovom.should eq("тридесет лева")
+
+      number = BigDecimal.new("76.00")
+      number.slovom.should eq("седемдесет и шест лева")
+
+      number = BigDecimal.new("293.00")
+      number.slovom.should eq("двеста деветдесет и три лева")
+
+      number = BigDecimal.new("303.00")
+      number.slovom.should eq("триста и три лева")
+
+      number = BigDecimal.new("452.00")
+      number.slovom.should eq("четиристотин петдесет и два лева")
+
+      number = BigDecimal.new("811.00")
+      number.slovom.should eq("осемстотин и единадесет лева")
+
+      number = BigDecimal.new("1000.00")
+      number.slovom.should eq("хиляда лева")
+
+      number = BigDecimal.new("1200.00")
+      number.slovom.should eq("хиляда и двеста лева")
+
+      number = BigDecimal.new("1407.00")
+      number.slovom.should eq("хиляда четиристотин и седем лева")
+
+      number = BigDecimal.new("2000.00")
+      number.slovom.should eq("две хиляди лева")
+
+      number = BigDecimal.new("2800.00")
+      number.slovom.should eq("две хиляди и осемстотин лева")
+
+      number = BigDecimal.new("10000.00")
+      number.slovom.should eq("десет хиляди лева")
+
+      number = BigDecimal.new("14100.00")
+      number.slovom.should eq("четиринадесет хиляди и сто лева")
+
+      number = BigDecimal.new("59374.00")
+      number.slovom.should eq("петдесет и девет хиляди триста седемдесет и четири лева")
+
+      number = BigDecimal.new("100000.00")
+      number.slovom.should eq("сто хиляди лева")
+
+      number = BigDecimal.new("200300.00")
+      number.slovom.should eq("двеста хиляди и триста лева")
+
+      number = BigDecimal.new("776315.00")
+      number.slovom.should eq("седемстотин седемдесет и шест хиляди триста и петнадесет лева")
+
+      number = BigDecimal.new("1000000.00")
+      number.slovom.should eq("един милион лева")
+
+      number = BigDecimal.new("156320010.00")
+      number.slovom.should eq("сто петдесет и шест милиона триста и двадесет хиляди и десет лева")
+
+      number = BigDecimal.new("1000001.00")
+      number.slovom.should eq("един милион и един лева")
+
+      number = BigDecimal.new("1000000000.00")
+      number.slovom.should eq("един милиард лева")
+
+      number = BigDecimal.new("121000000000.00")
+      number.slovom.should eq("сто двадесет и един милиарда лева")
+
+      number = BigDecimal.new("1000000000000.00")
+      number.slovom.should eq("един трилион лева")
+
+      number = BigDecimal.new("511000000000000.00")
+      number.slovom.should eq("петстотин и единадесет трилиона лева")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'slovom'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: slovom
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Svilen Vassilev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Converts decimal currency numbers into text in Bulgarian language. For
+  use in financial applications, documents, and all other instances requiring currency
+  verbalization.
+email:
+- svilen@rubystudio.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/slovom.rb
+- lib/slovom/version.rb
+- slovom.gemspec
+- spec/slovom/slovom_spec.rb
+- spec/slovom_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tarakanbg/slovom
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Converts decimal currency numbers into text in Bulgarian language
+test_files:
+- spec/slovom/slovom_spec.rb
+- spec/slovom_spec.rb
+- spec/spec_helper.rb