opal 0.8.1 → 0.9.0.beta1

data/benchmark/bm_hash_rehash_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = nil
+end
+
+1_000.times do
+  h.rehash
+end

data/benchmark/bm_hash_reject_bang_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = i
+end
+
+10_000.times do |i|
+  h.reject!{|k, v| v <= i}
+end

data/benchmark/bm_hash_reject_bang_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = i
+end
+
+10_000.times do |i|
+  h.reject!{|k, v| v <= i}
+end

data/benchmark/bm_hash_reject_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = i
+end
+
+100.times do |i|
+  h.reject{|k, v| v % 2 == 0}
+end

data/benchmark/bm_hash_reject_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = i
+end
+
+100.times do |i|
+  h.reject{|k, v| v % 2 == 0}
+end

data/benchmark/bm_hash_replace_object.rb

@@ -0,0 +1,18 @@
+h1 = {}
+h2 = {}
+
+a = []
+
+1.upto(5_000) do |i|
+  a[i] = Object.new
+  h1[a[i]] = nil
+end
+
+2_501.upto(7_500) do |i|
+  a[i] = Object.new
+  h2[a[i]] = nil
+end
+
+1_000.times do
+  h1.replace(h2)
+end

data/benchmark/bm_hash_replace_string.rb

@@ -0,0 +1,14 @@
+h1 = {}
+h2 = {}
+
+1.upto(5_000) do |i|
+  h1[i.to_s] = nil
+end
+
+2_501.upto(7_500) do |i|
+  h2[i.to_s] = nil
+end
+
+1_000.times do
+  h1.replace(h2)
+end

data/benchmark/bm_hash_select_bang_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = i
+end
+
+10_000.times do |i|
+  h.select!{|k, v| v > i}
+end

data/benchmark/bm_hash_select_bang_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = i
+end
+
+10_000.times do |i|
+  h.select!{|k, v| v > i}
+end

data/benchmark/bm_hash_select_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = i
+end
+
+100.times do |i|
+  h.select{|k, v| v % 2 == 0}
+end

data/benchmark/bm_hash_select_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = i
+end
+
+100.times do |i|
+  h.select{|k, v| v % 2 == 0}
+end

data/benchmark/bm_hash_shift_object.rb

@@ -0,0 +1,10 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = nil
+end
+
+1_000_000.times do
+  k, v = h.shift
+  h[k] = v
+end

data/benchmark/bm_hash_shift_string.rb

@@ -0,0 +1,10 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = nil
+end
+
+1_000_000.times do
+  k, v = h.shift
+  h[k] = v
+end

data/benchmark/bm_hash_to_a_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = nil
+end
+
+5_000.times do
+  h.to_a
+end

data/benchmark/bm_hash_to_a_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = nil
+end
+
+5_000.times do
+  h.to_a
+end

data/benchmark/bm_hash_to_h_object.rb

@@ -0,0 +1,10 @@
+class MyHash < Hash; end
+h = MyHash.new
+
+10_000.times do |i|
+  h[Object.new] = nil
+end
+
+1_000.times do
+  h.to_h
+end

data/benchmark/bm_hash_to_h_string.rb

@@ -0,0 +1,10 @@
+class MyHash < Hash; end
+h = MyHash.new
+
+10_000.times do |i|
+  h[i.to_s] = nil
+end
+
+1_000.times do
+  h.to_h
+end

data/benchmark/bm_hash_values_object.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[Object.new] = nil
+end
+
+1_000.times do
+  h.values
+end

data/benchmark/bm_hash_values_string.rb

@@ -0,0 +1,9 @@
+h = {}
+
+10_000.times do |i|
+  h[i.to_s] = nil
+end
+
+1_000.times do
+  h.values
+end

data/benchmark/run.rb

@@ -0,0 +1,48 @@
+if RUBY_ENGINE == 'opal'
+  require 'opal/compiler'
+  require 'nodejs'
+end
+
+BEST_OF_N = Integer(ENV['BEST_OF_N']) rescue 1
+
+require 'benchmark'
+
+files = ARGV
+
+if files.empty?
+  files = File.read('benchmark/benchmarks').lines.map(&:strip).reject do |line|
+    line.empty? || line.start_with?('#')
+  end
+end
+
+maxlen = files.max_by{|file| file.length}.length + 1
+
+total_time = 0
+
+files.each do |file|
+  print file, " " * (maxlen - file.length)
+
+  times = []
+
+  if RUBY_ENGINE == 'opal'
+    code = Opal.compile(File.read(file))
+    BEST_OF_N.times do
+      times << Benchmark.measure { `eval(code)` }
+    end
+  else
+    code = File.read(file)
+    BEST_OF_N.times do
+      times << Benchmark.measure { eval(code) }
+    end
+  end
+
+  time = times.min_by{|t| t.real}
+
+  total_time += time.real
+
+  print time.real, "\n"
+end
+
+bottom_line = "Executed #{ files.length } benchmark#{ 's' if files.length != 1} in #{ total_time } sec"
+$stderr.print "=" * bottom_line.length, "\n"
+$stderr.print bottom_line, "\n"

data/bin/opal-mspec

@@ -7,4 +7,4 @@ pattern = %Q{MSPEC_PATTERN="{#{specs.join(',')}}"} if specs.any?
 command = [pattern, 'rake mspec'].compact.join(' ')
 exec command
 
-# RUBYOPT="-rbundler/setup -rmspec/opal/special_calls" bundle exec mspec run -t opal -pspec/corelib/spec_helper spec/corelib/core/true/*
+# RUBYOPT="-rbundler/setup -rmspec/opal/special_calls" bundle exec mspec run -t opal -pspec/rubyspec/spec_helper spec/rubyspec/core/true/*

data/bin/opal-repl

@@ -14,7 +14,7 @@ module Opal
       begin
         require 'v8'
       rescue LoadError
-        abort 'therubyracer must be installed'
+        abort 'opal-repl depends on therubyracer gem, which is not currently installed'
       end
 
       @v8 = V8::Context.new
@@ -41,11 +41,11 @@ module Opal
 
       loop do
         # on SIGINT lets just return from the loop..
-        trap("SIGINT") { finish; return }
+        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?
+        if line == 'exit' or line.nil?
           break
         end
 
@@ -57,7 +57,7 @@ module Opal
 
     def eval_ruby(str)
       code = Opal::Builder.new.build_str(str, '(irb)', :irb => true, :const_missing => true)
-      code.processed[0...-1].each{ |c| @v8.eval(c.to_s) }
+      code.processed[0...-1].each { |c| @v8.eval(c.to_s) }
       @v8.eval "var $_result = #{code.processed.last.to_s} ($_result == null ? 'nil' : $_result.$inspect());"
     rescue => e
       puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"

data/docs/compiled_ruby.md

@@ -1,6 +1,6 @@
 # Compiled Ruby Code
 
-## Generated Javascript
+## Generated JavaScript
 
 Opal is a source-to-source compiler, so there is no VM as such and the
 compiled code aims to be as fast and efficient as possible, mapping
@@ -43,11 +43,11 @@ Hello there.
 EOS
 ```
 
-Ruby strings are compiled directly into javascript strings for
+Ruby strings are compiled directly into JavaScript strings for
 performance as well as readability. This has the side effect that Opal
 does not support mutable strings - i.e. all strings are immutable.
 
-NOTE: Strings in Opal are immutable because they are compiled into regular javascript strings. This is done for performance reasons.
+NOTE: Strings in Opal are immutable because they are compiled into regular JavaScript strings. This is done for performance reasons.
 
 For performance reasons, symbols are also compiled directly into strings.
 Opal supports all the symbol syntaxes, but does not have a real `Symbol`
@@ -55,8 +55,8 @@ class. Symbols and Strings can therefore be used interchangeably.
 
 #### Numbers
 
-In Opal there is a single class for numbers; `Numeric`. To keep opal
-as performant as possible, ruby numbers are mapped to native numbers.
+In Opal there is a single class for numbers; `Numeric`. To keep Opal
+as performant as possible, Ruby numbers are mapped to native numbers.
 This has the side effect that all numbers must be of the same class.
 Most relevant methods from `Integer`, `Float` and `Numeric` are
 implemented on this class.
@@ -68,8 +68,8 @@ implemented on this class.
 
 #### Arrays
 
-Ruby arrays are compiled directly into javascript arrays. Special
-ruby syntaxes for word arrays etc are also supported.
+Ruby arrays are compiled directly into JavaScript arrays. Special
+Ruby syntaxes for word arrays etc are also supported.
 
 ```ruby
 [1, 2, 3, 4]        # => [1, 2, 3, 4]
@@ -78,30 +78,30 @@ ruby syntaxes for word arrays etc are also supported.
 
 #### Hash
 
-Inside a generated ruby script, a function `__hash` is available which
-creates a new hash. This is also available in javascript as `Opal.hash`
+Inside a generated Ruby script, a function `Opal.hash` is available which
+creates a new hash. This is also available in JavaScript as `Opal.hash`
 and simply returns a new instance of the `Hash` class.
 
 ```ruby
-{ :foo => 100, :baz => 700 }    # => __hash("foo", 100, "baz", 700)
-{ foo: 42, bar: [1, 2, 3] }     # => __hash("foo", 42, "bar", [1, 2, 3])
+{ :foo => 100, :baz => 700 }    # => Opal.hash("foo", 100, "baz", 700)
+{ foo: 42, bar: [1, 2, 3] }     # => Opal.hash("foo", 42, "bar", [1, 2, 3])
 ```
 
 #### Range
 
-Similar to hash, there is a function `__range` available to create
+Similar to hash, there is a function `Opal.range` available to create
 range instances.
 
 ```ruby
-1..4        # => __range(1, 4, true)
-3...7       # => __range(3, 7, false)
+1..4        # => Opal.range(1, 4, true)
+3...7       # => Opal.range(3, 7, false)
 ```
 
 ### Logic and conditionals
 
-As per ruby, Opal treats only `false` and `nil` as falsy, everything
+As per Ruby, Opal treats only `false` and `nil` as falsy, everything
 else is a truthy value including `""`, `0` and `[]`. This differs from
-javascript as these values are also treated as false.
+JavaScript as these values are also treated as false.
 
 For this reason, most truthy tests must check if values are `false` or
 `nil`.
@@ -133,7 +133,7 @@ This makes the generated truthy tests (`if` statements, `and` checks and
 
 Instance variables in Opal work just as expected. When ivars are set or
 retrieved on an object, they are set natively without the `@` prefix.
-This allows real javascript identifiers to be used which is more
+This allows real JavaScript identifiers to be used which is more
 efficient then accessing variables by string name.
 
 ```ruby
@@ -152,13 +152,13 @@ this.foo;   // => 200
 this.bar;   // => nil
 ```
 
-NOTE: If an instance variable uses the same name as a reserved javascript keyword,
+NOTE: If an instance variable uses the same name as a reserved JavaScript keyword,
 then the instance variable is wrapped using the object-key notation: `this['class']`.
 
 ## Compiled Files
 
-As described above, a compiled ruby source gets generated into a string
-of javascript code that is wrapped inside an anonymous function. This
+As described above, a compiled Ruby source gets generated into a string
+of JavaScript code that is wrapped inside an anonymous function. This
 looks similar to the following:
 
 ```javascript
@@ -194,14 +194,14 @@ written to the browser's console.
 
 ### Debugging and finding errors
 
-Because Opal does not aim to be fully compatible with ruby, there are
+Because Opal does not aim to be fully compatible with Ruby, there are
 some instances where things can break and it may not be entirely
 obvious what went wrong.
 
-### Using javascript debuggers
+### Using JavaScript debuggers
 
-As opal just generates javascript, it is useful to use a native
-debugger to work through javascript code. To use a debugger, simply
+As Opal just generates JavaScript, it is useful to use a native
+debugger to work through JavaScript code. To use a debugger, simply
 add an x-string similar to the following at the place you wish to
 debug:
 
@@ -211,31 +211,32 @@ debug:
 # .. more code
 ```
 The x-strings just pass the debugger statement straight through to the
-javascript output.
+JavaScript output.
 
-NOTE: All local variables and method/block arguments also keep their ruby
-names except in the rare cases when the name is reserved in javascript.
+NOTE: All local variables and method/block arguments also keep their Ruby
+names except in the rare cases when the name is reserved in JavaScript.
 In these cases, a `$` suffix is added to the name
 (e.g. `try` → `try$`).
 
-## Javascript from Ruby
 
-Opal tries to interact as cleanly with javascript and its api as much
+## JavaScript from Ruby
+
+Opal tries to interact as cleanly with JavaScript and its api as much
 as possible. Ruby arrays, strings, numbers, regexps, blocks and booleans
-are just javascript native equivalents. The only boxed core features are
+are just JavaScript native equivalents. The only boxed core features are
 hashes.
 
 
-### Inline Javascript
+### Inline JavaScript
 
-As most of the corelib deals with these low level details, opal provides
-a special syntax for inlining javascript code. This is done with
-x-strings or "backticks", as their ruby use has no useful translation
+As most of the corelib deals with these low level details, Opal provides
+a special syntax for inlining JavaScript code. This is done with
+x-strings or "backticks", as their Ruby use has no useful translation
 in the browser.
 
 ```ruby
 `window.title`
-# => "Opal: Ruby to Javascript compiler"
+# => "Opal: Ruby to JavaScript compiler"
 
 %x{
   console.log("opal version is:");
@@ -267,7 +268,9 @@ as used by this example.
 
 _Reposted from: [Mikamayhem](http://dev.mikamai.com/post/79398725537/using-native-javascript-objects-from-opal)_
 
-Opal standard lib (stdlib) includes a `Native` module, let’s see how it works and wrap `window`:
+Opal standard lib (stdlib) includes a `Native` module. To use it, you need to download and reference `native.js`. You can find the latest minified one from the CDN [here](http://cdn.opalrb.org/opal/current/native.min.js).
+
+Let's see how it works and wrap `window`:
 
 ```ruby
 require 'native'
@@ -314,34 +317,190 @@ That’s all for now, bye!
 window.close!
 ```
 
-## Ruby from Javascript
+### Calling JavaScript Methods
+
+You can make direct JavaScript method calls on using the `recv.JS.method`
+syntax.  For example, if you have a JavaScript object named `foo` and want to call the
+`bar` method on it with no arguments, with or without parentheses:
+
+```ruby
+# javascript: foo.bar()
+foo.JS.bar
+foo.JS.bar()
+```
+
+You can call the JavaScript methods with arguments, with or without parentheses, just
+like Ruby methods:
+
+```ruby
+# JavaScript: foo.bar(1, "a")
+foo.JS.bar(1, :a)
+foo.JS.bar 1, :a
+```
+
+You can call the JavaScript methods with argument splats:
+
+```ruby
+# JavaScript: ($a = foo).bar.apply($a, [1].concat([2, 3]))
+foo.JS.bar(1, *[2, 3])
+foo.JS.bar 1, *[2, 3]
+```
+
+You can provide a block when making a JavaScript method call, and it will be
+converted to a JavaScript function added as the last argument to the method:
+
+```ruby
+# JavaScript:
+# ($a = (TMP_1 = function(arg){
+#     var self = TMP_1.$$s || this;
+#     if (arg == null) arg = nil;
+#     return "" + (arg.method()) + " " + (self.$baz(3))
+#    },
+#    TMP_1.$$s = self, TMP_1),
+# foo.bar)(1, 2, $a);
+foo.JS.bar(1, 2){|arg| arg.JS.method + baz(3)}
+```
+
+Note how `self` is set for the JavaScript function passed as an argument.  This
+allows normal Ruby block behavior to work when passing blocks to JavaScript
+methods.
 
-Accessing classes and methods defined in Opal from the javascript runtime is
+The `.JS.` syntax is recognized as a special token by the lexer, so if you have
+a Ruby method named `JS` that you want to call, you can add a space to call it:
+
+```ruby
+# call Ruby JS method on foo, call Ruby bar method on result
+foo. JS.bar
+```
+
+### Getting/Setting JavaScript Properties
+
+You can get JavaScript properties using the `recv.JS[:property]` syntax:
+
+```ruby
+# JavaScript: foo["bar"]
+foo.JS[:bar]
+```
+
+This also works for JavaScript array access:
+
+```ruby
+# JavaScript: foo[2]
+foo.JS[2]
+```
+
+You can set JavaScript properties using this as the left hand side in an
+assignment:
+
+```ruby
+# JavaScript: foo["bar"] = 1
+foo.JS[:bar] = 1
+```
+
+This also works for setting values in a JavaScript array:
+
+```ruby
+# JavaScript: foo[2] = "a"
+foo.JS[2] = :a
+```
+
+Like the `recv.JS.method` syntax, `.JS[` is recognized as a special token by
+the lexer, so if you want to call the Ruby `JS` method on a object and then
+call the Ruby `[]` method on the result, you can add a space:
+
+```ruby
+# call Ruby JS method on foo, call Ruby [] method on result with :a argument
+foo. JS[:a]
+```
+
+### Calling JavaScript Operators
+
+Opal has a `js` library in the stdlib that provides a `JS` module which can
+be used to call JavaScript operators such as `new`.  Example:
+
+```ruby
+require 'js'
+
+# new foo(bar)
+JS.new(foo, bar)
+
+# delete foo["bar"]
+JS.delete(foo, :bar)
+
+# "bar" in foo
+JS.in(:bar, foo)
+
+# foo instanceof bar
+JS.instanceof(foo, bar)
+
+# typeof foo
+JS.typeof(foo)
+```
+
+### Calling JavaScript Global Functions
+
+You can also use the `js` library to call JavaScript global functions via
+`JS.call`:
+
+```ruby
+require 'js'
+
+# parseFloat("1.1")
+JS.call(:parseFloat, "1.1")
+```
+
+For convenience, `method_missing` is aliased to call, allowing you to call
+global JavaScript methods directly on the `JS` module:
+
+```ruby
+require 'js'
+
+# parseFloat("1.1")
+JS.parseFloat("1.1")
+```
+
+
+### Wrapping JavaScript Libraries
+
+If you want to integrate a JavaScript library with Opal, so that you can make Ruby calls, you can choose one of the following options:
+
+- **Use backticks:** This is the quickest, simplest approach to integrating: call the native JavaScript code directly; it may provide a slight performance benefit, but also produces "ugly" Ruby code riddled with JavaScript. It's ideal for occasional calls to a JavaScript library.
+
+- **Use `.JS`:** You can make direct JavaScript method calls on using the `recv.JS.method` syntax.  It is very similar to using backticks but looks more like ruby.
+
+- **Use `Native`:** `Native` provides a reasonable Ruby-like wrapper around JavaScript objects. This provides a quick in-term solution if no dedicated Ruby wrapper library exists.
+
+- **Create your own Wrapper Library:** If you use the library a lot, you can create your own Ruby library that wraps the JavaScript calls (which call `Native` or use backticks under the hood). This provides the best abstraction (eg. you can provide high-level calls that provide functionality, regardless of if the underlying JavaScript call flows change).
+
+
+## Ruby from JavaScript
+
+Accessing classes and methods defined in Opal from the JavaScript runtime is
 possible via the `Opal` js object. The following class:
 
 ```ruby
 class Foo
   def bar
-    puts "called bar on class Foo defined in ruby code"
+    puts "called bar on class Foo defined in Ruby code"
   end
 end
 ```
 
-Can be accessed from javascript like this:
+Can be accessed from JavaScript like this:
 
 ```javascript
 Opal.Foo.$new().$bar();
-// => "called bar on class Foo defined in ruby code"
+// => "called bar on class Foo defined in Ruby code"
 ```
 
-Remember that all ruby methods are prefixed with a `$`.
+Remember that all Ruby methods are prefixed with a `$`.
 
-In the case that a method name can't be called directly due to a javascript syntax error, you will need to call the method using bracket notation. For example, you can call `foo.$merge(...)` but not `foo.$merge!(...)`, `bar.$fetch('somekey')` but not `bar.$[]('somekey')`. Instead you would write it like this: `foo['$merge!'](...)` or `bar['$[]']('somekey')`.
+In the case that a method name can't be called directly due to a JavaScript syntax error, you will need to call the method using bracket notation. For example, you can call `foo.$merge(...)` but not `foo.$merge!(...)`, `bar.$fetch('somekey')` but not `bar.$[]('somekey')`. Instead you would write it like this: `foo['$merge!'](...)` or `bar['$[]']('somekey')`.
 
 
 ### Hash
 
-Since ruby hashes are implemented directly with an Opal class, there's no "toll-free" bridging available (unlike with strings and arrays, for example). However, it's quite possible to interact with hashes from Javascript:
+Since Ruby hashes are implemented directly with an Opal class, there's no "toll-free" bridging available (unlike with strings and arrays, for example). However, it's quite possible to interact with hashes from JavaScript:
 
 ```javascript
 var myHash = Opal.hash({a: 1, b: 2});
@@ -355,7 +514,7 @@ myHash.$fetch('z','');
 myHash.$update(Opal.hash({b: 20, c: 30}));
 // output of $inspect: {"a"=>10, "b"=>20, "c"=>30}
 myHash.$to_n(); // provided by the Native module
-// output: {"a": 10, "b": 20, "c": 30} aka a standard Javascript object
+// output: {"a": 10, "b": 20, "c": 30} aka a standard JavaScript object
 ```
 
 NOTE: Be aware `Hash#to_n` produces a duplicate copy of the hash.
@@ -364,32 +523,32 @@ NOTE: Be aware `Hash#to_n` produces a duplicate copy of the hash.
 
 ### Method Missing
 
-Opal supports `method_missing`. This is a key feature of ruby, and opal wouldn't be much use without it! This page details the implementation of `method_missing` for Opal.
+Opal supports `method_missing`. This is a key feature of Ruby, and Opal wouldn't be much use without it! This page details the implementation of `method_missing` for Opal.
 
 #### Method dispatches
 
-Firstly, a ruby call `foo.bar 1, 2, 3` is compiled into the following javascript:
+Firstly, a Ruby call `foo.bar 1, 2, 3` is compiled into the following JavaScript:
 
 ```javascript
 foo.$bar(1, 2, 3)
 ```
 
-This should be pretty easy to read. The `bar` method has a `$` prefix just to distinguish it from underlying javascript properties, as well as ruby ivars. Methods are compiled like this to make the generated code really readable.
+This should be pretty easy to read. The `bar` method has a `$` prefix just to distinguish it from underlying JavaScript properties, as well as Ruby ivars. Methods are compiled like this to make the generated code really readable.
 
 #### Handling `method_missing`
 
-Javascript does not have an equivalent of `method_missing`, so how do we handle it? If a function is missing in javascript, then a language level exception will be raised.
+JavaScript does not have an equivalent of `method_missing`, so how do we handle it? If a function is missing in JavaScript, then a language level exception will be raised.
 
-To get around this, we make use of our compiler. During parsing, we collect a list of all method calls made inside a ruby file, and this gives us a list of all possible method calls. We then add stub methods to the root object prototype (an opal object, not the global javascript Object) which will proxy our method missing calls for us.
+To get around this, we make use of our compiler. During parsing, we collect a list of all method calls made inside a Ruby file, and this gives us a list of all possible method calls. We then add stub methods to the root object prototype (an Opal object, not the global JavaScript Object) which will proxy our method missing calls for us.
 
-For example, assume the following ruby script:
+For example, assume the following Ruby script:
 
 ```ruby
 first 1, 2, 3
 second "wow".to_sym
 ```
 
-After parsing, we know we only ever call 3 methods: `[:first, :second, :to_sym]`. So, imagine we could just add these 3 methods to `BasicObject` in ruby, we would get something like this:
+After parsing, we know we only ever call 3 methods: `[:first, :second, :to_sym]`. So, imagine we could just add these 3 methods to `BasicObject` in Ruby, we would get something like this:
 
 ```ruby
 class BasicObject
@@ -407,19 +566,18 @@ class BasicObject
 end
 ```
 
-It is obvious from here, that unless an object defines any given method, it will always resort in a dispatch to `method_missing` from one of our defined stub methods. This is how we get `method_missing` in opal.
+It is obvious from here, that unless an object defines any given method, it will always resort in a dispatch to `method_missing` from one of our defined stub methods. This is how we get `method_missing` in Opal.
 
 #### Optimising generated code
 
-To optimise the generated code slightly, we reduce the code output from the compiler into the following javascript:
+To optimise the generated code slightly, we reduce the code output from the compiler into the following JavaScript:
 
 ```javascript
 Opal.add_stubs(["first", "second", "to_sym"]);
 ```
 
-You will see this at the top of all your generated javascript files. This will add a stub method for all methods used in your file.
+You will see this at the top of all your generated JavaScript files. This will add a stub method for all methods used in your file.
 
 #### Alternative approaches
 
 The old approach was to inline `method_missing` calls by checking for a method on **every method dispatch**. This is still supported via a parser option, but not recommended.
-