opal 0.3.33 → 0.3.34

data/.travis.yml

@@ -2,4 +2,4 @@ language: ruby
 
 rvm:
   - 1.8.7
-  - 1.9.3
+  - 1.9.3

data/Gemfile

@@ -3,6 +3,11 @@ gemspec
 
 gem "rake"
 
+# for building opal.js
+group :building do
+  gem "sprockets"
+end
+
 # for rebuilding grammar.rb from grammar.y
 group :grammar do
   gem "racc"
@@ -11,4 +16,4 @@ end
 # running tests on command line
 group :testing do
   gem 'opal-spec'
-end
+end

data/README.md

@@ -27,23 +27,23 @@ web browser.
 
 ## Code Overview
 
-### core
-
-The `core` directory holds the opal runtime and corelib implemented in
-ruby and javascript. These are built using `rake opal`, as above.
-
 ### lib
 
 The `lib` directory holds the opal parser/compiler used to compile ruby
 into javascript. It is also built ready for the browser into `opal-parser.js`
 to allow compilation in any javascript environment.
 
+### lib/assets/javascripts
+
+This directory holds the opal runtime and corelib implemented in ruby and
+javascript. These are built using `rake opal`, as above.
+
 ### spec
 
 * **core** contains rubyspecs that apply to opal.
 * **language** applicable specs from rubyspec for testing language semantics
 * **opal** tests for extra methods/features in opal not found in standard ruby
-* **lib** specs for opal lib (parser, erb\_parser, grammar etc)
+* **lib** specs for opal lib (parser, lexer, grammar etc)
 
 ## License
 
@@ -65,4 +65,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.

data/Rakefile

@@ -1,14 +1,36 @@
 require 'bundler/setup'
-require 'opal/rake_task'
+require 'opal-spec'
 
-Opal::RakeTask.new do |t|
-  t.dependencies = %w(opal-spec)
-  t.files        = []   # we handle this by Opal.runtime instead
-  t.parser       = true # we want to also build opal-parser.js (used in specs)
+desc "Build opal.js into ./build"
+task :opal => [:dir] do
+  File.open('build/opal.js', 'w+') { |o| o.puts Opal.runtime }
 end
 
-# build runtime, dependencies and specs, then run the tests
-task :default => %w[opal opal:test]
+desc "Build opal-parser.js into ./build"
+task :parser => [:dir] do
+  File.open('build/opal-parser.js', 'w+') { |o| o.puts Opal.parser_code }
+end
+
+desc "Build specs ready to run"
+task :build_specs => [:dir] do
+  Opal.append_path File.join(File.dirname(__FILE__), 'spec')
+
+  File.open('build/specs.js', 'w+') do |out|
+    out.puts Opal.process('spec_helper')
+  end
+end
+
+task :default => [:build_specs, :parser, :test]
+
+desc "Run opal specs through phantomjs"
+task :test do
+  OpalSpec.runner
+end
+
+task :dir do
+  require 'fileutils'
+  FileUtils.mkdir_p 'build'
+end
 
 desc "opal.min.js and opal-parser.min.js"
 task :min do
@@ -52,27 +74,3 @@ def gzip(str)
     return i.read
   end
 end
-
-# For testing just specific sections of opal
-desc "Build each test case into build/"
-task :test_cases do
-  FileUtils.mkdir_p 'build/test_cases'
-
-  sources = Dir['spec/core/*', 'spec/language', 'spec/parser', 'spec/grammar']
-
-  sources.each do |c|
-    dest = "build/test_cases/#{File.basename c}"
-    FileUtils.mkdir_p dest
-    File.open("#{dest}/specs.js", "w+") do |out|
-      out.puts Opal.build_files(c)
-    end
-
-    File.open("#{dest}/index.html", "w+") do |out|
-      out.puts File.read("spec/test_case.html")
-    end
-  end
-
-  File.open("build/test_cases/runner.js", "w+") do |out|
-    out.puts Opal.parse(File.read("spec/spec_helper.rb"))
-  end
-end

data/bin/opal

@@ -13,4 +13,4 @@ elsif File.exist? first
   puts Opal.parse File.read(first)
 else
   puts Opal.parse(first)
-end
+end

data/{core/parser/browser.js → lib/assets/javascripts/opal-parser.js.erb}

@@ -1,3 +1,11 @@
+//= require opal/racc
+//= require opal/strscan
+
+// We need (some) of the libs from our real ruby parser (not in sprockets load path)
+<% ['/grammar', '/lexer', '/parser', '/scope', ''].each do |f| %>
+  <%= Opal.parse File.read(File.join Opal.lib_dir, "opal#{f}.rb") %>
+<% end %>
+
 (function() {
   // quick exit if not insde browser
   if (typeof(window) === 'undefined' || typeof(document) === 'undefined') {
@@ -54,4 +62,4 @@
   else {
     window.attachEvent('onload', findRubyScripts);
   }
-})();
+})();

data/lib/assets/javascripts/opal.js.erb

@@ -0,0 +1,321 @@
+// Opal v<%= Opal::VERSION %>
+// http://opalrb.org
+// Copyright 2013, Adam Beynon
+// Released under the MIT Licence
+//= require_self
+//= require opal/core
+(function(undefined) {
+  // The Opal object that is exposed globally
+  var Opal = this.Opal = {};
+
+  // Opal version
+  Opal.version = <%= Opal::VERSION.inspect %>;
+
+  // Very root class
+  function BasicObject(){}
+
+  // Core Object class
+  function Object(){}
+
+  // Class' class
+  function Class(){}
+
+  // the class of nil
+  function NilClass(){}
+
+  // TopScope is used for inheriting constants from the top scope
+  var TopScope = function(){};
+
+  // Opal just acts as the top scope
+  TopScope.prototype = Opal;
+
+  // To inherit scopes
+  Opal.alloc  = TopScope;
+
+  // This is a useful reference to global object inside ruby files
+  Opal.global = this;
+
+  // Minify common function calls
+  var __hasOwn = Opal.hasOwnProperty;
+  var __slice  = Opal.slice = Array.prototype.slice;
+
+  // Generates unique id for every ruby object
+  var unique_id = 0;
+
+  // Return next unique id
+  Opal.uid = function() {
+    return unique_id++;
+  };
+
+  // Table holds all class variables
+  Opal.cvars = {};
+
+  // Globals table
+  Opal.gvars = {};
+
+  Opal.klass = function(base, superklass, id, constructor) {
+    var klass;
+    if (base._isObject) {
+      base = base._klass;
+    }
+
+    if (superklass === null) {
+      superklass = Object;
+    }
+
+    if (__hasOwn.call(base._scope, id)) {
+      klass = base._scope[id];
+    }
+    else {
+      if (!superklass._methods) {
+        var bridged = superklass;
+        superklass  = Object;
+        klass       = bridge_class(bridged);
+      }
+      else {
+        klass = boot_class(superklass, constructor);
+      }
+
+      klass._name = (base === Object ? id : base._name + '::' + id);
+
+      var const_alloc   = function() {};
+      var const_scope   = const_alloc.prototype = new base._scope.alloc();
+      klass._scope      = const_scope;
+      const_scope.alloc = const_alloc;
+
+      base[id] = base._scope[id] = klass;
+
+      if (superklass.$inherited) {
+        superklass.$inherited(klass);
+      }
+    }
+
+    return klass;
+  };
+
+  // Define new module (or return existing module)
+  Opal.module = function(base, id, constructor) {
+    var klass;
+    if (base._isObject) {
+      base = base._klass;
+    }
+
+    if (__hasOwn.call(base._scope, id)) {
+      klass = base._scope[id];
+    }
+    else {
+      klass = boot_class(Class, constructor);
+      klass._name = (base === Object ? id : base._name + '::' + id);
+
+      klass.$included_in = [];
+
+      var const_alloc   = function() {};
+      var const_scope   = const_alloc.prototype = new base._scope.alloc();
+      klass._scope      = const_scope;
+      const_scope.alloc = const_alloc;
+
+      base[id] = base._scope[id]    = klass;
+    }
+
+    return klass;
+  }
+
+  // Utility function to raise a "no block given" error
+  var no_block_given = function() {
+    throw new Error('no block given');
+  };
+
+  // Boot a base class (makes instances).
+  var boot_defclass = function(id, constructor, superklass) {
+    if (superklass) {
+      var ctor           = function() {};
+          ctor.prototype = superklass.prototype;
+
+      constructor.prototype = new ctor();
+    }
+
+    var prototype = constructor.prototype;
+
+    prototype.constructor = constructor;
+    prototype._isObject   = true;
+    prototype._klass      = constructor;
+
+    constructor._included_in  = [];
+    constructor._isClass      = true;
+    constructor._name         = id;
+    constructor._super        = superklass;
+    constructor._methods      = [];
+    constructor._smethods     = [];
+    constructor._isObject     = false;
+
+    constructor._donate = __donate;
+    constructor._sdonate = __sdonate;
+
+    Opal[id] = constructor;
+
+    return constructor;
+  };
+
+  // Create generic class with given superclass.
+  var boot_class = Opal.boot = function(superklass, constructor) {
+    var ctor = function() {};
+        ctor.prototype = superklass.prototype;
+
+    constructor.prototype = new ctor();
+    var prototype = constructor.prototype;
+
+    prototype._klass      = constructor;
+    prototype.constructor = constructor;
+
+    constructor._included_in  = [];
+    constructor._isClass      = true;
+    constructor._super        = superklass;
+    constructor._methods      = [];
+    constructor._isObject     = false;
+    constructor._klass        = Class;
+    constructor._donate       = __donate
+    constructor._sdonate      = __sdonate;
+
+    constructor['$==='] = module_eqq;
+    constructor.$to_s = module_to_s;
+
+    var smethods;
+
+    smethods = superklass._smethods.slice();
+
+    constructor._smethods = smethods;
+    for (var i = 0, length = smethods.length; i < length; i++) {
+      var m = smethods[i];
+      constructor[m] = superklass[m];
+    }
+
+    return constructor;
+  };
+
+  var bridge_class = function(constructor) {
+    constructor.prototype._klass = constructor;
+
+    constructor._included_in  = [];
+    constructor._isClass      = true;
+    constructor._super        = Object;
+    constructor._klass        = Class;
+    constructor._methods      = [];
+    constructor._smethods     = [];
+    constructor._isObject     = false;
+
+    constructor._donate = function(){};
+    constructor._sdonate = __sdonate;
+
+    constructor['$==='] = module_eqq;
+    constructor.$to_s = module_to_s;
+
+    var smethods = constructor._smethods = Class._methods.slice();
+    for (var i = 0, length = smethods.length; i < length; i++) {
+      var m = smethods[i];
+      constructor[m] = Object[m];
+    }
+
+    bridged_classes.push(constructor);
+
+    var table = Object.prototype, methods = Object._methods;
+
+    for (var i = 0, length = methods.length; i < length; i++) {
+      var m = methods[i];
+      constructor.prototype[m] = table[m];
+    }
+
+    constructor._smethods.push('$allocate');
+
+    return constructor;
+  };
+
+  Opal.puts = function(a) { console.log(a); };
+
+  // Initialization
+  // --------------
+
+  boot_defclass('BasicObject', BasicObject)
+  boot_defclass('Object', Object, BasicObject);
+  boot_defclass('Class', Class, Object);
+
+  Class.prototype = Function.prototype;
+
+  BasicObject._klass = Object._klass = Class._klass = Class;
+
+  // Implementation of Class#===
+  function module_eqq(object) {
+    if (object == null) {
+      return false;
+    }
+
+    var search = object._klass;
+
+    while (search) {
+      if (search === this) {
+        return true;
+      }
+
+      search = search._super;
+    }
+
+    return false;
+  }
+
+  // Implementation of Class#to_s
+  function module_to_s() {
+    return this._name;
+  }
+
+  // Donator for all 'normal' classes and modules
+  function __donate(defined, indirect) {
+    var methods = this._methods, included_in = this.$included_in;
+
+    // if (!indirect) {
+      this._methods = methods.concat(defined);
+    // }
+
+    if (included_in) {
+      for (var i = 0, length = included_in.length; i < length; i++) {
+        var includee = included_in[i];
+        var dest = includee.prototype;
+
+        for (var j = 0, jj = defined.length; j < jj; j++) {
+          var method = defined[j];
+          dest[method] = this.prototype[method];
+        }
+
+        if (includee.$included_in) {
+          includee._donate(defined, true);
+        }
+      }
+
+    }
+  }
+
+  // Donator for singleton (class) methods
+  function __sdonate(defined) {
+    this._smethods = this._smethods.concat(defined);
+  }
+
+  var bridged_classes = Object.$included_in = [];
+
+  BasicObject._scope = Object._scope = Opal;
+  Opal.Module = Opal.Class;
+  Opal.Kernel = Object;
+
+  var class_const_alloc = function(){};
+  var class_const_scope = new TopScope();
+  class_const_scope.alloc = class_const_alloc;
+  Class._scope = class_const_scope;
+
+  Object.prototype.toString = function() {
+    return this.$to_s();
+  };
+
+  Opal.top = new Object;
+
+  Opal.klass(Object, Object, 'NilClass', NilClass)
+  Opal.nil = new NilClass;
+
+  Opal.breaker  = new Error('unexpected break');
+}).call(this);