Module: Kernel

Included in:

Object

Defined in:

opal/opal/corelib/kernel.rb,
opal/opal/corelib/complex.rb,
opal/opal/corelib/rational.rb,
opal/opal/corelib/unsupported.rb,
opal/opal/corelib/unsupported.rb,
opal/opal/corelib/unsupported.rb,
opal/opal/corelib/unsupported.rb

Instance Method Summary

• #!~(obj) ⇒ Object
• #<=>(other) ⇒ Object
• #===(other) ⇒ Object
• #=~(obj) ⇒ Object
• #Array(object) ⇒ Object
• #at_exit(&block) ⇒ Object
• #caller ⇒ Object

  Opal does not support #caller, but we stub it as an empty array to not break dependant libs.

• #catch(sym) ⇒ Object
• #class ⇒ Object
• #clone ⇒ Object
• #Complex(real, imag = nil) ⇒ Object
• #copy_instance_variables(other) ⇒ Object
• #copy_singleton_methods(other) ⇒ Object
• #define_singleton_method(name, method = undefined, &block) ⇒ Object
• #dup ⇒ Object
• #enum_for(method = :each, *args, &block) ⇒ Object (also: #to_enum)
• #equal?(other) ⇒ Boolean
• #eval ⇒ Object
• #exit(status = true) ⇒ Object
• #extend(*mods) ⇒ Object
• #Float(value) ⇒ Object
• #format(format_string, *args) ⇒ Object (also: #sprintf)
• #freeze ⇒ Object
• #frozen? ⇒ Boolean
• #Hash(arg) ⇒ Object
• #hash ⇒ Object
• #initialize_clone(other) ⇒ Object
• #initialize_copy(other) ⇒ Object
• #initialize_dup(other) ⇒ Object
• #inspect ⇒ Object
• #instance_of?(klass) ⇒ Boolean
• #instance_variable_defined?(name) ⇒ Boolean
• #instance_variable_get(name) ⇒ Object
• #instance_variable_set(name, value) ⇒ Object
• #instance_variables ⇒ Object
• #Integer(value, base = undefined) ⇒ Object
• #is_a?(klass) ⇒ Boolean (also: #kind_of?)
• #lambda(&block) ⇒ Object
• #load(file) ⇒ Object
• #loop(&block) ⇒ Object
• #method(name) ⇒ Object
• #method_missing(symbol, *args, &block) ⇒ Object
• #methods(all = true) ⇒ Object (also: #public_methods)
• #nil? ⇒ Boolean
• #p(*args) ⇒ Object
• #print(*strs) ⇒ Object
• #printf(*args) ⇒ Object
• #private_methods ⇒ Object (also: #private_instance_methods)
• #proc(&block) ⇒ Object
• #puts(*strs) ⇒ Object
• #raise(exception = undefined, string = nil, _backtrace = nil) ⇒ Object (also: #fail)
• #rand(max = undefined) ⇒ Object (also: #srand)
• #Rational(numerator, denominator = 1) ⇒ Object
• #remove_instance_variable(name) ⇒ Object
• #require(file) ⇒ Object
• #require_relative(file) ⇒ Object
• #require_tree(path) ⇒ Object

  path should be the full path to be found in registered modules (Opal.modules).

• #respond_to?(name, include_all = false) ⇒ Boolean
• #respond_to_missing?(method_name, include_all = false) ⇒ Boolean
• #singleton_class ⇒ Object
• #sleep(seconds = nil) ⇒ Object
• #String(str) ⇒ Object
• #taint ⇒ Object
• #tainted? ⇒ Boolean
• #tap {|_self| ... } ⇒ Object
• #throw(*args) ⇒ Object
• #to_proc ⇒ Object
• #to_s ⇒ Object
• #untaint ⇒ Object
• #warn(*strs) ⇒ Object

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(symbol, *args, &block) ⇒ Object

Raises:

• (NoMethodError)

# File 'opal/opal/corelib/kernel.rb', line 2

def method_missing(symbol, *args, &block)
  raise NoMethodError.new("undefined method `#{symbol}' for #{inspect}", symbol, args)
end

Instance Method Details

#!~(obj) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 10

def !~(obj)
  not(self =~ obj)
end

#<=>(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 18

def <=>(other)
  %x{
    // set guard for infinite recursion
    self.$$comparable = true;

    var x = #{self == other};

    if (x && x !== nil) {
      return 0;
    }

    return nil;
  }
end

#===(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 14

def ===(other)
  self.object_id == other.object_id || self == other
end

#=~(obj) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 6

def =~(obj)
  false
end

#Array(object) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 68

def Array(object)
  %x{
    var coerced;

    if (object === nil) {
      return [];
    }

    if (object.$$is_array) {
      return object;
    }

    coerced = #{Opal.coerce_to?(object, Array, :to_ary)};
    if (coerced !== nil) { return coerced; }

    coerced = #{Opal.coerce_to?(object, Array, :to_a)};
    if (coerced !== nil) { return coerced; }

    return [object];
  }
end

#at_exit(&block) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 90

def at_exit(&block)
  $__at_exit__ ||= []
  $__at_exit__ << block
end

#caller ⇒ Object

Opal does not support #caller, but we stub it as an empty array to not break dependant libs

# File 'opal/opal/corelib/kernel.rb', line 97

def caller
  []
end

#catch(sym) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1168

def catch(sym)
  yield
rescue UncaughtThrowError => e
  return e.arg if e.sym == sym
  raise
end

#class ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 101

def class
  `self.$$class`
end

#clone ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 138

def clone
  copy = self.class.allocate

  copy.copy_instance_variables(self)
  copy.copy_singleton_methods(self)
  copy.initialize_clone(self)

  copy
end

#Complex(real, imag = nil) ⇒ Object

# File 'opal/opal/corelib/complex.rb', line 278

def Complex(real, imag = nil)
  if imag
    Complex.new(real, imag)
  else
    Complex.new(real, 0)
  end
end

#copy_instance_variables(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 105

def copy_instance_variables(other)
  %x{
    for (var name in other) {
      if (other.hasOwnProperty(name) && name.charAt(0) !== '$') {
        self[name] = other[name];
      }
    }
  }
end

#copy_singleton_methods(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 115

def copy_singleton_methods(other)
  %x{
    var name;

    if (other.hasOwnProperty('$$meta')) {
      var other_singleton_class_proto = Opal.get_singleton_class(other).$$proto;
      var self_singleton_class_proto = Opal.get_singleton_class(self).$$proto;

      for (name in other_singleton_class_proto) {
        if (name.charAt(0) === '$' && other_singleton_class_proto.hasOwnProperty(name)) {
          self_singleton_class_proto[name] = other_singleton_class_proto[name];
        }
      }
    }

    for (name in other) {
      if (name.charAt(0) === '$' && name.charAt(1) !== '$' && other.hasOwnProperty(name)) {
        self[name] = other[name];
      }
    }
  }
end

#define_singleton_method(name, method = undefined, &block) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 152

def define_singleton_method(name, method = undefined, &block)
  singleton_class.define_method(name, method, &block)
end

#dup ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 156

def dup
  copy = self.class.allocate

  copy.copy_instance_variables(self)
  copy.initialize_dup(self)

  copy
end

#enum_for(method = :each, *args, &block) ⇒ Object Also known as: to_enum

# File 'opal/opal/corelib/kernel.rb', line 169

def enum_for(method = :each, *args, &block)
  Enumerator.for(self, method, *args, &block)
end

#equal?(other) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 175

def equal?(other)
  `self === other`
end

#eval ⇒ Object

Raises:

• (NotImplementedError)

# File 'opal/opal/corelib/unsupported.rb', line 212

def eval(*)
  raise NotImplementedError, "To use Kernel#eval, you must first require 'opal-parser'. "\
                             "See https://github.com/opal/opal/blob/#{RUBY_ENGINE_VERSION}/docs/opal_parser.md for details."
end

#exit(status = true) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 179

def exit(status = true)
  $__at_exit__ ||= []
  loop do
    block = $__at_exit__.pop
    block ? block.call : break
  end

  status = 0 if `status === true` # it's in JS because it can be null/undef
  `Opal.exit(status);`
  nil
end

#extend(*mods) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 191

def extend(*mods)
  %x{
    var singleton = #{singleton_class};

    for (var i = mods.length - 1; i >= 0; i--) {
      var mod = mods[i];

      if (!mod.$$is_module) {
        #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
      }

      #{`mod`.append_features `singleton`};
      #{`mod`.extended self};
    }
  }

  self
end

#Float(value) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 913

def Float(value)
  %x{
    var str;

    if (value === nil) {
      #{raise TypeError, "can't convert nil into Float"}
    }

    if (value.$$is_string) {
      str = value.toString();

      str = str.replace(/(\d)_(?=\d)/g, '$1');

      //Special case for hex strings only:
      if (/^\s*[-+]?0[xX][0-9a-fA-F]+\s*$/.test(str)) {
        return #{Integer(`str`)};
      }

      if (!/^\s*[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\s*$/.test(str)) {
        #{raise ArgumentError, "invalid value for Float(): \"#{value}\""}
      }

      return parseFloat(str);
    }

    return #{Opal.coerce_to!(value, Float, :to_f)};
  }
end

#format(format_string, *args) ⇒ Object Also known as: sprintf

# File 'opal/opal/corelib/kernel.rb', line 210

def format(format_string, *args)
  if args.length == 1 && args[0].respond_to?(:to_ary)
    ary = Opal.coerce_to?(args[0], Array, :to_ary)
    args = ary.to_a unless ary.nil?
  end

  %x{
    var result = '',
        //used for slicing:
        begin_slice = 0,
        end_slice,
        //used for iterating over the format string:
        i,
        len = format_string.length,
        //used for processing field values:
        arg,
        str,
        //used for processing %g and %G fields:
        exponent,
        //used for keeping track of width and precision:
        width,
        precision,
        //used for holding temporary values:
        tmp_num,
        //used for processing %{} and %<> fileds:
        hash_parameter_key,
        closing_brace_char,
        //used for processing %b, %B, %o, %x, and %X fields:
        base_number,
        base_prefix,
        base_neg_zero_regex,
        base_neg_zero_digit,
        //used for processing arguments:
        next_arg,
        seq_arg_num = 1,
        pos_arg_num = 0,
        //used for keeping track of flags:
        flags,
        FNONE  = 0,
        FSHARP = 1,
        FMINUS = 2,
        FPLUS  = 4,
        FZERO  = 8,
        FSPACE = 16,
        FWIDTH = 32,
        FPREC  = 64,
        FPREC0 = 128;

    function CHECK_FOR_FLAGS() {
      if (flags&FWIDTH) { #{raise ArgumentError, 'flag after width'} }
      if (flags&FPREC0) { #{raise ArgumentError, 'flag after precision'} }
    }

    function CHECK_FOR_WIDTH() {
      if (flags&FWIDTH) { #{raise ArgumentError, 'width given twice'} }
      if (flags&FPREC0) { #{raise ArgumentError, 'width after precision'} }
    }

    function GET_NTH_ARG(num) {
      if (num >= args.length) { #{raise ArgumentError, 'too few arguments'} }
      return args[num];
    }

    function GET_NEXT_ARG() {
      switch (pos_arg_num) {
      case -1: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with numbered"}
      case -2: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"}
      }
      pos_arg_num = seq_arg_num++;
      return GET_NTH_ARG(pos_arg_num - 1);
    }

    function GET_POS_ARG(num) {
      if (pos_arg_num > 0) {
        #{raise ArgumentError, "numbered(#{`num`}) after unnumbered(#{`pos_arg_num`})"}
      }
      if (pos_arg_num === -2) {
        #{raise ArgumentError, "numbered(#{`num`}) after named"}
      }
      if (num < 1) {
        #{raise ArgumentError, "invalid index - #{`num`}$"}
      }
      pos_arg_num = -1;
      return GET_NTH_ARG(num - 1);
    }

    function GET_ARG() {
      return (next_arg === undefined ? GET_NEXT_ARG() : next_arg);
    }

    function READ_NUM(label) {
      var num, str = '';
      for (;; i++) {
        if (i === len) {
          #{raise ArgumentError, 'malformed format string - %*[0-9]'}
        }
        if (format_string.charCodeAt(i) < 48 || format_string.charCodeAt(i) > 57) {
          i--;
          num = parseInt(str, 10) || 0;
          if (num > 2147483647) {
            #{raise ArgumentError, "#{`label`} too big"}
          }
          return num;
        }
        str += format_string.charAt(i);
      }
    }

    function READ_NUM_AFTER_ASTER(label) {
      var arg, num = READ_NUM(label);
      if (format_string.charAt(i + 1) === '$') {
        i++;
        arg = GET_POS_ARG(num);
      } else {
        arg = GET_NEXT_ARG();
      }
      return #{`arg`.to_int};
    }

    for (i = format_string.indexOf('%'); i !== -1; i = format_string.indexOf('%', i)) {
      str = undefined;

      flags = FNONE;
      width = -1;
      precision = -1;
      next_arg = undefined;

      end_slice = i;

      i++;

      switch (format_string.charAt(i)) {
      case '%':
        begin_slice = i;
      case '':
      case '\n':
      case '\0':
        i++;
        continue;
      }

      format_sequence: for (; i < len; i++) {
        switch (format_string.charAt(i)) {

        case ' ':
          CHECK_FOR_FLAGS();
          flags |= FSPACE;
          continue format_sequence;

        case '#':
          CHECK_FOR_FLAGS();
          flags |= FSHARP;
          continue format_sequence;

        case '+':
          CHECK_FOR_FLAGS();
          flags |= FPLUS;
          continue format_sequence;

        case '-':
          CHECK_FOR_FLAGS();
          flags |= FMINUS;
          continue format_sequence;

        case '0':
          CHECK_FOR_FLAGS();
          flags |= FZERO;
          continue format_sequence;

        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          tmp_num = READ_NUM('width');
          if (format_string.charAt(i + 1) === '$') {
            if (i + 2 === len) {
              str = '%';
              i++;
              break format_sequence;
            }
            if (next_arg !== undefined) {
              #{raise ArgumentError, "value given twice - %#{`tmp_num`}$"}
            }
            next_arg = GET_POS_ARG(tmp_num);
            i++;
          } else {
            CHECK_FOR_WIDTH();
            flags |= FWIDTH;
            width = tmp_num;
          }
          continue format_sequence;

        case '<':
        case '\{':
          closing_brace_char = (format_string.charAt(i) === '<' ? '>' : '\}');
          hash_parameter_key = '';

          i++;

          for (;; i++) {
            if (i === len) {
              #{raise ArgumentError, 'malformed name - unmatched parenthesis'}
            }
            if (format_string.charAt(i) === closing_brace_char) {

              if (pos_arg_num > 0) {
                #{raise ArgumentError, "named #{`hash_parameter_key`} after unnumbered(#{`pos_arg_num`})"}
              }
              if (pos_arg_num === -1) {
                #{raise ArgumentError, "named #{`hash_parameter_key`} after numbered"}
              }
              pos_arg_num = -2;

              if (args[0] === undefined || !args[0].$$is_hash) {
                #{raise ArgumentError, 'one hash required'}
              }

              next_arg = #{`args[0]`.fetch(`hash_parameter_key`)};

              if (closing_brace_char === '>') {
                continue format_sequence;
              } else {
                str = next_arg.toString();
                if (precision !== -1) { str = str.slice(0, precision); }
                if (flags&FMINUS) {
                  while (str.length < width) { str = str + ' '; }
                } else {
                  while (str.length < width) { str = ' ' + str; }
                }
                break format_sequence;
              }
            }
            hash_parameter_key += format_string.charAt(i);
          }

        case '*':
          i++;
          CHECK_FOR_WIDTH();
          flags |= FWIDTH;
          width = READ_NUM_AFTER_ASTER('width');
          if (width < 0) {
            flags |= FMINUS;
            width = -width;
          }
          continue format_sequence;

        case '.':
          if (flags&FPREC0) {
            #{raise ArgumentError, 'precision given twice'}
          }
          flags |= FPREC|FPREC0;
          precision = 0;
          i++;
          if (format_string.charAt(i) === '*') {
            i++;
            precision = READ_NUM_AFTER_ASTER('precision');
            if (precision < 0) {
              flags &= ~FPREC;
            }
            continue format_sequence;
          }
          precision = READ_NUM('precision');
          continue format_sequence;

        case 'd':
        case 'i':
        case 'u':
          arg = #{Integer(`GET_ARG()`)};
          if (arg >= 0) {
            str = arg.toString();
            while (str.length < precision) { str = '0' + str; }
            if (flags&FMINUS) {
              if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              while (str.length < width) { str = str + ' '; }
            } else {
              if (flags&FZERO && precision === -1) {
                while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0)) { str = '0' + str; }
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              } else {
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
                while (str.length < width) { str = ' ' + str; }
              }
            }
          } else {
            str = (-arg).toString();
            while (str.length < precision) { str = '0' + str; }
            if (flags&FMINUS) {
              str = '-' + str;
              while (str.length < width) { str = str + ' '; }
            } else {
              if (flags&FZERO && precision === -1) {
                while (str.length < width - 1) { str = '0' + str; }
                str = '-' + str;
              } else {
                str = '-' + str;
                while (str.length < width) { str = ' ' + str; }
              }
            }
          }
          break format_sequence;

        case 'b':
        case 'B':
        case 'o':
        case 'x':
        case 'X':
          switch (format_string.charAt(i)) {
          case 'b':
          case 'B':
            base_number = 2;
            base_prefix = '0b';
            base_neg_zero_regex = /^1+/;
            base_neg_zero_digit = '1';
            break;
          case 'o':
            base_number = 8;
            base_prefix = '0';
            base_neg_zero_regex = /^3?7+/;
            base_neg_zero_digit = '7';
            break;
          case 'x':
          case 'X':
            base_number = 16;
            base_prefix = '0x';
            base_neg_zero_regex = /^f+/;
            base_neg_zero_digit = 'f';
            break;
          }
          arg = #{Integer(`GET_ARG()`)};
          if (arg >= 0) {
            str = arg.toString(base_number);
            while (str.length < precision) { str = '0' + str; }
            if (flags&FMINUS) {
              if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
              while (str.length < width) { str = str + ' '; }
            } else {
              if (flags&FZERO && precision === -1) {
                while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0) - ((flags&FSHARP && arg !== 0) ? base_prefix.length : 0)) { str = '0' + str; }
                if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              } else {
                if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
                while (str.length < width) { str = ' ' + str; }
              }
            }
          } else {
            if (flags&FPLUS || flags&FSPACE) {
              str = (-arg).toString(base_number);
              while (str.length < precision) { str = '0' + str; }
              if (flags&FMINUS) {
                if (flags&FSHARP) { str = base_prefix + str; }
                str = '-' + str;
                while (str.length < width) { str = str + ' '; }
              } else {
                if (flags&FZERO && precision === -1) {
                  while (str.length < width - 1 - (flags&FSHARP ? 2 : 0)) { str = '0' + str; }
                  if (flags&FSHARP) { str = base_prefix + str; }
                  str = '-' + str;
                } else {
                  if (flags&FSHARP) { str = base_prefix + str; }
                  str = '-' + str;
                  while (str.length < width) { str = ' ' + str; }
                }
              }
            } else {
              str = (arg >>> 0).toString(base_number).replace(base_neg_zero_regex, base_neg_zero_digit);
              while (str.length < precision - 2) { str = base_neg_zero_digit + str; }
              if (flags&FMINUS) {
                str = '..' + str;
                if (flags&FSHARP) { str = base_prefix + str; }
                while (str.length < width) { str = str + ' '; }
              } else {
                if (flags&FZERO && precision === -1) {
                  while (str.length < width - 2 - (flags&FSHARP ? base_prefix.length : 0)) { str = base_neg_zero_digit + str; }
                  str = '..' + str;
                  if (flags&FSHARP) { str = base_prefix + str; }
                } else {
                  str = '..' + str;
                  if (flags&FSHARP) { str = base_prefix + str; }
                  while (str.length < width) { str = ' ' + str; }
                }
              }
            }
          }
          if (format_string.charAt(i) === format_string.charAt(i).toUpperCase()) {
            str = str.toUpperCase();
          }
          break format_sequence;

        case 'f':
        case 'e':
        case 'E':
        case 'g':
        case 'G':
          arg = #{Float(`GET_ARG()`)};
          if (arg >= 0 || isNaN(arg)) {
            if (arg === Infinity) {
              str = 'Inf';
            } else {
              switch (format_string.charAt(i)) {
              case 'f':
                str = arg.toFixed(precision === -1 ? 6 : precision);
                break;
              case 'e':
              case 'E':
                str = arg.toExponential(precision === -1 ? 6 : precision);
                break;
              case 'g':
              case 'G':
                str = arg.toExponential();
                exponent = parseInt(str.split('e')[1], 10);
                if (!(exponent < -4 || exponent >= (precision === -1 ? 6 : precision))) {
                  str = arg.toPrecision(precision === -1 ? (flags&FSHARP ? 6 : undefined) : precision);
                }
                break;
              }
            }
            if (flags&FMINUS) {
              if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              while (str.length < width) { str = str + ' '; }
            } else {
              if (flags&FZERO && arg !== Infinity && !isNaN(arg)) {
                while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0)) { str = '0' + str; }
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
              } else {
                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
                while (str.length < width) { str = ' ' + str; }
              }
            }
          } else {
            if (arg === -Infinity) {
              str = 'Inf';
            } else {
              switch (format_string.charAt(i)) {
              case 'f':
                str = (-arg).toFixed(precision === -1 ? 6 : precision);
                break;
              case 'e':
              case 'E':
                str = (-arg).toExponential(precision === -1 ? 6 : precision);
                break;
              case 'g':
              case 'G':
                str = (-arg).toExponential();
                exponent = parseInt(str.split('e')[1], 10);
                if (!(exponent < -4 || exponent >= (precision === -1 ? 6 : precision))) {
                  str = (-arg).toPrecision(precision === -1 ? (flags&FSHARP ? 6 : undefined) : precision);
                }
                break;
              }
            }
            if (flags&FMINUS) {
              str = '-' + str;
              while (str.length < width) { str = str + ' '; }
            } else {
              if (flags&FZERO && arg !== -Infinity) {
                while (str.length < width - 1) { str = '0' + str; }
                str = '-' + str;
              } else {
                str = '-' + str;
                while (str.length < width) { str = ' ' + str; }
              }
            }
          }
          if (format_string.charAt(i) === format_string.charAt(i).toUpperCase() && arg !== Infinity && arg !== -Infinity && !isNaN(arg)) {
            str = str.toUpperCase();
          }
          str = str.replace(/([eE][-+]?)([0-9])$/, '$10$2');
          break format_sequence;

        case 'a':
        case 'A':
          // Not implemented because there are no specs for this field type.
          #{raise NotImplementedError, '`A` and `a` format field types are not implemented in Opal yet'}

        case 'c':
          arg = GET_ARG();
          if (#{`arg`.respond_to?(:to_ary)}) { arg = #{`arg`.to_ary}[0]; }
          if (#{`arg`.respond_to?(:to_str)}) {
            str = #{`arg`.to_str};
          } else {
            str = String.fromCharCode(#{Opal.coerce_to(`arg`, Integer, :to_int)});
          }
          if (str.length !== 1) {
            #{raise ArgumentError, '%c requires a character'}
          }
          if (flags&FMINUS) {
            while (str.length < width) { str = str + ' '; }
          } else {
            while (str.length < width) { str = ' ' + str; }
          }
          break format_sequence;

        case 'p':
          str = #{`GET_ARG()`.inspect};
          if (precision !== -1) { str = str.slice(0, precision); }
          if (flags&FMINUS) {
            while (str.length < width) { str = str + ' '; }
          } else {
            while (str.length < width) { str = ' ' + str; }
          }
          break format_sequence;

        case 's':
          str = #{`GET_ARG()`.to_s};
          if (precision !== -1) { str = str.slice(0, precision); }
          if (flags&FMINUS) {
            while (str.length < width) { str = str + ' '; }
          } else {
            while (str.length < width) { str = ' ' + str; }
          }
          break format_sequence;

        default:
          #{raise ArgumentError, "malformed format string - %#{`format_string.charAt(i)`}"}
        }
      }

      if (str === undefined) {
        #{raise ArgumentError, 'malformed format string - %'}
      }

      result += format_string.slice(begin_slice, end_slice) + str;
      begin_slice = i + 1;
    }

    if (#{$DEBUG} && pos_arg_num >= 0 && seq_arg_num < args.length) {
      #{raise ArgumentError, 'too many arguments for format string'}
    }

    return result + format_string.slice(begin_slice);
  }
end

#freeze ⇒ Object

# File 'opal/opal/corelib/unsupported.rb', line 93

def freeze
  if `OPAL_CONFIG.freezing`
    `warn(ERROR)`
  else
    raise NotImplementedError, `ERROR`
  end

  self
end

#frozen? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/unsupported.rb', line 103

def frozen?
  if `OPAL_CONFIG.freezing`
    `warn(ERROR)`
  else
    raise NotImplementedError, `ERROR`
  end

  false
end

#Hash(arg) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 942

def Hash(arg)
  return {} if arg.nil? || arg == []
  return arg if Hash === arg
  return Opal.coerce_to!(arg, Hash, :to_hash)
end

#hash ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 751

def hash
  __id__
end

#initialize_clone(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 148

def initialize_clone(other)
  initialize_copy(other)
end

#initialize_copy(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 755

def initialize_copy(other)
end

#initialize_dup(other) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 165

def initialize_dup(other)
  initialize_copy(other)
end

#inspect ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 758

def inspect
  to_s
end

#instance_of?(klass) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 762

def instance_of?(klass)
  %x{
    if (!klass.$$is_class && !klass.$$is_module) {
      #{raise TypeError, 'class or module required'};
    }

    return self.$$class === klass;
  }
end

#instance_variable_defined?(name) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 772

def instance_variable_defined?(name)
  name = Opal.instance_variable_name!(name)

  `Opal.hasOwnProperty.call(self, name.substr(1))`
end

#instance_variable_get(name) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 778

def instance_variable_get(name)
  name = Opal.instance_variable_name!(name)

  %x{
    var ivar = self[Opal.ivar(name.substr(1))];

    return ivar == null ? nil : ivar;
  }
end

#instance_variable_set(name, value) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 788

def instance_variable_set(name, value)
  name = Opal.instance_variable_name!(name)

  `self[Opal.ivar(name.substr(1))] = value`
end

#instance_variables ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 810

def instance_variables
  %x{
    var result = [], ivar;

    for (var name in self) {
      if (self.hasOwnProperty(name) && name.charAt(0) !== '$') {
        if (name.substr(-1) === '$') {
          ivar = name.slice(0, name.length - 1);
        } else {
          ivar = name;
        }
        result.push('@' + ivar);
      }
    }

    return result;
  }
end

#Integer(value, base = undefined) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 829

def Integer(value, base = undefined)
  %x{
    var i, str, base_digits;

    if (!value.$$is_string) {
      if (base !== undefined) {
        #{raise ArgumentError, "base specified for non string value"}
      }
      if (value === nil) {
        #{raise TypeError, "can't convert nil into Integer"}
      }
      if (value.$$is_number) {
        if (value === Infinity || value === -Infinity || isNaN(value)) {
          #{raise FloatDomainError, value}
        }
        return Math.floor(value);
      }
      if (#{value.respond_to?(:to_int)}) {
        i = #{value.to_int};
        if (i !== nil) {
          return i;
        }
      }
      return #{Opal.coerce_to!(value, Integer, :to_i)};
    }

    if (base === undefined) {
      base = 0;
    } else {
      base = #{Opal.coerce_to(`base`, Integer, :to_int)};
      if (base === 1 || base < 0 || base > 36) {
        #{raise ArgumentError, "invalid radix #{base}"}
      }
    }

    str = value.toLowerCase();

    str = str.replace(/(\d)_(?=\d)/g, '$1');

    str = str.replace(/^(\s*[+-]?)(0[bodx]?)/, function (_, head, flag) {
      switch (flag) {
      case '0b':
        if (base === 0 || base === 2) {
          base = 2;
          return head;
        }
      case '0':
      case '0o':
        if (base === 0 || base === 8) {
          base = 8;
          return head;
        }
      case '0d':
        if (base === 0 || base === 10) {
          base = 10;
          return head;
        }
      case '0x':
        if (base === 0 || base === 16) {
          base = 16;
          return head;
        }
      }
      #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
    });

    base = (base === 0 ? 10 : base);

    base_digits = '0-' + (base <= 10 ? base - 1 : '9a-' + String.fromCharCode(97 + (base - 11)));

    if (!(new RegExp('^\\s*[+-]?[' + base_digits + ']+\\s*$')).test(str)) {
      #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
    }

    i = parseInt(str, base);

    if (isNaN(i)) {
      #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
    }

    return i;
  }
end

#is_a?(klass) ⇒ Boolean Also known as: kind_of?

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 948

def is_a?(klass)
  %x{
    if (!klass.$$is_class && !klass.$$is_module) {
      #{raise TypeError, 'class or module required'};
    }

    return Opal.is_a(self, klass);
  }
end

#lambda(&block) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 960

def lambda(&block)
  `block.$$is_lambda = true`

  block
end

#load(file) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 966

def load(file)
  file = Opal.coerce_to!(file, String, :to_str)
  `Opal.load(#{file})`
end

#loop(&block) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 971

def loop(&block)
  %x{
    while (true) {
      if (block() === $breaker) {
        return $breaker.$v;
      }
    }
  }

  self
end

#method(name) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 33

def method(name)
  %x{
    var meth = self['$' + name];

    if (!meth || meth.$$stub) {
      #{raise NameError.new("undefined method `#{name}' for class `#{self.class}'", name)};
    }

    return #{Method.new(self, `meth`, name)};
  }
end

#methods(all = true) ⇒ Object Also known as: public_methods

# File 'opal/opal/corelib/kernel.rb', line 45

def methods(all = true)
  %x{
    var methods = [];

    for (var key in self) {
      if (key[0] == "$" && typeof(self[key]) === "function") {
        if (all == false || all === nil) {
          if (!Opal.hasOwnProperty.call(self, key)) {
            continue;
          }
        }
        if (self[key].$$stub === undefined) {
          methods.push(key.substr(1));
        }
      }
    }

    return methods;
  }
end

#nil? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 983

def nil?
  false
end

#p(*args) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1010

def p(*args)
  args.each { |obj| $stdout.puts obj.inspect }

  args.length <= 1 ? args[0] : args
end

#print(*strs) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1016

def print(*strs)
  $stdout.print(*strs)
end

#printf(*args) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 989

def printf(*args)
  if args.length > 0
    print format(*args)
  end

  nil
end

#private_methods ⇒ Object Also known as: private_instance_methods

# File 'opal/opal/corelib/unsupported.rb', line 204

def private_methods(*)
  []
end

#proc(&block) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 997

def proc(&block)
  unless block
    raise ArgumentError, "tried to create Proc object without a block"
  end

  `block.$$is_lambda = false`
  block
end

#puts(*strs) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1006

def puts(*strs)
  $stdout.puts(*strs)
end

#raise(exception = undefined, string = nil, _backtrace = nil) ⇒ Object Also known as: fail

# File 'opal/opal/corelib/kernel.rb', line 1024

def raise(exception = undefined, string = nil, _backtrace = nil)
  %x{
    if (exception == null && #$! !== nil) {
      throw #$!;
    }
    if (exception == null) {
      exception = #{RuntimeError.new};
    }
    else if (exception.$$is_string) {
      exception = #{RuntimeError.new exception};
    }
    // using respond_to? and not an undefined check to avoid method_missing matching as true
    else if (exception.$$is_class && #{exception.respond_to?(:exception)}) {
      exception = #{exception.exception string};
    }
    else if (#{exception.kind_of?(Exception)}) {
      // exception is fine
    }
    else {
      exception = #{TypeError.new 'exception class/object expected'};
    }

    if (#$! !== nil) {
      Opal.exceptions.push(#$!);
    }

    #$! = exception;

    throw exception;
  }
end

#rand(max = undefined) ⇒ Object Also known as: srand

# File 'opal/opal/corelib/kernel.rb', line 1058

def rand(max = undefined)
  %x{
    if (max === undefined) {
      return Math.random();
    }
    else if (max.$$is_range) {
      var min = max.begin, range = max.end - min;
      if(!max.exclude) range++;

      return self.$rand(range) + min;
    }
    else {
      return Math.floor(Math.random() *
        Math.abs(#{Opal.coerce_to max, Integer, :to_int}));
    }
  }
end

#Rational(numerator, denominator = 1) ⇒ Object

# File 'opal/opal/corelib/rational.rb', line 358

def Rational(numerator, denominator = 1)
  Rational.convert(numerator, denominator)
end

#remove_instance_variable(name) ⇒ Object

Raises:

• (NameError)

# File 'opal/opal/corelib/kernel.rb', line 794

def remove_instance_variable(name)
  name = Opal.instance_variable_name!(name)

  %x{
    var key = Opal.ivar(name.substr(1)),
        val;
    if (self.hasOwnProperty(key)) {
      val = self[key];
      delete self[key];
      return val;
    }
  }

  raise NameError, "instance variable #{name} not defined"
end

#require(file) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1094

def require(file)
  file = Opal.coerce_to!(file, String, :to_str)
  `Opal.require(#{file})`
end

#require_relative(file) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1099

def require_relative(file)
  Opal.try_convert!(file, String, :to_str)
  file = File.expand_path File.join(`Opal.current_file`, '..', file)

  `Opal.require(#{file})`
end

#require_tree(path) ⇒ Object

path should be the full path to be found in registered modules (Opal.modules)

# File 'opal/opal/corelib/kernel.rb', line 1107

def require_tree(path)
  path = File.expand_path(path)
  path = '' if path == '.'

  %x{
    for (var name in Opal.modules) {
      if (#{`name`.start_with?(path)}) {
        Opal.require(name);
      }
    }
  }

  nil
end

#respond_to?(name, include_all = false) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 1076

def respond_to?(name, include_all = false)
  return true if respond_to_missing?(name, include_all)

  %x{
    var body = self['$' + name];

    if (typeof(body) === "function" && !body.$$stub) {
      return true;
    }
  }

  false
end

#respond_to_missing?(method_name, include_all = false) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/kernel.rb', line 1090

def respond_to_missing?(method_name, include_all = false)
  false
end

#singleton_class ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1125

def singleton_class
  `Opal.get_singleton_class(self)`
end

#sleep(seconds = nil) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1129

def sleep(seconds = nil)
  %x{
    if (seconds === nil) {
      #{raise TypeError, "can't convert NilClass into time interval"}
    }
    if (!seconds.$$is_number) {
      #{raise TypeError, "can't convert #{seconds.class} into time interval"}
    }
    if (seconds < 0) {
      #{raise ArgumentError, "time interval must be positive"}
    }
    var t = new Date();
    while (new Date() - t <= seconds * 1000);
    return seconds;
  }
end

#String(str) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1150

def String(str)
  Opal.coerce_to?(str, String, :to_str) ||
    Opal.coerce_to!(str, String, :to_s)
end

#taint ⇒ Object

# File 'opal/opal/corelib/unsupported.rb', line 117

def taint
  if `OPAL_CONFIG.tainting`
    `warn(ERROR)`
  else
    raise NotImplementedError, `ERROR`
  end

  self
end

#tainted? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/unsupported.rb', line 137

def tainted?
  if `OPAL_CONFIG.tainting`
    `warn(ERROR)`
  else
    raise NotImplementedError, `ERROR`
  end

  false
end

#tap {|_self| ... } ⇒ Object

Yields:

• (_self)

Yield Parameters:

• _self (Kernel) —

  the object that the method was called on

# File 'opal/opal/corelib/kernel.rb', line 1155

def tap(&block)
  yield self
  self
end

#throw(*args) ⇒ Object

Raises:

• (UncaughtThrowError)

# File 'opal/opal/corelib/kernel.rb', line 1175

def throw(*args)
  raise UncaughtThrowError.new(args)
end

#to_proc ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1160

def to_proc
  self
end

#to_s ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1164

def to_s
  "#<#{self.class}:0x#{__id__.to_s(16)}>"
end

#untaint ⇒ Object

# File 'opal/opal/corelib/unsupported.rb', line 127

def untaint
  if `OPAL_CONFIG.tainting`
    `warn(ERROR)`
  else
    raise NotImplementedError, `ERROR`
  end

  self
end

#warn(*strs) ⇒ Object

# File 'opal/opal/corelib/kernel.rb', line 1020

def warn(*strs)
  $stderr.puts(*strs) unless $VERBOSE.nil? || strs.empty?
end