roman_numbers 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 154520d9143e2297d9ca4437b70f1eb36de4cf57
-  data.tar.gz: 6764dcb2c45acd10300909022016e5c400708ef8
+  metadata.gz: 19a16ed12f582cd4cf0facf87dfb249da2090d44
+  data.tar.gz: 6e46b7f767a96b8aa9e75f3800211edb22c93dd1
 SHA512:
-  metadata.gz: 2c0d2b3fb03daaed1778de72df60e8f94f1496870073a3111998f1fcec225e9366d8830fedfa4f1e966d8f7a16eaf1f7c55d42d680cc351f15e6e131704f12ee
-  data.tar.gz: 1bb43845ca739c2ebded476deb5d8088a199458edbdd1797e3675c1856cc3946c2b95ac6d51583d710b1bb69ef8a744dbff9b1110fdf27fa3e26a7459e736dd4
+  metadata.gz: 0ea20220716f648aa0c48f623e24fcbd6933ba4c3d9f3cb91c20d143a0f8e2e2b3b27e39439daf48e99c4173d1f7b02d67b4dfc7f2b5bc563ae976399f43e31b
+  data.tar.gz: 64a0f5f5bacf1c0542f11172758d36d0adc1ee6e46aee5794c171aab0d81b20224ea4ff00e81f7e7aef52791bbbeab3eeca0fab49333e7850aefd50a3183ee3b

data/lib/roman_numbers/roman_number.rb

@@ -43,28 +43,29 @@ module RomanNumbers
           @output_roman = String.new
         when String
           @input_string = input.upcase
-          @output_arabic = 0
+          @output_integer = 0
       end
     end
 
+    attr_accessor :input_integer, :input_string, :output_roman, :staged_roman_hash, :output_integer
+
     # converts arabic to roman
-    def convert_decimal_to_roman(input_integer=@input_integer)
+    def convert_decimal_to_roman(passed_integer=input_integer)
       # validating input
-      unless (1..3999).include? input_integer
-        raise InvalidInputError, "Invalid Input: #{input_integer}"
+      unless (1..3999).include? passed_integer
+        raise InvalidInputError, "Invalid Input: #{passed_integer}"
       end
       # getting staged roman hash
-      calculate_staged_roman_hash(input_integer)
+      calculate_staged_roman_hash(passed_integer)
       # extracting hash from staged roman hash
-      @staged_roman_hash.each do |element|
-        @output_roman << (element[:largest_element][:unit].to_s)*(element[:times])
+      staged_roman_hash.each do |element|
+        output_roman << (element[:largest_element][:unit].to_s)*(element[:times])
       end
-      return @output_roman
+      output_roman
     end
 
     # converts given arabic number (in string form) to corresponding integer
-    def convert_roman_to_decimal(input_roman=@input_string.clone)
-      input_roman
+    def convert_roman_to_decimal(passed_roman=input_string.clone)
       # generating regex expressions
       double_units_array = ROMAN_NON_REPEATABLE_UNITS_2.map { |element| ('^' + element[:unit].to_s) }
       single_units_array = (ROMAN_REPEATABLE_UNITS + ROMAN_NON_REPEATABLE_UNITS_1).map { |element| ('^' + element[:unit].to_s) }
@@ -72,94 +73,95 @@ module RomanNumbers
       single_units_regex = Regexp.new(single_units_array.join('|'))
       # validation
       # TODO: to add more validations
-      if input_roman =~ /(.)\1{#{MAX_ALLOWED_REPETITION},}/
-        raise InvalidInputError, "Invalid Input: #{input_roman}"
+      if passed_roman =~ /(.)\1{#{MAX_ALLOWED_REPETITION},}/
+        raise InvalidInputError, "Invalid Input: #{passed_roman}"
       end
       # processing
-      if input_roman.length > 0
-        if unit = input_roman.slice!(double_units_regex)
-          @output_arabic += ROMAN_DOUBLE_UNITS.find { |element| element[:unit] == unit.to_sym }[:value]
-          convert_roman_to_decimal(input_roman)
-        elsif unit = input_roman.slice!(single_units_regex)
-          @output_arabic += ROMAN_SINGLE_UNITS.find { |element| element[:unit] == unit.to_sym }[:value]
-          convert_roman_to_decimal(input_roman)
+      if passed_roman.length > 0
+        if unit = passed_roman.slice!(double_units_regex)
+          self.output_integer += ROMAN_DOUBLE_UNITS.find { |element| element[:unit] == unit.to_sym }[:value]
+          convert_roman_to_decimal(passed_roman)
+        elsif unit = passed_roman.slice!(single_units_regex)
+          self.output_integer += ROMAN_SINGLE_UNITS.find { |element| element[:unit] == unit.to_sym }[:value]
+          convert_roman_to_decimal(passed_roman)
         else
-          # invalud input
-          raise InvalidInputError, "Invalid Input: #{input_roman}"
+          # invalid input
+          raise InvalidInputError, "Invalid Input: #{passed_roman}"
         end
       else
         # process is complete
-        return @output_arabic
+        self.output_integer
       end
-
     end
 
+    protected :input_integer, :input_string, :output_roman, :staged_roman_hash, :output_integer
+
     private
 
     # returns an array of hashed containing info on desired output roman
-    def calculate_staged_roman_hash(input_integer)
+    def calculate_staged_roman_hash(passed_input_integer)
       begin
-        temp_hash = largest_repeatable_element(input_integer)
+        temp_hash = largest_repeatable_element(passed_input_integer)
       rescue StartsWithNonRepeatableRomanUnitError => ex
-        temp_hash = largest_non_repeatable_element(input_integer)
+        temp_hash = largest_non_repeatable_element(passed_input_integer)
       end
       if temp_hash
-        @staged_roman_hash << temp_hash
-        input_integer = temp_hash[:reduced_integer]
-        calculate_staged_roman_hash(input_integer)
+        staged_roman_hash << temp_hash
+        passed_input_integer = temp_hash[:reduced_integer]
+        calculate_staged_roman_hash(passed_input_integer)
       else
         # processing done
-        return @staged_roman_hash
+        staged_roman_hash
       end
     end
 
     # returns reduced_integer, largest repeatable element, and number of times it can be repeated
-    def largest_repeatable_element(input_integer)
-      if input_integer > 0
-        largest_element = ROMAN_REPEATABLE_UNITS.find { |element| input_integer >= element[:value] }
+    def largest_repeatable_element(passed_input_integer)
+      if passed_input_integer > 0
+        largest_element = ROMAN_REPEATABLE_UNITS.find { |element| passed_input_integer >= element[:value] }
         # TODO: make it efficient by removing elements before largest_element
         # TODO: to use binary search instead
         if largest_element
-          times = input_integer/largest_element[:value]
-          reduced_integer = input_integer%largest_element[:value]
+          times = passed_input_integer/largest_element[:value]
+          reduced_integer = passed_input_integer%largest_element[:value]
           if times > MAX_ALLOWED_REPETITION
             # given integer starts with non_repeatable roman unit
             raise StartsWithNonRepeatableRomanUnitError
           end
-          return {:reduced_integer => reduced_integer, :largest_element => largest_element, :times => times}
+          {:reduced_integer => reduced_integer, :largest_element => largest_element, :times => times}
         else
           # non-reachable code
           raise NonReachableCodeError, 'LargestElementIsNil'
         end
-      elsif input_integer == 0
+      elsif passed_input_integer == 0
         # process completed
-        return nil
+        nil
       else
         # non-reachable code
-        # input_integer has to be >=0
+        # passed_input_integer has to be >=0
         raise NonReachableCodeError, 'ReceivedNegativeInteger'
       end
     end
 
     # returns largest non-repeatable element
-    def largest_non_repeatable_element(input_integer)
-      if input_integer > 0
-        largest_element = ROMAN_NON_REPEATABLE_UNITS.find { |element| input_integer >= element[:value] }
+    def largest_non_repeatable_element(passed_input_integer)
+      if passed_input_integer > 0
+        largest_element = ROMAN_NON_REPEATABLE_UNITS.find { |element| passed_input_integer >= element[:value] }
         # TODO: make it efficient by removing elements before largest_element
         # TODO: to use binary search instead
         if largest_element
-          reduced_integer = input_integer%largest_element[:value]
-          return {:reduced_integer => reduced_integer, :largest_element => largest_element, :times => 1}
+          reduced_integer = passed_input_integer%largest_element[:value]
+          {:reduced_integer => reduced_integer, :largest_element => largest_element, :times => 1}
         else
           # no non_repeatable element preset, but process is not complete yet
-          return {:reduced_integer => input_integer, :largest_element => nil, :times => 0}
+          {:reduced_integer => passed_input_integer, :largest_element => nil, :times => 0}
         end
-      elsif input_integer == 0
+      elsif passed_input_integer == 0
         # process completed
-        return nil
+        nil
       else
         # non-reachable code
-        # input_integer has to be >=0
+        # passed_input_integer has to be >=0
         raise NonReachableCodeError, 'ReceivedNegativeInteger'
       end
     end

data/lib/roman_numbers/version.rb

@@ -1,3 +1,3 @@
 module RomanNumbers
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/spec/integer_spec.rb

@@ -0,0 +1,13 @@
+require_relative './spec_helper'
+include RomanNumbers
+
+describe Integer do
+
+  context "#to_roman" do
+
+    it "is added and internally calls 'convert_decimal_to_roman'" do
+      expect_any_instance_of(RomanNumbers::RomanNumber).to receive(:convert_decimal_to_roman)
+      7999112.to_roman
+    end
+  end
+end

data/spec/roman_numbers/roman_number_spec.rb

@@ -10,15 +10,40 @@ module RomanNumbers
     end
     
     describe '#convert_decimal_to_roman' do
-      shared_examples_for "works_with_valid_integral_roman_input_collection" do |array|
+      shared_examples_for "works_with_valid_integral_input_and_roman_output_collection" do |array|
         # Note: here array is array of hashes
         array.each do |hsh|
-          it %Q{returns #{hsh[:integer]} for #{hsh[:roman]} as input} do
+          it %Q{returns #{hsh[:roman]} for #{hsh[:integer]} as input} do
             RomanNumber.new(hsh[:integer]).convert_decimal_to_roman.should == hsh[:roman]
           end
         end
       end
-      
+    
+      context 'For Following Valid Inputs' do
+        it_behaves_like "works_with_valid_integral_input_and_roman_output_collection", Helpers.valid_inputs
+      end
+    
+      context 'For Following Invalid Input' do
+        [4000, 0, -10, '10'].each do |exp_input|
+          it %Q{raises #{$invalid_input_error} for #{exp_input} as input} do
+            expect {
+              RomanNumber.new(exp_input).convert_decimal_to_roman
+            }.to raise_error($invalid_input_error)
+          end
+        end
+      end
+    end
+
+    describe '#convert_roman_to_decimal' do
+      shared_examples_for "works_with_valid_roman_input_and_integral_output_collection" do |array|
+        # Note: here array is array of hashes
+        array.each do |hsh|
+          it %Q{returns #{hsh[:integer]} for #{hsh[:roman]} as input} do
+            RomanNumber.new(hsh[:roman]).convert_roman_to_decimal.should == hsh[:integer]
+          end
+        end
+      end
+
       shared_examples_for "raises_error_on_invalid_roman_input_collection" do |array|
         # Note: here array is array of integers
         array.each do |integral_elem|
@@ -26,7 +51,7 @@ module RomanNumbers
             expect {
               RomanNumber.new(integral_elem).convert_decimal_to_roman
             }.to raise_error($invalid_input_error)
-        end
+          end
         end
       end
 
@@ -35,17 +60,17 @@ module RomanNumbers
       end
     
       context %q(Symbols 'I', 'X', 'C', and 'M' can be repeated 4 times if 3rd and 4th are separated by smaller value) do 
-        it_behaves_like "works_with_valid_integral_roman_input_collection", Helpers.input_set_1
+        it_behaves_like "works_with_valid_roman_input_and_integral_output_collection", Helpers.input_set_1
       end
 
       context %q(Symbols 'D', 'L', 'V' can never be repeated in succession) do 
         it_behaves_like "raises_error_on_invalid_roman_input_collection", %w(DD DDC LL LLX VV VVI)
       end
 
-      context %Q(Symbol 'I' can be subtrated from 'V' and 'X', and
+      context %Q(Symbol 'I' can be subtracted from 'V' and 'X', and
         Symbol 'L' can be subtracted from 'L' and 'C', and
         Symbol 'C' can be subtracted from 'D' and 'M') do 
-        it_behaves_like "works_with_valid_integral_roman_input_collection", Helpers.input_set_2
+        it_behaves_like "works_with_valid_roman_input_and_integral_output_collection", Helpers.input_set_2
       end
 
       context %Q(Symbol 'I' can be subtrated from 'V' and 'X' only, and
@@ -53,23 +78,7 @@ module RomanNumbers
         Symbol 'C' can be subtracted from 'D' and 'M' only) do
         it_behaves_like "raises_error_on_invalid_roman_input_collection", %w(IL IC ID IM XD XM)
       end
-    
-      context 'For Following Valid Inputs' do
-        it_behaves_like "works_with_valid_integral_roman_input_collection", Helpers.valid_inputs
-      end
-    
-      context 'For Following Invalid Input' do
-        [4000, 0, -10, '10'].each do |exp_input|
-          it %Q{raises #{$invalid_input_error} for #{exp_input} as input} do
-            expect {
-              RomanNumber.new(exp_input).convert_decimal_to_roman
-            }.to raise_error($invalid_input_error)
-          end
-        end
-      end
-    end
 
-    describe '#convert_roman_to_decimal' do
       context 'For Valid Input' do
         Helpers.valid_inputs.each do |hsh|
           it %Q{returns #{hsh[:roman]} for #{hsh[:integer]} as input} do

data/spec/string_spec.rb

@@ -0,0 +1,13 @@
+require_relative './spec_helper'
+include RomanNumbers
+
+describe String do
+
+  context "#from_roman_to_integer" do
+
+    it "is added and internally calls 'convert_roman_to_decimal'" do
+      expect_any_instance_of(RomanNumbers::RomanNumber).to receive(:convert_roman_to_decimal)
+      "some_string".from_roman_to_integer
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roman_numbers
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Munish Goyal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-02 00:00:00.000000000 Z
+date: 2015-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,8 +113,10 @@ files:
 - lib/roman_numbers/version.rb
 - roman_numbers.gemspec
 - spec/helpers.rb
+- spec/integer_spec.rb
 - spec/roman_numbers/roman_number_spec.rb
 - spec/spec_helper.rb
+- spec/string_spec.rb
 homepage: https://github.com/goyalmunish/roman_numbers
 licenses:
 - MIT
@@ -142,5 +144,7 @@ summary: Conversion between Integers and Roman Numbers
 test_files:
 - autotest/discover.rb
 - spec/helpers.rb
+- spec/integer_spec.rb
 - spec/roman_numbers/roman_number_spec.rb
 - spec/spec_helper.rb
+- spec/string_spec.rb