opal 0.4.3 → 0.4.4

data/stdlib/buffer.rb

@@ -0,0 +1,40 @@
+require 'buffer/array'
+require 'buffer/view'
+
+class Buffer
+  include Native::Base
+
+  def self.supported?
+    not $$[:ArrayBuffer].nil?
+  end
+
+  def self.name_for(bits, type)
+    "#{case type
+      when :unsigned then 'Uint'
+      when :signed   then 'Int'
+      when :float    then 'Float'
+    end}#{bits}"
+  end
+
+  def initialize(size, bits = 8)
+    if native?(size)
+      super(size)
+    else
+      super(`new ArrayBuffer(size * (bits / 8))`)
+    end
+  end
+
+  def length
+    `#@native.byteLength`
+  end
+
+  alias size length
+
+  def to_a(bits = 8, type = :unsigned)
+    Array.new(self, bits, type)
+  end
+
+  def view(offset = nil, length = nil)
+    View.new(self, offset, length)
+  end
+end

data/stdlib/buffer/array.rb

@@ -0,0 +1,66 @@
+class Buffer < Native
+
+class Array < Native
+  def self.for(bits, type)
+    $$["#{Buffer.name_for bits, type}Array"]
+  end
+
+  include Enumerable
+
+  attr_reader :buffer, :type
+
+  def initialize(buffer, bits = nil, type = nil)
+    if Native == buffer
+      super(buffer)
+    else
+      %x{
+        var klass = #{Array.for(bits, type)};
+
+        #{super(`new klass(#{buffer.to_n})`)}
+      }
+    end
+
+    @buffer = buffer
+    @type   = type
+  end
+
+  def bits
+    `#@native.BYTES_PER_ELEMENT * 8`
+  end
+
+  def [](index, offset = nil)
+    offset ? `#@native.subarray(index, offset)` : `#@native[index]`
+  end
+
+  def []=(index, value)
+    `#@native[index] = value`
+  end
+
+  def bytesize
+    `#@native.byteLength`
+  end
+
+  def each
+    return enum_for :each unless block_given?
+
+    %x{
+      for (var i = 0, length = #@native.length; i < length; i++) {
+        #{yield `#@native[i]`}
+      }
+    }
+
+    self
+  end
+
+  def length
+    `#@native.length`
+  end
+
+  def merge!(other, offset = undefined)
+    `#@native.set(#{other.to_n}, offset)`
+  end
+
+  alias size length
+end
+
+end

data/stdlib/buffer/view.rb

@@ -0,0 +1,70 @@
+class Buffer
+
+class View
+  include Native::Base
+
+  def self.supported?
+    not $$[:DataView].nil?
+  end
+
+  attr_reader :buffer, :offset
+
+  def initialize(buffer, offset = nil, length = nil)
+    if native?(buffer)
+      super(buffer)
+    elsif offset && length
+      super(`new DataView(#{buffer.to_n}, #{offset.to_n}, #{length.to_n})`)
+    elsif offset
+      super(`new DataView(#{buffer.to_n}, #{offset.to_n})`)
+    else
+      super(`new DataView(#{buffer.to_n})`)
+    end
+
+    @buffer = buffer
+    @offset = offset
+  end
+
+  def length
+    `#@native.byteLength`
+  end
+
+  alias size length
+
+  def get(offset, bits = 8, type = :unsigned, little = false)
+    `#@native["get" + #{Buffer.name_for bits, type}](offset, little)`
+  end
+
+  alias [] get
+
+  def set(offset, value, bits = 8, type = :unsigned, little = false)
+    `#@native["set" + #{Buffer.name_for bits, type}](offset, value, little)`
+  end
+
+  alias []= set
+
+  def get_int8(offset, little = false); `#@native.getInt8(offset, little)`; end
+  def set_int8(offset, value, little = false); `#@native.setInt8(offset, value, little)`; end
+
+  def get_uint8(offset, little = false); `#@native.getUint8(offset, little)`; end
+  def set_uint8(offset, value, little = false); `#@native.setUint8(offset, value, little)`; end
+
+  def get_int16(offset, little = false); `#@native.getInt16(offset, little)`; end
+  def set_int16(offset, value, little = false); `#@native.setInt16(offset, value, little)`; end
+
+  def get_uint16(offset, little = false); `#@native.getUint16(offset, little)`; end
+  def set_uint16(offset, value, little = false); `#@native.setUint16(offset, value, little)`; end
+
+  def get_int32(offset, little = false); `#@native.getInt32(offset, little)`; end
+  def set_int32(offset, value, little = false); `#@native.setInt32(offset, value, little)`; end
+
+  def get_uint32(offset, little = false); `#@native.getUint32(offset, little)`; end
+  def set_uint32(offset, value, little = false); `#@native.setUint32(offset, value, little)`; end
+
+  def get_float32(offset, little = false); `#@native.getFloat32(offset, little)`; end
+  def set_float32(offset, value, little = false); `#@native.setFloat32(offset, value, little)`; end
+
+  def get_float64(offset, little = false); `#@native.getFloat64(offset, little)`; end
+  def set_float64(offset, value, little = false); `#@native.setFloat64(offset, value, little)`; end
+end
+
+end

data/stdlib/erb.rb

@@ -1,26 +1,17 @@
-module Template
-  @_cache = {}
-  def self.[](name)
-    @_cache[name]
-  end
-
-  def self.[]=(name, instance)
-    @_cache[name] = instance
-  end
-end
+require 'template'
 
 class ERB
-  def initialize(name, &body)
-    @body = body
-    @name = name
-    Template[name] = self
-  end
+  module Util
 
-  def inspect
-    "#<ERB: name=#{@name.inspect}>"
-  end
+    `var escapes = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'};`
+    `var escape_regexp = /[&<>"']/g;`
+
+    def html_escape(str)
+      `return ("" + str).replace(escape_regexp, function (m) { return escapes[m] });`
+    end
 
-  def render(ctx = self)
-    ctx.instance_exec([], &@body)
+    alias h html_escape
+    module_function :h
+    module_function :html_escape
   end
 end

data/stdlib/forwardable.rb

@@ -0,0 +1,71 @@
+module Forwardable
+  def instance_delegate(hash)
+    hash.each {|methods, accessor|
+      methods = [methods] unless methods.respond_to? :each
+
+      methods.each {|method|
+        def_instance_delegator(accessor, method)
+      }
+    }
+  end
+
+  def def_instance_delegators(accessor, *methods)
+    methods.each {|method|
+      next if %w[__send__ __id__].include?(method)
+
+      def_instance_delegator(accessor, method)
+    }
+  end
+
+  def def_instance_delegator(accessor, method, ali = method)
+    if accessor.to_s.start_with? ?@
+      define_method ali do |*args, &block|
+        instance_variable_get(accessor).__send__(method, *args, &block)
+      end
+    else
+      define_method ali do |*args, &block|
+        __send__(accessor).__send__(method, *args, &block)
+      end
+    end
+  end
+
+  alias delegate instance_delegate
+  alias def_delegators def_instance_delegators
+  alias def_delegator def_instance_delegator
+end
+
+module SingleForwardable
+  def single_delegate(hash)
+    hash.each {|methods, accessor|
+      methods = [methods] unless methods.respond_to? :each
+
+      methods.each {|method|
+        def_single_delegator(accessor, method)
+      }
+    }
+  end
+
+  def def_single_delegators(accessor, *methods)
+    methods.each {|method|
+      next if %w[__send__ __id__].include? method
+
+      def_single_delegator(accessor, method)
+    }
+  end
+
+  def def_single_delegator(accessor, method, ali = method)
+    if accessor.to_s.start_with? ?@
+      define_singleton_method ali do |*args, &block|
+        instance_variable_get(accessor).__send__(method, *args, &block)
+      end
+    else
+      define_singleton_method ali do |*args, &block|
+        __send__(accessor).__send__(method, *args, &block)
+      end
+    end
+  end
+
+  alias delegate single_delegate
+  alias def_delegators def_single_delegators
+  alias def_delegator def_single_delegator
+end

data/stdlib/json.rb

@@ -54,3 +54,81 @@ module JSON
     };
   }
 end
+
+module Kernel
+  def to_json
+    to_s.to_json
+  end
+
+  def as_json
+    nil
+  end
+end
+
+class Array
+  def to_json
+    %x{
+      var result = [];
+
+      for (var i = 0, length = #{self}.length; i < length; i++) {
+        result.push(#{ `#{self}[i]`.to_json });
+      }
+
+      return '[' + result.join(', ') + ']';
+    }
+  end
+
+end
+
+class Boolean
+  def as_json
+    self
+  end
+
+  def to_json
+    `(#{self} == true) ? 'true' : 'false'`
+  end
+end
+
+class Hash
+  def to_json
+    %x{
+      var inspect = [], keys = #{self}.keys, map = #{self}.map;
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        var key = keys[i];
+        inspect.push(#{`key`.to_json} + ': ' + #{`map[key]`.to_json});
+      }
+
+      return '{' + inspect.join(', ') + '}';
+    }
+  end
+end
+
+class NilClass
+  def as_json
+    self
+  end
+
+  def to_json
+    'null'
+  end
+end
+
+class Numeric
+  def as_json
+    self
+  end
+
+  def to_json
+    `#{self}.toString()`
+  end
+end
+
+class String
+  def as_json
+    self
+  end
+
+  alias to_json inspect
+end

data/stdlib/ostruct.rb

@@ -0,0 +1,69 @@
+class OpenStruct
+  def initialize(hash = nil)
+    @table = {}
+
+    hash.each_pair {|key, value|
+      @table[key.to_sym] = value
+    } if hash
+  end
+
+  def [](name)
+    @table[name.to_sym]
+  end
+
+  def []=(name, value)
+    @table[name.to_sym] = value
+  end
+
+  def method_missing(name, *args)
+    if name.end_with? '='
+      @table[name[0 .. -2].to_sym] = args[0]
+    else
+      @table[name.to_sym]
+    end
+  end
+
+  def each_pair
+    return enum_for :each_pair unless block_given?
+
+    @table.each_pair {|pair|
+      yield pair
+    }
+  end
+
+  def ==(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table == other.instance_variable_get(:@table)
+  end
+
+  def ===(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table === other.instance_variable_get(:@table)
+  end
+
+  def eql?(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table.eql? other.instance_variable_get(:@table)
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def to_n
+    @table.to_n
+  end
+
+  def hash
+    @table.hash
+  end
+
+  def inspect
+    "#<#{self.class}: #{each_pair.map {|name, value|
+      "#{name}=#{self[name].inspect}"
+    }.join(" ")}>"
+  end
+end

data/stdlib/rbconfig.rb

@@ -17,3 +17,4 @@ end
 # required for mspec it would appear
 RUBY_NAME = 'opal'
 RUBY_EXE = 'opal'
+RUBY_PATCHLEVEL = "327"