romaniac 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/.travis.yml

@@ -0,0 +1,12 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree
+  - rbx-18mode
+  - rbx-19mode
+  - jruby
+
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENCE

@@ -0,0 +1,19 @@
+Copyright (C) MMXII Kyrylo Silin
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

data/README.md

@@ -0,0 +1,160 @@
+Romaniac
+![Romaniac][logo]
+========
+
+* Repository: [https://github.com/kyrylo/romaniac/][repo]
+
+Description
+-----------
+
+Romaniac turns you into a Roman numerals maniac. Blimey, not really… But! At
+at least you will be able to operate on some numbers.
+
+Installation
+------------
+
+    gem install romaniac
+
+Synopsis
+--------
+
+Basic example.
+
+```ruby
+require 'romaniac'
+
+ten = Roman(10) #=> (Roman: X)
+twelve = Roman(12) #=> (Roman: XII)
+puts ten.to_i #=> 10
+
+# Also, you can use strings as arguments.
+Roman('53') #=> (Roman: LIII)
+Roman('4444') #=> ArgumentError: invalid value for Roman(): "4444"/
+
+puts <<yummy
+Hi!
+My name is Kyrylo #{ Roman(1) }.
+I have #{ Roman(3) } chocolate bars.
+I just ate #{ Roman(2) } of them!
+yummy
+
+# Prints out:
+Hi!
+My name is Kyrylo I.
+I have III chocolate bars.
+I just ate II of them!
+```
+
+Arthmetic operations.
+
+```ruby
+# Addition.
+puts Roman(20) + Roman(5) #=> (Roman: XV)
+
+# Subtraction.
+Roman(20) - Roman(5) #=> (Roman: XV)
+
+# Division.
+puts Roman(20) / Roman(5) #=> (Roman: IV)
+
+# Multiplication.
+puts Roman(20) * Roman(5) #=> (Roman: C)
+```
+
+Comparison methods.
+
+```ruby
+Roman(20) > Roman(5) #=> true
+Roman(20) < Roman(5) #=> false
+Roman(20) == Roman(20) #=> true
+```
+
+If you feel brave enough, you can use monkey-patches.
+
+```ruby
+require 'romaniac/ext'
+
+10.to_roman #=> X
+
+# Enumerable goodness.
+(:a..:c).each_with_roman_index.to_a
+#=> [[:a, (Roman: I)], [:b, (Roman: II)], [:c, (Roman: III)]]
+(:a..:c).map.with_roman_index(10).to_a
+#=> [[:a, (Roman: X)], [:b, (Roman: XI)], [:c, (Roman: XII)]
+```
+
+If that is not enough for you, use Ruby constants as Roman numerals.
+
+```ruby
+require 'romaniac/const'
+
+# Hrhr!
+puts III + C #=> (Roman: CIII)
+puts C / L #=> (Roman: II)
+```
+
+Pseudo real world example.
+
+```ruby
+# my_school_schedule.rb
+require 'romaniac/ext'
+
+puts 'TUESDAY', '-------'
+{
+  '08:30' => '09:15',
+  '09:20' => '10:05',
+  '10:15' => '11:00',
+  '11:10' => '12:55',
+  '13:15' => '14:00',
+  '14:10' => '14:55',
+  '15:10' => '15:55'
+}.each.with_roman_index do |(t_begin, t_end), index|
+  printf("%4s %5s - %5s\n", index, t_begin, t_end)
+end
+
+# Will print out:
+
+TUESDAY
+-------
+   I 08:30 - 09:15
+  II 09:20 - 10:05
+ III 10:15 - 11:00
+  IV 11:10 - 12:55
+   V 13:15 - 14:00
+  VI 14:10 - 14:55
+ VII 15:10 - 15:55
+```
+
+Limitations
+-----------
+
+### Ruby implementations support
+
+* MRI 1.8.7
+* MRI 1.9.2
+* MRI 1.9.3
+* Latest REE
+* JRuby 1.7.0
+* Rubinius 1.2.4
+
+Well, maybe in future (but screw it for now)
+--------------------------------------------
+
+Basically, these two features are intertwined.
+
+* unicode support (so you can use Ⅷ or ⅷ instead of VIII);
+* extended number limit (current limit is 3999, but can be extended up to
+  399999 with help of unicode).
+
+Credits
+-------
+
+* Thanks to Jovanny Lemonad for Philosopher font;
+
+Licence
+-------
+
+The project uses Zlib License. See LICENCE file for more information.
+
+[logo]: http://img-fotki.yandex.ru/get/4138/98991937.f/0_8bb4e_ed3d7992_orig "Romaniac"
+[repo]: https://github.com/kyrylo/romaniac/

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test  do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/romaniac.rb

@@ -0,0 +1,88 @@
+require 'romaniac/converter'
+
+def Roman(int)
+  Romaniac.new(int)
+end
+
+class Romaniac
+  # The VERSION file must be in the root directory of the library.
+  VERSION_FILE = File.expand_path('../../VERSION', __FILE__)
+
+  VERSION = File.exist?(VERSION_FILE) ?
+    File.read(VERSION_FILE) : '(could not find VERSION file)'
+
+  # The maximum possible Roman numeral.
+  LIMIT = 3999
+
+  ARABIC_PATTERN = /\A\d{1,4}\z/
+
+  DivisionError = Class.new(StandardError)
+
+  include Comparable
+
+  def initialize(int)
+    validate(int)
+    @int   = int.to_i
+    @roman = Romaniac::Converter.to_roman(@int)
+  end
+
+  def inspect
+    "(Roman: #@roman)"
+  end
+
+  def to_i
+    @int
+  end
+
+  def to_s
+    @roman
+  end
+
+  def <=>(other)
+    @int <=> other.to_i
+  end
+
+  def +(other)
+    self.class.new(@int + other.to_i)
+  end
+
+  def -(other)
+    self.class.new(@int - other.to_i)
+  end
+
+  def /(other)
+    int, fraction = @int.divmod(other.to_i)
+    if fraction.zero?
+      self.class.new(int)
+    else
+      raise Romaniac::DivisionError, "quotient isn't an integer"
+    end
+  end
+
+  def *(other)
+    self.class.new(@int * other.to_i)
+  end
+
+  private
+
+  def validate(int)
+    if int.is_a?(String)
+      valid_int = (int =~ ARABIC_PATTERN && (i = int.to_i) > 0 && i <= LIMIT)
+      if !valid_int
+        raise ArgumentError, %|invalid value for Roman(): "#{ int }"|
+      else
+        return
+      end
+    end
+
+    if !int.is_a?(Fixnum)
+      raise TypeError, "can't convert #{ int.class } into Roman"
+    end
+
+    if int <= 0
+      raise RangeError, 'integer is too small to convert into Roman'
+    elsif int > LIMIT
+      raise RangeError, 'integer is too big to convert into Roman'
+    end
+  end
+end

data/lib/romaniac/const.rb

@@ -0,0 +1,35 @@
+class Romaniac::Const
+
+  ROMAN_PATTERN =
+    /\A(?i)M{0,3}(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])\z/i
+
+  # Handles the case when this file is required
+  # in the middle of a running program.
+  Romaniac::Converter::ARABIC_ROMAN.each_pair do |k, v|
+    Object.const_set(v, Roman(k))
+  end
+
+  def self.define!(name)
+    if Romaniac::Converter::ARABIC_ROMAN.has_value?(name)
+      if RUBY_VERSION == '1.8.7'
+        arabic = Romaniac::Converter::ARABIC_ROMAN.index(name)
+      else
+        arabic = Romaniac::Converter::ARABIC_ROMAN.key(name)
+      end
+    else
+      arabic = Romaniac::Converter.roman_to_arabic(name)
+    end
+    Object.const_set(name, Roman(arabic))
+  end
+
+end
+
+class Object
+  def self.const_missing(name)
+    if (name = name.to_s) =~ Romaniac::Const::ROMAN_PATTERN
+      Romaniac::Const.define!(name)
+    else
+      super
+    end
+  end
+end

data/lib/romaniac/converter.rb

@@ -0,0 +1,109 @@
+class Romaniac
+  module Converter
+
+    MAP = {
+      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'
+    }
+
+    INVERTED_MAP = [
+      ['M' , 1000],
+      ['CM',  900],
+      ['D' ,  500],
+      ['CD',  400],
+      ['C' ,  100],
+      ['XC',   90],
+      ['L' ,   50],
+      ['XL',   40],
+      ['X' ,   10],
+      ['IX',    9],
+      ['V' ,    5],
+      ['IV',    4],
+      ['I' ,    1]
+    ]
+
+    # Arabic numerals are used as key points that come in handy when the library
+    # dynamically creates new numerals.
+    KEY_POINTS = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
+
+    # Raw table of Arabic and Roman numerals. Fills out lazily.
+    ARABIC_ROMAN = Hash.new do |hash, int|
+                     hash[int] = addends_of(int).map { |addend|
+                       if hash.has_key?(addend)
+                         hash[addend]
+                       else
+                         arabic_to_roman(addend)
+                       end
+                     }.join('')
+                   end
+
+    class << self
+      # @api private
+      # @example
+      #   addends_of(6969) #=> [6000, 900, 60, 9]
+      # @param [Integer] int
+      # @return [Array] addends of +int+ with base of 10
+      def addends_of(int)
+        addends = []
+        pad     = 0
+        while int > 0
+          int, elem = int.divmod(10)
+          addends.unshift(10**pad * elem)
+          pad += 1
+        end
+        addends
+      end
+
+      # @api private
+      # @example
+      #   arabic_to_roman(142) #=> "CXLII"
+      # @param [Integer] int
+      # @return [String]
+      def arabic_to_roman(int)
+        roman = ''
+        while int > 0
+          point = KEY_POINTS.find { |key_point| key_point <= int }
+          times, int = int.divmod(point)
+          roman << MAP[point] * times
+        end
+        roman
+      end
+
+      # @api private
+      def to_roman(int)
+        ARABIC_ROMAN[int]
+      end
+
+      # @api private
+      # Also, stores the results of calculations into the ARABIC_ROMAN hash.
+      # @example
+      #   arabic_to_roman("CXLII") #=> 142
+      # @param [String] roman
+      # @return [Integer]
+      def roman_to_arabic(roman)
+        arabic = 0
+        r = roman.dup
+        INVERTED_MAP.each do |k, v|
+          while r.index(k) == 0
+            arabic += v
+            r.slice!(k)
+          end
+        end
+        ARABIC_ROMAN.merge!({ arabic => roman })
+        arabic
+      end
+    end
+
+  end
+end

data/lib/romaniac/ext.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path('../ext/*.rb', __FILE__)].each do |file|
+  require file
+end

data/lib/romaniac/ext/enumerable.rb

@@ -0,0 +1,14 @@
+module Enumerable
+  def with_roman_index(offset = 1)
+    return to_enum(:with_roman_index, offset) unless block_given?
+    each do |o|
+      val = yield(o, Roman(offset))
+      offset += 1
+      val
+    end
+  end
+
+  def each_with_roman_index(&block)
+    with_roman_index(&block)
+  end
+end

data/lib/romaniac/ext/fixnum.rb

@@ -0,0 +1,5 @@
+class Fixnum
+  def to_roman
+    Roman(self)
+  end
+end

data/romaniac.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name         = 'romaniac'
+  s.version      = '0.0.1'
+  s.date         = Time.now.strftime('%Y-%m-%d')
+  s.summary      = 'The library for Roman numerals maniacs.'
+  s.description  = 'The Romaniac library converts Arabic numerals to Roman numerals and vice versa.'
+  s.author       = 'Kyrylo Silin'
+  s.email        = 'kyrylosilin@gmail.com'
+  s.homepage     = 'https://github.com/kyrylo/romaniac'
+  s.licenses     = 'zlib'
+
+  s.require_path = 'lib'
+  s.files        = `git ls-files`.split "\n"
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+end

data/test/const_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class Romaniac::ConstTest < MiniTest::Unit::TestCase
+
+  def test_that_they_just_work!
+    assert_equal Roman(100), C
+    assert_equal Roman(103), C + III
+  end
+
+end

data/test/ext/enumerable_test.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class EnumerableTest < MiniTest::Unit::TestCase
+  def test_with_roman_index_method
+    assert_equal [[:a, Roman(1)], [:b, Roman(2)], [:c, Roman(3)]],
+                 [:a, :b, :c].map.with_roman_index.to_a
+  end
+
+  def test_with_roman_index_method_offset
+    assert_equal [[:a, Roman(10)], [:b, Roman(11)], [:c, Roman(12)]],
+                 [:a, :b, :c].map.with_roman_index(10).to_a
+  end
+end

data/test/ext/fixnum_test.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class FixnumTest < MiniTest::Unit::TestCase
+  def test_converting_a_number_to_a_roman_numeral
+    assert_equal Roman(124), 124.to_roman
+  end
+
+  def test_conversion_of_too_big_numbers_raises_exception
+    e = assert_raises RangeError do
+      19214.to_roman
+    end
+    assert_match /integer is too big to convert into Roman/, e.message
+  end
+
+  def test_conversion_of_zero_raises_exception
+    e = assert_raises RangeError do
+      0.to_roman
+    end
+    assert_match /integer is too small to convert into Roman/, e.message
+  end
+
+  def test_conversion_of_negative_numbers_raises_exception
+    e = assert_raises RangeError do
+      0.to_roman
+    end
+    assert_match /integer is too small to convert into Roman/, e.message
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
+
+require 'romaniac'
+require 'romaniac/ext'
+require 'romaniac/const'

data/test/romaniac_test.rb

@@ -0,0 +1,155 @@
+require 'helper'
+
+class RomaniacTest < MiniTest::Unit::TestCase
+  def test_arabic_to_roman_conversion
+    assert_equal '(Roman: I)', Roman(1).inspect
+    assert_equal '(Roman: CI)', Roman(101).inspect
+    assert_equal '(Roman: MMMCMXCIX)', Roman(3999).inspect
+  end
+
+  def test_arabic_to_roman_conversion_from_string
+    assert_equal '(Roman: I)', Roman('1').inspect
+    assert_equal '(Roman: CI)', Roman('101').inspect
+    assert_equal '(Roman: MMMCMXCIX)', Roman('3999').inspect
+  end
+
+  def test_malformed_string_argument_raises_exception
+    e = assert_raises ArgumentError do
+      Roman('...')
+    end
+    assert_match /invalid value for Roman\(\): "..."/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('aaa11')
+    end
+    assert_match /invalid value for Roman\(\): "aaa11"/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('11aaa')
+    end
+    assert_match /invalid value for Roman\(\): "11aaa"/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman(' 11 ')
+    end
+    assert_match /invalid value for Roman\(\): " 11 "/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('4444')
+    end
+    assert_match /invalid value for Roman\(\): "4444"/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('4444sdad')
+    end
+    assert_match /invalid value for Roman\(\): "4444sdad"/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('0')
+    end
+    assert_match /invalid value for Roman\(\): "0"/, e.message
+
+    e = assert_raises ArgumentError do
+      Roman('-4444')
+    end
+    assert_match /invalid value for Roman\(\): "-4444"/, e.message
+  end
+
+  def test_roman_to_arabic_conversion
+    assert_equal 201, Roman(201).to_i
+    assert_equal 3000, Roman(3000).to_i
+    assert_equal 66, Roman(66).to_i
+  end
+
+  def test_zero_to_roman_conversion_raises_exception
+    e = assert_raises RangeError do
+      Roman(0)
+    end
+    assert_match /integer is too small to convert into Roman/, e.message
+  end
+
+  def test_negative_arabic_to_roman_conversion_raises_exception
+    e = assert_raises RangeError do
+      Roman(-1)
+    end
+    assert_match /integer is too small to convert into Roman/, e.message
+  end
+
+  def test_noninteger_argument_value_raises_exception
+    e = assert_raises TypeError do
+      Roman(:'10')
+    end
+    assert_match /can't convert Symbol into Roman/, e.message
+
+    e = assert_raises TypeError do
+      Roman(10.55)
+    end
+    assert_match /can't convert Float into Roman/, e.message
+  end
+
+  def test_too_big_integer_value_raises_exception
+    e = assert_raises RangeError do
+      Roman(4000)
+    end
+    assert_match /integer is too big to convert into Roman/, e.message
+  end
+
+  def test_addition_works_correctly
+    assert_equal Roman(51), Roman(25) + Roman(26)
+  end
+
+  def test_too_big_sum_raises_exception
+    e = assert_raises RangeError do
+      Roman(2000) + Roman(3000)
+    end
+    assert_match /integer is too big to convert into Roman/, e.message
+  end
+
+  def test_subtraction_works_correctly
+    assert_equal Roman(1), Roman(26) - Roman(25)
+  end
+
+  def test_too_small_difference_raises_exception
+    e = assert_raises RangeError do
+      Roman(26) - Roman(26)
+    end
+    assert_match /integer is too small to convert into Roman/, e.message
+  end
+
+  def test_division_works_correctly
+    assert_equal Roman(5), Roman(20) / Roman(4)
+  end
+
+  def test_nonint_quotient_raises_exception
+    e = assert_raises Romaniac::DivisionError do
+      Roman(20) / Roman(3)
+    end
+    assert_match /quotient isn't an integer/, e.message
+  end
+
+  def test_multiplication_works_correctly
+    assert_equal Roman(20), Roman(5) * Roman(4)
+  end
+
+  def test_too_big_product_raises_exception
+    e = assert_raises RangeError do
+      Roman(400) * Roman(300)
+    end
+    assert_match /integer is too big to convert into Roman/, e.message
+  end
+
+  def test_comparison
+    assert Roman(20) == Roman(20)
+    assert Roman(20) > Roman(19)
+    assert Roman(20) < Roman(21)
+    assert Roman(20) != Roman(1)
+    assert Roman(20) >= Roman(20)
+    assert Roman(20) <= Roman(20)
+  end
+
+  def test_to_s_returns_human_readable_representation
+    assert_equal 'C', Roman(100).to_s
+    assert_equal 'CCC', Roman(300).to_s
+    assert_equal 'XXI', Roman(21).to_s
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: romaniac
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kyrylo Silin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-21 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: The Romaniac library converts Arabic numerals to Roman numerals and vice
+  versa.
+email: kyrylosilin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENCE
+- README.md
+- Rakefile
+- VERSION
+- lib/romaniac.rb
+- lib/romaniac/const.rb
+- lib/romaniac/converter.rb
+- lib/romaniac/ext.rb
+- lib/romaniac/ext/enumerable.rb
+- lib/romaniac/ext/fixnum.rb
+- romaniac.gemspec
+- test/const_test.rb
+- test/ext/enumerable_test.rb
+- test/ext/fixnum_test.rb
+- test/helper.rb
+- test/romaniac_test.rb
+homepage: https://github.com/kyrylo/romaniac
+licenses:
+- zlib
+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.24
+signing_key: 
+specification_version: 3
+summary: The library for Roman numerals maniacs.
+test_files: []
+has_rdoc: