opal-wedge 0.9.0.dev

data/opal/corelib/proc.rb

@@ -0,0 +1,105 @@
+class Proc
+  `def.$$is_proc = true`
+  `def.$$is_lambda = false`
+
+  def self.new(&block)
+    unless block
+      raise ArgumentError, "tried to create a Proc object without a block"
+    end
+
+    block
+  end
+
+  def call(*args, &block)
+    %x{
+      if (block !== nil) {
+        self.$$p = block;
+      }
+
+      var result;
+
+      if (self.$$is_lambda) {
+        result = self.apply(null, args);
+      }
+      else {
+        result = Opal.yieldX(self, args);
+      }
+
+      if (result === $breaker) {
+        return $breaker.$v;
+      }
+
+      return result;
+    }
+  end
+
+  alias [] call
+
+  def to_proc
+    self
+  end
+
+  def lambda?
+    # This method should tell the user if the proc tricks are unavailable,
+    # (see Proc#lambda? on ruby docs to find out more).
+    `!!self.$$is_lambda`
+  end
+
+  # FIXME: this should support the various splats and optional arguments
+  def arity
+    `if (self.$$is_curried) { return -1; }`
+    `self.length`
+  end
+
+  def source_location
+    `if (self.$$is_curried) { return nil; }`
+    nil
+  end
+
+  def binding
+    `if (self.$$is_curried) { #{raise ArgumentError, "Can't create Binding"} }`
+    nil
+  end
+
+  def parameters
+    `if (self.$$is_curried) { return #{[[:rest]]}; }`
+    nil
+  end
+
+  def curry(arity = undefined)
+    %x{
+      if (arity === undefined) {
+        arity = self.length;
+      }
+      else {
+        arity = #{Opal.coerce_to!(arity, Integer, :to_int)};
+        if (self.$$is_lambda && arity !== self.length) {
+          #{raise ArgumentError, "wrong number of arguments (#{`arity`} for #{`self.length`})"}
+        }
+      }
+
+      function curried () {
+        var args = $slice.call(arguments),
+            length = args.length;
+
+        if (length > arity && self.$$is_lambda) {
+          #{raise ArgumentError, "wrong number of arguments (#{`length`} for #{`arity`})"}
+        }
+
+        if (length >= arity) {
+          return self.$call.apply(self, args);
+        }
+
+        return function () {
+          return curried.apply(null,
+            args.concat($slice.call(arguments)));
+        }
+      };
+
+      curried.$$is_lambda = self.$$is_lambda;
+      curried.$$is_curried = true;
+      return curried;
+    }
+  end
+
+end

data/opal/corelib/process.rb

@@ -0,0 +1,27 @@
+class Process
+  CLOCK_REALTIME  = 0
+  CLOCK_MONOTONIC = 1
+
+  def self.pid
+    0
+  end
+
+  def self.times
+    t = Time.now.to_f
+    Benchmark::Tms.new(t, t, t, t, t)
+  end
+
+  def self.clock_gettime(clock_id, unit = nil)
+    Time.now.to_f
+  end
+end
+
+class Signal
+  def self.trap(*)
+  end
+end
+
+class GC
+  def self.start
+  end
+end

data/opal/corelib/range.rb

@@ -0,0 +1,116 @@
+require 'corelib/enumerable'
+
+class Range
+  include Enumerable
+
+  `def.$$is_range = true;`
+
+  attr_reader :begin, :end
+
+  def initialize(first, last, exclude = false)
+    raise ArgumentError unless first <=> last
+
+    @begin   = first
+    @end     = last
+    @exclude = exclude
+  end
+
+  def ==(other)
+    %x{
+      if (!other.$$is_range) {
+        return false;
+      }
+
+      return self.exclude === other.exclude &&
+             self.begin   ==  other.begin &&
+             self.end     ==  other.end;
+    }
+  end
+
+  def ===(value)
+    include? value
+  end
+
+  def cover?(value)
+    @begin <= value && (@exclude ? value < @end : value <= @end)
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+
+    current = @begin
+    last    = @end
+
+    while current < last
+      yield current
+
+      current = current.succ
+    end
+
+    yield current if !@exclude && current == last
+
+    self
+  end
+
+  def eql?(other)
+    return false unless Range === other
+
+    @exclude === other.exclude_end? &&
+    @begin.eql?(other.begin) &&
+    @end.eql?(other.end)
+  end
+
+  def exclude_end?
+    @exclude
+  end
+
+  alias :first :begin
+
+  alias :include? :cover?
+
+  alias :last :end
+
+  # FIXME: currently hardcoded to assume range holds numerics
+  def max
+    if block_given?
+      super
+    else
+      `#@exclude ? #@end - 1 : #@end`
+    end
+  end
+
+  alias :member? :cover?
+
+  def min
+    if block_given?
+      super
+    else
+      @begin
+    end
+  end
+
+  alias member? include?
+
+  def size
+    _begin = @begin
+    _end   = @end
+    _end  -= 1 if @exclude
+
+    return nil unless Numeric === _begin && Numeric === _end
+    return 0 if _end < _begin
+    infinity = Float::INFINITY
+    return infinity if infinity == _begin.abs || _end.abs == infinity
+
+    (`Math.abs(_end - _begin) + 1`).to_i
+  end
+
+  def step(n = 1)
+    raise NotImplementedError
+  end
+
+  def to_s
+    `#{@begin.inspect} + (#@exclude ? '...' : '..') + #{@end.inspect}`
+  end
+
+  alias inspect to_s
+end

data/opal/corelib/rational.rb

@@ -0,0 +1,3 @@
+class Rational < Numeric
+
+end

data/opal/corelib/regexp.rb

@@ -0,0 +1,203 @@
+class RegexpError < StandardError; end
+class Regexp
+  IGNORECASE = 1
+  MULTILINE = 4
+  
+  `def.$$is_regexp = true`  
+
+  class << self
+    def escape(string)
+      %x{
+        return string.replace(/([-[\]\/{}()*+?.^$\\| ])/g, '\\$1')
+                     .replace(/[\n]/g, '\\n')
+                     .replace(/[\r]/g, '\\r')
+                     .replace(/[\f]/g, '\\f')
+                     .replace(/[\t]/g, '\\t');
+      }
+    end
+
+    def last_match(n=nil)
+      if n.nil?
+        $~
+      else
+        $~[n]
+      end
+    end
+
+    alias quote escape
+
+    def union(*parts)
+      %x{
+        var is_first_part_array, quoted_validated, part, options, each_part_options;
+        if (parts.length == 0) {
+          return /(?!)/;
+        }
+        // cover the 2 arrays passed as arguments case
+        is_first_part_array = parts[0].$$is_array;
+        if (parts.length > 1 && is_first_part_array) {
+          #{raise TypeError, 'no implicit conversion of Array into String'}
+        }        
+        // deal with splat issues (related to https://github.com/opal/opal/issues/858)
+        if (is_first_part_array) {
+          parts = parts[0];
+        }
+        options = undefined;
+        quoted_validated = [];
+        for (var i=0; i < parts.length; i++) {
+          part = parts[i];
+          if (part.$$is_string) {
+            quoted_validated.push(#{escape(`part`)});
+          }
+          else if (part.$$is_regexp) { 
+            each_part_options = #{`part`.options};   
+            if (options != undefined && options != each_part_options) {
+              #{raise TypeError, 'All expressions must use the same options'}
+            }
+            options = each_part_options;
+            quoted_validated.push('('+part.source+')');
+          }
+          else {
+            quoted_validated.push(#{escape(`part`.to_str)});
+          }
+        }
+      }
+      # Take advantage of logic that can parse options from JS Regex
+      new(`quoted_validated`.join('|'), `options`) 
+    end
+
+    def new(regexp, options = undefined)      
+      %x{
+        if (regexp.$$is_regexp) {
+          return new RegExp(regexp);
+        }
+
+        regexp = #{Opal.coerce_to!(regexp, String, :to_str)};
+
+        if (regexp.charAt(regexp.length - 1) === '\\') {
+          #{raise RegexpError, "too short escape sequence: /#{regexp}/"}
+        }
+
+        if (options === undefined || #{!options}) {
+          return new RegExp(regexp);
+        }
+
+        if (options.$$is_number) {
+          var temp = '';
+          if (#{IGNORECASE} & options) { temp += 'i'; }
+          if (#{MULTILINE}  & options) { temp += 'm'; }
+          options = temp;
+        }
+        else {
+          options = 'i';
+        }
+
+        return new RegExp(regexp, options);
+      }
+    end
+  end
+
+  def ==(other)
+    `other.constructor == RegExp && self.toString() === other.toString()`
+  end
+
+  def ===(string)
+    `#{match(string)} !== nil`
+  end
+
+  def =~(string)
+    match(string) && $~.begin(0)
+  end
+
+  alias eql? ==
+
+  def inspect
+    `self.toString()`
+  end
+
+  def match(string, pos = undefined, &block)
+    %x{
+      if (pos === undefined) {
+        pos = 0;
+      } else {
+        pos = #{Opal.coerce_to(pos, Integer, :to_int)};
+      }
+
+      if (string === nil) {
+        return #{$~ = nil};
+      }
+
+      string = #{Opal.coerce_to(string, String, :to_str)};
+
+      if (pos < 0) {
+        pos += string.length;
+        if (pos < 0) {
+          return #{$~ = nil};
+        }
+      }
+
+      // global RegExp maintains state, so not using self/this
+      var md, re = new RegExp(self.source, 'gm' + (self.ignoreCase ? 'i' : ''));
+
+      while (true) {
+        md = re.exec(string);
+        if (md === null) {
+          return #{$~ = nil};
+        }
+        if (md.index >= pos) {
+          #{$~ = MatchData.new(`re`, `md`)}
+          return block === nil ? #{$~} : #{block.call($~)};
+        }
+        re.lastIndex = md.index + 1;
+      }
+    }
+  end
+
+  def ~
+    self =~ $_
+  end
+
+  def source
+    `self.source`
+  end
+  
+  def options
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags is still experimental
+    # we need the flags and source does not give us that
+    %x{
+      var as_string, text_flags, result, text_flag;
+      as_string = self.toString();
+      if (as_string == "/(?:)/") {
+        #{raise TypeError, 'uninitialized Regexp'}
+      }
+      text_flags = as_string.replace(self.source, '').match(/\w+/);
+      result = 0;
+      // may have no flags
+      if (text_flags == null) {
+        return result;
+      }
+      // first match contains all of our flags
+      text_flags = text_flags[0];
+      for (var i=0; i < text_flags.length; i++) {
+        text_flag = text_flags[i];
+        switch(text_flag) {
+          case 'i':
+            result |= #{IGNORECASE};
+            break;
+          case 'm':
+            result |= #{MULTILINE};
+            break;
+          default:
+            #{raise "RegExp flag #{`text_flag`} does not have a match in Ruby"}
+        }
+      }
+      
+      return result;
+    }  
+  end
+  
+  def casefold?
+    `self.ignoreCase`
+  end
+
+  alias to_s source
+end