opal 0.2.2 → 0.3.0

data/gems/core/lib/core/array.rb

@@ -0,0 +1,1470 @@
+# Arrays are ordered, indexed by integers starting at 0
+#
+# Implementation details
+# ======================
+#
+# For efficiency, an array instance is simply a native javascript array. There
+# is no wrapping, it is simply a toll-free class
+class Array
+  # Returns a new array populated with the given objects.
+  #
+  # @example
+  #
+  #     Array['a', 'b', 'c']
+  #     # => ['a', 'b', 'c']
+  #
+  # FIXME should support custom subclasses
+  #
+  # @param [Object] objs
+  # @return [Array]
+  def self.[](*objs)
+    objs
+  end
+
+  # FIXME should support custom subclasses
+  def self.allocate
+    []
+  end
+
+  def initialize(*objs)
+    `for (var i = 0, length = objs.length; i < length; i++) {
+      self.push(objs[i]);
+    }
+
+    return self;`
+  end
+
+  # Returns a formatted, printable version of the array. {#inspect} is called
+  # on each of the elements and appended to the string.
+  #
+  # @return [String] string representation of the receiver
+  def inspect
+    `var description = [];
+
+    for (var i = 0, length = self.length; i < length; i++) {
+      description.push(#{`self[i]`.inspect});
+    }
+
+    return '[' + description.join(', ') + ']';`
+  end
+
+  # Returns a simple string version of the array. {#to_s} is applied to each
+  # of the child elements with no seperator.
+  def to_s
+    `var description = [];
+
+    for (var i = 0, length = self.length; i < length; i++) {
+      description.push(#{`self[i]`.to_s});
+    }
+
+    return description.join('');`
+  end
+
+  # Append - pushes the given object onto the end of this array. This 
+  # expression returns the array itself, so several appends may be chained
+  # together.
+  #
+  # @example
+  #
+  #     [1, 2] << "c" << "d" << [3, 4]
+  #     # => [1, 2, "c", "d", [3, 4]]
+  #
+  # @param [Object] obj the object to append
+  # @return [Array] returns the receiver
+  def <<(obj)
+    `self.push(obj);`
+    self
+  end
+
+  # Returns the number of elements in `self`. May be zero.
+  #
+  # @example
+  #
+  #     [1, 2, 3, 4, 5].length
+  #     # => 5
+  #
+  # @return [Numeric] length
+  def length
+    `return self.length;`
+  end
+
+  def size
+    `return self.length;`
+  end
+
+  # Yields the block once for each element in `self`, passing that element as
+  # a parameter.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.each { |x| puts x }
+  #     # => 'a'
+  #     # => 'b'
+  #     # => 'c'
+  #
+  # TODO: needs to return enumerator for no block.
+  #
+  # @return [Array] returns the receiver
+  def each
+    `for (var i = 0, length = self.length; i < length; i++) {
+      try {
+        #{yield `self[i]`};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Similar to {#each}, but also passes in the current element index to the
+  # block.
+  def each_with_index
+    `for (var i = 0, length = self.length; i < length; i++) {
+      try {
+        #{yield `self[i]`, `i`};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Same as {#each}, but passes the index of the element instead of the 
+  # element itself.
+  #
+  # If no block given, an enumerator is returned instead.
+  #
+  # TODO: enumerator functionality not yet implemented.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3]
+  #     a.each_index { |x| puts x }
+  #     # => 0
+  #     # => 1
+  #     # => 2
+  #
+  # @return [Array] returns receiver
+  def each_index
+    `for (var i = 0, length = self.length; i < length; i++) {
+      try {
+        #{yield `i`};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Append - pushes the given object(s) onto the end of this array. This
+  # expression returns the array itself, so several appends may be chained
+  # together.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.push 'd', 'e', 'f'
+  #     # => ['a', 'b', 'c', 'd', 'e', 'f'
+  #
+  # @param [Object] obj the object(s) to push onto the array
+  # @return [Array] returns the receiver
+  def push(*objs)
+    `for (var i = 0, length = objs.length; i < length; i++) {
+      self.push(objs[i]);
+    }
+
+    return self;`
+  end
+
+  # Returns the index of the first object in `self` such that it is `==` to
+  # `obj`. If a block is given instead of an argument, returns first object for
+  # which the block is true. Returns `nil` if no match is found. See also
+  # {#rindex}.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.index('a')              # => 0
+  #     a.index('z')              # => nil
+  #     a.index { |x| x == 'b' }  # => 1
+  #
+  # @param [Object] obj the object to look for
+  # @return [Numeric, nil] result
+  def index(obj)
+    `for (var i = 0, length = self.length; i < length; i++) {
+      if (#{`self[i]` == obj}.$r) {
+        return i;
+      }
+    }
+
+    return nil;`
+  end
+
+  # Concatenation - returns a new array built by concatenating the two arrays
+  # together to produce a third array.
+  #
+  # @example
+  #
+  #     [1, 2, 3] + [4, 5]
+  #     # => [1, 2, 3, 4, 5]
+  #
+  # @param [Array] other the array to concat with
+  # @return [Array] returns new concatenated array
+  def +(other)
+    `return self.concat(other);`
+  end
+
+  # Difference. Creates a new array that is a copy of the original array,
+  # removing any items that also appear in `other`.
+  #
+  # @example
+  #
+  #   [1, 2, 3, 3, 4, 4, 5] - [1, 2, 4]
+  #   # => [3, 3, 5]
+  #
+  # @param [Array] other array to use for difference
+  # @return [Array] new array
+  def -(other)
+    raise "Array#- not yet implemented"
+  end
+
+  # Equality. Two arrays are equal if they contain the same number of elements
+  # and if each element is equal to (according to {Object#==} the corresponding
+  # element in the second array.
+  #
+  # @example
+  #
+  #     ['a', 'c'] == ['a', 'c', 7]       # => false
+  #     ['a', 'c', '7'] == ['a', 'c', 7]  # => true
+  #     ['a', 'c', 7] == ['a', 'd', 'f']  # => false
+  #
+  # @param [Array] other array to compare self with
+  # @return [Boolean] if the arrays are equal
+  def ==(other)
+    `if (self.$hash() == other.$hash()) return Qtrue;
+    if (self.length != other.length) return Qfalse;
+
+    for (var i = 0; i < self.length; i++) {
+      if (!#{`self[i]` == `other[i]`}.$r) {
+        return Qfalse;
+      }
+    }
+
+    return Qtrue;`
+  end
+
+  # Searches through an array whose elements are also arrays, comparing `obj`
+  # with their first element of each contained array using {Object#==}. Returns
+  # the first contained array that matches (that is, the first associated array)
+  # or `nil` if no match is found. See also {#rassoc}.
+  #
+  # @example
+  #
+  #     s1 = ['colors', 'red', 'blue', 'green']
+  #     s2 = ['letters', 'a', 'b', 'c']
+  #     s3 = 'foo'
+  #     a = [s1, s2, s3]
+  #
+  #     a.assoc 'letters'               # => ['letters', 'a', 'b', 'c']
+  #     a.assoc 'foo'                   # => nil
+  def assoc(obj)
+    `var arg;
+
+    for (var i = 0; i < self.length; i++) {
+      arg = self[i];
+
+      if (arg.length && #{`arg[0]` == obj}.$r) {
+        return arg;
+      }
+    }
+
+    return nil;`
+  end
+
+  # Returns the element at `index`. A negative index counts from the end of the
+  # receiver. Returns `nil` if the given index is out of range. See also {#[]}.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd', 'e']
+  #     a.at 0          # => 'a'
+  #     a.at -1         # => 'e'
+  #     a.at 324        # => nil
+  #
+  # @param [Numeric] index the index to get
+  # @return [Object, nil] returns nil or the result
+  def at(idx)
+    `if (idx < 0) idx += self.length;
+
+    if (idx < 0 || idx >= self.length) return nil;
+    return self[idx];`
+  end
+
+  # Removes all elements from the receiver.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd', 'e']
+  #     a.clear   # => []
+  #
+  # @return [Array] returns the receiver
+  def clear
+    `self.splice(0);
+    return self;`
+  end
+
+  # Yields the block, passing in successive elements from the receiver, 
+  # returning an array containing those elements for which the block returns a
+  # true value.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.select { |x| x > 4 }
+  #     # => [5, 6]
+  #
+  # @return [Array] returns a new array of selected elements
+  def select
+    `var result = [], arg;
+
+    for (var i = 0; i < self.length; i++) {
+      try {
+        arg = self[i];
+        if (#{yield `arg`}.$r) {
+          result.push(arg);
+        }
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return result;`
+  end
+
+  # Yields the block once for each element of the receiver. Creates a new array
+  # containing the values returned by the block. See also {Enumerable#collect}.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd']
+  #     a.collect { |x| x + '!' }     # => ['a!', 'b!', 'c!', 'd!']
+  #     a                             # => ['a', 'b', 'c', 'd']
+  #
+  # @return [Array] new array
+  def collect
+    `var result = [];
+
+    for (var i = 0; i < self.length; i++) {
+      try {
+        result.push(#{yield `self[i]`});
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return result;`
+  end
+
+  # alias_method 'map', 'collect'
+
+  # Yields the block once for each element of `self`, replacing the element with
+  # the value returned by the block. See also {Enumerable#collect}.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd']
+  #     a.collect { |x| x + '!' }
+  #     # => ['a!', 'b!', 'c!', 'd!']
+  #     a
+  #     # => ['a!', 'b!', 'c!', 'd!']
+  #
+  # @return [Array] returns the receiver
+  def collect!
+    `for (var i = 0; i < self.length; i++) {
+      try {
+        self[i] = #{yield `self[i]`};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Duplicate.
+  def dup
+    `return self.slice(0);`
+  end
+
+  # Returns a copy of the receiver with all nil elements removed
+  #
+  # @example
+  #
+  #     ['a', nil, 'b', nil, 'c', nil].compact
+  #     # => ['a', 'b', 'c']
+  #
+  # @return [Array] new Array
+  def compact
+    `var result = [], length = self.length;
+
+    for (var i = 0; i < length; i++) {
+      if (self[i] != nil) {
+        result.push(self[i]);
+      }
+    }
+
+    return result;`
+  end
+
+  # Removes nil elements from the receiver. Returns nil if no changes were made,
+  # otherwise returns self.
+  #
+  # @example
+  #
+  #     ['a', nil, 'b', nil, 'c'].compact!
+  #     # => ['a', 'b', 'c']
+  #
+  #     ['a', 'b', 'c'].compact!
+  #     # => nil
+  #
+  # @return [Array, nil] returns either the receiver or nil
+  def compact!
+    `var length = self.length;
+
+    for (var i = 0; i < length; i++) {
+      if (self[i] == nil) {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return length == self.length ? nil : self;`
+  end
+
+  # Appends the elements of `other` to `self`.
+  #
+  # @example
+  #
+  #     ['a', 'b'].concat ['c', 'd']
+  #     # => ['a', 'b', 'c', 'd']
+  #
+  # @param [Array] other array to concat
+  # @return [Array] returns the receiver
+  def concat(other)
+    `var length = other.length;
+
+    for (var i = 0; i < length; i++) {
+      self.push(other[i]);
+    }
+
+    return self;`
+  end
+
+  # Returns the number of elements. If an argument is given, counts the number
+  # of elements which equals to `obj`. If a block is given, counts the number of
+  # elements yielding a true value.
+  #
+  # @example
+  #
+  #     ary = [1, 2, 4, 2]
+  #     ary.count     # => 4
+  #     ary.count(2)  # =>2
+  #
+  # @param [Object] obj object to check
+  # @return [Numeric] count or count of obj
+  def count(obj)
+    `if (obj != undefined) {
+      var total = 0;
+
+      for (var i = 0; i < self.length; i++) {
+        if (#{`self[i]` == obj}.$r) {
+          total++;
+        }
+      }
+
+      return total;
+    } else {
+      return self.length;
+    }`
+  end
+
+  # Deletes items from `self` that are equal to `obj`. If any items are found,
+  # returns `obj`. If the item is not found, returns `nil`. If the optional code
+  # block is given, returns the result of block if the item is not found.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'b', 'b', 'c']
+  #
+  #     a.delete 'b'
+  #     # => 'b'
+  #     a
+  #     # => ['a', 'c']
+  #
+  #     a.delete 'z'
+  #     # => nil
+  #
+  # @param [Object] obj object to delete
+  # @return [Object, nil] returns obj or nil
+  def delete(obj)
+    `var length = self.length;
+
+    for (var i = 0; i < self.length; i++) {
+      if (#{`self[i]` == obj}.$r) {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return length == self.length ? nil : obj;`
+  end
+
+  # Deletes the element at the specified index, returning that element, or nil
+  # if the index is out of range. 
+  #
+  # @example
+  #
+  #     a = ['ant', 'bat', 'cat', 'dog']
+  #     a.delete_at 2
+  #     # => 'cat'
+  #     a
+  #     # => ['ant', 'bat', 'dog']
+  #     a.delete_at 99
+  #     # => nil
+  #
+  # @param [Numeric] idx the index to delete
+  # @return [Object, nil] returns the deleted object or nil
+  def delete_at(idx)
+    `if (idx < 0) idx += self.length;
+    if (idx < 0 || idx >= self.length) return nil;
+    var res = self[idx];
+    self.splice(idx, 1);
+    return self;`
+  end
+
+  # Deletes every element of `self` for which `block` evaluates to true.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3]
+  #     a.delete_if { |x| x >= 2 }
+  #     # => [1]
+  #
+  # @return [Array] returns amended receiver
+  def delete_if
+    `for (var i = 0; i < self.length; i++) {
+      try {
+        if (#{yield `self[i]`}.$r) {
+          self.splice(i, 1);
+          i--;
+        }
+      } catch (e) {
+        switch(e.$keyword) {
+          case 2:
+            return e.$value;
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Drop first `n` elements from receiver, and returns remaining elements in
+  # array.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.drop 3
+  #     # => [4, 5, 6]
+  #
+  # @param [Number] n number of elements to drop
+  # @return [Array] returns new array
+  def drop(n)
+    `if (n > self.length) return [];
+    return self.slice(n);`
+  end
+
+  # Drop elements up to, but not including, the first element for which the
+  # block returns nil or false, and returns an array containing the remaining
+  # elements.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.drop_while { |i| i < 3 }
+  #     # => [3, 4, 5, 6]
+  #
+  # @return [Array] returns a new array
+  def drop_while
+    `for (var i = 0; i < self.length; i++) {
+      if (!#{yield `self[i]`}.$r) {
+        return self.slice(i);
+      }
+    }
+
+    return [];`
+  end
+
+  # Returns `true` if the receiver contains no elements, `false` otherwise.
+  #
+  # @example
+  #
+  #     [].empty?
+  #     # => true
+  #
+  # @return [false, true] empty or not
+  def empty?
+    `return self.length == 0 ? Qtrue : Qfalse;`
+  end
+
+  # Tries to return the element as position `index`. If the index lies outside
+  # the array, the first form throws an IndexError exception, the second form
+  # returns `default`, and the third form returns the value of invoking the
+  # block, passing in the index. Negative values of `index` count from the end
+  # of the array.
+  #
+  # @example First form
+  #
+  #     a = [11, 22, 33, 44]
+  #     a.fetch 1
+  #     # => 22
+  #     a.fetch -1
+  #     # => 44
+  #
+  # @example Second form
+  #
+  #     a.fetch 4, 'cat'
+  #     # => 'cat'
+  #
+  # @example Third form
+  #
+  #     a.fetch 4 { |i| i * i }
+  #     # => 16
+  #
+  # @param [Numeric] idx
+  # @param [Object] defaults
+  # @return [Object] returns result
+  def fetch(idx, defaults)
+    `var original = idx;
+
+    if (idx < 0) idx += self.length;
+    if (idx < 0 || idx >= self.length) {
+      if (defaults == undefined)
+        return rb_raise("Index Error: Array#fetch");
+      else if (__block__)
+        return #{yield `original`};
+      else
+        return defaults;
+    }
+
+    return self[idx];`
+  end
+
+  # Returns the first element, or the first `n` elements, of the array. If the
+  # array is empty, the first form returns `nil`, and the second form returns an
+  # empty array.
+  #
+  # @example
+  #
+  #     a = ['q', 'r', 's', 't']
+  #     a.first
+  #     # => q
+  #     a.first 2
+  #     # => ['q', 'r']
+  #
+  # @param [Numeric] count number of elements
+  # @return [Object, Array] object or array of objects
+  def first(count = nil)
+    `if (count == nil) {
+      if (self.length == 0) return nil;
+      return self[0];
+    }
+    return self.slice(0, count);`
+  end
+
+  # Returns a new array that is a one-dimensional flattening of this array
+  # (recursively). That is, for evey element that is an array, extract its
+  # elements into the new array. If the optional `level` argument determines the
+  # level of recursion to flatten.
+  #
+  # @example
+  #
+  #     s = [1, 2, 3]
+  #     # => [a, 2, 3]
+  #     t = [4, 5, 6, [7, 8]]
+  #     # => [4, 5, 6, [7, 8]]
+  #     a = [s, t, 9, 10]
+  #     # => [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
+  #     a.flatten
+  #     # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  #     a = [1, 2, [3, [4, 5]]]
+  #     a.flatten 1
+  #     # => [1, 2, 3, [4, 5]]
+  #
+  # @param [Numeric] level the level to flatten
+  # @return [Array] returns new array
+  def flatten(level = nil)
+    `var result = [], item;
+
+    for (var i = 0; i < self.length; i++) {
+      item = self[i];
+
+      if (item.hasOwnProperty('length')) {
+        if (level == nil)
+          result = result.concat(#{`item`.flatten});
+        else if (level == 0)
+          result.push(item);
+        else
+          result = result.concat(#{`item`.flatten `level - 1`});
+      } else {
+        result.push(item);
+      }
+    }
+
+    return result;`
+  end
+
+  # Flattens the receiver in place. Returns `nil` if no modifications were made.
+  # If the optional level argument determines the level of recursion to flatten.
+  #
+  # @example
+  #
+  #     a = [1, 2, [3, [4, 5]]]
+  #     a.flatten!
+  #     # => [1, 2, 3, 4, 5]
+  #     a.flatten!
+  #     # => nil
+  #     a
+  #     # => [1, 2, 3, 4, 5]
+  #
+  # @param [Number] level to flatten to
+  # @return [Array] returns the receiver
+  def flatten!(level = nil)
+    `var length = self.length;
+    var result = #{self.flatten level};
+    self.splice(0);
+
+    for (var i = 0; i < result.length; i++) {
+      self.push(result[i]);
+    }
+
+    if (self.length == length)
+      return nil;
+
+    return self;`
+  end
+
+  # Returns true if the given object is present in `self`, false otherwise.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.include? 'b'
+  #     # => true
+  #     a.include? 'z'
+  #     # => false
+  def include?(member)
+    `for (var i = 0; i < self.length; i++) {
+      if (#{`self[i]` == member}.$r) {
+        return #{true};
+      }
+    }
+
+    return #{false};`
+  end
+
+  # Replaces the contents of `self` with the contents of `other`, truncating or
+  # expanding if necessary.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd', 'e']
+  #     a.replace ['x', 'y', 'z']
+  #     # => ['x', 'y', 'z']
+  #     a
+  #     # => ['x', 'y', 'z']
+  #
+  # @param [Array] other array to replace contents with
+  # @return [Array] returns the receiver
+  def replace(other)
+    `self.splice(0);
+
+    for (var i = 0; i < other.length; i++) {
+      self.push(other[i]);
+    }
+
+    return self;`
+  end
+
+  # Inserts the given values before the element with the given index (which may
+  # be negative).
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd']
+  #     a.insert 2, 99
+  #     # => ['a', 'b', 99, 'c', 'd']
+  #     a.insert -2, 1, 2, 3
+  #     # => ['a', 'b', 99, 'c', 1, 2, 3, 'd']
+  #
+  # @param [Numeric] idx the index for insertion
+  # @param [Object] objs objects to insert
+  # @return [Array] returns the receiver
+  def insert(idx, *objs)
+    `if (idx < 0) idx += self.length;
+
+    if (idx < 0 || idx >= self.length)
+      rb_raise("IndexError: out of range");
+
+    self.splice.apply(self, [idx, 0].concat(objs));
+    return self;`
+  end
+
+  # Returns a string created by converting each element of the array to a string
+  # seperated by `sep`.
+  #
+  # @example
+  #
+  #     ['a', 'b', 'c'].join
+  #     # => 'abc'
+  #     ['a', 'b', 'c'].join '-'
+  #     # => 'a-b-c'
+  #
+  # @param [String] sep the separator
+  # @return [String] joined string
+  def join(sep = '')
+    `var result = [];
+
+    for (var i = 0; i < self.length; i++) {
+      result.push(#{`self[i]`.to_s});
+    }
+
+    return result.join(sep);`
+  end
+
+  # Deletes every element of `self` for which the block evaluates to false.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.keep_if { |x| x < 4 }
+  #     # => [1, 2, 3]
+  #
+  # @return [Array] returns the receiver
+  def keep_if
+    `for (var i = 0; i < self.length; i++) {
+      if (!#{yield `self[i]`}.$r) {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return self;`
+  end
+
+  # Return the last element(s) of `self`. If the array is empty, the first form
+  # returns `nil`.
+  #
+  # @example
+  #
+  #     a = ['w', 'x', 'y', 'z']
+  #     a.last
+  #     # => 'z'
+  #     a.last 2
+  #     # => ['y', 'z']
+  #
+  # @param [Number] count the number of items to get
+  # @return [Object, Array] result
+  def last(count = nil)
+    `if (count == nil) {
+      if (self.length == 0) return nil;
+      return self[self.length - 1];
+    } else {
+      if (count > self.length) count = self.length;
+      return self.slice(self.length - count, self.length);
+    }`
+  end
+
+  # Removes the last element from `self` and returns it, or `nil` if the array
+  # is empty. If a count is given, returns an array of the last `count`
+  # elements (or less).
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd']
+  #     a.pop
+  #     # => 'd'
+  #     a.pop 2
+  #     # => 'b', 'c'
+  #     a
+  #     # => ['a']
+  #
+  # @param [Numeric] count number to pop
+  # @return [Array] returns popped items
+  def pop(count = nil)
+    `if (count == nil) {
+      if (self.length) return self.pop();
+      return nil;
+    } else {
+      return self.splice(self.length - count, self.length);
+    }`
+  end
+
+  # Searches through the array whose elements are also arrays. Compares `obj`
+  # with the second element of each contained array using `==`. Returns the
+  # first contained array that matches.
+  #
+  # @example
+  #
+  #     a = [[1, 'one'], [2, 'two'], [3, 'three'], ['ii', 'two']]
+  #     a.rassoc 'two'
+  #     # => [2, 'two']
+  #     a.rassoc 'four'
+  #     # => nil
+  #
+  # @param [Object] obj object to search for
+  # @return [Object, nil] result or nil
+  def rassoc(obj)
+    `var test;
+
+    for (var i = 0; i < self.length; i++) {
+      test = self[i];
+      if (test.hasOwnProperty('length') && test[1] != undefined) {
+        console.log("trying " + i);
+        if (#{`test[1]` == obj}.$r) return test;
+      }
+    }
+
+    return nil;`
+  end
+
+  # Returns a new array containing the items in `self` for which the block is
+  # not true. See also {#delete_if}.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.reject { |x| x > 3 }
+  #     # => [1, 2, 3]
+  #     a
+  #     # => [1, 2, 3, 4, 5, 6]
+  #
+  # @return [Array] returns the receiver
+  def reject
+    `var result = [];
+
+    for (var i = 0; i < self.length; i++) {
+      if (!#{yield `self[i]`}.$r) {
+        result.push(self[i]);
+      }
+    }
+
+    return result;`
+  end
+
+  # Equivalent to {#delete_if!}, deleting elements from self for which the block
+  # evaluates to true, but returns nil if no changes were made.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.reject! { |x| x > 3 }
+  #     # => [1, 2, 3]
+  #     a.reject! { |x| x > 3 }
+  #     # => nil
+  #     a
+  #     # => [1, 2, 3]
+  #
+  # @return [Array] returns receiver
+  def reject!
+    `var length = self.length;
+
+    for (var i = 0; i < self.length; i++) {
+      if (#{yield `self[i]`}.$r) {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return self.length == length ? nil : self;`
+  end
+
+  # Returns a new array containing the receiver's elements in reverse order.
+  #
+  # @example
+  #
+  #     ['a', 'b', 'c'].reverse
+  #     # => ['c', 'b', 'a']
+  #     [1].reverse
+  #     # => [1]
+  #
+  # @return [Array] return new array
+  def reverse
+    `var result = [];
+
+    for (var i = self.length - 1; i >= 0; i--) {
+      result.push(self[i]);
+    }
+
+    return result;`
+  end
+
+  # Reverses the receiver in place.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.reverse!
+  #     # => ['c', 'b', 'a']
+  #     a
+  #     # => ['c', 'b', 'a']
+  #
+  # @return [Array] returns the receiver
+  def reverse!
+    `var length = self.length / 2, tmp;
+
+    for (var i = 0; i < length; i++) {
+      tmp = self[i];
+      self[i] = self[self.length - (i + 1)];
+      self[self.length - (i + 1)] = tmp;
+    }
+
+    return self;`
+  end
+
+  # Same as {#each}, but traverses the receiver in reverse order
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.reverse_each { |x| puts x }
+  #     # => 'c'
+  #     # => 'b'
+  #     # => 'a'
+  #
+  # @return [Array] returns the receiver
+  def reverse_each
+    `for (var i = self.length - 1; i >= 0; i--) {
+      try {
+        #{yield `self[i]`};
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e['@exit_value'];
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return self;`
+  end
+
+  # Returns the index of the last object in self that is == to object. If a 
+  # block is given instead of an argument, returns the first object for which
+  # block is true, starting from the last object. Returns `nil` if no match is
+  # found.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'b', 'b', 'c']
+  #     a.rindex 'b'
+  #     # => 3
+  #     a.rindex 'z'
+  #     # => nil
+  #     a.rindex { |x| x == 'b' }
+  #     # => 3
+  #
+  # @return [Object, nil] returns result or nil
+  def rindex(obj = `undefined`)
+    `if (obj != undefined) {
+      for (var i = self.length - 1; i >=0; i--) {
+        if (#{`self[i]` == obj}.$r) {
+          return i;
+        }
+      }
+    } else if (true || __block__) {
+      rb_raise("array#rindex needs to do block action");
+    }
+
+    return nil;`
+  end
+
+  # Invokes the block passing in successive elements from `self`, deleting the
+  # elements for which the block returns a false value. It returns `self` if
+  # changes were made, otherwise it returns `nil`.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.select! { |x| x > 4 }
+  #     # => [5, 6]
+  #     a.select! { |x| x > 4 }
+  #     # => nil
+  #     a
+  #     # => [5, 6]
+  #
+  # @return [Array] returns receiver
+  def select!
+    `var length = self.length;
+
+    for (var i = 0; i < self.length; i++) {
+      if (!#{yield `self[i]`}.$r) {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return self.length == length ? nil : self;`
+  end
+
+  # Returns the first element of `self` and removes it (shifting all other
+  # elements down by one). Returns `nil` if the array is empty.
+  #
+  # If a number `n` is given, returns an array of the first n elements (or 
+  # less), just like {#slice} does.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.shift
+  #     # => 'a'
+  #     a
+  #     # => ['b', 'c']
+  #     a = ['a', 'b', 'c']
+  #     a.shift 2
+  #     # => ['a', 'b']
+  #     a
+  #     # => ['c']
+  #
+  # @param [Numeric] count elements to shift
+  # @return [Array] result
+  def shift(count = nil)
+    `if (count != nil)
+      return self.splice(0, count);
+
+    if (self.length) 
+      return self.shift();
+
+    return nil;`
+  end
+
+  # Deletes the element(s) given by an `index` (optionally with a length) or
+  # by a range. Returns the deleted object(s), or `nil` if the index is out of
+  # range.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c']
+  #     a.slice! 1
+  #     # => 'b'
+  #     a
+  #     # => ['a', 'c']
+  #     a.slice! -1
+  #     # => 'c'
+  #     a
+  #     # => ['a']
+  #     a.slice! 100
+  #     # => nil
+  #
+  # TODO does not yet work with ranges
+  #
+  # @param [Range, Number] index to begin with
+  # @param [Number] length last index
+  # @return [Array, nil] result
+  def slice!(index, length = nil)
+    `var size = self.length;
+
+    if (index < 0) index += size;
+
+    if (index >= size || index < 0) return nil;
+
+    if (length != nil) {
+      if (length <= 0 || length > self.length) return nil;
+      return self.splice(index, index + length);
+    } else {
+      return self.splice(index, 1)[0];
+    }`
+  end
+
+  # Returns first `count` elements from ary.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.take 3
+  #     # => [1, 2, 3]
+  #
+  # @return [Array] array of elements
+  def take(count)
+    `return self.slice(0, count);`
+  end
+
+
+  # Passes elements to the block until the block returns a false value, then
+  # stops iterating and returns an array of all prior elements.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3, 4, 5, 6]
+  #     a.take_while { |i| i < 3 }
+  #     # => [1, 2]
+  #
+  # @return [Array] new array with elements
+  def take_while
+    `var result = [];
+
+    for (var i = 0; i < self.length; i++) {
+      try {
+        if (#{yield `self[i]`}.$r) {
+          result.push(self[i]);
+        } else {
+          break;
+        }
+      } catch (e) {
+        switch (e.$keyword) {
+          case 2:
+            return e['@exit_value'];
+
+          default:
+            throw e;
+        }
+      }
+    }
+
+    return result;`
+  end
+
+  # Returns the receiver.
+  #
+  # @example
+  #
+  #     a = [1, 2, 3]
+  #     a.to_a
+  #     # => [1, 2, 3]
+  #
+  # @return [Array] returns the receiver
+  def to_a
+    self
+  end
+
+  # Returns a new array by removing duplicate values in `self`.
+  #
+  # @example
+  #
+  #     a = ['a', 'a', 'b', 'b', 'c']
+  #     a.uniq
+  #     # => ['a', 'b', 'c']
+  #     a
+  #     # => ['a', 'a', 'b', 'b', 'c']
+  #
+  # @return [Array]
+  def uniq
+    `var result = [], seen = [];
+
+    for (var i = 0; i < self.length; i++) {
+      var test = self[i], hash = test.$hash();
+      if (seen.indexOf(hash) == -1) {
+        seen.push(hash);
+        result.push(test);
+      }
+    }
+
+    return result;`
+  end
+
+  # Removes duplicate elements from `self`. Returns `nil` if no changes are
+  # made (that is, no duplicates are found).
+  #
+  # @example
+  #
+  #     a = ['a', 'a', 'b', 'b', 'c']
+  #     a.uniq!
+  #     # => ['a', 'b', 'c']
+  #     a.uniq!
+  #     # => nil
+  #
+  # @return [Array] returns receiver
+  def uniq!
+    `var seen = [], length = self.length;
+
+    for (var i = 0; i < self.length; i++) {
+      var test = self[i], hash = test.$hash();
+      if (seen.indexOf(hash) == -1) {
+        seen.push(hash);
+      } else {
+        self.splice(i, 1);
+        i--;
+      }
+    }
+
+    return self.length == length ? nil : self;`
+  end
+
+  # Prepends objects to the front of `self`, moving other elements upwards.
+  #
+  # @example
+  #
+  #     a = ['b', 'c', 'd']
+  #     a.unshift 'a'
+  #     # => ['a', 'b', 'c', 'd']
+  #     a.unshift 1, 2
+  #     # => [1, 2, 'a', 'b', 'c', 'd']
+  #
+  # @param [Object] objs objects to add
+  # @return [Array] returns the receiver
+  def unshift(*objs)
+    `for (var i = objs.length - 1; i >= 0; i--) {
+      self.unshift(objs[i]);
+    }
+
+    return self;`
+  end
+
+  # Set intersection - Returns a new array containing elements common to the
+  # two arrays, with no duplicates.
+  #
+  # @example
+  #
+  #     [1, 1, 3, 5] & [1, 2, 3]
+  #     # => [1, 3]
+  #
+  # @param [Array] other second array to intersect
+  # @return [Array] new intersected array
+  def &(other)
+    `var result = [], seen = [];
+
+    for (var i = 0; i < self.length; i++) {
+      var test = self[i], hash = test.$hash();
+
+      if (seen.indexOf(hash) == -1) {
+        for (var j = 0; j < other.length; j++) {
+          var test_b = other[j], hash_b = test_b.$hash();
+
+          if ((hash == hash_b) && seen.indexOf(hash) == -1) {
+            seen.push(hash);
+            result.push(test);
+          }
+        }
+      }
+    }
+
+    return result;`
+  end
+
+  # Repitition - When given a string argument, acts the same as {#join}.
+  # Otherwise, returns a new array build by concatenating the `num` copies of
+  # self.
+  #
+  # @example With Number
+  #
+  #     [1, 2, 3] * 3
+  #     # => [1, 2, 3, 1, 2, 3, 1, 2, 3]
+  #
+  # @example With String
+  #
+  #     [1, 2, 3] * ','
+  #     # => '1,2,3'
+  #
+  # @param [String, Number] num string or number used to join or concat
+  # @return [String, Array] depending on argument
+  def *(arg)
+    `if (typeof arg == 'string') {
+      return #{self.join `arg`};
+    } else {
+      var result = [];
+      for (var i = 0; i < parseInt(arg); i++) {
+        result = result.concat(self);
+      }
+
+      return result;
+    }`
+  end
+
+  # Element Reference - Returns the element at `index`, or returns a subarray
+  # at index and counting for length elements, or returns a subarray if index
+  # is a range. Negative indecies count backward from the end of the array (-1
+  # is the last element). Returns `nil` if the index (or starting index) are
+  # out of range.
+  #
+  # @example
+  #
+  #     a = ['a', 'b', 'c', 'd', 'e']
+  #     a[2] + a[0] + a[1]              # => 'cab'
+  #     a[6]                            # => nil
+  #     a[1, 2]                         # => ['b', 'c']
+  #     a[1..3]                         # => ['b', 'c', 'd']
+  #     a[4..7]                         # => ['e']
+  #     a[6..10]                        # => nil
+  #     a[-3, 3]                        # => ['c', 'd', 'e']
+  #     a[5]                            # => nil
+  #     a[5, 1]                         # => []
+  #     a[5..10]                        # => []
+  #
+  # @TODO: does not yet work with ranges
+  #
+  # @param [Range, Numeric] index to begin
+  # @param [Numeric] length last index
+  # @return [Array, Object, nil] result
+  def [](index, length = `undefined`)
+    `var size = self.length;
+
+    if (index < 0) index += size;
+
+    if (index >= size || index < 0) return nil;
+
+    if (length != undefined) {
+      if (length <= 0) return [];
+      return self.slice(index, index + length);
+    } else {
+      return self[index];
+    }`
+  end
+
+  # Element reference setting.
+  #
+  # @TODO: need to expand functionlaity.
+  def []=(index, value)
+    `return self[index] = value;`
+  end
+end
+