ruby_wasm 2.5.0-x64-mingw-ucrt

data/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "ruby.wasm",
+    "private": true,
+    "workspaces": [
+        "packages/npm-packages/*"
+    ],
+    "devDependencies": {
+        "@playwright/test": "^1.40.1",
+        "@rollup/plugin-json": "^6.0.1",
+        "rollup": "^4.6.1"
+    }
+}

data/rakelib/check.rake

@@ -0,0 +1,37 @@
+namespace :check do
+  wit_bindgen = RubyWasm::WitBindgen.new(build_dir: "build")
+  task :install_wit_bindgen do
+    wit_bindgen.install
+  end
+  task bindgen_c: :install_wit_bindgen do
+    wits = [
+      %w[packages/gems/js/ext/witapi/bindgen/rb-abi-guest.wit --export],
+      %w[packages/gems/js/ext/js/bindgen/rb-js-abi-host.wit --import]
+    ]
+    wits.each do |wit|
+      path, mode = wit
+      sh "#{wit_bindgen.bin_path} guest c #{mode} #{path} --out-dir #{File.dirname(path)}"
+    end
+  end
+
+  task bindgen_js: :install_wit_bindgen do
+    sh *[
+         wit_bindgen.bin_path,
+         "host",
+         "js",
+         "--import",
+         "packages/gems/js/ext/witapi/bindgen/rb-abi-guest.wit",
+         "--export",
+         "packages/gems/js/ext/js/bindgen/rb-js-abi-host.wit",
+         "--out-dir",
+         "packages/npm-packages/ruby-wasm-wasi/src/bindgen"
+       ]
+  end
+
+  desc "Check wit-bindgen'ed sources are up-to-date"
+  task bindgen: %i[bindgen_c bindgen_js]
+
+  task :type do
+    sh "bundle exec steep check"
+  end
+end

data/rakelib/ci.rake

@@ -0,0 +1,152 @@
+def latest_build_sources
+  BUILD_SOURCES
+    .filter_map do |name|
+      src = RubyWasm::Packager.build_source_aliases(LIB_ROOT)[name]
+      case src[:type]
+      when "github"
+        url = "repos/#{src[:repo]}/commits/#{src[:rev]}"
+        revision = JSON.parse(`gh api #{url}`)
+        [name, revision["sha"]]
+      when "tarball"
+        nil
+      else
+        raise "#{src[:type]} is not supported to pin source revision"
+      end
+    end
+    .to_h
+end
+
+def release_note
+  output = <<EOS
+| channel | source |
+|:-------:|:------:|
+EOS
+
+  BUILD_SOURCES.each do |name|
+    source = RubyWasm::Packager.build_source_aliases(LIB_ROOT)[name]
+    case source[:type]
+    when "github"
+      output +=
+        "| #{name} | [`#{source[:repo]}@#{source[:rev]}`](https://github.com/ruby/ruby/tree/#{source[:rev]}) |\n"
+    when "tarball"
+      output += "| #{name} | #{source[:url]} |\n"
+    else
+      raise "unknown source type: #{source[:type]}"
+    end
+  end
+  output
+end
+
+def sh_or_warn(*cmd)
+  sh *cmd do |ok, status|
+    unless ok
+      warn "Command failed with status (#{status.exitstatus}): #{cmd.join ""}"
+    end
+  end
+end
+
+def rake_task_matrix
+  require "pathname"
+  ruby_cache_keys = {}
+  BUILD_TASKS.each { |build| ruby_cache_keys[build.name] = build.hexdigest }
+  build_entries =
+    BUILD_TASKS.map do |build|
+      {
+        task: "build:#{build.name}",
+        artifact:
+          Pathname.new(build.artifact).relative_path_from(LIB_ROOT).to_s,
+        artifact_name: File.basename(build.artifact, ".tar.gz"),
+        builder: build.target,
+        rubies_cache_key: ruby_cache_keys[build.name]
+      }
+    end
+  npm_entries =
+    NPM_PACKAGES.map do |pkg|
+      entry = {
+        task: "npm:#{pkg[:name]}",
+        prerelease: "npm:configure_prerelease",
+        artifact: "packages/npm-packages/#{pkg[:name]}/#{pkg[:name]}-*.tgz",
+        artifact_name: "npm-#{pkg[:name]}",
+        builder: pkg[:target],
+        rubies_cache_key: npm_pkg_rubies_cache_key(pkg)
+      }
+      # Run tests only if the package has 'test' script
+      package_json =
+        JSON.parse(
+          File.read("packages/npm-packages/#{pkg[:name]}/package.json")
+        )
+      if package_json["scripts"] && package_json["scripts"]["test"]
+        entry[:test] = "npm:#{pkg[:name]}:check"
+      end
+      entry
+    end
+  standalone_entries =
+    STANDALONE_PACKAGES.map do |pkg|
+      {
+        task: "standalone:#{pkg[:name]}",
+        artifact: "packages/standalone/#{pkg[:name]}/dist",
+        artifact_name: "standalone-#{pkg[:name]}",
+        builder: "wasm32-unknown-wasi",
+        rubies_cache_key: ruby_cache_keys[pkg[:build]]
+      }
+    end
+  { build: build_entries, npm: npm_entries, standalone: standalone_entries }
+end
+
+namespace :ci do
+  task :rake_task_matrix do
+    print JSON.generate(rake_task_matrix.flat_map { |_, entries| entries })
+  end
+
+  task :pin_build_manifest do
+    content = JSON.generate({ ruby_revisions: latest_build_sources })
+    File.write("build_manifest.json", content)
+  end
+
+  desc "Fetch artifacts of a run of GitHub Actions"
+  task :fetch_artifacts, [:run_id] do |t, args|
+    RubyWasm::Toolchain.check_executable("gh")
+
+    artifacts =
+      JSON.load(
+        `gh api repos/{owner}/{repo}/actions/runs/#{args[:run_id]}/artifacts`
+      )
+    matrix = rake_task_matrix.flat_map { |_, entries| entries }
+    release_artifacts = matrix.map { |entry| entry[:artifact_name] }
+    artifacts =
+      artifacts["artifacts"].filter { release_artifacts.include?(_1["name"]) }
+    mkdir_p "release"
+    Dir.chdir("release") do
+      artifacts.each do |artifact|
+        url = artifact["archive_download_url"]
+        sh "gh api #{url} > #{artifact["name"]}.zip"
+        mkdir_p artifact["name"]
+        sh "unzip #{artifact["name"]}.zip -d #{artifact["name"]}"
+        rm "#{artifact["name"]}.zip"
+      end
+    end
+  end
+
+  desc "Publish artifacts as a GitHub Release"
+  task :publish, [:tag] do |t, args|
+    RubyWasm::Toolchain.check_executable("gh")
+
+    nightly = /^\d{4}-\d{2}-\d{2}-.$/.match?(args[:tag])
+    matrix = rake_task_matrix
+    files =
+      matrix
+        .flat_map { |_, entries| entries }
+        .map { |entry| "release/#{entry[:artifact_name]}/*" }
+    File.open("release/note.md", "w") { |f| f.print release_note }
+    matrix[:npm].each do |task|
+      artifact = task[:artifact_name]
+      tarball = Dir.glob("release/#{artifact}/*")
+      next if tarball.empty?
+      tarball = tarball[0]
+      # tolerate failure as a case that has already been released
+      npm_tag = nightly ? "next" : "latest"
+      sh_or_warn %Q(npm publish --tag #{npm_tag} #{tarball})
+    end
+    sh %Q(gh release create #{args[:tag]} --title #{args[:tag]} --notes-file release/note.md #{nightly ? "--prerelease" : ""} #{files.join(" ")})
+  end
+end

data/rakelib/doc.rake

@@ -0,0 +1,29 @@
+require "rdoc/task"
+require "ruby_wasm/version"
+
+RDoc::Task.new do |doc|
+  doc.main = "README.md"
+  doc.title = "ruby.wasm Documentation"
+  doc.rdoc_files =
+    FileList.new %w[
+                   *.md
+                   packages/gems/js/ext/**/*.c
+                   packages/gems/js/lib/**/*.rb
+                 ]
+end
+
+namespace :doc do
+  desc "Update docs/api/javascript.md"
+  task :api_js do
+    sh "npx",
+       "documentation",
+       "readme",
+       "--readme-file",
+       "./packages/npm-packages/ruby-wasm-wasi/README.md",
+       "--section",
+       "API",
+       "--markdown-toc",
+       "false",
+       "./packages/npm-packages/ruby-wasm-wasi/dist/esm/index.js"
+  end
+end

data/rakelib/format.rake

@@ -0,0 +1,35 @@
+namespace :format do
+  begin
+    require "syntax_tree/rake_tasks"
+    SyntaxTree::Rake::WriteTask.new(
+      :ruby,
+      Rake::FileList[
+        "Rakefile",
+        "lib/**/*.rb",
+        "ext/**/*.rb",
+        "test/**/*.rb",
+        "rakelib/**/*.rake",
+        "packages/**/*.rb"
+      ]
+    )
+  rescue LoadError
+  end
+
+  task :js do
+    sh "npm run format", chdir: "packages/npm-packages/ruby-wasm-wasi"
+  end
+
+  task :c do
+    sh "find packages/gems/ ext/ -iname *.h -o -iname *.c | xargs clang-format -i"
+  end
+end
+
+task :format do
+  if Rake::Task.task_defined?("format:ruby")
+    Rake::Task["format:ruby"].invoke
+  else
+    puts "\e[33mSyntaxTree not installed, skipping format:ruby\e[0m"
+  end
+  Rake::Task["format:js"].invoke
+  Rake::Task["format:c"].invoke
+end

data/rakelib/gem.rake

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+begin
+  require "rb_sys/extensiontask"
+
+  gemspec = Gem::Specification.load("ruby_wasm.gemspec")
+  RbSys::ExtensionTask.new("ruby_wasm", gemspec) do |ext|
+    ext.lib_dir = "lib/ruby_wasm"
+  end
+rescue LoadError => e
+  task :compile do
+    $stderr.puts "Skipping compilation of ruby_wasm extension: #{e.message}"
+    exit 1
+  end
+end

data/rakelib/packaging.rake

@@ -0,0 +1,151 @@
+wasi_vfs = RubyWasm::WasiVfsProduct.new(File.join(Dir.pwd, "build"))
+wasi_sdk = TOOLCHAINS["wasi-sdk"]
+tools = {
+  "WASI_VFS_CLI" => File.expand_path(File.join(__dir__, "..", "exe", "rbwasm")),
+  "WASMOPT" => wasi_sdk.wasm_opt
+}
+
+def npm_pkg_build_command(pkg)
+  # Skip if the package does not require building ruby
+  return nil unless pkg[:ruby_version] && pkg[:target]
+  [
+    "bundle",
+    "exec",
+    "rbwasm",
+    "build",
+    "--ruby-version",
+    pkg[:ruby_version],
+    "--target",
+    pkg[:target],
+    "--build-profile",
+    "full"
+  ]
+end
+
+def npm_pkg_rubies_cache_key(pkg)
+  build_command = npm_pkg_build_command(pkg)
+  return nil unless build_command
+  require "open3"
+  cmd = build_command + ["--print-ruby-cache-key"]
+  stdout, status = Open3.capture2(*cmd)
+  unless status.success?
+    raise "Command failed with status (#{status.exitstatus}): #{cmd.join ""}"
+  end
+  require "json"
+  JSON.parse(stdout)["hexdigest"]
+end
+
+namespace :npm do
+  NPM_PACKAGES.each do |pkg|
+    base_dir = Dir.pwd
+    pkg_dir = "#{Dir.pwd}/packages/npm-packages/#{pkg[:name]}"
+
+    namespace pkg[:name] do
+      desc "Build ruby for npm package #{pkg[:name]}"
+      task "ruby" do
+        build_command = npm_pkg_build_command(pkg)
+        # Skip if the package does not require building ruby
+        next unless build_command
+
+        env = {
+          # Share ./build and ./rubies in the same workspace
+          "RUBY_WASM_ROOT" => base_dir
+        }
+        if gemfile_path = pkg[:gemfile]
+          env["BUNDLE_GEMFILE"] = File.join(base_dir, gemfile_path)
+        else
+          # Explicitly disable rubygems integration since Bundler finds
+          # Gemfile in the repo root directory.
+          build_command.push "--disable-gems"
+        end
+        dist_dir = File.join(pkg_dir, "dist")
+        mkdir_p dist_dir
+        if pkg[:target] == "wasm32-unknown-wasi"
+          sh env,
+             *build_command,
+             "--no-stdlib",
+             "-o",
+             File.join(dist_dir, "ruby.wasm")
+          sh env,
+             *build_command,
+             "-o",
+             File.join(dist_dir, "ruby.debug+stdlib.wasm")
+          sh wasi_sdk.wasm_opt,
+             "--strip-debug",
+             File.join(dist_dir, "ruby.wasm"),
+             "-o",
+             File.join(dist_dir, "ruby.wasm")
+          sh wasi_sdk.wasm_opt,
+             "--strip-debug",
+             File.join(dist_dir, "ruby.debug+stdlib.wasm"),
+             "-o",
+             File.join(dist_dir, "ruby+stdlib.wasm")
+        elsif pkg[:target] == "wasm32-unknown-emscripten"
+          sh env, *build_command, "-o", "/dev/null"
+        end
+      end
+
+      desc "Build npm package #{pkg[:name]}"
+      task "build" => ["ruby"] do
+        sh tools, "npm run build", chdir: pkg_dir
+      end
+
+      desc "Check npm package #{pkg[:name]}"
+      task "check" do
+        sh "npm test", chdir: pkg_dir
+      end
+    end
+
+    desc "Make tarball for npm package #{pkg[:name]}"
+    task pkg[:name] do
+      wasi_sdk.install_binaryen
+      Rake::Task["npm:#{pkg[:name]}:build"].invoke
+      sh "npm pack", chdir: pkg_dir
+    end
+  end
+
+  desc "Configure for pre-release"
+  task :configure_prerelease, [:prerel] do |t, args|
+    require "json"
+    prerel = args[:prerel]
+    new_pkgs = {}
+    NPM_PACKAGES.each do |pkg|
+      pkg_dir = "#{Dir.pwd}/packages/npm-packages/#{pkg[:name]}"
+      pkg_json = "#{pkg_dir}/package.json"
+      package = JSON.parse(File.read(pkg_json))
+
+      version = package["version"] + "-#{prerel}"
+      new_pkgs[package["name"]] = version
+      sh *["npm", "pkg", "set", "version=#{version}"], chdir: pkg_dir
+    end
+
+    NPM_PACKAGES.each do |pkg|
+      pkg_dir = "#{Dir.pwd}/packages/npm-packages/#{pkg[:name]}"
+      pkg_json = "#{pkg_dir}/package.json"
+      package = JSON.parse(File.read(pkg_json))
+      (package["dependencies"] || []).each do |dep, _|
+        next unless new_pkgs[dep]
+        sh *["npm", "pkg", "set", "dependencies.#{dep}=#{new_pkgs[dep]}"],
+           chdir: pkg_dir
+      end
+    end
+  end
+
+  desc "Build all npm packages"
+  multitask all: NPM_PACKAGES.map { |pkg| pkg[:name] }
+end
+
+namespace :standalone do
+  STANDALONE_PACKAGES.each do |pkg|
+    pkg_dir = "#{Dir.pwd}/packages/standalone/#{pkg[:name]}"
+
+    desc "Build standalone package #{pkg[:name]}"
+    task "#{pkg[:name]}" => ["build:#{pkg[:build]}"] do
+      wasi_sdk.install_binaryen
+      base_dir = Dir.pwd
+      sh tools,
+         "./build-package.sh #{base_dir}/rubies/ruby-#{pkg[:build]}",
+         chdir: pkg_dir
+    end
+  end
+end

data/rakelib/version.rake

@@ -0,0 +1,40 @@
+def bump_version_npm_package(package, version)
+  require "json"
+  pkg_dir = "#{Dir.pwd}/packages/npm-packages/#{package}"
+  pkg_json = "#{pkg_dir}/package.json"
+  package = JSON.parse(File.read(pkg_json))
+  old_version = package["version"]
+  pkg_name = package["name"]
+  package["version"] = version
+  File.write(pkg_json, JSON.pretty_generate(package) + "\n")
+
+  # Update package-lock.json
+  # Update README.md and other docs
+  `git grep -l #{pkg_name}@#{old_version}`.split.each do |file|
+    content = File.read(file)
+    next_nightly = Date.today.strftime("%Y-%m-%d")
+    content.gsub!(
+      /#{pkg_name}@#{old_version}-\d{4}-\d{2}-\d{2}-a/,
+      "#{pkg_name}@#{version}-#{next_nightly}-a"
+    )
+    content.gsub!(/#{pkg_name}@#{old_version}/, "#{pkg_name}@#{version}")
+    File.write(file, content)
+  end
+end
+
+def bump_version_rb(version_rb, version)
+  version_rb_content = File.read(version_rb)
+  version_rb_content.gsub!(/VERSION = ".+"/, "VERSION = \"#{version}\"")
+  File.write(version_rb, version_rb_content)
+end
+
+task :bump_version, %i[version] do |t, args|
+  version = args[:version] or raise "version is required"
+  bump_version_rb("lib/ruby_wasm/version.rb", version)
+  bump_version_rb("packages/gems/js/lib/js/version.rb", version)
+  NPM_PACKAGES.each { |pkg| bump_version_npm_package(pkg[:name], version) }
+  # Update ./package-lock.json
+  sh "npm install"
+  # Update Gemfile.lock
+  sh "BUNDLE_GEMFILE=packages/npm-packages/ruby-wasm-wasi/Gemfile bundle install"
+end

data/sig/open_uri.rbs

@@ -0,0 +1,4 @@
+# TODO: Upstream OpenURI sigs to rbs/stdlib
+module OpenURI
+  def self.open_uri: [T] (*untyped, **untyped) { (untyped) -> T } -> T
+end