opal 0.3.44 → 0.4.0

data/opal/source_map/vlq.rb

@@ -0,0 +1,122 @@
+class SourceMap
+  # Support for encoding/decoding the variable length quantity format
+  # described in the spec at:
+  #
+  # https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+  #
+  # This implementation is heavily based on https://github.com/mozilla/source-map
+  # Copyright 2009-2011, Mozilla Foundation and contributors, BSD
+  #
+  module VLQ
+
+    # A single base 64 digit can contain 6 bits of data. For the base 64 variable
+    # length quantities we use in the source map spec, the first bit is the sign,
+    # the next four bits are the actual value, and the 6th bit is the
+    # continuation bit. The continuation bit tells us whether there are more
+    # digits in this value following this digit.
+    #
+    #   Continuation
+    #   |    Sign
+    #   |    |
+    #   V    V
+    #   101011
+
+    VLQ_BASE_SHIFT = 5;
+
+    # binary: 100000
+    VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+    # binary: 011111
+    VLQ_BASE_MASK = VLQ_BASE - 1;
+
+    # binary: 100000
+    VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+    BASE64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('')
+    BASE64_VALUES = (0..64).inject({}){ |h, i| h.update BASE64_DIGITS[i] => i }
+
+    # Returns the base 64 VLQ encoded value.
+    def self.encode(int)
+
+      vlq = to_vlq_signed(int)
+      encoded = []
+
+      begin
+        digit = vlq & VLQ_BASE_MASK
+        vlq >>= VLQ_BASE_SHIFT
+        digit |= VLQ_CONTINUATION_BIT if vlq > 0
+        encoded << base64_encode(digit)
+      end while vlq > 0
+
+      encoded.join
+    end
+
+    # Decodes the next base 64 VLQ value from the given string and returns the
+    # value and the rest of the string.
+    def self.decode(str)
+
+      vlq = 0
+      shift = 0
+      continue = true
+      chars = str.split('')
+
+      while continue
+        char = chars.shift or raise "Expected more digits in base 64 VLQ value."
+        digit = base64_decode(char)
+        continue = false if (digit & VLQ_CONTINUATION_BIT) == 0
+        digit &= VLQ_BASE_MASK
+        vlq += digit << shift
+        shift += VLQ_BASE_SHIFT
+      end
+
+      [from_vlq_signed(vlq), chars.join('')]
+    end
+
+    # Decode an array of variable length quantities from the given string and
+    # return them.
+    def self.decode_array(str)
+      output = []
+      while str != ''
+        int, str = decode(str)
+        output << int
+      end
+      output
+    end
+
+    protected
+
+    def self.base64_encode(int)
+      BASE64_DIGITS[int] or raise ArgumentError, "#{int} is not a valid base64 digit"
+    end
+
+    def self.base64_decode(char)
+      BASE64_VALUES[char] or raise ArgumentError, "#{char} is not a valid base64 digit"
+    end
+
+    # Converts from a two's-complement integer to an integer where the
+    # sign bit is placed in the least significant bit. For example, as decimals:
+    #  1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+    #  2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+    def self.to_vlq_signed(int)
+      if int < 0
+        ((-int) << 1) + 1
+      else
+        int << 1
+      end
+    end
+
+    # Converts to a two's-complement value from a value where the sign bit is
+    # placed in the least significant bit. For example, as decimals:
+    #
+    #  2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+    #  4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+    def self.from_vlq_signed(vlq)
+      if vlq & 1 == 1
+        -(vlq >> 1)
+      else
+        vlq >> 1
+      end
+    end
+
+  end
+end

data/opal/strscan.rb

@@ -7,6 +7,7 @@ class StringScanner
     @pos     = 0
     @matched = nil
     @working = string
+    @match = []
   end
 
   def scan(regex)
@@ -15,12 +16,13 @@ class StringScanner
           result = regex.exec(#@working);
 
       if (result == null) {
-        return this.matched = nil;
+        return #{self}.matched = nil;
       }
       else if (typeof(result) === 'object') {
         #@pos      += result[0].length;
         #@working  = #@working.substring(result[0].length);
         #@matched  = result[0];
+        #@match    = result;
 
         return result[0];
       }
@@ -36,16 +38,32 @@ class StringScanner
     }
   end
 
+  def [](idx)
+    %x{
+      var match = #@match;
+
+      if (idx < 0) {
+        idx += match.length;
+      }
+
+      if (idx < 0 || idx >= match.length) {
+        return nil;
+      }
+
+      return match[idx];
+    }
+  end
+
   def check(regex)
     %x{
       var regexp = new RegExp('^' + regex.toString().substring(1, regex.toString().length - 1)),
           result = regexp.exec(#@working);
 
       if (result == null) {
-        return this.matched = nil;
+        return #{self}.matched = nil;
       }
 
-      return this.matched = result[0];
+      return #{self}.matched = result[0];
     }
   end
 
@@ -63,14 +81,14 @@ class StringScanner
       var result = re.exec(#@working);
 
       if (result == null) {
-        return this.matched = nil;
+        return #{self}.matched = nil;
       }
       else {
         var match_str = result[0];
         var match_len = match_str.length;
-        this.matched = match_str;
-        this.pos += match_len;
-        this.working = this.working.substring(match_len);
+        #{self}.matched = match_str;
+        #{self}.pos += match_len;
+        #{self}.working = #{self}.working.substring(match_len);
         return match_len;
       }
     }
@@ -79,13 +97,13 @@ class StringScanner
   def get_byte()
     %x{
       var result = nil;
-      if (this.pos < this.string.length) {
-        this.pos += 1;
-        result = this.matched = this.working.substring(0, 1);
-        this.working = this.working.substring(1);
+      if (#{self}.pos < #{self}.string.length) {
+        #{self}.pos += 1;
+        result = #{self}.matched = #{self}.working.substring(0, 1);
+        #{self}.working = #{self}.working.substring(1);
       }
       else {
-        this.matched = nil; 
+        #{self}.matched = nil;
       }
 
       return result;

data/spec/opal/class/_inherited_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 class Class
   def get_inherited_classes
-    `#{self}._inherited`
+    `#{self}._inherited || []`
   end
 end
 

data/spec/{rubyspec/core → opal}/class/bridge_class_spec.rb

@@ -9,7 +9,9 @@
   };
 }
 
-class BridgeClassSpec < `BridgeClassProto`
+Class.bridge_class :BridgeClassSpec, `BridgeClassProto`
+
+class BridgeClassSpec
   def get_foo
     `#{self}.foo`
   end
@@ -19,7 +21,7 @@ class BridgeClassSpec < `BridgeClassProto`
   end
 end
 
-describe "Bridging native prototypes to a class" do
+describe "Class#bridge_class" do
   it "should have a superclass of Object" do
     BridgeClassSpec.superclass.should == Object
   end
@@ -34,4 +36,4 @@ describe "Bridging native prototypes to a class" do
     obj.get_foo.should == 200
     obj.say_it.should == "hello world"
   end
-end
+end

data/spec/{rubyspec/core → opal}/class/last_value_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Class definition returning its last value' do
   it 'with a number' do

data/spec/opal/kernel/freeze_spec.rb

@@ -0,0 +1,15 @@
+# No real support, just mocking
+
+describe "Kernel#freeze" do
+  it 'responds to #freeze and #frozen?' do
+    o = mock('o')
+    o.frozen?.should be_false
+    o.freeze
+    o.frozen?.should be_true
+  end
+
+  it "returns self" do
+    o = Object.new
+    o.freeze.should equal(o)
+  end
+end

data/spec/{rubyspec/core → opal}/module/module_function_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe "Module#module_function with specific method names" do
   it "creates duplicates of the given instance methods on the Module object" do

data/spec/opal/native_spec.rb

@@ -20,6 +20,14 @@ require 'spec_helper'
 
     child_object: {
       grand_child: 100
+    },
+
+    func_returning_null: function() {
+      return null;
+    },
+
+    func_returning_undefined: function() {
+      return undefined;
     }
   };
 }
@@ -71,13 +79,18 @@ describe "Native objects" do
       @obj.check_args(1, 2, 3).should == [1, 2, 3]
     end
 
-    it "tries to convert each argument with to_native if defined" do
+    it "tries to convert each argument with to_n if defined" do
       obj, obj2, obj3 = Object.new, Object.new, Object.new
-      def obj.to_native; "foo"; end
-      def obj2.to_native; 42; end
+      def obj.to_n; "foo"; end
+      def obj2.to_n; 42; end
 
       @obj.check_args(obj, obj2, obj3).should == ["foo", 42, obj3]
     end
+
+    it "converts null/undefined values to nil from function" do
+      @obj.func_returning_null.should be_nil
+      @obj.func_returning_undefined.should be_nil
+    end
   end
 
   describe "#[]" do
@@ -110,6 +123,22 @@ describe "Native objects" do
     end
   end
 
+  describe "#[]=" do
+    it "sets values on the receiver object" do
+      object = `{}`
+
+      object["foo"] = 42
+      object["foo"].should == 42
+    end
+
+    it "sets null on the object when nil given as value" do
+      object = `{}`
+
+      object["foo"] = nil
+      `(object.foo === null)`.should be_true
+    end
+  end
+
   describe "==" do
     it "returns true if the wrapped objects are `===` to each other" do
       %x{
@@ -124,4 +153,57 @@ describe "Native objects" do
       (a == c).should be_false
     end
   end
+
+  describe "each" do
+    describe "with an array-like object" do
+      it "yields each element to block" do
+        object = `{ "0": 3.142, "1": 42, "length": 2 }`
+        result = []
+
+        object.each { |obj| result << obj }
+        result.should == [3.142, 42]
+      end
+
+      it "yields null and undefined values as nil" do
+        object = `{length: 3, 0: null, 1: undefined}`
+        result = []
+
+        object.each { |obj| result << obj }
+        result.should == [nil, nil, nil]
+      end
+    end
+
+    describe "with a normal js object" do
+      it "yields each key-value pair to the block" do
+        object = `{"foo": 3.142, "bar": 42}`
+        result = []
+
+        object.each { |k, v| result << [k, v] }
+        result.should == [["foo", 3.142], ["bar", 42]]
+      end
+
+      it "yields null and undefined values as nil" do
+        object = `{"foo": null, "bar": undefined}`
+        result = []
+
+        object.each { |k, v| result << v }
+        result.should == [nil, nil]
+      end
+    end
+  end
+
+  describe "#to_h" do
+    it "converts a simple js object into a ruby hash" do
+      object = `{"foo": true, "bar": 42}`
+      hash = object.to_h
+
+      hash.should be_kind_of(Hash)
+      hash.should == {"foo" => true, "bar" => 42}
+    end
+
+    it "converts all null and undefined values to nil" do
+      object = `{"a": null, "b": undefined}`
+      object.to_h.should == {"a" => nil, "b" => nil}
+    end
+  end
 end

data/spec/opal/numeric/equal_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Numeric#==" do
+  it "should be true when two js Number objects are compared" do
+    first = `new Number(42)`
+    second = `new Number(42)`
+    first.should == second
+  end
+end