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,
opal/opal/corelib/kernel/format.rb more...

Overview

helpers: coerce_to

Instance Method Summary

• #!~(obj) ⇒ Object
• #<=>(other) ⇒ Object
• #===(other) ⇒ Object
• #=~(obj) ⇒ Object
• #Array(object) ⇒ Object
• #at_exit(&block) ⇒ Object
• #caller(start = 1, length = nil) ⇒ Object
• #catch(sym) ⇒ Object
• #class ⇒ Object
• #clone(freeze: true) ⇒ 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 ⇒ Object
• #Hash(arg) ⇒ 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?)
• #itself ⇒ Object
• #lambda(&block) ⇒ Object
• #load(file) ⇒ Object
• #loop ⇒ Object
• #method(name) ⇒ Object
• #method_missing(symbol, *args, &block) ⇒ Object
• #methods(all = true) ⇒ Object
• #nil? ⇒ Boolean
• #open(*args, &block) ⇒ Object

  basic implementation of open, delegate to File.open.

• #p(*args) ⇒ Object
• #print(*strs) ⇒ Object
• #printf(*args) ⇒ Object
• #private_methods ⇒ Object (also: #private_instance_methods)
• #proc(&block) ⇒ Object
• #public_methods(all = true) ⇒ Object
• #puts(*strs) ⇒ Object
• #raise(exception = undefined, string = nil, _backtrace = nil) ⇒ Object (also: #fail)
• #rand(max = undefined) ⇒ Object
• #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
• #srand(seed = Random.new_seed) ⇒ Object
• #String(str) ⇒ Object
• #taint ⇒ Object
• #tainted? ⇒ Boolean
• #tap {|_self| ... } ⇒ Object
• #throw(*args) ⇒ Object
• #to_proc ⇒ Object
• #to_s ⇒ Object
• #untaint ⇒ Object
• #warn(*strs, uplevel: nil) ⇒ Object
• #yield_self {|_self| ... } ⇒ Object (also: #then)

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 4

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 12

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

#<=>(other) ⇒ Object

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

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 16

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

#=~(obj) ⇒ Object

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

def =~(obj)
  false
end

#Array(object) ⇒ Object

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

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 89

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

#caller(start = 1, length = nil) ⇒ Object

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

def caller(start = 1, length = nil)
  %x{
    var stack, result

    stack = (new Error().stack || "").split("\n")
    result = []

    // Skip the initial line ("Error:") and Kernel#caller with i=3
    for (var i = 3, ii = stack.length; i < ii; i++) {
      if (!stack[i].match("runtime.js")) {
        result.push(stack[i].replace(/^ *\w+ +/, ''))
        if (length && result.length == length) break
      }
    }
    return result
  }
end

#catch(sym) ⇒ Object

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

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 113

def class
  `self.$$class`
end

#clone(freeze: true) ⇒ Object

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

def clone(freeze: true)
  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 295

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 117

def copy_instance_variables(other)
  %x{
    var keys = Object.keys(other), i, ii, name;
    for (i = 0, ii = keys.length; i < ii; i++) {
      name = keys[i];
      if (name.charAt(0) !== '$' && other.hasOwnProperty(name)) {
        self[name] = other[name];
      }
    }
  }
end

#copy_singleton_methods(other) ⇒ Object

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

def copy_singleton_methods(other)
  %x{
    var i, name, names, length;

    if (other.hasOwnProperty('$$meta')) {
      var other_singleton_class = Opal.get_singleton_class(other);
      var self_singleton_class = Opal.get_singleton_class(self);
      names = Object.getOwnPropertyNames(other_singleton_class.$$prototype);

      for (i = 0, length = names.length; i < length; i++) {
        name = names[i];
        if (Opal.is_method(name)) {
          self_singleton_class.$$prototype[name] = other_singleton_class.$$prototype[name];
        }
      }

      self_singleton_class.$$const = Object.assign({}, other_singleton_class.$$const);
      Object.setPrototypeOf(
        self_singleton_class.$$prototype,
        Object.getPrototypeOf(other_singleton_class.$$prototype)
      );
    }

    for (i = 0, names = Object.getOwnPropertyNames(other), length = names.length; i < length; i++) {
      name = names[i];
      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 175

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 179

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 192

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 198

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

#eval ⇒ Object

Raises:

• (NotImplementedError)

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

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 202

def exit(status = true)
  $__at_exit__ ||= []

  until $__at_exit__.empty?
    block = $__at_exit__.pop
    block.call
  end

  %x{
    if (status.$$is_boolean) {
      status = status ? 0 : 1;
    } else {
      status = $coerce_to(status, #{Integer}, 'to_int')
    }

    Opal.exit(status);
  }
  nil
end

#extend(*mods) ⇒ Object

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

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`.extend_object self};
      #{`mod`.extended self};
    }
  }

  self
end

#Float(value) ⇒ Object

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

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/format.rb', line 4

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($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 126

def freeze
  `handle_unsupported_feature(ERROR)`
  self
end

#frozen? ⇒ Boolean

Returns:

• (Boolean)

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

def frozen?
  `handle_unsupported_feature(ERROR)`
  false
end

#hash ⇒ Object

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

def hash
  __id__
end

#Hash(arg) ⇒ Object

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

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

#initialize_clone(other) ⇒ Object

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

def initialize_clone(other)
  initialize_copy(other)
end

#initialize_copy(other) ⇒ Object

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

def initialize_copy(other)
end

#initialize_dup(other) ⇒ Object

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

def initialize_dup(other)
  initialize_copy(other)
end

#inspect ⇒ Object

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

def inspect
  to_s
end

#instance_of?(klass) ⇒ Boolean

Returns:

• (Boolean)

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

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 263

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 269

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 279

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 301

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 320

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 (value === "0") {
      return 0;
    }

    if (base === undefined) {
      base = 0;
    } else {
      base = $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 443

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

#itself ⇒ Object

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

def itself
  self
end

#lambda(&block) ⇒ Object

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

def lambda(&block)
  `Opal.lambda(block)`
end

#load(file) ⇒ Object

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

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

#loop ⇒ Object

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

def loop
  return enum_for(:loop) { Float::INFINITY } unless block_given?

  while true
    begin
      yield
    rescue StopIteration => e
      return e.result
    end
  end

  self
end

#method(name) ⇒ Object

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

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.$$owner || #{self.class}`, `meth`, name)};
  }
end

#methods(all = true) ⇒ Object

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

def methods(all = true)
  %x{
    if ($truthy(#{all})) {
      return Opal.methods(self);
    } else {
      return Opal.own_methods(self);
    }
  }
end

#nil? ⇒ Boolean

Returns:

• (Boolean)

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

def nil?
  false
end

#open(*args, &block) ⇒ Object

basic implementation of open, delegate to File.open

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

def open(*args, &block)
  File.open(*args, &block)
end

#p(*args) ⇒ Object

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

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 515

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

#printf(*args) ⇒ Object

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

def printf(*args)
  if args.any?
    print format(*args)
  end

  nil
end

#private_methods ⇒ Object Also known as: private_instance_methods

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

def private_methods(*)
  []
end

#proc(&block) ⇒ Object

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

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

  `block.$$is_lambda = false`
  block
end

#public_methods(all = true) ⇒ Object

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

def public_methods(all = true)
  %x{
    if ($truthy(#{all})) {
      return Opal.methods(self);
    } else {
      return Opal.receiver_methods(self);
    }
  }
end

#puts(*strs) ⇒ Object

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

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 531

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.is_a?(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

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

def rand(max = undefined)
  %x{
    if (max === undefined) {
      return #{Random::DEFAULT.rand};
    }

    if (max.$$is_number) {
      if (max < 0) {
        max = Math.abs(max);
      }

      if (max % 1 !== 0) {
        max = max.$to_i();
      }

      if (max === 0) {
        max = undefined;
      }
    }
  }
  Random::DEFAULT.rand(max)
end

#Rational(numerator, denominator = 1) ⇒ Object

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

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

#remove_instance_variable(name) ⇒ Object

Raises:

• (NameError)

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

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 610

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 615

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 623

def require_tree(path)
  %x{
    var result = [];

    path = #{File.expand_path(path)}
    path = Opal.normalize(path);
    if (path === '.') path = '';
    for (var name in Opal.modules) {
      if (#{`name`.start_with?(path)}) {
        result.push([name, Opal.require(name)]);
      }
    }

    return result;
  }
end

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

Returns:

• (Boolean)

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

def respond_to?(name, include_all = false)
  %x{
    var body = self['$' + name];

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

    if (self['$respond_to_missing?'].$$pristine === true) {
      return false;
    } else {
      return #{respond_to_missing?(name, include_all)};
    }
  }
end

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

Returns:

• (Boolean)

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

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

#singleton_class ⇒ Object

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

def singleton_class
  `Opal.get_singleton_class(self)`
end

#sleep(seconds = nil) ⇒ Object

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

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 get_time = Opal.global.performance ?
      function() {return performance.now()} :
      function() {return new Date()}

    var t = get_time();
    while (get_time() - t <= seconds * 1000);
    return Math.round(seconds);
  }
end

#srand(seed = Random.new_seed) ⇒ Object

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

def srand(seed = Random.new_seed)
  Random.srand(seed)
end

#String(str) ⇒ Object

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

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 140

def taint
  `handle_unsupported_feature(ERROR)`
  self
end

#tainted? ⇒ Boolean

Returns:

• (Boolean)

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

def tainted?
  `handle_unsupported_feature(ERROR)`
  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 677

def tap(&block)
  yield self
  self
end

#throw(*args) ⇒ Object

Raises:

• (UncaughtThrowError)

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

def throw(*args)
  raise UncaughtThrowError, args
end

#to_proc ⇒ Object

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

def to_proc
  self
end

#to_s ⇒ Object

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

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

#untaint ⇒ Object

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

def untaint
  `handle_unsupported_feature(ERROR)`
  self
end

#warn(*strs, uplevel: nil) ⇒ Object

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

def warn(*strs, uplevel: nil)
  if uplevel
    uplevel = Opal.coerce_to!(uplevel, Integer, :to_str)
    raise ArgumentError, "negative level (#{uplevel})" if uplevel < 0
    location = caller(uplevel + 2, 1).first
    location = "#{location}: " if location
    strs = strs.map { |s| "#{location}warning: #{s}" }
  end

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

#yield_self {|_self| ... } ⇒ Object Also known as: then

Yields:

• (_self)

Yield Parameters:

• _self (Kernel) —

  the object that the method was called on

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

def yield_self
  return enum_for(:yield_self) { 1 } unless block_given?
  yield self
end