opal-wedge 0.9.0.dev

data/stdlib/dir.rb

@@ -0,0 +1 @@
+warn "Dir is already part of corelib now, you don't need to require it anymore."

data/stdlib/encoding.rb

@@ -0,0 +1,170 @@
+require 'corelib/string'
+
+class Encoding
+  def self.register(name, options = {}, &block)
+    names    = [name] + (options[:aliases] || [])
+    encoding = Class.new(self, &block).
+      new(name, names, options[:ascii] || false, options[:dummy] || false)
+
+    names.each {|name|
+      const_set name.sub('-', '_'), encoding
+    }
+  end
+
+  def self.find(name)
+    upcase_name = name.upcase
+    return upcase_name if self === upcase_name
+
+    constants.each {|const|
+      encoding = const_get(const)
+
+      if encoding.name == upcase_name || encoding.names.include?(upcase_name)
+        return encoding
+      end
+    }
+
+    raise ArgumentError, "unknown encoding name - #{name}"
+  end
+
+  class << self
+    attr_accessor :default_external
+  end
+
+  attr_reader :name, :names
+
+  def initialize(name, names, ascii, dummy)
+    @name  = name
+    @names = names
+    @ascii = ascii
+    @dummy = dummy
+  end
+
+  def ascii_compatible?
+    @ascii
+  end
+
+  def dummy?
+    @dummy
+  end
+
+  def to_s
+    @name
+  end
+
+  def inspect
+    "#<Encoding:#{@name}#{" (dummy)" if @dummy}>"
+  end
+
+  # methods to implement per encoding
+  def each_byte(*)
+    raise NotImplementedError
+  end
+
+  def getbyte(*)
+    raise NotImplementedError
+  end
+
+  def bytesize(*)
+    raise NotImplementedError
+  end
+
+  class EncodingError < StandardError; end
+  class CompatibilityError < EncodingError; end
+end
+
+Encoding.register "UTF-8", aliases: ["CP65001"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        if (code <= 0x7f) {
+          #{yield `code`};
+        }
+        else {
+          var encoded = encodeURIComponent(string.charAt(i)).substr(1).split('%');
+
+          for (var j = 0, encoded_length = encoded.length; j < encoded_length; j++) {
+            #{yield `parseInt(encoded[j], 16)`};
+          }
+        }
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "UTF-16LE" do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        #{yield `code & 0xff`};
+        #{yield `code >> 8`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "ASCII-8BIT", aliases: ["BINARY"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        #{yield `string.charCodeAt(i) & 0xff`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+class String
+  `def.encoding = #{Encoding::UTF_16LE}`
+
+  def bytes
+    each_byte.to_a
+  end
+
+  def bytesize
+    @encoding.bytesize(self)
+  end
+
+  def each_byte(&block)
+    return enum_for :each_byte unless block_given?
+
+    @encoding.each_byte(self, &block)
+
+    self
+  end
+
+  def encoding
+    @encoding
+  end
+
+  def force_encoding(encoding)
+    encoding = Encoding.find(encoding)
+
+    return self if encoding == @encoding
+
+    %x{
+      var result = new String(self);
+      result.encoding = encoding;
+
+      return result;
+    }
+  end
+
+  def getbyte(idx)
+    @encoding.getbyte(self, idx)
+  end
+end

data/stdlib/enumerator.rb

@@ -0,0 +1 @@
+# stub

data/stdlib/erb.rb

@@ -0,0 +1,16 @@
+require 'template'
+
+class ERB
+  module Util
+    `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
+
+    alias h html_escape
+    module_function :h
+    module_function :html_escape
+  end
+end

data/stdlib/file.rb

@@ -0,0 +1 @@
+warn "File is already part of corelib now, you don't need to require it anymore."

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/js.rb

@@ -0,0 +1,56 @@
+# The JS module provides syntax sugar for calling native javascript
+# operators (e.g. typeof, instanceof, new, delete) and global functions
+# (e.g. parseFloat, parseInt).
+module JS
+  # Use delete to remove a property from an object.
+  def delete(object, property)
+    `delete #{object}[#{property}]`
+  end
+
+  # The global object
+  def global
+    `Opal.global`
+  end
+
+  # Use in to check for a property in an object.
+  def in(property, object)
+    `#{property} in #{object}`
+  end
+
+  # Use instanceof to return whether value is an instance of the function.
+  def instanceof(value, func)
+    `#{value} instanceof #{func}`
+  end
+
+  # Use new to create a new instance of the prototype of the function.
+  def new(func, *args, &block)
+    args << block if block
+    f = `function(){return func.apply(this, args)}`
+    f.JS[:prototype] = func.JS[:prototype]
+    `new f()`
+  end
+
+  # Use typeof to return the underlying javascript type of value.
+  # Note that for undefined values, this will not work exactly like
+  # the javascript typeof operator, as the argument is evaluated before
+  # the function call.
+  def typeof(value)
+    `typeof #{value}`
+  end
+
+  # Use void to return undefined.
+  def void(expr)
+    # Could use `undefined` here, but this is closer to the intent of the method
+    `void #{expr}`
+  end
+
+  # Call the global javascript function with the given arguments.
+  def call(func, *args, &block)
+    g = global
+    args << block if block
+    g.JS[func].JS.apply(g, args)
+  end
+  alias method_missing call
+
+  extend self
+end

data/stdlib/json.rb

@@ -0,0 +1,190 @@
+module JSON
+  %x{
+    var $parse  = JSON.parse,
+        $hasOwn = Opal.hasOwnProperty;
+
+    function to_opal(value, options) {
+      switch (typeof value) {
+        case 'string':
+          return value;
+
+        case 'number':
+          return value;
+
+        case 'boolean':
+          return !!value;
+
+        case 'null':
+          return nil;
+
+        case 'object':
+          if (!value) return nil;
+
+          if (value.$$is_array) {
+            var arr = #{`options.array_class`.new};
+
+            for (var i = 0, ii = value.length; i < ii; i++) {
+              #{`arr`.push(`to_opal(value[i], options)`)};
+            }
+
+            return arr;
+          }
+          else {
+            var hash = #{`options.object_class`.new};
+
+            for (var k in value) {
+              if ($hasOwn.call(value, k)) {
+                #{`hash`[`k`] = `to_opal(value[k], options)`};
+              }
+            }
+
+            var klass;
+            if ((klass = #{`hash`[JSON.create_id]}) != nil) {
+              klass = Opal.get(klass);
+              return #{`klass`.json_create(`hash`)};
+            }
+            else {
+              return hash;
+            }
+          }
+      }
+    };
+  }
+
+  class << self
+    attr_accessor :create_id
+  end
+
+  self.create_id = :json_class
+
+  def self.[](value, options = {})
+    if String === value
+      parse(value, options)
+    else
+      generate(value, options)
+    end
+  end
+
+  def self.parse(source, options = {})
+    from_object(`$parse(source)`, options)
+  end
+
+  def self.parse!(source, options = {})
+    parse(source, options)
+  end
+
+  # Raw js object => opal object
+  def self.from_object(js_object, options = {})
+    options[:object_class] ||= Hash
+    options[:array_class]  ||= Array
+
+    `to_opal(js_object, options.smap)`
+  end
+
+  def self.generate(obj, options = {})
+    obj.to_json(options)
+  end
+
+  def self.dump(obj, io = nil, limit = nil)
+    string = generate(obj)
+
+    if io
+      io = io.to_io if io.responds_to? :to_io
+      io.write string
+
+      io
+    else
+      string
+    end
+  end
+end
+
+class Object
+  def to_json
+    to_s.to_json
+  end
+end
+
+# BUG: Enumerable must come before Array, otherwise it overrides #to_json
+#      this is due to how modules are implemented.
+module Enumerable
+  def to_json
+    to_a.to_json
+  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 to_json
+    `(self == true) ? 'true' : 'false'`
+  end
+end
+
+class Hash
+  def to_json
+    %x{
+      var result = [];
+
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        result.push(#{`key`.to_s.to_json} + ':' + #{`value`.to_json});
+      }
+
+      return '{' + result.join(', ') + '}';
+    }
+  end
+end
+
+class NilClass
+  def to_json
+    'null'
+  end
+end
+
+class Numeric
+  def to_json
+    `self.toString()`
+  end
+end
+
+class String
+  alias to_json inspect
+end
+
+class Time
+  def to_json
+    strftime("%FT%T%z").to_json
+  end
+end
+
+class Date
+  def to_json
+    to_s.to_json
+  end
+
+  def as_json
+    to_s
+  end
+end
+