format_engine 0.7.5 → 0.7.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7de75c3d7edeb874f08d60a24eac574aaf43b5bc
-  data.tar.gz: 1c27046189aaf9bae3697dda5385c8ce8528b660
+SHA256:
+  metadata.gz: ec7fa6186a5cf7c6b5f43baac77c50e4bffd20aa5f6cc7c2a374f18fa21af6cd
+  data.tar.gz: 7bf6cc704a4166570d2e162e7d019da702a5fd9e070fc194b23b329a806c5dcf
 SHA512:
-  metadata.gz: d6d49cbd0ecba6ef8aa43bbf168d156e871e244e5c93024a2db2731cc752fb6400d947a84416b1abdbec847cd4b10951b9fe676f55e6fe9187e544b201e43276
-  data.tar.gz: 5d737eab6f9944dc491894d887935260345ff0127d171a6d88709835085a0f6f0db8867988bdb983152234b9817a7b8a13b87a3d112dd68e6b6947984bf6cd8e
+  metadata.gz: c66ccf19b664166fe719b220e12b0497219006c11158c6d1299f576279c568b9fa703ff8f19612d358870f557aa5c249622c8296b5c0c1377a9581d15f73d9d6
+  data.tar.gz: d98b0ab166a013d6af2be1e936fb0b2efc59a442ee4d4104f3690389d89c65b4a29a5c11373c61dbf4d242a1e1981ec2bbb9251fa6e369af8439e24e14424b61

data/README.md

@@ -304,3 +304,14 @@ fmt attribute, has itself, the following attributes:
 
 Go to the GitHub repository and raise an issue calling attention to some
 aspect that could use some TLC or a suggestion or idea.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](./LICENSE.txt).
+
+## Code of Conduct
+
+Everyone interacting in the fully_freeze project’s codebases, issue trackers,
+chat rooms and mailing lists is expected to follow the
+[code of conduct](./CODE_OF_CONDUCT.md).

data/format_engine.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = FormatEngine::VERSION
   spec.authors       = ["Peter Camilleri"]
   spec.email         = ["peter.c.camilleri@gmail.com"]
-  spec.summary       = %q{An engine for string formatting and parsing.}
-  spec.description   = %q{An engine for string formatting and parsing like the strftime and strptime methods.}
-  spec.homepage      = "http://teuthida-technologies.com/"
+  spec.summary       = %q{A meta-engine for creating string formatters and parsers.}
+  spec.description   = %q{A meta-engine for creating string formatters and parsers like the strftime and strptime methods.}
+  spec.homepage      = "https://github.com/PeterCamilleri/format_engine"
   spec.license       = "MIT"
 
   raw_list           = `git ls-files`.split($/)
@@ -21,9 +21,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9.3'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency 'minitest', "~> 5.5.1"
-  spec.add_development_dependency 'minitest_visible', ">= 0.1.1"
-  spec.add_development_dependency 'rdoc', "~> 4.0.1"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "bundler", ">= 2.1.0"
+  spec.add_development_dependency 'minitest', "~> 5.7"
+  spec.add_development_dependency 'rdoc', "~> 5.0"
+
 end

data/lib/format_engine/version.rb

@@ -1,5 +1,5 @@
 
 module FormatEngine
   # The version of the format_engine gem.
-  VERSION = "0.7.5"
+  VERSION = "0.7.10".freeze
 end

data/sire.rb

@@ -3,7 +3,6 @@
 
 require_relative 'lib/format_engine'
 
-$no_alias_read_line_module = true
 require 'mini_readline'
 require 'pp'
 

data/tests/engine_base_tests.rb

@@ -1,18 +1,14 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class EngineBaseTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_that_it_has_a_library
     test = FormatEngine::Engine.new({"%A" => 42})
 
     assert_equal(42, test["%A"])
-    assert_equal(nil, test["%B"])
+    assert_nil(test["%B"])
     assert(test[:before])
     assert(test[:after])
     assert_equal(3, test.library.length)

data/tests/format_engine_tests.rb

@@ -1,16 +1,12 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 require_relative '../mocks/demo'
 
 # A full test of the formatter/parser engine.
 class FormatEngineTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_that_engines_are_returned
     assert_equal(FormatEngine::Engine, Customer.formatter_engine.class)
     assert_equal(FormatEngine::Engine, Customer.parser_engine.class)

data/tests/format_spec_tests.rb

@@ -1,207 +1,203 @@
-require_relative '../lib/format_engine'
-gem              'minitest'
-require          'minitest/autorun'
-require          'minitest_visible'
-
-class FormatSpecTester < Minitest::Test
-
-  #Track mini-test progress.
-  include MinitestVisible
-
-  def test_that_it_scans_literal_formats
-    test = FormatEngine::FormatSpec.new "ABCDEFG!"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
-    assert_equal("ABCDEFG!", test.specs[0].literal)
-  end
-
-  def test_that_backslash_quotes
-    test = FormatEngine::FormatSpec.new "ABC\\%DEFG!"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
-    assert_equal("ABC%DEFG!", test.specs[0].literal)
-  end
-
-  def test_that_it_scans_simple_variable_formats
-    test = FormatEngine::FormatSpec.new "%A"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-    assert_equal("%A", test.specs[0].format)
-    assert_equal(nil, test.specs[0].parms)
-  end
-
-  def test_that_it_scans_set_formats
-    test = FormatEngine::FormatSpec.new "%[A]"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
-    assert_equal("%[", test.specs[0].short_name)
-    assert_equal("%[A]", test.specs[0].long_name)
-    assert_equal(/[A]+/, test.specs[0].regex)
-
-    test = FormatEngine::FormatSpec.new "%*[A]"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
-    assert_equal("%*[", test.specs[0].short_name)
-    assert_equal("%*[A]", test.specs[0].long_name)
-    assert_equal(/[A]+/, test.specs[0].regex)
-
-    test = FormatEngine::FormatSpec.new "%7[A]"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
-    assert_equal("%[", test.specs[0].short_name)
-    assert_equal("%[A]", test.specs[0].long_name)
-    assert_equal(/[A]{1,7}/, test.specs[0].regex)
-
-    test = FormatEngine::FormatSpec.new "%*7[A]"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
-    assert_equal("%*[", test.specs[0].short_name)
-    assert_equal("%*[A]", test.specs[0].long_name)
-    assert_equal(/[A]{1,7}/, test.specs[0].regex)
-  end
-
-  def test_a_mixed_set
-    test = FormatEngine::FormatSpec.new "%f %l %[age] %a"
-    assert_equal(Array, test.specs.class)
-    assert_equal(7, test.specs.length)
-
-  end
-
-  def test_that_it_scans_tab_seperators
-    test = FormatEngine::FormatSpec.new "%A\t%B"
-    assert_equal(Array, test.specs.class)
-    assert_equal(3, test.specs.length)
-
-    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-    assert_equal("%A", test.specs[0].format)
-    assert_equal(nil, test.specs[0].parms)
-
-    assert_equal(FormatEngine::FormatLiteral, test.specs[1].class)
-    assert_equal("\t", test.specs[1].literal)
-
-    assert_equal(FormatEngine::FormatVariable, test.specs[2].class)
-    assert_equal("%B", test.specs[2].format)
-    assert_equal(nil, test.specs[2].parms)
-  end
-
-  def test_that_it_scans_option_variable_formats
-    "~@#&^&*-+=?_<>|".each_char do |char|
-      test = FormatEngine::FormatSpec.new "%#{char}A"
-      assert_equal(Array, test.specs.class)
-      assert_equal(1, test.specs.length)
-      assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-      assert_equal("%#{char}A", test.specs[0].format)
-      refute(test.specs[0].has_width?)
-      refute(test.specs[0].has_prec?)
-      assert_equal("", test.specs[0].width_str)
-      assert_equal("", test.specs[0].prec_str)
-      assert_equal("", test.specs[0].parm_str)
-    end
-  end
-
-  def test_that_it_scans_single_variable_formats
-    test = FormatEngine::FormatSpec.new "%123A"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-    assert_equal("%A", test.specs[0].format)
-
-    assert_equal(Array, test.specs[0].parms.class)
-    assert_equal(1, test.specs[0].parms.length)
-    assert_equal("123", test.specs[0].parms[0])
-    assert(test.specs[0].has_width?)
-    refute(test.specs[0].has_prec?)
-    assert_equal("123", test.specs[0].width_str)
-    assert_equal("", test.specs[0].prec_str)
-    assert_equal("123", test.specs[0].parm_str)
-  end
-
-  def test_that_it_scans_double_variable_formats
-    test = FormatEngine::FormatSpec.new "%123.456A"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-    assert_equal("%A", test.specs[0].format)
-
-    assert_equal(Array, test.specs[0].parms.class)
-    assert_equal(2, test.specs[0].parms.length)
-    assert_equal("123", test.specs[0].parms[0])
-    assert_equal("456", test.specs[0].parms[1])
-    assert(test.specs[0].has_width?)
-    assert(test.specs[0].has_prec?)
-    assert_equal("123", test.specs[0].width_str)
-    assert_equal("456", test.specs[0].prec_str)
-    assert_equal("123.456", test.specs[0].parm_str)
-  end
-
-  def test_negative_variable_formats
-    test = FormatEngine::FormatSpec.new "%-123.456A"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
-    assert_equal("%A", test.specs[0].format)
-
-    assert_equal(Array, test.specs[0].parms.class)
-    assert_equal(2, test.specs[0].parms.length)
-    assert_equal("-123", test.specs[0].parms[0])
-    assert_equal("456", test.specs[0].parms[1])
-    assert(test.specs[0].has_width?)
-    assert(test.specs[0].has_prec?)
-    assert_equal("-123", test.specs[0].width_str)
-    assert_equal("456", test.specs[0].prec_str)
-    assert_equal("-123.456", test.specs[0].parm_str)
-  end
-
-  def test_multipart_formats
-    test = FormatEngine::FormatSpec.new "T(%+02A:%3B:%4.1C)"
-
-    assert_equal(Array, test.specs.class)
-    assert_equal(7, test.specs.length)
-
-    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
-    assert_equal("T(", test.specs[0].literal)
-
-    assert_equal(FormatEngine::FormatVariable, test.specs[1].class)
-    assert_equal("%A", test.specs[1].format)
-    assert_equal(1, test.specs[1].parms.length)
-    assert_equal("+02", test.specs[1].parms[0])
-
-    assert_equal(FormatEngine::FormatLiteral, test.specs[2].class)
-    assert_equal(":", test.specs[2].literal)
-
-    assert_equal(FormatEngine::FormatVariable, test.specs[3].class)
-    assert_equal("%B", test.specs[3].format)
-    assert_equal(1, test.specs[3].parms.length)
-    assert_equal("3", test.specs[3].parms[0])
-
-    assert_equal(FormatEngine::FormatLiteral, test.specs[4].class)
-    assert_equal(":", test.specs[4].literal)
-
-    assert_equal(FormatEngine::FormatVariable, test.specs[5].class)
-    assert_equal("%C", test.specs[5].format)
-    assert_equal(2, test.specs[5].parms.length)
-    assert_equal("4", test.specs[5].parms[0])
-    assert_equal("1", test.specs[5].parms[1])
-
-    assert_equal(FormatEngine::FormatLiteral, test.specs[6].class)
-    assert_equal(")", test.specs[6].literal)
-  end
-
-  def test_that_it_scans_regex_formats
-    test = FormatEngine::FormatSpec.new "%/ABC/"
-    assert_equal(Array, test.specs.class)
-    assert_equal(1, test.specs.length)
-    assert_equal(FormatEngine::FormatRgx, test.specs[0].class)
-    assert_equal(/ABC/, test.specs[0].regex)
-  end
-
-
-
-end
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+
+class FormatSpecTester < Minitest::Test
+
+  def test_that_it_scans_literal_formats
+    test = FormatEngine::FormatSpec.new "ABCDEFG!"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
+    assert_equal("ABCDEFG!", test.specs[0].literal)
+  end
+
+  def test_that_backslash_quotes
+    test = FormatEngine::FormatSpec.new "ABC\\%DEFG!"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
+    assert_equal("ABC%DEFG!", test.specs[0].literal)
+  end
+
+  def test_that_it_scans_simple_variable_formats
+    test = FormatEngine::FormatSpec.new "%A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+    assert_nil(test.specs[0].parms)
+  end
+
+  def test_that_it_scans_set_formats
+    test = FormatEngine::FormatSpec.new "%[A]"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
+    assert_equal("%[", test.specs[0].short_name)
+    assert_equal("%[A]", test.specs[0].long_name)
+    assert_equal(/[A]+/, test.specs[0].regex)
+
+    test = FormatEngine::FormatSpec.new "%*[A]"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
+    assert_equal("%*[", test.specs[0].short_name)
+    assert_equal("%*[A]", test.specs[0].long_name)
+    assert_equal(/[A]+/, test.specs[0].regex)
+
+    test = FormatEngine::FormatSpec.new "%7[A]"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
+    assert_equal("%[", test.specs[0].short_name)
+    assert_equal("%[A]", test.specs[0].long_name)
+    assert_equal(/[A]{1,7}/, test.specs[0].regex)
+
+    test = FormatEngine::FormatSpec.new "%*7[A]"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatSet, test.specs[0].class)
+    assert_equal("%*[", test.specs[0].short_name)
+    assert_equal("%*[A]", test.specs[0].long_name)
+    assert_equal(/[A]{1,7}/, test.specs[0].regex)
+  end
+
+  def test_a_mixed_set
+    test = FormatEngine::FormatSpec.new "%f %l %[age] %a"
+    assert_equal(Array, test.specs.class)
+    assert_equal(7, test.specs.length)
+
+  end
+
+  def test_that_it_scans_tab_seperators
+    test = FormatEngine::FormatSpec.new "%A\t%B"
+    assert_equal(Array, test.specs.class)
+    assert_equal(3, test.specs.length)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+    assert_nil(test.specs[0].parms)
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[1].class)
+    assert_equal("\t", test.specs[1].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[2].class)
+    assert_equal("%B", test.specs[2].format)
+    assert_nil(test.specs[2].parms)
+  end
+
+  def test_that_it_scans_option_variable_formats
+    "~@#&^&*-+=?_<>|".each_char do |char|
+      test = FormatEngine::FormatSpec.new "%#{char}A"
+      assert_equal(Array, test.specs.class)
+      assert_equal(1, test.specs.length)
+      assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+      assert_equal("%#{char}A", test.specs[0].format)
+      refute(test.specs[0].has_width?)
+      refute(test.specs[0].has_prec?)
+      assert_equal("", test.specs[0].width_str)
+      assert_equal("", test.specs[0].prec_str)
+      assert_equal("", test.specs[0].parm_str)
+    end
+  end
+
+  def test_that_it_scans_single_variable_formats
+    test = FormatEngine::FormatSpec.new "%123A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+
+    assert_equal(Array, test.specs[0].parms.class)
+    assert_equal(1, test.specs[0].parms.length)
+    assert_equal("123", test.specs[0].parms[0])
+    assert(test.specs[0].has_width?)
+    refute(test.specs[0].has_prec?)
+    assert_equal("123", test.specs[0].width_str)
+    assert_equal("", test.specs[0].prec_str)
+    assert_equal("123", test.specs[0].parm_str)
+  end
+
+  def test_that_it_scans_double_variable_formats
+    test = FormatEngine::FormatSpec.new "%123.456A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+
+    assert_equal(Array, test.specs[0].parms.class)
+    assert_equal(2, test.specs[0].parms.length)
+    assert_equal("123", test.specs[0].parms[0])
+    assert_equal("456", test.specs[0].parms[1])
+    assert(test.specs[0].has_width?)
+    assert(test.specs[0].has_prec?)
+    assert_equal("123", test.specs[0].width_str)
+    assert_equal("456", test.specs[0].prec_str)
+    assert_equal("123.456", test.specs[0].parm_str)
+  end
+
+  def test_negative_variable_formats
+    test = FormatEngine::FormatSpec.new "%-123.456A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+
+    assert_equal(Array, test.specs[0].parms.class)
+    assert_equal(2, test.specs[0].parms.length)
+    assert_equal("-123", test.specs[0].parms[0])
+    assert_equal("456", test.specs[0].parms[1])
+    assert(test.specs[0].has_width?)
+    assert(test.specs[0].has_prec?)
+    assert_equal("-123", test.specs[0].width_str)
+    assert_equal("456", test.specs[0].prec_str)
+    assert_equal("-123.456", test.specs[0].parm_str)
+  end
+
+  def test_multipart_formats
+    test = FormatEngine::FormatSpec.new "T(%+02A:%3B:%4.1C)"
+
+    assert_equal(Array, test.specs.class)
+    assert_equal(7, test.specs.length)
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
+    assert_equal("T(", test.specs[0].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[1].class)
+    assert_equal("%A", test.specs[1].format)
+    assert_equal(1, test.specs[1].parms.length)
+    assert_equal("+02", test.specs[1].parms[0])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[2].class)
+    assert_equal(":", test.specs[2].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[3].class)
+    assert_equal("%B", test.specs[3].format)
+    assert_equal(1, test.specs[3].parms.length)
+    assert_equal("3", test.specs[3].parms[0])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[4].class)
+    assert_equal(":", test.specs[4].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[5].class)
+    assert_equal("%C", test.specs[5].format)
+    assert_equal(2, test.specs[5].parms.length)
+    assert_equal("4", test.specs[5].parms[0])
+    assert_equal("1", test.specs[5].parms[1])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[6].class)
+    assert_equal(")", test.specs[6].literal)
+  end
+
+  def test_that_it_scans_regex_formats
+    test = FormatEngine::FormatSpec.new "%/ABC/"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatRgx, test.specs[0].class)
+    assert_equal(/ABC/, test.specs[0].regex)
+  end
+
+
+
+end

data/tests/formatter_engine_tests.rb

@@ -1,16 +1,12 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 require_relative '../mocks/test_person_mock'
 
 # Test the internals of the formatter engine. This is not the normal interface.
 class FormatterTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def make_formatter
     FormatEngine::Engine.new(
       "%a"  => lambda {cat "%#{fmt.width_str}d" % src.age},

data/tests/literal_spec_tests.rb

@@ -1,13 +1,9 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class LiteralSpecTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_that_it_formats
     spec_info = FormatEngine::SpecInfo.new(nil, "", nil)
     test = FormatEngine::FormatLiteral.new("Test 1 2 3")

data/tests/parser_engine_tests.rb

@@ -1,16 +1,12 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 require_relative '../mocks/test_person_mock'
 
 # Test the internals of the parser engine. This is not the normal interface.
 class ParserTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def make_parser
     FormatEngine::Engine.new(
       "%a"  => lambda { tmp[:age] = found.to_i if parse(/\d+/) },

data/tests/rgx_spec_tests.rb

@@ -3,13 +3,9 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class RgxSpecTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_the_parms
     test = FormatEngine::FormatRgx.new("%/ABC/")
     assert_equal(0, test.width)

data/tests/scan_tests.rb

@@ -1,15 +1,10 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
-
 
 # Test the internals of the parser engine. This is not the normal interface.
 class ScanTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   DECIMAL  = /[+-]?\d+/
   HEX      = /[+-]?(0[xX])?\h+/
   OCTAL    = /[+-]?(0[oO])?[0-7]+/

data/tests/set_spec_tests.rb

@@ -1,13 +1,9 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class SetSpecTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_the_parms
     test = FormatEngine::FormatSet.new("%[ABC]")
     assert_equal(0, test.width)

data/tests/variable_spec_tests.rb

@@ -1,13 +1,9 @@
 require_relative '../lib/format_engine'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class VariableSpecTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_the_parms
     test = FormatEngine::FormatVariable.new("%B")
     refute(test.has_width?)

metadata

@@ -1,87 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: format_engine
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.7.10
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-23 00:00:00.000000000 Z
+date: 2021-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.5.1
+        version: '5.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.5.1
-- !ruby/object:Gem::Dependency
-  name: minitest_visible
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: '5.7'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.1
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.1
-description: An engine for string formatting and parsing like the strftime and strptime
-  methods.
+        version: '5.0'
+description: A meta-engine for creating string formatters and parsers like the strftime
+  and strptime methods.
 email:
 - peter.c.camilleri@gmail.com
 executables: []
@@ -126,7 +112,7 @@ files:
 - tests/scan_tests.rb
 - tests/set_spec_tests.rb
 - tests/variable_spec_tests.rb
-homepage: http://teuthida-technologies.com/
+homepage: https://github.com/PeterCamilleri/format_engine
 licenses:
 - MIT
 metadata: {}
@@ -145,10 +131,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
-summary: An engine for string formatting and parsing.
+summary: A meta-engine for creating string formatters and parsers.
 test_files: []
-has_rdoc: