opal 0.2.2 → 0.3.0

data/gems/core/lib/core/kernel.rb

@@ -0,0 +1,240 @@
+module Kernel
+  # Repeatedly executes the given block.
+  #
+  # @example
+  #
+  #     loop do
+  #       puts "this will infinetly repeat"
+  #     end
+  #
+  # @return [Object] returns the receiver.
+  def loop
+    `while (true) {
+      try {
+        #{yield};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e['@exit_value'];
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Simple equivalent to `Proc.new`. Returns a new proc from the given block.
+  #
+  # @example
+  #
+  #     proc { puts "a" }
+  #     # => #<Proc 02002>
+  #
+  # @return [Proc]
+  def proc(&block)
+    raise ArgumentError, "block required" unless block_given?
+    block
+  end
+
+  def lambda(&block)
+    raise ArgumentError, "block required" unless block_given?
+    block
+  end
+
+  # Raises an exception. If given a string, this method will raise a
+  # RuntimeError with the given string as a message. Otherwise, if the first
+  # parameter is a subclass of Exception, then the method will raise a new
+  # instance of the given exception class with the string as a message, if it
+  # exists, or a fdefault message otherwise.
+  #
+  # @example String message
+  #
+  #     raise "some error"
+  #     # => RuntimeError: some error
+  #
+  # @example Exception subclass
+  #
+  #     raise StandardError, "something went wrong"
+  #     # => StandardError: something went wrong
+  #
+  # @param [Exception, String] exception
+  # @param [String]
+  # @return [nil]
+  def raise(exception, string = nil)
+    `var msg = nil, exc;
+
+    if (typeof exception == 'string') {
+      msg = exception;
+      exc = #{RuntimeError.new `msg`};
+    } else if (#{`exception`.kind_of? Exception}.$r) {
+      exc = exception;
+    } else {
+      if (string != nil) msg = string;
+      exc = #{`exception`.new `msg`};
+    }
+    VM.raise(exc);`
+  end
+
+  def fail(exception, string = nil)
+    raise exception, string
+  end
+
+  def instance_variable_defined?(name)
+    `name = #{name.to_s};
+    return self[name] == undefined ? Qfalse : Qtrue;`
+  end
+
+  def instance_variable_get(name)
+    `name = #{name.to_s};
+    return self[name] == undefined ? nil : self[name];`
+  end
+
+  def instance_variable_set(name, value)
+    `name = #{name.to_s};
+    return self[name] = value;`
+  end
+
+  # Returns `true` if a block was given to the current method, `false`
+  # otherwise.
+  #
+  # @NOTE: In opal, this is actually a fake method. block_given? is inlined
+  # for efficiency and implementation details.
+  #
+  # @return [true, false]
+  def block_given?
+    false
+  end
+
+  def method_missing(sym, *args)
+    raise NoMethodError, "undefined method `#{sym}` for #{self.inspect}"
+  end
+
+  def to_a
+    [self]
+  end
+
+  def tap
+    raise LocalJumpError, "no block given" unless block_given?
+    yield self
+    self
+  end
+
+  def kind_of?(klass)
+    `var search = self.$klass;
+
+    while (search) {
+      if (search == klass) {
+        return Qtrue;
+      }
+
+      search = search.$super;
+    }
+
+    return Qfalse;`
+  end
+
+  def is_a?(klass)
+    kind_of? klass
+  end
+
+  def nil?
+    false
+  end
+
+  # Returns `true` if the method with the given id exists on the receiver,
+  # `false` otherwise.
+  #
+  # Implementation Details
+  # ----------------------
+  # Opals' internals are constructed so that when a method is initially called,
+  # a fake method is created on the root basic object, so that any subsequent
+  # calls to that method on an object that has not defined it, will yield a
+  # method_missing behaviour. For this reason, fake methods are tagged with a
+  # `.$rbMM` property so that they will not be counted when this method checks
+  # if a given method has been defined.
+  #
+  # @param [String, Symbol] method_id
+  # @return [Boolean]
+  def respond_to?(method_id)
+    `var method = self.$m[#{`method_id`.to_s}];
+
+    if (method && !method.$rbMM) {
+      return Qtrue;
+    }
+
+    return Qfalse;`
+  end
+
+  def ===(other)
+    self == other
+  end
+
+  def __send__(method_id, *args)
+    `args.unshift(self);
+    return self.$m[#{method_id.to_s}].apply(self, args);`
+  end
+
+  def send(method_id, *args)
+    __send__ method_id, *args
+  end
+
+  def class
+    `return VM.class_real(self.$klass);`
+  end
+
+  # Returns a random number. If max is `nil`, then the result is 0. Otherwise
+  # returns a random number between 0 and max.
+  #
+  # @example
+  #
+  #     rand        # => 0.918378392234
+  #     rand        # => 0.283842929289
+  #     rand 10     # => 9
+  #     rand 100    # => 21
+  #
+  # @param [Numeric] max
+  # @return [Numeric]
+  def rand(max = `undefined`)
+    `if (max != undefined)
+        return Math.floor(Math.random() * max);
+    else
+      return Math.random();`
+  end
+
+  def __id__
+    `return self.$hash();`
+  end
+
+  def object_id
+    `return self.$hash();`
+  end
+
+  # Returns a simple string representation of the receiver object. The id shown in the string
+  # is not just the object_id, but it is mangled to resemble the format output by ruby, which
+  # is basically a hex number.
+  #
+  # FIXME: proper hex output needed
+  def to_s
+    "#<#{`VM.class_real(self.$klass)`}:0x#{`(self.$hash() * 400487).toString(16)`}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def instance_eval(&block)
+    `block(self)` if block_given?
+    self
+  end
+
+  def const_set(name, value)
+    `return rb_const_set(VM.class_real(self.$klass), name, value);`
+  end
+
+  def const_defined?(name)
+    false
+  end
+end
+

data/gems/core/lib/core/module.rb

@@ -0,0 +1,98 @@
+
+class Module
+
+  def name
+    `return self.__classid__;`
+  end
+
+  def ===(obj)
+    obj.kind_of? self
+  end
+
+  def define_method(method_id, &block)
+    raise LocalJumpError, "no block given" unless block_given?
+    `VM.define_method(self, #{method_id.to_s}, block)`
+    nil
+  end
+
+  def attr_accessor(*attrs)
+    attr_reader *attrs
+    attr_writer *attrs
+  end
+
+  def attr_reader(*attrs)
+    `for (var i = 0; i < attrs.length; i++) {
+      var attr = attrs[i];
+      var method_id = #{`attr`.to_s};
+
+      VM.define_method(self, method_id,
+            new Function('self', 'var iv = self["@' + method_id + '"]; return iv === undefined ? nil : iv;'));
+
+    }
+
+    return nil;`
+  end
+
+  def attr_writer(*attrs)
+    `for (var i = 0; i < attrs.length; i++) {
+      var attr = attrs[i];
+      var method_id = #{`attr`.to_s};
+
+      VM.define_method(self, method_id + '=',
+        new Function('self', 'val', 'return self["@' + method_id + '"] = val;'));
+
+    }
+
+    return nil;`
+  end
+
+  def alias_method(new_name, old_name)
+    new_name = new_name.to_s
+    old_name = old_name.to_s
+    `VM.define_method(self, new_name, self.$m_prototype_tbl[old_name])`
+    self
+  end
+
+  def to_s
+    `return self.__classid__;`
+  end
+
+  def const_set(id, value)
+    `return rb_vm_cs(self, #{id.to_s}, value);`
+  end
+
+  def class_eval(str, &block)
+    if block_given?
+      `block(self)`
+    else
+      raise "need to compile str"
+    end
+  end
+
+  def module_eval(str, &block)
+    class_eval str, &block
+  end
+
+  def private
+    self
+  end
+
+  def public
+    self
+  end
+
+  def protected
+    self
+  end
+
+  def include(mod)
+    `VM.include_module(self, mod)`
+    nil
+  end
+
+  def extend(mod)
+    `VM.extend_module(self, mod)`
+    nil
+  end
+end
+

data/gems/core/lib/core/nil_class.rb

@@ -0,0 +1,41 @@
+class NilClass
+
+  def to_i
+    0
+  end
+
+  def to_f
+    0.0
+  end
+
+  def to_s
+    ""
+  end
+
+  def to_a
+    []
+  end
+
+  def inspect
+    "nil"
+  end
+
+  def nil?
+    true
+  end
+
+  def &(other)
+    false
+  end
+
+  def |(other)
+    `return other.$r ? Qtrue : Qfalse;`
+  end
+
+  def ^(other)
+    `return other.$r ? Qtrue : Qfalse;`
+  end
+end
+
+NIL = nil
+

data/gems/core/lib/core/numeric.rb

@@ -0,0 +1,370 @@
+class Numeric
+  # Unary Plus - Returns the receivers value
+  #
+  # @example
+  #
+  #     +5
+  #     # => 5
+  #
+  # @return [Numeric] receiver
+  def +@
+    `return self;`
+  end
+
+  # Unary minus - returns the receiver's value, negated.
+  #
+  # @example
+  #
+  #     -5
+  #     # => -5
+  #
+  # @return [Numeric] result
+  def -@
+    `return -self;`
+  end
+
+  # Returns `self` modulo `other`. See {#divmod} for more information.
+  #
+  # @param [Numeric] other number to use for module
+  # @return [Numeric] result
+  def %(other)
+    `return self % other;`
+  end
+
+  def modulo(other)
+    `return self % other;`
+  end
+
+  # Bitwise AND.
+  #
+  # @param [Numeric] other numeric to AND with
+  # @return [Numeric]
+  def &(num2)
+    `return self & num2;`
+  end
+
+  # Performs multiplication
+  #
+  # @param [Numeric] other number to multiply with
+  # @return [Numeric]
+  def *(other)
+    `return self * other;`
+  end
+
+  # Raises `self` to the power of `other`.
+  #
+  # @param [Numeric] other number to raise to
+  # @return [Numeric]
+  def **(other)
+    `return Math.pow(self, other);`
+  end
+
+  # Performs addition.
+  #
+  # @param [Numeric] other number to add
+  # @return [Numeric]
+  def +(other)
+    `return self + other;`
+  end
+
+  # Performs subtraction
+  #
+  # @param [Numeric] other number to subtract
+  # @return [Numeric]
+  def -(other)
+    `return self - other;`
+  end
+
+  # Performs division
+  #
+  # @param [Numeric] other number to divide by
+  # @return [Numeric]
+  def /(other)
+    `return self / other;`
+  end
+
+  # Returns `true` if the value of `self` is less than that or `other`, `false`
+  # otherwise.
+  #
+  # @param [Numeric] other number to compare
+  # @return [true, false] result of comparison
+  def <(other)
+    `return self < other ? Qtrue : Qfalse;`
+  end
+
+  # Returns `true` if the value of `self` is less than or equal to `other`,
+  # `false` otherwise.
+  #
+  # @param [Numeric] other number to comapre
+  # @return [true, false] result of comparison
+  def <=(other)
+    `return self <= other ? Qtrue : Qfalse;`
+  end
+
+  # Returns `true` if the value of `self` is greater than `other`, `false`
+  # otherwise.
+  #
+  # @param [Numeric] other number to compare with
+  # @return [true, false] result of comparison
+  def >(other)
+    `return self > other ? Qtrue : Qfalse;`
+  end
+
+  # Returns `true` if `self` is greater than or equal to `other`, `false`
+  # otherwise.
+  #
+  # @param [Numeric] other number to compare with
+  # @return [true, false] result of comparison
+  def >=(other)
+    `return self >= other ? Qtrue : Qfalse;`
+  end
+
+  # Shift `self` left by `count` positions.
+  #
+  # @param [Numeric] count number to shift
+  # @return [Numeric]
+  def <<(count)
+    `return self << count;`
+  end
+
+  # Shifts 'self' right by `count` positions.
+  #
+  # @param [Numeric] count number to shift
+  # @return [Numeric]
+  def >>(count)
+    `return self >> count;`
+  end
+
+  # Comparison - Returns '-1', '0', '1' or nil depending on whether `self` is
+  # less than, equal to or greater than `other`.
+  #
+  # @param [Numeric] other number to compare with
+  # @return [Number, nil]
+  def <=>(other)
+    `if (typeof other != 'number') return nil;
+    else if (self < other) return -1;
+    else if (self > other) return 1;
+    return 0;`
+  end
+
+  # Returns `true` if `self` equals `other` numerically, `false` otherwise.
+  #
+  # @param [Numeric] other number to compare
+  # @return [true, false]
+  def ==(other)
+    `return self.valueOf() === other.valueOf() ? Qtrue : Qfalse;`
+  end
+
+  # Bitwise EXCLUSIVE OR.
+  #
+  # @param [Numeric] other number to XOR with
+  # @return [Numeric]
+  def ^(other)
+    `return self ^ other;`
+  end
+
+  # Returns the absolute value of `self`.
+  #
+  # @example
+  #
+  #     -1234.abs
+  #     # => 1234
+  #     1234.abs
+  #     # => 1234
+  #
+  # @return [Numeric]
+  def abs
+    `return Math.abs(self);`
+  end
+
+  def magnitude
+    `return Math.abs(self);`
+  end
+
+  # Returns `true` if self is even, `false` otherwise.
+  #
+  # @return [true, false]
+  def even?
+    `return (self % 2 == 0) ? Qtrue : Qfalse;`
+  end
+
+  # Returns `true` if self is odd, `false` otherwise.
+  #
+  # @return [true, false]
+  def odd?
+    `return (self % 2 == 0) ? Qfalse : Qtrue;`
+  end
+
+  # Returns the number equal to `self` + 1.
+  #
+  # @example
+  #
+  #     1.next
+  #     # => 2
+  #     (-1).next
+  #     # => 0
+  #
+  # @return [Numeric]
+  def succ
+    `return self + 1;`
+  end
+
+  def next
+    `return self + 1;`
+  end
+
+  # Returns the number equal to `self` - 1
+  #
+  # @example
+  #
+  #     1.pred
+  #     # => 0
+  #     (-1).pred
+  #     # => -2
+  #
+  # @return [Numeric]
+  def pred
+    `return self - 1;`
+  end
+
+  # Iterates the block, passing integer values from `self` upto and including
+  # `finish`.
+  #
+  # @example
+  #
+  #     5.upto(10) { |i| puts i }
+  #     # => 5
+  #     # => 6
+  #     # => 7
+  #     # => 8
+  #     # => 9
+  #     # => 10
+  #
+  # @param [Numeric] finish where to stop iteration
+  # @return [Numeric] returns the receiver
+  def upto(finish)
+    `for (var i = self; i <= finish; i++) {
+      #{yield `i`};
+    }
+
+    return self;`
+  end
+
+  # Iterates the block, passing decreasing values from `self` downto and
+  # including `finish`.
+  #
+  # @example
+  #
+  #     5.downto(1) { |x| puts x }
+  #     # => 5
+  #     # => 4
+  #     # => 3
+  #     # => 2
+  #     # => 1
+  #
+  # @param [Numeric] finish where to stop iteration
+  # @return [Numeric] returns the receiver
+  def downto(finish)
+    `for (var i = self; i >= finish; i--) {
+      #{yield `i`};
+    }
+
+    return self;`
+  end
+
+  # Iterates the block `self` number of times, passing values in the range 0 to
+  # `self` - 1.
+  #
+  # @example
+  #
+  #     5.times { |x| puts x }
+  #     # => 0
+  #     # => 1
+  #     # => 2
+  #     # => 3
+  #     # => 4
+  #
+  # @return [Numeric] returns the receiver
+  def times
+    `for (var i = 0; i < self; i++) {
+      #{yield `i`};
+    }
+
+    return self;`
+  end
+
+  # Bitwise OR.
+  #
+  # @param [Numeric] other number to OR with
+  # @return [Numeric]
+  def |(other)
+    `return self | other;`
+  end
+
+  # Returns `true` if `self` is zero, `false` otherwise.
+  #
+  # @return [true, false]
+  def zero?
+    `return self == 0 ? Qtrue : Qfalse;`
+  end
+
+  # Returns the receiver if it is not zero, `nil` otherwise
+  #
+  # @return [Numeric, nil]
+  def nonzero?
+    `return self == 0 ? nil : self;`
+  end
+
+  # One's complement: returns a number where each bit is flipped.
+  #
+  # @return [Numeric]
+  def ~
+    `return ~self;`
+  end
+
+  # Returns the smallest integer greater than or equal to `num`.
+  #
+  # @example
+  #
+  #     1.ceil        # => 1
+  #     1.2.ceil      # => 2
+  #     (-1.2).ceil   # => -1
+  #     (-1.0).ceil   # => -1
+  #
+  # @return [Numeric]
+  def ceil
+    `return Math.ceil(self);`
+  end
+
+  # Returns the largest integer less than or equal to `self`.
+  #
+  # @example
+  #
+  #     1.floor       # => 1
+  #     (-1).floor    # => -1
+  #
+  # @return [Numeric]
+  def floor
+    `return Math.floor(self);`
+  end
+
+  # Returns `true` if self is an ineteger, `false` otherwise.
+  #
+  # @return [true, false]
+  def integer?
+    `return self % 1 == 0 ? Qtrue : Qfalse;`
+  end
+
+  def inspect
+    `return self.toString();`
+  end
+
+  def to_s
+    `return self.toString();`
+  end
+
+  def to_i
+    `return parseInt(self);`
+  end
+end
+