opal 1.7.4 → 1.8.0.alpha1

data/opal/corelib/helpers.rb

@@ -1,4 +1,5 @@
 # helpers: type_error, coerce_to
+# backtick_javascript: true
 
 module ::Opal
   def self.bridge(constructor, klass)

data/opal/corelib/io.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::IO
   self::SEEK_SET = 0
   self::SEEK_CUR = 1

data/opal/corelib/irb.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 # Debug is a helper module that allows us to conduct some debugging on
 # a live codebase. It goes with an assumption, that opal-parser or
 # opal-replutils will not be loaded, in which case we will do what we can

data/opal/corelib/kernel/format.rb

@@ -1,4 +1,5 @@
 # helpers: coerce_to
+# backtick_javascript: true
 
 module ::Kernel
   def format(format_string, *args)

data/opal/corelib/kernel.rb

@@ -1,5 +1,6 @@
 # helpers: truthy, coerce_to, respond_to, Opal, deny_frozen_access, freeze, freeze_props, jsid
 # use_strict: true
+# backtick_javascript: true
 
 module ::Kernel
   def =~(obj)
@@ -385,30 +386,55 @@ module ::Kernel
     }
   end
 
-  def Integer(value, base = undefined)
+  def Integer(value, base = undefined, exception: true)
     %x{
       var i, str, base_digits;
 
+      exception = $truthy(#{exception});
+
       if (!value.$$is_string) {
         if (base !== undefined) {
-          #{::Kernel.raise ::ArgumentError, 'base specified for non string value'}
+          if (exception) {
+            #{::Kernel.raise ::ArgumentError, 'base specified for non string value'}
+          } else {
+            return nil;
+          }
         }
         if (value === nil) {
-          #{::Kernel.raise ::TypeError, "can't convert nil into Integer"}
+          if (exception) {
+            #{::Kernel.raise ::TypeError, "can't convert nil into Integer"}
+          } else {
+            return nil;
+          }
         }
         if (value.$$is_number) {
           if (value === Infinity || value === -Infinity || isNaN(value)) {
-            #{::Kernel.raise ::FloatDomainError, value}
+            if (exception) {
+              #{::Kernel.raise ::FloatDomainError, value}
+            } else {
+              return nil;
+            }
           }
           return Math.floor(value);
         }
         if (#{value.respond_to?(:to_int)}) {
           i = #{value.to_int};
-          if (i !== nil) {
+          if (Opal.is_a(i, #{::Integer})) {
             return i;
           }
         }
-        return #{::Opal.coerce_to!(value, ::Integer, :to_i)};
+        if (#{value.respond_to?(:to_i)}) {
+          i = #{value.to_i};
+          if (Opal.is_a(i, #{::Integer})) {
+            return i;
+          }
+        }
+
+        if (exception) {
+          #{::Kernel.raise ::TypeError, "can't convert #{value.class} into Integer"}
+        } else {
+          return nil;
+        }
       }
 
       if (value === "0") {
@@ -420,7 +446,11 @@ module ::Kernel
       } else {
         base = $coerce_to(base, #{::Integer}, 'to_int');
         if (base === 1 || base < 0 || base > 36) {
-          #{::Kernel.raise ::ArgumentError, "invalid radix #{base}"}
+          if (exception) {
+            #{::Kernel.raise ::ArgumentError, "invalid radix #{base}"}
+          } else {
+            return nil;
+          }
         }
       }
 
@@ -456,7 +486,11 @@ module ::Kernel
           }
           // no-break
         }
-        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        if (exception) {
+          #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        } else {
+          return nil;
+        }
       });
 
       base = (base === 0 ? 10 : base);
@@ -464,25 +498,39 @@ module ::Kernel
       base_digits = '0-' + (base <= 10 ? base - 1 : '9a-' + String.fromCharCode(97 + (base - 11)));
 
       if (!(new RegExp('^\\s*[+-]?[' + base_digits + ']+\\s*$')).test(str)) {
-        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        if (exception) {
+          #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        } else {
+          return nil;
+        }
       }
 
       i = parseInt(str, base);
 
       if (isNaN(i)) {
-        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        if (exception) {
+          #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        } else {
+          return nil;
+        }
       }
 
       return i;
     }
   end
 
-  def Float(value)
+  def Float(value, exception: true)
     %x{
       var str;
 
+      exception = $truthy(#{exception});
+
       if (value === nil) {
-        #{::Kernel.raise ::TypeError, "can't convert nil into Float"}
+        if (exception) {
+          #{::Kernel.raise ::TypeError, "can't convert nil into Float"}
+        } else {
+          return nil;
+        }
       }
 
       if (value.$$is_string) {
@@ -496,13 +544,21 @@ module ::Kernel
         }
 
         if (!/^\s*[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\s*$/.test(str)) {
-          #{::Kernel.raise ::ArgumentError, "invalid value for Float(): \"#{value}\""}
+          if (exception) {
+            #{::Kernel.raise ::ArgumentError, "invalid value for Float(): \"#{value}\""}
+          } else {
+            return nil;
+          }
         }
 
         return parseFloat(str);
       }
 
-      return #{::Opal.coerce_to!(value, ::Float, :to_f)};
+      if (exception) {
+        return #{::Opal.coerce_to!(value, ::Float, :to_f)};
+      } else {
+        return $coerce_to(value, #{::Float}, 'to_f');
+      }
     }
   end
 

data/opal/corelib/main.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class << self
   def to_s
     'main'

data/opal/corelib/marshal/read_buffer.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 # https://github.com/ruby/ruby/blob/trunk/doc/marshal.rdoc
 # https://github.com/ruby/ruby/blob/trunk/marshal.c
 

data/opal/corelib/marshal/write_buffer.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::NilClass
   def __marshal__(buffer)
     buffer.append('0')

data/opal/corelib/math/polyfills.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 # Polyfills for browsers in the age of IE11
 
 unless defined?(`Math.acosh`)

data/opal/corelib/math.rb

@@ -1,4 +1,5 @@
 # helpers: type_error
+# backtick_javascript: true
 
 module ::Math
   self::E  = `Math.E`

data/opal/corelib/method.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Method
   attr_reader :owner, :receiver, :name
 

data/opal/corelib/module.rb

@@ -1,4 +1,5 @@
 # helpers: truthy, coerce_to, const_set, Object, return_ivar, assign_ivar, ivar, deny_frozen_access, freeze, prop, jsid
+# backtick_javascript: true
 
 class ::Module
   def self.allocate

data/opal/corelib/nil.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::NilClass
   `self.$$prototype.$$meta = #{self}`
 
@@ -54,7 +56,7 @@ class ::NilClass
   end
 
   def to_h
-    `Opal.hash()`
+    `new Map()`
   end
 
   def to_i

data/opal/corelib/number.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/numeric'
 
 class ::Number < ::Numeric

data/opal/corelib/numeric.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/comparable'
 
 class ::Numeric

data/opal/corelib/object_space.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # helpers: respond_to, truthy
 
 module ::ObjectSpace

data/opal/corelib/pack_unpack/format_string_parser.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 module ::PackUnpack
   %x{
     var directives = [

data/opal/corelib/proc.rb

@@ -1,4 +1,5 @@
 # helpers: slice
+# backtick_javascript: true
 
 class ::Proc < `Function`
   `Opal.prop(self.$$prototype, '$$is_proc', true)`
@@ -12,44 +13,45 @@ class ::Proc < `Function`
     block
   end
 
-  def call(*args, &block)
-    %x{
-      if (block !== nil) {
-        self.$$p = block;
-      }
-
-      var result, $brk = self.$$brk, $ret = self.$$ret;
-
-      if ($brk || ($ret && self.$$is_lambda)) {
+  %x{
+    function $call_lambda(self, args) {
+      if (self.$$ret) {
         try {
-          if (self.$$is_lambda) {
-            result = self.apply(null, args);
-          }
-          else {
-            result = Opal.yieldX(self, args);
-          }
+          return self.apply(null, args);
         } catch (err) {
-          if (err === $brk) {
-            return err.$v;
-          }
-          else if (self.$$is_lambda && err === $ret) {
+          if (err === self.$$ret) {
             return err.$v;
-          }
-          else {
+          } else {
             throw err;
           }
         }
+      } else {
+        return self.apply(null, args);
       }
-      else {
-        if (self.$$is_lambda) {
-          result = self.apply(null, args);
-        }
-        else {
-          result = Opal.yieldX(self, args);
+    }
+
+    function $call_proc(self, args) {
+      if (self.$$brk) {
+        try {
+          return Opal.yieldX(self, args);
+        } catch (err) {
+          if (err === self.$$brk) {
+            return err.$v;
+          } else {
+            throw err;
+          }
         }
+      } else {
+        return Opal.yieldX(self, args);
       }
+    }
+  }
 
-      return result;
+  def call(*args, &block)
+    %x{
+      if (block !== nil) self.$$p = block;
+      if (self.$$is_lambda) return $call_lambda(self, args);
+      return $call_proc(self, args);
     }
   end
 

data/opal/corelib/process.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 module ::Process
   @__clocks__ = []
   def self.__register_clock__(name, func)

data/opal/corelib/random/formatter.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Random
   module self::Formatter
     def hex(count = nil)

data/opal/corelib/random/math_random.js.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Random
   MATH_RANDOM_GENERATOR = `{
     new_seed: function() { return 0; },

data/opal/corelib/random/mersenne_twister.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 # This is based on an adaptation of Makoto Matsumoto and Takuji Nishimura's code
 # done by Sean McCullough <banksean@gmail.com> and Dave Heitzman
 # <daveheitzman@yahoo.com>, subsequently readapted from an updated version of

data/opal/corelib/random/seedrandom.js.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Random
   %x{
     var module = { exports: {} };

data/opal/corelib/random.rb

@@ -1,4 +1,5 @@
 # helpers: truthy
+# backtick_javascript: true
 
 require 'corelib/random/formatter'
 

data/opal/corelib/range.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/enumerable'
 
 class ::Range
@@ -145,19 +147,39 @@ class ::Range
   end
 
   def size
-    infinity = ::Float::INFINITY
-
-    return 0 if (@begin == infinity && !@end.nil?) || (@end == -infinity && !@begin.nil?)
-    return infinity if `is_infinite(self)`
-    return nil unless ::Numeric === @begin && ::Numeric === @end
-
-    range_begin = @begin
-    range_end   = @end
-    range_end  -= 1 if @excl
-
-    return 0 if range_end < range_begin
+    %x{
+      var b = this.begin, e = this.end;
+
+      // If begin is Numeric
+      if (#{::Numeric === `b`}) {
+        // If end is Numeric
+        if (#{::Numeric === `e`}) {
+          // Calculating size based on whether range is exclusive or inclusive
+          var size = #{`e` - `b`};
+          if (size < 0) {
+            return 0;
+          }
+          if (!this.excl) {
+            size += 1;
+          }
+          return (#{::Float === `b`} || #{::Float === `e`}) ? Math.floor(size) : size;
+        }
+        // If end is nil
+        else if (e === nil) {
+          return Infinity;
+        }
+      }
+      // If begin is nil
+      else if (b === nil) {
+        // If end is Numeric
+        if (#{::Numeric === `e`}) {
+          return Infinity;
+        }
+      }
 
-    `Math.abs(range_end - range_begin) + 1`.to_i
+      // If neither begin nor end is Numeric
+      return nil;
+    }
   end
 
   def step(n = undefined)

data/opal/corelib/rational.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/numeric'
 require 'corelib/rational/base'
 

data/opal/corelib/regexp.rb

@@ -1,4 +1,5 @@
 # helpers: coerce_to, prop, freeze
+# backtick_javascript: true
 
 class ::RegexpError < ::StandardError; end