Module: Kernel

Defined in:
opal/stdlib/pp.rb,
opal/stdlib/await.rb,
opal/stdlib/native.rb,
opal/stdlib/open-uri.rb,
opal/stdlib/pathname.rb,
opal/stdlib/bigdecimal.rb,
opal/stdlib/opal-parser.rb,
opal/stdlib/nodejs/kernel.rb,
opal/stdlib/nodejs/require.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.open(name, *rest, &block) ⇒ Object

Allows the opening of various resources including URIs.

If the first argument responds to the 'open' method, 'open' is called on it with the rest of the arguments.

If the first argument is a string that begins with xxx://, it is parsed by URI.parse. If the parsed object responds to the 'open' method, 'open' is called on it with the rest of the arguments.

Otherwise, the original Kernel#open is called.

OpenURI::OpenRead#open provides URI::HTTP#open, URI::HTTPS#open and URI::FTP#open, Kernel#open.

We can accept URIs and strings that begin with http://, https:// and ftp://. In these cases, the opened file object is extended by OpenURI::Meta.



32
33
34
35
36
37
38
 
# File 'opal/stdlib/open-uri.rb', line 32

def open(name, *rest, &block) # :doc:
  if name.respond_to?(:to_str) && %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ name
    OpenURI.open_uri(name, *rest, &block)
  else
    open_uri_original_open(name, *rest, &block)
  end
end

.open_uri_original_open ⇒ Object

:nodoc:



13
 
# File 'opal/stdlib/open-uri.rb', line 13

alias open_uri_original_open open

.pp(*objs) ⇒ Object

prints arguments in pretty form.

pp returns argument(s).



610
611
612
613
614
615
 
# File 'opal/stdlib/pp.rb', line 610

def pp(*objs)
  objs.each {|obj|
    PP.pp(obj)
  }
  objs.size <= 1 ? objs.first : objs
end

Instance Method Details

#__prepare_require__(path) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'opal/stdlib/nodejs/require.rb', line 6

def __prepare_require__(path)
  name = `Opal.normalize(#{path})`
  full_path = name.end_with?('.rb') ? name : name + '.rb'

  if `!Opal.modules[#{name}]`
    ruby = File.read(full_path)
    compiler = Opal::Compiler.new(ruby, requirable: true, file: name)
    js = compiler.compile
    compiler.requires.each do |sub_path|
      __prepare_require__(sub_path)
    end
    `eval(#{js})`
  end

  name
rescue => e
  raise [path, name, full_path].inspect + e.message
end

#_Array ⇒ Object 



245
 
# File 'opal/stdlib/native.rb', line 245

alias _Array Array

#`(cmdline) ⇒ Object 



33
34
35
 
# File 'opal/stdlib/nodejs/kernel.rb', line 33

def `(cmdline)
  Buffer.new(`__child_process__.execSync(#{cmdline})`).to_s.encode('UTF-8')
end

#Array(object, *args, &block) ⇒ Object

Wraps array-like JavaScript objects in Native::Array



248
249
250
251
252
253
 
# File 'opal/stdlib/native.rb', line 248

def Array(object, *args, &block)
  if native?(object)
    return Native::Array.new(object, *args, &block).to_a
  end
  _Array(object)
end

#BigDecimal(initial, digits = 0) ⇒ Object 



9
10
11
12
13
 
# File 'opal/stdlib/bigdecimal.rb', line 9

def BigDecimal(initial, digits = 0)
  bigdecimal = BigDecimal.allocate
  bigdecimal.initialize(initial, digits)
  bigdecimal
end

#eval(str, binding = nil, file = nil, line = nil) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'opal/stdlib/opal-parser.rb', line 12

def eval(str, binding = nil, file = nil, line = nil)
  str = ::Opal.coerce_to!(str, String, :to_str)
  default_eval_options = { file: file || '(eval)', eval: true }
  compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
  compiler = Opal::Compiler.new(str, compiling_options)
  code = compiler.compile
  code += compiler.source_map.to_data_uri_comment unless compiling_options[:no_source_map]
  if binding
    binding.js_eval(code)
  else
    %x{
      return (function(self) {
        return eval(#{code});
      })(self)
    }
  end
end

#exit(status = true) ⇒ Object

Overwrite Kernel.exit to be async-capable.



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'opal/stdlib/await.rb', line 40

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

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

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

    Opal.exit(status);
  }
  nil
end

#load(path) ⇒ Object 



29
30
31
 
# File 'opal/stdlib/nodejs/require.rb', line 29

def load(path)
  `Opal.load(#{__prepare_require__(path)})`
end

#Native(obj) ⇒ Native::Object, ...

Wraps a native JavaScript with Native::Object.new

Returns:

  • (Native::Object) —

    The wrapped object if it is native

  • (nil) —

    for null and undefined

  • (obj) —

    The object itself if it's not native



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'opal/stdlib/native.rb', line 227

def Native(obj)
  if `#{obj} == null`
    nil
  elsif native?(obj)
    Native::Object.new(obj)
  elsif obj.is_a?(Array)
    obj.map do |o|
      Native(o)
    end
  elsif obj.is_a?(Proc)
    proc do |*args, &block|
      Native(obj.call(*args, &block))
    end
  else
    obj
  end
end

#native?(value) ⇒ Boolean

Returns:



218
219
220
 
# File 'opal/stdlib/native.rb', line 218

def native?(value)
  `value == null || !value.$$class`
end

#Pathname(path) ⇒ Object 



224
225
226
 
# File 'opal/stdlib/pathname.rb', line 224

def Pathname(path)
  Pathname.new(path)
end

#pretty_inspect ⇒ Object

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.



603
604
605
 
# File 'opal/stdlib/pp.rb', line 603

def pretty_inspect
  PP.pp(self, StringIO.new).string
end

#require(path) ⇒ Object 



25
26
27
 
# File 'opal/stdlib/nodejs/require.rb', line 25

def require(path)
  `Opal.require(#{__prepare_require__(path)})`
end

#require_remote(url) ⇒ Object 



30
31
32
33
34
35
36
37
 
# File 'opal/stdlib/opal-parser.rb', line 30

def require_remote(url)
  %x{
    var r = new XMLHttpRequest();
    r.open("GET", url, false);
    r.send('');
  }
  eval `r.responseText`
end

#sleep(seconds) ⇒ Object 



60
61
62
63
64
 
# File 'opal/stdlib/await.rb', line 60

def sleep(seconds)
  prom = PromiseV2.new
  `setTimeout(#{proc { prom.resolve }}, #{seconds * 1000})`
  prom
end

#system(*argv, exception: false) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'opal/stdlib/nodejs/kernel.rb', line 10

def system(*argv, exception: false)
  env = {}
  env = argv.shift if argv.first.is_a? Hash
  env = ENV.merge(env).to_n
  cmdname = argv.shift

  out = if argv.empty?
          `__child_process__.spawnSync(#{cmdname}, { shell: true, stdio: 'inherit', env: #{env} })`
        elsif Array === cmdname
          `__child_process__.spawnSync(#{cmdname[0]}, #{argv}, { argv0: #{cmdname[1]}, stdio: 'inherit', env: #{env} })`
        else
          `__child_process__.spawnSync(#{cmdname}, #{argv}, { stdio: 'inherit', env: #{env} })`
        end

  status = out.JS[:status]
  status = 127 if `status === null`
  pid = out.JS[:pid]

  $? = Process::Status.new(status, pid)
  raise "Command failed with exit #{status}: #{cmdname}" if exception && status != 0
  status == 0
end