opal-js_wrap-three 0.1.0

data/lib-opal/js_wrap/three.rb

@@ -0,0 +1,4 @@
+require "js_wrap"
+require "js_wrap/three/three" # JavaScript
+
+Three = JSWrap::ClassView.wrap(`Three`)

data/lib-opal/js_wrap.rb

@@ -0,0 +1,720 @@
+# helpers: native, defineProperty
+
+`var inspect_stack = []`
+
+# JSWrap is basically a Native v2. It has the same aims and goals. It should
+# be interoperable with Native, ie. both modules can coexist.
+
+# TODO: DSL methods:
+#  - js_method
+#    - (
+#        how about something like: js_method :set_timeout => [:$block, :timeout]
+#        which would allow us also to call it using any of the following:
+#        `Window.set_timeout(timeout: 123) { p "Hello!" }`
+#        `Window.set_timeout(123) { p "Hello!" }`
+#        `Window.set_timeout(-> { p "Hello" }, 123)`
+#      )
+# TODO: support for restricted values
+# TODO: to_js
+
+module JSWrap
+  module WrapperClassMethods
+    # By default, we will transfer calls and properties like
+    # "my_method" into "myMethod". Since, unlike with Native, we
+    # inherit from Object, not BasicObject, some call names may
+    # conflict, but we can use names like "class_" instead of
+    # "class". This setting allows us to disable this behavior.
+    attr_accessor :js_raw_naming
+
+    # The default behavior when dispatching to a function is to
+    # call it and return a result.
+    attr_accessor :js_function_wrap
+
+    # The default behavior for things based on ObjectWrapper is to
+    # automatically wrap even the regular Arrays, so that we may
+    # correctly wrap all members.
+    #
+    # The default behavior for things based on Wrapper is to never
+    # wrap the regular Arrays, only Array-like things. It is the
+    # responsibility of the programmer to provide a good interface.
+    #
+    # This property allows you to change the default behavior.
+    attr_accessor :js_array_wrap
+
+    def js_attr_reader(*vars)
+      vars.each do |var|
+        define_method(var) { js_property(var) }
+      end
+      vars.length > 1 ? vars : vars.first
+    end
+
+    def js_attr_writer(*vars)
+      vars.each do |var|
+        define_method(:"#{var}=") { |val| js_property_set(var, val) }
+      end
+      vars.length > 1 ? vars : vars.first
+    end
+
+    def js_attr_accessor(*vars)
+      Array(js_attr_reader(*vars)) + Array(js_attr_writer(*vars))
+    end
+
+    def js_method(*vars)
+      vars.each do |var|
+        define_method(var) do |*args,&block|
+          args << block if block_given?
+          js_property(var, args: args)
+        end
+      end
+      vars.length > 1 ? vars : vars.first
+    end
+
+    def js_export_class(classname = name)
+      `Opal.global[name] = self`
+    end
+
+    alias js_export_module js_export_class
+
+    # Example:
+    #
+    # module Blobulizer
+    #   include JSWrap::Wrapper
+    #   js_export_module
+    #
+    #   js_export def self.extended_blobulize(thing)
+    #     Blobulizer::Processor.new(thing).extended_blobulize
+    #   end
+    # end
+    #
+    # JS:
+    # Blobulizer.extendedBlobulize({hello: "world"})
+    def js_export(*args)
+      args = Array(args.first) if args.length == 1
+
+      args.each do |i|
+        `self[#{js_property_name_rb2js(i)}] = #{JSWrap.unwrap_proc(`method(i).to_proc`, self)}`
+      end
+    end
+
+    def wrap(object, parent = nil)
+      obj = allocate
+      obj.initialize_wrapped(object, parent)
+      obj
+    end
+
+    def js_class(js_constructor)
+      js_constructor = JSWrap.unwrap(js_constructor, self)
+      @native = js_constructor
+      JSWrap.register_wrapping(self, js_constructor)
+    end
+
+    # Also includes RawClassWrapper, but we don't have that yet.
+  end
+
+  module Wrapper
+    def self.included(klass)
+      klass.extend(WrapperClassMethods)
+      super
+    end
+
+    attr_accessor :native
+
+    def initialize_wrapped(object, parent = nil)
+      %x{
+        try {
+          $defineProperty(object, '$$js_wrap', self)
+        }
+        catch(e) {}
+      }
+      @native_parent = parent if parent
+      @native = object
+    end
+
+    def initialize(*args, &block)
+      raise NotImplementedError, 'See [doc:JSWrap::Wrapper#initialize]' unless `#{self.class}.native`
+
+      args << block if block_given?
+      args = JSWrap.unwrap_ary(args, self)
+      obj = `new (self.$$class.native.bind.apply(self.$$class.native, [null].concat(args)))`
+      initialize_wrapped(obj)
+    end
+
+    # @private
+    def js_property_name_rb2js(name, raw: nil)
+      raw = self.js_function_wrap if raw.nil?
+      if raw || name.start_with?(/[A-Z]/)
+        name
+      else
+        name.gsub(/_(.?)/) { Regexp.last_match(1).upcase }
+      end
+    end
+
+    # @private
+    def js_property_name_js2rb(name, raw: nil)
+      raw = self.js_function_wrap if raw.nil?
+      if raw || name.start_with?(/[A-Z]/)
+        name
+      else
+        name.gsub(/([A-Z])/) { '_' + Regexp.last_match(1).downcase }
+      end
+    end
+
+    def js_properties(not_just_own = true, raw: nil)
+      %x{
+        var out = [];
+        for (var name in self.native) {
+          if (!not_just_own || self.native.hasOwnProperty(name)) {
+            #{`out` << js_property_name_js2rb(`name`, raw: raw)}
+          }
+        }
+        return out;
+      }
+    end
+
+    def js_property?(name, raw: nil)
+      %x{
+        return #{js_property_name_rb2js(name, raw: raw)} in self.native
+      }
+    end
+
+    # Returns a wrapped property. If args are nil, functions are
+    # always returned verbatim.
+    def js_property(name, raw: nil, args: nil)
+      JSWrap(`self.native[#{
+               js_property_name_rb2js(name, raw: raw)
+             }]`,
+        self, args, name: name
+      )
+    end
+
+    def js_property_set(name, value, raw: nil)
+      `self.native[#{
+        js_property_name_rb2js(name, raw: raw)
+      }] = #{JSWrap.unwrap(value, self)}`
+    end
+
+    def js_raw_naming
+      @js_raw_naming.nil? ? self.class.js_raw_naming : @js_raw_naming
+    end
+
+    def js_function_wrap
+      @js_function_wrap.nil? ? self.class.js_function_wrap : @js_function_wrap
+    end
+
+    def js_array_wrap
+      @js_array_wrap.nil? ? self.class.js_array_wrap : @js_array_wrap
+    end
+
+    def to_js
+      @native
+    end
+
+    alias to_n to_js
+  end
+
+  module ObjectWrapper
+    include Enumerable
+    include Wrapper
+
+    alias [] js_property
+
+    def []=(name, kwargs = {}, value)
+      js_property_set(name, value, **kwargs)
+    end
+
+    alias keys js_properties
+    alias has? js_property
+    alias include? js_property
+
+    def values
+      to_h.values
+    end
+
+    def each(&block)
+      return enum_for(:each) { length } unless block_given?
+
+      %x{
+        for (var name in self.native) {
+          Opal.yieldX(block, [
+            #{js_property_name_js2rb `name`},
+            #{JSWrap(`self.native[name]`, self)}
+          ]);
+        }
+      }
+      self
+    end
+
+    def inspect
+      if `inspect_stack`.include?(__id__)
+        inside = '...'
+      else
+        inside = to_h.inspect
+        `inspect_stack` << __id__
+        pushed = true
+      end
+      klass = `Object.prototype.toString.apply(self.native)`
+      klass =~ /^\[object (.*?)\]$/
+      "#<#{self.class.name} #{Regexp.last_match(1) || klass} #{inside}>"
+    ensure
+      `inspect_stack.pop()` if pushed
+    end
+
+    def pretty_print(o)
+      klass = `Object.prototype.toString.apply(self.native)`
+      klass =~ /^\[object (.*?)\]$/
+      o.group(1, "#<#{self.class.name} #{Regexp.last_match(1) || klass}", '>') do
+        o.breakable
+        o.pp(to_h)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if method.end_with? '='
+        raise ArgumentError, 'JS attr assignment needs 1 argument' if args.length != 1
+        js_property_set(method[0..-2], args.first)
+      elsif js_property?(method)
+        args << block if block_given?
+        js_property(method, args: args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_all = true)
+      if method.end_with?('=') || js_property?(method)
+        true
+      else
+        super
+      end
+    end
+
+    def raw(raw = true)
+      self.dup.tap do |i|
+        i.instance_variable_set(:@js_raw_naming, true)
+      end
+    end
+  end
+
+  module ArrayWrapper
+    include Enumerable
+    include ObjectWrapper
+
+    def each(&block)
+      return enum_for(:each) { length } unless block_given?
+
+      %x{
+        for (var i = 0; i < self.native.length; i++) {
+          Opal.yield1(block, #{JSWrap(`self.native[i]`, self)});
+        }
+      }
+      self
+    end
+
+    def [](key)
+      if key.is_a? Number
+        JSWrap.wrap(`self.native[key]`, self)
+      else
+        super
+      end
+    end
+
+    def []=(key, kwargs = {}, value)
+      if key.is_a? Number
+        `self.native[key] = #{JSWrap.unwrap(value, self)}`
+      else
+        super
+      end
+    end
+
+    def <<(value)
+      `Array.prototype.push.apply(self.native, [#{JSWrap.unwrap(value, self)}])`
+      self
+    end
+
+    alias append <<
+
+    def length
+      `self.native.length`
+    end
+
+    def inspect
+      if `inspect_stack`.include?(__id__)
+        inside = '[...]'
+      else
+        `inspect_stack` << __id__
+        pushed = true
+        inside = to_a.inspect
+      end
+      klass = `Object.prototype.toString.apply(self.native)`
+      klass =~ /^\[object (.*?)\]$/
+      "#<#{self.class.name} #{Regexp.last_match(1) || klass} #{inside}>"
+    ensure
+      `inspect_stack.pop()` if pushed
+    end
+
+    def pretty_print(o)
+      klass = `Object.prototype.toString.apply(self.native)`
+      klass =~ /^\[object (.*?)\]$/
+      o.group(1, "#<#{self.class.name} #{Regexp.last_match(1) || klass}", '>') do
+        o.breakable
+        o.pp(to_a)
+      end
+    end
+  end
+
+  module FunctionWrapper
+    include ObjectWrapper
+
+    def call(*args, &block)
+      JSWrap.call(@native_parent, @native, *args, &block)
+    end
+
+    def to_proc
+      proc do |*args, &block|
+        call(*args, &block)
+      end
+    end
+
+    def inspect
+      if `typeof self.native.toString !== 'function'`
+        super
+      else
+        fundesc = `self.native.toString()`.split('{').first.strip.delete("\n")
+        "#<#{self.class.name} #{fundesc}>"
+      end
+    end
+
+    def pretty_print(o)
+      if `typeof self.native.toString !== 'function'`
+        super
+      else
+        o.text(inspect)
+      end
+    end
+  end
+
+  module RawClassWrapper
+    include Wrapper
+
+    def superclass
+      JSWrap(`#{@native}.prototype.__proto__`, self)
+    end
+  end
+
+  module ClassWrapper
+    include FunctionWrapper
+    include RawClassWrapper
+
+    def const_missing(name)
+      if js_property?(name)
+        js_property(name)
+      else
+        super
+      end
+    end
+
+    def new(*args, &block)
+      args << block if block_given?
+      args = JSWrap.unwrap_ary(args, self)
+      JSWrap(`new (#{@native}.bind.apply(#{@native}, [null].concat(args)))`, self)
+    end
+  end
+
+  def self.wrapped?(object)
+    `object != null && '$$class' in object && Opal.is_a(object, Opal.JSWrap.Wrapper)`
+  end
+
+  def self.unwrap(object, parent = nil)
+    %x{
+      if (object === null || object === undefined || object === nil) {
+        return null;
+      }
+      else if (object.$$class !== undefined) {
+        // Opal < 1.4 bug: Opal.respond_to vs #respond_to_missing? does not call
+        // #respond_to?
+        if (object.$to_js !== undefined && !object.$to_js.$$stub) {
+          return object.$to_js(parent);
+        }
+        else if (object.$to_n !== undefined && !object.$to_n.$$stub) {
+          return object.$to_n();
+        }
+      }
+      return object;
+    }
+  end
+
+  def self.unwrap_ary(ary, parent = nil)
+    %x{
+      var i;
+      for (i = 0; i < ary.length; i++) {
+        ary[i] = #{unwrap(ary[`i`], parent)}
+      }
+      return ary;
+    }
+  end
+
+  def self.unwrap_proc(proc, parent = nil)
+    %x{
+      var f = (function() {
+        var i, ary = Array.prototype.slice.apply(arguments), ret;
+        for (i = 0; i < ary.length; i++) {
+          ary[i] = #{wrap(`ary[i]`, parent)}
+        }
+        ret = proc.apply(null, ary);
+        return #{unwrap(`ret`, parent)}
+      });
+      f.$$proc_unwrapped = proc;
+      return f;
+    }
+  end
+
+  def self.wrap(object, parent = nil, args = nil, name: nil)
+    %x{
+      var i, out, wrapping;
+      for (i = self.wrappings.length - 1; i >= 0; i--) {
+        wrapping = self.wrappings[i];
+        if (wrapping.block !== nil) {
+          out = #{`wrapping.block`.call(object, parent, args, name)}
+          if (out == null) return nil;
+          else if (out !== nil) return out;
+        }
+        else if (object instanceof wrapping.js_constructor) {
+          return #{`wrapping.opal_klass`.wrap(`object`)}
+        }
+      }
+    }
+  end
+
+  def self.call(parent, item, *args, &block)
+    args << block if block_given?
+    orig_parent = parent
+    parent = unwrap(parent, orig_parent)
+    args = unwrap_ary(args, orig_parent)
+    %x{
+      if (typeof item !== 'function') {
+        item = parent[item];
+      }
+      item = item.apply(parent, args);
+      return #{wrap(item, orig_parent)}
+    }
+  end
+
+  @wrappings = []
+  def self.register_wrapping(opal_klass = undefined, js_constructor = undefined, priority: 0, &block)
+    @wrappings << `{
+      priority: priority,
+      opal_klass: opal_klass,
+      js_constructor: js_constructor,
+      block: block
+    }`
+    @wrappings.sort_by!(&`function(i){
+                          return -i.priority;
+                        }`
+                       )
+  end
+
+  module WrapperClassMethods
+    include RawClassWrapper
+  end
+
+  class ObjectView
+    extend WrapperClassMethods
+    include ObjectWrapper
+    self.js_array_wrap = true
+    undef Array, String
+  end
+  class ArrayView
+    extend WrapperClassMethods
+    include ArrayWrapper
+    self.js_array_wrap = true
+  end
+  # ClassView does not work as a class fully. This is only a limited contract.
+  # ie. ClassView.wrap(`BigInt`).new.class == ObjectView.
+  # The reason why we inherit from Class is that so we can access properties like A::B
+  class ClassView < Class
+    extend WrapperClassMethods
+    include ClassWrapper
+    self.js_array_wrap = true
+  end
+  class FunctionView
+    extend WrapperClassMethods
+    include FunctionWrapper
+    self.js_array_wrap = true
+  end
+end
+
+module Kernel
+  def JSWrap(*args, &block)
+    JSWrap.wrap(*args, &block)
+  end
+end
+
+JSWrap.register_wrapping(priority: -10) do |item, parent, args, name|
+  %x{
+    var type = typeof item;
+
+    var array_wrap = $truthy(parent) ? $truthy(parent.$js_array_wrap()) : true;
+    var function_wrap = $truthy(parent) ? $truthy(parent.$js_function_wrap()) : false;
+
+    if (type === 'undefined' || item === null || item === nil) {
+      // A special case not documented anywhere: null makes it dispatch a nil.
+      if (args !== nil && args.length !== 0) {
+        #{raise ArgumentError, 'given args while dispatching a null value'}
+      }
+      return null;
+    }
+    else if (type === 'symbol' || type === 'bigint') {
+      // As of Opal 1.4, we don't support those. Let's pretend they
+      // are just objects.
+      if (args !== nil && args.length !== 0) {
+        #{raise ArgumentError, "given args while dispatching a #{`type`}"}
+      }
+      return #{JSWrap::ObjectView.wrap(item, parent)}
+    }
+    else if (type === 'number' || type === 'string' || type === 'boolean') {
+      // Otherwise it's some primitive and it's wrapped
+      if (args !== nil && args.length !== 0) {
+        #{raise ArgumentError, "given args while dispatching a #{`type`}"}
+      }
+      return item;
+    }
+    else if ('$$js_wrap' in item) {
+      // Wrapping is dispatched already, we can trust it to be wrapped properly
+      if (args !== nil && args.length !== 0) {
+        #{raise ArgumentError, 'given args while dispatching an already dispatched value'}
+      }
+      return item.$$js_wrap;
+    }
+    else if (type === 'function') {
+      if (item.$$class === Opal.Class) {
+        // Opal Class
+        if (args !== nil && args.length !== 0) {
+          #{raise ArgumentError, 'given args while dispatching an Opal class'}
+        }
+        return item;
+      }
+      else if ("$$arity" in item) {
+        // Native Opal proc
+        return item;
+      }
+      else if ("$$proc_unwrapped" in item) {
+        // Unwrapped native Opal proc
+        return item.$$proc_unwrapped;
+      }
+      else if (name !== nil && 'prototype' in item && name.match(/^[A-Z]/)) {
+        // Class
+        // There is no reliable way to detect a JS class. So we check if its
+        // name starts with an uppercase letter.
+        if (args !== nil && args.length !== 0) {
+          #{raise ArgumentError, 'given args while dispatching a class'}
+        }
+        return #{JSWrap::ClassView.wrap(item, parent)}
+      }
+      else {
+        // Regular function
+        if (function_wrap || args === nil) {
+          return #{JSWrap::FunctionView.wrap(item, parent)}
+        }
+        else {
+          var ret = #{JSWrap.call(parent, item, *args)}
+          return ret === nil ? null : ret;
+        }
+      }
+    }
+    else if (type === 'object') {
+      if (item instanceof Array) {
+        // A regular array
+        if (args !== nil && args.length !== 0) {
+          #{raise ArgumentError, 'given args while dispatching an array'}
+        }
+        if (array_wrap) {
+          return #{JSWrap::ArrayView.wrap(item, parent)}
+        }
+        else {
+          return item;
+        }
+      }
+      else if ('$$class' in item) {
+        // Opal item
+        if (args !== nil && args.length !== 0) {
+          #{raise ArgumentError, 'given args while dispatching an Opal object'}
+        }
+        return item;
+      }
+      else {
+        // Pass.
+        return nil;
+      }
+    }
+    else {
+      #{raise ArgumentError, "unknown value type #{type}"}
+    }
+  }
+end
+
+# Now custom wrappers run... but if nothing is found... we run a
+# final wrapper:
+
+JSWrap.register_wrapping(priority: 10) do |item, parent, args|
+  %x{
+    if (args !== nil && args.length !== 0) {
+      #{raise ArgumentError, 'given args while dispatching an object'}
+    }
+    else if ('length' in item) {
+      // A pseudo-array, we always wrap those
+      return #{JSWrap::ArrayView.wrap(item, parent)}
+    }
+    else {
+      // Otherwise it is a regulat object
+      return #{JSWrap::ObjectView.wrap(item, parent)}
+    }
+  }
+end
+
+class Hash
+  # @return a JavaScript object with the same keys but calling #to_n on
+  # all values.
+  def to_js(parent=nil)
+    %x{
+      var result = {},
+          keys = self.$$keys,
+          smap = self.$$smap,
+          key, value;
+      for (var i = 0, length = keys.length; i < length; i++) {
+        key = keys[i];
+        if (key.$$is_string) {
+          value = smap[key];
+        } else {
+          key = key.key;
+          value = key.value;
+        }
+        key = #{parent.js_property_name_rb2js(`key`)}
+        result[key] = #{JSWrap.unwrap(`value`, parent)}
+      }
+      return result;
+    }
+  end
+end
+
+class Method
+  def to_js(parent=nil)
+    JSWrap.unwrap_proc(to_proc, parent)
+  end
+end
+
+class Proc
+  def to_js(parent=nil)
+    %x{
+      // Is this a native Opal Proc? Or is it JavaScript
+      // created?
+      if ('$$arity' in self) {
+        return #{JSWrap.unwrap_proc(self, parent)}
+      }
+      else {
+        return self;
+      }
+    }
+  end
+end
+
+JSGlobal = JSWrap(`Opal.global`)