to_decimal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f859738206a03fb0a00035e44e2a662802ff26bff56df8d39ccb09b16cacd615
+  data.tar.gz: ced07eabf62e00f554914d5c4f865063c2924972d912f7f617c0736d3e0ad340
+SHA512:
+  metadata.gz: 1a467ba70eb07499cad887f9db131173f104bad319845c332dde768431cfb59672b85c87c599a436ded343520676c588b413ad88c922d55e208a64939d637af9
+  data.tar.gz: e439bb489045de5973dfa690fb632e4b4df58b420dc454a90c59e78663ddd3de3657387b2ca3e3091deb80cda933f0e2c47b89e0576c15bdbed8377b4f4ad275

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+ruby '2.5.0'
+
+gem 'minitest'
+gem 'minitest-reporters', '~> 1.1'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.3)
+    minitest (5.11.3)
+    minitest-reporters (1.1.19)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    rake (12.3.0)
+    ruby-progressbar (1.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  minitest-reporters (~> 1.1)
+  rake
+
+RUBY VERSION
+   ruby 2.5.0p0
+
+BUNDLED WITH
+   1.16.1

data/LICENCE.txt

@@ -0,0 +1,20 @@
+to_decimal Copyright 2017 Laurent Guinotte
+
+***MIT Licence***
+
+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,124 @@
+# to_decimal
+
+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)`).
+
+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.
+
+I found the following two gems :
+- [bases](https://github.com/whatyouhide/bases) ;
+- [radix](https://github.com/rubyworks/radix) gems ;
+
+They are very comprehensive, and go both behind the base 36, which is the limit
+of Ruby.
+
+But they are a little too heavy for my purpose. I just wanted something like :
+
+```ruby
+ToDecimal.to_d(12, base: 8) # => 10
+
+# or
+
+base8.to_d(12) # => 10
+
+# or even
+
+base8[12] # => 10 
+```
+
+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.
+
+So I decided to create this little gem for that. If something similar already
+exists, I would be happy to know.
+
+
+# Installation
+```shell
+$ gem install to_decimal
+$ bundle install
+```
+
+# Test
+
+This project is tested under minitest.
+
+`rake` or `rake test`
+
+# Usage
+
+### Instance methods
+
+Instantiate a new `ToDecimal` object :
+
+```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 :
+
+```ruby
+base8.base = 3
+
+#or
+
+base8.base = '3'
+```
+
+To convert a number of a given base to a base 10 integer, use the `#to_d(input)`
+method (alias `#to_decimal`):
+
+```ruby
+base8.to_d(12) # => 10
+
+# alias
+
+convertor[12] # => 10
+```
+An error wil be raised if the input integer is not of the given base.
+
+### Class method
+
+Instead of creating a new object, you can also call a class method `#to_d` on
+the ToDecimal class itself :
+
+```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 !
+
+- Fork it ;
+- Create your own branch (`git checkout -b my-new-feature`) ;
+- Make your feature addition or bug fix ;
+- Add tests for it ;
+- Commit on your own branch ;
+- Push to the branch (`git push origin my-new-feature`) ;
+- Create a new pull request ;
+
+# Author
+
+Laurent Guinotte
+
+
+# Licence
+
+to_decimal is released under the MIT Licence. See LICENCE.txt
+for further details.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake/testtask'
+require 'find'
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc 'Run tests'
+task :default => :test
+
+desc 'Display inventory of all files'
+task :inventory do
+  Find.find('.') do |name|
+    next if name.include?('/.') # Excludes files and directories with . names
+    puts name if File.file?(name)
+  end
+end
+
+desc 'Run rubocop'
+task :rub do
+  sh 'rubocop'
+end

data/lib/to_decimal.rb

@@ -0,0 +1,2 @@
+require_relative 'to_decimal/to_decimal_class'
+require_relative 'to_decimal/wrong_base_input_error'

data/lib/to_decimal/to_decimal_class.rb

@@ -0,0 +1,60 @@
+class ToDecimal
+  attr_reader :input, :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

data/lib/to_decimal/wrong_base_input_error.rb

@@ -0,0 +1 @@
+class WrongBaseInputError < ArgumentError; end

data/test/to_decimal_test.rb

@@ -0,0 +1,254 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require_relative '../lib/to_decimal'
+
+# ========== Data for the tests ================================================
+
+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)
+  test_values.each do |data_set|
+    assert_equal data_set[2], ToDecimal.to_d(data_set[0], base: data_set[1])
+  end
+end
+
+class ToDecimalConvertorTest < Minitest::Test
+  # ======== Setup =============================================================
+
+  def setup
+    @convertor = ToDecimal.new
+  end
+
+  # ======== Testing initialization process ====================================
+
+  def test_initialization_without_argument_has_default_base
+    assert_equal 10, @convertor.base
+  end
+
+  def test_initialization_with_arguments_has_base
+    @new_convertor = ToDecimal.new(8)
+    assert_equal 8, @new_convertor.base
+  end
+
+  def test_initialization_accepts_also_string_as_base
+    @new_convertor = ToDecimal.new('4')
+    assert_equal 4, @new_convertor.base
+  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)
+  end
+
+  def test_base_can_also_be_updated_with_a_string
+    @convertor.base = '4'
+    assert_equal 4, @convertor.base
+  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 }
+  end
+
+  def test_raises_an_error_if_base_arg_is_greater_than_10
+    assert_raises(ArgumentError) { @convertor.base = 12 }
+  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 }
+  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
+
+  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
+
+  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
+
+  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) }
+  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) }
+  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) }
+  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) }
+  end
+
+  def test_to_d_raises_error_if_input_is_not_from_base_9
+    @convertor.base = 9
+    assert_raises(WrongBaseInputError) { @convertor.to_d(9) }
+  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)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_3
+    execute_test_of_to_d(TEST_VALUES_BASE_3)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_4
+    execute_test_of_to_d(TEST_VALUES_BASE_4)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_5
+    execute_test_of_to_d(TEST_VALUES_BASE_5)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_6
+    execute_test_of_to_d(TEST_VALUES_BASE_6)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_7
+    execute_test_of_to_d(TEST_VALUES_BASE_7)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_8
+    execute_test_of_to_d(TEST_VALUES_BASE_8)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_9
+    execute_test_of_to_d(TEST_VALUES_BASE_9)
+  end
+
+  def test_to_d_returns_decimal_value_of_number_of_base_10
+    execute_test_of_to_d(TEST_VALUES_BASE_10)
+  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])
+  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) }
+  end
+
+  def test_to_d_class_method_accepts_strings_for_both_parameters
+    assert_silent { ToDecimal.to_d('101', base: '2') }
+  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) }
+  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) }
+  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
+
+  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) }
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: to_decimal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Laurent Guinotte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: |
+  Provides a simple way to convert an integer expressed in bases
+  2 up to 10 to a decimal integer
+email: laurentguinotte@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENCE.txt
+- README.md
+- Rakefile
+- lib/to_decimal.rb
+- lib/to_decimal/to_decimal_class.rb
+- lib/to_decimal/wrong_base_input_error.rb
+- test/to_decimal_test.rb
+homepage: https://github.com/loranger32/to_decimal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A simple integer converter from bases 2..10 to decimal integers
+test_files: []