Module: Kernel

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

Constant Summary

NODE_REQUIRE = 
`require`

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.



29
30
31
32
33
34
35
 
# File 'opal/stdlib/open-uri.rb', line 29

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:



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

alias open_uri_original_open open

.pp(*objs) ⇒ Object 



6
7
8
9
10
11
 
# File 'opal/stdlib/pp.rb', line 6

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

Instance Method Details

#__prepare_require__(path) ⇒ Object 



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

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 



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

alias _Array Array

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

Wraps array-like JavaScript objects in Native::Array



245
246
247
248
249
250
 
# File 'opal/stdlib/native.rb', line 245

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 



2
3
4
 
# File 'opal/stdlib/bigdecimal/kernel.rb', line 2

def BigDecimal(initial, digits = 0)
  BigDecimal.new(initial, digits)
end

#caller(*args) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'opal/stdlib/nodejs/kernel.rb', line 6

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

#eval(str) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
 
# File 'opal/stdlib/opal-parser.rb', line 9

def eval(str)
  str = Opal.coerce_to!(str, String, :to_str)
  default_eval_options = { file: '(eval)', eval: true }
  compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
  code = Opal.compile str, compiling_options
  %x{
    return (function(self) {
      return eval(#{code});
    })(self)
  }
end

#load(path) ⇒ Object 



27
28
29
 
# File 'opal/stdlib/nodejs/require.rb', line 27

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



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

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:



215
216
217
 
# File 'opal/stdlib/native.rb', line 215

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

#node_require(path) ⇒ Object

Deprecated.

Please use require('module') instead



20
21
22
23
 
# File 'opal/stdlib/nodejs/kernel.rb', line 20

def node_require(path)
  warn '[DEPRECATION] node_require is deprecated. Please use `require(\'module\')` instead.'
  `#{NODE_REQUIRE}(#{path.to_str})`
end

#Pathname(path) ⇒ Object 



219
220
221
 
# File 'opal/stdlib/pathname.rb', line 219

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

#pretty_inspect ⇒ Object 



2
3
4
 
# File 'opal/stdlib/pp.rb', line 2

def pretty_inspect
  inspect
end

#require(path) ⇒ Object 



23
24
25
 
# File 'opal/stdlib/nodejs/require.rb', line 23

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

#require_remote(url) ⇒ Object 



21
22
23
24
25
26
27
28
 
# File 'opal/stdlib/opal-parser.rb', line 21

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