opal 0.3.2 → 0.3.6

data/lib/core/match_data.rb

@@ -0,0 +1,33 @@
+class MatchData
+
+  def inspect
+    "#<MatchData #{`self.$data[0]`.inspect}>"
+  end
+
+  def to_s
+    `return self.$data[0];`
+  end
+
+  def length
+    `return self.$data.length;`
+  end
+
+  def size
+    `return self.$data.length;`
+  end
+
+  def to_a
+    `return [].slice.call(self.$data, 0);`
+  end
+
+  def [](index)
+    `var length = self.$data.length;
+
+    if (index < 0) index += length;
+
+    if (index >= length || index < 0) return nil;
+
+    return self.$data[index];`
+  end
+end
+

data/lib/core/module.rb

@@ -0,0 +1,97 @@
+# Implements the core functionality of modules. This is inherited from
+# by instances of {Class}, so these methods are also available to
+# classes.
+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?
+    `$rb.dm(self, #{method_id.to_s}.toString(), block)`
+    nil
+  end
+
+  def attr_accessor(*attrs)
+    attr_reader *attrs
+    attr_writer *attrs
+  end
+
+  def attr_reader(*attrs)
+    attrs.each do |a|
+      method_id = a.to_s
+      `$rb.dm(self, method_id, function(self) {
+        var iv = self['@' + method_id];
+        return iv == undefined ? nil : iv;
+      });`
+    end
+    nil
+  end
+
+  def attr_writer(*attrs)
+    attrs.each do |a|
+      method_id = a.to_s
+      `$rb.dm(self, method_id + '=', function(self, val) {
+        return self['@' + method_id] = val;
+      });`
+    end
+    nil
+  end
+
+  def alias_method(new_name, old_name)
+    `$rb.alias_method(self, #{new_name.to_s}, #{old_name.to_s});`
+    self
+  end
+
+  def instance_methods
+    `return self.$methods;`
+  end
+
+  def ancestors
+    `var ary = [], parent = self;
+
+    while (parent) {
+      if (parent.$flags & $rb.FL_SINGLETON) {
+        // nothing?
+      }
+      else {
+        ary.push(parent);
+      }
+
+      parent = parent.$super;
+    }
+
+    return ary;`
+  end
+
+  def to_s
+    `return self.__classid__;`
+  end
+
+  def const_set(id, value)
+    `return $rb.cs(self, #{id.to_s}, value);`
+  end
+
+  def class_eval(str = nil, &block)
+    if block_given?
+      `block(self)`
+    else
+      raise "need to compile str"
+    end
+  end
+
+  def module_eval(str = nil, &block)
+    class_eval str, &block
+  end
+
+  def extend(mod)
+    `$rb.extend_module(self, mod)`
+    nil
+  end
+end
+

data/{gems/core/lib → lib}/core/numeric.rb

@@ -326,6 +326,7 @@ class Numeric
   #
   # @return [Numeric] returns the receiver
   def times
+    raise "no block given" unless block_given?
     `for (var i = 0; i < self; i++) {
       #{yield `i`};
     }
@@ -406,5 +407,9 @@ class Numeric
   def to_i
     `return parseInt(self);`
   end
+
+  def self.allocate
+    raise RuntimeError, "cannot instantiate instance of Numeric class"
+  end
 end
 

data/{gems/core/lib → lib}/core/proc.rb

@@ -30,7 +30,9 @@
 class Proc
 
   def self.new(&block)
-    raise "No block given" unless block_given?
+    raise ArgumentError,
+      "tried to create Proc object without a block" unless block_given?
+
     block
   end
 
@@ -39,7 +41,15 @@ class Proc
   end
 
   def call(*args)
-    # `args.unshift(self.$self);
-    `return self.apply(self.$self, args);`
+    `args.unshift(self.$proc[0]); return self.apply(null, args);`
+  end
+
+  def to_s
+    `return "#<Proc:0x" + (self.$hash() * 400487).toString(16) + (self.$lambda ? ' (lambda)' : '') + ">";`
+  end
+
+  def lambda?
+    `return self.$fn.$lambda ? Qtrue : Qfalse;`
   end
 end
+

data/{gems/core/lib → lib}/core/range.rb

@@ -1,5 +1,15 @@
 class Range
 
+  def begin
+    `return self.$beg;`
+  end
+
+  alias_method :first, :begin
+
+  def end
+    `return self.$end;`
+  end
+
   def to_s
     `var str = #{`self.$beg`.to_s};
     var str2 = #{`self.$end`.to_s};

data/{gems/core/lib → lib}/core/regexp.rb

@@ -18,10 +18,23 @@
 # particular browsers documentation might point to differences
 # discovered. The majority of regexp syntax is typically the same.
 class Regexp
+
+  def self.escape(s)
+    s
+  end
+
+  def self.new(s)
+    `return new RegExp(s);`
+  end
+
   def inspect
     `return self.toString();`
   end
 
+  def to_s
+    `return self.source;`
+  end
+
   def ==(other)
     `return self.toString() === other.toString() ? Qtrue : Qfalse;`
   end
@@ -30,8 +43,27 @@ class Regexp
     self == other
   end
 
+  # Match - matches the regular expression against the given string. If
+  # the string matches, the index of the match is returned. Otherwise,
+  # `nil` is returned to imply no match.
+  #
+  # @param [String] str The string to match
+  # @return [Numeric, nil]
+  def =~(str)
+    `var result = self.exec(str);
+    $rb.X = result;
+
+    if (result) {
+      return result.index;
+    }
+    else {
+      return nil;
+    }`
+  end
+
   def match(pattern)
-    nil
+    self =~ pattern
+    $~
   end
 end
 

data/{gems/core/lib → lib}/core/string.rb

@@ -126,8 +126,8 @@ class String
     `return self.toLowerCase();`
   end
 
-  def to_s
-    self
+  def upcase
+    `return self.toUpperCase();`
   end
 
   # Returns a printable version of `self`, surrounded with quotation marks, with
@@ -172,6 +172,10 @@ class String
     `return self.length;`
   end
 
+  def to_i
+    `return parseInt(self);`
+  end
+
   # Returns the corresponding symbol for the receiver.
   #
   # @example
@@ -185,11 +189,11 @@ class String
   #
   # @return [Symbol]
   def to_sym
-    `return VM.Y(self);`
+    `return $rb.Y(self);`
   end
 
   def intern
-    `return VM.Y(self);`
+    `return $rb.Y(self);`
   end
 
   # Returns a new string with the characters from `self` in reverse order.
@@ -204,18 +208,26 @@ class String
     `return self.split('').reverse().join('');`
   end
 
+  def succ
+    `return String.fromCharCode(self.charCodeAt(0));`
+  end
+
+  def [](idx)
+    `return self.substr(idx, idx + 1);`
+  end
+
   def sub(pattern)
     `return self.replace(pattern, function(str) {
       return #{yield `str`};
     });`
   end
 
-  def gsub(pattern)
+  def gsub(pattern, replace)
     `var r = pattern.toString();
     r = r.substr(1, r.lastIndexOf('/') - 1);
     r = new RegExp(r, 'g');
     return self.replace(pattern, function(str) {
-      return #{yield `str`};
+      return replace;
     });`
   end
 
@@ -223,7 +235,7 @@ class String
     `return self.substr(start, finish);`
   end
 
-  def split(split)
+  def split(split, limit = nil)
     `return self.split(split);`
   end
 
@@ -260,13 +272,16 @@ class String
   # obj is not a regexp, then it calls =~ on it, using the receiver as an
   # argument
   #
-  # **TODO** passing a non regexp is not currently supported
+  # TODO passing a non regexp is not currently supported
   #
   # @param [Regexp, Objec] obj
   # @return [Numeric, nil]
   def =~(obj)
-    obj.match self
-    nil
+    `if (obj.$flags & $rb.T_STRING) {
+      $rb.raise(VM.TypeError, "type mismatch: String given");
+    }`
+
+    obj =~ self
   end
 
   # Case-insensitive version of {#<=>}

data/{gems/core/lib → lib}/core/symbol.rb

@@ -31,11 +31,11 @@ class Symbol
     `return ':' + self.toString();`
   end
 
-  def to_s
-    `return self.toString();`
+  def to_sym
+    self
   end
 
-  def to_sym
+  def intern
     self
   end
 end

data/lib/dev.rb

@@ -0,0 +1,169 @@
+require 'opal/ruby/parser'
+
+module Opal
+
+  def self.compile(source)
+    res = Opal::RubyParser.new(source).parse!.generate_top :debug => true
+    res
+  end
+
+  def self.run_ruby_content(source, filename = "(opal)")
+    js = compile source
+    `var exec = new Function('$rb', 'self', '__FILE__', js);
+    return exec($rb, $rb.top, filename);`
+  end
+
+  # Load the ruby code at the remote url, parse and run it. This is typically
+  # used when loading a script tag of type text/ruby. The filename given in the
+  # tag is used as the actual filename
+  #
+  # @param [String] filename
+  def self.run_remote_content(filename)
+    `var xhr;
+
+    if (window.ActiveXObject)
+      xhr = new window.ActiveXObject('Microsoft.XMLHTTP');
+    else
+      xhr = new XMLHttpRequest();
+
+    xhr.open('GET', filename, true);
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState == 4) {
+        if (xhr.status == 0 || xhr.status == 200) {
+          #{ run_ruby_content `xhr.responseText`, filename };
+        } else {
+          #{ raise "LoadError: Cannot load: #{filename}" };
+        }
+      }
+    };
+    xhr.send(null);`
+    nil
+  end
+
+  def self.run_script_tags
+    `var scripts = document.getElementsByTagName('script');
+
+    for (var i = 0, ii = scripts.length; i < ii; i++) {
+      var script = scripts[i];
+
+      if (script.type == "text/ruby") {
+        if (script.src) {
+          #{ run_remote_content `script.src` };
+        } else {
+          #{ run_ruby_content `script.innerHTML`, "(script-tag)" };
+        }
+      }
+    }`
+
+    nil
+  end
+end
+
+`opal.compile = function(source, options) {
+  console.log("need to compile some code");
+  return #{ Opal.compile `source` };
+};`
+
+`if (typeof window !== 'undefined') {
+  var runner = function() { #{ Opal.run_script_tags }; };
+
+  if (window.addEventListener) {
+    window.addEventListener('DOMContentLoaded', runner, false);
+  } else {
+    window.attachEvent('onload', runner);
+  }
+}`
+
+`var repl_running = false;
+
+opal.browser_repl = function() {
+  if (repl_running) return;
+  repl_running = true;
+
+  var html = '<div id="opal-repl" style="position: fixed; width: 100%; height: '
+           +     '230px; bottom: 0px; overflow: scroll; border-top: 4px solid'
+           +     '#A5A5A5; left: 0px; padding: 4px; background-color: #E5E5E5;">'
+
+           +   '<div id="opal-stdout" style="font-family: \'Bitstream Vera Sans'
+           +       'Mono\', \'Courier\', monospace; font-size: 12px"></div>'
+
+           +   '<span style="float: left; display: block; font-family: \'Bitst'
+           +       'ream Vera Sans Mono\', \'Courier\', monospace; font-size: '
+           +       '12px">&gt;&gt;&nbsp;</span>'
+
+           +   '<input id="opal-stdin" type="text" style="position: relative;'
+           +       'float: left; right: 0px; width: 500px; font-family: \'Bit'
+           +       'stream Vera Sans Mono\', \'Courier\', monospace;'
+           +       'font-size: 12px; outline-width: 0; outline: none; border:'
+           +       '0px; padding: 0px; margin: 0px; background: none" />'
+
+           + '</div>';
+
+  var host = document.createElement('div');
+  host.innerHTML = html;
+  document.body.appendChild(host);
+  var opal_repl = document.getElementById('opal-repl');
+
+  var stdout = document.getElementById('opal-stdout');
+  var stdin = document.getElementById('opal-stdin');
+  var history = [], history_idx = 0;
+  setTimeout(function() { stdin.focus(); }, 0);
+
+  var puts_content = function(str) {
+    var elem = document.createElement('div');
+    elem.textContent == null ? elem.innerText = str : elem.textContent = str;
+    stdout.appendChild(elem);
+  };
+
+  var stdin_keydown = function(evt) {
+    if (evt.keyCode == 13) {
+      var ruby = stdin.value;
+
+      history.push(stdin.value);
+      history_idx = history.length;
+      stdin.value = '';
+      puts_content(">> " + ruby);
+
+      try {
+        puts_content("=> " + #{Opal.run_ruby_content(`ruby`, '(irb)').inspect}.toString());
+      }
+      catch (err) {
+        // if (err.stack) puts_content(err.stack);
+        //else puts_content("=> " + err.message);
+        puts_content("=> " + err.$klass.__classid__ + ": " + err['@message']);
+      }
+
+      opal_repl.scrollTop = opal_repl.scrollHeight;
+    }
+    else if (evt.keyCode == 38) {
+      if (history_idx > 0) {
+        history_idx -= 1;
+        stdin.value = history[history_idx];
+      }
+    }
+    else if (evt.keyCode == 40) {
+      if (history_idx < history.length - 1) {
+        history_idx += 1;
+        stdin.value = history[history_idx];
+      }
+    }
+  };
+
+  if (stdin.addEventListener) {
+    stdin.addEventListener('keydown', stdin_keydown, false);
+  } else {
+    stdin.attachEvent('onkeydown', stdin_keydown);
+  }
+
+  #{
+  def $stdout.puts(*a)
+    `for (var i = 0, ii = a.length; i < ii; i ++) {
+      puts_content(#{`a[i]`.to_s}.toString());
+    }`
+    nil
+  end
+  };
+
+  puts_content("opal REPL! Type command then <enter>.");
+};`
+