roman_converter 1.0.0

data/.gitignore

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    roman_converter (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  roman_converter!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Manjunath Manohar
+
+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,32 @@
+# RomanConverter
+
+Roman Converter converts a roman numeral to an english / modern number. 
+
+The gem checks for the validity of the roman numeral string, before converting.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'roman_converter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install roman_converter
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Please add tests for the feature which you have built
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/roman_converter.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../roman_converter/roman.rb', __FILE__)
+require File.expand_path('../roman_converter/roman_util.rb', __FILE__)
+require File.expand_path('../roman_converter/rules.rb', __FILE__)
+
+module RomanConverter
+
+  String.class_eval do
+    def to_number
+      roman = RomanConverter::Roman.new(self)
+      roman.convert_to_number
+    end
+  end
+
+end

data/lib/roman_converter/roman.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../rules.rb', __FILE__)
+require File.expand_path('../roman_util.rb', __FILE__)
+
+module RomanConverter
+  class Roman
+    attr_reader :input, :roman_array
+    attr_accessor :roman_util
+
+    def initialize(string)
+      @input = string
+      @roman_array = @input.split("")
+      @roman_util = RomanConverter::RomanUtil.new(@roman_array)
+    end
+
+    def is_valid?
+      !@roman_util.is_invalid?
+    end
+
+    # Converts the roman numerals into english mumber
+    # => english number / false if invalid roman numeral combination
+    def convert_to_number
+      @roman_util.compute_number
+    end
+
+  end
+end

data/lib/roman_converter/roman_util.rb

@@ -0,0 +1,164 @@
+require File.expand_path('../rules.rb', __FILE__)
+
+module RomanConverter
+  class RomanUtil
+    attr_reader :roman_array
+
+    def initialize(roman_array)
+      @roman_array = roman_array
+    end
+
+    # Converts the roman numerals into english mumber
+    # => english number / false if invalid roman numeral combination
+    def compute_number
+      is_invalid? ? false : generate_number
+    end
+
+
+    # This method can be called directly on the roman_utils object provided the **roman_array** is valid?
+    # Adds the values, if subtraction is required, then the iterator moves back and subtracts the value
+    # => english number
+    def generate_number
+      number = 0
+      @roman_array.each_with_index do |roman_number, array_index|
+        current_element_value = RomanConverter::Rules::Mapper::VALUES[roman_number]
+        number += current_element_value
+        if array_index > 0 
+          previous_element_value = RomanConverter::Rules::Mapper::VALUES[@roman_array[array_index - 1]]
+          if previous_element_value < current_element_value
+            # Here 2 is multiplied as the **previous_element_value** was previously added to the **number**
+            number -= (previous_element_value * 2)
+          end
+        end
+      end
+      number
+    end
+
+    def is_invalid?
+      is_invalid_numerals? ||
+      is_repeating_succession? ||
+      invalidate_never_repeatable_elements? ||
+      invalidate_repeatable_elements? ||
+      invalidate_subtractable_elements?
+    end
+
+    # Checks whether all the elements have proper roman numerals
+    # => true / false
+    def is_invalid_numerals?
+      (@roman_array & RomanConverter::Rules::Mapper::VALUES.keys).size != @roman_array.uniq.size
+    end
+
+    # Returns true if there is more than **MAX_SUCCESSIVE** successive elements
+    # => true/false
+    def is_repeating_succession?
+      !generate_occurrence_list.find{|chunk| chunk.last > RomanConverter::Rules::MAX_SUCCESSIVE}.nil?
+    end
+
+    # Returns true if there are never repeatable elements occuring more than once
+    # => true/false
+    def invalidate_never_repeatable_elements?
+      chunk_hash = generate_occurrence_hash
+      RomanConverter::Rules::Mapper::NEVER_REPEATABLE.select{|element| !chunk_hash[element].nil? }.each do |roman_literal|
+        return true if chunk_hash[roman_literal] > 1
+      end
+      return false
+    end
+
+    # Returns true if there are repeatable elements occuring more than **MAX_OCCURENCE**
+    # Also, checks if there occurs repeatable elements occurring **MAX_OCCURENCE** times and respecting the condition
+    # that it needs to be interleaved.
+    # => true/false
+    def invalidate_repeatable_elements?
+      chunk_hash = generate_occurrence_hash
+      chunk_list = generate_occurrence_list
+      RomanConverter::Rules::Mapper::REPEATABLE.each do |roman_literal|
+        next if chunk_hash[roman_literal].nil?
+        if chunk_hash[roman_literal] > RomanConverter::Rules::MAX_OCCURENCE
+          return true
+        elsif chunk_hash[roman_literal] == Rules::MAX_OCCURENCE
+          chunk_list_index = chunk_list.find_index{|chunk_array| chunk_array.first == roman_literal}
+          next_index = chunk_list_index + 1
+          # Check for only one small character can occur between **MAX_OCCCURRENCE** times repeating character is made.
+          return true if chunk_list[next_index].nil? || (chunk_list[next_index].last > 1) || compare_mapper_values?(chunk_list[next_index].first, roman_literal, false)
+        end
+      end
+      return false
+    end
+
+    # invalidates the subtraction rules
+    # This method assumes that the **NEVER_REPEATABLE** elements occur only once.
+    # Thus this method must be called after the **invalidate_never_repeatable_elements?** 
+    # => true / false
+    def invalidate_subtractable_elements?
+      RomanConverter::Rules::Mapper::NEVER_REPEATABLE.each do |roman_literal|
+        next_element = get_next_elements(roman_literal).first
+        return true if !next_element.nil? && compare_mapper_values?(next_element, roman_literal, false)
+      end
+      RomanConverter::Rules::Mapper::SUBTRACTABLE_ELEMENTS.each do |roman_literal|
+        next_elements = get_next_elements(roman_literal)
+        next_elements.each do |next_element|
+          return true if !next_element.nil? && can_subtract?(roman_literal, next_element) && !RomanConverter::Rules::Mapper::SUBTRACTABLE_ELIGIBLE[roman_literal].include?(next_element)
+        end
+      end
+      return false
+    end
+
+  private
+
+    def can_subtract?(key1, key2)
+      compare_mapper_values?(key1, key2)
+    end
+
+    def compare_mapper_values?(key1, key2, lesser = true)
+      lesser ? mapper_value_less_than?(key1, key2) : mapper_value_greater_than?(key1, key2)
+    end
+
+    def mapper_value_greater_than?(key1, key2)
+      RomanConverter::Rules::Mapper::VALUES[key1] > RomanConverter::Rules::Mapper::VALUES[key2]
+    end
+
+    def mapper_value_less_than?(key1, key2)
+      RomanConverter::Rules::Mapper::VALUES[key1] < RomanConverter::Rules::Mapper::VALUES[key2]
+    end
+    
+    # Returns the next elements of the matched elements with **roman_literal** in the array
+    # => **@roman_array** = [1, 2, 3, 4, 5, 7, 1]   
+    # => get_next_elements(1)
+    # => [2, nil]
+    # => get_next_elements(2)
+    # => [3]
+    def get_next_elements(roman_literal)
+      index_map = @roman_array.map.with_index.to_a
+      selected_array = index_map.select { |index_array| index_array.first == roman_literal }
+      selected_array.collect{ |index_array| @roman_array[index_array.last + 1]}
+    end
+
+    # => generate_occurrence_hash([1,2,3,4,6,6,6,1,6])
+    # => {1=>2, 2=>1, 3=>1, 4=>1, 6=>4}
+    def generate_occurrence_hash
+      occurrence_hash = {}
+      generate_chunks do |category, chunk_array|
+        num = occurrence_hash[category]
+        occurrence_hash[category] = num.to_i + chunk_array.size
+      end
+      occurrence_hash
+    end
+
+    # => generate_occurrence_list([1,2,3,4,6,6,6,1,6])
+    # => [[1, 1], [2, 1], [3, 1], [4, 1], [6, 3], [1, 1], [6, 1]]
+    def generate_occurrence_list
+      generate_chunks do |category, chunk_array|
+        [category, chunk_array.size]
+      end
+    end
+
+    # The method below categorises the successive elements and groups and returns based on the block
+    # => generate_chunks([1,2,3,4,6,6,6]){|a, b| [a, b.size]}
+    # => [[1, 1], [2, 1], [3, 1], [4, 1], [6, 3]]
+    def generate_chunks(&block)
+      @roman_array.chunk{|y| y}.map do |category, chunk_array|
+        block.call(category, chunk_array)
+      end
+    end
+  end
+end

data/lib/roman_converter/rules.rb

@@ -0,0 +1,27 @@
+module RomanConverter
+  module Rules
+    MAX_SUCCESSIVE = 3
+    MAX_OCCURENCE = 4    
+    module Mapper
+      VALUES = {
+        "I" => 1,
+        "V" => 5,
+        "X" => 10,
+        "L" => 50,
+        "C" => 100,
+        "D" => 500,
+        "M" => 1000
+      }
+
+      REPEATABLE = ["I", "X", "C", "M"]
+      NEVER_REPEATABLE = ["D", "L", "V"]
+
+      SUBTRACTABLE_ELEMENTS = ["I", "X", "C"]
+      SUBTRACTABLE_ELIGIBLE = {
+        "I" => ["V", "X"],
+        "X" => ["L", "C"],
+        "C" => ["D", "M"]
+      }
+    end
+  end
+end

data/lib/roman_converter/version.rb

@@ -0,0 +1,3 @@
+module RomanConverter
+  VERSION = "1.0.0"
+end

data/roman_converter.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/roman_converter/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Manjunath Manohar"]
+  gem.email         = ["manjunath.nm89@gmail.com"]
+  gem.description   = "Roman Converter converts a roman numeral to an english / modern number. Making sure all rules invloved in the formation of a roman numeral is obeyed."
+  gem.summary       = "Roman Converter converts a roman numeral to an english / modern number"
+  gem.homepage      = "http://technical-arsenal.blogspot.in"
+
+  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          = "roman_converter"
+  gem.require_paths = ["lib"]
+  gem.version       = RomanConverter::VERSION
+  
+  gem.add_development_dependency 'debugger'
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+
+def assert_false(boolean)
+  assert !boolean
+end
+
+def create_roman_util(string)
+  RomanConverter::RomanUtil.new(create_roman_array(string))
+end
+
+def create_roman(string)
+  RomanConverter::Roman.new(string)
+end
+
+def create_roman_array(input_string)
+  input_string.split("")
+end

data/test/unit/roman_converter/roman_test.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require File.expand_path('../../../../lib/roman_converter/roman.rb', __FILE__)
+require File.expand_path('../../../../test/test_helper.rb', __FILE__)
+
+class RomanConverter::RomanTest < Test::Unit::TestCase
+  def test_is_valid?
+    roman = create_roman("XVI")
+    assert_equal "XVI", roman.input
+    assert_equal ["X", "V", "I"], roman.roman_array
+    assert roman.is_valid?
+    assert_equal 16, roman.convert_to_number
+
+    roman = create_roman("XXVI")
+    assert roman.is_valid?
+    assert_equal 26, roman.convert_to_number
+
+    roman = create_roman("VV")
+    assert_false roman.is_valid?
+    assert_false roman.convert_to_number
+  end
+
+  def test_convert_to_number
+    roman = create_roman("D")
+    assert_equal 500, roman.convert_to_number
+
+    roman = create_roman("M")
+    assert_equal 1000, roman.convert_to_number
+
+    roman = create_roman("V")
+    assert_equal 5, roman.convert_to_number
+
+    roman = create_roman("IV")
+    assert_equal 4, roman.convert_to_number
+
+    roman = create_roman("XXXIX")
+    assert_equal 39, roman.convert_to_number
+
+    roman = create_roman("MCMXC")
+    assert_equal 1990, roman.convert_to_number
+
+    roman = create_roman("CV")
+    assert_equal 105, roman.convert_to_number
+
+    roman = create_roman("XV")
+    assert_equal 15, roman.convert_to_number
+
+    roman = create_roman("MMXIII")
+    assert_equal 2013, roman.convert_to_number    
+
+    roman = create_roman("XVI")
+    assert_equal 16, roman.convert_to_number    
+
+    roman = create_roman("MMXIIII")
+    assert_false roman.convert_to_number    
+
+    roman = create_roman("VC")
+    assert_false roman.convert_to_number
+  end
+end

data/test/unit/roman_converter/roman_util_test.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+require File.expand_path('../../../../lib/roman_converter/roman_util.rb', __FILE__)
+require File.expand_path('../../../../test/test_helper.rb', __FILE__)
+
+class RomanConverter::RomanUtilTest < Test::Unit::TestCase
+
+  def test_is_invalid_numerals
+    roman_util = create_roman_util("MXVIMANJU")
+    assert roman_util.is_invalid?
+    assert roman_util.is_invalid_numerals?
+
+    roman_util = create_roman_util("MXVI")
+    assert_false roman_util.is_invalid_numerals?
+
+    roman_util = create_roman_util("X")
+    assert_false roman_util.is_invalid_numerals?
+
+    roman_util = create_roman_util("AM")
+    assert roman_util.is_invalid_numerals?
+  end
+
+  def test_is_repeating_succession
+    roman_util = create_roman_util("MXVI")
+    assert_false roman_util.is_repeating_succession?
+
+    roman_util = create_roman_util("MMMCM")
+    assert_false roman_util.is_repeating_succession?
+
+    roman_util = create_roman_util("MMMMM")
+    assert roman_util.is_repeating_succession?
+    assert roman_util.is_invalid?
+
+    roman_util = create_roman_util("MMMMCCCCC")
+    assert roman_util.is_repeating_succession?
+    assert roman_util.is_invalid?
+  end
+
+  def test_invalidate_never_repeatable_elements
+    roman_util = create_roman_util("CD")
+    assert_false roman_util.invalidate_never_repeatable_elements?
+
+    roman_util = create_roman_util("DDD")
+    assert roman_util.invalidate_never_repeatable_elements?
+    assert roman_util.is_invalid?
+
+    roman_util = create_roman_util("XLLL")
+    assert roman_util.invalidate_never_repeatable_elements?    
+    assert roman_util.is_invalid?
+  end
+
+  def test_invalidate_repeatable_elements_for_greater_than_max_occurrence
+    roman_util = create_roman_util("CCCD")
+    assert_false roman_util.invalidate_repeatable_elements?
+
+    roman_util = create_roman_util("XXXIX")
+    assert_false roman_util.invalidate_repeatable_elements?    
+
+    roman_util = create_roman_util("CCCDCC")
+    assert roman_util.invalidate_repeatable_elements?
+
+    roman_util = create_roman_util("III")
+    assert_false roman_util.invalidate_repeatable_elements?    
+
+    roman_util = create_roman_util("IIII")
+    assert roman_util.invalidate_repeatable_elements?
+  end
+
+  def test_invalidate_repeatable_elements_for_separated_by_a_single_small_value
+    roman_util = create_roman_util("XXXIX")
+    assert_false roman_util.invalidate_repeatable_elements?
+
+    roman_util = create_roman_util("XXXIIX")
+    assert roman_util.invalidate_repeatable_elements?
+
+    roman_util = create_roman_util("XXXCX")
+    assert roman_util.invalidate_repeatable_elements?
+  end
+
+  def test_invalidate_subtractable_elements_for_never_repeatable
+    roman_util = create_roman_util("D")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("DI")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("ID")
+    assert roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("IV")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("IX")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("XL")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("XV")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("CD")
+    assert_false roman_util.invalidate_subtractable_elements?
+
+    roman_util = create_roman_util("VC")
+    assert roman_util.invalidate_subtractable_elements?
+  end
+
+  def test_compute_number
+    roman_util = create_roman_util("D")
+    assert_equal 500, roman_util.compute_number
+
+    roman_util = create_roman_util("M")
+    assert_equal 1000, roman_util.compute_number
+
+    roman_util = create_roman_util("V")
+    assert_equal 5, roman_util.compute_number
+
+    roman_util = create_roman_util("IV")
+    assert_equal 4, roman_util.compute_number
+
+    roman_util = create_roman_util("XXXIX")
+    assert_equal 39, roman_util.compute_number
+
+    roman_util = create_roman_util("MCMXC")
+    assert_equal 1990, roman_util.compute_number
+
+    roman_util = create_roman_util("CV")
+    assert_equal 105, roman_util.compute_number
+
+    roman_util = create_roman_util("XV")
+    assert_equal 15, roman_util.compute_number
+
+    roman_util = create_roman_util("MMXIII")
+    assert_equal 2013, roman_util.compute_number    
+
+    roman_util = create_roman_util("XVI")
+    assert_equal 16, roman_util.compute_number    
+
+    roman_util = create_roman_util("MMXIIII")
+    assert_false roman_util.compute_number    
+
+    roman_util = create_roman_util("VC")
+    assert_false roman_util.compute_number
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: roman_converter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Manjunath Manohar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debugger
+  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: Roman Converter converts a roman numeral to an english / modern number.
+  Making sure all rules invloved in the formation of a roman numeral is obeyed.
+email:
+- manjunath.nm89@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/roman_converter.rb
+- lib/roman_converter/roman.rb
+- lib/roman_converter/roman_util.rb
+- lib/roman_converter/rules.rb
+- lib/roman_converter/version.rb
+- roman_converter.gemspec
+- test/test_helper.rb
+- test/unit/roman_converter/roman_test.rb
+- test/unit/roman_converter/roman_util_test.rb
+homepage: http://technical-arsenal.blogspot.in
+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.24
+signing_key: 
+specification_version: 3
+summary: Roman Converter converts a roman numeral to an english / modern number
+test_files:
+- test/test_helper.rb
+- test/unit/roman_converter/roman_test.rb
+- test/unit/roman_converter/roman_util_test.rb