opal 1.0.3 → 1.1.1.rc1

data/stdlib/base64.rb

@@ -6,7 +6,7 @@ module Base64
 
     // encoder
     // [https://gist.github.com/999166] by [https://github.com/nignag]
-    encode = Opal.global.btoa || function (input) {
+    encode = function (input) {
       var str = String(input);
       /* jshint ignore:start */
       for (
@@ -31,7 +31,7 @@ module Base64
 
     // decoder
     // [https://gist.github.com/1020396] by [https://github.com/atk]
-    decode = Opal.global.atob || function (input) {
+    decode = function (input) {
       var str = String(input).replace(/=+$/, '');
       if (str.length % 4 == 1) {
         #{raise ArgumentError, 'invalid base64 (failed: The string to be decoded is not correctly encoded.)'};

data/stdlib/bigdecimal.rb

@@ -1,10 +1,22 @@
 class BigDecimal < Numeric; end
 
 require 'js'
-require 'bigdecimal/kernel'
-require 'bigdecimal/bignumber.js'
+require 'bigdecimal/bignumber'
 
-class BigDecimal
+module Kernel
+  def BigDecimal(initial, digits = 0)
+    bigdecimal = BigDecimal.allocate
+    bigdecimal.initialize(initial, digits)
+    bigdecimal
+  end
+end
+
+def BigDecimal.new(*args, **kwargs)
+  warn 'BigDecimal.new is deprecated; use BigDecimal() method instead.', uplevel: 1
+  BigDecimal(*args, **kwargs)
+end
+
+class BigDecimal < Numeric
   ROUND_MODE = 256
 
   # NOTE: the numeric values of the ROUND_* constants

data/stdlib/bigdecimal/bignumber.js.rb

@@ -1,4 +1,4 @@
-class BigDecimal
+class BigDecimal < Numeric
   %x{
     var define = function (f) { Opal.const_set(self, 'BigNumber', f()); };
     define.amd = true;

data/stdlib/bigdecimal/util.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: false
+#
+#--
+# bigdecimal/util extends various native classes to provide the #to_d method,
+# and provides BigDecimal#to_d and BigDecimal#to_digits.
+#++
+
+require 'bigdecimal'
+
+class Integer < Numeric
+  # call-seq:
+  #     int.to_d  -> bigdecimal
+  #
+  # Returns the value of +int+ as a BigDecimal.
+  #
+  #     require 'bigdecimal'
+  #     require 'bigdecimal/util'
+  #
+  #     42.to_d   # => 0.42e2
+  #
+  # See also BigDecimal::new.
+  #
+  def to_d
+    BigDecimal(self)
+  end
+end
+
+
+class Float < Numeric
+  # call-seq:
+  #     float.to_d             -> bigdecimal
+  #     float.to_d(precision)  -> bigdecimal
+  #
+  # Returns the value of +float+ as a BigDecimal.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result (the default is Float::DIG).
+  #
+  #     require 'bigdecimal'
+  #     require 'bigdecimal/util'
+  #
+  #     0.5.to_d         # => 0.5e0
+  #     1.234.to_d(2)    # => 0.12e1
+  #
+  # See also BigDecimal::new.
+  #
+  def to_d(precision = Float::DIG)
+    BigDecimal(self, precision)
+  end
+end
+
+
+class String
+  # call-seq:
+  #     str.to_d  -> bigdecimal
+  #
+  # Returns the result of interpreting leading characters in +str+
+  # as a BigDecimal.
+  #
+  #     require 'bigdecimal'
+  #     require 'bigdecimal/util'
+  #
+  #     "0.5".to_d             # => 0.5e0
+  #     "123.45e1".to_d        # => 0.12345e4
+  #     "45.67 degrees".to_d   # => 0.4567e2
+  #
+  # See also BigDecimal::new.
+  #
+  def to_d
+    BigDecimal(`#{self}.replace("_", '').replace(/ .*$/,'')`)
+  end
+end
+
+
+class BigDecimal < Numeric
+  # call-seq:
+  #     a.to_digits -> string
+  #
+  # Converts a BigDecimal to a String of the form "nnnnnn.mmm".
+  # This method is deprecated; use BigDecimal#to_s("F") instead.
+  #
+  #     require 'bigdecimal/util'
+  #
+  #     d = BigDecimal("3.14")
+  #     d.to_digits                  # => "3.14"
+  #
+  def to_digits
+    if nan? || infinite? || zero?
+      to_s
+    else
+      i          = to_i.to_s
+      _, f, _, z = frac.split
+      i + '.' + ('0' * -z) + f
+    end
+  end
+
+  # call-seq:
+  #     a.to_d -> bigdecimal
+  #
+  # Returns self.
+  #
+  #     require 'bigdecimal/util'
+  #
+  #     d = BigDecimal("3.14")
+  #     d.to_d                       # => 0.314e1
+  #
+  def to_d
+    self
+  end
+end
+
+
+class Rational < Numeric
+  # call-seq:
+  #     rat.to_d(precision)  -> bigdecimal
+  #
+  # Returns the value as a BigDecimal.
+  #
+  # The required +precision+ parameter is used to determine the number of
+  # significant digits for the result.
+  #
+  #     require 'bigdecimal'
+  #     require 'bigdecimal/util'
+  #
+  #     Rational(22, 7).to_d(3)   # => 0.314e1
+  #
+  # See also BigDecimal::new.
+  #
+  def to_d(precision)
+    BigDecimal(self, precision)
+  end
+end
+
+
+class NilClass
+  # call-seq:
+  #     nil.to_d -> bigdecimal
+  #
+  # Returns nil represented as a BigDecimal.
+  #
+  #     require 'bigdecimal'
+  #     require 'bigdecimal/util'
+  #
+  #     nil.to_d   # => 0.0
+  #
+  def to_d
+    BigDecimal(0)
+  end
+end

data/stdlib/delegate.rb

@@ -12,6 +12,14 @@ class Delegator < BasicObject
       super(m, *args, &block)
     end
   end
+
+  #
+  # Checks for a method provided by this the delegate object by forwarding the
+  # call through \_\_getobj\_\_.
+  #
+  def respond_to_missing?(m, include_private)
+    __getobj__.respond_to?(m, include_private)
+  end
 end
 
 class SimpleDelegator < Delegator

data/stdlib/nodejs/fileutils.rb

@@ -11,7 +11,7 @@ module FileUtils
 
   def cp(source, target)
     target = File.join(target, File.basename(source)) if File.directory? target
-    `__fs__.writeFileSync(target, __fs__.readFileSync(source));`
+    `__fs__.writeFileSync(target, __fs__.readFileSync(source))`
   end
 
   def rm(path)

data/stdlib/nodejs/kernel.rb

@@ -3,19 +3,6 @@
 module Kernel
   NODE_REQUIRE = `require`
 
-  def caller(*args)
-    %x{
-      var stack;
-      try {
-        var err = Error("my error");
-        throw err;
-      } catch(e) {
-        stack = e.stack;
-      }
-      return stack.$split("\n").slice(3);
-    }
-  end
-
   # @deprecated Please use `require('module')` instead
   def node_require(path)
     warn '[DEPRECATION] node_require is deprecated. Please use `require(\'module\')` instead.'

data/stdlib/nodejs/stacktrace.rb

@@ -1,179 +1,4 @@
-# SOURCE: https://raw.githubusercontent.com/RReverser/stack-displayname/13732cedc506200ee8465edcbfce00a9e914853c/displayName.js
-
-# Copyright 2014 Ingvar Stepanyan
-#
-# Copyright 2006-2011, the V8 project authors. All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-#       copyright notice, this list of conditions and the following
-#       disclaimer in the documentation and/or other materials provided
-#       with the distribution.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-%x{
-  (function () {
-
-  if (!Error.captureStackTrace) {
-    return;
-  }
-
-  var ObjectToString = Object.prototype.toString;
-
-  var NODE = ObjectToString.call(process) === "[object process]";
-
-  // https://github.com/v8/v8/blob/cab94bbe3d532d85705950ed049a294050fcb4c9/src/messages.js#L1112-L1124 [converted to JS]
-  function GetTypeName(receiver, requireConstructor) {
-    if (receiver == null) return null;
-    var constructor = receiver.constructor;
-    if (!constructor) {
-      return requireConstructor ? null : ObjectToString.call(receiver);
-    }
-    var constructorName = constructor.name;
-    if (!constructorName) {
-      return requireConstructor ? null : ObjectToString.call(receiver);
-    }
-    return constructorName;
-  }
-
-  // https://github.com/v8/v8/blob/cab94bbe3d532d85705950ed049a294050fcb4c9/src/messages.js#L917-L981 [converted & modified]
-  function CallSiteToString() {
-    var fileName;
-    var fileLocation = "";
-    if (this.isNative()) {
-      fileLocation = "native";
-    } else {
-      fileName = this.getScriptNameOrSourceURL();
-      if (!fileName && this.isEval()) {
-        fileLocation = this.getEvalOrigin();
-        fileLocation += ", "; // Expecting source position to follow.
-      }
-
-      if (fileName) {
-        fileLocation += fileName;
-      } else {
-        // Source code does not originate from a file and is not native, but we
-        // can still get the source position inside the source string, e.g. in
-        // an eval string.
-        fileLocation += "<anonymous>";
-      }
-      var lineNumber = this.getLineNumber();
-      if (lineNumber !== null) {
-        fileLocation += ":" + lineNumber;
-        var columnNumber = this.getColumnNumber();
-        if (columnNumber) {
-          fileLocation += ":" + columnNumber;
-        }
-      }
-    }
-
-    var line = "";
-    var func = this.getFunction();
-    if (func) var customName = func.displayName;
-    if (NODE && customName) {
-      if (customName && func.$$owner) {
-        var customNameOwner;
-        customNameOwner = (func.$$owner.displayName || func.$$owner.$$name);
-        customName = (func.$$owner.singleton_of ? '.' : '#') + customName;
-      }
-      customName = customNameOwner + customName;
-    }
-    var functionName = customName || this.getFunctionName();
-    var addSuffix = true;
-    var isConstructor = this.isConstructor();
-    var isMethodCall = !(this.isToplevel() || isConstructor);
-    if (isMethodCall) {
-      var typeName = GetTypeName(this.receiver, true);
-      var methodName = this.getMethodName();
-      if (functionName) {
-        if (!customName && typeName && functionName.indexOf(typeName) !== 0) {
-          line += typeName + ".";
-        }
-        line += functionName;
-        if (methodName && methodName !== functionName) {//} && functionName.indexOf("." + methodName) !== functionName.length - methodName.length - 1) {
-          line += " [as " + methodName + "]";
-        }
-      } else {
-        line += typeName + "." + (methodName || "<anonymous>");
-      }
-    } else if (isConstructor) {
-      line += "new " + (functionName || "<anonymous>");
-    } else if (functionName) {
-      if (func.$$s) {
-        if (func.$$s.displayName || func.$$s.$$name) {
-          line += 'block in ' + (func.$$s.displayName || func.$$s.$$name) + ' [as ' + functionName + ']';
-        } else if (func.$$s.$$class && func.$$s.$$class.$$name) {
-          line += 'block in #<' + func.$$s.$$class.$$name + ' $$id: ' + Opal.id(func.$$s) + '> [as ' + functionName + ']';
-        } else {
-          line += functionName;
-        }
-      } else {
-        line += functionName;
-      }
-    } else {
-      line += fileLocation;
-      addSuffix = false;
-    }
-    if (addSuffix) {
-      line += " (" + fileLocation + ")";
-    }
-    return line;
-  }
-
-  var ErrorToString = Error.prototype.toString;
-
-  // https://github.com/v8/v8/blob/cab94bbe3d532d85705950ed049a294050fcb4c9/src/messages.js#L1042-L1052 [converted]
-  function FormatErrorString(error) {
-    try {
-      return ErrorToString.call(error);
-    } catch (e) {
-      try {
-        return "<error: " + e + ">";
-      } catch (ee) {
-        return "<error>";
-      }
-    }
-  }
-
-  // https://github.com/v8/v8/blob/cab94bbe3d532d85705950ed049a294050fcb4c9/src/messages.js#L1091-L1108 [logic duplicated]
-  Error.prepareStackTrace = function (error, frames) {
-    var lines = [];
-    lines.push(FormatErrorString(error));
-    for (var i = 0; i < frames.length; i++) {
-      var frame = frames[i];
-      var line;
-      try {
-        line = CallSiteToString.call(frame);
-      } catch (e) {
-        try {
-          line = "<error: " + e + ">";
-        } catch (ee) {
-          // Any code that reaches this point is seriously nasty!
-          line = "<error>";
-        }
-      }
-      lines.push("    at " + line);
-    }
-    return lines.join("\n");
-  };
-
-  })();
-}
+warn <<-WARN, uplevel: 1
+Requiring nodejs/stacktrace has been deprecated, if you use the default
+Node.js runner stack-traces will have source-map support out of the box.
+WARN

data/stdlib/ostruct.rb

@@ -31,6 +31,11 @@ class OpenStruct
     end
   end
 
+  def respond_to_missing?(mid, include_private = false) # :nodoc:
+    mname = mid.to_s.chomp('=').to_sym
+    @table&.key?(mname) || super
+  end
+
   def each_pair
     return enum_for :each_pair unless block_given?
 

data/stdlib/pp.rb

@@ -1,33 +1,600 @@
-module Kernel
-  def pretty_inspect
-    inspect
+# frozen_string_literal: true
+
+# Opal: load stdlib/thread.rb
+require 'thread'
+require 'stringio'
+require 'prettyprint'
+
+##
+# A pretty-printer for Ruby objects.
+#
+##
+# == What PP Does
+#
+# Standard output by #p returns this:
+#   #<PP:0x81fedf0 @genspace=#<Proc:0x81feda0>, @group_queue=#<PrettyPrint::GroupQueue:0x81fed3c @queue=[[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], []]>, @buffer=[], @newline="\n", @group_stack=[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], @buffer_width=0, @indent=0, @maxwidth=79, @output_width=2, @output=#<IO:0x8114ee4>>
+#
+# Pretty-printed output returns this:
+#   #<PP:0x81fedf0
+#    @buffer=[],
+#    @buffer_width=0,
+#    @genspace=#<Proc:0x81feda0>,
+#    @group_queue=
+#     #<PrettyPrint::GroupQueue:0x81fed3c
+#      @queue=
+#       [[#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
+#        []]>,
+#    @group_stack=
+#     [#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
+#    @indent=0,
+#    @maxwidth=79,
+#    @newline="\n",
+#    @output=#<IO:0x8114ee4>,
+#    @output_width=2>
+#
+##
+# == Usage
+#
+#   pp(obj)             #=> obj
+#   pp obj              #=> obj
+#   pp(obj1, obj2, ...) #=> [obj1, obj2, ...]
+#   pp()                #=> nil
+#
+# Output <tt>obj(s)</tt> to <tt>$></tt> in pretty printed format.
+#
+# It returns <tt>obj(s)</tt>.
+#
+##
+# == Output Customization
+#
+# To define a customized pretty printing function for your classes,
+# redefine method <code>#pretty_print(pp)</code> in the class.
+#
+# <code>#pretty_print</code> takes the +pp+ argument, which is an instance of the PP class.
+# The method uses #text, #breakable, #nest, #group and #pp to print the
+# object.
+#
+##
+# == Pretty-Print JSON
+#
+# To pretty-print JSON refer to JSON#pretty_generate.
+#
+##
+# == Author
+# Tanaka Akira <akr@fsij.org>
+
+class PP < PrettyPrint
+  # Outputs +obj+ to +out+ in pretty printed format of
+  # +width+ columns in width.
+  #
+  # If +out+ is omitted, <code>$></code> is assumed.
+  # If +width+ is omitted, 79 is assumed.
+  #
+  # PP.pp returns +out+.
+  def PP.pp(obj, out=$stdout, width=79)  # Opal: replace $> with $stdout
+    q = PP.new(out, width)
+    q.guard_inspect_key {q.pp obj}
+    q.flush
+    #$pp = q
+    out << "\n"
   end
 
-  def pp(*objs)
-    objs.each do |obj|
-      PP.pp(obj)
+  # Outputs +obj+ to +out+ like PP.pp but with no indent and
+  # newline.
+  #
+  # PP.singleline_pp returns +out+.
+  def PP.singleline_pp(obj, out=$stdout)  # Opal: replace $> with $stdout
+    q = SingleLine.new(out)
+    q.guard_inspect_key {q.pp obj}
+    q.flush
+    out
+  end
+
+  # :stopdoc:
+  def PP.mcall(obj, mod, meth, *args, &block)
+    mod.instance_method(meth).bind_call(obj, *args, &block)
+  end
+  # :startdoc:
+
+  @sharing_detection = false
+  class << self
+    # Returns the sharing detection flag as a boolean value.
+    # It is false by default.
+    attr_accessor :sharing_detection
+  end
+
+  module PPMethods
+
+    # Yields to a block
+    # and preserves the previous set of objects being printed.
+    def guard_inspect_key
+      if Thread.current[:__recursive_key__] == nil
+        Thread.current[:__recursive_key__] = {}.compare_by_identity
+      end
+
+      if Thread.current[:__recursive_key__][:inspect] == nil
+        Thread.current[:__recursive_key__][:inspect] = {}.compare_by_identity
+      end
+
+      save = Thread.current[:__recursive_key__][:inspect]
+
+      begin
+        Thread.current[:__recursive_key__][:inspect] = {}.compare_by_identity
+        yield
+      ensure
+        Thread.current[:__recursive_key__][:inspect] = save
+      end
+    end
+
+    # Check whether the object_id +id+ is in the current buffer of objects
+    # to be pretty printed. Used to break cycles in chains of objects to be
+    # pretty printed.
+    def check_inspect_key(id)
+      Thread.current[:__recursive_key__] &&
+      Thread.current[:__recursive_key__][:inspect] &&
+      Thread.current[:__recursive_key__][:inspect].include?(id)
+    end
+
+    # Adds the object_id +id+ to the set of objects being pretty printed, so
+    # as to not repeat objects.
+    def push_inspect_key(id)
+      Thread.current[:__recursive_key__][:inspect][id] = true
+    end
+
+    # Removes an object from the set of objects being pretty printed.
+    def pop_inspect_key(id)
+      Thread.current[:__recursive_key__][:inspect].delete id
+    end
+
+    # Adds +obj+ to the pretty printing buffer
+    # using Object#pretty_print or Object#pretty_print_cycle.
+    #
+    # Object#pretty_print_cycle is used when +obj+ is already
+    # printed, a.k.a the object reference chain has a cycle.
+    def pp(obj)
+      # If obj is a Delegator then use the object being delegated to for cycle
+      # detection
+      obj = obj.__getobj__ if defined?(::Delegator) and obj.is_a?(::Delegator)
+
+      if check_inspect_key(obj)
+        group {obj.pretty_print_cycle self}
+        return
+      end
+
+      begin
+        push_inspect_key(obj)
+        group {obj.pretty_print self}
+      ensure
+        pop_inspect_key(obj) unless PP.sharing_detection
+      end
+    end
+
+    # A convenience method which is same as follows:
+    #
+    #   group(1, '#<' + obj.class.name, '>') { ... }
+    def object_group(obj, &block) # :yield:
+      group(1, '#<' + obj.class.name, '>', &block)
+    end
+
+    # A convenience method, like object_group, but also reformats the Object's
+    # object_id.
+    def object_address_group(obj, &block)
+      str = Kernel.instance_method(:to_s).bind_call(obj)
+      str.chomp!('>')
+      group(1, str, '>', &block)
+    end
+
+    # A convenience method which is same as follows:
+    #
+    #   text ','
+    #   breakable
+    def comma_breakable
+      text ','
+      breakable
+    end
+
+    # Adds a separated list.
+    # The list is separated by comma with breakable space, by default.
+    #
+    # #seplist iterates the +list+ using +iter_method+.
+    # It yields each object to the block given for #seplist.
+    # The procedure +separator_proc+ is called between each yields.
+    #
+    # If the iteration is zero times, +separator_proc+ is not called at all.
+    #
+    # If +separator_proc+ is nil or not given,
+    # +lambda { comma_breakable }+ is used.
+    # If +iter_method+ is not given, :each is used.
+    #
+    # For example, following 3 code fragments has similar effect.
+    #
+    #   q.seplist([1,2,3]) {|v| xxx v }
+    #
+    #   q.seplist([1,2,3], lambda { q.comma_breakable }, :each) {|v| xxx v }
+    #
+    #   xxx 1
+    #   q.comma_breakable
+    #   xxx 2
+    #   q.comma_breakable
+    #   xxx 3
+    def seplist(list, sep=nil, iter_method=:each) # :yield: element
+      sep ||= lambda { comma_breakable }
+      first = true
+      list.__send__(iter_method) {|*v|
+        if first
+          first = false
+        else
+          sep.call
+        end
+        yield(*v)
+      }
+    end
+
+    # A present standard failsafe for pretty printing any given Object
+    def pp_object(obj)
+      object_address_group(obj) {
+        seplist(obj.pretty_print_instance_variables, lambda { text ',' }) {|v|
+          breakable
+          v = v.to_s if Symbol === v
+          text v
+          text '='
+          group(1) {
+            breakable ''
+            pp(obj.instance_eval(v))
+          }
+        }
+      }
+    end
+
+    # A pretty print for a Hash
+    def pp_hash(obj)
+      group(1, '{', '}') {
+        seplist(obj, nil, :each_pair) {|k, v|
+          group {
+            pp k
+            text '=>'
+            group(1) {
+              breakable ''
+              pp v
+            }
+          }
+        }
+      }
+    end
+  end
+
+  include PPMethods
+
+  class SingleLine < PrettyPrint::SingleLine # :nodoc:
+    include PPMethods
+  end
+
+  module ObjectMixin # :nodoc:
+    # 1. specific pretty_print
+    # 2. specific inspect
+    # 3. generic pretty_print
+
+    # A default pretty printing method for general objects.
+    # It calls #pretty_print_instance_variables to list instance variables.
+    #
+    # If +self+ has a customized (redefined) #inspect method,
+    # the result of self.inspect is used but it obviously has no
+    # line break hints.
+    #
+    # This module provides predefined #pretty_print methods for some of
+    # the most commonly used built-in classes for convenience.
+    def pretty_print(q)
+      umethod_method = Object.instance_method(:method)
+      begin
+        inspect_method = umethod_method.bind_call(self, :inspect)
+      rescue NameError
+      end
+      if inspect_method && inspect_method.owner != Kernel
+        q.text self.inspect
+      elsif !inspect_method && self.respond_to?(:inspect)
+        q.text self.inspect
+      else
+        q.pp_object(self)
+      end
+    end
+
+    # A default pretty printing method for general objects that are
+    # detected as part of a cycle.
+    def pretty_print_cycle(q)
+      q.object_address_group(self) {
+        q.breakable
+        q.text '...'
+      }
+    end
+
+    # Returns a sorted array of instance variable names.
+    #
+    # This method should return an array of names of instance variables as symbols or strings as:
+    # +[:@a, :@b]+.
+    def pretty_print_instance_variables
+      instance_variables.sort
+    end
+
+    # Is #inspect implementation using #pretty_print.
+    # If you implement #pretty_print, it can be used as follows.
+    #
+    #   alias inspect pretty_print_inspect
+    #
+    # However, doing this requires that every class that #inspect is called on
+    # implement #pretty_print, or a RuntimeError will be raised.
+    def pretty_print_inspect
+      if Object.instance_method(:method).bind_call(self, :pretty_print).owner == PP::ObjectMixin
+        raise "pretty_print is not overridden for #{self.class}"
+      end
+      PP.singleline_pp(self, ''.dup)
     end
-    objs.size <= 1 ? objs.first : objs
   end
-  module_function :pp
 end
 
-class PP
-  class << self
-    if `(typeof(console) === "undefined" || typeof(console.log) === "undefined")`
-      def pp(obj, out = $stdout, width = 79)
-        p(*args)
+class Array # :nodoc:
+  def pretty_print(q) # :nodoc:
+    q.group(1, '[', ']') {
+      q.seplist(self) {|v|
+        q.pp v
+      }
+    }
+  end
+
+  def pretty_print_cycle(q) # :nodoc:
+    q.text(empty? ? '[]' : '[...]')
+  end
+end
+
+class Hash # :nodoc:
+  def pretty_print(q) # :nodoc:
+    q.pp_hash self
+  end
+
+  def pretty_print_cycle(q) # :nodoc:
+    q.text(empty? ? '{}' : '{...}')
+  end
+end
+
+class << ENV # :nodoc:
+  def pretty_print(q) # :nodoc:
+    h = {}
+    ENV.keys.sort.each {|k|
+      h[k] = ENV[k]
+    }
+    q.pp_hash h
+  end
+end
+
+class Struct # :nodoc:
+  def pretty_print(q) # :nodoc:
+    q.group(1, sprintf("#<struct %s", PP.mcall(self, Kernel, :class).name), '>') {
+      q.seplist(PP.mcall(self, Struct, :members), lambda { q.text "," }) {|member|
+        q.breakable
+        q.text member.to_s
+        q.text '='
+        q.group(1) {
+          q.breakable ''
+          q.pp self[member]
+        }
+      }
+    }
+  end
+
+  def pretty_print_cycle(q) # :nodoc:
+    q.text sprintf("#<struct %s:...>", PP.mcall(self, Kernel, :class).name)
+  end
+end
+
+class Range # :nodoc:
+  def pretty_print(q) # :nodoc:
+    q.pp self.begin
+    q.breakable ''
+    q.text(self.exclude_end? ? '...' : '..')
+    q.breakable ''
+    q.pp self.end if self.end
+  end
+end
+
+class String # :nodoc:
+  def pretty_print(q) # :nodoc:
+    lines = self.lines
+    if lines.size > 1
+      q.group(0, '', '') do
+        q.seplist(lines, lambda { q.text ' +'; q.breakable }) do |v|
+          q.pp v
+        end
       end
     else
-      def pp(obj, out = $stdout, width = 79)
-        if String === out
-          out + obj.inspect + "\n"
+      q.text inspect
+    end
+  end
+end
+
+# Opal: does not have File::Stat
+#class File < IO # :nodoc:
+#  class Stat # :nodoc:
+#    def pretty_print(q) # :nodoc:
+#      require 'etc.so'
+#      q.object_group(self) {
+#        q.breakable
+#        q.text sprintf("dev=0x%x", self.dev); q.comma_breakable
+#        q.text "ino="; q.pp self.ino; q.comma_breakable
+#        q.group {
+#          m = self.mode
+#          q.text sprintf("mode=0%o", m)
+#          q.breakable
+#          q.text sprintf("(%s %c%c%c%c%c%c%c%c%c)",
+#            self.ftype,
+#            (m & 0400 == 0 ? ?- : ?r),
+#            (m & 0200 == 0 ? ?- : ?w),
+#            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
+#                             (m & 04000 == 0 ? ?x : ?s)),
+#            (m & 0040 == 0 ? ?- : ?r),
+#            (m & 0020 == 0 ? ?- : ?w),
+#            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
+#                             (m & 02000 == 0 ? ?x : ?s)),
+#            (m & 0004 == 0 ? ?- : ?r),
+#            (m & 0002 == 0 ? ?- : ?w),
+#            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
+#                             (m & 01000 == 0 ? ?x : ?t)))
+#        }
+#        q.comma_breakable
+#        q.text "nlink="; q.pp self.nlink; q.comma_breakable
+#        q.group {
+#          q.text "uid="; q.pp self.uid
+#          begin
+#            pw = Etc.getpwuid(self.uid)
+#          rescue ArgumentError
+#          end
+#          if pw
+#            q.breakable; q.text "(#{pw.name})"
+#          end
+#        }
+#        q.comma_breakable
+#        q.group {
+#          q.text "gid="; q.pp self.gid
+#          begin
+#            gr = Etc.getgrgid(self.gid)
+#          rescue ArgumentError
+#          end
+#          if gr
+#            q.breakable; q.text "(#{gr.name})"
+#          end
+#        }
+#        q.comma_breakable
+#        q.group {
+#          q.text sprintf("rdev=0x%x", self.rdev)
+#          if self.rdev_major && self.rdev_minor
+#            q.breakable
+#            q.text sprintf('(%d, %d)', self.rdev_major, self.rdev_minor)
+#          end
+#        }
+#        q.comma_breakable
+#        q.text "size="; q.pp self.size; q.comma_breakable
+#        q.text "blksize="; q.pp self.blksize; q.comma_breakable
+#        q.text "blocks="; q.pp self.blocks; q.comma_breakable
+#        q.group {
+#          t = self.atime
+#          q.text "atime="; q.pp t
+#          q.breakable; q.text "(#{t.tv_sec})"
+#        }
+#        q.comma_breakable
+#        q.group {
+#          t = self.mtime
+#          q.text "mtime="; q.pp t
+#          q.breakable; q.text "(#{t.tv_sec})"
+#        }
+#        q.comma_breakable
+#        q.group {
+#          t = self.ctime
+#          q.text "ctime="; q.pp t
+#          q.breakable; q.text "(#{t.tv_sec})"
+#        }
+#      }
+#    end
+#  end
+#end
+
+class MatchData # :nodoc:
+  def pretty_print(q) # :nodoc:
+    nc = []
+    self.regexp.named_captures.each {|name, indexes|
+      indexes.each {|i| nc[i] = name }
+    }
+    q.object_group(self) {
+      q.breakable
+      q.seplist(0...self.size, lambda { q.breakable }) {|i|
+        if i == 0
+          q.pp self[i]
         else
-          out << obj.inspect + "\n"
+          if nc[i]
+            q.text nc[i]
+          else
+            q.pp i
+          end
+          q.text ':'
+          q.pp self[i]
         end
-      end
+      }
+    }
+  end
+end
+
+# Opal: does not have RubyVM
+#class RubyVM::AbstractSyntaxTree::Node
+#  def pretty_print_children(q, names = [])
+#    children.zip(names) do |c, n|
+#      if n
+#        q.breakable
+#        q.text "#{n}:"
+#      end
+#      q.group(2) do
+#        q.breakable
+#        q.pp c
+#      end
+#    end
+#  end
+#
+#  def pretty_print(q)
+#    q.group(1, "(#{type}@#{first_lineno}:#{first_column}-#{last_lineno}:#{last_column}", ")") {
+#      case type
+#      when :SCOPE
+#        pretty_print_children(q, %w"tbl args body")
+#      when :ARGS
+#        pretty_print_children(q, %w[pre_num pre_init opt first_post post_num post_init rest kw kwrest block])
+#      when :DEFN
+#        pretty_print_children(q, %w[mid body])
+#      when :ARYPTN
+#        pretty_print_children(q, %w[const pre rest post])
+#      when :HSHPTN
+#        pretty_print_children(q, %w[const kw kwrest])
+#      else
+#        pretty_print_children(q)
+#      end
+#    }
+#  end
+#end
+
+class Object < BasicObject # :nodoc:
+  include PP::ObjectMixin
+end
+
+[Numeric, Symbol, FalseClass, TrueClass, NilClass, Module].each {|c|
+  c.class_eval {
+    def pretty_print_cycle(q)
+      q.text inspect
     end
+  }
+}
 
-    alias singleline_pp pp
+[Numeric, FalseClass, TrueClass, Module].each {|c|
+  c.class_eval {
+    def pretty_print(q)
+      q.text inspect
+    end
+  }
+}
+
+module Kernel
+  # Returns a pretty printed object as a string.
+  #
+  # In order to use this method you must first require the PP module:
+  #
+  #   require 'pp'
+  #
+  # See the PP module for more information.
+  def pretty_inspect
+    PP.pp(self, StringIO.new).string
   end
+
+  # prints arguments in pretty form.
+  #
+  # pp returns argument(s).
+  def pp(*objs)
+    objs.each {|obj|
+      PP.pp(obj)
+    }
+    objs.size <= 1 ? objs.first : objs
+  end
+  module_function :pp
 end