opal 0.8.1 → 0.9.0.beta1

data/lib/opal/parser/grammar.y

@@ -8,14 +8,14 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
       tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
       tREGEXP_END tUPLUS tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ tGEQ tLEQ tANDOP
-      tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF tASET tLSHFT tRSHFT
+      tOROP tMATCH tNMATCH tJSDOT tDOT tDOT2 tDOT3 tAREF tASET tLSHFT tRSHFT
       tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN tLPAREN2 tRPAREN tLPAREN_ARG
       ARRAY_BEG tRBRACK tLBRACE tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2
       tTILDE tPERCENT tDIVIDE tPLUS tMINUS tLT tGT tPIPE tBANG tCARET
       tLCURLY tRCURLY tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
       tWORDS_BEG tAWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
       tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG
-      tLBRACK2 tLBRACK tDSTAR
+      tLBRACK2 tLBRACK tJSLBRACK tDSTAR
 
 prechigh
   right    tBANG tTILDE tUPLUS
@@ -150,6 +150,7 @@ rule
                       result = new_op_asgn val[1], val[0], val[2]
                     }
                 | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN command_call
+                | primary_value tJSLBRACK aref_args tRBRACK tOP_ASGN command_call
                 | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
                     {
                       result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
@@ -208,6 +209,7 @@ rule
                     }
 
    block_command: block_call
+                | block_call tJSDOT operation2 command_args
                 | block_call tDOT operation2 command_args
                 | block_call tCOLON2 operation2 command_args
 
@@ -218,6 +220,11 @@ rule
                       result = new_call(nil, val[0], val[1])
                     }
                 | operation command_args cmd_brace_block
+                | primary_value tJSDOT operation2 command_args =tLOWEST
+                    {
+                      result = new_js_call(val[0], val[2], val[3])
+                    }
+                | primary_value tJSDOT operation2 command_args cmd_brace_block
                 | primary_value tDOT operation2 command_args =tLOWEST
                     {
                       result = new_call(val[0], val[2], val[3])
@@ -327,6 +334,10 @@ rule
                     {
                       result = new_assignable val[0]
                     }
+                | primary_value tJSLBRACK aref_args tRBRACK
+                    {
+                      result = new_js_attrasgn(val[0], val[2])
+                    }
                 | primary_value tLBRACK2 aref_args tRBRACK
                     {
                       result = new_attrasgn(val[0], :[]=, val[2])
@@ -428,6 +439,10 @@ rule
                     {
                       result = new_op_asgn1(val[0], val[2], val[4], val[5])
                     }
+                | primary_value tJSLBRACK aref_args tRBRACK tOP_ASGN arg
+                    {
+                      raise ".JS[...] #{val[4]} is not supported"
+                    }
                 | primary_value tDOT tIDENTIFIER tOP_ASGN arg
                     {
                       result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
@@ -537,8 +552,7 @@ rule
                     }
                 | arg tNEQ arg
                     {
-                      result = new_unary_call(['!', []], new_binary_call(
-                                 val[0], ['==', []], val[2]))
+                      result = new_binary_call(val[0], val[1], val[2])
                     }
                 | arg tMATCH arg
                     {
@@ -546,8 +560,7 @@ rule
                     }
                 | arg tNMATCH arg
                     {
-                      result = new_not(val[1], new_binary_call(
-                                 val[0], ['=~', []], val[2]))
+                      result = new_binary_call(val[0], val[1], val[2])
                     }
                 | tBANG arg
                     {
@@ -657,6 +670,7 @@ rule
                     {
                       result = val[0]
                       result << new_hash(nil, val[2], nil)
+                      result << val[3] if val[3]
                     }
                 | block_arg
                     {
@@ -769,6 +783,10 @@ rule
                     {
                       result = new_call val[0], [:[], []], val[2]
                     }
+                | primary_value tJSLBRACK aref_args tRBRACK
+                    {
+                      result = new_js_call val[0], [:[], []], val[2]
+                    }
                 | tLBRACK aref_args tRBRACK
                     {
                       result = new_array(val[0], val[1], val[2])
@@ -1098,6 +1116,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       val[0] << val[1]
                       result = val[0]
                     }
+                | block_call tJSDOT operation2 opt_paren_args
                 | block_call tDOT operation2 opt_paren_args
                 | block_call tCOLON2 operation2 opt_paren_args
 
@@ -1109,6 +1128,10 @@ opt_block_args_tail: tCOMMA block_args_tail
                     {
                       result = new_call(val[0], val[2], val[3])
                     }
+                | primary_value tJSDOT operation2 opt_paren_args
+                    {
+                      result = new_js_call(val[0], val[2], val[3])
+                    }
                 | primary_value tDOT paren_args
                     {
                       result = new_call(val[0], [:call, []], val[2])

data/lib/opal/parser/lexer.rb

@@ -987,6 +987,16 @@ module Opal
           @lex_state = :expr_beg
           return :tDOT2
 
+        elsif @lex_state != :expr_fname && scan(/\.JS\[/)
+          @lex_state = :expr_beg
+          cond_push 0
+          cmdarg_push 0
+          return :tJSLBRACK
+
+        elsif @lex_state != :expr_fname && scan(/\.JS\./)
+          @lex_state = :expr_dot
+          return :tJSDOT
+
         elsif scan(/\./)
           @lex_state = :expr_dot unless @lex_state == :expr_fname
           return :tDOT
@@ -1031,16 +1041,16 @@ module Opal
           self.set_arg_state
           return :tCARET
 
-        elsif check(/\</)
-          if scan(/\<\<\=/)
+        elsif check(/</)
+          if scan(/<<\=/)
             @lex_state = :expr_beg
             return new_op_asgn('<<')
 
-          elsif scan(/\<\</)
+          elsif scan(/<</)
             if after_operator?
               @lex_state = :expr_arg
               return :tLSHFT
-            elsif !after_operator? && !end? && (!arg? || @space_seen)
+            elsif !after_operator? && !end? && (!arg? || @space_seen) && @lex_state != :expr_class
               if token = heredoc_identifier
                 return token
               end
@@ -1050,7 +1060,7 @@ module Opal
             end
             @lex_state = :expr_beg
             return :tLSHFT
-          elsif scan(/\<\=\>/)
+          elsif scan(/<\=\>/)
             if after_operator?
               @lex_state = :expr_arg
             else
@@ -1062,11 +1072,11 @@ module Opal
             end
 
             return :tCMP
-          elsif scan(/\<\=/)
+          elsif scan(/<\=/)
             self.set_arg_state
             return :tLEQ
 
-          elsif scan(/\</)
+          elsif scan(/</)
             self.set_arg_state
             return :tLT
           end
@@ -1228,7 +1238,7 @@ module Opal
         elsif check(/[0-9]/)
           return process_numeric
 
-        elsif scan(/(\w)+[\?\!]?/)
+        elsif scan(/(\w)+(\?|(\!(?!=)))?/)
           return process_identifier scanner.matched, cmd_start
         end
 

data/lib/opal/sprockets.rb

@@ -1,3 +1,88 @@
 require 'opal/sprockets/processor'
 require 'opal/sprockets/erb'
 require 'opal/sprockets/server'
+
+module Opal
+  module Sprockets
+    # Public: Bootstraps modules loaded by sprockets on `Opal.modules` marking any
+    #   non-Opal asset as already loaded.
+    #
+    # name      - The name of the main asset to be loaded (with or without ext)
+    # sprockets - A Sprockets::Environment instance
+    #
+    # Example
+    #
+    #   Opal::Sprockets.load_asset(Rails.application.assets, 'application')
+    #
+    # Will output the following JavaScript:
+    #
+    #   if (typeof(Opal) !== 'undefined') {
+    #     Opal.mark_as_loaded("opal");
+    #     Opal.mark_as_loaded("jquery.self");
+    #     Opal.load("application");
+    #   }
+    #
+    # Returns a String containing JavaScript code.
+    def self.load_asset(name, sprockets)
+      asset = sprockets[name.sub(/(\.(js|rb|opal))*#{REGEXP_END}/, '.js')]
+      return '' if asset.nil?
+
+      opal_extnames = sprockets.engines.map do |ext, engine|
+        ext if engine <= ::Opal::Processor
+      end.compact
+
+      module_name       = -> asset { asset.logical_path.sub(/\.js#{REGEXP_END}/, '') }
+      path_extnames     = -> path  { File.basename(path).scan(/\.[^.]+/) }
+      mark_loaded       = -> paths { "Opal.loaded([#{paths.map(&:inspect).join(',')}]);" }
+      processed_by_opal = -> asset { (path_extnames[asset.pathname] & opal_extnames).any? }
+      stubbed_files     = ::Opal::Processor.stubbed_files
+
+      non_opal_assets = ([asset]+asset.dependencies)
+        .select { |asset| not(processed_by_opal[asset]) }
+        .map { |asset| module_name[asset] }
+
+      loaded = ['opal'] + non_opal_assets + stubbed_files.to_a
+
+      if processed_by_opal[asset]
+        load_asset_code = "Opal.load(#{module_name[asset].inspect});"
+      end
+
+
+      "if (typeof(Opal) !== 'undefined') { "\
+        "#{mark_loaded[loaded]} "\
+        "#{load_asset_code} "\
+      "}"
+    end
+
+    # Public: Generate a `<script>` tag for Opal assets.
+    #
+    # name    - The name of the asset to be loaded
+    # options - (default: {}):
+    #   :sprockets - A Sprockets::Environment instance
+    #   :prefix    - The prefix String at which is mounted Sprockets
+    #   :debug     - Wether to enable debug mode along with sourcemaps support
+    #
+    # Returns a string of HTML code containing `<script>` tags.
+    def self.javascript_include_tag(name, options = {})
+      sprockets = options.fetch(:sprockets)
+      prefix    = options.fetch(:prefix)
+      debug     = options.fetch(:debug)
+
+      asset = sprockets[name]
+      raise "Cannot find asset: #{name}" if asset.nil?
+      scripts = []
+
+      if debug
+        asset.to_a.map do |dependency|
+          scripts << %{<script src="#{prefix}/#{dependency.logical_path}?body=1"></script>}
+        end
+      else
+        scripts << %{<script src="#{prefix}/#{name}.js"></script>}
+      end
+
+      scripts << %{<script>#{::Opal::Sprockets.load_asset(name, sprockets)}</script>}
+
+      scripts.join "\n"
+    end
+  end
+end

data/lib/opal/sprockets/processor.rb

@@ -8,12 +8,12 @@ require 'opal/sprockets/source_map_server'
 $OPAL_SOURCE_MAPS = {}
 
 module Opal
-  # The Processor class is used to make ruby files (with rb or opal extensions)
-  # available to any sprockets based server. Processor will then get passed any
-  # ruby source file to build.
+  # Internal: The Processor class is used to make ruby files (with .rb or .opal
+  #   extensions) available to any sprockets based server. Processor will then
+  #   get passed any ruby source file to build.
   class Processor < TiltTemplate
-    # DEPRECATED:
-    # Support legacy accessors to default options, now moved to Opal::Config
+    # Deprecated: Support legacy accessors to default options,
+    #   now moved to Opal::Config
     Opal::Config.default_config.keys.each do |config_option|
       define_singleton_method(config_option) { Opal::Config.config[config_option] }
       define_singleton_method("#{config_option}=") { |value| Opal::Config.config[config_option] = value }
@@ -36,7 +36,8 @@ module Opal
       # In Sprockets 3 logical_path has an odd behavior when the filename is "index"
       # thus we need to bake our own logical_path
       filename = context.respond_to?(:filename) ? context.filename : context.pathname.to_s
-      logical_path = filename.gsub(%r{^#{context.root_path}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
+      root_path_regexp = Regexp.escape(context.root_path)
+      logical_path = filename.gsub(%r{^#{root_path_regexp}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
 
       compiler_options = self.compiler_options.merge(file: logical_path)
 
@@ -78,6 +79,8 @@ module Opal
       end
     end
 
+    # Internal: Add files required with `require_tree` as asset dependencies.
+    #
     # Mimics (v2) Sprockets::DirectiveProcessor#process_require_tree_directive
     def process_required_trees(required_trees, context)
       return if required_trees.empty?
@@ -122,36 +125,9 @@ module Opal
       end
     end
 
+    # Deprecated: Moved to Opal::Sprockets.load_asset(sprockets, name)
     def self.load_asset_code(sprockets, name)
-      asset = sprockets[name.sub(/(\.(js|rb|opal))*#{REGEXP_END}/, '.js')]
-      return '' if asset.nil?
-
-      opal_extnames = sprockets.engines.map do |ext, engine|
-        ext if engine <= ::Opal::Processor
-      end.compact
-
-      module_name = -> asset { asset.logical_path.sub(/\.js#{REGEXP_END}/, '') }
-      path_extnames = -> path { File.basename(path).scan(/\.[^.]+/) }
-      mark_as_loaded = -> path { "Opal.mark_as_loaded(#{path.inspect});" }
-      processed_by_opal = -> asset { (path_extnames[asset.pathname] & opal_extnames).any? }
-
-      non_opal_assets = ([asset]+asset.dependencies)
-        .select { |asset| not(processed_by_opal[asset]) }
-        .map { |asset| module_name[asset] }
-
-      mark_as_loaded = (['opal'] + non_opal_assets + stubbed_files.to_a)
-        .map { |path| mark_as_loaded[path] }
-
-      if processed_by_opal[asset]
-        load_asset_code = "Opal.load(#{module_name[asset].inspect});"
-      end
-
-      <<-JS
-      if (typeof(Opal) !== 'undefined') {
-        #{mark_as_loaded.join("\n")}
-        #{load_asset_code}
-      }
-      JS
+      ::Opal::Sprockets.load_asset(name, sprockets)
     end
 
     def self.stubbed_files

data/lib/opal/sprockets/server.rb

@@ -117,6 +117,7 @@ module Opal
           raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
           Tilt.new(@index_path).render(self)
         else
+          raise "Main asset path not configured (set 'main' within Opal::Server.new block)" if @server.main.nil?
           source
         end
       end
@@ -124,21 +125,7 @@ module Opal
       def javascript_include_tag name
         sprockets = @server.sprockets
         prefix = @server.prefix
-        asset = sprockets[name]
-        raise "Cannot find asset: #{name}" if asset.nil?
-        scripts = []
-
-        if @server.debug
-          asset.to_a.map do |dependency|
-            scripts << %{<script src="#{prefix}/#{dependency.logical_path}?body=1"></script>}
-          end
-        else
-          scripts << %{<script src="#{prefix}/#{name}.js"></script>}
-        end
-
-        scripts << %{<script>#{Opal::Processor.load_asset_code(sprockets, name)}</script>}
-
-        scripts.join "\n"
+        ::Opal::Sprockets.javascript_include_tag(name, sprockets: @server.sprockets, prefix: @server.prefix, debug: @server.debug)
       end
 
       def source
@@ -146,6 +133,7 @@ module Opal
           <!DOCTYPE html>
           <html>
           <head>
+            <meta charset="utf-8">
             <title>Opal Server</title>
           </head>
           <body>

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
-  # Remember to update RUBY_ENGINE_VERSION in opal/corelib/variables.rb too!
-  VERSION = '0.8.1'
+  # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
+  VERSION = '0.9.0.beta1'
 end

data/opal.gemspec

@@ -9,16 +9,16 @@ Gem::Specification.new do |s|
   s.author       = 'Adam Beynon'
   s.email        = 'adam.beynon@gmail.com'
   s.homepage     = 'http://opalrb.org'
-  s.summary      = 'Ruby runtime and core library for javascript'
-  s.description  = 'Ruby runtime and core library for javascript.'
+  s.summary      = 'Ruby runtime and core library for JavaScript'
+  s.description  = 'Ruby runtime and core library for JavaScript.'
   s.license      = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ['lib']
 
-  required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 1.9.3'
 
   s.add_dependency 'sourcemap', '~> 0.1.0'
   s.add_dependency 'sprockets', '~> 3.1'

data/opal/README.md

@@ -4,3 +4,12 @@ This is the Opal corelib implementation API documentation.
 The whole corelib is loaded upon `require 'opal'`.
 
 The `runtime.js` documentation is [available here](runtime.js.html)
+
+# Cherry-picking
+
+Note that `require 'opal'` will load all of the corelib, which is likely to
+have a ton of stuff you don't need.
+
+If you're concerned about runtime size, you can `require 'opal/base'` and
+require anything you need, or `require 'opal/mini'` to have a working Ruby
+without *useless* stuff.

data/opal/corelib/array.rb

@@ -1,6 +1,7 @@
 require 'corelib/enumerable'
+require 'corelib/numeric'
 
-class Array
+class Array < `Array`
   include Enumerable
 
   # Mark all javascript arrays as being valid ruby arrays
@@ -10,18 +11,17 @@ class Array
     objects
   end
 
-  def initialize(*args)
-    self.class.new(*args)
-  end
-
-  def self.new(size = nil, obj = nil, &block)
+  def initialize(size = nil, obj = nil, &block)
     if `arguments.length > 2`
       raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..2)"
     end
 
-    if `arguments.length === 0`
-      return []
-    end
+    %x{
+      if (arguments.length === 0) {
+        self.splice(0, self.length);
+        return self;
+      }
+    }
 
     if `arguments.length === 1`
       if Array === size
@@ -38,29 +38,34 @@ class Array
     end
 
     %x{
-      var result = [];
+      self.splice(0, self.length);
+      var i, value;
 
       if (block === nil) {
-        for (var i = 0; i < size; i++) {
-          result.push(obj);
+        for (i = 0; i < size; i++) {
+          self.push(obj);
         }
       }
       else {
-        for (var i = 0, value; i < size; i++) {
+        for (i = 0, value; i < size; i++) {
           value = block(i);
 
           if (value === $breaker) {
             return $breaker.$v;
           }
 
-          result[i] = value;
+          self[i] = value;
         }
       }
 
-      return result;
+      return self;
     }
   end
 
+  def self.new(*args, &block)
+    [].initialize(*args, &block)
+  end
+
   def self.try_convert(obj)
     Opal.coerce_to? obj, Array, :to_ary
   end
@@ -73,21 +78,16 @@ class Array
     end
 
     %x{
-      var result = [],
-          seen   = {};
-
-      for (var i = 0, length = self.length; i < length; i++) {
-        var item = self[i];
+      var result = [], hash = #{{}}, i, length, item;
 
-        if (!seen[item]) {
-          for (var j = 0, length2 = other.length; j < length2; j++) {
-            var item2 = other[j];
+      for (i = 0, length = other.length; i < length; i++) {
+        Opal.hash_put(hash, other[i], true);
+      }
 
-            if (!seen[item2] && #{`item` == `item2`}) {
-              seen[item] = true;
-              result.push(item);
-            }
-          }
+      for (i = 0, length = self.length; i < length; i++) {
+        item = self[i];
+        if (Opal.hash_delete(hash, item) !== undefined) {
+          result.push(item);
         }
       }
 
@@ -103,32 +103,22 @@ class Array
     end
 
     %x{
-      var result = [],
-          seen   = {};
+      var hash = #{{}}, i, length, item;
 
-      for (var i = 0, length = self.length; i < length; i++) {
-        var item = self[i];
-
-        if (!seen[item]) {
-          seen[item] = true;
-          result.push(item);
-        }
+      for (i = 0, length = self.length; i < length; i++) {
+        Opal.hash_put(hash, self[i], true);
       }
 
-      for (var i = 0, length = other.length; i < length; i++) {
-        var item = other[i];
-
-        if (!seen[item]) {
-          seen[item] = true;
-          result.push(item);
-        }
+      for (i = 0, length = other.length; i < length; i++) {
+        Opal.hash_put(hash, other[i], true);
       }
-      return result;
+
+      return hash.$keys();
     }
   end
 
   def *(other)
-    return `self.join(#{other.to_str})` if other.respond_to? :to_str
+    return 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"
@@ -172,17 +162,15 @@ class Array
     return clone if `other.length === 0`
 
     %x{
-      var seen   = {},
-          result = [];
+      var result = [], hash = #{{}}, i, length, item;
 
-      for (var i = 0, length = other.length; i < length; i++) {
-        seen[other[i]] = true;
+      for (i = 0, length = other.length; i < length; i++) {
+        Opal.hash_put(hash, other[i], true);
       }
 
-      for (var i = 0, length = self.length; i < length; i++) {
-        var item = self[i];
-
-        if (!seen[item]) {
+      for (i = 0, length = self.length; i < length; i++) {
+        item = self[i];
+        if (Opal.hash_get(hash, item) === undefined) {
           result.push(item);
         }
       }
@@ -211,11 +199,9 @@ class Array
         return 0;
       }
 
-      if (self.length != other.length) {
-        return (self.length > other.length) ? 1 : -1;
-      }
+      var count = Math.min(self.length, other.length);
 
-      for (var i = 0, length = self.length; i < length; i++) {
+      for (var i = 0; i < count; i++) {
         var tmp = #{`self[i]` <=> `other[i]`};
 
         if (tmp !== 0) {
@@ -223,7 +209,7 @@ class Array
         }
       }
 
-      return 0;
+      return #{`self.length` <=> `other.length`};
     }
   end
 
@@ -277,12 +263,14 @@ class Array
   end
 
   def [](index, length = undefined)
-    if Range === index
-      %x{
-        var size    = self.length,
-            exclude = index.exclude,
-            from    = #{Opal.coerce_to `index.begin`, Integer, :to_int},
-            to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
+    %x{
+      var size = self.length,
+          exclude, from, to;
+
+      if (index.$$is_range) {
+        exclude = index.exclude;
+        from    = #{Opal.coerce_to `index.begin`, Integer, :to_int};
+        to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
 
         if (from < 0) {
           from += size;
@@ -310,11 +298,8 @@ class Array
 
         return self.slice(from, to);
       }
-    else
-      index = Opal.coerce_to index, Integer, :to_int
-
-      %x{
-        var size = self.length;
+      else {
+        index = #{Opal.coerce_to(index, Integer, :to_int)};
 
         if (index < 0) {
           index += size;
@@ -341,10 +326,14 @@ class Array
           return self.slice(index, index + length);
         }
       }
-    end
+    }
   end
 
   def []=(index, value, extra = undefined)
+    %x{
+      var i, size = self.length;
+    }
+
     if Range === index
       if Array === value
         data = value.to_a
@@ -355,8 +344,7 @@ class Array
       end
 
       %x{
-        var size    = self.length,
-            exclude = index.exclude,
+        var exclude = index.exclude,
             from    = #{Opal.coerce_to `index.begin`, Integer, :to_int},
             to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
 
@@ -377,7 +365,7 @@ class Array
         }
 
         if (from > size) {
-          for (var i = size; i < from; i++) {
+          for (i = size; i < from; i++) {
             self[i] = nil;
           }
         }
@@ -408,10 +396,10 @@ class Array
       end
 
       %x{
-        var size   = self.length,
-            index  = #{Opal.coerce_to index, Integer, :to_int},
-            length = #{Opal.coerce_to length, Integer, :to_int},
-            old;
+        var old;
+
+        index  = #{Opal.coerce_to index, Integer, :to_int};
+        length = #{Opal.coerce_to length, Integer, :to_int};
 
         if (index < 0) {
           old    = index;
@@ -427,7 +415,7 @@ class Array
         }
 
         if (index > size) {
-          for (var i = size; i < index; i++) {
+          for (i = size; i < index; i++) {
             self[i] = nil;
           }
         }
@@ -515,15 +503,24 @@ class Array
   end
 
   def cycle(n = nil, &block)
+    return enum_for(:cycle, n) {
+      if n == nil
+        Float::INFINITY
+      else
+        n = Opal.coerce_to!(n, Integer, :to_int)
+        n > 0 ? self.enumerator_size * n : 0
+      end
+    } unless block_given?
+
     return if empty? || n == 0
 
-    return enum_for :cycle, n unless block
+    %x{
+      var i, length, value;
 
-    if n.nil?
-      %x{
+      if (n === nil) {
         while (true) {
-          for (var i = 0, length = self.length; i < length; i++) {
-            var value = Opal.yield1(block, self[i]);
+          for (i = 0, length = self.length; i < length; i++) {
+            value = Opal.yield1(block, self[i]);
 
             if (value === $breaker) {
               return $breaker.$v;
@@ -531,17 +528,15 @@ class Array
           }
         }
       }
-    else
-      n = Opal.coerce_to! n, Integer, :to_int
-
-      %x{
+      else {
+        n = #{Opal.coerce_to!(n, Integer, :to_int)};
         if (n <= 0) {
           return self;
         }
 
         while (n > 0) {
-          for (var i = 0, length = self.length; i < length; i++) {
-            var value = Opal.yield1(block, self[i]);
+          for (i = 0, length = self.length; i < length; i++) {
+            value = Opal.yield1(block, self[i]);
 
             if (value === $breaker) {
               return $breaker.$v;
@@ -551,7 +546,7 @@ class Array
           n--;
         }
       }
-    end
+    }
 
     self
   end
@@ -564,6 +559,7 @@ class Array
 
   def clone
     copy = []
+    copy.copy_singleton_methods(self)
     copy.initialize_clone(self)
     copy
   end
@@ -579,7 +575,7 @@ class Array
   end
 
   def collect(&block)
-    return enum_for :collect unless block_given?
+    return enum_for(:collect){self.size} unless block_given?
 
     %x{
       var result = [];
@@ -599,7 +595,7 @@ class Array
   end
 
   def collect!(&block)
-    return enum_for :collect! unless block_given?
+    return enum_for(:collect!){self.size} unless block_given?
 
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
@@ -616,9 +612,23 @@ class Array
     self
   end
 
+  %x{
+    function binomial_coefficient(n, k) {
+      if (n === k || k === 0) {
+        return 1;
+      }
+
+      if (k > 0 && n > k) {
+        return binomial_coefficient(n - 1, k - 1) + binomial_coefficient(n - 1, k);
+      }
+
+      return 0;
+    }
+  }
+
   def combination(n)
     num = Opal.coerce_to! n, Integer, :to_int
-    return enum_for :combination, num unless block_given?
+    return enum_for(:combination, num){ `binomial_coefficient(#{self}.length, num)` } unless block_given?
 
     %x{
       var i, length, stack, chosen, lev, done, next;
@@ -755,7 +765,7 @@ class Array
   end
 
   def delete_if(&block)
-    return enum_for :delete_if unless block_given?
+    return enum_for(:delete_if){self.size} unless block_given?
 
     %x{
       for (var i = 0, length = self.length, value; i < length; i++) {
@@ -785,10 +795,8 @@ class Array
     }
   end
 
-  alias dup clone
-
   def each(&block)
-    return enum_for :each unless block_given?
+    return enum_for(:each){self.size} unless block_given?
 
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
@@ -804,7 +812,7 @@ class Array
   end
 
   def each_index(&block)
-    return enum_for :each_index unless block_given?
+    return enum_for(:each_index){self.size} unless block_given?
 
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
@@ -900,6 +908,10 @@ class Array
   end
 
   def fill(*args, &block)
+    %x{
+      var i, length, value;
+    }
+
     if block
       if `args.length > 2`
         raise ArgumentError, "wrong number of arguments (#{args.length} for 0..2)"
@@ -949,7 +961,7 @@ class Array
 
     if `left > #@length`
       %x{
-        for (var i = #@length; i < right; i++) {
+        for (i = #@length; i < right; i++) {
           self[i] = nil;
         }
       }
@@ -961,8 +973,8 @@ class Array
 
     if block
       %x{
-        for (var length = #@length; left < right; left++) {
-          var value = block(left);
+        for (length = #@length; left < right; left++) {
+          value = block(left);
 
           if (value === $breaker) {
             return $breaker.$v;
@@ -973,7 +985,7 @@ class Array
       }
     else
       %x{
-        for (var length = #@length; left < right; left++) {
+        for (length = #@length; left < right; left++) {
           self[left] = #{obj};
         }
       }
@@ -1000,14 +1012,13 @@ class Array
 
   def flatten(level = undefined)
     %x{
-      var object_id = #{`self`.object_id};
-
       function _flatten(array, level) {
-        var array = #{`array`.to_a},
-            result = [],
+        var result = [],
             i, length,
             item, ary;
 
+        array = #{`array`.to_a};
+
         for (i = 0, length = array.length; i < length; i++) {
           item = array[i];
 
@@ -1027,7 +1038,7 @@ class Array
             #{raise TypeError};
           }
 
-          if (object_id === #{`ary`.object_id}) {
+          if (ary === self) {
             #{raise ArgumentError};
           }
 
@@ -1077,17 +1088,42 @@ class Array
 
   def hash
     %x{
-      var hash = ['A'],
-          item;
-      for (var i = 0, length = self.length; i < length; i++) {
-        item = self[i];
-        if (item.$$is_array && #{`self`.eql?(`item`)}) {
-          hash.push('self');
-        } else {
-          hash.push(item.$hash());
+      var top = (Opal.hash_ids == undefined),
+          result = ['A'],
+          hash_id = self.$object_id(),
+          item, i, key;
+
+      try {
+        if (top) {
+          Opal.hash_ids = {};
+        }
+
+        if (Opal.hash_ids.hasOwnProperty(hash_id)) {
+          return 'self';
+        }
+
+        for (key in Opal.hash_ids) {
+          if (Opal.hash_ids.hasOwnProperty(key)) {
+            item = Opal.hash_ids[key];
+            if (#{eql?(`item`)}) {
+              return 'self';
+            }
+          }
+        }
+
+        Opal.hash_ids[hash_id] = self;
+
+        for (i = 0; i < self.length; i++) {
+          item = self[i];
+          result.push(item.$hash());
+        }
+
+        return result.join(',');
+      } finally {
+        if (top) {
+          delete Opal.hash_ids;
         }
       }
-      return hash.join(',');
     }
   end
 
@@ -1105,15 +1141,17 @@ class Array
 
   def index(object=undefined, &block)
     %x{
+      var i, length, value;
+
       if (object != null) {
-        for (var i = 0, length = self.length; i < length; i++) {
+        for (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++) {
+        for (i = 0, length = self.length; i < length; i++) {
           if ((value = block(self[i])) === $breaker) {
             return $breaker.$v;
           }
@@ -1185,13 +1223,13 @@ class Array
 
     %x{
       var result = [];
-      var object_id = #{`self`.object_id};
+      var i, length, item, tmp;
 
-      for (var i = 0, length = self.length; i < length; i++) {
-        var item = self[i];
+      for (i = 0, length = self.length; i < length; i++) {
+        item = self[i];
 
         if (#{Opal.respond_to? `item`, :to_str}) {
-          var tmp = #{`item`.to_str};
+          tmp = #{`item`.to_str};
 
           if (tmp !== nil) {
             result.push(#{`tmp`.to_s});
@@ -1201,9 +1239,9 @@ class Array
         }
 
         if (#{Opal.respond_to? `item`, :to_ary}) {
-          var tmp = #{`item`.to_ary};
+          tmp = #{`item`.to_ary};
 
-          if (object_id === #{`tmp`.object_id}) {
+          if (tmp === self) {
             #{raise ArgumentError};
           }
 
@@ -1215,7 +1253,7 @@ class Array
         }
 
         if (#{Opal.respond_to? `item`, :to_s}) {
-          var tmp = #{`item`.to_s};
+          tmp = #{`item`.to_s};
 
           if (tmp !== nil) {
             result.push(tmp);
@@ -1237,7 +1275,7 @@ class Array
   end
 
   def keep_if(&block)
-    return enum_for :keep_if unless block_given?
+    return enum_for(:keep_if){self.size} unless block_given?
 
     %x{
       for (var i = 0, length = self.length, value; i < length; i++) {
@@ -1284,7 +1322,73 @@ class Array
   alias map collect
 
   alias map! collect!
+  
+  def permutation(num = undefined, &block)
+    return enum_for(:permutation, num){self.size} unless block_given?
+
+    %x{
+      var permute, offensive, output;
+      
+      if (num === undefined) {
+        num = self.length;
+      }
+      else {
+        num = #{ Opal.coerce_to num, Integer, :to_int }
+      }
+      
+      if (num < 0 || self.length < num) {
+        // no permutations, yield nothing
+      }
+      else if (num === 0) {
+        // exactly one permutation: the zero-length array
+        #{ yield [] }
+      }
+      else if (num === 1) {
+        // this is a special, easy case
+        for (var i = 0; i < self.length; i++) {
+          #{ yield `[self[i]]` }
+        }
+      }
+      else {
+        // this is the general case
+        #{ perm = Array.new(num) }
+        #{ used = Array.new(`self.length`, false) }
+      
+        permute = function(num, perm, index, used, blk) {
+          self = this;
+          for(var i = 0; i < self.length; i++){
+            if(#{ !used[`i`] }) {              
+              perm[index] = i;
+              if(index < num - 1) {
+                used[i] = true;
+                permute.call(self, num, perm, index + 1, used, blk);
+                used[i] = false;
+              } 
+              else {
+                output = [];
+                for (var j = 0; j < perm.length; j++) {
+                  output.push(self[perm[j]]);
+                }
+                Opal.yield1(blk, output);
+              }
+            }
+          }
+        }
+        
+        if (#{block_given?}) {
+          // offensive (both definitions) copy.
+          offensive = self.slice();
+          permute.call(offensive, num, perm, 0, used, block);
+        }
+        else {
+          permute.call(self, num, perm, 0, used, block);
+        }
+      }
+    }
 
+    self
+  end
+  
   def pop(count = undefined)
     if `count === undefined`
       return if `self.length === 0`
@@ -1383,7 +1487,7 @@ class Array
   end
 
   def reject(&block)
-    return enum_for :reject unless block_given?
+    return enum_for(:reject){self.size} unless block_given?
 
     %x{
       var result = [];
@@ -1402,7 +1506,7 @@ class Array
   end
 
   def reject!(&block)
-    return enum_for :reject! unless block_given?
+    return enum_for(:reject!){self.size} unless block_given?
 
     original = length
     delete_if(&block)
@@ -1436,7 +1540,7 @@ class Array
   end
 
   def reverse_each(&block)
-    return enum_for :reverse_each unless block_given?
+    return enum_for(:reverse_each){self.size} unless block_given?
 
     reverse.each &block
     self
@@ -1444,19 +1548,26 @@ class Array
 
   def rindex(object = undefined, &block)
     %x{
+      var i, value;
+
       if (object != null) {
-        for (var i = self.length - 1; i >= 0; i--) {
+        for (i = self.length - 1; i >= 0; i--) {
+          if (i >= self.length) {
+            break;
+          }
           if (#{`self[i]` == `object`}) {
             return i;
           }
         }
       }
       else if (block !== nil) {
-        for (var i = self.length - 1, value; i >= 0; i--) {
+        for (i = self.length - 1; i >= 0; i--) {
+          if (i >= self.length) {
+            break;
+          }
           if ((value = block(self[i])) === $breaker) {
             return $breaker.$v;
           }
-
           if (value !== false && value !== nil) {
             return i;
           }
@@ -1492,8 +1603,6 @@ class Array
   end
   
   def rotate!(cnt=1)
-    raise RuntimeError, "can't modify frozen Array" if frozen?
-
     %x{
       if (self.length === 0 || self.length === 1) {
         return self;
@@ -1504,21 +1613,133 @@ class Array
     replace ary
   end
   
-  def sample(n = nil)
-    return nil if !n && empty?
-    return []  if  n && empty?
+  class SampleRandom
+    def initialize(rng)
+      @rng = rng
+    end
 
-    if n
-      (1 .. n).map {
-        self[rand(length)]
-      }
-    else
-      self[rand(length)]
+    def rand(size)
+      random = Opal.coerce_to @rng.rand(size), Integer, :to_int
+      raise RangeError, "random value must be >= 0" if `random < 0`
+      raise RangeError, "random value must be less than Array size" unless `random < size`
+
+      random
     end
   end
 
+  def sample(count = undefined, options = undefined)
+    return at Kernel.rand(`self.length`) if `count === undefined`
+    
+    if `options === undefined`
+      if (o = Opal.coerce_to? count, Hash, :to_hash)
+        options = o
+        count = nil
+      else
+        options = nil
+        count = Opal.coerce_to count, Integer, :to_int
+      end
+    else
+      count = Opal.coerce_to count, Integer, :to_int
+      options = Opal.coerce_to options, Hash, :to_hash
+    end
+
+    if count and `count < 0`
+      raise ArgumentError, "count must be greater than 0"
+    end
+
+    rng = options[:random] if options
+    if rng and rng.respond_to? :rand
+      rng = SampleRandom.new rng
+    else
+      rng = Kernel
+    end
+
+    return `self[#{rng.rand(`self.length`)}]` unless count
+
+    %x{
+      
+      var abandon, spin, result, i, j, k, targetIndex, oldValue;
+      
+      if (count > self.length) { 
+        count = self.length;
+      }
+      
+      switch (count) {
+        case 0:
+          return [];
+          break;
+        case 1:
+          return [self[#{rng.rand(`self.length`)}]];
+          break;
+        case 2:
+          i = #{rng.rand(`self.length`)};
+          j = #{rng.rand(`self.length`)};
+          if (i === j) {
+            j = i === 0 ? i + 1 : i - 1;
+          }
+          return [self[i], self[j]];
+          break;
+        default:
+          if (self.length / count > 3) {
+            abandon = false;
+            spin = 0;
+            
+            result = #{ Array.new(count) };
+            i = 1;
+            
+            result[0] = #{rng.rand(`self.length`)};
+            while (i < count) {
+              k = #{rng.rand(`self.length`)};
+              j = 0;
+              
+              while (j < i) {
+                while (k === result[j]) {
+                  spin++;
+                  if (spin > 100) {
+                    abandon = true;
+                    break;
+                  }
+                  k = #{rng.rand(`self.length`)};
+                }
+                if (abandon) { break; }
+                  
+                j++;
+              }
+              
+              if (abandon) { break; }
+              
+              result[i] = k;
+              
+              i++;
+            }
+            
+            if (!abandon) {
+              i = 0;
+              while (i < count) {
+                result[i] = self[result[i]];
+                i++;
+              }
+              
+              return result;
+            }
+          }
+          
+          result = self.slice();
+          
+          for (var c = 0; c < count; c++) {
+            targetIndex = #{rng.rand(`self.length`)};
+            oldValue = result[c];
+            result[c] = result[targetIndex];
+            result[targetIndex] = oldValue;
+          }
+          
+          return count === self.length ? result : #{`result`[0, count]};
+      }
+    }
+  end
+  
   def select(&block)
-    return enum_for :select unless block_given?
+    return enum_for(:select){self.size} unless block_given?
 
     %x{
       var result = [];
@@ -1540,7 +1761,7 @@ class Array
   end
 
   def select!(&block)
-    return enum_for :select! unless block_given?
+    return enum_for(:select!){self.size} unless block_given?
 
     %x{
       var original = self.length;
@@ -1568,22 +1789,49 @@ class Array
 
   alias size length
 
-  def shuffle
-    clone.shuffle!
+  def shuffle(rng = undefined)
+    dup.shuffle!(rng)
   end
 
-  def shuffle!
+  def shuffle!(rng = undefined)
     %x{
-      for (var i = self.length - 1; i > 0; i--) {
-        var tmp = self[i],
-            j   = Math.floor(Math.random() * (i + 1));
+      var randgen, i = self.length, j, tmp;
+
+      if (rng !== undefined) {
+        rng = #{Opal.coerce_to?(rng, Hash, :to_hash)};
+
+        if (rng !== nil) {
+          rng = #{rng[:random]};
+
+          if (rng !== nil && #{rng.respond_to?(:rand)}) {
+            randgen = rng;
+          }
+        }
+      }
+
+      while (i) {
+        if (randgen) {
+          j = randgen.$rand(i).$to_int();
+
+          if (j < 0) {
+            #{raise RangeError, "random number too small #{`j`}"}
+          }
+
+          if (j >= i) {
+            #{raise RangeError, "random number too big #{`j`}"}
+          }
+        }
+        else {
+          j = Math.floor(Math.random() * i);
+        }
 
+        tmp = self[--i];
         self[i] = self[j];
         self[j] = tmp;
       }
-    }
 
-    self
+      return self;
+    }
   end
 
   alias slice []
@@ -1610,7 +1858,7 @@ class Array
     return self unless `self.length > 1`
 
     %x{
-      if (!#{block_given?}) {
+      if (block === nil) {
         block = function(a, b) {
           return #{`a` <=> `b`};
         };
@@ -1713,7 +1961,7 @@ class Array
         }
         key = ary[0];
         val = ary[1];
-        hash.$store(key, val);
+        Opal.hash_put(hash, key, val);
       }
 
       return hash;
@@ -1750,47 +1998,51 @@ class Array
     result
   end
 
-  def uniq
+  def uniq(&block)
     %x{
-      var result = [],
-          seen   = {};
+      var hash = #{{}}, i, length, item, key;
 
-      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);
+      if (block === nil) {
+        for (i = 0, length = self.length; i < length; i++) {
+          item = self[i];
+          if (Opal.hash_get(hash, item) === undefined) {
+            Opal.hash_put(hash, item, item);
+          }
+        }
+      }
+      else {
+        for (i = 0, length = self.length; i < length; i++) {
+          item = self[i];
+          key = Opal.yield1(block, item);
+          if (Opal.hash_get(hash, key) === undefined) {
+            Opal.hash_put(hash, key, item);
+          }
         }
       }
 
-      return result;
+      return hash.$values();
     }
   end
 
-  def uniq!
+  def uniq!(&block)
     %x{
-      var original = self.length,
-          seen     = {};
+      var original_length = self.length, hash = #{{}}, i, length, item, key;
 
-      for (var i = 0, length = original, item, hash; i < length; i++) {
+      for (i = 0, length = original_length; i < length; i++) {
         item = self[i];
-        hash = item;
+        key = (block === nil ? item : Opal.yield1(block, item));
 
-        if (!seen[hash]) {
-          seen[hash] = true;
+        if (Opal.hash_get(hash, key) === undefined) {
+          Opal.hash_put(hash, key, item);
+          continue;
         }
-        else {
-          self.splice(i, 1);
 
-          length--;
-          i--;
-        }
+        self.splice(i, 1);
+        length--;
+        i--;
       }
 
-      return self.length === original ? nil : self;
+      return self.length === original_length ? nil : self;
     }
   end