RubyGems - ruby_wasm - Versions diffs - 2.5.0-x64-mingw32 - Mend

ruby_wasm 2.5.0-x64-mingw32

Files changed (64) hide show

checksums.yaml +7 -0
data/.clang-format +8 -0
data/CONTRIBUTING.md +126 -0
data/Gemfile +17 -0
data/LICENSE +21 -0
data/NOTICE +1293 -0
data/README.md +153 -0
data/Rakefile +163 -0
data/Steepfile +24 -0
data/benchmarks/vm_deep_call.rb +55 -0
data/builders/wasm32-unknown-emscripten/Dockerfile +43 -0
data/builders/wasm32-unknown-emscripten/entrypoint.sh +7 -0
data/builders/wasm32-unknown-wasi/Dockerfile +47 -0
data/builders/wasm32-unknown-wasi/entrypoint.sh +7 -0
data/docs/api.md +2 -0
data/docs/cheat_sheet.md +195 -0
data/docs/faq.md +25 -0
data/exe/rbwasm +7 -0
data/ext/.gitignore +2 -0
data/ext/README.md +11 -0
data/ext/extinit.c.erb +32 -0
data/lib/ruby_wasm/3.0/ruby_wasm.so +0 -0
data/lib/ruby_wasm/build/build_params.rb +3 -0
data/lib/ruby_wasm/build/downloader.rb +18 -0
data/lib/ruby_wasm/build/executor.rb +187 -0
data/lib/ruby_wasm/build/product/baseruby.rb +37 -0
data/lib/ruby_wasm/build/product/crossruby.rb +330 -0
data/lib/ruby_wasm/build/product/libyaml.rb +68 -0
data/lib/ruby_wasm/build/product/openssl.rb +88 -0
data/lib/ruby_wasm/build/product/product.rb +39 -0
data/lib/ruby_wasm/build/product/ruby_source.rb +103 -0
data/lib/ruby_wasm/build/product/wasi_vfs.rb +45 -0
data/lib/ruby_wasm/build/product/zlib.rb +68 -0
data/lib/ruby_wasm/build/product.rb +8 -0
data/lib/ruby_wasm/build/toolchain/wit_bindgen.rb +31 -0
data/lib/ruby_wasm/build/toolchain.rb +193 -0
data/lib/ruby_wasm/build.rb +88 -0
data/lib/ruby_wasm/cli.rb +217 -0
data/lib/ruby_wasm/packager/core.rb +156 -0
data/lib/ruby_wasm/packager/file_system.rb +158 -0
data/lib/ruby_wasm/packager.rb +159 -0
data/lib/ruby_wasm/rake_task.rb +59 -0
data/lib/ruby_wasm/util.rb +15 -0
data/lib/ruby_wasm/version.rb +3 -0
data/lib/ruby_wasm.rb +33 -0
data/package-lock.json +9500 -0
data/package.json +12 -0
data/rakelib/check.rake +37 -0
data/rakelib/ci.rake +152 -0
data/rakelib/doc.rake +29 -0
data/rakelib/format.rake +35 -0
data/rakelib/gem.rake +22 -0
data/rakelib/packaging.rake +151 -0
data/rakelib/version.rake +40 -0
data/sig/open_uri.rbs +4 -0
data/sig/ruby_wasm/build.rbs +318 -0
data/sig/ruby_wasm/cli.rbs +27 -0
data/sig/ruby_wasm/ext.rbs +13 -0
data/sig/ruby_wasm/packager.rbs +91 -0
data/sig/ruby_wasm/util.rbs +5 -0
data/tools/clang-format-diff.sh +18 -0
data/tools/exe/rbminify +12 -0
data/tools/lib/syntax_tree/minify_ruby.rb +63 -0
metadata +112 -0

data/docs/cheat_sheet.md ADDED Viewed

@@ -0,0 +1,195 @@
+[[**Cheat Sheet**]](./cheat_sheet.md)
+[[**FAQ**]](./faq.md)
+[[**API Reference**]](./api.md)
+[[**Complete Examples**]](https://github.com/ruby/ruby.wasm/tree/main/packages/npm-packages/ruby-wasm-wasi/example)
+[[**Community Showcase**]](https://github.com/ruby/ruby.wasm/wiki/Showcase)
+# ruby.wasm Cheat Sheet
+## Node.js
+To install the package, install `@ruby/3.3-wasm-wasi` and `@ruby/wasm-wasi` from npm:
+```console
+npm install --save @ruby/3.3-wasm-wasi @ruby/wasm-wasi
+```
+Then instantiate a Ruby VM by the following code:
+```javascript
+import fs from "fs/promises";
+import { DefaultRubyVM } from "@ruby/wasm-wasi/dist/node";
+const binary = await fs.readFile("./node_modules/@ruby/3.3-wasm-wasi/dist/ruby.wasm");
+const module = await WebAssembly.compile(binary);
+const { vm } = await DefaultRubyVM(module);
+vm.eval(`puts "hello world"`);
+```
+Then run the example code with `--experimental-wasi-unstable-preview1` flag to enable WASI support:
+```console
+$ node --experimental-wasi-unstable-preview1 index.mjs
+```
+## Browser
+The easiest way to run Ruby on browser is to use `browser.script.iife.js` script from CDN:
+```html
+<html>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/browser.script.iife.js"></script>
+  <script type="text/ruby">
+    require "js"
+    JS.global[:document].write "Hello, world!"
+  </script>
+</html>
+```
+If you want to control Ruby VM from JavaScript, you can use `@ruby/wasm-wasi` package API:
+```html
+<html>
+  <script type="module">
+    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser/+esm";
+    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+    const module = await WebAssembly.compileStreaming(response);
+    const { vm } = await DefaultRubyVM(module);
+    vm.eval(`
+      require "js"
+      JS.global[:document].write "Hello, world!"
+    `);
+  </script>
+</html>
+```
+<details>
+<summary>Alternative: Without ES Modules</summary>
+```html
+<html>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser.umd.js"></script>
+  <script>
+    const main = async () => {
+      const { DefaultRubyVM } = window["ruby-wasm-wasi"];
+      const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+      const module = await WebAssembly.compileStreaming(response);
+      const { vm } = await DefaultRubyVM(module);
+      vm.eval(`
+        require "js"
+        JS.global[:document].write "Hello, world!"
+      `);
+    }
+    main()
+  </script>
+</html>
+```
+</details>
+## Use JavaScript from Ruby
+### Get/set JavaScript variables from Ruby
+```ruby
+require "js"
+document = JS.global[:document]
+document[:title] = "Hello, world!"
+```
+### Call JavaScript methods from Ruby
+```ruby
+require "js"
+JS.global[:document].createElement("div")
+JS.global[:document].call(:createElement, "div".to_js) # same as above
+```
+### Pass Ruby `Proc` to JavaScript (Callback to Ruby)
+```ruby
+require "js"
+JS.global.setTimeout(proc { puts "Hello, world!" }, 1000)
+input = JS.global[:document].querySelector("input")
+input.addEventListener("change") do |event|
+  puts event[:target][:value].to_s
+end
+```
+### `await` JavaScript `Promise` from Ruby
+`data-eval="async"` attribute is required to use `await` in `<script>` tag:
+```html
+<html>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/browser.script.iife.js"></script>
+  <script type="text/ruby" data-eval="async">
+    require "js"
+    response = JS.global.fetch("https://www.ruby-lang.org/").await
+    puts response[:status]
+  </script>
+</html>
+```
+Or using `@ruby/wasm-wasi` package API `RubyVM#evalAsync`:
+```html
+<html>
+  <script type="module">
+    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser/+esm";
+    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+    const module = await WebAssembly.compileStreaming(response);
+    const { vm } = await DefaultRubyVM(module);
+    vm.evalAsync(`
+      require "js"
+      response = JS.global.fetch("https://www.ruby-lang.org/").await
+      puts response[:status]
+    `);
+  </script>
+</html>
+```
+### `new` JavaScript instance from Ruby
+```ruby
+require "js"
+JS.global[:Date].new(2000, 9, 13)
+```
+### Convert returned JavaScript `String` value to Ruby `String`
+```ruby
+require "js"
+title = JS.global[:document].title # => JS::Object("Hello, world!")
+title.to_s # => "Hello, world!"
+```
+### Convert JavaScript `Boolean` value to Ruby `true`/`false`
+```ruby
+require "js"
+JS.global[:document].hasFocus? # => true
+JS.global[:document].hasFocus  # => JS::Object(true)
+```
+### Convert JavaScript `Number` value to Ruby `Integer`/`Float`
+```ruby
+require "js"
+rand = JS.global[:Math].random # JS::Object(0.123456789)
+rand.to_i # => 0
+rand.to_f # => 0.123456789
+```

data/docs/faq.md ADDED Viewed

@@ -0,0 +1,25 @@
+[[**Cheat Sheet**]](./cheat_sheet.md)
+[[**FAQ**]](./faq.md)
+[[**API Reference**]](./api.md)
+[[**Complete Examples**]](https://github.com/ruby/ruby.wasm/tree/main/packages/npm-packages/ruby-wasm-wasi/example)
+[[**Community Showcase**]](https://github.com/ruby/ruby.wasm/wiki/Showcase)
+# FAQ
+## Where my `puts` output goes?
+By default, `puts` output goes to `STDOUT` which is a JavaScript `console.log` function. You can override it by setting `$stdout` to a Ruby object which has `write` method.
+```ruby
+$stdout = Object.new.tap do |obj|
+  def obj.write(str)
+    JS.global[:document].write(str)
+  end
+end
+puts "Hello, world!" # => Prints "Hello, world!" to the HTML document
+```
+## How to run WebAssembly in Ruby
+Use [`wasmtime` Ruby gem](https://rubygems.org/gems/wasmtime).

data/exe/rbwasm ADDED Viewed

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.join(__dir__, "../lib")
+require "ruby_wasm"
+require "ruby_wasm/cli"
+RubyWasm::CLI.new(stdout: $stdout, stderr: $stderr).run(ARGV)

data/ext/.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ *.o
2	+ link.filelist

data/ext/README.md ADDED Viewed

@@ -0,0 +1,11 @@
+# Ruby extensions
+`ruby.wasm` uses two C extensions to turn Ruby in to a guest module.
+The `js` extension enables Ruby to use JavaScript APIs.
+The `witapi` extension exports Ruby's interpreter interface to allow the host to use the Ruby interpreter.
+In other words, `js` allows Ruby to talk to Javascript and `witapi` allows a host to talk to Ruby.
+Under each subdirectory, there is a `bindgen/*.wit` file outlining the interfaces for each form of communication.
+Specifically, `bindgen/rb-js-abi-host.wit` describes embedder's requirements and `bindgen/rb-js-abi-guest.wit` describes exported API from Ruby interpreter.
+The `.c` and `.h` files are autogenerated from [wit-bindgen](https://github.com/bytecodealliance/wit-bindgen#host-runtimes-for-components).
+You can read more about it in the [contributing guide](/CONTRIBUTING.md#re-bindgen-from-wit-files).
+Note that we currently do not use the latest version of wit-bindgen because of how fast it is changing, with features being changed or even [removed](https://github.com/bytecodealliance/wit-bindgen/pull/346) at times.

data/ext/extinit.c.erb ADDED Viewed

@@ -0,0 +1,32 @@
+require "erb"
+require "optparse"
+opts = OptionParser.new
+opts.on("--cc CC") {|cc| @cc = cc }
+opts.on("--output FILE") {|o| @o = o }
+opts.parse!(ARGV)
+if @cc.nil? || @o.nil?
+  puts opts.help
+  exit 1
+end
+exts = ARGV
+c_src = ERB.new(DATA.read).result
+IO.popen([@cc, "-c", "-xc", "-", "-o", @o], "w") {|f| f << c_src }
+exit $?.exitstatus
+__END__
+#define init(func, name) { \
+    extern void func(void);	\
+    ruby_init_ext(name".so", func); \
+}
+void ruby_init_ext(const char *name, void (*init)(void));
+void Init_extra_exts(void) {
+<% exts.each do |ext| %>
+  init(<%= "Init_#{File.basename ext}" %>, "<%= ext %>");
+<% end %>
+}

data/lib/ruby_wasm/3.0/ruby_wasm.so ADDED Viewed

Binary file

data/lib/ruby_wasm/build/build_params.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module RubyWasm
+  BuildParams = Struct.new(:name, :target, :default_exts, keyword_init: true)
+end

data/lib/ruby_wasm/build/downloader.rb ADDED Viewed

@@ -0,0 +1,18 @@
+module RubyWasm
+  class Downloader
+    def download(url, dest, message)
+      require "open-uri"
+      content_length = 0
+      uri = URI.parse(url)
+      OpenURI.open_uri(
+        uri,
+        content_length_proc: ->(len) { content_length = len },
+        progress_proc: ->(size) do
+          print "\r#{message} (#{SizeFormatter.format(content_length)}) %.2f%%" %
+                  (size.to_f / content_length * 100)
+        end
+      ) { |f| File.open(dest, "wb") { |out| out.write f.read } }
+      puts "\r"
+    end
+  end
+end

data/lib/ruby_wasm/build/executor.rb ADDED Viewed

@@ -0,0 +1,187 @@
+module RubyWasm
+  # Build executor to run the actual build commands.
+  class BuildExecutor
+    attr_reader :process_count
+    def initialize(verbose: false, process_count: nil)
+      @verbose = verbose
+      @github_actions_markup = ENV["ENABLE_GITHUB_ACTIONS_MARKUP"] != nil
+      __skip__ =
+        begin
+          require "etc"
+          @process_count = process_count || Etc.nprocessors
+        rescue LoadError
+          @process_count = process_count || 1
+        end
+    end
+    def system(*args, chdir: nil, env: nil)
+      require "open3"
+      _print_command(args, env)
+      # @type var kwargs: Hash[Symbol, untyped]
+      kwargs = {}
+      kwargs[:chdir] = chdir if chdir
+      args = args.to_a.map(&:to_s)
+      # TODO: Remove __skip__ once we have open3 RBS definitions.
+      __skip__ =
+        if @verbose || !$stdout.tty?
+          kwargs[:exception] = true
+          if env
+            Kernel.system(env, *args, **kwargs)
+          else
+            Kernel.system(*args, **kwargs)
+          end
+        else
+          printer = StatusPrinter.new
+          block =
+            proc do |stdin, stdout, stderr, wait_thr|
+              mux = Mutex.new
+              out = String.new
+              err = String.new
+              readers =
+                [
+                  [stdout, :stdout, out],
+                  [stderr, :stderr, err]
+                ].map do |io, name, str|
+                  reader =
+                    Thread.new do
+                      while (line = io.gets)
+                        mux.synchronize do
+                          printer.send(name, line)
+                          str << line
+                        end
+                      end
+                    end
+                  reader.report_on_exception = false
+                  reader
+                end
+              readers.each(&:join)
+              [out, err, wait_thr.value]
+            end
+          begin
+            stdout, stderr, status =
+              if env
+                Open3.popen3(env, *args, **kwargs, &block)
+              else
+                Open3.popen3(*args, **kwargs, &block)
+              end
+            unless status.success?
+              $stderr.puts stdout
+              $stderr.puts stderr
+              cmd_to_print = args.map { |a| "'#{a}'" }.join(" ")
+              raise "Command failed with status (#{status.exitstatus}): #{cmd_to_print}"
+            end
+          ensure
+            printer.done
+          end
+        end
+      return
+    rescue => e
+      $stdout.flush
+      $stderr.puts "Try running with `rake --verbose` for more complete output."
+      raise e
+    end
+    def begin_section(klass, name, note)
+      message = "\e[1;36m==>\e[0m \e[1m#{klass}(#{name}) -- #{note}\e[0m"
+      if @github_actions_markup
+        puts "::group::#{message}"
+      else
+        puts message
+      end
+      # Record the start time
+      @start_times ||= Hash.new
+      @start_times[[klass, name]] = Time.now
+      $stdout.flush
+    end
+    def end_section(klass, name)
+      took = Time.now - @start_times[[klass, name]]
+      puts "::endgroup::" if @github_actions_markup
+      puts "\e[1;36m==>\e[0m \e[1m#{klass}(#{name}) -- done in #{took.round(2)}s\e[0m"
+    end
+    def rm_rf(list)
+      FileUtils.rm_rf(list)
+    end
+    def rm_f(list)
+      FileUtils.rm_f(list)
+    end
+    def cp_r(src, dest)
+      FileUtils.cp_r(src, dest)
+    end
+    def mv(src, dest)
+      FileUtils.mv(src, dest)
+    end
+    def mkdir_p(list)
+      FileUtils.mkdir_p(list)
+    end
+    def write(path, data)
+      File.write(path, data)
+    end
+    private
+    def _print_command(args, env)
+      require "shellwords"
+      # Bold cyan
+      print "\e[1;36m  ==>\e[0m "
+      print "env " + env.map { |k, v| "#{k}=#{v}" }.join(" ") + " " if env
+      print args.map { |arg| Shellwords.escape(arg.to_s) }.join(" ") + "\n"
+    end
+  end
+  # Human readable status printer for the build.
+  class StatusPrinter
+    def initialize
+      @mutex = Mutex.new
+      @counter = 0
+      @indicators = "|/-\\"
+    end
+    def stdout(message)
+      require "io/console"
+      @mutex.synchronize do
+        $stdout.print "\e[K"
+        first_line = message.lines(chomp: true).first || ""
+        # Make sure we don't line-wrap the output
+        size =
+          __skip__ =
+            IO.respond_to?(:console_size) ? IO.console_size : IO.console.winsize
+        terminal_width = size[1].to_i.nonzero? || 80
+        width_limit = terminal_width / 2 - 3
+        if first_line.length > width_limit
+          first_line = (first_line[0..width_limit - 5] || "") + "..."
+        end
+        indicator = @indicators[@counter] || " "
+        to_print = "  " + indicator + " " + first_line
+        $stdout.print to_print
+        $stdout.print "\e[1A\n"
+        @counter += 1
+        @counter = 0 if @counter >= @indicators.length
+      end
+    end
+    def stderr(message)
+      @mutex.synchronize { $stdout.print message }
+    end
+    def done
+      @mutex.synchronize { $stdout.print "\e[K" }
+    end
+  end
+end

data/lib/ruby_wasm/build/product/baseruby.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require_relative "./product"
+module RubyWasm
+  class BaseRubyProduct < BuildProduct
+    def initialize(build_dir, source)
+      @build_dir = build_dir
+      @source = source
+      @channel = source.name
+    end
+    def product_build_dir
+      File.join(@build_dir, RbConfig::CONFIG["host"], "baseruby-#{@channel}")
+    end
+    def install_dir
+      File.join(product_build_dir, "opt")
+    end
+    def name
+      "baseruby-#{@channel}"
+    end
+    def build(executor)
+      executor.mkdir_p product_build_dir
+      @source.build(executor)
+      return if Dir.exist?(install_dir)
+      executor.system @source.configure_file,
+                      "--prefix=#{install_dir}",
+                      "--disable-install-doc",
+                      chdir: product_build_dir
+      executor.system "make",
+                      "-j#{executor.process_count}",
+                      "install",
+                      chdir: product_build_dir
+    end
+  end
+end