opal 0.3.6 → 0.3.9

data/README.md

@@ -1,126 +1,98 @@
-Opal: Ruby runtime for javascript
-=================================
+Opal
+====
 
-**Homepage**:      [http://opalscript.org](http://opalscript.org)  
-**Github**:        [http://github.com/adambeynon/opal](http://github.com/adambeynon/opal)  
+Opal is a partial implementation of ruby designed to run in any
+javascript environment. The runtime is written in javascript, with all
+core libraries written directly in ruby with inline javascript to make
+them as fast as possible.
 
-Description
------------
+Wherever possible ruby objects are mapped directly onto their native
+javascript counterparts to speed up the generated code and to improve
+interopability with existing javascript libraries.
 
-Opal is a Ruby runtime and standard library designed to run directly on
-top of javascript. It can be run within the browser or on the command
-line through the bundled build tools. Opal includes a parser/compiler
-that builds ruby ahead of time directly into javascript that runs with
-the bundled runtime.
+The opal compiler is a source-to-source compiler which outputs
+javascript which can then run on the core runtime.
 
-Features
---------
+Opal does not aim to be 100% comaptible with other ruby implementations,
+but does so where the generated code can be efficient on all modern web
+browsers - including older versions of IE and mobile devices.
 
-* Full method\_missing support for all objects and classes
-* Debug mode to provide stack traces and arg checking
-* Private and public method support
-* Full operator overloading (`[]`, `[]=`, `+`, `-`, `==`, etc)
-* Toll free bridges to javascript objects (`String`, `Number`, `Array`
-  etc)
-* Inline javascript within ruby code using backticks
-* In browser loading of `<script type="text/ruby></script>` tags
-* Generated code is clean and maintains line numbers to ease debugging
-* super(), metaclasses, eigenclasses, blocks, yield, block\_given?,
-  ranges, arg count errors, lambda, singletons, etc....
+Using opal
+----------
 
-Installation
-------------
+Opal can currently be used in two ways: through a distributed ruby gem,
+or directly in the web browser.
 
-The best way to get started with opal is to clone this repo and use the
-`opal` bin file directly:
+### Using the gem
 
-    $ git clone git://github.com/adambeynon/opal.git
+Install via ruby gems:
 
-Although opal is distributed as a gem, the latest gem release is mostly
-incompatible with the loading and runtime system for opal, so until a
-newer gem is released (0.3.5), it is best to stick with the repo.
+```
+$ gem install opal
+```
 
-### Try without installing
+The `opal` command should then be available. To run the simple repl use:
 
-Browser can be used inside a repl on the
-[http://opalscript.org](http://opalscript.org) homepage which gives an
-IRB style interface for running ruby code which is compiled and
-evaluated within the browser (no plugins!).
+```
+opal irb
+```
 
-Alternatively the opal runtime and opal parser can be downloaded
-directly from the `extras` directory in this repository.
+The `opal` command can also be used directly from this source repo, so
+to download and run opal:
 
-Usage
------
+```
+$ git clone https://github.com/adambeynon/opal.git
+$ cd opal
+$ bin/opal
+```
 
-Opal can be used within in the browser, or on the command line using the
-build tools. A Nodejs environment is also partially implemented.
-
-### Browser
-
-To run within the browser, you can either use the latest build version
-on the opal website, or clone the build tools as above, and then run the
-following task in this directory:
-
-    $ rake opal
-
-This will place a non minified version ready to run within the browser
-into `extras/opal.js`
-
-#### Compiling ruby sources
-
-To run ruby code in the browser, ruby must either be precompiled to
-javascript using these build tools, or the `opal_dev.js` file can parse
-and compile ruby code referenced in html `script` tags that use the
-`text/ruby` type.
-
-### Command line
-
-Opal is bundled with a set of build tools available in the `opalite/`
-directory. These are available when running opal from the command line
-or including it from ruby sources.
-
-#### Ruby repl
-
-To run the repl, clone this repo as directed above and run:
+Running tests
+-------------
 
-    $ bin/opal irb
+To run tests, you need opaltest which is the testing framework for opal
+based on minitest. To get opaltest, run the following in the opal
+directory:
 
-This will act like any other repl to try out commands. The repl relies
-on `therubyracer` as its javascript engine.
+```
+$ rake vendor
+```
 
-Running tests
--------------
+This will put opaltest into `vendor/opaltest` so it will be available
+for running. To test `array.rb` for example, run:
 
-Opal uses a subset of the `rubyspec` specs for ruby until it reaches a
-mature enough state to just use rubyspec directly. These tests are found
-in the `spec/` folder. They can be run either through the command line,
-or built ready to open in the browser.
+```
+$ bin/opal test/array.rb
+```
 
-### Running in the browser
+The results should be printed to the console.
 
-To run in the browser, first build the specs (compile into js ready):
+Differences from ruby
+---------------------
 
-    $ rake opal_spec
+### No method\_missing
 
-This will build the specs into `extras/` so open `extras/opal.spec.html`
-in any browser to see how the specs run.
+To optimize method dispatch, `method_missing` is not supported in opal.
+It is supported in debug mode to improve readability of error messages
+from calling undefined methods, but should/will not be used in
+production code.
 
-### Running on command line
+### Immutable strings and removed symbols
 
-The opal binary has a `spec` flag which can be passed one or any number
-of specs. For example, to run the `and` and `&&` specs from this repo,
-run:
+All strings in opal are immutable to make them easier to map onto
+javascript strings. In opal a ruby string compiles directly into a js
+string without a wrapper so that they can be passed back between code
+bases easily. Also, symbol syntax is maintained, but all symbols just
+compile into javascript strings. The `Symbol` class is also therefore
+removed.
 
-    $ bin/opal spec spec/language/and_spec.rb
+### Unified Numeric class
 
-Between gem releases every spec will pass. The master branch in this
-repo may contain broken specs, but these will be fixed before the next
-gem release and version bump.
+All numbers in opal are members of the `Numeric` class. The `Integer`
+and `Float` classes are removed.
 
-Examples
---------
+### Unified Boolean class
 
-Examples can be found in the `examples/` directory in this repo, and
-rely on `extras/opal.js` being created using the above commands.
+Both `true` and `false` compile into their native javascript
+counterparts which means that they both become instances of the
+`Boolean` class and opal removes the `TrueClass` and `FalseClass`.
 

data/bin/opal

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
 
-opal_lib = File.expand_path('../../opal_lib', __FILE__)
+opal_lib = File.expand_path('../../lib', __FILE__)
 $:.unshift opal_lib unless $:.include? opal_lib
 
 require 'opal'
 require 'opal/command'
 
-Opal::Command.start
+Opal::Command.new ARGV
 

data/{lib/core → corelib}/array.rb

@@ -16,20 +16,16 @@ class Array
   end
 
   def self.allocate
-    `var arr = [];
-    arr.$klass = self;
-    arr.$m = self.$m_tbl;
-    return arr;`
+    `var ary = new self.$a();
+    return ary;`
   end
 
-  def initialize(len, fill = nil)
-    `var ary = self;
-
-    for (var i = 0; i < len; i++) {
-      ary[i] = fill;
+  def initialize(len = 0, fill = nil)
+    `for (var i = 0; i < len; i++) {
+      self[i] = fill;
     }
 
-    ary.length = len;
+    self.length = len;
 
     return self;`
   end
@@ -120,9 +116,9 @@ class Array
   def each_with_index
     raise "Array#each_with_index no block given" unless block_given?
 
-    `for (var i = 0, len = self.length; i < len; i++) {
-      #{ yield `self[i]`, `i` };
-    }`
+    `for (var i = 0, len = self.length; i < len; i++) {`
+      yield `self[i]`, `i`
+    `}`
     self
   end
 
@@ -235,16 +231,16 @@ class Array
   # @param [Array] other array to compare self with
   # @return [Boolean] if the arrays are equal
   def ==(other)
-    `if (self.$hash() == other.$hash()) return Qtrue;
-    if (self.length != other.length) return Qfalse;
+    `if (self.$h() == other.$h()) return true;
+    if (self.length != other.length) return false;
 
     for (var i = 0; i < self.length; i++) {
-      if (!#{`self[i]` == `other[i]`}.$r) {
-        return Qfalse;
+      if (!#{`self[i]` == `other[i]`}) {
+        return false;
       }
     }
 
-    return Qtrue;`
+    return true;`
   end
 
   # Searches through an array whose elements are also arrays, comparing `obj`
@@ -288,9 +284,11 @@ class Array
   # @param [Numeric] index the index to get
   # @return [Object, nil] returns nil or the result
   def at(idx)
-    `if (idx < 0) idx += self.length;
+    `var size = self.length;
 
-    if (idx < 0 || idx >= self.length) return nil;
+    if (idx < 0) idx += size;
+
+    if (idx < 0 || idx >= size) return nil;
     return self[idx];`
   end
 
@@ -457,7 +455,7 @@ class Array
   #
   # @param [Object] obj object to check
   # @return [Numeric] count or count of obj
-  def count(obj)
+  def count(obj = undefined)
     `if (obj != undefined) {
       var total = 0;
 
@@ -594,7 +592,7 @@ class Array
   #
   # @return [false, true] empty or not
   def empty?
-    `return self.length == 0 ? Qtrue : Qfalse;`
+    `return self.length == 0;`
   end
 
   # Tries to return the element as position `index`. If the index lies outside
@@ -624,13 +622,13 @@ class Array
   # @param [Numeric] idx
   # @param [Object] defaults
   # @return [Object] returns result
-  def fetch(idx, defaults)
+  def fetch(idx, defaults = undefined)
     `var original = idx;
 
     if (idx < 0) idx += self.length;
     if (idx < 0 || idx >= self.length) {
       if (defaults == undefined)
-        return rb_raise("Index Error: Array#fetch");
+        raise(eIndexError, "Array#fetch");
       else if (__block__)
         return #{yield `original`};
       else
@@ -654,8 +652,8 @@ class Array
   #
   # @param [Numeric] count number of elements
   # @return [Object, Array] object or array of objects
-  def first(count = nil)
-    `if (count == nil) {
+  def first(count = undefined)
+    `if (count == undefined) {
       if (self.length == 0) return nil;
       return self[0];
     }
@@ -683,14 +681,14 @@ class Array
   #
   # @param [Numeric] level the level to flatten
   # @return [Array] returns new array
-  def flatten(level = nil)
+  def flatten(level = undefined)
     `var result = [], item;
 
     for (var i = 0; i < self.length; i++) {
       item = self[i];
 
-      if (item.hasOwnProperty('length')) {
-        if (level == nil)
+      if (item.o$f & T_ARRAY) {
+        if (level == undefined)
           result = result.concat(#{`item`.flatten});
         else if (level == 0)
           result.push(item);
@@ -719,7 +717,7 @@ class Array
   #
   # @param [Number] level to flatten to
   # @return [Array] returns the receiver
-  def flatten!(level = nil)
+  def flatten!(level = undefined)
     `var length = self.length;
     var result = #{self.flatten level};
     self.splice(0);
@@ -734,6 +732,20 @@ class Array
     return self;`
   end
 
+  def grep(pattern)
+    `var result = [], arg;
+
+    for (var i = 0, ii = self.length; i < ii; i++) {
+      arg = self[i];
+
+      if (pattern.exec(arg)) {
+        result.push(arg);
+      }
+    }
+
+    return result;`
+  end
+
   # Returns true if the given object is present in `self`, false otherwise.
   #
   # @example
@@ -745,7 +757,7 @@ class Array
   #     # => false
   def include?(member)
     `for (var i = 0; i < self.length; i++) {
-      if (#{`self[i]` == member}.$r) {
+      if (#{`self[i]` == member}) {
         return #{true};
       }
     }
@@ -753,6 +765,17 @@ class Array
     return #{false};`
   end
 
+  def inject(initial = undefined)
+    `if (initial === undefined) initial = self[0];
+    var result;
+
+    for (var i = 0, ii = self.length; i < ii; i++) {
+      initial = #{ yield `initial`, `self[i]` };
+    }
+
+    return initial;`
+  end
+
   # Replaces the contents of `self` with the contents of `other`, truncating or
   # expanding if necessary.
   #
@@ -791,10 +814,12 @@ class Array
   # @param [Object] objs objects to insert
   # @return [Array] returns the receiver
   def insert(idx, *objs)
-    `if (idx < 0) idx += self.length;
+    `var size = self.length;
 
-    if (idx < 0 || idx >= self.length)
-      rb_raise("IndexError: out of range");
+    if (idx < 0) idx += size;
+
+    if (idx < 0 || idx >= size)
+      raise(eIndexError, "out of range");
 
     self.splice.apply(self, [idx, 0].concat(objs));
     return self;`
@@ -855,13 +880,15 @@ class Array
   #
   # @param [Number] count the number of items to get
   # @return [Object, Array] result
-  def last(count = nil)
-    `if (count == nil) {
-      if (self.length == 0) return nil;
-      return self[self.length - 1];
+  def last(count = undefined)
+    `var size = self.length;
+
+    if (count == undefined) {
+      if (size == 0) return nil;
+      return self[size - 1];
     } else {
-      if (count > self.length) count = self.length;
-      return self.slice(self.length - count, self.length);
+      if (count > size) count = size;
+      return self.slice(size - count, size);
     }`
   end
 
@@ -881,12 +908,14 @@ class Array
   #
   # @param [Numeric] count number to pop
   # @return [Array] returns popped items
-  def pop(count = nil)
-    `if (count == nil) {
-      if (self.length) return self.pop();
+  def pop(count = undefined)
+    `var size = self.length;
+
+    if (count == undefined) {
+      if (size) return self.pop();
       return nil;
     } else {
-      return self.splice(self.length - count, self.length);
+      return self.splice(size - count, size);
     }`
   end
 
@@ -909,7 +938,7 @@ class Array
 
     for (var i = 0; i < self.length; i++) {
       test = self[i];
-      if (test.hasOwnProperty('length') && test[1] != undefined) {
+      if (test.o$f & T_ARRAY && test[1] != undefined) {
         if (#{`test[1]` == obj}.$r) return test;
       }
     }
@@ -1048,7 +1077,7 @@ class Array
   #     # => 3
   #
   # @return [Object, nil] returns result or nil
-  def rindex(obj = `undefined`)
+  def rindex(obj = undefined)
     `if (obj != undefined) {
       for (var i = self.length - 1; i >=0; i--) {
         if (#{`self[i]` == obj}.$r) {
@@ -1056,7 +1085,7 @@ class Array
         }
       }
     } else if (true || __block__) {
-      rb_raise("array#rindex needs to do block action");
+      raise(eException, "Array#rindex needs to do block action");
     }
 
     return nil;`
@@ -1111,11 +1140,11 @@ class Array
   #
   # @param [Numeric] count elements to shift
   # @return [Array] result
-  def shift(count = nil)
-    `if (count != nil)
+  def shift(count = undefined)
+    `if (count != undefined)
       return self.splice(0, count);
 
-    if (self.length) 
+    if (self.length)
       return self.shift();
 
     return nil;`
@@ -1226,7 +1255,7 @@ class Array
     `var result = [], seen = [];
 
     for (var i = 0; i < self.length; i++) {
-      var test = self[i], hash = test.$hash();
+      var test = self[i], hash = test.$h();
       if (seen.indexOf(hash) == -1) {
         seen.push(hash);
         result.push(test);
@@ -1252,7 +1281,7 @@ class Array
     `var seen = [], length = self.length;
 
     for (var i = 0; i < self.length; i++) {
-      var test = self[i], hash = test.$hash();
+      var test = self[i], hash = test.$h();
       if (seen.indexOf(hash) == -1) {
         seen.push(hash);
       } else {
@@ -1298,11 +1327,11 @@ class Array
     `var result = [], seen = [];
 
     for (var i = 0; i < self.length; i++) {
-      var test = self[i], hash = test.$hash();
+      var test = self[i], hash = test.$h();
 
       if (seen.indexOf(hash) == -1) {
         for (var j = 0; j < other.length; j++) {
-          var test_b = other[j], hash_b = test_b.$hash();
+          var test_b = other[j], hash_b = test_b.$h();
 
           if ((hash == hash_b) && seen.indexOf(hash) == -1) {
             seen.push(hash);
@@ -1332,7 +1361,7 @@ class Array
   # @param [String, Number] num string or number used to join or concat
   # @return [String, Array] depending on argument
   def *(arg)
-    `if (typeof arg == 'string') {
+    `if (arg.o$f & T_STRING) {
       return #{self.join `arg`};
     } else {
       var result = [];
@@ -1369,7 +1398,7 @@ class Array
   # @param [Range, Numeric] index to begin
   # @param [Numeric] length last index
   # @return [Array, Object, nil] result
-  def [](index, length = `undefined`)
+  def [](index, length = undefined)
     `var ary = self, size = ary.length;
 
     if (index < 0) index += size;