funky-cli 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f56bde6982bfdedb5db4bf82420cc2bd615860fe
-  data.tar.gz: 23a432baa90d51b61959b08b4cfc379ffba6deef
+  metadata.gz: 60569a154fee04e94e0a645a553e1b11dd6f6acc
+  data.tar.gz: 2d2777172480c008f8646076e39d4cbde708e3f0
 SHA512:
-  metadata.gz: cda5dbcdb7d788d73273dac914bd74afc860feafa688bc9c636c571f361952348a56d950a0512574548a46d3058b821d33a222dc943a97dda959501209466f71
-  data.tar.gz: e5e6d948be3426f55bbda59756733e4183600febd4e33620b6aea4fec5f466b214be61ee084b2a89f67d577b6f3ce92c90683d4846e1c3c45f4b88f15e8223ce
+  metadata.gz: b3b9ffca21d7cc07a00417a205c0868ac2abdea28a51e411cb7615a5902dbcaccd8199e9596d51d3c0405e1b3f3d616bbd197aeb7c76746f51a9b5284c238baa
+  data.tar.gz: cdcd0fd7e955b299e794576ba1d261363d5a7654994a5a7d6065f271bd5527147f8cf7aece9f732cddebec12e22d89482aa47b949c7523864758afef1b1e63a7

data/Rakefile

@@ -98,3 +98,4 @@ desc "cleanup"
 task :clean do
   sh "rake deep_clean"
 end
+

data/build_config.rb

@@ -1,5 +1,49 @@
 def gem_config(conf)
-  #conf.gembox 'default'
+  conf.gem :core => "mruby-sprintf"
+  conf.gem :mgem => 'mruby-mtest'
+  conf.gem :core => "mruby-print"
+  conf.gem :core => "mruby-math"
+  conf.gem :core => "mruby-time"
+  conf.gem :core => "mruby-struct"
+  conf.gem :core => "mruby-enum-ext"
+  conf.gem :core => "mruby-string-ext"
+  conf.gem :core => "mruby-numeric-ext"
+  conf.gem :core => "mruby-array-ext"
+  conf.gem :core => "mruby-hash-ext"
+  conf.gem :core => "mruby-range-ext"
+  conf.gem :core => "mruby-proc-ext"
+  conf.gem :core => "mruby-symbol-ext"
+  conf.gem :core => "mruby-random"
+  conf.gem :core => "mruby-object-ext"
+  conf.gem :core => "mruby-objectspace"
+  conf.gem :core => "mruby-fiber"
+  conf.gem :core => "mruby-enumerator"
+  conf.gem :core => "mruby-enum-lazy"
+  conf.gem :core => "mruby-toplevel-ext"
+  conf.gem :core => "mruby-kernel-ext"
+  conf.gem :core => "mruby-eval"
+  conf.gem :core => "mruby-exit"
+
+  conf.gem :github => "scalone/mruby-hs-regexp"
+  conf.gem :mgem => "mruby-io"
+  conf.gem :mgem => "mruby-dir"
+  conf.gem :mgem => "mruby-tempfile"
+  conf.gem :github => "iij/mruby-require"
+  conf.gem :mgem => "mruby-socket"
+  conf.gem :mgem => "mruby-pack"
+  conf.gem :mgem => "mruby-polarssl"
+  #conf.gem :github => "sadasant/mruby-qrcode", :check_sum => "83205181508fe77f9fa7e556002334e439bcbc7b"
+  conf.gem :github => "scalone/mruby-miniz"
+  conf.gem :mgem => "mruby-sleep"
+  conf.gem :mgem => "mruby-msgpack"
+  conf.gem :mgem => "mruby-json"
+  conf.gem :github => "scalone/mruby-context"
+  conf.gem :github => "scalone/mruby-ripemd"
+  conf.gem :github => "scalone/mruby-hmac"
+  conf.gem :mgem => "mruby-sha2"
+  conf.gem :mgem => "mruby-sha1"
+  conf.gem :mgem => "mruby-base58"
+  conf.gem :mgem => "mruby-bignum"
 
   # be sure to include this gem (the cli app)
   conf.gem File.expand_path(File.dirname(__FILE__))
@@ -12,7 +56,10 @@ MRuby::Build.new do |conf|
   conf.enable_debug
   conf.enable_test
 
-  gem_config(conf)
+  conf.gem :mgem => 'mruby-mtest'
+  conf.gem :core => "mruby-print"
+
+  #gem_config(conf)
 end
 
 MRuby::Build.new('x86_64-pc-linux-gnu') do |conf|
@@ -92,3 +139,4 @@ MRuby::CrossBuild.new('i686-w64-mingw32') do |conf|
 
   gem_config(conf)
 end
+

data/mrbgem.rake

@@ -4,6 +4,50 @@ MRuby::Gem::Specification.new('funky-cli') do |spec|
   spec.summary = 'funky-cli'
   spec.bins    = ['funky-cli']
 
-  spec.add_dependency 'mruby-print', :core => 'mruby-print'
+  spec.add_dependency "mruby-sprintf", :core => "mruby-sprintf"
   spec.add_dependency 'mruby-mtest', :mgem => 'mruby-mtest'
+  spec.add_dependency "mruby-print", :core => "mruby-print"
+  spec.add_dependency "mruby-math", :core => "mruby-math"
+  spec.add_dependency "mruby-time", :core => "mruby-time"
+  spec.add_dependency "mruby-struct", :core => "mruby-struct"
+  spec.add_dependency "mruby-enum-ext", :core => "mruby-enum-ext"
+  spec.add_dependency "mruby-string-ext", :core => "mruby-string-ext"
+  spec.add_dependency "mruby-numeric-ext", :core => "mruby-numeric-ext"
+  spec.add_dependency "mruby-array-ext", :core => "mruby-array-ext"
+  spec.add_dependency "mruby-hash-ext", :core => "mruby-hash-ext"
+  spec.add_dependency "mruby-range-ext", :core => "mruby-range-ext"
+  spec.add_dependency "mruby-proc-ext", :core => "mruby-proc-ext"
+  spec.add_dependency "mruby-symbol-ext", :core => "mruby-symbol-ext"
+  spec.add_dependency "mruby-random", :core => "mruby-random"
+  spec.add_dependency "mruby-object-ext", :core => "mruby-object-ext"
+  spec.add_dependency "mruby-objectspace", :core => "mruby-objectspace"
+  spec.add_dependency "mruby-fiber", :core => "mruby-fiber"
+  spec.add_dependency "mruby-enumerator", :core => "mruby-enumerator"
+  spec.add_dependency "mruby-enum-lazy", :core => "mruby-enum-lazy"
+  spec.add_dependency "mruby-toplevel-ext", :core => "mruby-toplevel-ext"
+  spec.add_dependency "mruby-kernel-ext", :core => "mruby-kernel-ext"
+  spec.add_dependency "mruby-eval", :core => "mruby-eval"
+  spec.add_dependency "mruby-exit", :core => "mruby-exit"
+
+  spec.add_dependency "mruby-hs-regexp", :github => "scalone/mruby-hs-regexp"
+  spec.add_dependency "mruby-io", :mgem => "mruby-io"
+  spec.add_dependency "mruby-dir", :mgem => "mruby-dir"
+  spec.add_dependency "mruby-tempfile", :mgem => "mruby-tempfile"
+  spec.add_dependency "mruby-require", :github => "iij/mruby-require"
+  spec.add_dependency "mruby-socket", :mgem => "mruby-socket"
+  spec.add_dependency "mruby-pack", :mgem => "mruby-pack"
+  spec.add_dependency "mruby-polarssl", :mgem => "mruby-polarssl"
+  #spec.add_dependency "mruby-qrcode", :github => "sadasant/mruby-qrcode", :check_sum => "83205181508fe77f9fa7e556002334e439bcbc7b"
+  spec.add_dependency "mruby-miniz", :github => "scalone/mruby-miniz"
+  spec.add_dependency "mruby-sleep", :mgem => "mruby-sleep"
+  spec.add_dependency "mruby-msgpack", :mgem => "mruby-msgpack"
+  spec.add_dependency "mruby-json", :mgem => "mruby-json"
+  spec.add_dependency "mruby-context", :github => "scalone/mruby-context"
+  spec.add_dependency "mruby-ripemd", :github => "scalone/mruby-ripemd"
+  spec.add_dependency "mruby-hmac", :github => "scalone/mruby-hmac"
+  spec.add_dependency "mruby-sha2", :mgem => "mruby-sha2"
+  spec.add_dependency "mruby-sha1", :mgem => "mruby-sha1"
+  spec.add_dependency "mruby-base58", :mgem => "mruby-base58"
+  spec.add_dependency "mruby-bignum", :mgem => "mruby-bignum"
 end
+

data/mrblib/funky-cli/helper.rb

@@ -0,0 +1,13 @@
+module FunkyCli
+  class Helper
+    def self.run
+      puts "funky-cli [switches] [arguments]"
+      puts "funky-cli help                            : show this message"
+      puts "funky-cli new <name>                      : create app"
+      puts "funky-cli compile -o<out> <file1> <file2> : compile ruby to mrb"
+      puts "funky-cli console                         : mirb console"
+      puts "funky-cli run -b <out>, <file1>           : run ruby or binary file"
+      puts "funky-cli version                         : print funky-cli version"
+    end
+  end
+end

data/mrblib/funky-cli/mruby.rb

@@ -0,0 +1,24 @@
+module FunkyCli
+  class Mruby
+    def self.run(*args)
+      FunkyCli.mruby(args.size + 1, args.insert(0, "mruby"))
+    end
+
+    def self.compile(*args)
+      FunkyCli.mrbc(args.size + 1, args.insert(0, "mrbc"))
+    end
+
+    def self.console(*args)
+      path = File.expand_path("./")
+      app  = File.basename(path)
+      if File.exists?(File.join(path, "out", app, "main.mrb"))
+        Dir.chdir("out")
+        $LOAD_PATH.unshift "./#{app}"
+        require "da_funk"
+        require "main"
+      end
+      FunkyCli.mirb
+    end
+  end
+end
+

data/mrblib/funky-cli/setup.rb

@@ -0,0 +1,140 @@
+module FunkyCli
+  class Setup
+    def self.run(name)
+      Dir.mkdir(name) unless Dir.exist?(name)
+      Dir.chdir(name) do
+        write_file(".gitignore", gitignore)
+        write_file("Gemfile", gemfile)
+        write_file("Rakefile", rakefile)
+        create_dir_p("lib")
+        write_file("lib/main.rb", main)
+        create_dir_p("test/unit")
+        create_dir_p("test/integration")
+        write_file("test/test_helper.rb", helper)
+        write_file("test/unit/#{name}_test.rb", unit(name))
+        write_file("test/integration/#{name}_test.rb", integration)
+      end
+    end
+
+    def self.gitignore
+      <<IGNORE
+out/
+IGNORE
+    end
+
+    def self.create_dir_p(dir)
+      dir.split("/").inject("") do |parent, base|
+        new_dir =
+          if parent == ""
+            base
+          else
+            "#{parent}/#{base}"
+          end
+
+        create_dir(new_dir)
+
+        new_dir
+      end
+    end
+
+    def self.create_dir(dir)
+      if Dir.exist?(dir)
+        puts "  skip    #{dir}"
+      else
+        puts "  create  #{dir}/"
+        Dir.mkdir(dir)
+      end
+    end
+
+    def self.write_file(file, contents)
+      puts "  create  #{file}"
+      File.open(file, 'w') {|file| file.puts contents }
+    end
+
+    def self.gemfile
+      <<GEMFILE
+source 'https://rubygems.org'
+
+gem 'da_funk'
+gem 'funky-cli'
+gem 'rake'
+GEMFILE
+    end
+
+    def self.rakefile
+      <<RAKEFILE
+#!/usr/bin/env rake
+
+require 'rake'
+require 'fileutils'
+require 'bundler/setup'
+
+Bundler.require(:default)
+
+DaFunk::RakeTask.new do |t|
+  t.mrbc  = "funky-cli compile"
+  t.mruby = "funky-cli run -b"
+end
+RAKEFILE
+    end
+
+    def self.main
+      <<MAIN
+class Main < Device
+  def self.call
+    puts "Hello World!"
+    getc
+    true
+  end
+
+  def self.foo
+    :foo
+  end
+
+  def self.version
+    "0.0.1"
+  end
+end
+MAIN
+    end
+
+    def self.helper
+      <<HELPER
+ROOT_PATH = File.expand_path("../")
+APP_NAME = File.basename(ROOT_PATH)
+
+$LOAD_PATH.unshift "./\#{APP_NAME}"
+require 'da_funk'
+
+DaFunk::Test.configure do |t|
+  t.root_path = ROOT_PATH
+  t.name      = APP_NAME
+end
+HELPER
+    end
+
+    def self.integration
+      <<INTEGRATION
+class MainTest < DaFunk::Test.case
+  def test_true
+    assert Main.call
+  end
+end
+INTEGRATION
+    end
+
+    def self.unit(name)
+      <<UNIT
+class #{Util.camelize(name)}Test < DaFunk::Test.case
+  def test_foo0
+    assert_equal :foo, Main.foo
+  end
+
+  def test_foo1
+    assert_equal :foo, Main.foo
+  end
+end
+UNIT
+    end
+  end
+end

data/mrblib/funky-cli/version.rb

@@ -1,3 +1,3 @@
 module FunkyCli
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/mrblib/funky-cli.rb

@@ -1,7 +1,18 @@
 def __main__(argv)
-  if argv[1] == "version"
+  case argv[1]
+  when "version"
     puts "v#{FunkyCli::VERSION}"
+  when "new"
+    FunkyCli::Setup.run(argv[2])
+  when "help"
+    FunkyCli::Helper.run
+  when "compile"
+    FunkyCli::Mruby.compile(*argv[2..-1])
+  when "run"
+    FunkyCli::Mruby.run(*argv[2..-1])
+  when "console"
+    FunkyCli::Mruby.console
   else
-    puts "Hello World"
+    FunkyCli::Helper.run
   end
 end

data/mrblib/util.rb

@@ -0,0 +1,10 @@
+class Util
+  class << self
+    def camelize(string)
+      string.split("-").map {|w| w.capitalize }.map {|w|
+        w.split("_").map {|w2| w2.capitalize }.join('')
+      }.join('')
+    end
+  end
+end
+

data/src/funky_cli_gem.c

@@ -0,0 +1,316 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "mruby.h"
+#include "mruby/compile.h"
+#include "mruby/value.h"
+#include "mruby/array.h"
+#include "mruby/string.h"
+#include "mruby/hash.h"
+#include "mruby/dump.h"
+#include "mruby/proc.h"
+
+#define DONE mrb_gc_arena_restore(mrb, 0)
+
+#define RITEBIN_EXT ".mrb"
+#define C_EXT       ".c"
+
+struct mrbc_args {
+  int argc;
+  char **argv;
+  int idx;
+  const char *prog;
+  const char *outfile;
+  const char *initname;
+  mrb_bool check_syntax : 1;
+  mrb_bool verbose      : 1;
+  unsigned int flags    : 4;
+};
+
+static char *
+get_outfilename(mrb_state *mrb, char *infile, const char *ext)
+{
+  size_t infilelen;
+  size_t extlen;
+  char *outfile;
+  char *p;
+
+  infilelen = strlen(infile);
+  extlen = strlen(ext);
+  outfile = (char*)mrb_malloc(mrb, infilelen + extlen + 1);
+  memcpy(outfile, infile, infilelen + 1);
+  if (*ext) {
+    if ((p = strrchr(outfile, '.')) == NULL)
+      p = outfile + infilelen;
+    memcpy(p, ext, extlen + 1);
+  }
+
+  return outfile;
+}
+
+static int
+parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
+{
+  char *outfile = NULL;
+  static const struct mrbc_args args_zero = { 0 };
+  int i;
+
+  *args = args_zero;
+  args->argc = argc;
+  args->argv = argv;
+  args->prog = argv[0];
+
+  for (i=1; i<argc; i++) {
+    if (argv[i][0] == '-') {
+      /*fprintf(stderr, "[%d]", (argv[i])[1]);*/
+      switch ((argv[i])[1]) {
+      case 'o':
+        if (args->outfile) {
+          fprintf(stderr, "%s: an output file is already specified. (%s)\n",
+                  args->prog, outfile);
+          return -1;
+        }
+        if (argv[i][2] == '\0' && argv[i+1]) {
+          i++;
+          args->outfile = get_outfilename(mrb, argv[i], "");
+        }
+        else {
+          args->outfile = get_outfilename(mrb, argv[i] + 2, "");
+        }
+        break;
+      case 'B':
+        if (argv[i][2] == '\0' && argv[i+1]) {
+          i++;
+          args->initname = argv[i];
+        }
+        else {
+          args->initname = argv[i]+2;
+        }
+        if (*args->initname == '\0') {
+          fprintf(stderr, "%s: function name is not specified.\n", args->prog);
+          return -1;
+        }
+        break;
+      case 'c':
+        args->check_syntax = TRUE;
+        break;
+      case 'v':
+        if (!args->verbose) mrb_show_version(mrb);
+        args->verbose = TRUE;
+        break;
+      case 'g':
+        args->flags |= DUMP_DEBUG_INFO;
+        break;
+      case 'E':
+        args->flags = DUMP_ENDIAN_BIG | (args->flags & ~DUMP_ENDIAN_MASK);
+        break;
+      case 'e':
+        args->flags = DUMP_ENDIAN_LIL | (args->flags & ~DUMP_ENDIAN_MASK);
+        break;
+      case 'h':
+        return -1;
+      case '-':
+        if (argv[i][1] == '\n') {
+          return i;
+        }
+        if (strcmp(argv[i] + 2, "version") == 0) {
+          mrb_show_version(mrb);
+          exit(EXIT_SUCCESS);
+        }
+        else if (strcmp(argv[i] + 2, "verbose") == 0) {
+          args->verbose = TRUE;
+          break;
+        }
+        else if (strcmp(argv[i] + 2, "copyright") == 0) {
+          mrb_show_copyright(mrb);
+          exit(EXIT_SUCCESS);
+        }
+        return -1;
+      default:
+        return i;
+      }
+    }
+    else {
+      break;
+    }
+  }
+  if (args->verbose && args->initname && (args->flags & DUMP_ENDIAN_MASK) == 0) {
+    fprintf(stderr, "%s: generating %s endian C file. specify -e/-E for cross compiling.\n",
+            args->prog, bigendian_p() ? "big" : "little");
+  }
+  return i;
+}
+
+static int
+partial_hook(struct mrb_parser_state *p)
+{
+  mrbc_context *c = p->cxt;
+  struct mrbc_args *args = (struct mrbc_args *)c->partial_data;
+  const char *fn;
+
+  if (p->f) fclose(p->f);
+  if (args->idx >= args->argc) {
+    p->f = NULL;
+    return -1;
+  }
+  fn = args->argv[args->idx++];
+  p->f = fopen(fn, "r");
+  if (p->f == NULL) {
+    fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, fn);
+    return -1;
+  }
+  mrb_parser_set_filename(p, fn);
+  return 0;
+}
+
+static mrb_value
+load_file(mrb_state *mrb, struct mrbc_args *args)
+{
+  mrbc_context *c;
+  mrb_value result;
+  char *input = args->argv[args->idx];
+  FILE *infile;
+  mrb_bool need_close = FALSE;
+
+  c = mrbc_context_new(mrb);
+  if (args->verbose)
+    c->dump_result = TRUE;
+  c->no_exec = TRUE;
+  if (input[0] == '-' && input[1] == '\0') {
+    infile = stdin;
+  }
+  else {
+    need_close = TRUE;
+    if ((infile = fopen(input, "r")) == NULL) {
+      fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
+      return mrb_nil_value();
+    }
+  }
+  mrbc_filename(mrb, c, input);
+  args->idx++;
+  if (args->idx < args->argc) {
+    need_close = FALSE;
+    mrbc_partial_hook(mrb, c, partial_hook, (void*)args);
+  }
+
+  result = mrb_load_file_cxt(mrb, infile, c);
+  if (need_close) fclose(infile);
+  mrbc_context_free(mrb, c);
+  if (mrb_undef_p(result)) {
+    return mrb_nil_value();
+  }
+  return result;
+}
+
+static int
+dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args)
+{
+  int n = MRB_DUMP_OK;
+  mrb_irep *irep = proc->body.irep;
+
+  if (args->initname) {
+    n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+    if (n == MRB_DUMP_INVALID_ARGUMENT) {
+      fprintf(stderr, "%s: invalid C language symbol name\n", args->initname);
+    }
+  }
+  else {
+    n = mrb_dump_irep_binary(mrb, irep, args->flags, wfp);
+  }
+  if (n != MRB_DUMP_OK) {
+    fprintf(stderr, "%s: error in mrb dump (%s) %d\n", args->prog, outfile, n);
+  }
+  return n;
+}
+
+static mrb_value
+mrb_mruby_cli_mrbc(mrb_state *mrb, mrb_value klass)
+{
+  FILE *wfp;
+  char *argv[255];
+  struct mrbc_args args;
+  mrb_int n, result, i, argc;
+  mrb_value load, array, element;
+
+  mrb_get_args(mrb, "io", &argc, &array);
+
+  for (i = 0; i < argc; i++) {
+    element = mrb_ary_shift(mrb, array);
+    argv[i] = RSTRING_PTR(element);
+  }
+
+  if (mrb == NULL) {
+    fputs("Invalid mrb_state, exiting funky-cli\n", stderr);
+    return mrb_fixnum_value(EXIT_FAILURE);
+  }
+
+  n = parse_args(mrb, argc, argv, &args);
+  if (n == argc) {
+    fprintf(stderr, "%s: no program file given\n", args.prog);
+    return mrb_fixnum_value(EXIT_FAILURE);
+  }
+  if (args.outfile == NULL && !args.check_syntax) {
+    if (n + 1 == argc) {
+      args.outfile = get_outfilename(mrb, argv[n], args.initname ? C_EXT : RITEBIN_EXT);
+    }
+    else {
+      fprintf(stderr, "%s: output file should be specified to compile multiple files\n", args.prog);
+      return mrb_fixnum_value(EXIT_FAILURE);
+    }
+  }
+
+  args.idx = n;
+  load = load_file(mrb, &args);
+  if (mrb_nil_p(load)) {
+    return mrb_fixnum_value(EXIT_FAILURE);
+  }
+  if (args.check_syntax) {
+    printf("%s:%s:Syntax OK\n", args.prog, argv[n]);
+  }
+
+  if (args.check_syntax) {
+    return mrb_fixnum_value(EXIT_SUCCESS);
+  }
+
+  if (args.outfile) {
+    if (strcmp("-", args.outfile) == 0) {
+      wfp = stdout;
+    }
+    else if ((wfp = fopen(args.outfile, "wb")) == NULL) {
+      fprintf(stderr, "%s: cannot open output file:(%s)\n", args.prog, args.outfile);
+      return mrb_fixnum_value(EXIT_FAILURE);
+    }
+  }
+  else {
+    fprintf(stderr, "Output file is required\n");
+    return mrb_fixnum_value(EXIT_FAILURE);
+  }
+  result = dump_file(mrb, wfp, args.outfile, mrb_proc_ptr(load), &args);
+  fclose(wfp);
+  if (result != MRB_DUMP_OK) {
+    return mrb_fixnum_value(EXIT_FAILURE);
+  }
+
+  return mrb_fixnum_value(EXIT_SUCCESS);
+}
+
+mrb_value mrb_mruby_cli_mirb(mrb_state *mrb, mrb_value klass);
+mrb_value mrb_mruby_cli_mruby(mrb_state *mrb, mrb_value klass);
+
+void
+mrb_funky_cli_gem_init(mrb_state* mrb)
+{
+  struct RClass *cli;
+
+  cli = mrb_define_module(mrb, "FunkyCli");
+  mrb_define_class_method(mrb , cli , "mrbc"  , mrb_mruby_cli_mrbc  , MRB_ARGS_REQ(2));
+  mrb_define_class_method(mrb , cli , "mirb"  , mrb_mruby_cli_mirb  , MRB_ARGS_NONE());
+  mrb_define_class_method(mrb , cli , "mruby" , mrb_mruby_cli_mruby , MRB_ARGS_REQ(2));
+  DONE;
+}
+
+void
+mrb_funky_cli_gem_final(mrb_state* mrb)
+{
+}