opal 0.3.6 → 0.3.9

data/corelib/object.rb

@@ -0,0 +1,37 @@
+# Core object in hierarchy. Most of the implementation of this core
+# object are implemented in {Kernel}.
+class Object
+
+  def initialize(*a)
+    # ...
+  end
+
+  def ==(other)
+    `return self === other;`
+  end
+
+  def equal?(other)
+    self == other
+  end
+
+  def __send__(method_id, *args, &block)
+    `var method = self['m$' + method_id];
+
+    if ($B.f == arguments.callee) {
+      $B.f = method;
+    }
+
+    return method.apply(self, args);`
+  end
+
+  def instance_eval(&block)
+    raise ArgumentError, "block not supplied" unless block_given?
+    `block.call(self);`
+    self
+  end
+
+  def method_missing(sym, *args)
+    raise NoMethodError, "undefined method `#{sym}` for #{self.inspect}"
+  end
+end
+

data/{lib/core → corelib}/proc.rb

@@ -41,15 +41,15 @@ class Proc
   end
 
   def call(*args)
-    `args.unshift(self.$proc[0]); return self.apply(null, args);`
+    `return self.apply(self.o$s,args);`
   end
 
   def to_s
-    `return "#<Proc:0x" + (self.$hash() * 400487).toString(16) + (self.$lambda ? ' (lambda)' : '') + ">";`
+    `return "#<Proc:0x" + (self.$h() * 400487).toString(16) + (self.$lambda ? ' (lambda)' : '') + ">";`
   end
 
   def lambda?
-    `return self.$fn.$lambda ? Qtrue : Qfalse;`
+    `return self.$lambda;`
   end
 end
 

data/corelib/range.rb

@@ -0,0 +1,27 @@
+class Range
+
+  def begin
+    `return self.beg;`
+  end
+
+  alias_method :first, :begin
+
+  def end
+    `return self.end;`
+  end
+
+  def to_s
+    `var str = #{`self.beg`.to_s};
+    var str2 = #{`self.end`.to_s};
+    var join = self.exc ? '...' : '..';
+    return str + join + str2;`
+  end
+
+  def inspect
+    `var str = #{`self.beg`.inspect};
+    var str2 = #{`self.end`.inspect};
+    var join = self.exc ? '...' : '..';
+    return str + join + str2;`
+  end
+end
+

data/{lib/core → corelib}/regexp.rb

@@ -36,7 +36,7 @@ class Regexp
   end
 
   def ==(other)
-    `return self.toString() === other.toString() ? Qtrue : Qfalse;`
+    `return self.toString() === other.toString();`
   end
 
   def eql?(other)

data/{lib/core → corelib}/string.rb

@@ -1,99 +1,13 @@
 # -*- encoding: utf-8 -*-
 
-# String objects holds a sequence of bytes, typically representing
-# characters. Strings may be constructed by using methods like
-# {String.new} or literals, like the following:
-#
-#     String.new("foo")     # => "foo"
-#     "bar"                 # => "bar"
-#
-# Strings in Opal are immutable; which means that their contents cannot
-# be changed. This means that a lot of methods like `strip!` are not
-# present, and will yield a `NoMethodError`. Thier immutable
-# counterparts are still available, which typically just return a new
-# string.
-#
-# Implementation details
-# ----------------------
-#
-# Ruby strings are toll-free bridged to native javascript strings,
-# meaning that anywhere that a ruby string is required, a normal
-# javascript string may be passed. This dramatically improves the
-# performance of Opal due to a lower overhead in allocating strings as
-# well as the ability to used functions of the String prototype to
-# perform many of the core ruby methods.
-#
-# It is due to this limitation that strings are immutable. Javascript
-# strings are immutable too, which limits what can be done with them in
-# regards to Ruby methods.
-#
-# Ruby compatibility
-# ------------------
-#
-# As discussed, {String} instances are immutable so they do not
-# implement any of the self mutable methods found in the ruby core
-# library. Most of these methods have their relative immutable
-# implementations, or alternative methods to take their place.
-#
-# Custom subclasses of {String} can be used, and are constructed in the
-# {.new} method. To due opals internals, a regular string is constructed
-# using `new String(string_content)`, and its class and method table
-# simply pointed at the custom subclass. As these custom subclasses are
-# simply javascript strings as well, they are also limited to being
-# immutable. This is because they share the same internal structre as
-# regular {String} instances.
-#
-# String instances will never actually have their {.allocate} methods
-# called. Due to the way opal bridges strings to javascript, when a new
-# string is constructed, its value must be know. This is not possible in
-# `allocate` as the value is not passed. Therefore the creation of
-# strings (including subclasses) is done in {.new} where the string
-# value is passed as an argument.
-#
-# Finally, strings do not currently include the `Comparable` module, as
-# it is not yet implemented. The main methods used by {String} from this
-# module are implemented directly as String methods. When `Comparable`
-# is implemented, these methods will be moved back to the module.
 class String
 
   def self.new(str = "")
-    `var result = new String(str);
-    result.$klass = self;
-    result.$m = self.$m_tbl;
-    return result;`
+    str
   end
 
-  # Copy - returns a new string containing `count` copies of the receiver.
-  #
-  # @example
-  #
-  #     'Ho! ' * 3
-  #     # => 'Ho! Ho! Ho! '
-  #
-  # @param [Numeric] count number of copies
-  # @return [String]
-  def *(count)
-    `var result = [];
-
-    for (var i = 0; i < count; i++) {
-      result.push(self);
-    }
-
-    return result.join('');`
-  end
-
-  # Concatenation - Returns a new string containing `other` concatenated onto
-  # `self`.
-  #
-  # @example
-  #
-  #     'Hello from ' + self.to_s
-  #     # => 'Hello from main'
-  #
-  # @param [String] other string to concatenate
-  # @return [String]
-  def +(other)
-    `return self + other;`
+  def ==(other)
+    `return self.valueOf() === other.valueOf();`
   end
 
   # Returns a copy of `self` with the first character converted to uppercase and
@@ -226,7 +140,7 @@ class String
     `var r = pattern.toString();
     r = r.substr(1, r.lastIndexOf('/') - 1);
     r = new RegExp(r, 'g');
-    return self.replace(pattern, function(str) {
+    return self.replace(r, function(str) {
       return replace;
     });`
   end
@@ -252,21 +166,12 @@ class String
   # @param [String] other string to compare
   # @return [-1, 0, 1, nil] result
   def <=>(other)
-    `if (typeof other != 'string') return nil;
+    `if (!(other.o$f & T_STRING)) return nil;
     else if (self > other) return 1;
     else if (self < other) return -1;
     return 0;`
   end
 
-  # Equality - if other is not a string, returns false. Otherwise, returns true
-  # if self <=> other returns zero.
-  #
-  # @param [String] other string to compare
-  # @return [true, false]
-  def ==(other)
-    `return self.valueOf() === other.valueOf() ? Qtrue : Qfalse;`
-  end
-
   # Match - if obj is a Regexp, then uses it to match against self, returning
   # nil if there is no match, or the index of the match location otherwise. If
   # obj is not a regexp, then it calls =~ on it, using the receiver as an
@@ -277,8 +182,8 @@ class String
   # @param [Regexp, Objec] obj
   # @return [Numeric, nil]
   def =~(obj)
-    `if (obj.$flags & $rb.T_STRING) {
-      $rb.raise(VM.TypeError, "type mismatch: String given");
+    `if (obj.o$f & T_STRING) {
+      raise(eTypeError, "type mismatch: String given");
     }`
 
     obj =~ self
@@ -313,7 +218,7 @@ class String
   #
   # @return [true, false]
   def empty?
-    `return self.length == 0 ? Qtrue : Qfalse;`
+    `return self.length == 0;`
   end
 
   # Returns true is self ends with the given suffix.
@@ -327,10 +232,10 @@ class String
   # @return [true, false]
   def end_with?(suffix)
     `if (self.lastIndexOf(suffix) == self.length - suffix.length) {
-      return Qtrue;
+      return true;
     }
 
-    return Qfalse;`
+    return false;`
   end
 
   # Two strings are equal if they have the same length and content.
@@ -338,7 +243,11 @@ class String
   # @param [String] other string to compare
   # @return [true, false]
   def eql?(other)
-    `return self == other ? Qtrue : Qfalse;`
+    `return self == other;`
+  end
+
+  def +(other)
+    `return self + other;`
   end
 
   # Returns true if self contains the given string `other`.
@@ -351,7 +260,7 @@ class String
   # @param [String] other string to check for
   # @return [true, false]
   def include?(other)
-    `return self.indexOf(other) == -1 ? Qfalse : Qtrue;`
+    `return self.indexOf(other) == -1 ? false : true;`
   end
 
   # Returns the index of the first occurance of the given `substr` or pattern in

data/lib/opal.rb

@@ -0,0 +1,7 @@
+require 'rbp'
+
+require 'opal/parser'
+require 'opal/builder'
+require 'opal/context'
+require 'opal/browserify'
+

data/lib/opal/browserify.rb

@@ -0,0 +1,34 @@
+module Opal
+
+  # Takes a package and builds it ready for the browser
+  class Browserify
+
+    def initialize(package)
+      @package = package
+      @builder = Builder.new
+    end
+
+    # Simple build - returns a string which can be written to a file
+    # FIXME: hardcoded lib directory to './lib'
+    def build
+      libs = @package.lib_files
+      libs.map! do |f|
+        path = File.join @package.root, './lib', f
+        src = @builder.compile_source path
+        "\"#{f}\": #{src}"
+      end
+
+      bundle = []
+      bundle << %[opal.package({\n]
+      bundle << %[  name: "#{@package.name}",\n]
+      bundle << %[  version: "#{@package.version}",\n]
+      bundle << %[  libs: {\n]
+      bundle << %[    #{libs.join ",\n    "}\n]
+      bundle << %[  }\n]
+      bundle << %[});\n]
+
+      bundle.join ''
+    end
+  end
+end
+

data/{opal_lib → lib}/opal/builder.rb

@@ -1,52 +1,97 @@
 require 'fileutils'
-require 'opal/build_methods'
 
 module Opal
-  # Builder is used for compiling simple ruby files into javascript files
-  # through the command line or a rake task. It is used for non bundle based
-  # building systems, and is meant for building small scale pages rather than
-  # applications.
+
+  # The Builder class is used for building single ruby sources, or
+  # building the core library ready for the browser/v8 context. It
+  # is not used directly for building packages.
   class Builder
-    include BuildMethods
 
     OPAL_PATH = File.expand_path(File.join('..', '..', '..'), __FILE__)
 
-    STDLIB_PATH = File.join OPAL_PATH, 'lib'
+    STDLIB_PATH = File.join OPAL_PATH, 'stdlib'
 
     RUNTIME_PATH = File.join OPAL_PATH, 'runtime'
 
-    def build_runtime
-      code = ''
+    CORE_PATH = File.join OPAL_PATH, 'corelib'
 
-      %w[pre runtime init class module fs loader debug post].each do |f|
-        code += File.read(File.join RUNTIME_PATH, f + '.js')
-      end
+    # Returns the result of the compiled file ready for opal to load.
+    #
+    # `relative_path` is used for the name the built file should have.
+    # This is used for building a singular rb or js file into the
+    # compiled output, and will avoid the user's dir setup being exposed
+    # in production code. It will be of the form
+    # `lib/some_lib/some_lib.rb`
+    #
+    # @param [String] full_path The full pathname to the file to build
+    # @paeam [String] relative_path The pathname to be used in the build
+    # file.
+    #
+    # @return [String]
+    def wrap_source(full_path, relative_path = nil)
+      relative_path ||= full_path
+      ext = File.extname full_path
+      # relative_path = relative_path.sub(/\.rb/, '.js') if ext == '.rb'
+      content = compile_source full_path
+
+      "opal.lib('#{relative_path}.rb', #{content});\n"
+    end
 
-      code
+    # Simply compile the given source code at the given path. This is
+    # for compiling ruby or javascript sources only. This can be used
+    # for any method that builds for the browser.
+    #
+    # @param [String] full_path location of the source to build
+    # @return [String] compiled source
+    def compile_source(full_path)
+      ext = File.extname full_path
+      src = File.read full_path
+
+      case ext
+      when '.js'
+        "function($rb, self, __FILE__) { #{src} }"
+
+      when '.rb'
+        src = Opal::Parser.new(src).parse!.generate_top
+        "function($rb, self, __FILE__) { #{src} }"
+
+      else
+        raise "Bad file type for wrapping. Must be ruby or javascript"
+      end
     end
 
     # Builds core opal runtime + core libs, and returns as a string.
     # This can then just be used directly by any compiled code. The
     # core lib is then auto loaded so it is ready for running.
     def build_core
-      code = build_runtime
-      code += build_stdlib('core.rb', 'core/*.rb')
-      code += "opal.require('core');"
+      code = ''
 
-      code
+      %w[pre runtime init class module fs loader].each do |f|
+        code += File.read(File.join RUNTIME_PATH, f + '.js')
+      end
+
+      order = File.read(File.join(CORE_PATH, 'load_order')).strip.split
+
+      core = order.map do |o|
+        File.read File.join(CORE_PATH, o + '.rb')
+      end
+
+      code += 'var core_lib = function($rb, self, __FILE__) { ' + Opal::Parser.new(core.join).parse!.generate_top + '};'
+
+      code + File.read(File.join RUNTIME_PATH, 'post.js')
     end
 
     # Builds the opal parser and dev.rb file, and returns as a string.
     def build_parser
       code = ''
 
-      %w[opal/ruby/nodes opal/ruby/parser opal/ruby/ruby_parser].each do |src|
-        full = File.join OPAL_PATH, 'opal_lib', src + '.rb'
+      %w[opal/nodes opal/lexer opal/parser].each do |src|
+        full = File.join OPAL_PATH, 'lib', src + '.rb'
         compiled = compile_source full
-        code += "opal.register('#{src}.rb', #{compiled});"
+        code += "opal.lib('#{src}.rb', #{compiled});"
       end
 
-      code += build_stdlib 'racc/parser.rb', 'strscan.rb', 'dev.rb'
+      code += build_stdlib 'racc/parser', 'strscan', 'dev'
       code += "opal.require('dev');"
 
       code
@@ -57,9 +102,10 @@ module Opal
     def build_stdlib(*files)
       code = []
       Dir.chdir(STDLIB_PATH) do
-        Dir.[](*files).each do |lib|
-          full_path = File.join STDLIB_PATH, lib
-          code << wrap_source(full_path, lib)
+        files.each do |file|
+          lib = Dir[file + '.rb']
+          full_path = File.join STDLIB_PATH, lib.first
+          code << wrap_source(full_path, file)
         end
       end