webruby 0.2.7 → 0.9.1

data/modules/mruby/mrbgems/mruby-math/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-math') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'standard Math module'
 end

data/modules/mruby/mrbgems/mruby-math/src/math.c

@@ -9,18 +9,90 @@
 
 #include <math.h>
 
-#define domain_error(msg) \
-    mrb_raise(mrb, E_RANGE_ERROR, "Numerical argument is out of domain - " #msg)
+static void
+domain_error(mrb_state *mrb, const char *func)
+{
+  struct RClass *math = mrb_module_get(mrb, "Math");
+  struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
+  mrb_value str = mrb_str_new_cstr(mrb, func);
+  mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %S", str);
+}
 
 /* math functions not provided by Microsoft Visual C++ 2012 or older */
 #if defined _MSC_VER && _MSC_VER < 1800
 
+#include <float.h>
+
 #define MATH_TOLERANCE 1E-12
 
-#define asinh(x) log(x + sqrt(pow(x,2.0) + 1))
-#define acosh(x) log(x + sqrt(pow(x,2.0) - 1))
-#define atanh(x) (log(1+x) - log(1-x))/2.0
-#define cbrt(x)  pow(x,1.0/3.0)
+double
+asinh(double x)
+{
+  double xa, ya, y;
+
+  /* Basic formula loses precision for x < 0, but asinh is an odd function */
+  xa = fabs(x);
+  if (xa > 3.16227E+18) {
+    /* Prevent x*x from overflowing; basic formula reduces to log(2*x) */
+    ya = log(xa) + 0.69314718055994530942;
+  }
+  else {
+    /* Basic formula for asinh */
+    ya = log(xa + sqrt(xa*xa + 1.0));
+  }
+
+  y = _copysign(ya, x);
+  return y;
+}
+
+double
+acosh(double x)
+{
+  double y;
+
+  if (x > 3.16227E+18) {
+    /* Prevent x*x from overflowing; basic formula reduces to log(2*x) */
+    y = log(x) + 0.69314718055994530942;
+  }
+  else {
+    /* Basic formula for acosh */
+    y = log(x + sqrt(x*x - 1.0));
+  }
+
+  return y;
+}
+
+double
+atanh(double x)
+{
+  double y;
+
+  if (fabs(x) < 1E-2) {
+    /* The sums 1+x and 1-x lose precision for small x.  Use the polynomial
+       instead. */
+    double x2 = x * x;
+    y = x*(1.0 + x2*(1.0/3.0 + x2*(1.0/5.0 + x2*(1.0/7.0))));
+  }
+  else {
+    /* Basic formula for atanh */
+    y = 0.5 * (log(1.0+x) - log(1.0-x));
+  }
+
+  return y;
+}
+
+double
+cbrt(double x)
+{
+  double xa, ya, y;
+
+  /* pow(x, y) is undefined for x < 0 and y not an integer, but cbrt is an
+     odd function */
+  xa = fabs(x);
+  ya = pow(xa, 1.0/3.0);
+  y = _copysign(ya, x);
+  return y;
+}
 
 /* Declaration of complementary Error function */
 double
@@ -172,6 +244,9 @@ math_asin(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < -1.0 || x > 1.0) {
+    domain_error(mrb, "asin");
+  }
   x = asin(x);
 
   return mrb_float_value(mrb, x);
@@ -189,6 +264,9 @@ math_acos(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < -1.0 || x > 1.0) {
+    domain_error(mrb, "acos");
+  }
   x = acos(x);
 
   return mrb_float_value(mrb, x);
@@ -334,6 +412,9 @@ math_acosh(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < 1.0) {
+    domain_error(mrb, "acosh");
+  }
   x = acosh(x);
 
   return mrb_float_value(mrb, x);
@@ -351,6 +432,9 @@ math_atanh(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < -1.0 || x > 1.0) {
+    domain_error(mrb, "atanh");
+  }
   x = atanh(x);
 
   return mrb_float_value(mrb, x);
@@ -359,14 +443,6 @@ math_atanh(mrb_state *mrb, mrb_value obj)
 /*
   EXPONENTIALS AND LOGARITHMS
 */
-#if defined __CYGWIN__
-# include <cygwin/version.h>
-# if CYGWIN_VERSION_DLL_MAJOR < 1005
-#  define nan(x) nan()
-# endif
-# define log(x) ((x) < 0.0 ? nan("") : log(x))
-# define log10(x) ((x) < 0.0 ? nan("") : log10(x))
-#endif
 
 /*
  *  call-seq:
@@ -412,8 +488,14 @@ math_log(mrb_state *mrb, mrb_value obj)
   int argc;
 
   argc = mrb_get_args(mrb, "f|f", &x, &base);
+  if (x < 0.0) {
+    domain_error(mrb, "log");
+  }
   x = log(x);
   if (argc == 2) {
+    if (base < 0.0) {
+      domain_error(mrb, "log");
+    }
     x /= log(base);
   }
   return mrb_float_value(mrb, x);
@@ -437,6 +519,9 @@ math_log2(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < 0.0) {
+    domain_error(mrb, "log2");
+  }
   x = log2(x);
 
   return mrb_float_value(mrb, x);
@@ -459,6 +544,9 @@ math_log10(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < 0.0) {
+    domain_error(mrb, "log10");
+  }
   x = log10(x);
 
   return mrb_float_value(mrb, x);
@@ -477,6 +565,9 @@ math_sqrt(mrb_state *mrb, mrb_value obj)
   mrb_float x;
 
   mrb_get_args(mrb, "f", &x);
+  if (x < 0.0) {
+    domain_error(mrb, "sqrt");
+  }
   x = sqrt(x);
 
   return mrb_float_value(mrb, x);
@@ -632,6 +723,8 @@ mrb_mruby_math_gem_init(mrb_state* mrb)
   struct RClass *mrb_math;
   mrb_math = mrb_define_module(mrb, "Math");
 
+  mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);
+
 #ifdef M_PI
   mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
 #else

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

@@ -23,6 +23,22 @@ 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

data/modules/mruby/mrbgems/mruby-numeric-ext/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-numeric-ext') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'extensional Numeric class'
 end

data/modules/mruby/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb

@@ -0,0 +1,5 @@
+module Integral
+  def div(other)
+    self.divmod(other)[0]
+  end
+end

data/modules/mruby/mrbgems/mruby-numeric-ext/test/numeric.rb

@@ -6,5 +6,13 @@ assert('Integer#chr') do
   assert_equal("B", 0x42.chr)
 
   # multibyte encoding (not support yet)
-  assert_raise(RangeError) { 12345.chr }
+  assert_raise(RangeError) { 256.chr }
+end
+
+assert('Integer#div') do
+  assert_equal 52, 365.div(7)
+end
+
+assert('Float#div') do
+  assert_float 52, 365.2425.div(7)
 end

data/modules/mruby/mrbgems/mruby-object-ext/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-object-ext') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'extensional Object class'
 end

data/modules/mruby/mrbgems/mruby-object-ext/mrblib/object.rb

@@ -0,0 +1,19 @@
+class Object
+  ##
+  #  call-seq:
+  #     obj.tap{|x|...}    -> obj
+  #
+  #  Yields <code>x</code> to the block, and then returns <code>x</code>.
+  #  The primary purpose of this method is to "tap into" a method chain,
+  #  in order to perform operations on intermediate results within the chain.
+  #
+  #  (1..10)                .tap {|x| puts "original: #{x.inspect}"}
+  #    .to_a                .tap {|x| puts "array: #{x.inspect}"}
+  #    .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
+  #    .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}
+  #
+  def tap
+    yield self
+    self
+  end
+end

data/modules/mruby/mrbgems/mruby-object-ext/src/object.c

@@ -12,7 +12,7 @@
 static mrb_value
 nil_to_a(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_ary_new(mrb);
+  return mrb_ary_new(mrb);
 }
 
 /*
@@ -25,7 +25,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj)
 static mrb_value
 nil_to_f(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_float_value(mrb, 0.0);
+  return mrb_float_value(mrb, 0.0);
 }
 
 /*
@@ -38,7 +38,7 @@ nil_to_f(mrb_state *mrb, mrb_value obj)
 static mrb_value
 nil_to_i(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_fixnum_value(0);
+  return mrb_fixnum_value(0);
 }
 
 /*
@@ -59,14 +59,11 @@ nil_to_i(mrb_state *mrb, mrb_value obj)
  *     k.instance_exec(5) {|x| @secret+x }   #=> 104
  */
 
-mrb_value
-mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
-
 static mrb_value
 mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
 {
   mrb_value *argv;
-  int argc;
+  mrb_int argc;
   mrb_value blk;
   struct RClass *c;
 
@@ -87,7 +84,7 @@ mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
     break;
   }
 
-  return mrb_yield_internal(mrb, blk, argc, argv, self, c);
+  return mrb_yield_with_class(mrb, blk, argc, argv, self, c);
 }
 
 void

data/modules/mruby/mrbgems/mruby-object-ext/test/object.rb

@@ -7,3 +7,19 @@ assert('Object#instance_exec') do
   k = KlassWithSecret.new
   assert_equal 104, k.instance_exec(5) {|x| @secret+x }
 end
+
+assert('Object#tap') do
+  ret = []
+  (1..10)                 .tap {|x| ret << "original: #{x.inspect}"}
+     .to_a                .tap {|x| ret << "array: #{x.inspect}"}
+     .select {|x| x%2==0} .tap {|x| ret << "evens: #{x.inspect}"}
+     .map { |x| x*x }     .tap {|x| ret << "squares: #{x.inspect}"}
+
+  assert_equal [
+    "original: 1..10",
+    "array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+    "evens: [2, 4, 6, 8, 10]",
+    "squares: [4, 16, 36, 64, 100]"
+  ], ret
+  assert_equal(:tap_ok, Class.new {def m; tap{return :tap_ok}; end}.new.m)
+end

data/modules/mruby/mrbgems/mruby-objectspace/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-objectspace') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'ObjectSpace class'
 end

data/modules/mruby/mrbgems/mruby-objectspace/src/mruby_objectspace.c

@@ -1,25 +1,27 @@
-#include <mruby.h>
-#include <mruby/gc.h>
-#include <mruby/hash.h>
-#include <mruby/value.h>
+#include "mruby.h"
+#include "mruby/gc.h"
+#include "mruby/hash.h"
+#include "mruby/class.h"
 
 struct os_count_struct {
-  size_t total;
-  size_t freed;
-  size_t counts[MRB_TT_MAXDEFINE+1];
+  mrb_int total;
+  mrb_int freed;
+  mrb_int counts[MRB_TT_MAXDEFINE+1];
 };
 
-void
-os_count_object_type(mrb_state *mrb, struct RBasic* obj, void *data)
+static void
+os_count_object_type(mrb_state *mrb, struct RBasic *obj, void *data)
 {
-  struct os_count_struct* obj_count;
-  obj_count = (struct os_count_struct*)(data);
+  struct os_count_struct *obj_count;
+  obj_count = (struct os_count_struct*)data;
+
+  obj_count->total++;
 
   if (is_dead(mrb, obj)) {
     obj_count->freed++;
-  } else {
+  }
+  else {
     obj_count->counts[obj->tt]++;
-    obj_count->total++;
   }
 }
 
@@ -33,8 +35,8 @@ os_count_object_type(mrb_state *mrb, struct RBasic* obj, void *data)
  *  {
  *    :TOTAL=>10000,
  *    :FREE=>3011,
- *    :MRB_TT_OBJECT=>6,
- *    :MRB_TT_CLASS=>404,
+ *    :T_OBJECT=>6,
+ *    :T_CLASS=>404,
  *    # ...
  *  }
  *
@@ -43,11 +45,11 @@ os_count_object_type(mrb_state *mrb, struct RBasic* obj, void *data)
  *
  */
 
-mrb_value
+static mrb_value
 os_count_objects(mrb_state *mrb, mrb_value self)
 {
-  struct os_count_struct obj_count;
-  size_t i;
+  struct os_count_struct obj_count = { 0 };
+  enum mrb_vtype i;
   mrb_value hash;
 
   if (mrb_get_args(mrb, "|H", &hash) == 0) {
@@ -58,43 +60,38 @@ os_count_objects(mrb_state *mrb, mrb_value self)
     mrb_hash_clear(mrb, hash);
   }
 
-  for (i = 0; i <= MRB_TT_MAXDEFINE; i++) {
-    obj_count.counts[i] = 0;
-  }
-  obj_count.total = 0;
-  obj_count.freed = 0;
-
   mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
 
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
 
-  for (i = 0; i < MRB_TT_MAXDEFINE; i++) {
+  for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
     mrb_value type;
     switch (i) {
-#define COUNT_TYPE(t) case (t): type = mrb_symbol_value(mrb_intern_cstr(mrb, #t)); break;
-      COUNT_TYPE(MRB_TT_FALSE);
-      COUNT_TYPE(MRB_TT_FREE);
-      COUNT_TYPE(MRB_TT_TRUE);
-      COUNT_TYPE(MRB_TT_FIXNUM);
-      COUNT_TYPE(MRB_TT_SYMBOL);
-      COUNT_TYPE(MRB_TT_UNDEF);
-      COUNT_TYPE(MRB_TT_FLOAT);
-      COUNT_TYPE(MRB_TT_CPTR);
-      COUNT_TYPE(MRB_TT_OBJECT);
-      COUNT_TYPE(MRB_TT_CLASS);
-      COUNT_TYPE(MRB_TT_MODULE);
-      COUNT_TYPE(MRB_TT_ICLASS);
-      COUNT_TYPE(MRB_TT_SCLASS);
-      COUNT_TYPE(MRB_TT_PROC);
-      COUNT_TYPE(MRB_TT_ARRAY);
-      COUNT_TYPE(MRB_TT_HASH);
-      COUNT_TYPE(MRB_TT_STRING);
-      COUNT_TYPE(MRB_TT_RANGE);
-      COUNT_TYPE(MRB_TT_EXCEPTION);
-      COUNT_TYPE(MRB_TT_FILE);
-      COUNT_TYPE(MRB_TT_ENV);
-      COUNT_TYPE(MRB_TT_DATA);
+#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(mrb_intern_lit(mrb, #t)); break;
+      COUNT_TYPE(T_FALSE);
+      COUNT_TYPE(T_FREE);
+      COUNT_TYPE(T_TRUE);
+      COUNT_TYPE(T_FIXNUM);
+      COUNT_TYPE(T_SYMBOL);
+      COUNT_TYPE(T_UNDEF);
+      COUNT_TYPE(T_FLOAT);
+      COUNT_TYPE(T_CPTR);
+      COUNT_TYPE(T_OBJECT);
+      COUNT_TYPE(T_CLASS);
+      COUNT_TYPE(T_MODULE);
+      COUNT_TYPE(T_ICLASS);
+      COUNT_TYPE(T_SCLASS);
+      COUNT_TYPE(T_PROC);
+      COUNT_TYPE(T_ARRAY);
+      COUNT_TYPE(T_HASH);
+      COUNT_TYPE(T_STRING);
+      COUNT_TYPE(T_RANGE);
+      COUNT_TYPE(T_EXCEPTION);
+      COUNT_TYPE(T_FILE);
+      COUNT_TYPE(T_ENV);
+      COUNT_TYPE(T_DATA);
+      COUNT_TYPE(T_FIBER);
 #undef COUNT_TYPE
     default:
       type = mrb_fixnum_value(i); break;
@@ -106,12 +103,83 @@ os_count_objects(mrb_state *mrb, mrb_value self)
   return hash;
 }
 
+struct os_each_object_data {
+  mrb_value block;
+  struct RClass *target_module;
+  mrb_int count;
+};
+
+static void
+os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
+{
+  struct os_each_object_data *d = (struct os_each_object_data*)ud;
+
+  /* filter dead objects */
+  if (is_dead(mrb, obj)) {
+    return;
+  }
+
+  /* filter internal objects */
+  switch (obj->tt) {
+  case MRB_TT_ENV:
+  case MRB_TT_ICLASS:
+    return;
+  default:
+    break;
+  }
+
+  /* filter half baked (or internal) objects */
+  if (!obj->c) return;
+
+  /* filter class kind if target module defined */
+  if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
+    return;
+  }
+
+  mrb_yield(mrb, d->block, mrb_obj_value(obj));
+  ++d->count;
+}
+
+/*
+ *  call-seq:
+ *     ObjectSpace.each_object([module]) {|obj| ... } -> fixnum
+ *
+ *  Calls the block once for each object in this Ruby process.
+ *  Returns the number of objects found.
+ *  If the optional argument +module+ is given,
+ *  calls the block for only those classes or modules
+ *  that match (or are a subclass of) +module+.
+ *
+ *  If no block is given, ArgumentError is raised.
+ *
+ */
+
+static mrb_value
+os_each_object(mrb_state *mrb, mrb_value self)
+{
+  mrb_value cls = mrb_nil_value();
+  struct os_each_object_data d;
+  mrb_get_args(mrb, "&|C", &d.block, &cls);
+
+  if (mrb_nil_p(d.block)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "Expected block in ObjectSpace.each_object.");
+  }
+
+  d.target_module = mrb_nil_p(cls) ? NULL : mrb_class_ptr(cls);
+  d.count = 0;
+  mrb_objspace_each_objects(mrb, os_each_object_cb, &d);
+  return mrb_fixnum_value(d.count);
+}
+
 void
-mrb_mruby_objectspace_gem_init(mrb_state* mrb) {
+mrb_mruby_objectspace_gem_init(mrb_state *mrb)
+{
   struct RClass *os = mrb_define_module(mrb, "ObjectSpace");
-  mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_ANY());
+  mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_OPT(1));
+  mrb_define_class_method(mrb, os, "each_object", os_each_object, MRB_ARGS_OPT(1));
 }
 
 void
-mrb_mruby_objectspace_gem_final(mrb_state* mrb) {
+mrb_mruby_objectspace_gem_final(mrb_state *mrb)
+{
 }

data/modules/mruby/mrbgems/mruby-objectspace/test/objectspace.rb

@@ -1,5 +1,6 @@
 assert('ObjectSpace.count_objects') do
   h = {}
+  f = Fiber.new {} if Object.const_defined? :Fiber
   ObjectSpace.count_objects(h)
   assert_kind_of(Hash, h)
   assert_true(h.keys.all? {|x| x.is_a?(Symbol) || x.is_a?(Integer) })
@@ -7,6 +8,9 @@ assert('ObjectSpace.count_objects') do
 
   assert_true(h.has_key?(:TOTAL))
   assert_true(h.has_key?(:FREE))
+  assert_true(h.has_key?(:T_FIBER)) if Object.const_defined? :Fiber
+
+  assert_equal(h[:TOTAL] * 2, h.values.reduce(:+))
 
   h = ObjectSpace.count_objects
   assert_kind_of(Hash, h)
@@ -15,9 +19,9 @@ assert('ObjectSpace.count_objects') do
 
   assert_raise(TypeError) { ObjectSpace.count_objects(1) }
 
-  h0 = {:MRB_TT_FOO=>1000}
+  h0 = {:T_FOO=>1000}
   h = ObjectSpace.count_objects(h0)
-  assert_false(h0.has_key?(:MRB_TT_FOO))
+  assert_false(h0.has_key?(:T_FOO))
 
   GC.start
   h_after = {}
@@ -32,6 +36,25 @@ assert('ObjectSpace.count_objects') do
   GC.start
   ObjectSpace.count_objects(h_after)
 
-  assert_equal(h[:MRB_TT_HASH], h_before[:MRB_TT_HASH] + 1000)
-  assert_equal(h_after[:MRB_TT_HASH], h_before[:MRB_TT_HASH])
+  assert_equal(h[:T_HASH], h_before[:T_HASH] + 1000)
+  assert_equal(h_after[:T_HASH], h_before[:T_HASH])
+end
+
+assert('ObjectSpace.each_object') do
+  objs = []
+  objs_count = ObjectSpace.each_object { |obj|
+    objs << obj
+  }
+  assert_equal objs.length, objs_count
+
+  arys = []
+  arys_count = ObjectSpace.each_object(Array) { |obj|
+    arys << obj
+  }
+  assert_equal arys.length, arys_count
+  assert_true arys.length < objs.length
+end
+
+assert 'Check class pointer of ObjectSpace.each_object.' do
+  ObjectSpace.each_object { |obj| !obj }
 end

data/modules/mruby/mrbgems/mruby-print/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-print') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'standard print/puts/p'
 end

data/modules/mruby/mrbgems/mruby-print/src/print.c

@@ -5,14 +5,12 @@
 static void
 printstr(mrb_state *mrb, mrb_value obj)
 {
-  struct RString *str;
   char *s;
-  int len;
+  mrb_int len;
 
   if (mrb_string_p(obj)) {
-    str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = RSTRING_PTR(obj);
+    len = RSTRING_LEN(obj);
     fwrite(s, len, 1, stdout);
   }
 }

data/modules/mruby/mrbgems/mruby-proc-ext/mrbgem.rake

@@ -1,4 +1,5 @@
 MRuby::Gem::Specification.new('mruby-proc-ext') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
+  spec.summary = 'extensional Proc class'
 end