opal 0.4.4 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdf74450cbd2b81a0d8ba44700ef6e0e77b5ca45
+  data.tar.gz: 01e6a0e881a43bdaa1eb4db93c0e1989ca1d4568
+SHA512:
+  metadata.gz: 90d5d6913908ef1d38f69d029d6033fbcd0d2214035a3cf34ebe5c5d8725e2bd37689009dbbd28e99ca27f9069cfe09b44445a0a3710e3d0e71f0d1ce00dd72b
+  data.tar.gz: bca3fd06513433d71ff656a473acf3269caa301a55589fdccea45cc463d9f865b6d558bbc1f427552f46586172f6f053cf6396cb5bbe193aa2e5b113783d0a86

data/.gitignore

@@ -5,3 +5,4 @@
 Gemfile.lock
 /mspec
 /build
+/.github_access_token

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "rubyspec"]
+	path = rubyspec
+	url = git://github.com/rubyspec/rubyspec.git

data/.travis.yml

@@ -4,6 +4,14 @@ rvm:
   - 1.8.7
   - 1.9.3
   - 2.0.0
+  - rbx-20mode
+
+before_install:
+  - git submodule update --init
 
 notifications:
   irc: "irc.freenode.org#opal"
+
+matrix:
+  allow_failures:
+    - rvm: rbx-20mode

data/CONTRIBUTING.md

@@ -1,5 +1,21 @@
 # Contributing
 
+This is the issue tracker for Opal. If you have a more general question about
+using opal (or related libraries) then use the
+[google group for opal](http://groups.google.com/forum/#!forum/opalrb), or the
+[#opal](http://webchat.freenode.net/?channels=opal) irc channel on
+FreeNode.
+
+## Contributing
+
+* Before opening a new issue, search for previous discussions including closed
+ones. At comments there if a similar issue is found.
+
+* Before sending pull requests make sure all tests run and pass (see below).
+
+* Make sure to use a similar coding style to the rest of the code base. In ruby
+and javascript code we use 2 spaces (no tabs).
+
 ## Quick Start
 
 Clone repo:
@@ -14,13 +30,23 @@ Get dependencies:
 $ bundle
 ```
 
-## Tests
+## Running Tests
+
+### Runtime
+
+Some opal specific tests are found inside `spec/`, but the majority of our
+runtime tests now come from rubyspec. Rubyspec is included as a git submodule.
+To get our latest referenced checkout, just run:
+
+```
+$ git submodule update --init
+```
 
 You need phantomjs installed to run tests. To build opal, its dependencies
 and all specs, run:
 
 ```
-$ rake
+$ bundle exec rake mspec
 ```
 
 You can alternatively run tests in a browser using:
@@ -30,3 +56,21 @@ $ rackup
 ```
 
 And then opening `http://127.0.0.1:9292` in a web browser.
+
+### Gem/lib tests
+
+We also include some tests for running under your standard ruby implementation
+which are in `mri_spec/`. To run tests tests using rake, use:
+
+```
+$ bundle exec rake mri_spec
+```
+
+### All tests
+
+To run all the tests together (which you should do while contributing), run:
+
+```
+$ bundle exec rake
+```
+

data/Gemfile

@@ -1,2 +1,19 @@
 source 'https://rubygems.org'
 gemspec
+
+gem 'opal-sprockets', :github => 'opal/opal-sprockets'
+
+# Stick with older racc until
+# https://github.com/tenderlove/racc/issues/32
+# is solved.
+gem 'racc', '< 1.4.10' if RUBY_VERSION.to_f < 1.9
+
+platform :rbx do
+  gem 'rubysl'
+  gem 'rubysl-openssl'
+end
+
+group :repl do
+  gem 'therubyracer', :require => 'v8', :platform => :mri
+  gem 'therubyrhino', :platform => :jruby
+end

data/README.md

@@ -2,8 +2,9 @@
 
 [![Build Status](https://secure.travis-ci.org/opal/opal.png?branch=master)](http://travis-ci.org/opal/opal)
 [![Gem Version](https://badge.fury.io/rb/opal.png)](http://badge.fury.io/rb/opal)
+[![Code Climate](https://codeclimate.com/github/opal/opal.png)](https://codeclimate.com/github/opal/opal)
 
-Opal is a ruby to javascript source-to-source compiler. It also has an 
+Opal is a ruby to javascript source-to-source compiler. It also has an
 implementation of the ruby corelib.
 
 Opal is [hosted on github](http://github.com/opal/opal), and there
@@ -15,11 +16,11 @@ See the website, [http://opalrb.org](http://opalrb.org).
 
 ### Compiling ruby code
 
-`Opal.parse` is a simple interface to just compile a string of ruby into a
+`Opal.compile` is a simple interface to just compile a string of ruby into a
 string of javascript code.
 
 ```ruby
-Opal.parse("puts 'wow'")  # => "(function() { ... })()"
+Opal.compile("puts 'wow'")  # => "(function() { ... })()"
 ```
 
 Running this by itself is not enough, you need the opal runtime/corelib.
@@ -54,11 +55,15 @@ First, install dependencies:
 
     $ bundle install
 
+Rubyspecs must be cloned as a gitsubmodule:
+
+    $ git submodule update --init
+
 Tests can be run with phantomjs using:
 
     $ rake
 
-Alternatively, you can just load up a rack instance using `rackup`, and
+Alternatively, you can just load up a rack instance using `rackup spec/config.ru`, and
 visit `http://localhost:9292/` in any web browser.
 
 ## Code Overview
@@ -112,3 +117,7 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/opal/opal/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/Rakefile

@@ -2,79 +2,24 @@ require 'bundler'
 Bundler.require
 Bundler::GemHelper.install_tasks
 
-require 'rack'
-require 'webrick'
-require 'opal-sprockets'
-
-# mspec/rubyspec use a top level "language_version" to require relative specs.
-# We can't do this at runtime, so we hijack the method (and make sure we only
-# do this at the top level). We figure out which file we are including, and
-# add it to our require list
-class ::Opal::Parser
-  alias_method :mspec_process_call, :process_call
-
-  def process_call(sexp, level)
-    if sexp[1] == :language_version and @scope.top?
-      lang_type = sexp[2][2][1]
-      target = "rubyspec/language/versions/#{lang_type}_1.9"
-      @requires << target
-      return f("nil")
-    end
-
-    mspec_process_call sexp, level
-  end
-end
-
-class RunSpec
-  def initialize(file=nil)
-    Opal::Processor.arity_check_enabled = true
-
-    ENV['OPAL_SPEC'] = file.nil? ? ["#{Dir.pwd}/spec/"].join(',') : file.join(',')
-
-    build_specs
-
-    server = fork do
-      app = Rack::Builder.app do
-        use Rack::ShowExceptions
-        run Rack::Directory.new('.')
-      end
-
-      Rack::Server.start(:app => app, :Port => 9999, :AccessLog => [],
-        :Logger => WEBrick::Log.new("/dev/null"))
-    end
-
-    system "phantomjs \"spec/ospec/sprockets.js\" \"http://localhost:9999/spec/index.html\""
-    success = $?.success?
-
-    exit 1 unless success
-
-  rescue => e
-    puts e.message
-  ensure
-    Process.kill(:SIGINT, server)
-    Process.wait
-  end
-
-  def build_specs
-    env = Opal::Environment.new
-    env.append_path 'spec'
-    env.use_gem 'mspec'
-
-    FileUtils.mkdir_p 'build'
-    puts " * build/specs.js"
-
-    specs = uglify(env['ospec/main'].to_s)
-    File.open('build/specs.js', 'w+') { |o| o << specs }
-  end
-
-  # Only if OPAL_UGLIFY is set
-  def uglify(str)
-    if ENV['OPAL_UGLIFY']
-      require 'uglifier'
-      puts " * uglifying"
-      Uglifier.compile(str)
-    else
-      str
+import 'tasks/mspec.rake'
+
+namespace :github do
+  desc "Upload assets to github"
+  task :upload_assets do
+    require 'octokit'
+    # https://github.com/octokit/octokit.rb#oauth-access-tokens
+    token_path = '.github_access_token'
+    File.exist?(token_path) or raise ArgumentError, "Please create a personal access token (https://github.com/settings/tokens/new) and paste it inside #{token_path.inspect}"
+    token = File.read(token_path).strip
+    client = Octokit::Client.new :access_token => token
+    tag_name = ENV['TAG'] || raise(ArgumentError, 'missing the TAG env variable (e.g. TAG=v0.4.4)')
+    release = client.releases('opal/opal').find{|r| p(r.id); p(r).tag_name == tag_name}
+    release_url = "https://api.github.com/repos/opal/opal/releases/#{release.id}"
+    %w[opal opal-parser].each do |name|
+      client.upload_asset release_url, "build/#{name}.js", :content_type => 'application/x-javascript'
+      client.upload_asset release_url, "build/#{name}.min.js", :content_type => 'application/x-javascript'
+      client.upload_asset release_url, "build/#{name}.min.js.gz", :content_type => 'application/octet-stream'
     end
   end
 end
@@ -94,59 +39,17 @@ end
 
 desc "Build specs to build/specs.js and build/specs.min.js"
 task :build_specs do
-  require 'uglifier'
-
   Opal::Processor.arity_check_enabled = true
   ENV['OPAL_SPEC'] = ["#{Dir.pwd}/spec/"].join(',')
 
-  env = Opal::Environment.new
-  env.append_path 'spec'
-  env.use_gem 'mspec'
-
-  FileUtils.mkdir_p 'build'
-
-  puts " * build/specs.js"
-  specs = env['ospec/main'].to_s
-
-  puts " * build/specs.min.js"
-#  min = Uglifier.compile(specs)
-
-  File.open('build/specs.js', 'w+') { |o| o << specs }
-#  File.open('build/specs.min.js', 'w+') { |o| o << min }
-end
-
-desc "Run task with spec:dir:file helper"
-namespace :spec do
-  task 'dirs' do
-  end
-  rule '' do |task|
-
-    #build path for spec files\dirs.
-    #Example:
-    #spec:core => spec/core/
-    #spec:core:array:allocate => spec/core/array/allocate_spec.rb
-    def path(dirs)
-      path = "#{Dir.pwd}"
-      dirs.each do |dir|
-        base = path + "/#{dir}"
-        if Dir.exists?(base)
-          path = base
-        else
-          path = Dir.glob("#{base}_spec.rb")
-        end
-      end
-      path = [path].flatten
-      raise ArgumentError, "File or Dir with task #{dirs.join('/')} not found." if path.empty?
-      path
-    end
-
-    RunSpec.new(path(task.name.split(":")))
-  end
+  env = SpecEnvironment.new
+  env.build
 end
 
 desc "Build opal.js and opal-parser.js to build/"
 task :dist do
   Opal::Processor.arity_check_enabled = false
+  Opal::Processor.const_missing_enabled = false
 
   env = Opal::Environment.new
 
@@ -173,7 +76,7 @@ end
 
 desc "Rebuild grammar.rb for opal parser"
 task :racc do
-  %x(racc -l lib/opal/grammar.y -o lib/opal/grammar.rb)
+  %x(racc -l lib/opal/parser/grammar.y -o lib/opal/parser/grammar.rb)
 end
 
 # Used for uglifying source to minify

data/bin/opal

@@ -5,6 +5,15 @@ options = Opal::CLIOptions.new
 options.parse!
 
 require 'opal/cli'
-cli = Opal::CLI.new ARGV.first, options.options
-cli.run
 
+if ARGV.empty? and !options.options[:evals]
+  p options
+else
+  cli = Opal::CLI.new options.options.merge(:filename => ARGV.first)
+  begin
+    cli.run
+  rescue Opal::CLI::MissingNode => e
+    $stderr.puts e.message
+    exit 127
+  end
+end

data/bin/opal-repl

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'opal'
+
+module Opal
+  class V8Context
+    def initialize
+      @builder = Opal::Builder.new
+    end
+
+    def run(filename = nil)
+      return if @v8
+
+      begin
+        require 'v8'
+      rescue LoadError
+        abort 'therubyracer must be installed'
+      end
+
+      @v8 = V8::Context.new
+      @v8['console'] = self
+      @v8.eval @builder.build 'opal'
+
+      if filename
+        if File.exist? filename
+          eval_ruby File.read(filename)
+        else
+          fail "file does not exist: #{filename}"
+        end
+      end
+
+      run_repl
+    end
+
+    def log(*str)
+      puts(*str)
+    end
+
+    def run_repl
+      require 'readline'
+
+      loop do
+        # on SIGINT lets just return from the loop..
+        trap("SIGINT") { finish; return }
+        line = Readline.readline '>> ', true
+
+        # if we type exit, then we need to close down context
+        if line == "exit" or line.nil?
+          break
+        end
+
+        puts "=> #{eval_ruby line}"
+      end
+
+      finish
+    end
+
+    def eval_ruby(str)
+      code = @builder.build_str str, :irb => true, :const_missing => true
+      @v8.eval "var $_result = #{code} ($_result == null ? 'nil' : $_result.$inspect());"
+    rescue => e
+      puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+
+    def finish
+      @v8 = nil
+    end
+  end
+end
+
+Opal::V8Context.new.run ARGV.first

data/corelib/array.rb

@@ -12,102 +12,80 @@ class Array
     self.class.new(*args)
   end
 
-  def self.new(size = undefined, obj = nil, &block)
-    %x{
+  def self.new(size = nil, obj = nil, &block)
+    if `arguments.length > 2`
+      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..2)"
+    end
 
-      if (arguments.length > 2)
-        #{raise ArgumentError.new("wrong number of arguments. Array#new")};
+    if `arguments.length === 0`
+      return []
+    end
 
-      if (arguments.length == 0)
-        return [];
+    if `arguments.length === 1`
+      if Array === size
+        return size.to_a
+      elsif size.respond_to? :to_ary
+        return size.to_ary
+      end
+    end
 
-      var size,
-          obj = arguments[1],
-          arr = [];
+    size = Opal.coerce_to size, Integer, :to_int
 
-      if (!obj) {
-        if (#{size.respond_to? :to_ary}) {
-          if (size['$is_a?'](Array))
-            return size;
-          return size['$to_ary']();
-        }
-      }
-
-      if (typeof(arguments[0]) == 'number')
-        size = arguments[0];
-      else {
-        if (#{`arguments[0]`.respond_to? :to_int}) {
-          size = arguments[0]['$to_int']();
-          if (typeof(size) == 'number') {
-            if (size % 1 !== 0) {
-              #{raise TypeError.new("can't convert to Integer. Array#new")};
-            }
-          } else {
-            #{raise TypeError.new("can't convert to Integer. Array#new")};
-          }
-        } else {
-          #{raise TypeError.new("can't convert to Integer. Array#new")};
-        }
-      }
-
-      if (size < 0) {
-        #{raise ArgumentError.new("negative array size")};
-      }
-
-      if (obj == undefined) {
-        obj = nil;
-      }
+    if `size < 0`
+      raise ArgumentError, "negative array size"
+    end
 
+    %x{
+      var result = [];
 
-      if (block === nil)
+      if (block === nil) {
         for (var i = 0; i < size; i++) {
-          arr.push(obj);
+          result.push(obj);
         }
+      }
       else {
         for (var i = 0, value; i < size; i++) {
           value = block(i);
+
           if (value === $breaker) {
             return $breaker.$v;
           }
-          arr[i] = block(i);
+
+          result[i] = value;
         }
       }
 
-      return arr;
+      return result;
     }
   end
 
   def self.try_convert(obj)
-    %x{
-      if (obj._isArray) {
-        return obj;
-      }
+    return obj if Array === obj
+    return obj.to_ary if obj.respond_to? :to_ary
 
-      return nil;
-    }
+    nil
   end
 
   def &(other)
+    if Array === other
+      other = other.to_a
+    else
+      other = Opal.coerce_to other, Array, :to_ary
+    end
+
     %x{
       var result = [],
           seen   = {};
 
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        var item = #{self}[i];
-        if (item._isString) {
-          item = item.toString();
-        }
+      for (var i = 0, length = self.length; i < length; i++) {
+        var item = self[i];
 
         if (!seen[item]) {
           for (var j = 0, length2 = other.length; j < length2; j++) {
             var item2 = other[j];
-            if (item2._isString) {
-              item2 = item2.toString();
-            }
 
-            if (item === item2 && !seen[item]) {
+            if (!seen[item2] && #{`item` == `item2`}) {
               seen[item] = true;
-
               result.push(item);
             }
           }
@@ -119,15 +97,23 @@ class Array
   end
 
   def *(other)
-    %x{
-      if (typeof(other) === 'string') {
-        return #{self}.join(other);
-      }
+    return `self.join(#{other.to_str})` if other.respond_to? :to_str
 
+    unless other.respond_to? :to_int
+      raise TypeError, "no implicit conversion of #{other.class} into Integer"
+    end
+
+    other = Opal.coerce_to other, Integer, :to_int
+
+    if `other < 0`
+      raise ArgumentError, "negative argument"
+    end
+
+    %x{
       var result = [];
 
       for (var i = 0; i < other; i++) {
-        result = result.concat(#{self});
+        result = result.concat(self);
       }
 
       return result;
@@ -135,75 +121,73 @@ class Array
   end
 
   def +(other)
-    %x{
-      var arr = other;
+    if Array === other
+      other = other.to_a
+    else
+      other = Opal.coerce_to other, Array, :to_ary
+    end
 
-      if (!other._isArray){
-        if (#{other.respond_to?(:to_ary)}) {
-          arr = other['$to_ary']();
-        }
-        else {
-          #{raise TypeError.new("can't convert to Array. Array#+") };
-        }
-      }
-
-      return #{self}.concat(arr);
-    }
+    `self.concat(other)`
   end
 
   def -(other)
+    if Array === other
+      other = other.to_a
+    else
+      other = Opal.coerce_to other, Array, :to_ary
+    end
+
+    return [] if `self.length === 0`
+    return clone if `other.length === 0`
+
     %x{
-      var a = #{self},
-          b = #{other},
-          tmp = [],
+      var seen   = {},
           result = [];
 
-     if (typeof(b) == "object" && !(b._isArray))  {
-        if (#{other.respond_to? :to_ary}) {
-          b = b['$to_ary']();
-        } else {
-          #{raise TypeError.new("can't convert to Array. Array#-") };
-        }
-      }else if ((typeof(b) != "object")) {
-        #{raise TypeError.new("can't convert to Array. Array#-") };
+      for (var i = 0, length = other.length; i < length; i++) {
+        seen[other[i]] = true;
       }
 
-      if (a.length == 0)
-        return [];
-      if (b.length == 0)
-        return a;
+      for (var i = 0, length = self.length; i < length; i++) {
+        var item = self[i];
 
-      for(var i = 0, length = b.length; i < length; i++) {
-        tmp[b[i]] = true;
-      }
-      for(var i = 0, length = a.length; i < length; i++) {
-        if (!tmp[a[i]]) {
-          result.push(a[i]);
+        if (!seen[item]) {
+          result.push(item);
         }
-     }
+      }
 
       return result;
     }
   end
 
   def <<(object)
-    `#{self}.push(object);`
+    `self.push(object);`
 
     self
   end
 
   def <=>(other)
+    if Array === other
+      other = other.to_a
+    elsif other.respond_to? :to_ary
+      other = other.to_ary
+    else
+      return
+    end
+
     %x{
-      if (#{self.hash} === #{other.hash}) {
+      if (#{hash} === #{other.hash}) {
         return 0;
       }
 
-      if (#{self}.length != other.length) {
-        return (#{self}.length > other.length) ? 1 : -1;
+      if (self.length != other.length) {
+        return (self.length > other.length) ? 1 : -1;
       }
 
-      for (var i = 0, length = #{self}.length, tmp; i < length; i++) {
-        if ((tmp = #{`#{self}[i]` <=> `other[i]`}) !== 0) {
+      for (var i = 0, length = self.length; i < length; i++) {
+        var tmp = #{`self[i]` <=> `other[i]`};
+
+        if (tmp !== 0) {
           return tmp;
         }
       }
@@ -213,33 +197,35 @@ class Array
   end
 
   def ==(other)
+    return false unless Array === other
+
+    other = other.to_a
+
     %x{
-      if (!other || (#{self}.length !== other.length)) {
+      if (self.length !== other.length) {
         return false;
       }
 
-      for (var i = 0, length = #{self}.length, tmp1, tmp2; i < length; i++) {
-        tmp1 = #{self}[i];
-        tmp2 = #{other}[i];
+      for (var i = 0, length = self.length; i < length; i++) {
+        var a = self[i],
+            b = other[i];
 
-        if (tmp1._isArray && tmp2._isArray && (tmp1 === #{self})) {
+        if (a._isArray && b._isArray && (a === self)) {
           continue;
         }
 
-        if (!(#{`tmp1` == `tmp2`})) {
+        if (!(#{`a` == `b`})) {
           return false;
         }
-
       }
-
-
-      return true;
     }
+
+    true
   end
 
   def [](index, length = undefined)
     %x{
-      var size = #{self}.length;
+      var size = self.length;
 
       if (typeof index !== 'number' && !index._isNumber) {
         if (index._isRange) {
@@ -256,7 +242,7 @@ class Array
           }
 
           if (!exclude) length += 1;
-          return #{self}.slice(index, length);
+          return self.slice(index, length);
         }
         else {
           #{ raise "bad arg for Array#[]" };
@@ -272,34 +258,76 @@ class Array
           return nil;
         }
 
-        return #{self}.slice(index, index + length);
+        return self.slice(index, index + length);
       }
       else {
         if (index >= size || index < 0) {
           return nil;
         }
 
-        return #{self}[index];
+        return self[index];
       }
     }
   end
 
-  def []=(index, value)
+  def []=(index, value, extra = undefined)
     %x{
-      var size = #{self}.length;
+      var size = self.length;
+
+      if (typeof index !== 'number' && !index._isNumber) {
+        if (index._isRange) {
+          var exclude = index.exclude;
+          extra = value;
+          value = index.end;
+          index = index.begin;
+
+          if (value < 0) {
+            value += size;
+          }
+
+          if (!exclude) value += 1;
+
+          value = value - index;
+        }
+        else {
+          #{raise ArgumentError};
+        }
+      }
 
       if (index < 0) {
         index += size;
       }
 
-      return #{self}[index] = value;
+      if (extra != null) {
+        if (value < 0) {
+          #{raise IndexError};
+        }
+
+        if (index > size) {
+          for (var i = size; index > i; i++) {
+            self[i] = nil;
+          }
+        }
+
+        self.splice.apply(self, [index, value].concat(extra));
+
+        return extra;
+      }
+
+      if (index > size) {
+        for (var i = size; i < index; i++) {
+          self[i] = nil;
+        }
+      }
+
+      return self[index] = value;
     }
   end
 
   def assoc(object)
     %x{
-      for (var i = 0, length = #{self}.length, item; i < length; i++) {
-        if (item = #{self}[i], item.length && #{`item[0]` == object}) {
+      for (var i = 0, length = self.length, item; i < length; i++) {
+        if (item = self[i], item.length && #{`item[0]` == object}) {
           return item;
         }
       }
@@ -309,36 +337,68 @@ class Array
   end
 
   def at(index)
+    index = Opal.coerce_to index, Integer, :to_int
+
     %x{
       if (index < 0) {
-        index += #{self}.length;
+        index += self.length;
       }
 
-      if (index < 0 || index >= #{self}.length) {
+      if (index < 0 || index >= self.length) {
         return nil;
       }
 
-      return #{self}[index];
+      return self[index];
     }
   end
 
+  def cycle(n = nil, &block)
+    return if `self.length === 0 || n === 0`
+    return enum_for :cycle, n unless block
+
+    if `n === nil`
+      while true
+        if `#{(value = each(&block))} !== self`
+          return value
+        end
+      end
+    else
+      cycles = Opal.coerce_to n, Integer, :to_int
+
+      unless Integer === cycles
+        raise TypeError, "can't convert #{n.class} into Integer (#{n.class}#to_int gives #{cycles.class}"
+      end
+
+      while cycles > 0
+        each(&block)
+
+        cycles -= 1
+      end
+    end
+
+    self
+  end
+
   def clear
-    `#{self}.splice(0, #{self}.length)`
+    `self.splice(0, self.length)`
 
     self
   end
 
   def clone
-    `#{self}.slice()`
+    `self.slice()`
   end
 
   def collect(&block)
+    return enum_for :collect unless block_given?
+
     %x{
       var result = [];
 
+      for (var i = 0, length = self.length; i < length; i++) {
+        var value = Opal.$yield1(block, self[i]);
 
-      for (var i = 0, length = #{self}.length, value; i < length; i++) {
-        if ((value = block(#{self}[i])) === $breaker) {
+        if (value === $breaker) {
           return $breaker.$v;
         }
 
@@ -350,13 +410,17 @@ class Array
   end
 
   def collect!(&block)
+    return enum_for :collect! unless block_given?
+
     %x{
-      for (var i = 0, length = #{self}.length, val; i < length; i++) {
-        if ((val = block(#{self}[i])) === $breaker) {
+      for (var i = 0, length = self.length; i < length; i++) {
+        var value = Opal.$yield1(block, self[i]);
+
+        if (value === $breaker) {
           return $breaker.$v;
         }
 
-        #{self}[i] = val;
+        self[i] = value;
       }
     }
 
@@ -367,8 +431,8 @@ class Array
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length, item; i < length; i++) {
-        if ((item = #{self}[i]) !== nil) {
+      for (var i = 0, length = self.length, item; i < length; i++) {
+        if ((item = self[i]) !== nil) {
           result.push(item);
         }
       }
@@ -379,93 +443,77 @@ class Array
 
   def compact!
     %x{
-      var original = #{self}.length;
+      var original = self.length;
 
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        if (#{self}[i] === nil) {
-          #{self}.splice(i, 1);
+      for (var i = 0, length = self.length; i < length; i++) {
+        if (self[i] === nil) {
+          self.splice(i, 1);
 
           length--;
           i--;
         }
       }
 
-      return #{self}.length === original ? nil : #{self};
+      return self.length === original ? nil : self;
     }
   end
 
   def concat(other)
     %x{
       for (var i = 0, length = other.length; i < length; i++) {
-        #{self}.push(other[i]);
+        self.push(other[i]);
       }
     }
 
     self
   end
 
-  def count(object = undefined)
-    %x{
-      if (object == null) {
-        return #{self}.length;
-      }
-
-      var result = 0;
-
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        if (#{`#{self}[i]` == object}) {
-          result++;
-        }
-      }
-
-      return result;
-    }
-  end
-
   def delete(object)
     %x{
-      var original = #{self}.length;
+      var original = self.length;
 
       for (var i = 0, length = original; i < length; i++) {
-        if (#{`#{self}[i]` == object}) {
-          #{self}.splice(i, 1);
+        if (#{`self[i]` == object}) {
+          self.splice(i, 1);
 
           length--;
           i--;
         }
       }
 
-      return #{self}.length === original ? nil : object;
+      return self.length === original ? nil : object;
     }
   end
 
   def delete_at(index)
     %x{
       if (index < 0) {
-        index += #{self}.length;
+        index += self.length;
       }
 
-      if (index < 0 || index >= #{self}.length) {
+      if (index < 0 || index >= self.length) {
         return nil;
       }
 
-      var result = #{self}[index];
+      var result = self[index];
 
-      #{self}.splice(index, 1);
+      self.splice(index, 1);
 
       return result;
     }
   end
 
   def delete_if(&block)
+    return enum_for :delete_if unless block_given?
+
     %x{
-      for (var i = 0, length = #{self}.length, value; i < length; i++) {
-        if ((value = block(#{self}[i])) === $breaker) {
+      for (var i = 0, length = self.length, value; i < length; i++) {
+        if ((value = block(self[i])) === $breaker) {
           return $breaker.$v;
         }
 
         if (value !== false && value !== nil) {
-          #{self}.splice(i, 1);
+          self.splice(i, 1);
 
           length--;
           i--;
@@ -477,7 +525,13 @@ class Array
   end
 
   def drop(number)
-    `#{self}.slice(number)`
+    %x{
+      if (number < 0) {
+        #{raise ArgumentError}
+      }
+
+      return self.slice(number);
+    }
   end
 
   alias dup clone
@@ -486,16 +540,11 @@ class Array
     return enum_for :each unless block_given?
 
     %x{
-      if (block.length > 1) {
-        for (var i = 0, length = #{self}.length, el; i < length; i++) {
-          el = #{self}[i];
-          if (!el._isArray) el = [el];
+      for (var i = 0, length = self.length; i < length; i++) {
+        var value = $opal.$yield1(block, self[i]);
 
-          if (block.apply(null, el) === $breaker) return $breaker.$v;
-        }
-      } else {
-        for (var i = 0, length = #{self}.length; i < length; i++) {
-          if (block(#{self}[i]) === $breaker) return $breaker.$v;
+        if (value == $breaker) {
+          return $breaker.$v;
         }
       }
     }
@@ -504,15 +553,23 @@ class Array
   end
 
   def each_index(&block)
-    `for (var i = 0, length = #{self}.length; i < length; i++) {`
-      yield `i`
-    `}`
+    return enum_for :each_index unless block_given?
+
+    %x{
+      for (var i = 0, length = self.length; i < length; i++) {
+        var value = $opal.$yield1(block, i);
+
+        if (value === $breaker) {
+          return $breaker.$v;
+        }
+      }
+    }
 
     self
   end
 
   def empty?
-    `!#{self}.length`
+    `self.length === 0`
   end
 
   def fetch(index, defaults = undefined, &block)
@@ -520,38 +577,110 @@ class Array
       var original = index;
 
       if (index < 0) {
-        index += #{self}.length;
+        index += self.length;
       }
 
-      if (index >= 0 && index < #{self}.length) {
-        return #{self}[index];
-      }
-
-      if (defaults != null) {
-        return defaults;
+      if (index >= 0 && index < self.length) {
+        return self[index];
       }
 
       if (block !== nil) {
         return block(original);
       }
 
+      if (defaults != null) {
+        return defaults;
+      }
+
       #{ raise IndexError, "Array#fetch" };
     }
   end
 
-  def fill(obj = undefined, &block)
-    %x{
-      if (block !== nil) {
-        for (var i = 0, length = #{self}.length; i < length; i++) {
-          #{self}[i] = block(i);
+  def fill(*args, &block)
+    if block
+      if `args.length > 2`
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 0..2)"
+      end
+
+      one, two = args
+    else
+      if `args.length == 0`
+        raise ArgumentError, "wrong number of arguments (0 for 1..3)"
+      elsif `args.length > 3`
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 1..3)"
+      end
+
+      obj, one, two = args
+    end
+
+    if Range === one
+      raise TypeError, "length invalid with range" if two
+
+      left   = Opal.coerce_to one.begin, Integer, :to_int
+      `left += #@length` if `left < 0`
+      raise RangeError, "#{one.inspect} out of range" if `left < 0`
+
+      right  = Opal.coerce_to one.end, Integer, :to_int
+      `right += #@length` if `right < 0`
+      `right += 1` unless one.exclude_end?
+
+      return self if `right <= left`
+    elsif one
+      left   = Opal.coerce_to one, Integer, :to_int
+      `left += #@length` if `left < 0`
+      left   = 0 if `left < 0`
+
+      if two
+        right = Opal.coerce_to two, Integer, :to_int
+
+        return self if `right == 0`
+
+        `right += left`
+      else
+        right = @length
+      end
+    else
+      left  = 0
+      right = @length
+    end
+
+    if `right > 2147483648`
+      raise RangeError, "bignum too big to convert into `long'"
+    elsif `right >= 536870910`
+      raise ArgumentError, "argument too big"
+    end
+
+    if `left > #@length`
+      %x{
+        for (var i = #@length; i < right; i++) {
+          self[i] = nil;
         }
       }
-      else {
-        for (var i = 0, length = #{self}.length; i < length; i++) {
-          #{self}[i] = obj;
+    end
+
+    if `right > #@length`
+      @length = right
+    end
+
+    if block
+      %x{
+        for (var length = #@length; left < right; left++) {
+          var value = block(left);
+
+          if (value === $breaker) {
+            return $breaker.$v;
+          }
+
+          self[left] = value;
         }
       }
-    }
+    else
+      %x{
+        for (var length = #@length; left < right; left++) {
+          self[left] = #{obj};
+        }
+      }
+    end
 
     self
   end
@@ -559,10 +688,15 @@ class Array
   def first(count = undefined)
     %x{
       if (count != null) {
-        return #{self}.slice(0, count);
+
+        if (count < 0) {
+          #{raise ArgumentError};
+        }
+
+        return self.slice(0, count);
       }
 
-      return #{self}.length === 0 ? nil : #{self}[0];
+      return self.length === 0 ? nil : self[0];
     }
   end
 
@@ -570,10 +704,12 @@ class Array
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length, item; i < length; i++) {
-        item = #{self}[i];
+      for (var i = 0, length = self.length; i < length; i++) {
+        var item = self[i];
+
+        if (#{`item`.respond_to?(:to_ary)}) {
+          item = #{`item`.to_ary};
 
-        if (item._isArray) {
           if (level == null) {
             result = result.concat(#{`item`.flatten});
           }
@@ -595,21 +731,34 @@ class Array
 
   def flatten!(level = undefined)
     %x{
-      var size = #{self}.length;
-      #{replace flatten level};
+      var flattened = #{flatten level};
 
-      return size === #{self}.length ? nil : #{self};
+      if (self.length == flattened.length) {
+        for (var i = 0, length = self.length; i < length; i++) {
+          if (self[i] !== flattened[i]) {
+            break;
+          }
+        }
+
+        if (i == length) {
+          return nil;
+        }
+      }
+
+      #{replace `flattened`};
     }
+
+    self
   end
 
   def hash
-    `#{self}._id || (#{self}._id = Opal.uid())`
+    `self._id || (self._id = Opal.uid())`
   end
 
   def include?(member)
     %x{
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        if (#{`#{self}[i]` == member}) {
+      for (var i = 0, length = self.length; i < length; i++) {
+        if (#{`self[i]` == member}) {
           return true;
         }
       }
@@ -621,15 +770,15 @@ class Array
   def index(object=undefined, &block)
     %x{
       if (object != null) {
-        for (var i = 0, length = #{self}.length; i < length; i++) {
-          if (#{`#{self}[i]` == object}) {
+        for (var i = 0, length = self.length; i < length; i++) {
+          if (#{`self[i]` == object}) {
             return i;
           }
         }
       }
       else if (block !== nil) {
-        for (var i = 0, length = #{self}.length, value; i < length; i++) {
-          if ((value = block(#{self}[i])) === $breaker) {
+        for (var i = 0, length = self.length, value; i < length; i++) {
+          if ((value = block(self[i])) === $breaker) {
             return $breaker.$v;
           }
 
@@ -638,6 +787,9 @@ class Array
           }
         }
       }
+      else {
+        return #{enum_for :index};
+      }
 
       return nil;
     }
@@ -647,19 +799,19 @@ class Array
     %x{
       if (objects.length > 0) {
         if (index < 0) {
-          index += #{self}.length + 1;
+          index += self.length + 1;
 
           if (index < 0) {
             #{ raise IndexError, "#{index} is out of bounds" };
           }
         }
-        if (index > #{self}.length) {
-          for (var i = #{self}.length; i < index; i++) {
-            #{self}.push(nil);
+        if (index > self.length) {
+          for (var i = self.length; i < index; i++) {
+            self.push(nil);
           }
         }
 
-        #{self}.splice.apply(#{self}, [index, 0].concat(objects));
+        self.splice.apply(self, [index, 0].concat(objects));
       }
     }
 
@@ -672,7 +824,7 @@ class Array
 
       inspect = [];
       object_id = #{object_id};
-      length = #{self}.length;
+      length = self.length;
 
       for (i = 0; i < length; i++) {
         el = #{self[`i`]};
@@ -690,8 +842,8 @@ class Array
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length; i < length; i++) {
-        result.push(#{`#{self}[i]`.to_s});
+      for (var i = 0, length = self.length; i < length; i++) {
+        result.push(#{`self[i]`.to_s});
       }
 
       return result.join(sep);
@@ -699,14 +851,16 @@ class Array
   end
 
   def keep_if(&block)
+    return enum_for :keep_if unless block_given?
+
     %x{
-      for (var i = 0, length = #{self}.length, value; i < length; i++) {
-        if ((value = block(#{self}[i])) === $breaker) {
+      for (var i = 0, length = self.length, value; i < length; i++) {
+        if ((value = block(self[i])) === $breaker) {
           return $breaker.$v;
         }
 
         if (value === false || value === nil) {
-          #{self}.splice(i, 1);
+          self.splice(i, 1);
 
           length--;
           i--;
@@ -719,7 +873,7 @@ class Array
 
   def last(count = undefined)
     %x{
-      var length = #{self}.length;
+      var length = self.length;
 
       if (count === nil || typeof(count) == 'string') {
         #{ raise TypeError, "no implicit conversion to integer" };
@@ -735,7 +889,7 @@ class Array
       }
 
       if (count == null) {
-        return length === 0 ? nil : #{self}[length - 1];
+        return length === 0 ? nil : self[length - 1];
       }
       else if (count < 0) {
         #{ raise ArgumentError, "negative count given" };
@@ -745,12 +899,12 @@ class Array
         count = length;
       }
 
-      return #{self}.slice(length - count, length);
+      return self.slice(length - count, length);
     }
   end
 
   def length
-    `#{self}.length`
+    `self.length`
   end
 
   alias map collect
@@ -759,24 +913,24 @@ class Array
 
   def pop(count = undefined)
     %x{
-      var length = #{self}.length;
+      var length = self.length;
 
       if (count == null) {
-        return length === 0 ? nil : #{self}.pop();
+        return length === 0 ? nil : self.pop();
       }
 
       if (count < 0) {
-        #{ raise "negative count given" };
+        #{ raise ArgumentError, "negative count given" };
       }
 
-      return count > length ? #{self}.splice(0, #{self}.length) : #{self}.splice(length - count, length);
+      return count > length ? self.splice(0, self.length) : self.splice(length - count, length);
     }
   end
 
   def push(*objects)
     %x{
       for (var i = 0, length = objects.length; i < length; i++) {
-        #{self}.push(objects[i]);
+        self.push(objects[i]);
       }
     }
 
@@ -785,8 +939,8 @@ class Array
 
   def rassoc(object)
     %x{
-      for (var i = 0, length = #{self}.length, item; i < length; i++) {
-        item = #{self}[i];
+      for (var i = 0, length = self.length, item; i < length; i++) {
+        item = self[i];
 
         if (item.length && item[1] !== undefined) {
           if (#{`item[1]` == object}) {
@@ -800,16 +954,18 @@ class Array
   end
 
   def reject(&block)
+    return enum_for :reject unless block_given?
+
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length, value; i < length; i++) {
-        if ((value = block(#{self}[i])) === $breaker) {
+      for (var i = 0, length = self.length, value; i < length; i++) {
+        if ((value = block(self[i])) === $breaker) {
           return $breaker.$v;
         }
 
         if (value === false || value === nil) {
-          result.push(#{self}[i]);
+          result.push(self[i]);
         }
       }
       return result;
@@ -817,40 +973,51 @@ class Array
   end
 
   def reject!(&block)
+    return enum_for :reject! unless block_given?
+
     %x{
-      var original = #{self}.length;
+      var original = self.length;
       #{ delete_if &block };
-      return #{self}.length === original ? nil : #{self};
+      return self.length === original ? nil : self;
     }
   end
 
   def replace(other)
     %x{
-      #{self}.splice(0, #{self}.length);
-      #{self}.push.apply(#{self}, other);
-      return #{self};
+      self.splice(0, self.length);
+      self.push.apply(self, other);
     }
+
+    self
   end
 
   def reverse
-    `#{self}.slice(0).reverse()`
+    `self.slice(0).reverse()`
   end
 
   def reverse!
-    `#{self}.reverse()`
+    `self.reverse()`
   end
 
   def reverse_each(&block)
-    reverse.each &block
+    return enum_for :reverse_each unless block_given?
 
+    reverse.each &block
     self
   end
 
   def rindex(object = undefined, &block)
     %x{
-      if (block !== nil) {
-        for (var i = #{self}.length - 1, value; i >= 0; i--) {
-          if ((value = block(#{self}[i])) === $breaker) {
+      if (object != null) {
+        for (var i = self.length - 1; i >= 0; i--) {
+          if (#{`self[i]` == `object`}) {
+            return i;
+          }
+        }
+      }
+      else if (block !== nil) {
+        for (var i = self.length - 1, value; i >= 0; i--) {
+          if ((value = block(self[i])) === $breaker) {
             return $breaker.$v;
           }
 
@@ -859,24 +1026,35 @@ class Array
           }
         }
       }
-      else {
-        for (var i = #{self}.length - 1; i >= 0; i--) {
-          if (#{`#{self}[i]` == `object`}) {
-            return i;
-          }
-        }
+      else if (object == null) {
+        return #{enum_for :rindex};
       }
 
       return nil;
     }
   end
 
+  def sample(n = nil)
+    return nil if !n && empty?
+    return []  if  n && empty?
+
+    if n
+      (1 .. n).map {
+        self[rand(length)]
+      }
+    else
+      self[rand(length)]
+    end
+  end
+
   def select(&block)
+    return enum_for :select unless block_given?
+
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length, item, value; i < length; i++) {
-        item = #{self}[i];
+      for (var i = 0, length = self.length, item, value; i < length; i++) {
+        item = self[i];
 
         if ((value = block(item)) === $breaker) {
           return $breaker.$v;
@@ -892,143 +1070,136 @@ class Array
   end
 
   def select!(&block)
+    return enum_for :select! unless block_given?
+
     %x{
-      var original = #{self}.length;
+      var original = self.length;
       #{ keep_if &block };
-      return #{self}.length === original ? nil : #{self};
+      return self.length === original ? nil : self;
     }
   end
 
   def shift(count = undefined)
     %x{
-      if (#{self}.length === 0) {
+      if (self.length === 0) {
         return nil;
       }
 
-      return count == null ? #{self}.shift() : #{self}.splice(0, count)
+      return count == null ? self.shift() : self.splice(0, count)
     }
   end
 
   alias size length
 
   def shuffle
+    clone.shuffle!
+  end
+
+  def shuffle!
     %x{
-        for (var i = #{self}.length - 1; i > 0; i--) {
-          var j = Math.floor(Math.random() * (i + 1));
-          var tmp = #{self}[i];
-          #{self}[i] = #{self}[j];
-          #{self}[j] = tmp;
-        }
+      for (var i = self.length - 1; i > 0; i--) {
+        var tmp = self[i],
+            j   = Math.floor(Math.random() * (i + 1));
 
-        return #{self};
+        self[i] = self[j];
+        self[j] = tmp;
+      }
     }
+
+    self
   end
 
-  alias slice :[]
+  alias slice []
 
   def slice!(index, length = undefined)
     %x{
       if (index < 0) {
-        index += #{self}.length;
+        index += self.length;
       }
 
       if (length != null) {
-        return #{self}.splice(index, length);
+        return self.splice(index, length);
       }
 
-      if (index < 0 || index >= #{self}.length) {
+      if (index < 0 || index >= self.length) {
         return nil;
       }
 
-      return #{self}.splice(index, 1)[0];
+      return self.splice(index, 1)[0];
     }
   end
 
   def sort(&block)
+    return self unless `self.length > 1`
+
     %x{
-      var copy = #{self}.slice();
-      var t_arg_error = false;
-      var t_break = [];
+      if (!#{block_given?}) {
+        block = function(a, b) {
+          return #{`a` <=> `b`};
+        };
+      }
 
-      if (block !== nil) {
-        var result = copy.sort(function(x, y) {
-          var result = block(x, y);
-          if (result === $breaker) {
-            t_break.push($breaker.$v);
-          }
-          if (result === nil) {
-            t_arg_error = true;
-          }
-          if ((result != null) && #{ `result`.respond_to? :<=> }) {
-            result = result['$<=>'](0);
+      try {
+        return self.slice().sort(function(x, y) {
+          var ret = block(x, y);
+
+          if (ret === $breaker) {
+            throw $breaker;
           }
-          if (result !== -1 && result !== 0 && result !== 1) {
-            t_arg_error = true;
+          else if (ret === nil) {
+            #{raise ArgumentError, "comparison of #{`x`.inspect} with #{`y`.inspect} failed"};
           }
-          return result;
-        });
-
-        if (t_break.length > 0)
-          return t_break[0];
-        if (t_arg_error)
-          #{raise ArgumentError, "Array#sort"};
 
-        return result;
+          return #{`ret` > 0} ? 1 : (#{`ret` < 0} ? -1 : 0);
+        });
       }
-
-      var result = copy.sort(function(a, b){
-        if (typeof(a) !== typeof(b)) {
-          t_arg_error = true;
+      catch (e) {
+        if (e === $breaker) {
+          return $breaker.$v;
         }
-
-        if (a['$<=>'] && typeof(a['$<=>']) == "function") {
-          var result = a['$<=>'](b);
-          if (result === nil) {
-            t_arg_error = true;
-          }
-          return result;
+        else {
+          throw e;
         }
-        if (a > b)
-          return 1;
-        if (a < b)
-          return -1;
-        return 0;
-      });
-
-      if (t_arg_error)
-        #{raise ArgumentError, "Array#sort"};
-
-      return result;
+      }
     }
   end
 
   def sort!(&block)
     %x{
       var result;
-      if (block !== nil) {
-        //strangely
-        result = #{self}.slice().sort(block);
-      } else {
-        result = #{self}.slice()['$sort']();
+
+      if (#{block_given?}) {
+        result = #{`self.slice()`.sort(&block)};
+      }
+      else {
+        result = #{`self.slice()`.sort};
       }
-      #{self}.length = 0;
-      for(var i = 0; i < result.length; i++) {
-        #{self}.push(result[i]);
+
+      self.length = 0;
+      for(var i = 0, length = result.length; i < length; i++) {
+        self.push(result[i]);
       }
-      return #{self};
+
+      return self;
     }
   end
 
   def take(count)
-    `#{self}.slice(0, count)`
+    %x{
+      if (count < 0) {
+        #{raise ArgumentError};
+      }
+
+      return self.slice(0, count);
+    }
   end
 
   def take_while(&block)
     %x{
       var result = [];
 
-      for (var i = 0, length = #{self}.length, item, value; i < length; i++) {
-        item = #{self}[i];
+      for (var i = 0, length = self.length, item, value; i < length; i++) {
+        item = self[i];
 
         if ((value = block(item)) === $breaker) {
           return $breaker.$v;
@@ -1055,11 +1226,11 @@ class Array
     %x{
       var result = [], obj
 
-      for (var i = 0, len = #{self}.length; i < len; i++) {
-        obj = #{self}[i];
+      for (var i = 0, len = self.length; i < len; i++) {
+        obj = self[i];
 
-        if (obj.$to_n) {
-          result.push(#{ `obj`.to_n });
+        if (#{`obj`.respond_to? :to_n}) {
+          result.push(#{`obj`.to_n});
         }
         else {
           result.push(obj);
@@ -1070,69 +1241,96 @@ class Array
     }
   end
 
-
   alias to_s inspect
 
+  def transpose
+    return [] if empty?
+
+    result = []
+    max    = nil
+
+    each {|row|
+      if Array === row
+        row = row.to_a
+      else
+        row = Opal.coerce_to row, Array, :to_ary
+      end
+
+      max ||= `row.length`
+
+      if `row.length` != max
+        raise IndexError, "element size differs (#{`row.length`} should be #{max}"
+      end
+
+      `row.length`.times {|i|
+        entry = (result[i] ||= [])
+        entry << row.at(i)
+      }
+    }
+
+    result
+  end
+
   def uniq
     %x{
       var result = [],
           seen   = {};
-
-      for (var i = 0, length = #{self}.length, item, hash; i < length; i++) {
-        item = #{self}[i];
+   
+      for (var i = 0, length = self.length, item, hash; i < length; i++) {
+        item = self[i];
         hash = item;
-
+   
         if (!seen[hash]) {
           seen[hash] = true;
-
+   
           result.push(item);
         }
       }
-
+   
       return result;
     }
   end
 
   def uniq!
     %x{
-      var original = #{self}.length,
+      var original = self.length,
           seen     = {};
 
       for (var i = 0, length = original, item, hash; i < length; i++) {
-        item = #{self}[i];
+        item = self[i];
         hash = item;
 
         if (!seen[hash]) {
           seen[hash] = true;
         }
         else {
-          #{self}.splice(i, 1);
+          self.splice(i, 1);
 
           length--;
           i--;
         }
       }
 
-      return #{self}.length === original ? nil : #{self};
+      return self.length === original ? nil : self;
     }
   end
 
   def unshift(*objects)
     %x{
       for (var i = objects.length - 1; i >= 0; i--) {
-        #{self}.unshift(objects[i]);
+        self.unshift(objects[i]);
       }
-
-      return #{self};
     }
+
+    self
   end
 
   def zip(*others, &block)
     %x{
-      var result = [], size = #{self}.length, part, o;
+      var result = [], size = self.length, part, o;
 
       for (var i = 0; i < size; i++) {
-        part = [#{self}[i]];
+        part = [self[i]];
 
         for (var j = 0, jj = others.length; j < jj; j++) {
           o = others[j][i];