enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-bin-mrbc/mrbgem.rake

@@ -0,0 +1,15 @@
+MRuby::Gem::Specification.new 'mruby-bin-mrbc' do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'mruby compiler executable'
+  spec.add_dependency 'mruby-compiler', :core => 'mruby-compiler'
+
+  exec = exefile("#{build.build_dir}/bin/mrbc")
+  mrbc_objs = Dir.glob("#{spec.dir}/tools/mrbc/*.c").map { |f| objfile(f.pathmap("#{spec.build_dir}/tools/mrbc/%n")) }
+
+  file exec => mrbc_objs << build.libmruby_core_static do |t|
+    build.linker.run t.name, t.prerequisites
+  end
+
+  build.bins << 'mrbc'
+end

data/ext/enclave/mruby/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c

@@ -0,0 +1,362 @@
+#include <mruby.h>
+
+#ifdef MRB_NO_STDIO
+# error mruby-bin-mrbc conflicts 'MRB_NO_STDIO' in your build configuration
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <mruby/compile.h>
+#include <mruby/dump.h>
+#include <mruby/proc.h>
+#include <mruby/internal.h>
+
+#define RITEBIN_EXT ".mrb"
+#define C_EXT       ".c"
+
+struct mrbc_args {
+  const char *prog;
+  const char *outfile;
+  const char *initname;
+  char **argv;
+  int argc;
+  int idx;
+  mrb_bool dump_struct  : 1;
+  mrb_bool check_syntax : 1;
+  mrb_bool verbose      : 1;
+  mrb_bool no_ext_ops   : 1;
+  mrb_bool no_optimize  : 1;
+  uint8_t flags         : 3;
+};
+
+static void
+usage(const char *name)
+{
+  static const char *const usage_msg[] = {
+  "switches:",
+  "-c           check syntax only",
+  "-o<outfile>  place the output into <outfile>; required for multi-files",
+  "-v           print version number, then turn on verbose mode",
+  "-g           produce debugging information",
+  "-B<symbol>   binary <symbol> output in C language format",
+  "-S           dump C struct (requires -B)",
+  "-s           define <symbol> as static variable",
+  "--remove-lv  remove local variables",
+  "--no-ext-ops prohibit using OP_EXTs",
+  "--no-optimize disable peephole optimization",
+  "--verbose    run at verbose mode",
+  "--version    print the version",
+  "--copyright  print the copyright",
+  NULL
+  };
+  const char *const *p = usage_msg;
+
+  printf("Usage: %s [switches] programfile...\n", name);
+  while (*p)
+    printf("  %s\n", *p++);
+}
+
+static char *
+get_outfilename(mrb_state *mrb, char *infile, const char *ext)
+{
+  size_t ilen, flen, elen;
+  char *outfile;
+  char *p = NULL;
+
+  ilen = strlen(infile);
+  flen = ilen;
+  if (*ext) {
+    elen = strlen(ext);
+    if ((p = strrchr(infile, '.'))) {
+      ilen = p - infile;
+    }
+    flen += elen;
+  }
+  else {
+    flen = ilen;
+  }
+  outfile = (char*)mrb_malloc(mrb, flen+1);
+  strncpy(outfile, infile, ilen+1);
+  if (p) {
+    strncpy(outfile+ilen, ext, elen+1);
+  }
+
+  return outfile;
+}
+
+static int
+parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
+{
+  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] == '-') {
+      switch ((argv[i])[1]) {
+      case 'o':
+        if (args->outfile) {
+          fprintf(stderr, "%s: an output file is already specified. (%s)\n",
+                  args->prog, args->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 'S':
+        args->dump_struct = TRUE;
+        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 |= MRB_DUMP_DEBUG_INFO;
+        break;
+      case 's':
+        args->flags |= MRB_DUMP_STATIC;
+        break;
+      case 'E':
+      case 'e':
+        fprintf(stderr, "%s: -e/-E option no longer needed.\n", args->prog);
+        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);
+        }
+        else if (strcmp(argv[i] + 2, "remove-lv") == 0) {
+          args->flags |= MRB_DUMP_NO_LVAR;
+          break;
+        }
+        else if (strcmp(argv[i] + 2, "no-ext-ops") == 0) {
+          args->no_ext_ops = TRUE;
+          break;
+        }
+        else if (strcmp(argv[i] + 2, "no-optimize") == 0) {
+          args->no_optimize = TRUE;
+          break;
+        }
+        return -1;
+      default:
+        return i;
+      }
+    }
+    else {
+      break;
+    }
+  }
+  return i;
+}
+
+static void
+cleanup(mrb_state *mrb, struct mrbc_args *args)
+{
+  mrb_free(mrb, (void*)args->outfile);
+  mrb_close(mrb);
+}
+
+static int
+partial_hook(struct mrb_parser_state *p)
+{
+  mrb_ccontext *c = p->cxt;
+  struct mrbc_args *args = (struct mrbc_args*)c->partial_data;
+
+  if (p->f) fclose(p->f);
+  if (args->idx >= args->argc) {
+    p->f = NULL;
+    return -1;
+  }
+  const char *fn = args->argv[args->idx++];
+  p->f = fopen(fn, "rb");
+  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)
+{
+  char *input = args->argv[args->idx];
+  FILE *infile;
+  mrb_bool need_close = FALSE;
+
+  mrb_ccontext *c = mrb_ccontext_new(mrb);
+  if (args->verbose)
+    c->dump_result = TRUE;
+  c->no_exec = TRUE;
+  c->no_ext_ops = args->no_ext_ops;
+  c->no_optimize = args->no_optimize;
+  if (input[0] == '-' && input[1] == '\0') {
+    infile = stdin;
+  }
+  else {
+    need_close = TRUE;
+    if ((infile = fopen(input, "rb")) == NULL) {
+      fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
+      return mrb_nil_value();
+    }
+  }
+  mrb_ccontext_filename(mrb, c, input);
+  args->idx++;
+  if (args->idx < args->argc) {
+    need_close = FALSE;
+    mrb_ccontext_partial_hook(c, partial_hook, (void*)args);
+  }
+
+  mrb_value result = mrb_load_file_cxt(mrb, infile, c);
+  if (need_close) fclose(infile);
+  mrb_ccontext_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, const struct RProc *proc, struct mrbc_args *args)
+{
+  int n = MRB_DUMP_OK;
+  const mrb_irep *irep = proc->body.irep;
+
+  if (args->initname) {
+    if (args->dump_struct) {
+      n = mrb_dump_irep_cstruct(mrb, irep, args->flags, wfp, args->initname);
+    }
+    else {
+      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;
+}
+
+int
+main(int argc, char **argv)
+{
+  mrb_state *mrb = mrb_open_core();
+  struct mrbc_args args;
+  FILE *wfp;
+
+  if (mrb == NULL) {
+    fputs("Invalid mrb_state, exiting mrbc\n", stderr);
+    return EXIT_FAILURE;
+  }
+
+  int n = parse_args(mrb, argc, argv, &args);
+  if (n < 0) {
+    cleanup(mrb, &args);
+    usage(argv[0]);
+    return EXIT_FAILURE;
+  }
+  if (n == argc) {
+    fprintf(stderr, "%s: no program file given\n", args.prog);
+    return 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 EXIT_FAILURE;
+    }
+  }
+
+  args.idx = n;
+  mrb_value load = load_file(mrb, &args);
+  if (mrb_nil_p(load)) {
+    cleanup(mrb, &args);
+    return EXIT_FAILURE;
+  }
+  if (args.check_syntax) {
+    printf("%s:%s:Syntax OK\n", args.prog, argv[n]);
+  }
+
+  if (args.check_syntax) {
+    cleanup(mrb, &args);
+    return 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 EXIT_FAILURE;
+    }
+  }
+  else {
+    fputs("Output file is required\n", stderr);
+    return EXIT_FAILURE;
+  }
+  int result = dump_file(mrb, wfp, args.outfile, mrb_proc_ptr(load), &args);
+  fclose(wfp);
+  cleanup(mrb, &args);
+  if (result != MRB_DUMP_OK) {
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
+}
+
+void
+mrb_init_mrblib(mrb_state *mrb)
+{
+}
+
+#ifndef MRB_NO_GEMS
+void
+mrb_init_mrbgems(mrb_state *mrb)
+{
+}
+#endif

data/ext/enclave/mruby/mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c

@@ -0,0 +1,104 @@
+#include <mruby.h>
+
+/*
+  functions defined in mrbgems referenced from the core should be listed here
+  to avoid link errors, since mrbc does not link any mrbgem ignoring configuration.
+*/
+
+#ifdef MRB_USE_COMPLEX
+mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value x)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value x)
+{
+  return mrb_nil_value();
+}
+void mrb_complex_copy(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+}
+#endif
+
+#ifdef MRB_USE_RATIONAL
+mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value x)
+{
+  return mrb_nil_value();
+}
+mrb_value mrb_rational_to_f(mrb_state *mrb, mrb_value x)
+{
+  return mrb_nil_value();
+}
+mrb_value
+mrb_as_rational(mrb_state *mrb, mrb_value x)
+{
+  return mrb_nil_value();
+}
+void mrb_rational_copy(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+}
+int mrb_rational_mark(mrb_state *mrb, struct RBasic *x)
+{
+  return 2;
+}
+#endif
+
+#ifdef MRB_USE_SET
+size_t mrb_gc_mark_set(mrb_state *mrb, struct RBasic *obj)
+{
+  /* stub for mrbc */
+  return 0;
+}
+
+void mrb_gc_free_set(mrb_state *mrb, struct RBasic *obj)
+{
+  /* stub for mrbc */
+}
+#endif
+
+#ifdef MRB_USE_TASK_SCHEDULER
+void mrb_task_mark_all(mrb_state *mrb)
+{
+  /* stub for mrbc */
+  (void)mrb;
+}
+#endif

data/ext/enclave/mruby/mrbgems/mruby-bin-mruby/README.md

@@ -0,0 +1,47 @@
+# mruby-bin-mruby
+
+mruby is the main interpreter for executing Ruby scripts with mruby.
+
+## Usage
+
+```
+mruby [switches] [programfile] [arguments]
+```
+
+### Options
+
+- `-b` - load and execute RiteBinary (mrb) file
+- `-c` - check syntax only
+- `-d` - set debugging flags (set `$DEBUG` to true)
+- `-e 'command'` - one line of script
+- `-r library` - load the library before executing your script
+- `-v` - print version number, then run in verbose mode
+- `--verbose` - run in verbose mode
+- `--version` - print the version
+- `--copyright` - print the copyright
+
+## Examples
+
+```bash
+# Execute a Ruby script
+mruby script.rb
+
+# Execute inline code
+mruby -e 'puts "Hello, mruby!"'
+
+# Check syntax without executing
+mruby -c script.rb
+
+# Execute a compiled binary
+mruby -b script.mrb
+
+# Load a library before running script
+mruby -r mruby-io script.rb
+
+# Pass arguments to script
+mruby script.rb arg1 arg2
+```
+
+## License
+
+MIT License - see the mruby LICENSE file.

data/ext/enclave/mruby/mrbgems/mruby-bin-mruby/bintest/mruby.rb

@@ -0,0 +1,178 @@
+require 'tempfile'
+require 'open3'
+
+def assert_mruby(exp_out, exp_err, exp_success, args)
+  out, err, stat = Open3.capture3( *(cmd_list("mruby") + args))
+  assert "assert_mruby" do
+    assert_operator(exp_out, :===, out, "standard output")
+    assert_operator(exp_err, :===, err, "standard error")
+    assert_equal(exp_success, stat.success?, "exit success?")
+  end
+end
+
+assert('regression for #1564') do
+  assert_mruby("", /\A-e:1:2: syntax error, .*\n\z/, false, %w[-e <<])
+  assert_mruby("", /\A-e:1:3: syntax error, .*\n\z/, false, %w[-e <<-])
+end
+
+assert('regression for #1572') do
+  script, bin = Tempfile.new('test.rb'), Tempfile.new('test.mrb')
+  File.write script.path, 'p "ok"'
+  system "#{cmd('mrbc')} -g -o #{bin.path} #{script.path}"
+  o = `#{cmd('mruby')} #{bin.path}`.strip
+  assert_equal '"ok"', o
+end
+
+assert '$0 value' do
+  script, bin = Tempfile.new('test.rb'), Tempfile.new('test.mrb')
+
+  # .rb script
+  script.write "p $0\n"
+  script.flush
+  assert_equal "\"#{script.path}\"", `#{cmd('mruby')} "#{script.path}"`.chomp
+
+  # .mrb file
+  `#{cmd('mrbc')} -o "#{bin.path}" "#{script.path}"`
+  assert_equal "\"#{bin.path}\"", `#{cmd('mruby')} "#{bin.path}"`.chomp
+
+  # one liner
+  assert_equal '"-e"', `#{cmd('mruby')} -e #{shellquote('p $0')}`.chomp
+end
+
+assert 'ARGV value' do
+  assert_mruby(%{["ab", "cde"]\n}, "", true, %w[-e p(ARGV) ab cde])
+  assert_mruby("[]\n", "", true, %w[-e p(ARGV)])
+end
+
+assert '__END__', '8.6' do
+  script = Tempfile.new('test.rb')
+
+  script.write <<EOS
+p 'test'
+  __END__ = 'fin'
+p __END__
+__END__
+p 'legend'
+EOS
+  script.flush
+  assert_equal "\"test\"\n\"fin\"\n", `#{cmd('mruby')} #{script.path}`
+end
+
+assert('garbage collecting built-in classes') do
+  script = Tempfile.new('test.rb')
+
+  script.write <<RUBY
+NilClass = nil
+GC.start
+Array.dup
+print nil.class.to_s
+RUBY
+  script.flush
+  assert_equal "NilClass", `#{cmd('mruby')} #{script.path}`
+  assert_equal 0, $?.exitstatus
+end
+
+assert('mruby -c option') do
+  assert_mruby("Syntax OK\n", "", true, ["-c", "-e", "p 1"])
+  assert_mruby("", /\A-e:1:7: syntax error, .*\n\z/, false, ["-c", "-e", "p 1; 1."])
+end
+
+assert('mruby -d option') do
+  assert_mruby("false\n", "", true, ["-e", "p $DEBUG"])
+  assert_mruby("true\n", "", true, ["-dep $DEBUG"])
+end
+
+assert('mruby -e option (no code specified)') do
+  assert_mruby("", /\A.*: No code specified for -e\n\z/, false, %w[-e])
+end
+
+assert('mruby -h option') do
+  assert_mruby(/\AUsage: #{Regexp.escape cmd_bin("mruby")} .*/m, "", true, %w[-h])
+end
+
+assert('mruby -r option') do
+  lib = Tempfile.new('lib.rb')
+  lib.write <<EOS
+class Hoge
+  def hoge
+    :hoge
+  end
+end
+EOS
+  lib.flush
+
+  script = Tempfile.new('test.rb')
+  script.write <<EOS
+print Hoge.new.hoge
+EOS
+  script.flush
+  assert_equal 'hoge', `#{cmd('mruby')} -r #{lib.path} #{script.path}`
+  assert_equal 0, $?.exitstatus
+
+  assert_equal 'hogeClass', `#{cmd('mruby')} -r #{lib.path} -r #{script.path} -e #{shellquote('print Hoge.class')}`
+  assert_equal 0, $?.exitstatus
+end
+
+assert('mruby -r option (no library specified)') do
+  assert_mruby("", /\A.*: No library specified for -r\n\z/, false, %w[-r])
+end
+
+assert('mruby -r option (file not found)') do
+  assert_mruby("", /\A.*: Cannot open library file: .*\n\z/, false, %w[-r _no_exists_])
+end
+
+assert('mruby -v option') do
+  ver_re = '\Amruby \d+\.\d+\.\d+.* \(\d+-\d+-\d+\)\n'
+  assert_mruby(/#{ver_re}\z/, "", true, %w[-v])
+  assert_mruby(/#{ver_re}^[^\n]*NODE.*\n:end\n\z/m, "", true, %w[-v -e p(:end)])
+end
+
+assert('mruby --verbose option') do
+  assert_mruby(/\A[^\n]*NODE.*\n:end\n\z/m, "", true, %w[--verbose -e p(:end)])
+end
+
+assert('mruby --') do
+  assert_mruby(%{["-x", "1"]\n}, "", true, %w[-e p(ARGV) -- -x 1])
+end
+
+assert('mruby invalid short option') do
+  assert_mruby("", /\A.*: invalid option -1 .*\n\z/, false, %w[-1])
+end
+
+assert('mruby invalid long option') do
+  assert_mruby("", /\A.*: invalid option --longopt .*\n\z/, false, %w[--longopt])
+end
+
+assert('unhandled exception') do
+  assert_mruby("", /\bEXCEPTION\b.*\n\z/, false, %w[-e raise("EXCEPTION")])
+end
+
+assert('program file not found') do
+  assert_mruby("", /\A.*: Cannot open program file: .*\n\z/, false, %w[_no_exists_])
+end
+
+assert('codegen error') do
+  code = "def f(#{(1..100).map{|n| "a#{n}"} * ","}); end"
+  assert_mruby("", /\A.*\n\z/, false, ["-e", code])
+end
+
+assert('top level local variables are in file scope') do
+  arb, amrb = Tempfile.new('a.rb'), Tempfile.new('a.mrb')
+  brb, bmrb = Tempfile.new('b.rb'), Tempfile.new('b.mrb')
+  crb, cmrb = Tempfile.new('c.rb'), Tempfile.new('c.mrb')
+  drb, dmrb = Tempfile.new('d.rb'), Tempfile.new('d.mrb')
+
+  File.write arb.path, 'a = 1'
+  system "#{cmd('mrbc')} -g -o #{amrb.path} #{arb.path}"
+  File.write brb.path, 'p a'
+  system "#{cmd('mrbc')} -g -o #{bmrb.path} #{brb.path}"
+  assert_mruby("", /:1: undefined method 'a' .*\(NoMethodError\)\n\z/, false, ["-r", arb.path, brb.path])
+  assert_mruby("", /:1: undefined method 'a' .*\(NoMethodError\)\n\z/, false, ["-b", "-r", amrb.path, bmrb.path])
+
+  File.write crb.path, 'a, b, c = 1, 2, 3; A = -> { b = -2; [a, b, c] }'
+  system "#{cmd('mrbc')} -g -o #{cmrb.path} #{crb.path}"
+  File.write drb.path, 'a, b = 5, 6; p A.call; p a, b'
+  system "#{cmd('mrbc')} -g -o #{dmrb.path} #{drb.path}"
+  assert_mruby("[1, -2, 3]\n5\n6\n", "", true, ["-r", crb.path, drb.path])
+  assert_mruby("[1, -2, 3]\n5\n6\n", "", true, ["-b", "-r", cmrb.path, dmrb.path])
+end

data/ext/enclave/mruby/mrbgems/mruby-bin-mruby/mrbgem.rake

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-bin-mruby') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'mruby command'
+  spec.bins = %w(mruby)
+  spec.add_dependency('mruby-compiler', :core => 'mruby-compiler')
+end