to_decimal 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 718f822ef696b84cb34b6992cdd5f36dc7d432a4f03b3a9a1b2c6c3d53eea61b
-  data.tar.gz: cef1615b1c378f2f148b2c5781307cf8a0ee55d5513470cee3dad81497fc7bae
+  metadata.gz: 536d4add05473007155d6508a38be3c2edc844c8b2ca055c284d66b610156218
+  data.tar.gz: 99c02b0b97440add3b06f8b3e81e4c3695bb3dff8725cce9e89ebed2caf1cc3c
 SHA512:
-  metadata.gz: 9289a2685a665184fba5a416d7500dc1cd820135490a9e221f362281992230e2cb02eb6ee8a0db56832aab50ca026affe06cde938c16557ab47d309e23c17929
-  data.tar.gz: c7ad1939a6e33d80b384a0ddce212e2ad2f59cb58a5cd51238c64c3f87839d96e426c91e4be17528169ee1d0c26f94fec897c3655df56c7573a3c15fcce7c75e
+  metadata.gz: 9d3c17dd84adcdfd27018bf9c39a57f716e67a925ba92af4520b7872d816dea34075258bee82478ee1e28ef63e1ad941629640bda53cde12d176568cb7eb6014
+  data.tar.gz: 8ee66486d089201851a3dcd2502cdd2ffc26685a6bccbc69e7dcff294c150615dbe561306a82225f56fbdc369233ab6a19eb3b2a40278230e0da1b2e69796bd6

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# to_decimal 0.0.3 (2018-11-27)
+---
+
+**Breaking changes !!!** 
+
+- Provides a namespace `ToDecimal` to the gem
+- Renames the main class from `ToDecimal` to `Convertor`
+- Provides constants `ToDecimal::Base2` to `ToDecimal::Base10` as convenience.
+- Remove all other class and instance methods, except the getter for the `base`
+  attribute of the `Convertor` class
+- Make the `ToDecimal::Convertor.new` class method private
+- Update tests accordingly
+
+
 # to_decimal 0.0.2 (2018-05-08)
 ---
 

data/README.md

@@ -4,40 +4,53 @@ A simple gem to convert an integer expressed in bases
 ranging from 2 to 10 into a decimal integer.
 
 Ruby comes with useful built-in methods to convert integers and string
-representation of integers to another base (`String#to_i(base=10)` and 
-`Ìnteger#to_s(base=10)`).
+representations of integers to another base ([`String#to_i(base=10)`](http://ruby-doc.org/core-2.5.3/String.html#method-i-to_i),
+[`Kernel#Integer(arg, base=0)`](https://ruby-doc.com/core-2.5.2/Kernel.html#method-i-Integer) and 
+[`Integer#to_s(base=10)`](http://ruby-doc.org/core-2.5.3/Integer.html#method-i-to_s).
 
-But I didn't found a simple and straightforward way to convert an integer
-form a given base to an integer of base 10, nor in the core API, nor in the
-Standard Library.
+You can also use prefixes with [litteral numeric constant](https://ruby-doc.com/core-2.5.2/doc/syntax/literals_rdoc.html#label-Numbers),
+but it only works for binary, octal, decimal and hexadecimal notation (which cover
+the most usecases):
 
-I found the following two gems :
-- [bases](https://github.com/whatyouhide/bases) ;
-- [radix](https://github.com/rubyworks/radix) gems ;
+```ruby
+# binary
+0b10111 # => 23
 
-They are very comprehensive, and go both behind the base 36, which is the limit
-of Ruby.
+# octal
+0o27 # => 23
 
-But they are a little too heavy for my purpose. I just wanted something like :
+# decimal
+0d23 # => 23
 
-```ruby
-ToDecimal.to_d(12, base: 8) # => 10
+# hexadecimal
+0x17 # => 23
+```
 
-# or
+But if you want to convert an integer of say, base 6, to an integer of base 10,
+you need to proceed like this (AFAIK):
 
-base8.to_d(12) # => 10
+```ruby
+12.to_s.to_i(6) # => 8
+```
 
-# or even
+It's not a concern if you need to do this occasionally, or if you can easily
+manage using prefixes, but I thought there could be a more straightforward,
+consise and explicit way to perform this, showing more clearly what your intent
+is.
 
-base8[12] # => 10 
-```
+I've looked in the core API and in the Standard Library, but I didn't find
+anything. 
 
-And, if any conversion is needed back to the original base, we can just use
-the buit-in Ruby methods on the return value of the method.
+I found the following two gems :
+- [bases](https://github.com/whatyouhide/bases) ;
+- [radix](https://github.com/rubyworks/radix) ;
 
-So I decided to create this little gem for that. If something similar already
-exists, I would be happy to know.
+They are very comprehensive, go both behind the base 36, which is the limit
+of Ruby, and allow to convert form bases back and forth.
 
+But they were a little too heavy for my purpose, which was simply
+converting from a base lesser or equal than 10 and to return an integer
+expressed in base 10. So I decided to write my own gem.
 
 # Installation
 ```shell
@@ -55,55 +68,46 @@ This project is tested under minitest.
 
 ### Instance methods
 
-Instantiate a new `ToDecimal` object :
+The gem gives you access to 9 objects under the namespace `ToDecimal` called :
+`Base2`, `Base3`,... `Base10`.
 
-```ruby
-base10 = ToDecimal.new
-# => a new object with default base set to 10
-
-# or
-base8 = ToDecimal.new(8)
-# or
-base8 = ToDecimal.new('8')
-# => a new object with base set to 8
-```
-
-The base attribute can be updated simply :
+Each object has a `[]` instance method, which takes as parameter an integer OR a string
+representation of the corresponding base and returns this integer expressed
+in base 10 :
 
 ```ruby
-base8.base = 3
+base2 = ToDecimal::Base2
+base2[10] # => 2
 
-#or
+b8 = ToDecimal::Base8
+b8[12] # => 10
 
-base8.base = '3'
+b8['12'] # => 10
+b8['012'] # => 10
 ```
 
-To convert a number of a given base to a base 10 integer, use the `#to_d(input)`
-method (alias `#[]`):
+These objects and their associated `[]` method are basically wrappers for the
+`Integer.to_s.to_i(original_base)` or `String.to_i(original_base)` methods,
+with a custom error when the input is not of the excpected base, or not a valid
+string representation of an integer. In this case, you will get
+a `WrongBaseInputError` instead of the default results of the previous methods, which can lead to unexpected results if drown into some other computations.
 
-```ruby
-base8.to_d(12) # => 10
+The objects are frozen and no new `Convertor` object can be instantiated.
 
-# alias
+The benefit you may find using this gem are:
 
-base8[12] # => 10
-```
-An error wil be raised if the input integer is not of the given base.
-
-### Class method
+- **argument validation** : you avoid the standard behavior of the different built-in
+methods, which sometimes throw an error (`Kernel#Integer(arg, base)`) or worse,
+silently stop the conversion process when they encounter an invalid character, returning the result of the conversion so far. Instead, you have a consistent
+behavior, and you are free to decide what to do with the error.
 
-Instead of creating a new object, you can also call a class method `#to_d` on
-the `ToDecimal class itself :
+- **allow you to work with strings with leading zeros** : in this case, zeros are removed form the beginning of the string, avoiding the implict conversion in
+base 8, which is, most of the time, not what you want ;
 
-```ruby
-ToDecimal.to_d(1231, base: 4)
-# => 109
-```
 
 # Contribute
 
-If you think this small gem could be improved in any way, don't hesitate,
-I would be happy to learn. And if you want to contribute, I would be happy too !
+Think it could be better ? Great !
 
 - Fork it ;
 - Create your own branch (`git checkout -b my-new-feature`) ;

data/lib/to_decimal.rb

@@ -1,2 +1,21 @@
-require_relative 'to_decimal/to_decimal_class'
+require_relative 'to_decimal/validator_class'
+require_relative 'to_decimal/convertor_class'
 require_relative 'to_decimal/wrong_base_input_error'
+
+module ToDecimal
+  Base2 = Convertor.new(2)
+  Base3 = Convertor.new(3)
+  Base4 = Convertor.new(4)
+  Base5 = Convertor.new(5)
+  Base6 = Convertor.new(6)
+  Base7 = Convertor.new(7)
+  Base8 = Convertor.new(8)
+  Base9 = Convertor.new(9)
+  Base10 = Convertor.new(10)
+
+  class Convertor
+    class << self
+      private :new
+    end
+  end
+end

data/lib/to_decimal/convertor_class.rb

@@ -0,0 +1,38 @@
+module ToDecimal
+  class Convertor
+    attr_reader :base
+
+    def initialize(base)
+      validate_base(base)
+      @base = base
+      self.freeze
+    end
+
+    def [](input)
+      input = remove_leading_zeros_of(input)
+      Validator.new(input, base).validate
+      
+      input_as_integer = integerize(input)
+      convert(input_as_integer)
+    end
+
+    private
+
+    def remove_leading_zeros_of(input)
+      input.is_a?(String) ? input.sub(/\A0+/, '') : input
+    end
+
+    def convert(integer)
+      integer.to_s.to_i(base)
+    end
+
+    def integerize(input)
+      input.is_a?(String) ? input.to_i : input
+    end
+
+    def validate_base(base)
+      raise ArgumentError, "Base must be an Integer" unless base.is_a?(Integer)
+      raise ArgumentError, "Base must be 1..10" unless base > 0 && base <= 10
+    end
+  end
+end

data/lib/to_decimal/validator_class.rb

@@ -0,0 +1,27 @@
+module ToDecimal
+  class Validator
+    def initialize(input, base)
+      @input = input
+      @base = base
+    end
+
+    def validate
+      raise ArgumentError, "Argument must be an integer or a valid string\
+ representation of an integer. You input : #{@input}" unless valid_integer_string_or_integer?
+      
+      raise WrongBaseInputError, "A number of base #{@base} cannot have a digit\
+ greater or equal to #{@base}. Check your argument: #{@input}" unless valid_input_base?
+    end
+
+    private
+
+    def valid_integer_string_or_integer?
+       @input.is_a?(Integer) || (@input.is_a?(String) && @input.to_i.to_s == @input)
+    end
+
+    def valid_input_base?
+      digitized_input = @input.to_i.digits
+      digitized_input.none? { |digit| digit >= @base }
+    end
+  end
+end

data/lib/to_decimal/wrong_base_input_error.rb

@@ -1 +1,3 @@
-class WrongBaseInputError < ArgumentError; end
+module ToDecimal
+  class WrongBaseInputError < ArgumentError; end
+end

data/test/to_decimal_test.rb

@@ -4,251 +4,216 @@ Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
 require_relative '../lib/to_decimal'
 
-# ========== Data for the tests ================================================
+# ========== Test helper method ================================================
 
-TEST_VALUES_BASE_2 = [[101, 2, 5], [100_000_000, 2, 256]]
-TEST_VALUES_BASE_3 = [[1122111, 3, 1201], [12, 3, 5]]
-TEST_VALUES_BASE_4 = [[11001, 4, 321], [322, 4, 58]]
-TEST_VALUES_BASE_5 = [[14, 5, 9], [10011302, 5, 78952]]
-TEST_VALUES_BASE_6 = [[13, 6, 9], [1405304, 6, 78952]]
-TEST_VALUES_BASE_7 = [[12, 7, 9], [446116, 7, 78952]]
-TEST_VALUES_BASE_8 = [[11, 8, 9], [232150, 8, 78952]]
-TEST_VALUES_BASE_9 = [[10, 9, 9], [130264, 9, 78952]]
-TEST_VALUES_BASE_10 = [[9, 10, 9], [78952, 10, 78952]]
-
-# ========== Test helper methods ===============================================
-
-def execute_test_of_to_d(test_values)
-  test_values.each do |data_set|
-    @convertor.base = data_set[1]
-    assert_equal data_set[2], @convertor.to_d(data_set[0]) 
-  end
-end
-
-def execute_test_of_to_d_class_method(test_values)
+def execute_test_with(test_values, base_convertor)
   test_values.each do |data_set|
-    assert_equal data_set[2], ToDecimal.to_d(data_set[0], base: data_set[1])
+    assert_equal data_set[1], base_convertor[data_set[0]] 
   end
 end
 
-class ToDecimalConvertorTest < Minitest::Test
-  # ======== Setup =============================================================
-
-  def setup
-    @convertor = ToDecimal.new
-  end
+class ToDecimalBaseValidationTest < Minitest::Test
 
-  # ======== Testing initialization process ====================================
-
-  def test_initialization_without_argument_has_default_base
-    assert_equal 10, @convertor.base
+# ======== Testing error is raises if input is not of the correct base =========
+  
+  def test_raises_error_if_input_is_not_from_base_2
+    base2 = ToDecimal::Base2
+    assert_raises(ToDecimal::WrongBaseInputError) { base2[2] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base2[9] }
   end
 
-  def test_initialization_with_arguments_has_base
-    @new_convertor = ToDecimal.new(8)
-    assert_equal 8, @new_convertor.base
+  def test_raises_error_if_input_is_not_from_base_3
+    base3 = ToDecimal::Base3
+    assert_raises(ToDecimal::WrongBaseInputError) { base3[3] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base3[9] }
   end
 
-  def test_initialization_accepts_also_string_as_base
-    @new_convertor = ToDecimal.new('4')
-    assert_equal 4, @new_convertor.base
+  def test_raises_error_if_input_is_not_from_base_4
+    base4 = ToDecimal::Base4
+    assert_raises(ToDecimal::WrongBaseInputError) { base4[4] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base4[9] }
   end
 
-  # ======== Testing accessing and modifying attributes ========================
-
-  def test_base_can_be_updated
-    @convertor.base = 2
-    assert_equal(2, @convertor.base)
-    @convertor.base = 8
-    assert_equal(8, @convertor.base)
+  def test_raises_error_if_input_is_not_from_base_5
+    base5 = ToDecimal::Base5
+    assert_raises(ToDecimal::WrongBaseInputError) { base5[5] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base5[9] }
   end
 
-  def test_base_can_also_be_updated_with_a_string
-    @convertor.base = '4'
-    assert_equal 4, @convertor.base
+  def test_raises_error_if_input_is_not_from_base_6
+    base6 = ToDecimal::Base6
+    assert_raises(ToDecimal::WrongBaseInputError) { base6[6] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base6[9] }
   end
 
-  # ========= Testing ArgumentError is raised with invalid base attribute ======
-
-  def test_raises_an_error_if_base_arg_is_not_an_integer_or_a_string
-    assert_raises(ArgumentError) { @convertor.base = [3] }
-    assert_raises(ArgumentError) { @convertor.base = :sym }
+  def test_raises_error_if_input_is_not_from_base_7
+    base7 = ToDecimal::Base7
+    assert_raises(ToDecimal::WrongBaseInputError) { base7[7] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base7[9] }
   end
 
-  def test_raises_an_error_if_base_arg_is_greater_than_10
-    assert_raises(ArgumentError) { @convertor.base = 12 }
+  def test_raises_error_if_input_is_not_from_base_8
+    base8 = ToDecimal::Base8
+    assert_raises(ToDecimal::WrongBaseInputError) { base8[8] }
+    assert_raises(ToDecimal::WrongBaseInputError) { base8[9] }
   end
 
-  def test_raises_an_error_if_base_arg_is_smaller_than_1
-    assert_raises(ArgumentError) { @convertor.base = 0 }
-    assert_raises(ArgumentError) { @convertor.base = -4 }
+  def test_raises_error_if_input_is_not_from_base_9
+    base9 = ToDecimal::Base9
+    assert_raises(ToDecimal::WrongBaseInputError) { base9[9] }
   end
+end
 
-  # ======== Testing error is raises if input is not of the correct base =======
-  
-  def test_to_d_raises_error_if_input_is_not_from_base_2
-    @convertor.base = 2
-    assert_raises(WrongBaseInputError) { @convertor.to_d(2) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
-  end
+# ========= Testing return values of [] instance method ========================
 
-  def test_to_d_raises_error_if_input_is_not_from_base_3
-    @convertor.base = 3
-    assert_raises(WrongBaseInputError) { @convertor.to_d(3) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
-  end
+class ToDecimalConvserionFromIntegerTest < Minitest::Test
 
-  def test_to_d_raises_error_if_input_is_not_from_base_4
-    @convertor.base = 4
-    assert_raises(WrongBaseInputError) { @convertor.to_d(4) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
-  end
+  # Test data
+  TEST_VALUES_BASE_2 = [[101, 5], [100_000_000, 256]]
+  TEST_VALUES_BASE_3 = [[1122111, 1201], [12, 5]]
+  TEST_VALUES_BASE_4 = [[11001, 321], [322, 58]]
+  TEST_VALUES_BASE_5 = [[14, 9], [10011302, 78952]]
+  TEST_VALUES_BASE_6 = [[13, 9], [1405304, 78952]]
+  TEST_VALUES_BASE_7 = [[12, 9], [446116, 78952]]
+  TEST_VALUES_BASE_8 = [[11, 9], [232150, 78952]]
+  TEST_VALUES_BASE_9 = [[10, 9], [130264, 78952]]
+  TEST_VALUES_BASE_10 = [[9, 9], [78952, 78952]]
 
-  def test_to_d_raises_error_if_input_is_not_from_base_5
-    @convertor.base = 5
-    assert_raises(WrongBaseInputError) { @convertor.to_d(5) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  def test_returns_decimal_value_of_integer_of_base_2
+    execute_test_with(TEST_VALUES_BASE_2, ToDecimal::Base2)
   end
 
-  def test_to_d_raises_error_if_input_is_not_from_base_6
-    @convertor.base = 6
-    assert_raises(WrongBaseInputError) { @convertor.to_d(6) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  def test_returns_decimal_value_of_integer_of_base_3
+    execute_test_with(TEST_VALUES_BASE_3, ToDecimal::Base3)
   end
 
-  def test_to_d_raises_error_if_input_is_not_from_base_7
-    @convertor.base = 7
-    assert_raises(WrongBaseInputError) { @convertor.to_d(7) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  def test_returns_decimal_value_of_integer_of_base_4
+    execute_test_with(TEST_VALUES_BASE_4, ToDecimal::Base4)
   end
 
-  def test_to_d_raises_error_if_input_is_not_from_base_8
-    @convertor.base = 8
-    assert_raises(WrongBaseInputError) { @convertor.to_d(8) }
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  def test_returns_decimal_value_of_integer_of_base_5
+    execute_test_with(TEST_VALUES_BASE_5, ToDecimal::Base5)
   end
 
-  def test_to_d_raises_error_if_input_is_not_from_base_9
-    @convertor.base = 9
-    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  def test_returns_decimal_value_of_integer_of_base_6
+    execute_test_with(TEST_VALUES_BASE_6, ToDecimal::Base6)
   end
 
-  # ========= Testing return values of to_d instance method ====================
-
-  def test_to_d_returns_decimal_value_of_number_of_base_2
-    execute_test_of_to_d(TEST_VALUES_BASE_2)
+  def test_returns_decimal_value_of_integer_of_base_7
+    execute_test_with(TEST_VALUES_BASE_7, ToDecimal::Base7)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_3
-    execute_test_of_to_d(TEST_VALUES_BASE_3)
+  def test_returns_decimal_value_of_integer_of_base_8
+    execute_test_with(TEST_VALUES_BASE_8, ToDecimal::Base8)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_4
-    execute_test_of_to_d(TEST_VALUES_BASE_4)
+  def test_returns_decimal_value_of_integer_of_base_9
+    execute_test_with(TEST_VALUES_BASE_9, ToDecimal::Base9)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_5
-    execute_test_of_to_d(TEST_VALUES_BASE_5)
+  def test_returns_decimal_value_of_integer_of_base_10
+    execute_test_with(TEST_VALUES_BASE_10, ToDecimal::Base10)
   end
+end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_6
-    execute_test_of_to_d(TEST_VALUES_BASE_6)
-  end
+class ToDecimalConvserionFromStringTest < Minitest::Test
+  TEST_VALUES_BASE_2 = [['101', 5], ['100000000', 256]]
+  TEST_VALUES_BASE_3 = [['1122111', 1201], ['12', 5]]
+  TEST_VALUES_BASE_4 = [['11001', 321], ['322', 58]]
+  TEST_VALUES_BASE_5 = [['14', 9], ['10011302', 78952]]
+  TEST_VALUES_BASE_6 = [['13', 9], ['1405304', 78952]]
+  TEST_VALUES_BASE_7 = [['12', 9], ['446116', 78952]]
+  TEST_VALUES_BASE_8 = [['11', 9], ['232150', 78952]]
+  TEST_VALUES_BASE_9 = [['10', 9], ['130264', 78952]]
+  TEST_VALUES_BASE_10 = [['9', 9], ['78952', 78952]]
 
-  def test_to_d_returns_decimal_value_of_number_of_base_7
-    execute_test_of_to_d(TEST_VALUES_BASE_7)
+  def test_returns_decimal_value_of_string_of_base_2
+    execute_test_with(TEST_VALUES_BASE_2, ToDecimal::Base2)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_8
-    execute_test_of_to_d(TEST_VALUES_BASE_8)
+  def test_returns_decimal_value_of_string_of_base_3
+    execute_test_with(TEST_VALUES_BASE_3, ToDecimal::Base3)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_9
-    execute_test_of_to_d(TEST_VALUES_BASE_9)
+  def test_returns_decimal_value_of_string_of_base_4
+    execute_test_with(TEST_VALUES_BASE_4, ToDecimal::Base4)
   end
 
-  def test_to_d_returns_decimal_value_of_number_of_base_10
-    execute_test_of_to_d(TEST_VALUES_BASE_10)
+  def test_returns_decimal_value_of_string_of_base_5
+    execute_test_with(TEST_VALUES_BASE_5, ToDecimal::Base5)
   end
 
-  # ========= Testing aliased to_decimal instance method =======================
-
-  def test_square_brackets_is_alias_for_to_d
-    convertor = ToDecimal.new(10)
-    assert_equal(200, convertor[200])
+  def test_returns_decimal_value_of_string_of_base_6
+    execute_test_with(TEST_VALUES_BASE_6, ToDecimal::Base6)
   end
 
-  # ========= Testing to_d class method accepts both string and integer args ===
-
-  def test_to_d_class_method_accepts_integers_for_both_parameters
-    assert_silent { ToDecimal.to_d(101, base: 2) }
+  def test_returns_decimal_value_of_string_of_base_7
+    execute_test_with(TEST_VALUES_BASE_7, ToDecimal::Base7)
   end
 
-  def test_to_d_class_method_accepts_strings_for_both_parameters
-    assert_silent { ToDecimal.to_d('101', base: '2') }
+  def test_returns_decimal_value_of_string_of_base_8
+    execute_test_with(TEST_VALUES_BASE_8, ToDecimal::Base8)
   end
-  
-  def test_to_d_class_method_accepts_mixed_strings_and_integers_as_args
-    assert_silent { ToDecimal.to_d('101', base: 2) }
-    assert_silent { ToDecimal.to_d(101, base: '2') } 
-  end
-
-  # ======== Testing to_d class method raises error with invalid parameters ====
 
-  def test_to_d_class_method_raises_error_if_first_arg_is_not_string_or_integer
-    assert_raises(ArgumentError) { ToDecimal.to_d(:sym, base: 5) }
-    assert_raises(ArgumentError) { ToDecimal.to_d([4], base: 5) }
+  def test_returns_decimal_value_of_string_of_base_9
+    execute_test_with(TEST_VALUES_BASE_9, ToDecimal::Base9)
   end
 
-  def test_to_d_class_method_raises_error_if_base_arg_is_not_an_integer_or_str
-    assert_raises(ArgumentError) { ToDecimal.to_d('222', base: [5]) }
-    assert_raises(ArgumentError) { ToDecimal.to_d(45, base: :sym) }
+  def test_returns_decimal_value_of_string_of_base_10
+    execute_test_with(TEST_VALUES_BASE_10, ToDecimal::Base10)
   end
+end
 
-  def test_to_d_class_method_raises_an_error_if_base_arg_is_greater_than_10
-    assert_raises(ArgumentError) { ToDecimal.to_d(456, base: 12) }
-  end
+class RemoveLeadingZeroesFromStringsTest < Minitest::Test
+  TEST_VALUES_BASE_2 = [['00101', 5], ['0100000000', 256]]
+  TEST_VALUES_BASE_3 = [['001122111', 1201], ['012', 5]]
+  TEST_VALUES_BASE_4 = [['0011001', 321], ['322', 58]]
+  TEST_VALUES_BASE_5 = [['0014', 9], ['010011302', 78952]]
+  TEST_VALUES_BASE_6 = [['0013', 9], ['01405304', 78952]]
+  TEST_VALUES_BASE_7 = [['0012', 9], ['0446116', 78952]]
+  TEST_VALUES_BASE_8 = [['0011', 9], ['0232150', 78952]]
+  TEST_VALUES_BASE_9 = [['0010', 9], ['0130264', 78952]]
+  TEST_VALUES_BASE_10 = [['009', 9], ['078952', 78952]]
 
-  def test_to_d_class_method_raises_an_error_if_base_arg_is_smaller_than_1
-    assert_raises(ArgumentError) { ToDecimal.to_d(456, base: 0) }
-    assert_raises(ArgumentError) { ToDecimal.to_d(456, base: -8) }
+  def test_removes_leading_zeros_from_string_with_base2
+    execute_test_with(TEST_VALUES_BASE_2, ToDecimal::Base2)
   end
 
-  # ======== Testing return values of to_d class method ========================
-  
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_2
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_2)
+  def test_removes_leading_zeros_from_string_with_base3
+    execute_test_with(TEST_VALUES_BASE_3, ToDecimal::Base3)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_3
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_3)
+  def test_removes_leading_zeros_from_string_with_base4
+    execute_test_with(TEST_VALUES_BASE_4, ToDecimal::Base4)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_4
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_4)
+  def test_removes_leading_zeros_from_string_with_base5
+    execute_test_with(TEST_VALUES_BASE_5, ToDecimal::Base5)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_5
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_5)
+  def test_removes_leading_zeros_from_string_with_base6
+    execute_test_with(TEST_VALUES_BASE_6, ToDecimal::Base6)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_6
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_6)
+  def test_removes_leading_zeros_from_string_with_base7
+    execute_test_with(TEST_VALUES_BASE_7, ToDecimal::Base7)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_7
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_7)
+  def test_removes_leading_zeros_from_string_with_base8
+    execute_test_with(TEST_VALUES_BASE_8, ToDecimal::Base8)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_8
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_8)
+  def test_removes_leading_zeros_from_string_with_base9
+    execute_test_with(TEST_VALUES_BASE_9, ToDecimal::Base9)
   end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_9
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_9)
+  def test_removes_leading_zeros_from_string_with_base10
+    execute_test_with(TEST_VALUES_BASE_10, ToDecimal::Base10)
   end
+end
 
-  def test_to_d_class_method_returns_decimal_value_of_number_of_base_10
-    execute_test_of_to_d_class_method(TEST_VALUES_BASE_10)
+class ConvertorCannotBeInstantiatedTest < Minitest::Test
+  def test_raises_error_if_user_tries_to_instantiate_new_convertor
+    assert_raises(NoMethodError) { ToDecimal::Convertor.new }
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: to_decimal
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Laurent Guinotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-07 00:00:00.000000000 Z
+date: 2018-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,8 @@ files:
 - README.md
 - Rakefile
 - lib/to_decimal.rb
-- lib/to_decimal/to_decimal_class.rb
+- lib/to_decimal/convertor_class.rb
+- lib/to_decimal/validator_class.rb
 - lib/to_decimal/wrong_base_input_error.rb
 - test/to_decimal_test.rb
 homepage: https://github.com/loranger32/to_decimal
@@ -89,7 +90,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/loranger32/to_decimal
-  changelog_uri: https://github.com/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/loranger32/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/to_decimal/to_decimal_class.rb

@@ -1,60 +0,0 @@
-class ToDecimal
-  attr_reader :base
-
-  def self.to_d(digit, base: 10)
-    self.new(base).to_d(digit)
-  end
-  
-  def initialize(base=10)
-    @base = format_and_validate(base)
-  end
-
-  def base=(new_base)
-    @base = format_and_validate(new_base)
-  end
-
-  def to_d(input)
-    formatted_input = format(input).digits
-    validate_input(formatted_input)
-    decimal = 0
-    formatted_input.each_with_index do |digit, power|
-      decimal += digit * (base**power)
-    end
-    decimal
-  end
-
-  alias_method :[], :to_d
-
-  private
-
-  def format(input)
-    if input.is_a?(String) || input.is_a?(Integer)
-      if input.is_a?(String)
-        input.to_i
-      else
-        input
-      end
-    else
-      raise ArgumentError, "Integer or String representation of an Integer\
-expected as input or base"
-    end
-  end
-
-  def validate_base(base)
-    raise ArgumentError, "Base must be an Integer" unless base.is_a?(Integer)
-    raise ArgumentError, "Base must be 1..10" unless base > 0 && base <= 10
-  end
-
-  def format_and_validate(base)
-    formatted_base = format(base)
-    validate_base(formatted_base)
-    formatted_base
-  end
-
-  def validate_input(formatted_input)
-    if formatted_input.any? { |digit| digit >= base }
-      raise WrongBaseInputError, "A number of base #{base} cannot have a digit\
- greater or equal to #{base}. Check your input: #{formatted_input.reverse.join}"
-    end
-  end
-end