esruby 0.0.0

data/resources/mruby/mrbgems/mruby-math/test/math.rb

@@ -0,0 +1,152 @@
+##
+# Math Test
+
+##
+# Performs fuzzy check for equality on methods returning floats
+# on the basis of the Math::TOLERANCE constant.
+def check_float(a, b)
+  tolerance = Math::TOLERANCE
+  a = a.to_f
+  b = b.to_f
+  if a.finite? and b.finite?
+    (a-b).abs < tolerance
+  else
+    true
+  end
+end
+
+assert('Math.sin 0') do
+  check_float(Math.sin(0), 0)
+end
+
+assert('Math.sin PI/2') do
+  check_float(Math.sin(Math::PI / 2), 1)
+end
+
+assert('Math.cos 0') do
+  check_float(Math.cos(0), 1)
+end
+
+assert('Math.cos PI/2') do
+  check_float(Math.cos(Math::PI / 2), 0)
+end
+
+assert('Math.tan 0') do
+  check_float(Math.tan(0), 0)
+end
+
+assert('Math.tan PI/4') do
+  check_float(Math.tan(Math::PI / 4), 1)
+end
+
+assert('Fundamental trig identities') do
+  result = true
+  N = 13
+  N.times do |i|
+    a  = Math::PI / N * i
+    ca = Math::PI / 2 - a
+    s  = Math.sin(a)
+    c  = Math.cos(a)
+    t  = Math.tan(a)
+    result &= check_float(s, Math.cos(ca))
+    result &= check_float(t, 1 / Math.tan(ca))
+    result &= check_float(s ** 2 + c ** 2, 1)
+    result &= check_float(t ** 2 + 1, (1/c) ** 2)
+    result &= check_float((1/t) ** 2 + 1, (1/s) ** 2)
+  end
+  result
+end
+
+assert('Math.erf 0') do
+  check_float(Math.erf(0), 0)
+end
+
+assert('Math.exp 0') do
+  check_float(Math.exp(0), 1.0)
+end
+
+assert('Math.exp 1') do
+  check_float(Math.exp(1), 2.718281828459045)
+end
+
+assert('Math.exp 1.5') do
+  check_float(Math.exp(1.5), 4.4816890703380645)
+end
+
+assert('Math.log 1') do
+  check_float(Math.log(1), 0)
+end
+
+assert('Math.log E') do
+  check_float(Math.log(Math::E), 1.0)
+end
+
+assert('Math.log E**3') do
+  check_float(Math.log(Math::E**3), 3.0)
+end
+
+assert('Math.log2 1') do
+  check_float(Math.log2(1), 0.0)
+end
+
+assert('Math.log2 2') do
+  check_float(Math.log2(2), 1.0)
+end
+
+assert('Math.log10 1') do
+  check_float(Math.log10(1), 0.0)
+end
+
+assert('Math.log10 10') do
+  check_float(Math.log10(10), 1.0)
+end
+
+assert('Math.log10 10**100') do
+  check_float(Math.log10(10**100), 100.0)
+end
+
+assert('Math.sqrt') do
+  num = [0.0, 1.0, 2.0, 3.0, 4.0]
+  sqr = [0, 1, 4, 9, 16]
+  result = true
+  sqr.each_with_index do |v,i|
+    result &= check_float(Math.sqrt(v), num[i])
+  end
+  result
+end
+
+assert('Math.cbrt') do
+  num = [-2.0, -1.0, 0.0, 1.0, 2.0]
+  cub = [-8, -1, 0, 1, 8]
+  result = true
+  cub.each_with_index do |v,i|
+    result &= check_float(Math.cbrt(v), num[i])
+  end
+  result
+end
+
+assert('Math.hypot') do
+  check_float(Math.hypot(3, 4), 5.0)
+end
+
+assert('Math.frexp 1234') do
+  n = 1234
+  fraction, exponent = Math.frexp(n)
+  check_float(Math.ldexp(fraction, exponent), n)
+end
+
+assert('Math.erf 1') do
+  check_float(Math.erf(1), 0.842700792949715)
+end
+
+assert('Math.erfc 1') do
+  check_float(Math.erfc(1), 0.157299207050285)
+end
+
+assert('Math.erf -1') do
+  check_float(Math.erf(-1), -0.8427007929497148)
+end
+
+assert('Math.erfc -1') do
+  check_float(Math.erfc(-1), 1.8427007929497148)
+end

data/resources/mruby/mrbgems/mruby-method/README.md

@@ -0,0 +1,59 @@
+mruby-method
+===
+
+A implementetion of class **Method** and **UnboundMethod** for mruby
+
+```ruby
+p Enumerable.instance_method(:find_all).source_location
+#=> ["mruby/mruby/mrblib/enum.rb", 148]
+```
+
+# Note
+
+`source_location` method need this configuration in build_config.rb
+
+```ruby
+MRuby::Build.new do |conf|
+  enable_debug
+end
+```
+
+# Supported Methods
+
+## Kernel
+
+- `Kernel#method`
+- `Kernel#singleton_method`
+
+## Module
+
+- `Module#instance_method`
+
+## Method class
+
+- `Method#name`
+- `Method#call`
+- `Method#super_method`
+- `Method#arity`
+- `Method#unbind`
+- `Method#[]`
+- `Method#owner`
+- `Method#receiver`
+- `Method#parameters`
+- `Method#source_location`
+- `Method#to_proc`
+
+## UnboundMethod class
+
+- `UnboundMethod#name`
+- `UnboundMethod#bind`
+- `UnboundMethod#super_method`
+- `UnboundMethod#arity`
+- `UnboundMethod#owner`
+- `UnboundMethod#parameters`
+- `UnboundMethod#source_location`
+
+# See also
+
+- https://ruby-doc.org/core-2.3.3/Method.html
+- https://ruby-doc.org/core-2.3.3/UnboundMethod.html

data/resources/mruby/mrbgems/mruby-method/mrbgem.rake

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-method') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Method and UnboundMethod class'
+
+  spec.add_dependency('mruby-proc-ext', :core => 'mruby-proc-ext')
+end

data/resources/mruby/mrbgems/mruby-method/mrblib/kernel.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def singleton_method(name)
+    m = method(name)
+    if m.owner != singleton_class
+      raise NameError, "undefined method `#{name}' for class `#{singleton_class}'"
+    end
+    m
+  end
+end

data/resources/mruby/mrbgems/mruby-method/mrblib/method.rb

@@ -0,0 +1,20 @@
+class Method
+  def to_proc
+    m = self
+    lambda { |*args, &b|
+      m.call(*args, &b)
+    }
+  end
+
+  def owner
+    @owner
+  end
+
+  def receiver
+    @recv
+  end
+
+  def name
+    @name
+  end
+end

data/resources/mruby/mrbgems/mruby-method/mrblib/unbound_method.rb

@@ -0,0 +1,9 @@
+class UnboundMethod
+  def owner
+    @owner
+  end
+
+  def name
+    @name
+  end
+end

data/resources/mruby/mrbgems/mruby-method/src/method.c

@@ -0,0 +1,418 @@
+#include "mruby.h"
+#include "mruby/array.h"
+#include "mruby/class.h"
+#include "mruby/variable.h"
+#include "mruby/proc.h"
+#include "mruby/string.h"
+
+static struct RObject *
+method_object_alloc(mrb_state *mrb, struct RClass *mclass)
+{
+  return (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mclass);
+}
+
+static mrb_value
+unbound_method_bind(mrb_state *mrb, mrb_value self)
+{
+  struct RObject *me;
+  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"));
+  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass"));
+  mrb_value recv;
+
+  mrb_get_args(mrb, "o", &recv);
+
+  if (mrb_type(owner) != MRB_TT_MODULE &&
+      mrb_class_ptr(owner) != mrb_obj_class(mrb, recv) &&
+      !mrb_obj_is_kind_of(mrb, recv, mrb_class_ptr(owner))) {
+        if (mrb_type(owner) == MRB_TT_SCLASS) {
+          mrb_raise(mrb, E_TYPE_ERROR, "singleton method called for a different object");
+        } else {
+          const char *s = mrb_class_name(mrb, mrb_class_ptr(owner));
+          mrb_raisef(mrb, E_TYPE_ERROR, "bind argument must be an instance of %S", mrb_str_new_static(mrb, s, strlen(s)));
+        }
+  }
+  me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@owner"), owner);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@recv"), recv);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@name"), name);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "proc"), proc);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@klass"), klass);
+
+  return mrb_obj_value(me);
+}
+
+#define IV_GET(value, name) mrb_iv_get(mrb, value, mrb_intern_lit(mrb, name))
+static mrb_value
+method_eql(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other, receiver, orig_proc, other_proc;
+  struct RClass *owner, *klass;
+  struct RProc *orig_rproc, *other_rproc;
+
+  mrb_get_args(mrb, "o", &other);
+  if (!mrb_obj_is_instance_of(mrb, other, mrb_class(mrb, self)))
+    return mrb_false_value();
+
+  if (mrb_class(mrb, self) != mrb_class(mrb, other))
+    return mrb_false_value();
+
+  klass = mrb_class_ptr(IV_GET(self, "@klass"));
+  if (klass != mrb_class_ptr(IV_GET(other, "@klass")))
+    return mrb_false_value();
+
+  owner = mrb_class_ptr(IV_GET(self, "@owner"));
+  if (owner != mrb_class_ptr(IV_GET(other, "@owner")))
+    return mrb_false_value();
+
+  receiver = IV_GET(self, "@recv");
+  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "@recv")))
+    return mrb_false_value();
+
+  orig_proc = IV_GET(self, "proc");
+  other_proc = IV_GET(other, "proc");
+  if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) {
+    if (mrb_symbol(IV_GET(self, "@name")) == mrb_symbol(IV_GET(other, "@name")))
+      return mrb_true_value();
+    else
+      return mrb_false_value();
+  }
+
+  if (mrb_nil_p(orig_proc))
+    return mrb_false_value();
+  if (mrb_nil_p(other_proc))
+    return mrb_false_value();
+
+  orig_rproc = mrb_proc_ptr(orig_proc);
+  other_rproc = mrb_proc_ptr(other_proc);
+  if (MRB_PROC_CFUNC_P(orig_rproc)) {
+    if (!MRB_PROC_CFUNC_P(other_rproc))
+      return mrb_false_value();
+    if (orig_rproc->body.func != other_rproc->body.func)
+      return mrb_false_value();
+  }
+  else {
+    if (MRB_PROC_CFUNC_P(other_rproc))
+      return mrb_false_value();
+    if (orig_rproc->body.irep != other_rproc->body.irep)
+      return mrb_false_value();
+  }
+
+  return mrb_true_value();
+}
+
+#undef IV_GET
+
+static mrb_value
+method_call(mrb_state *mrb, mrb_value self)
+{
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
+  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@recv"));
+  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner")));
+  mrb_int argc;
+  mrb_value *argv, ret, block;
+  mrb_sym orig_mid;
+
+  mrb_get_args(mrb, "*&", &argv, &argc, &block);
+  orig_mid = mrb->c->ci->mid;
+  mrb->c->ci->mid = mrb_symbol(name);
+  if (mrb_nil_p(proc)) {
+    mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
+    mrb_ary_unshift(mrb, missing_argv, name);
+    ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv));
+  }
+  else if (!mrb_nil_p(block)) {
+    /*
+      workaround since `mrb_yield_with_class` does not support passing block as parameter
+      need new API that initializes `mrb->c->stack[argc+1]` with block passed by argument
+    */
+    ret = mrb_funcall_with_block(mrb, recv, mrb_symbol(name), argc, argv, block);
+  }
+  else {
+    ret = mrb_yield_with_class(mrb, proc, argc, argv, recv, owner);
+  }
+  mrb->c->ci->mid = orig_mid;
+  return ret;
+}
+
+static mrb_value
+method_unbind(mrb_state *mrb, mrb_value self)
+{
+  struct RObject *ume;
+  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"));
+  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass"));
+
+  ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@owner"), owner);
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@recv"), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@name"), name);
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "proc"), proc);
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@klass"), klass);
+
+  return mrb_obj_value(ume);
+}
+
+static struct RProc *
+method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
+{
+  mrb_method_t m = mrb_method_search_vm(mrb, cp, mid);
+  if (MRB_METHOD_UNDEF_P(m))
+    return NULL;
+  if (MRB_METHOD_PROC_P(m))
+    return MRB_METHOD_PROC(m);
+  return mrb_proc_new_cfunc(mrb, MRB_METHOD_FUNC(m));
+}
+
+static mrb_value
+method_super_method(mrb_state *mrb, mrb_value self)
+{
+  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@recv"));
+  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass"));
+  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"));
+  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
+  struct RClass *super, *rklass;
+  struct RProc *proc;
+  struct RObject *me;
+
+  switch (mrb_type(klass)) {
+    case MRB_TT_SCLASS:
+      super = mrb_class_ptr(klass)->super->super;
+      break;
+    case MRB_TT_ICLASS:
+      super = mrb_class_ptr(klass)->super;
+      break;
+    default:
+      super = mrb_class_ptr(owner)->super;
+      break;
+  }
+
+  proc = method_search_vm(mrb, &super, mrb_symbol(name));
+  if (!proc)
+    return mrb_nil_value();
+
+  rklass = super;
+  while (super->tt == MRB_TT_ICLASS)
+    super = super->c;
+
+  me = method_object_alloc(mrb, mrb_obj_class(mrb, self));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@owner"), mrb_obj_value(super));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@recv"), recv);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@name"), name);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "proc"), mrb_obj_value(proc));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@klass"), mrb_obj_value(rklass));
+
+  return mrb_obj_value(me);
+}
+
+static mrb_value
+method_arity(mrb_state *mrb, mrb_value self)
+{
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  struct RProc *rproc;
+  struct RClass *orig;
+  mrb_value ret;
+
+  if (mrb_nil_p(proc))
+    return mrb_fixnum_value(-1);
+
+  rproc = mrb_proc_ptr(proc);
+  orig = rproc->c;
+  rproc->c = mrb->proc_class;
+  ret = mrb_funcall(mrb, proc, "arity", 0);
+  rproc->c = orig;
+  return ret;
+}
+
+static mrb_value
+method_source_location(mrb_state *mrb, mrb_value self)
+{
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  struct RProc *rproc;
+  struct RClass *orig;
+  mrb_value ret;
+
+  if (mrb_nil_p(proc))
+    return mrb_nil_value();
+
+  rproc = mrb_proc_ptr(proc);
+  orig = rproc->c;
+  rproc->c = mrb->proc_class;
+  ret = mrb_funcall(mrb, proc, "source_location", 0);
+  rproc->c = orig;
+  return ret;
+}
+
+static mrb_value
+method_parameters(mrb_state *mrb, mrb_value self)
+{
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
+  struct RProc *rproc;
+  struct RClass *orig;
+  mrb_value ret;
+
+  if (mrb_nil_p(proc)) {
+    mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest"));
+    mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest);
+    return mrb_ary_new_from_values(mrb, 1, &arest);
+  }
+
+  rproc = mrb_proc_ptr(proc);
+  orig = rproc->c;
+  rproc->c = mrb->proc_class;
+  ret = mrb_funcall(mrb, proc, "parameters", 0);
+  rproc->c = orig;
+  return ret;
+}
+
+static mrb_value
+method_to_s(mrb_state *mrb, mrb_value self)
+{
+  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"));
+  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass"));
+  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
+  mrb_value str = mrb_str_new_lit(mrb, "#<");
+  struct RClass *rklass;
+
+  mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, self));
+  mrb_str_cat_lit(mrb, str, ": ");
+  rklass = mrb_class_ptr(klass);
+  if (mrb_class_ptr(owner) == rklass) {
+    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
+    mrb_str_cat_lit(mrb, str, "#");
+    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
+  }
+  else {
+    mrb_str_cat_cstr(mrb, str, mrb_class_name(mrb, rklass));
+    mrb_str_cat_lit(mrb, str, "(");
+    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
+    mrb_str_cat_lit(mrb, str, ")#");
+    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
+  }
+  mrb_str_cat_lit(mrb, str, ">");
+  return str;
+}
+
+static void
+mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym name, struct RClass **owner, struct RProc **proc, mrb_bool unbound)
+{
+  mrb_value ret;
+  const char *s;
+
+  *owner = c;
+  *proc = method_search_vm(mrb, owner, name);
+  if (!*proc) {
+    if (unbound) {
+      goto name_error;
+    }
+    if (!mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "respond_to_missing?"))) {
+      goto name_error;
+    }
+    ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value());
+    if (!mrb_test(ret)) {
+      goto name_error;
+    }
+    *owner = c;
+  }
+
+  while ((*owner)->tt == MRB_TT_ICLASS)
+    *owner = (*owner)->c;
+
+  return;
+
+name_error:
+  s = mrb_class_name(mrb, c);
+  mrb_raisef(
+    mrb, E_NAME_ERROR,
+    "undefined method `%S' for class `%S'",
+    mrb_sym2str(mrb, name),
+    mrb_str_new_static(mrb, s, strlen(s))
+  );
+}
+
+static mrb_value
+mrb_kernel_method(mrb_state *mrb, mrb_value self)
+{
+  struct RClass *owner;
+  struct RProc *proc;
+  struct RObject *me;
+  mrb_sym name;
+
+  mrb_get_args(mrb, "n", &name);
+
+  mrb_search_method_owner(mrb, mrb_class(mrb, self), self, name, &owner, &proc, FALSE);
+
+  me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@owner"), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@recv"), self);
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@name"), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@klass"), mrb_obj_value(mrb_class(mrb, self)));
+
+  return mrb_obj_value(me);
+}
+
+static mrb_value
+mrb_module_instance_method(mrb_state *mrb, mrb_value self)
+{
+  struct RClass *owner;
+  struct RProc *proc;
+  struct RObject *ume;
+  mrb_sym name;
+
+  mrb_get_args(mrb, "n", &name);
+
+  mrb_search_method_owner(mrb, mrb_class_ptr(self), self, name, &owner, &proc, TRUE);
+
+  ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@owner"), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@recv"), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@name"), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@klass"), self);
+
+  return mrb_obj_value(ume);
+}
+
+void
+mrb_mruby_method_gem_init(mrb_state* mrb)
+{
+  struct RClass *unbound_method = mrb_define_class(mrb, "UnboundMethod", mrb->object_class);
+  struct RClass *method = mrb_define_class(mrb, "Method", mrb->object_class);
+
+  mrb_undef_class_method(mrb, unbound_method, "new");
+  mrb_define_method(mrb, unbound_method, "bind", unbound_method_bind, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, unbound_method, "super_method", method_super_method, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "==", method_eql, MRB_ARGS_REQ(1));
+  mrb_alias_method(mrb, unbound_method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "=="));
+  mrb_define_method(mrb, unbound_method, "to_s", method_to_s, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "inspect", method_to_s, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "arity", method_arity, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "source_location", method_source_location, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "parameters", method_parameters, MRB_ARGS_NONE());
+
+  mrb_undef_class_method(mrb, method, "new");
+  mrb_define_method(mrb, method, "==", method_eql, MRB_ARGS_REQ(1));
+  mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "=="));
+  mrb_define_method(mrb, method, "to_s", method_to_s, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "inspect", method_to_s, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "call", method_call, MRB_ARGS_ANY());
+  mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "[]"), mrb_intern_lit(mrb, "call"));
+  mrb_define_method(mrb, method, "unbind", method_unbind, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "super_method", method_super_method, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "arity", method_arity, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "source_location", method_source_location, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "parameters", method_parameters, MRB_ARGS_NONE());
+
+  mrb_define_method(mrb, mrb->kernel_module, "method", mrb_kernel_method, MRB_ARGS_REQ(1));
+
+  mrb_define_method(mrb, mrb->module_class, "instance_method", mrb_module_instance_method, MRB_ARGS_REQ(1));
+}
+
+void
+mrb_mruby_method_gem_final(mrb_state* mrb)
+{
+}