cousin_roman 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d721d30a8c9bfff8692b8be996a4b10697fb2d60
-  data.tar.gz: 9134a9f70a990f750a4c904daaa90878aefd6552
+  metadata.gz: f16dc19c0864ea51d64a45d94b4a0acf07cea72b
+  data.tar.gz: d0bd841b1ab1c55cb9ed88ef4671a9d9a134820c
 SHA512:
-  metadata.gz: 6fd61fa7907ce017e491be441e96f00c51e94cb67ac1407965dc15bb3d41caf118f4b4898fe3a885cd0d117b911182aa4a5ce363bb674f0c13d1ca25ae76c919
-  data.tar.gz: fa39c4136a8b29e9d7d7408a37716ed423f1144cf6422b98368838a640ae1b82ee9b2056db4b7de2cc86f7166cb919184cf609d4122708b27db556092a488321
+  metadata.gz: ec7600e60f73656ed7aefa6c1bdaf6a36e70d29943becb1f2d9115cf20f43eb7cc052228d85ad08d74c85e2d996ef5a82bfb395efe46bbadcfaecd7720643ea6
+  data.tar.gz: 9e41c6a9c0f41a90d47258623b6e8088dff534add7ff06ef8d69f2303cbf01c8c00de59bf5f31f4162d513a434eee36838ce7ebeafc6d56817746333c5727283

data/README.md

@@ -1,8 +1,8 @@
 # CousinRoman
 
-`CousinRoman` is a `String` extension which allows you to convert
-Roman numerals (following modern subtractive notation)
-to Arabic numbers (i.e. Integers).
+`CousinRoman` provides functionality to convert between Roman and Arabian numerals.
+
+The functionality provided via String and Integer extensions.
 
 ## Installation
 
@@ -20,14 +20,22 @@ Or install it yourself as:
 
 ## Usage
 
-Just use `String#to_arabic` or `String#to_arabic!` method.
+Just use `String#to_arabian` or `String#to_arabian!` methods
+if you want to convert from Roman to Arabian
+and
+`Integer#to_roman` or `Integer#to_roman!`
+if you want to convert from Arabian to Roman.
 
 For example:
 
 ```ruby
-'MMXIII'.to_arabic # => 2013
-'MMYUOX'.to_arabic # => nil
-'MMYOUX'.to_arabic! # => TypeError: not a valid roman number
+'MMXIII'.to_arabian # => 2013
+'MMYUOX'.to_arabian # => nil
+'MMYOUX'.to_arabian! # => TypeError: not a valid roman number
+
+2013.to_roman # => 'MMXIII'
+'0'.to_roman # => nil
+'100500'.to_roman # => TypeError: not a valid roman number
 ```
 
 ## Testing
@@ -36,7 +44,7 @@ Just run
 
     $ rake
 
-under gem folder.
+under gem folder (be prepared for massive output).
 
 ## Contributing
 

data/cousin_roman.gemspec

@@ -8,14 +8,14 @@ Gem::Specification.new do |spec|
   spec.version       = CousinRoman::VERSION
   spec.authors       = ["Artem Pyanykh"]
   spec.email         = ["artem.pyanykh@gmail.com"]
-  spec.description   = %q{Easily convert Roman numerals to Integers. Functionality provided via String extension}
-  spec.summary       = %q{Convert Roman numerals to Integers}
+  spec.description   = %q{Easily convert Roman and Arabian number. Functionality provided via String and extensions}
+  spec.summary       = %q{Convert Roman numerals to Integers and vice versa}
   spec.homepage      = "https://github.com/ArtemPyanykh/cousin_roman"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)*/})
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"

data/lib/cousin_roman/arabian.rb

@@ -0,0 +1,69 @@
+require 'cousin_roman'
+
+module CousinRoman
+  module Arabian
+    extend self
+
+    def valid?(number)
+      number.is_a? Integer and number >= 1 and number <= 3999
+    end
+
+    def to_roman(arabian)
+      convert arabian if valid? arabian
+    end
+
+    def to_roman!(arabian)
+      if valid? arabian
+        convert arabian
+      else
+        raise TypeError, 'not a valid roman number'
+      end
+    end
+
+    def convert(number)
+      thousands = number / 1000
+      hundreds = number / 100 % 10
+      tens = number / 10 % 10
+      ones = number % 10
+
+      build_roman(thousands, hundreds, tens, ones).upcase
+    end
+
+    def build_roman(thousands, hundreds, tens, ones)
+      build_pow(thousands, 4) +
+      build_pow(hundreds, 3) +
+      build_pow(tens, 2) +
+      build_pow(ones, 1)
+    end
+
+    def build_pow(number, pow)
+      literals = pow_literals(pow)
+
+      case number
+      when 1..3 then literals[:one]*number
+      when 4 then literals[:subtractives][4]
+      when 5..8 then literals[:five] + (literals[:one]*(number - 5))
+      when 9 then literals[:subtractives][9]
+      else ""
+      end
+    end
+
+    def pow_literals(pow)
+      one_literal, _ = ONES.find do |literal, value|
+        value >= 10 ** (pow - 1) and value < 10 ** pow
+      end
+      five_literal, _ = FIVES.find do |literal, value|
+        value >= 10 ** (pow - 1) and value < 10 ** pow
+      end
+      subtractive_literals = {}
+      SUBTRACTIVES.select do |literal, value|
+        value >= 10 ** (pow - 1) and value < 10 ** pow
+      end.each do |literal, number|
+        order = number / (10 ** (pow - 1))
+        subtractive_literals[order] = literal
+      end
+
+      {one: one_literal, five: five_literal, subtractives: subtractive_literals}
+    end
+  end
+end

data/lib/cousin_roman/integer_extension.rb

@@ -0,0 +1,11 @@
+require "cousin_roman/roman"
+
+class Integer
+  def to_roman
+    CousinRoman::Arabian.to_roman(self)
+  end
+
+  def to_roman!
+    CousinRoman::Arabian.to_roman!(self)
+  end
+end

data/lib/cousin_roman/{conversion.rb → roman.rb}

@@ -1,39 +1,9 @@
-module CousinRoman
-  LITERALS = [
-    'i', 'I',
-    'v', 'V',
-    'x', 'X',
-    'l', 'L',
-    'c', 'C',
-    'd', 'D',
-    'm', 'M'
-  ]
-
-  ONES = {
-    'i' => 1,
-    'x' => 10,
-    'c' => 100,
-    'm' => 1000
-  }
-
-  FIVES = {
-    'v' => 5,
-    'l' => 50,
-    'd' => 500,
-  }
+require 'cousin_roman'
 
-  SUBTRACTIVE = {
-    'iv' => 4,
-    'ix' => 9,
-    'xl' => 40,
-    'xc' => 90,
-    'cd' => 400,
-    'cm' => 900,
-  }
-
-  FACTORS = ONES.merge(FIVES).merge(SUBTRACTIVE)
+module CousinRoman
+  module Roman
+    extend self
 
-  class << self
     def valid?(number)
       matches = number.match roman_regex
       matches and !matches[0].empty?
@@ -50,7 +20,7 @@ module CousinRoman
     # 2. Sum this numeric values to get the final answer
     def convert(number)
       intermediate = number.dup.downcase
-      SUBTRACTIVE.each do |factor, value|
+      SUBTRACTIVES.each do |factor, value|
         intermediate.gsub!(factor, "(#{value})")
       end
       ONES.merge(FIVES).each do |factor, value|
@@ -62,12 +32,12 @@ module CousinRoman
       end
     end
 
-    def to_arabic(number)
+    def to_arabian(number)
       clean = number.strip
       convert clean if valid? clean
     end
 
-    def to_arabic!(number)
+    def to_arabian!(number)
       clean = number.strip
       if valid? clean
         convert clean

data/lib/cousin_roman/string_extension.rb

@@ -1,11 +1,11 @@
-require "cousin_roman/conversion"
+require "cousin_roman/roman"
 
 class String
-  def to_arabic
-    CousinRoman.to_arabic(self)
+  def to_arabian
+    CousinRoman::Roman.to_arabian(self)
   end
 
-  def to_arabic!
-    CousinRoman.to_arabic!(self)
+  def to_arabian!
+    CousinRoman::Roman.to_arabian!(self)
   end
 end

data/lib/cousin_roman/version.rb

@@ -1,3 +1,3 @@
 module CousinRoman
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/lib/cousin_roman.rb

@@ -1,3 +1,41 @@
 require "cousin_roman/version"
-require "cousin_roman/conversion"
+require "cousin_roman/roman"
+require "cousin_roman/arabian"
 require "cousin_roman/string_extension"
+require "cousin_roman/integer_extension"
+
+module CousinRoman
+  LITERALS = [
+    'i', 'I',
+    'v', 'V',
+    'x', 'X',
+    'l', 'L',
+    'c', 'C',
+    'd', 'D',
+    'm', 'M'
+  ]
+
+  ONES = {
+    'i' => 1,
+    'x' => 10,
+    'c' => 100,
+    'm' => 1000
+  }
+
+  FIVES = {
+    'v' => 5,
+    'l' => 50,
+    'd' => 500,
+  }
+
+  SUBTRACTIVES = {
+    'iv' => 4,
+    'ix' => 9,
+    'xl' => 40,
+    'xc' => 90,
+    'cd' => 400,
+    'cm' => 900,
+  }
+
+  FACTORS = ONES.merge(FIVES).merge(SUBTRACTIVES)
+end

data/spec/cousin_roman/arabian_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe CousinRoman::Arabian do
+  describe 'valid?' do
+    it 'should consider invalid numbers <= 0' do
+      (-10..0).each do |number|
+        CousinRoman::Arabian.valid?(number).should be_false
+      end
+    end
+
+    it 'should consider valid numbers > 1 and <= 3999' do
+      CousinRoman::Arabian.valid?(1).should be_true
+      CousinRoman::Arabian.valid?(3999).should be_true
+    end
+
+    it 'should consider invalid numbers > 3999' do
+      CousinRoman::Arabian.valid?(4000).should be_false
+    end
+  end
+
+
+  describe 'convert' do
+    1.upto(3999).each do |arabian|
+      it "should succeed on #{arabian}", slow: true do
+        roman = CousinRoman::Arabian.convert(arabian)
+        CousinRoman::Roman.valid?(roman).should be_true
+        CousinRoman::Roman.convert(roman).should == arabian
+      end
+    end
+  end
+
+  describe 'to_roman' do
+    it 'should call convert on valid number' do
+      CousinRoman::Arabian.should_receive(:convert).and_call_original
+      CousinRoman::Arabian.to_roman(1).should == 'I'
+    end
+
+    it 'should return nil on invalid number' do
+      CousinRoman::Arabian.to_roman(100500).should be_nil
+    end
+  end
+
+  describe 'to_roman!' do
+    it 'should call convert on valid number' do
+      CousinRoman::Arabian.should_receive(:convert).and_call_original
+      CousinRoman::Arabian.to_roman!(1).should == 'I'
+    end
+
+    it 'should throw TypeError on invalid number' do
+      expect { CousinRoman::Arabian.to_roman!(100500) }.to raise_error(TypeError)
+    end
+  end
+end

data/spec/cousin_roman/roman_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe CousinRoman::Roman do
+  describe 'valid?' do
+    describe 'literals validation' do
+      ASCII = 0.upto(127).map(&:chr)
+      NON_ROMAN_LITERALS = ASCII - CousinRoman::LITERALS
+
+      CousinRoman::LITERALS.each do |l|
+        it "should allow #{l}" do
+          CousinRoman::Roman.valid?(l).should be_true
+        end
+      end
+
+      NON_ROMAN_LITERALS.each do |l|
+        it "should not allow #{l}" do
+          CousinRoman::Roman.valid?(l).should be_false
+        end
+      end
+
+      it 'should not allow mix of allowed and disallowed literals' do
+        CousinRoman::Roman.valid?('MYCXI').should be_false
+      end
+
+      it 'should not allow empty string' do
+        CousinRoman::Roman.valid?('').should be_false
+      end
+    end
+
+    describe 'factors validation' do
+      CousinRoman::ONES.keys.each do |factor|
+        1.upto(3).each do |reps|
+          it "should allow #{reps} repetitions of #{factor}" do
+            CousinRoman::Roman.valid?(factor*reps).should be_true
+          end
+        end
+
+        it "should not allow more than 3 repetitions of #{factor}" do
+          CousinRoman::Roman.valid?(factor*4).should be_false
+        end
+      end
+
+      CousinRoman::FIVES.merge(CousinRoman::SUBTRACTIVES).keys.each do |factor|
+        it "should not allow repetition of #{factor}" do
+          CousinRoman::Roman.valid?(factor*2).should be_false
+        end
+      end
+
+      it 'should allow ones and fives of the same power' do
+        CousinRoman::FIVES.keys.each_with_index do |five, index|
+          1.upto(3).each do |reps|
+            corresponding_one = CousinRoman::ONES.keys[index]
+            CousinRoman::Roman.valid?(five + (corresponding_one * reps)).should be_true
+          end
+        end
+      end
+
+      it 'should not allow subtractives and ones or fives of the same power' do
+        CousinRoman::Roman.valid?('ivi').should be_false
+        CousinRoman::Roman.valid?('ixi').should be_false
+        CousinRoman::Roman.valid?('xlx').should be_false
+        CousinRoman::Roman.valid?('xcx').should be_false
+        CousinRoman::Roman.valid?('cdc').should be_false
+        CousinRoman::Roman.valid?('cmc').should be_false
+
+        CousinRoman::Roman.valid?('ivv').should be_false
+        CousinRoman::Roman.valid?('ixv').should be_false
+        CousinRoman::Roman.valid?('xll').should be_false
+        CousinRoman::Roman.valid?('xcl').should be_false
+        CousinRoman::Roman.valid?('cdd').should be_false
+        CousinRoman::Roman.valid?('cmd').should be_false
+      end
+    end
+
+    describe 'ordering validation' do
+      context 'when validating that factors are ordered by descreasing of power' do
+        ORDERINGS_RIGHT = [
+          'md', 'mc',
+          'cl', 'cx',
+          'xv', 'xi',
+          'mcm', 'mcd',
+          'cxc', 'cxl',
+          'xix', 'xiv'
+        ]
+        ORDERINGS_WRONG = [
+          'dm', 'lc', 'vx',
+          'cmm', 'cdm',
+          'xcc', 'xlc',
+          'ixx', 'ivx'
+        ]
+
+        ORDERINGS_RIGHT.each do |pair|
+          high, low = pair.split('', 2)
+          it "should allow #{high}#{low}" do
+            CousinRoman::Roman.valid?(high + low).should be_true
+          end
+        end
+
+        ORDERINGS_WRONG.each do |pair|
+          low, high = pair.split('', 2)
+          it "should not allow #{low}#{high}" do
+            CousinRoman::Roman.valid?(low + high).should be_false
+          end
+        end
+      end
+    end
+  end
+
+  describe 'convert' do
+    context 'singular factors' do
+      CousinRoman::FACTORS.each do |factor, number|
+        it "should convert #{factor} to #{number}" do
+          CousinRoman::Roman.convert(factor).should == number
+        end
+      end
+    end
+
+    context 'repetitive factors' do
+      CousinRoman::ONES.each do |factor, number|
+        1.upto(3).each do |reps|
+          it "should convert #{factor*reps} to #{number*reps}" do
+            CousinRoman::Roman.convert(factor*reps).should == (number*reps)
+          end
+        end
+      end
+    end
+
+    context 'different power factors' do
+      it 'should honor ones' do
+        CousinRoman::Roman.convert('mcxi').should == 1111
+      end
+
+      it 'should honor fives' do
+        CousinRoman::Roman.convert('dlv').should == 555
+      end
+
+      it 'should honor ones and fives together' do
+        CousinRoman::Roman.convert('mdclxvi').should == 1666
+      end
+
+      it 'should honor subtractives ones and fives together' do
+        CousinRoman::Roman.convert('mcmlxxxix').should == 1989
+      end
+
+      it 'should honor max number' do
+        CousinRoman::Roman.convert('mmmcmxcix').should == 3999
+      end
+
+      it 'should honor the longest number' do
+        CousinRoman::Roman.convert('dccclxxxviii').should == 888
+      end
+
+      it 'should be case insensitive' do
+        number = 'MCXI'
+        CousinRoman::Roman.convert(number).should == CousinRoman::Roman.convert(number.downcase)
+      end
+    end
+  end
+
+  describe 'to_arabian' do
+    it 'should call convert on valid number' do
+      CousinRoman::Roman.should_receive(:convert).and_call_original
+      CousinRoman::Roman.to_arabian('MMM').should == 3000
+    end
+
+    it 'should return nil on invalid number' do
+      CousinRoman::Roman.to_arabian('YRU?!').should be_nil
+    end
+  end
+
+  describe 'to_arabian!' do
+    it 'should call convert on valid number' do
+      CousinRoman::Roman.should_receive(:convert).and_call_original
+      CousinRoman::Roman.to_arabian!('MMM').should == 3000
+    end
+
+    it 'should throw TypeError on invalid number' do
+      expect { CousinRoman::Roman.to_arabian!('YRU?!') }.to raise_error(TypeError)
+    end
+  end
+
+end

data/spec/cousin_roman_spec.rb

@@ -4,195 +4,26 @@ describe CousinRoman do
   it 'should have a version number' do
     CousinRoman::VERSION.should_not be_nil
   end
-
-  describe 'valid?' do
-    describe 'literals validation' do
-      ASCII = 0.upto(127).map(&:chr)
-      NON_ROMAN_LITERALS = ASCII - CousinRoman::LITERALS
-
-      CousinRoman::LITERALS.each do |l|
-        it "should allow #{l}" do
-          CousinRoman.valid?(l).should be_true
-        end
-      end
-
-      NON_ROMAN_LITERALS.each do |l|
-        it "should not allow #{l}" do
-          CousinRoman.valid?(l).should be_false
-        end
-      end
-
-      it 'should not allow mix of allowed and disallowed literals' do
-        CousinRoman.valid?('MYCXI').should be_false
-      end
-
-      it 'should not allow empty string' do
-        CousinRoman.valid?('').should be_false
-      end
-    end
-
-    describe 'factors validation' do
-      CousinRoman::ONES.keys.each do |factor|
-        1.upto(3).each do |reps|
-          it "should allow #{reps} repetitions of #{factor}" do
-            CousinRoman.valid?(factor*reps).should be_true
-          end
-        end
-
-        it "should not allow more than 3 repetitions of #{factor}" do
-          CousinRoman.valid?(factor*4).should be_false
-        end
-      end
-
-      CousinRoman::FIVES.merge(CousinRoman::SUBTRACTIVE).keys.each do |factor|
-        it "should not allow repetition of #{factor}" do
-          CousinRoman.valid?(factor*2).should be_false
-        end
-      end
-
-      it 'should allow ones and fives of the same power' do
-        CousinRoman::FIVES.keys.each_with_index do |five, index|
-          1.upto(3).each do |reps|
-            corresponding_one = CousinRoman::ONES.keys[index]
-            CousinRoman.valid?(five + (corresponding_one * reps)).should be_true
-          end
-        end
-      end
-
-      it 'should not allow subtractives and ones or fives of the same power' do
-        CousinRoman.valid?('ivi').should be_false
-        CousinRoman.valid?('ixi').should be_false
-        CousinRoman.valid?('xlx').should be_false
-        CousinRoman.valid?('xcx').should be_false
-        CousinRoman.valid?('cdc').should be_false
-        CousinRoman.valid?('cmc').should be_false
-
-        CousinRoman.valid?('ivv').should be_false
-        CousinRoman.valid?('ixv').should be_false
-        CousinRoman.valid?('xll').should be_false
-        CousinRoman.valid?('xcl').should be_false
-        CousinRoman.valid?('cdd').should be_false
-        CousinRoman.valid?('cmd').should be_false
-      end
-    end
-
-    describe 'ordering validation' do
-      context 'when validating that factors are ordered by descreasing of power' do
-        ORDERINGS_RIGHT = [
-          'md', 'mc',
-          'cl', 'cx',
-          'xv', 'xi',
-          'mcm', 'mcd',
-          'cxc', 'cxl',
-          'xix', 'xiv'
-        ]
-        ORDERINGS_WRONG = [
-          'dm', 'lc', 'vx',
-          'cmm', 'cdm',
-          'xcc', 'xlc',
-          'ixx', 'ivx'
-        ]
-
-        ORDERINGS_RIGHT.each do |pair|
-          high, low = pair.split('', 2)
-          it "should allow #{high}#{low}" do
-            CousinRoman.valid?(high + low).should be_true
-          end
-        end
-
-        ORDERINGS_WRONG.each do |pair|
-          low, high = pair.split('', 2)
-          it "should not allow #{low}#{high}" do
-            CousinRoman.valid?(low + high).should be_false
-          end
-        end
-      end
-    end
-  end
-
-  describe 'convert' do
-    context 'singular factors' do
-      CousinRoman::FACTORS.each do |factor, number|
-        it "should convert #{factor} to #{number}" do
-          CousinRoman.convert(factor).should == number
-        end
-      end
-    end
-
-    context 'repetitive factors' do
-      CousinRoman::ONES.each do |factor, number|
-        1.upto(3).each do |reps|
-          it "should convert #{factor*reps} to #{number*reps}" do
-            CousinRoman.convert(factor*reps).should == (number*reps)
-          end
-        end
-      end
-    end
-
-    context 'different power factors' do
-      it 'should honor ones' do
-        CousinRoman.convert('mcxi').should == 1111
-      end
-
-      it 'should honor fives' do
-        CousinRoman.convert('dlv').should == 555
-      end
-
-      it 'should honor ones and fives together' do
-        CousinRoman.convert('mdclxvi').should == 1666
-      end
-
-      it 'should honor subtractives ones and fives together' do
-        CousinRoman.convert('mcmlxxxix').should == 1989
-      end
-
-      it 'should honor max number' do
-        CousinRoman.convert('mmmcmxcix').should == 3999
-      end
-
-      it 'should honor the longest number' do
-        CousinRoman.convert('dccclxxxviii').should == 888
-      end
-
-      it 'should be case insensitive' do
-        number = 'MCXI'
-        CousinRoman.convert(number).should == CousinRoman.convert(number.downcase)
-      end
-    end
-  end
-
-  describe 'to_arabic' do
-    it 'should call convert on valid number' do
-      CousinRoman.should_receive(:convert).and_call_original
-      CousinRoman.to_arabic('MMM').should == 3000
-    end
-
-    it 'should return nil on invalid number' do
-      CousinRoman.to_arabic('YRU?!').should be_nil
-    end
-  end
-
-  describe 'to_arabic!' do
-    it 'should call convert on valid number' do
-      CousinRoman.should_receive(:convert).and_call_original
-      CousinRoman.to_arabic!('MMM').should == 3000
-    end
-
-    it 'should throw TypeError on invalid number' do
-      expect { CousinRoman.to_arabic!('YRU?!') }.to raise_error(TypeError)
-    end
-  end
-
 end
 
 describe String do
-  [:to_arabic, :to_arabic!].each do |meth|
+  [:to_arabian, :to_arabian!].each do |meth|
     it { should respond_to(meth) }
 
-    it "should call CousinRoman.#{meth} on String##{meth}" do
+    it "should call CousinRoman::Roman.#{meth} on String##{meth}" do
       roman = 'i'
-      CousinRoman.should_receive(meth).with(roman).and_call_original
+      CousinRoman::Roman.should_receive(meth).with(roman).and_call_original
       roman.send(meth).should == 1
     end
   end
 end
+
+describe Integer do
+  [:to_roman, :to_roman!].each do |meth|
+    it "should call CousinRoman::Arabian.#{meth} on Fixnum##{meth}" do
+      arabian = 1
+      CousinRoman::Arabian.should_receive(meth).with(arabian).and_call_original
+      arabian.send(meth).should == 'I'
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cousin_roman
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Artem Pyanykh
@@ -52,8 +52,8 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Easily convert Roman numerals to Integers. Functionality provided via
-  String extension
+description: Easily convert Roman and Arabian number. Functionality provided via String
+  and extensions
 email:
 - artem.pyanykh@gmail.com
 executables: []
@@ -69,9 +69,13 @@ files:
 - Rakefile
 - cousin_roman.gemspec
 - lib/cousin_roman.rb
-- lib/cousin_roman/conversion.rb
+- lib/cousin_roman/arabian.rb
+- lib/cousin_roman/integer_extension.rb
+- lib/cousin_roman/roman.rb
 - lib/cousin_roman/string_extension.rb
 - lib/cousin_roman/version.rb
+- spec/cousin_roman/arabian_spec.rb
+- spec/cousin_roman/roman_spec.rb
 - spec/cousin_roman_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ArtemPyanykh/cousin_roman
@@ -97,7 +101,9 @@ rubyforge_project:
 rubygems_version: 2.1.8
 signing_key: 
 specification_version: 4
-summary: Convert Roman numerals to Integers
+summary: Convert Roman numerals to Integers and vice versa
 test_files:
+- spec/cousin_roman/arabian_spec.rb
+- spec/cousin_roman/roman_spec.rb
 - spec/cousin_roman_spec.rb
 - spec/spec_helper.rb