much-decimal 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  data.tar.gz: defcdf171b49f129b69685c1a999a1872843d112
-  metadata.gz: 0a02551889905e311afb337fed92d4c9b53c7427
-SHA512: 
-  data.tar.gz: 6f6638b2f55058c237cb24a6a91d0f2fe113f0280eae6f66872489d9337d9e9f2dea559c0d09c14cf41862105b29f6191ac0c8d80ec0e0647ece5b300990d5d8
-  metadata.gz: 8da6b0a650cce4c7f80958f99c36cf87df22491f8e68a8dd5d17b60469e79afe44e793be46bd6c789222ce994e031835985a604f6c3a203b775c8f9edec9d950
+---
+SHA256:
+  metadata.gz: 17deac20653a970e1af8304da862f557e10c701e2b5ac469ea468f04e9e4dfa5
+  data.tar.gz: 93ba2c5485af9d79cebd1fae5457b92acec08dc4669e4fec1106c63ce4d05f74
+SHA512:
+  metadata.gz: 1e02c119bffc8890aaf82acc21ae2c65050cc06e5a221411774b13b1118060c0b9ded30fb560fc6192be201496283935c6fbd582963db28f602b996bf17ba957
+  data.tar.gz: d99c011bbe87a62916b9a2d445d398a75b88badd3c7e1eebaee28901e40dbfb8eaeab6505c7c11f95bfb3a7ee1702c525c50e8464bcc589bd17aa9d86f6f1598

data/.l.yml

@@ -0,0 +1,8 @@
+# https://github.com/redding/l.rb
+
+linters:
+  - name: "Rubocop"
+    cmd: "bundle exec rubocop"
+    extensions:
+      - ".rb"
+    cli_abbrev: "u"

data/.rubocop.yml

@@ -0,0 +1,6 @@
+inherit_gem:
+  much-style-guide:
+    - "lib/much-style-guide/rubocop.yml"
+
+AllCops:
+  SuggestExtensions: false

data/.ruby-version

@@ -0,0 +1 @@
+2.5.8

data/.t.yml

@@ -0,0 +1,4 @@
+- default_cmd: "bundle exec assert"
+  test_dir: "test"
+  test_file_suffixes:
+    - "_tests.rb"

data/Gemfile

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby "~> 2.5"
+
 gemspec
 
-gem 'pry', "~> 0.9.0"
+gem "pry"

data/README.md

@@ -10,7 +10,7 @@ TODO: Write code samples and usage instructions here
 
 Add this line to your application's Gemfile:
 
-    gem 'much-decimal'
+    gem "much-decimal"
 
 And then execute:
 

data/lib/much-decimal.rb

@@ -1,77 +1,69 @@
-require 'much-plugin'
+# frozen_string_literal: true
 
-require 'much-decimal/version'
+require "much-decimal/version"
+require "much-mixin"
 
 module MuchDecimal
-  include MuchPlugin
+  include MuchMixin
 
-  DEFAULT_PRECISION = 2.freeze
+  DEFAULT_PRECISION = 2
 
   def self.integer_to_decimal(integer, precision)
     if integer.respond_to?(:to_i) && !integer.to_s.empty?
-      base_10_modifier = (10.0 ** precision)
+      base_10_modifier = (10.0**precision)
       integer.to_i / base_10_modifier
     end
   end
 
   def self.decimal_to_integer(decimal, precision)
     if decimal.respond_to?(:to_f) && !decimal.to_s.empty?
-      base_10_modifier = (10.0 ** precision)
+      base_10_modifier = (10.0**precision)
       (decimal.to_f * base_10_modifier).round.to_i
     end
   end
 
-  plugin_included do
-    extend ClassMethods
-  end
-
-  module ClassMethods
-
-    def decimal_as_integer(attribute, options = nil)
-      options ||= {}
-      source    = options[:source] || "#{attribute}_as_integer"
-      precision = (options[:precision] || DEFAULT_PRECISION).to_i
-
-      define_method(attribute) do
-        integer = self.send(source)
-        MuchDecimal.integer_to_decimal(integer, precision)
-      end
-
-      define_method("#{attribute}=") do |decimal|
-        integer = MuchDecimal.decimal_to_integer(decimal, precision)
-        self.send("#{source}=", integer)
-      end
+  mixin_class_methods do
+    def decimal_as_integer(attribute, source: nil, precision: nil)
+      source ||= "#{attribute}_as_integer"
+      precision = (precision || DEFAULT_PRECISION).to_i
+
+      class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{attribute}
+          MuchDecimal.integer_to_decimal(#{source}, #{precision})
+        end
+
+        def #{attribute}=(decimal_value)
+          self.#{source} =
+            MuchDecimal.decimal_to_integer(decimal_value, #{precision})
+        end
+      RUBY
     end
-
   end
+end
 
-  module TestHelpers
-    include MuchPlugin
-
-    plugin_included do
-      include InstanceMethods
-
-      require 'assert/factory'
-    end
-
-    module InstanceMethods
-
-      def assert_decimal_as_integer(subject, attribute, options = nil)
-        options ||= {}
-        source    = options[:source] || "#{attribute}_as_integer"
-        precision = (options[:precision] || DEFAULT_PRECISION).to_i
-
-        value = Assert::Factory.float
-        subject.send("#{attribute}=", value)
+module MuchDecimal::TestHelpers
+  include MuchMixin
 
-        exp = MuchDecimal.decimal_to_integer(value, precision)
-        assert_equal exp, subject.send(source)
-        exp = MuchDecimal.integer_to_decimal(exp, precision)
-        assert_equal exp, subject.send(attribute)
-      end
+  mixin_included do
+    require "assert/factory"
+  end
 
+  mixin_instance_methods do
+    def assert_decimal_as_integer(
+          subject,
+          attribute,
+          source: nil,
+          precision: nil)
+      source ||= "#{attribute}_as_integer"
+      precision = (precision || MuchDecimal::DEFAULT_PRECISION).to_i
+
+      value = Assert::Factory.float
+      subject.public_send("#{attribute}=", value)
+
+      integer = MuchDecimal.decimal_to_integer(value, precision)
+      assert_that(subject.public_send(source)).equals(integer)
+      assert_that(subject.public_send(attribute))
+        .equals(MuchDecimal.integer_to_decimal(integer, precision))
     end
-
   end
-
 end

data/lib/much-decimal/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchDecimal
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/much-decimal.gemspec

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-decimal/version"
 
@@ -11,15 +13,17 @@ Gem::Specification.new do |gem|
   gem.summary     = "Define decimal attributes that are stored as integers"
   gem.description = "Define decimal attributes that are stored as integers"
   gem.homepage    = "https://github.com/redding/much-decimal"
-  gem.license     = 'MIT'
+  gem.license     = "MIT"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.16.1"])
+  gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency('much-plugin', ["~> 0.2.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.2"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.4.0"])
 
+  gem.add_dependency("much-mixin", ["~> 0.2.3"])
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,15 +7,6 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
-
-require 'test/support/factory'
-
-# 1.8.7 backfills
+require "pry"
 
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,6 +1,7 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
-
 end

data/test/unit/much_decimal_tests.rb

@@ -1,220 +1,214 @@
-require 'assert'
-require 'much-decimal'
+# frozen_string_literal: true
 
-module MuchDecimal
+require "assert"
+require "much-decimal"
 
+module MuchDecimal
   class UnitTests < Assert::Context
     desc "MuchDecimal"
-    setup do
-      @module = MuchDecimal
-    end
-    subject{ @module }
+    subject{ unit_module }
+
+    let(:unit_module){ MuchDecimal }
+
+    let(:integer){ Factory.integer }
+    let(:decimal){ Factory.float }
+    let(:precision){ Factory.integer(10) }
+    let(:base_10_modifier){ 10.0**precision }
+    let(:invalid_value){ [nil, "", true, false].sample }
 
     should have_imeths :integer_to_decimal, :decimal_to_integer
 
-    should "use much-plugin" do
-      assert_includes MuchPlugin, subject
+    should "use MuchMixin" do
+      assert_that(subject).includes(MuchMixin)
     end
 
     should "know its default precision" do
-      assert_equal 2, DEFAULT_PRECISION
+      assert_that(DEFAULT_PRECISION).equals(2)
     end
 
     should "know how to convert an integer to a decimal" do
-      integer          = Factory.integer
-      precision        = Factory.integer(10)
-      base_10_modifier = (10.0 ** precision)
-
       exp = integer / base_10_modifier
-      assert_equal exp, subject.integer_to_decimal(integer,      precision)
-      assert_equal exp, subject.integer_to_decimal(integer.to_s, precision)
+      assert_that(subject.integer_to_decimal(integer, precision)).equals(exp)
+      assert_that(subject.integer_to_decimal(integer.to_s, precision))
+        .equals(exp)
 
-      invalid_value = [nil, '', true, false].sample
-      assert_nil subject.integer_to_decimal(invalid_value, precision)
+      assert_that(subject.integer_to_decimal(invalid_value, precision)).is_nil
     end
 
     should "know how to convert a decimal to an integer" do
-      decimal          = Factory.float
-      precision        = Factory.integer(10)
-      base_10_modifier = (10.0 ** precision)
-
       exp = (decimal * base_10_modifier).round.to_i
-      assert_equal exp, subject.decimal_to_integer(decimal,      precision)
-      assert_equal exp, subject.decimal_to_integer(decimal.to_s, precision)
+      assert_that(subject.decimal_to_integer(decimal, precision)).equals(exp)
+      assert_that(subject.decimal_to_integer(decimal.to_s, precision))
+        .equals(exp)
 
-      invalid_value = [nil, '', true, false].sample
-      assert_nil subject.decimal_to_integer(invalid_value, precision)
+      assert_that(subject.decimal_to_integer(invalid_value, precision)).is_nil
     end
-
   end
 
-  class MixinSetupTests < UnitTests
-    setup do
-      @class = Class.new do
+  class ReceiverSetupTests < UnitTests
+    subject{ receiver_class }
+
+    let(:receiver_class) do
+      Class.new do
         include MuchDecimal
         attr_accessor :seconds_as_integer, :integer_seconds
       end
     end
-    subject{ @class }
-
   end
 
-  class MixinTests < MixinSetupTests
-    desc "when mixed in"
+  class ReceiverTests < ReceiverSetupTests
+    desc "receiver"
+
+    let(:decimal){ Factory.float }
+    let(:integer){ Factory.integer }
+
+    let(:custom_source){ :integer_seconds }
+    let(:custom_precision){ Factory.integer(5) }
 
     should have_imeths :decimal_as_integer
 
     should "add a decimal-as-integer accessor using `decimal_as_integer`" do
-      subject.decimal_as_integer :seconds
-
-      instance = subject.new
-      assert_respond_to :seconds,  instance
-      assert_respond_to :seconds=, instance
+      subject.decimal_as_integer(:seconds)
 
-      decimal = Factory.float
-      integer = Factory.integer
+      receiver = subject.new
+      assert_that(receiver).responds_to(:seconds)
+      assert_that(receiver).responds_to(:seconds=)
 
-      instance.seconds = decimal
-      exp = @module.decimal_to_integer(decimal, DEFAULT_PRECISION)
-      assert_equal exp, instance.seconds_as_integer
+      receiver.seconds = decimal
+      assert_that(receiver.seconds_as_integer)
+        .equals(unit_module.decimal_to_integer(decimal, DEFAULT_PRECISION))
 
-      instance.seconds_as_integer = integer
-      exp = @module.integer_to_decimal(integer, DEFAULT_PRECISION)
-      assert_equal exp, instance.seconds
+      receiver.seconds_as_integer = integer
+      assert_that(receiver.seconds)
+        .equals(unit_module.integer_to_decimal(integer, DEFAULT_PRECISION))
     end
 
     should "allow specifying custom options using `decimal_as_integer`" do
-      source    = :integer_seconds
-      precision = Factory.integer(5)
-      subject.decimal_as_integer :seconds, {
-        :source    => source,
-        :precision => precision
-      }
-
-      instance = subject.new
-      assert_respond_to :seconds,  instance
-      assert_respond_to :seconds=, instance
+      subject.decimal_as_integer(
+        :seconds,
+        source:    custom_source,
+        precision: custom_precision,
+      )
 
-      decimal = Factory.float
-      integer = Factory.integer
+      receiver = subject.new
+      assert_that(receiver).responds_to(:seconds)
+      assert_that(receiver).responds_to(:seconds=)
 
-      instance.seconds = decimal
-      exp = @module.decimal_to_integer(decimal, precision)
-      assert_equal exp, instance.send(source)
+      receiver.seconds = decimal
+      assert_that(receiver.public_send(custom_source))
+        .equals(unit_module.decimal_to_integer(decimal, custom_precision))
 
-      instance.send("#{source}=", integer)
-      exp = @module.integer_to_decimal(integer, precision)
-      assert_equal exp, instance.seconds
+      receiver.public_send("#{custom_source}=", integer)
+      assert_that(receiver.seconds)
+        .equals(unit_module.integer_to_decimal(integer, custom_precision))
     end
-
   end
 
   class EdgeCaseTests < UnitTests
     desc "edge cases"
-    setup do
-      @class = Class.new do
+    subject{ receiver_class.new }
+
+    let(:receiver_class) do
+      Class.new do
         include MuchDecimal
 
         attr_accessor :ten_thousandth_seconds
 
-        decimal_as_integer(:seconds, {
-          :source    => :ten_thousandth_seconds,
-          :precision => 4
-        })
+        decimal_as_integer :seconds,
+                           source:    :ten_thousandth_seconds,
+                           precision: 4
       end
-      @instance = @class.new
     end
-    subject{ @instance }
 
     should "allow writing and reading `nil` values" do
-      assert_nil subject.ten_thousandth_seconds
-      assert_nil subject.seconds
+      assert_that(subject.ten_thousandth_seconds).is_nil
+      assert_that(subject.seconds).is_nil
 
       subject.seconds = 1.2345
-      assert_equal 12345,  subject.ten_thousandth_seconds
-      assert_equal 1.2345, subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(12345)
+      assert_that(subject.seconds).equals(1.2345)
 
-      assert_nothing_raised{ subject.seconds = nil }
-      assert_nil subject.seconds
-      assert_nil subject.ten_thousandth_seconds
+      assert_that{ subject.seconds = nil }.does_not_raise
+      assert_that(subject.seconds).is_nil
+      assert_that(subject.ten_thousandth_seconds).is_nil
     end
 
     should "write empty string values as `nil` values" do
       subject.seconds = 1.2345
-      assert_not_nil subject.ten_thousandth_seconds
-      assert_not_nil subject.seconds
+      assert_that(subject.ten_thousandth_seconds).is_not_nil
+      assert_that(subject.seconds).is_not_nil
 
-      assert_nothing_raised{ subject.seconds = '' }
-      assert_nil subject.seconds
-      assert_nil subject.ten_thousandth_seconds
+      assert_that{ subject.seconds = "" }.does_not_raise
+      assert_that(subject.seconds).is_nil
+      assert_that(subject.ten_thousandth_seconds).is_nil
     end
 
     should "write values that can't be converted as `nil` values" do
       subject.seconds = 1.2345
-      assert_not_nil subject.ten_thousandth_seconds
-      assert_not_nil subject.seconds
+      assert_that(subject.ten_thousandth_seconds).is_not_nil
+      assert_that(subject.seconds).is_not_nil
 
-      assert_nothing_raised{ subject.seconds = true }
-      assert_nil subject.seconds
-      assert_nil subject.ten_thousandth_seconds
+      assert_that{ subject.seconds = true }.does_not_raise
+      assert_that(subject.seconds).is_nil
+      assert_that(subject.ten_thousandth_seconds).is_nil
     end
 
     should "handle decimals with less significant digits" do
       subject.seconds = 1.12
-      assert_equal 11200, subject.ten_thousandth_seconds
-      assert_equal 1.12,  subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(11200)
+      assert_that(subject.seconds).equals(1.12)
     end
 
     should "handle integers" do
       subject.seconds = 5
-      assert_equal 50000, subject.ten_thousandth_seconds
-      assert_equal 5.0,   subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(50000)
+      assert_that(subject.seconds).equals(5.0)
     end
 
     should "handle decimals that are less than 1" do
       subject.seconds = 0.0001
-      assert_equal 1,      subject.ten_thousandth_seconds
-      assert_equal 0.0001, subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(1)
+      assert_that(subject.seconds).equals(0.0001)
     end
 
     should "handle decimals with too many significant digits by rounding" do
       subject.seconds = 1.00005
-      assert_equal 10001,  subject.ten_thousandth_seconds
-      assert_equal 1.0001, subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(10001)
+      assert_that(subject.seconds).equals(1.0001)
     end
 
     should "handle repeating decimals" do
       subject.seconds = 1 / 3.0
-      assert_equal 3333,   subject.ten_thousandth_seconds
-      assert_equal 0.3333, subject.seconds
+      assert_that(subject.ten_thousandth_seconds).equals(3333)
+      assert_that(subject.seconds).equals(0.3333)
     end
-
   end
 
-  class TestHelpersTests < MixinSetupTests
+  class TestHelpersTests < ReceiverSetupTests
     include MuchDecimal::TestHelpers
 
     desc "TestHelpers"
-    setup do
-      @class.decimal_as_integer :seconds
-      @custom_precision = Factory.integer(10)
-      @class.decimal_as_integer :other_seconds, {
-        :source    => :integer_seconds,
-        :precision => @custom_precision
-      }
+    subject{ receiver_class.new }
 
-      @instance = @class.new
+    setup do
+      receiver_class.decimal_as_integer(:seconds)
+      receiver_class.decimal_as_integer(
+        :other_seconds,
+        source:    :integer_seconds,
+        precision: @custom_precision,
+      )
     end
-    subject{ @instance }
 
-    should "provide helpers for testing that a class has json fields" do
-      assert_decimal_as_integer subject, :seconds
-      assert_decimal_as_integer subject, :other_seconds, {
-        :source    => :integer_seconds,
-        :precision => @custom_precision
-      }
-    end
+    let(:custom_precision){ Factory.integer(10) }
 
+    should "provide helpers for testing that a class has decimal fields" do
+      assert_decimal_as_integer(subject, :seconds)
+      assert_decimal_as_integer(
+        subject,
+        :other_seconds,
+        source:    :integer_seconds,
+        precision: @custom_precision,
+      )
+    end
   end
-
 end

metadata

@@ -1,87 +1,106 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: much-decimal
-version: !ruby/object:Gem::Version 
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 0.1.2
 platform: ruby
-authors: 
+authors:
 - Kelly Redding
 - Collin Redding
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2016-06-15 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2021-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.2
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 2.16.1
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.2
+- !ruby/object:Gem::Dependency
+  name: much-style-guide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: much-plugin
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.2.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: much-mixin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
 description: Define decimal attributes that are stored as integers
-email: 
+email:
 - kelly@kellyredding.com
 - collin.redding@me.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
+- ".l.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".t.yml"
 - Gemfile
 - LICENSE
 - README.md
 - lib/much-decimal.rb
 - lib/much-decimal/version.rb
-- log/.gitkeep
+- log/.keep
 - much-decimal.gemspec
 - test/helper.rb
 - test/support/factory.rb
 - test/unit/much_decimal_tests.rb
-- tmp/.gitkeep
 homepage: https://github.com/redding/much-decimal
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - &id003 
-    - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Define decimal attributes that are stored as integers
-test_files: 
+test_files:
 - test/helper.rb
 - test/support/factory.rb
 - test/unit/much_decimal_tests.rb