mruby_tools 0.0.2.1 → 0.0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bde41419ba3eb29e2b6487d232c94b2cf630387f
-  data.tar.gz: 643bb284b8af86dbd22cd29a70d5badb5824fcfb
+  metadata.gz: 9d06a51f1ed9667b7b39c12bcb3173f4b064d6ad
+  data.tar.gz: e63a21a002b71f1aef930fb5f91950e90757e7c3
 SHA512:
-  metadata.gz: 4dcbdcf5da887ffad6bb6ac220aa4e2525724e228af89329beb64e58131c7eea40bf66038d13cb95c6dd3a1fe2f321e6246a6bc1cac68cf7c7b564ec6d60dff5
-  data.tar.gz: 376214a2967c23a8c9fd27aa113337a6439b4ed18c48e4749b90b94f96ac9a9e465e9bf9a86a5ec8b20235155fca3cb0ef930328d6529da7dfe5fd8ed1e28376
+  metadata.gz: 566ad106b83ae4838f08d0233f485b910e9f86d484e819c72034b4b9fb36422db9e490bcfc9f0d24add9e0f021d244400b4704644afc38bf508c90f7dff4408f
+  data.tar.gz: 32b9ae7a7685e73e17b23fba501c8036ec04065c9ee46afc97f855fbd6fc2b6cfcf2da4c29df9e685760e27cb0024d08cee470dee46be9aaf099949e1a2a4ad5

data/README.md

@@ -1 +1,226 @@
-# MRuby Tools
+[![Build Status](https://travis-ci.org/rickhull/mruby_tools.svg?branch=master)](https://travis-ci.org/rickhull/mruby_tools)
+[![Gem Version](https://badge.fury.io/rb/mruby_tools.svg)](https://badge.fury.io/rb/mruby_tools)
+[![Dependency Status](https://gemnasium.com/rickhull/mruby_tools.svg)](https://gemnasium.com/rickhull/mruby_tools)
+[![Security Status](https://hakiri.io/github/rickhull/mruby_tools/master.svg)](https://hakiri.io/github/rickhull/mruby_tools/master)
+
+# mruby tools
+
+This is a small gem that provides one tool at present: `mrbt`.  This is a
+**ruby gem**, not an **mruby mgem**, but it is primarily useful for working
+with **mruby**.
+
+`mrbt` accepts any number of .rb files and "compiles" them into a standalone
+executable using mruby.  The .rb files must be
+[mruby-compatible](https://github.com/mruby/mruby/blob/master/doc/limitations.md) (roughly equivalent to MRI v1.9).
+
+## Install
+
+### `git clone`
+
+By using `git clone` rather than `gem install`, you can make use of rake
+tasks, particularly for compiling mruby itself, a necessary prerequisite
+for using `mrbt`.  This is the easiest way to get started if you are new
+to mruby.  The mruby source is provided as a git submodule;
+therefore you must `git clone --recursive` or else update the submodule
+manually.
+
+Prerequisites:
+
+* `git`
+* `rake`
+* *build tools:* `gcc` `make` `bison` `ar`
+
+```shell
+git clone --recursive https://github.com/rickhull/mruby_tools.git
+cd mruby_tools
+rake hello_world
+```
+
+This will provide mruby source via a git repo submodule and then build it to
+provide `libmruby.a`.
+
+The rake command will proceed to "compiling" `examples/hello_world.rb` to
+a standalone binary executable `examples/hello_world`, which will then be
+executed with the customary output shown.
+
+Once mruby has been built by rake, it will not be built again by rake as long
+as `libmruby.a` is present.  The first run of `rake hello_world` takes up to
+30 seconds or so, depending on your system.  The next run of
+`rake hello_world` takes about a half-second, including compiling and
+running the executable.
+
+### *rubygems*
+
+Only use this if you have an existing mruby built and installed.  `mrbt` will
+be set up in your PATH, but you will have to specify the path to mruby
+source via `-m path/to/mruby_dir` or `MRUBY_DIR` environment variable.  You
+will not have (easy) access to rake tasks.
+
+Prerequisites:
+
+* *rubygems*
+* *build tools:* `gcc` `make` `bison` `ar`
+* *mruby_dir*
+* *mruby_dir*/build/host/lib/libmruby.a
+
+```shell
+gem install mruby_tools
+```
+
+Now, `mrbt` may be used.  It will need to know where to find the mruby_dir,
+so specify it with the `-m` flag or `MRUBY_DIR` environment variable.
+
+```shell
+export MRUBY_DIR=~/src/mruby-1.3.0    # or wherever
+mrbt file1.rb file2.rb                # etc.
+```
+
+## Usage
+
+With no additional options, `mrbt` will inject the contents of file1.rb and
+file2.rb into C strings, to be loaded with mrb_load_nstring(), written to a
+Tempfile.  `mrbt` then compiles the generated .c file using GCC and writes
+a standalone executable (around 1.5 MB for "hello world").
+
+### With `git clone` and `rake`
+
+You can use `rake mrbt` to execute `bin/mrbt` with the proper load path, and
+any arguments will be passed along. Some mrbt options conflict with rake
+options.  You can prevent rake from parsing arguments by placing them
+after ` -- `.
+
+```shell
+rake mrbt -- -h
+rake mrbt examples/hello_world.rb
+rake mrbt -- examples/hello_world.rb examples/goodbye_world.rb -o adios
+```
+
+Other useful rake tasks:
+
+* hello world - compiles and runs `examples/hello_world.rb`
+* timed_simplex - compiles and runs several files that work together
+* raise_exception - compiles and runs `examples/raise.rb`
+* examples - runs hello_world and timed_simplex
+* verbose - add verbose output, e.g. `rake verbose hello_world`
+
+### With *rubygems*
+
+```shell
+mrbt -h
+```
+
+```
+  USAGE: mrbt file1.rb file2.rb ...
+OPTIONS: -o outfile     (provide a name for the standalone executable)
+         -c generated.c (leave the specified C file on the filesystem)
+         -m mruby_dir   (provide the dir for mruby src)
+         -v             (verbose)
+```
+
+## Examples
+
+There are some example .rb files in examples/ that can be used to produce
+an executable.  Use `mrbt` or `rake mrbt` as appropriate:
+
+```shell
+mrbt examples/hello_world.rb
+
+# or
+rake mrbt examples/hello_world.rb
+
+# or even
+rake hello_world
+```
+
+```
+/home/vagrant/.rubies/ruby-2.4.0/bin/ruby -Ilib bin/mrbt examples/hello_world.rb -o examples/hello_world
+compiling...
+created binary executable: examples/hello_world
+examples/hello_world
+hello_world
+```
+
+The first line shows that rake is executing `mrbt` (via `ruby`), passing it
+`examples/hello_world.rb` and naming the output executable
+`examples/hello_world`.
+
+`mrbt` outputs "compiling..." and then "created binary
+executable: examples/hello_world"
+
+Then `examples/hello_world` is executed, and it outputs "hello_world".
+
+### Verbose Hello World
+
+```shell
+mrbt examples/hello_world.rb -v
+
+# or
+rake mrbt -- -v examples/hello_world.rb
+
+# or even
+rake verbose hello_world
+```
+
+```
+/home/vagrant/.rubies/ruby-2.4.0/bin/ruby -Ilib bin/mrbt examples/hello_world.rb -o examples/hello_world -v
+#include <stdlib.h>
+#include <mruby.h>
+#include <mruby/compile.h>
+#include <mruby/string.h>
+
+void check_exc(mrb_state *mrb, char *filename) {
+  if (mrb->exc) {
+    mrb_value exc = mrb_obj_value(mrb->exc);
+    mrb_value exc_msg = mrb_funcall(mrb, exc, "to_s", 0);
+    fprintf(stderr, "ERROR in %s - %s: %s\n",
+            filename,
+            mrb_obj_classname(mrb, exc),
+            mrb_str_to_cstr(mrb, exc_msg));
+    /* mrb_print_backtrace(mrb);   # empty */
+    exit(1);
+  }
+}
+
+int
+main(void)
+{
+  mrb_state *mrb = mrb_open();
+  if (!mrb) {
+    printf("mrb problem");
+    exit(1);
+  }
+
+  /* examples/hello_world.rb */
+  mrb_load_nstring(mrb, "puts :hello_world\n", 18);
+  check_exc(mrb, "examples/hello_world.rb");
+
+  mrb_close(mrb);
+  return 0;
+}
+
+generated /tmp/mrbt-20171117-24568-no7ee3.c
+compiling...
+created binary executable: examples/hello_world
+
+file examples/hello_world
+examples/hello_world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=2114ab60983156c92a5a74b88895f9c43a4bb086, not stripped
+
+stat examples/hello_world
+  File: ‘examples/hello_world’
+    Size: 1559056         Blocks: 3048       IO Block: 4096   regular file
+Device: 801h/2049d      Inode: 388049      Links: 1
+Access: (0755/-rwxr-xr-x)  Uid: ( 1000/ vagrant)   Gid: ( 1000/ vagrant)
+Access: 2017-11-17 18:48:25.713629203 +0000
+Modify: 2017-11-17 18:48:25.709629203 +0000
+Change: 2017-11-17 18:48:25.709629203 +0000
+ Birth: -
+
+examples/hello_world
+hello_world
+```
+
+This proceeds exactly as before but with additional output:
+
+* Show the generated C code
+* Note the temporary file containing the C code
+* Call `file` and `stat` on the output executable

data/Rakefile

@@ -1,4 +1,25 @@
 require 'rake/testtask'
+require_relative './lib/mruby_tools.rb'
+
+#
+# GET / SETUP MRUBY
+#
+
+mrb = MRubyTools.new
+
+file mrb.ar_path do
+  if mrb.src?
+    Dir.chdir MRubyTools.mruby_dir do
+      sh "make"
+    end
+  end
+  mrb.validate!
+end
+
+
+#
+# lib/mruby_tools tests
+#
 
 Rake::TestTask.new :test do |t|
   t.pattern = "test/*.rb"
@@ -6,6 +27,90 @@ Rake::TestTask.new :test do |t|
 end
 
 
+#
+# run mrbt via `rake mrbt`
+#
+
+@verbose = false
+
+task :verbose do
+  @verbose = true
+end
+
+def mrbt *args
+  args.unshift('-v') if @verbose and !args.include?('-v')
+  ruby '-Ilib', 'bin/mrbt', *args
+end
+
+task mrbt: mrb.ar_path do
+  # consume ARGV
+  args = []
+  found_mrbt = false
+  while !ARGV.empty?
+    arg = ARGV.shift
+    # skip all args until we reach 'mrbt'
+    if found_mrbt
+      args << arg
+      next
+    end
+    found_mrbt = true if arg == 'mrbt'
+  end
+  begin
+    mrbt *args
+  rescue RuntimeError
+    exit 1
+  end
+end
+
+
+#
+# mrbt EXAMPLES
+#
+
+def run_clean outfile, clean: true
+  begin
+    if @verbose
+      puts
+      sh "file", outfile
+      puts
+      sh "stat", outfile
+      puts
+    end
+    sh outfile
+  ensure
+    if clean
+      File.unlink outfile unless @verbose
+    end
+  end
+end
+
+desc "Run hello_world example"
+task hello_world: mrb.ar_path do
+  outfile = "examples/hello_world"
+  mrbt "examples/hello_world.rb", "-o", outfile
+  run_clean outfile
+end
+
+desc "Run timed_simplex example"
+task timed_simplex: mrb.ar_path do
+  outfile = "examples/timed_simplex"
+  mrbt "examples/timer.rb", "examples/simplex.rb", "examples/driver.rb",
+       "-o", outfile
+  run_clean outfile
+end
+
+desc "Run raise example"
+task raise_exception: mrb.ar_path do
+  outfile = "examples/raise"
+  mrbt "examples/hello_world.rb", "examples/raise.rb", "-o", outfile
+  run_clean outfile
+end
+
+desc "Run examples"
+task examples: [:hello_world, :timed_simplex]
+
+task default: [:test, :examples]
+
 #
 # METRICS
 #

data/VERSION

@@ -1 +1 @@
-0.0.2.1
+0.0.3.1

data/bin/mrbt

@@ -6,25 +6,33 @@ require 'mruby_tools'
 # args like: file1.rb file2.rb -o outfile
 #  possibly: file1.rb -o outfile file2.rb -c generated.c
 
-opts = MRubyTools.args(ARGV)
-MRubyTools.usage if opts[:help]
+opts = MRubyTools::CLI.args(ARGV)
+MRubyTools::CLI.usage if opts[:help]
+
+mrb = MRubyTools.new(opts[:mruby_dir]) # nil is fine
+begin
+  mrb.validate!
+rescue MRubyTools::MRubyNotFound => e
+  warn "#{e.class}: can't find #{e}"
+  exit 1
+end
 
 rb_files = opts.fetch(:rb_files)
-MRubyTools.usage("no .rb files provided") if rb_files.empty?
-c_code = MRubyTools.c_wrapper(rb_files)
+MRubyTools::CLI.usage("no .rb files provided") if rb_files.empty?
+
+c_code = MRubyTools::C.wrapper(rb_files)
 puts c_code + "\n" if opts[:verbose]
 
-out_file = opts.fetch(:out_file)
 c_file = opts.fetch(:c_file)
 c_file.write(c_code)
 c_file.close
+puts "generated #{c_file.path}" if opts[:verbose]
 
-msd = MRubyTools.mruby_src_dir
-
-gcc_args = [
-  '-std=c99', "-I", File.join(msd, 'include'), c_file.path, "-o", out_file,
-  File.join(msd, 'build', 'host', 'lib', 'libmruby.a'), '-lm',
-]
-
+out_file = opts.fetch(:out_file)
 puts "compiling..."
-puts "created binary executable: #{out_file}" if system('gcc', *gcc_args)
+if mrb.compile(c_file.path, out_file)
+  puts "created binary executable: #{out_file}"
+else
+  warn "FATAL: compile failed"
+  exit 1
+end

data/lib/mruby_tools.rb

@@ -1,8 +1,47 @@
 require 'tempfile'
 
-module MRubyTools
-  def self.c_wrapper(rb_files)
-    c_code = <<'EOF'
+class MRubyTools
+  class MRubyNotFound < RuntimeError; end
+
+  MRUBY_DIR = File.expand_path("../mruby", __dir__)
+
+  def self.mruby_dir
+    ENV['MRUBY_DIR'] || MRUBY_DIR
+  end
+
+  attr_accessor :mruby_dir, :inc_path, :ar_path
+
+  def initialize(mruby_dir = nil)
+    @mruby_dir = mruby_dir || self.class.mruby_dir
+    @inc_path = File.join(@mruby_dir, 'include')
+    @ar_path = File.join(@mruby_dir, 'build', 'host', 'lib', 'libmruby.a')
+  end
+
+  def src?
+    File.directory?(@inc_path)
+  end
+
+  def built?
+    File.readable?(@ar_path)
+  end
+
+  def validate!
+    raise(MRubyNotFound, @inc_path) unless File.directory? @inc_path
+    raise(MRubyNotFound, @ar_path) unless File.readable? @ar_path
+    self
+  end
+
+  def gcc_args(c_file, out_file)
+    ['-std=c99', "-I", @inc_path, c_file, "-o", out_file, @ar_path, '-lm']
+  end
+
+  def compile(c_file, out_file)
+    system('gcc', *self.gcc_args(c_file, out_file))
+  end
+
+  module C
+    def self.wrapper(rb_files)
+      c_code = <<'EOF'
 #include <stdlib.h>
 #include <mruby.h>
 #include <mruby/compile.h>
@@ -30,79 +69,78 @@ main(void)
     exit(1);
   }
 EOF
-    c_code += rb_files.map { |rbf|
-      "\n" + self.rb2c(rbf) + "\n\n"
-    }.join
+      c_code += rb_files.map { |rbf|
+        "\n" + self.slurp_rb(rbf) + "\n\n"
+      }.join
 
-    c_code += <<EOF
+      c_code += <<EOF
   mrb_close(mrb);
   return 0;
 }
 EOF
-    c_code
-  end
-
-  def self.rb2c(rb_filename, indent: '  ')
-    c_str = File.read(rb_filename)
-    size = c_str.size
-    c_str = c_str.gsub("\n", '\n').gsub('"', '\"')
-    c_str = File.read(rb_filename).gsub("\n", '\n').gsub('"', '\"')
-    [ "/* #{rb_filename} */",
-      'mrb_load_nstring(mrb, "' + c_str + '", ' + "#{size});",
-      "check_exc(mrb, \"#{rb_filename}\");",
-    ].map { |s| indent + s }.join("\n")
-  end
+      c_code
+    end
 
-  def self.mruby_src_dir(env_var = 'MRUBY_SRC')
-    mruby_src_dir = ENV[env_var]
-    raise "env: MRUBY_SRC is required" unless mruby_src_dir
-    raise "bad MRUBY_SRC #{mruby_src_dir}" unless File.directory? mruby_src_dir
-    mruby_inc_dir = File.join(mruby_src_dir, 'include')
-    raise "bad MRUBY_SRC #{mruby_inc_dir}" unless File.directory? mruby_inc_dir
-    mruby_src_dir
+    def self.slurp_rb(rb_filename, indent: '  ')
+      c_str = File.read(rb_filename)
+      size = c_str.size
+      c_str = c_str.gsub("\n", '\n').gsub('"', '\"')
+      [ "/* #{rb_filename} */",
+        'mrb_load_nstring(mrb, "' + c_str + '", ' + "#{size});",
+        "check_exc(mrb, \"#{rb_filename}\");",
+      ].map { |s| indent + s }.join("\n")
+    end
   end
 
-  def self.usage(msg = nil)
-    puts <<EOF
+  module CLI
+    def self.usage(msg = nil)
+      puts <<EOF
   USAGE: mrbt file1.rb file2.rb ...
 OPTIONS: -o outfile     (provide a name for the standalone executable)
          -c generated.c (leave the specified C file on the filesystem)
+         -m mruby_dir   (provide the dir for mruby src)
          -v             (verbose)
 EOF
-    warn "  ERROR: #{msg}" if msg
-    exit
-  end
+      warn "  ERROR: #{msg}" if msg
+      exit(msg ? 1 : 0)
+    end
 
-  def self.args(argv = ARGV)
-    rb_files = []
-    out_file = nil
-    c_file = nil
-    verbose = false
-    help = false
-
-    while !argv.empty?
-      arg = argv.shift
-      if arg == '-o'
-        out_file = argv.shift
-        raise "no out_file provided with -o" unless out_file
-        raise "#{out_file} is misnamed" if File.extname(out_file) == '.rb'
-      elsif arg == '-c'
-        c_file = File.open(argv.shift || 'generated.c', "w")
-      elsif arg == '-v'
-        verbose = true
-      elsif arg == '-h'
-        help = true
-      else
-        rb_files << arg
+    def self.args(argv = ARGV)
+      rb_files = []
+      out_file = nil
+      c_file = nil
+      mruby_dir = nil
+      verbose = false
+      help = false
+
+      while !argv.empty?
+        arg = argv.shift
+        if arg == '-o'
+          out_file = argv.shift
+          raise "no out_file provided with -o" unless out_file
+          raise "#{out_file} is misnamed" if File.extname(out_file) == '.rb'
+        elsif arg == '-c'
+          c_file = File.open(argv.shift || 'generated.c', "w")
+        elsif arg == '-v'
+          verbose = true
+        elsif arg == '-h'
+          help = true
+        elsif arg == '-m'
+          mruby_dir = argv.shift
+          raise "no mruby_dir provided with -m" unless mruby_dir
+        else
+          rb_files << arg
+        end
       end
-    end
 
-    c_file ||= Tempfile.new(['generated', '.c'])
+      c_file ||= Tempfile.new(['mrbt-', '.c'])
 
-    { verbose: verbose,
-      help: help,
-      c_file: c_file,
-      out_file: out_file || 'outfile',
-      rb_files: rb_files }
+      { verbose: verbose,
+        help: help,
+        c_file: c_file,
+        out_file: out_file || 'outfile',
+        rb_files: rb_files,
+        mruby_dir: mruby_dir }
+    end
   end
 end

data/mruby_tools.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rake", "~> 0"
   s.add_development_dependency "buildar", "~> 3.0"
-#  s.add_development_dependency "minitest", "~> 5.0"
+  s.add_development_dependency "minitest", "~> 5.0"
 #  s.add_development_dependency "flog", "~> 0"
 #  s.add_development_dependency "flay", "~> 0"
 #  s.add_development_dependency "roodi", "~> 0"

data/test/mruby_tools.rb

@@ -2,24 +2,31 @@ require 'mruby_tools'
 require 'minitest/autorun'
 
 describe MRubyTools do
-  describe "c_wrapper" do
-    it "must return a string of mruby C code" do
-      [[], [__FILE__]].each { |rb_files|
-        str = MRubyTools.c_wrapper(rb_files)
-        str.must_be_kind_of String
-        str.wont_be_empty
-        str.must_match(/main\(void\)/)
-        str.must_match(/return/)
-        str.must_match(/exit/)
-        str.must_match(/mruby/)
-        str.must_match(/mrb/)
+  describe "new instance" do
+    before do
+      @valid = MRubyTools.new
+      @invalid = MRubyTools.new('blah blah')
+    end
+
+    it "must validate!" do
+      @valid.validate! if @valid.built?
+      proc { @invalid.validate! }.must_raise MRubyTools::MRubyNotFound
+    end
+
+    it "must have ivars" do
+      [@valid, @invalid].each { |obj|
+        obj.mruby_dir.must_be_kind_of String
+        obj.inc_path.must_be_kind_of String
+        obj.ar_path.must_be_kind_of String
       }
+      @valid.inc_path.must_match %r{include}
+      @valid.ar_path.must_match %r{libmruby.a}
     end
   end
 
-  describe "rb2c" do
+  describe "C.slurp_rb" do
     it "must inject the contents of a ruby file into mrb_load_string()" do
-      str = MRubyTools.rb2c(__FILE__)
+      str = MRubyTools::C.slurp_rb(__FILE__)
       str.must_be_kind_of String
       str.wont_be_empty
       str.must_match(/mrb_load_n?string\(/)
@@ -27,33 +34,27 @@ describe MRubyTools do
     end
   end
 
-  describe "mruby_src_dir" do
-    it "must confirm the specified mruby source on the filesystem" do
-      candidates = []
-      %w{src git}.each { |subdir|
-        candidates +=
-          Dir[File.join(ENV['HOME'], subdir, 'mruby-1.*', 'include')]
+  describe "C.wrapper" do
+    it "must return a string of mruby C code" do
+      [[], [__FILE__]].each { |rb_files|
+        str = MRubyTools::C.wrapper(rb_files)
+        str.must_be_kind_of String
+        str.wont_be_empty
+        str.must_match(/main\(void\)/)
+        str.must_match(/return/)
+        str.must_match(/exit/)
+        str.must_match(/mruby/)
+        str.must_match(/mrb/)
       }
-      unless candidates.empty?
-        latest = File.expand_path('..', candidates.last)
-        key = 'TESTING_MRUBY_SRC_DIR'
-        ENV[key] = latest
-        dir = MRubyTools.mruby_src_dir(key)
-        File.directory?(dir).must_equal true
-        File.directory?(File.join(dir, 'include')).must_equal true
-      end
-    end
-
-    it "must accept the dir specification from the environment" do
-      proc { MRubyTools.mruby_src_dir('bad key') }.must_raise Exception
     end
   end
 
-  describe "args" do
+  describe "CLI.args" do
     it "must provide a hash with expected keys" do
-      h = MRubyTools.args([])
+      h = MRubyTools::CLI.args([])
       h.must_be_kind_of Hash
-      [:verbose, :help, :c_file, :out_file, :rb_files].each { |key|
+      [:verbose, :help, :c_file,
+       :out_file, :rb_files, :mruby_dir].each { |key|
         h.key?(key).must_equal true
       }
       h[:verbose].must_equal false
@@ -63,6 +64,7 @@ describe MRubyTools do
       h[:out_file].wont_be_empty
       h[:rb_files].must_be_kind_of Array
       h[:rb_files].must_be_empty
+      h[:mruby_dir].must_be_nil
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mruby_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.2.1
+  version: 0.0.3.1
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-16 00:00:00.000000000 Z
+date: 2017-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: TBD
 email: 
 executables: