js 0.0.1 → 2.5.0

data/js.gemspec

@@ -1,19 +1,29 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'js/version'
+# frozen_string_literal: true
 
-Gem::Specification.new do |gem|
-  gem.name          = "js"
-  gem.version       = Js::VERSION
-  gem.authors       = ["Charles Lowell"]
-  gem.email         = ["cowboyd@thefrontside.net"]
-  gem.description   = %q{embed a JavaScript interpreter}
-  gem.summary       = %q{use JavaScript objects from Ruby and embed Ruby objects into JavaScript}
-  gem.homepage      = ""
+require_relative "lib/js/version"
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+Gem::Specification.new do |spec|
+  spec.name = "js"
+  spec.version = JS::VERSION
+  spec.authors = ["Yuta Saito"]
+  spec.email = ["kateinoigakukun@gmail.com"]
+
+  spec.summary = %q{JavaScript bindings for ruby.wasm}
+  spec.description = %q{JavaScript bindings for ruby.wasm. This gem provides a way to use JavaScript functionalities from Ruby through WebAssembly.}
+  spec.homepage = "https://github.com/ruby/ruby.wasm"
+
+  spec.metadata = {
+    "source_code_uri" => "https://github.com/ruby/ruby.wasm/tree/main/packages/gems/js",
+  }
+
+  spec.license = "MIT"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/js/extconf.rb", "ext/witapi/extconf.rb"]
 end

data/lib/js/array.rb

@@ -0,0 +1,9 @@
+class Array
+  # Convert Ruby array to JavaScript array
+  def to_js
+    new_array = JS.eval("return []")
+    # NOTE: This method call implicitly convert element to JS object by to_js
+    new_array.push *self
+    new_array
+  end
+end

data/lib/js/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  # Convert a hash to a JavaScript object
+  def to_js
+    new_object = JS.eval("return {}")
+    self.each { |key, value| new_object[key] = value }
+    new_object
+  end
+end

data/lib/js/nil_class.rb

@@ -0,0 +1,6 @@
+class NilClass
+  # Convert to JS null
+  def to_js
+    JS::Null
+  end
+end

data/lib/js/require_remote/evaluator.rb

@@ -0,0 +1,15 @@
+module JS
+  class RequireRemote
+    # Execute the body of the response and record the URL.
+    class Evaluator
+      def evaluate(code, filename, final_url)
+        Kernel.eval(code, ::Object::TOPLEVEL_BINDING, filename)
+        $LOADED_FEATURES << final_url
+      end
+
+      def evaluated?(url)
+        $LOADED_FEATURES.include?(url)
+      end
+    end
+  end
+end

data/lib/js/require_remote/url_resolver.rb

@@ -0,0 +1,45 @@
+module JS
+  class RequireRemote
+    ScriptLocation = Data.define(:url, :filename)
+
+    # When require_relative is called within a running Ruby script,
+    # the URL is resolved from a relative file path based on the URL of the running Ruby script.
+    # It uses a stack to store URLs of running Ruby Script.
+    # Push the URL onto the stack before executing the new script.
+    # Then pop it when the script has finished executing.
+    class URLResolver
+      def initialize(base_url)
+        @url_stack = [base_url]
+      end
+
+      def get_location(relative_feature)
+        filename = filename_from(relative_feature)
+        url = resolve(filename)
+        ScriptLocation.new(url, filename)
+      end
+
+      def push(url)
+        @url_stack.push url
+      end
+
+      def pop()
+        @url_stack.pop
+      end
+
+      private
+
+      def filename_from(relative_feature)
+        if relative_feature.end_with?(".rb")
+          relative_feature
+        else
+          "#{relative_feature}.rb"
+        end
+      end
+
+      # Return a URL object of JavaScript.
+      def resolve(relative_filepath)
+        JS.global[:URL].new relative_filepath, @url_stack.last
+      end
+    end
+  end
+end

data/lib/js/require_remote.rb

@@ -0,0 +1,85 @@
+require "singleton"
+require "js"
+require_relative "./require_remote/url_resolver"
+require_relative "./require_remote/evaluator"
+
+module JS
+  # This class is used to load remote Ruby scripts.
+  #
+  # == Example
+  #
+  #   require 'js/require_remote'
+  #   JS::RequireRemote.instance.load("foo")
+  #
+  # This class is intended to be used to replace Kernel#require_relative.
+  #
+  # == Example
+  #
+  #   require 'js/require_remote'
+  #   module Kernel
+  #     def require_relative(path) = JS::RequireRemote.instance.load(path)
+  #   end
+  #
+  # If you want to load the bundled gem
+  #
+  # == Example
+  #
+  #    require 'js/require_remote'
+  #    module Kernel
+  #      alias original_require_relative require_relative
+  #
+  #      def require_relative(path)
+  #        caller_path = caller_locations(1, 1).first.absolute_path || ''
+  #        dir = File.dirname(caller_path)
+  #        file = File.absolute_path(path, dir)
+  #
+  #        original_require_relative(file)
+  #      rescue LoadError
+  #        JS::RequireRemote.instance.load(path)
+  #      end
+  #   end
+  #
+  class RequireRemote
+    include Singleton
+
+    def initialize
+      base_url = JS.global[:URL].new(JS.global[:location][:href])
+      @resolver = URLResolver.new(base_url)
+      @evaluator = Evaluator.new
+    end
+
+    # Load the given feature from remote.
+    def load(relative_feature)
+      location = @resolver.get_location(relative_feature)
+
+      # Do not load the same URL twice.
+      return false if @evaluator.evaluated?(location.url[:href].to_s)
+
+      response = JS.global.fetch(location.url).await
+      unless response[:status].to_i == 200
+        raise LoadError.new "cannot load such url -- #{response[:status]} #{location.url}"
+      end
+
+      # The fetch API may have responded to a redirect response
+      # and fetched the script from a different URL than the original URL.
+      # Retrieve the final URL again from the response object.
+      final_url = response[:url].to_s
+
+      # Do not evaluate the same URL twice.
+      return false if @evaluator.evaluated?(final_url)
+
+      code = response.text().await.to_s
+
+      evaluate(code, location.filename, final_url)
+    end
+
+    private
+
+    def evaluate(code, filename, final_url)
+      @resolver.push(final_url)
+      @evaluator.evaluate(code, filename, final_url)
+      @resolver.pop
+      true
+    end
+  end
+end

data/lib/js/version.rb

@@ -1,3 +1,3 @@
-module Js
-  VERSION = "0.0.1"
+module JS
+  VERSION = "2.5.0"
 end

data/lib/js.rb

@@ -1,5 +1,240 @@
-require "js/version"
+require "js.so"
+require_relative "js/hash.rb"
+require_relative "js/array.rb"
+require_relative "js/nil_class.rb"
 
-module Js
-  # Your code goes here...
+# The JS module provides a way to interact with JavaScript from Ruby.
+#
+# == Example
+#
+#   require 'js'
+#   JS.eval("return 1 + 2") # => 3
+#   JS.global[:document].write("Hello, world!")
+#   div = JS.global[:document].createElement("div")
+#   div[:innerText] = "click me"
+#   body = JS.global[:document][:body]
+#   if body[:classList].contains?("main")
+#     body.appendChild(div)
+#   end
+#   div.addEventListener("click") do |event|
+#     puts event          # => # [object MouseEvent]
+#     puts event[:detail] # => 1
+#     div[:innerText] = "clicked!"
+#   end
+#
+# If you are using `ruby.wasm` without `stdlib` you will not have `addEventListener`
+# and other specialized functions defined. You can still acomplish many
+# of the same things using `call` instead.
+#
+# == Example
+#
+#   require 'js'
+#   JS.eval("return 1 + 2") # => 3
+#   JS.global[:document].call(:write, "Hello, world!")
+#   div = JS.global[:document].call(:createElement, "div")
+#   div[:innerText] = "click me"
+#   if body[:classList].call(:contains, "main") == JS::True
+#     body.appendChild(div)
+#   end
+#   div.call(:addEventListener, "click") do |event|
+#     puts event          # => # [object MouseEvent]
+#     puts event[:detail] # => 1
+#     div[:innerText] = "clicked!"
+#   end
+#
+module JS
+  Undefined = JS.eval("return undefined")
+  Null = JS.eval("return null")
+
+  # A boolean value in JavaScript is always a JS::Object instance from Ruby's point of view.
+  # If we use the boolean value returned by a JavaScript function as the condition for an if expression in Ruby,
+  # the if expression will always be true.
+  #
+  # == Bad Example
+  #
+  #   searchParams = JS.global[:URLSearchParams].new(JS.global[:location][:search])
+  #   if searchParams.has('phrase')
+  #     # Always pass through here.
+  #     ...
+  #   else
+  #     ...
+  #   end
+  #
+  # Therefore, the JS::True constant is used to determine if the JavaScript function return value is true or false.
+  #
+  # == Good Example
+  #
+  #   if searchParams.has('phrase') == JS::True
+  #     ...
+  #   end
+  True = JS.eval("return true;")
+  False = JS.eval("return false;")
+
+  class PromiseScheduler
+    def initialize(loop)
+      @loop = loop
+    end
+
+    def await(promise)
+      current = Fiber.current
+      promise.call(
+        :then,
+        ->(value) { current.transfer(value, :success) },
+        ->(value) { current.transfer(value, :failure) }
+      )
+      if @loop == current
+        raise (
+                "JS::Object#await can be called only from RubyVM#evalAsync or RbValue#callAsync JS API\n" +
+                  "If you are using browser.script.iife.js, please ensure that you specify `data-eval=\"async\"` in your script tag\n" +
+                  "e.g. <script type=\"text/ruby\" data-eval=\"async\">puts :hello</script>\n" +
+                  "Or <script type=\"text/ruby\" data-eval=\"async\" src=\"path/to/script.rb\"></script>"
+              )
+      end
+      value, status = @loop.transfer
+      raise JS::Error.new(value) if status == :failure
+      value
+    end
+  end
+
+  @promise_scheduler = PromiseScheduler.new Fiber.current
+
+  def self.promise_scheduler
+    @promise_scheduler
+  end
+
+  private
+
+  def self.__eval_async_rb(rb_code, future)
+    self.__async(future) do
+      JS::Object.wrap(Kernel.eval(rb_code.to_s, TOPLEVEL_BINDING, "eval_async"))
+    end
+  end
+
+  def self.__call_async_method(recv, method_name, future, *args)
+    self.__async(future) { recv.send(method_name.to_s, *args) }
+  end
+
+  def self.__async(future, &block)
+    Fiber
+      .new do
+        future.resolve block.call
+      rescue => e
+        future.reject JS::Object.wrap(e)
+      end
+      .transfer
+  end
+end
+
+class JS::Object
+  # Create a JavaScript object with the new method
+  #
+  # The below examples show typical usage in Ruby
+  #
+  #   JS.global[:Object].new
+  #   JS.global[:Number].new(1.23)
+  #   JS.global[:String].new("string")
+  #   JS.global[:Array].new(1, 2, 3)
+  #   JS.global[:Date].new(2020, 1, 1)
+  #   JS.global[:Error].new("error message")
+  #   JS.global[:URLSearchParams].new(JS.global[:location][:search])
+  #
+  def new(*args)
+    JS.global[:Reflect].construct(self, args.to_js)
+  end
+
+  # Converts +self+ to an Array:
+  #
+  #   JS.eval("return [1, 2, 3]").to_a.map(&:to_i)    # => [1, 2, 3]
+  #   JS.global[:document].querySelectorAll("p").to_a # => [[object HTMLParagraphElement], ...
+  def to_a
+    as_array = JS.global[:Array].from(self)
+    Array.new(as_array[:length].to_i) { as_array[_1] }
+  end
+
+  # Provide a shorthand form for JS::Object#call
+  #
+  # This method basically calls the JavaScript method with the same
+  # name as the Ruby method name as is using JS::Object#call.
+  #
+  # Exceptions are the following cases:
+  # * If the method name ends with a question mark (?), the question mark is removed
+  #   and the method is called as a predicate method. The return value is converted to
+  #   a Ruby boolean value automatically.
+  #
+  # This shorthand is unavailable for the following cases and you need to use
+  # JS::Object#call instead:
+  # * If the method name is invalid as a Ruby method name (e.g. contains a hyphen, reserved word, etc.)
+  # * If the method name is already defined as a Ruby method under JS::Object
+  # * If the JavaScript method name ends with a question mark (?)
+  def method_missing(sym, *args, &block)
+    sym_str = sym.to_s
+    if sym_str.end_with?("?")
+      # When a JS method is called with a ? suffix, it is treated as a predicate method,
+      # and the return value is converted to a Ruby boolean value automatically.
+      self.call(sym_str[0..-2].to_sym, *args, &block) == JS::True
+    elsif self[sym].typeof == "function"
+      self.call(sym, *args, &block)
+    else
+      super
+    end
+  end
+
+  # Check if a JavaScript method exists
+  #
+  # See JS::Object#method_missing for details.
+  def respond_to_missing?(sym, include_private)
+    return true if super
+    sym_str = sym.to_s
+    sym = sym_str[0..-2].to_sym if sym_str.end_with?("?")
+    self[sym].typeof == "function"
+  end
+
+  # Await a JavaScript Promise like `await` in JavaScript.
+  # This method looks like a synchronous method, but it actually runs asynchronously using fibers.
+  # In other words, the next line to the `await` call at Ruby source will be executed after the
+  # promise will be resolved. However, it does not block JavaScript event loop, so the next line
+  # to the RubyVM.evalAsync` (in the case when no `await` operator before the call expression)
+  # at JavaScript source will be executed without waiting for the promise.
+  #
+  # The below example shows how the execution order goes. It goes in the order of "step N"
+  #
+  #   # In JavaScript
+  #   const response = vm.evalAsync(`
+  #     puts "step 1"
+  #     JS.global.fetch("https://example.com").await
+  #     puts "step 3"
+  #   `) // => Promise
+  #   console.log("step 2")
+  #   await response
+  #   console.log("step 4")
+  #
+  # The below examples show typical usage in Ruby
+  #
+  #   JS.eval("return new Promise((ok) => setTimeout(() => ok(42), 1000))").await # => 42 (after 1 second)
+  #   JS.global.fetch("https://example.com").await                                # => [object Response]
+  #   JS.eval("return 42").await                                                  # => 42
+  #   JS.eval("return new Promise((ok, err) => err(new Error())").await           # => raises JS::Error
+  def await
+    # Promise.resolve wrap a value or flattens promise-like object and its thenable chain
+    promise = JS.global[:Promise].resolve(self)
+    JS.promise_scheduler.await(promise)
+  end
+end
+
+# A wrapper class for JavaScript Error to allow the Error to be thrown in Ruby.
+class JS::Error
+  def initialize(exception)
+    @exception = exception
+    super
+  end
+
+  def message
+    stack = @exception[:stack]
+    if stack.typeof == "string"
+      # Error.stack contains the error message also
+      stack.to_s
+    else
+      @exception.to_s
+    end
+  end
 end

metadata

@@ -1,53 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: js
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 2.5.0
 platform: ruby
 authors:
-- Charles Lowell
+- Yuta Saito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-18 00:00:00.000000000 Z
+date: 2024-01-28 00:00:00.000000000 Z
 dependencies: []
-description: embed a JavaScript interpreter
+description: JavaScript bindings for ruby.wasm. This gem provides a way to use JavaScript
+  functionalities from Ruby through WebAssembly.
 email:
-- cowboyd@thefrontside.net
+- kateinoigakukun@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/js/extconf.rb
+- ext/witapi/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
+- ext/js/bindgen/.clang-format
+- ext/js/bindgen/rb-js-abi-host.c
+- ext/js/bindgen/rb-js-abi-host.h
+- ext/js/bindgen/rb-js-abi-host.wit
+- ext/js/depend
+- ext/js/extconf.rb
+- ext/js/js-core.c
+- ext/witapi/bindgen/.clang-format
+- ext/witapi/bindgen/rb-abi-guest.c
+- ext/witapi/bindgen/rb-abi-guest.h
+- ext/witapi/bindgen/rb-abi-guest.wit
+- ext/witapi/depend
+- ext/witapi/extconf.rb
+- ext/witapi/witapi-core.c
 - js.gemspec
 - lib/js.rb
+- lib/js/array.rb
+- lib/js/hash.rb
+- lib/js/nil_class.rb
+- lib/js/require_remote.rb
+- lib/js/require_remote/evaluator.rb
+- lib/js/require_remote/url_resolver.rb
 - lib/js/version.rb
-homepage: ''
-licenses: []
+homepage: https://github.com/ruby/ruby.wasm
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ruby/ruby.wasm/tree/main/packages/gems/js
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 3.5.3
 signing_key: 
-specification_version: 3
-summary: use JavaScript objects from Ruby and embed Ruby objects into JavaScript
+specification_version: 4
+summary: JavaScript bindings for ruby.wasm
 test_files: []

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in js.gemspec
-gemspec

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2012 Charles Lowell
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,35 +0,0 @@
-# js.rb - Embed JavasScript into Ruby
-
-js.rb harnesses the power of JavaScript inside your Ruby application
-
-## Synopsis
-
-evaluate some simple JavaScript
-
-    cxt = JS::Context.new
-    cxt.eval('7 * 6') #=> 42
-
-embed values into the scope of your context
-
-    cxt['foo'] = "bar"
-    cxt.eval('foo') # => "bar"
-
-embed Ruby code into your scope and call it from JavaScript
-
-    cxt["say"] = lambda {|this, word, times| word * times}
-    cxt.eval("say('Hello', 3)") #=> HelloHelloHello
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'js'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install js
-

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"