ruby_wasm 2.5.0-x86_64-linux-musl

data/lib/ruby_wasm/build/product/zlib.rb

@@ -0,0 +1,68 @@
+require_relative "./product"
+
+module RubyWasm
+  class ZlibProduct < AutoconfProduct
+    attr_reader :target
+
+    ZLIB_VERSION = "1.3.1"
+
+    def initialize(build_dir, target, toolchain)
+      @build_dir = build_dir
+      @target = target
+      super(target, toolchain)
+    end
+
+    def product_build_dir
+      File.join(@build_dir, target, "zlib-#{ZLIB_VERSION}")
+    end
+
+    def destdir
+      File.join(product_build_dir, "opt")
+    end
+
+    def install_root
+      File.join(destdir, "usr", "local")
+    end
+
+    def name
+      "zlib-#{ZLIB_VERSION}-#{target}"
+    end
+
+    def configure_args
+      args = %w[CHOST=linux]
+
+      args + tools_args
+    end
+
+    def build(executor)
+      return if Dir.exist?(install_root)
+
+      executor.mkdir_p File.dirname(product_build_dir)
+      executor.rm_rf product_build_dir
+      executor.mkdir_p product_build_dir
+
+      tarball_path = File.join(product_build_dir, "zlib-#{ZLIB_VERSION}.tar.gz")
+      executor.system "curl",
+                      "-o",
+                      tarball_path,
+                      "-L",
+                      "https://github.com/madler/zlib/releases/download/v#{ZLIB_VERSION}/zlib-#{ZLIB_VERSION}.tar.gz"
+      executor.system "tar",
+                      "xzf",
+                      tarball_path,
+                      "-C",
+                      product_build_dir,
+                      "--strip-components=1"
+
+      executor.system "env",
+                      *configure_args,
+                      "./configure",
+                      "--static",
+                      chdir: product_build_dir
+      executor.system "make",
+                      "install",
+                      "DESTDIR=#{destdir}",
+                      chdir: product_build_dir
+    end
+  end
+end

data/lib/ruby_wasm/build/product.rb

@@ -0,0 +1,8 @@
+require_relative "product/product"
+require_relative "product/ruby_source"
+require_relative "product/baseruby"
+require_relative "product/zlib"
+require_relative "product/libyaml"
+require_relative "product/openssl"
+require_relative "product/wasi_vfs"
+require_relative "product/crossruby"

data/lib/ruby_wasm/build/toolchain/wit_bindgen.rb

@@ -0,0 +1,31 @@
+module RubyWasm
+  class WitBindgen
+    attr_reader :bin_path
+
+    def initialize(
+      build_dir:,
+      revision: "251e84b89121751f79ac268629e9285082b2596d"
+    )
+      @build_dir = build_dir
+      @tool_dir = File.join(@build_dir, "toolchain", "wit-bindgen")
+      @bin_path = File.join(@tool_dir, "bin", "wit-bindgen")
+      @revision = revision
+    end
+
+    def install
+      return if File.exist?(@bin_path)
+      RubyWasm::Toolchain.check_executable("cargo")
+      Kernel.system(
+        "cargo",
+        "install",
+        "--git",
+        "https://github.com/bytecodealliance/wit-bindgen",
+        "--rev",
+        @revision,
+        "--root",
+        @tool_dir,
+        "wit-bindgen-cli"
+      )
+    end
+  end
+end

data/lib/ruby_wasm/build/toolchain.rb

@@ -0,0 +1,193 @@
+require_relative "./toolchain/wit_bindgen"
+
+module RubyWasm
+  class Toolchain
+    attr_reader :name
+
+    def initialize
+      @tools = {}
+    end
+
+    def find_tool(name)
+      raise "not implemented"
+    end
+
+    def check_envvar(name)
+      raise "missing environment variable: #{name}" if ENV[name].nil?
+    end
+
+    def self.get(target, build_dir = nil)
+      case target
+      when "wasm32-unknown-wasi"
+        return RubyWasm::WASISDK.new(build_dir: build_dir)
+      when "wasm32-unknown-emscripten"
+        return RubyWasm::Emscripten.new
+      else
+        raise "unknown target: #{target}"
+      end
+    end
+
+    def self.find_path(command)
+      (ENV["PATH"] || "")
+        .split(File::PATH_SEPARATOR)
+        .each do |path_dir|
+          bin_path = File.join(path_dir, command)
+          return bin_path if File.executable?(bin_path)
+        end
+      nil
+    end
+
+    def self.check_executable(command)
+      tool = find_path(command)
+      raise "missing executable: #{command}" unless tool
+      tool
+    end
+
+    %i[cc ranlib ld ar].each do |name|
+      define_method(name) do
+        @tools_cache ||= {}
+        @tools_cache[name] ||= find_tool(name)
+        @tools_cache[name]
+      end
+    end
+  end
+
+  class WASISDK < Toolchain
+    def initialize(
+      wasi_sdk_path = ENV["WASI_SDK_PATH"],
+      build_dir: nil,
+      version_major: 20,
+      version_minor: 0,
+      binaryen_version: 108
+    )
+      @wasm_opt_path = Toolchain.find_path("wasm-opt")
+      @need_fetch_wasi_sdk = wasi_sdk_path.nil?
+      @need_fetch_binaryen = @wasm_opt_path.nil?
+
+      if @need_fetch_wasi_sdk
+        if build_dir.nil?
+          raise "build_dir is required when WASI_SDK_PATH is not set"
+        end
+        wasi_sdk_path = File.join(build_dir, "toolchain", "wasi-sdk")
+        @version_major = version_major
+        @version_minor = version_minor
+      end
+
+      if @need_fetch_binaryen
+        if build_dir.nil?
+          raise "build_dir is required when wasm-opt not installed in PATH"
+        end
+        @binaryen_path = File.join(build_dir, "toolchain", "binaryen")
+        @binaryen_version = binaryen_version
+        @wasm_opt_path = File.join(@binaryen_path, "bin", "wasm-opt")
+      end
+
+      @tools = {
+        cc: "#{wasi_sdk_path}/bin/clang",
+        ld: "#{wasi_sdk_path}/bin/clang",
+        ar: "#{wasi_sdk_path}/bin/llvm-ar",
+        ranlib: "#{wasi_sdk_path}/bin/llvm-ranlib"
+      }
+      @wasi_sdk_path = wasi_sdk_path
+      @name = "wasi-sdk"
+    end
+
+    def find_tool(name)
+      if !File.exist?(@tools[name]) && !ENV["WASI_SDK_PATH"].nil?
+        raise "missing tool '#{name}' at #{@tools[name]}"
+      end
+      @tools[name]
+    end
+
+    def wasm_opt
+      @wasm_opt_path
+    end
+
+    def wasi_sdk_path
+      @wasi_sdk_path
+    end
+
+    def download_url(version_major, version_minor)
+      version = "#{version_major}.#{version_minor}"
+      assets = [
+        [/x86_64-linux/, "wasi-sdk-#{version}-linux.tar.gz"],
+        [/(arm64e?|x86_64)-darwin/, "wasi-sdk-#{version}-macos.tar.gz"]
+      ]
+      asset = assets.find { |os, _| os =~ RUBY_PLATFORM }&.at(1)
+      if asset.nil?
+        raise "unsupported platform for fetching WASI SDK: #{RUBY_PLATFORM}"
+      end
+      "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-#{version_major}/#{asset}"
+    end
+
+    def binaryen_download_url(version)
+      assets = [
+        [
+          /x86_64-linux/,
+          "binaryen-version_#{@binaryen_version}-x86_64-linux.tar.gz"
+        ],
+        [
+          /x86_64-darwin/,
+          "binaryen-version_#{@binaryen_version}-x86_64-macos.tar.gz"
+        ],
+        [
+          /arm64e?-darwin/,
+          "binaryen-version_#{@binaryen_version}-arm64-macos.tar.gz"
+        ]
+      ]
+      asset = assets.find { |os, _| os =~ RUBY_PLATFORM }&.at(1)
+      if asset.nil?
+        raise "unsupported platform for fetching Binaryen: #{RUBY_PLATFORM}"
+      end
+      "https://github.com/WebAssembly/binaryen/releases/download/version_#{@binaryen_version}/#{asset}"
+    end
+
+    def install_wasi_sdk
+      return unless @need_fetch_wasi_sdk
+      wasi_sdk_tarball =
+        File.join(File.dirname(@wasi_sdk_path), "wasi-sdk.tar.gz")
+      unless File.exist? wasi_sdk_tarball
+        FileUtils.mkdir_p File.dirname(wasi_sdk_tarball)
+        system "curl -L -o #{wasi_sdk_tarball} #{self.download_url(@version_major, @version_minor)}"
+      end
+      unless File.exist? @wasi_sdk_path
+        FileUtils.mkdir_p @wasi_sdk_path
+        system "tar -C #{@wasi_sdk_path} --strip-component 1 -xzf #{wasi_sdk_tarball}"
+      end
+    end
+
+    def install_binaryen
+      return unless @need_fetch_binaryen
+      binaryen_tarball = File.expand_path("../binaryen.tar.gz", @binaryen_path)
+      unless File.exist? binaryen_tarball
+        FileUtils.mkdir_p File.dirname(binaryen_tarball)
+        system "curl -L -o #{binaryen_tarball} #{self.binaryen_download_url(@binaryen_version)}"
+      end
+
+      unless File.exist? @binaryen_path
+        FileUtils.mkdir_p @binaryen_path
+        system "tar -C #{@binaryen_path} --strip-component 1 -xzf #{binaryen_tarball}"
+      end
+    end
+
+    def install
+      install_wasi_sdk
+      install_binaryen
+    end
+  end
+
+  class Emscripten < Toolchain
+    def initialize
+      @tools = { cc: "emcc", ld: "emcc", ar: "emar", ranlib: "emranlib" }
+      @name = "emscripten"
+    end
+
+    def install
+    end
+
+    def find_tool(name)
+      Toolchain.check_executable(@tools[name])
+      @tools[name]
+    end
+  end
+end

data/lib/ruby_wasm/build.rb

@@ -0,0 +1,88 @@
+require_relative "build/build_params"
+require_relative "build/product"
+require_relative "build/toolchain"
+require_relative "build/executor"
+
+class RubyWasm::Build
+  # Source to build from.
+  attr_reader :source
+
+  # Target to build for.
+  attr_reader :target
+
+  # Toolchain for the build.
+  # Defaults to the Toolchain.get for the target.
+  attr_reader :toolchain
+
+  # LibYAML product to build.
+  attr_reader :libyaml
+
+  # zlib product to build.
+  attr_reader :zlib
+
+  # wasi-vfs product used by the crossruby.
+  attr_reader :wasi_vfs
+
+  # BaseRuby product to build.
+  attr_reader :baseruby
+
+  # CrossRuby product to build.
+  attr_reader :crossruby
+
+  def initialize(
+    name,
+    target:,
+    src:,
+    toolchain:,
+    build_dir:,
+    rubies_dir:,
+    **options
+  )
+    @target = target
+    @build_dir = build_dir
+    @rubies_dir = rubies_dir
+    @toolchain = (toolchain || RubyWasm::Toolchain.get(target, @build_dir))
+
+    @libyaml = RubyWasm::LibYAMLProduct.new(@build_dir, @target, @toolchain)
+    @zlib = RubyWasm::ZlibProduct.new(@build_dir, @target, @toolchain)
+    @wasi_vfs = RubyWasm::WasiVfsProduct.new(@build_dir)
+    @source = RubyWasm::BuildSource.new(src, @build_dir)
+    @baseruby = RubyWasm::BaseRubyProduct.new(@build_dir, @source)
+    @openssl = RubyWasm::OpenSSLProduct.new(@build_dir, @target, @toolchain)
+
+    build_params =
+      RubyWasm::BuildParams.new(
+        name: name,
+        target: target,
+        default_exts: options[:default_exts]
+      )
+
+    @crossruby =
+      RubyWasm::CrossRubyProduct.new(
+        build_params,
+        @build_dir,
+        @rubies_dir,
+        @baseruby,
+        @source,
+        @toolchain
+      )
+
+    @crossruby.with_libyaml @libyaml
+    @crossruby.with_zlib @zlib
+    @crossruby.with_wasi_vfs @wasi_vfs
+    @crossruby.with_openssl @openssl
+  end
+
+  def cache_key(digest)
+    @source.cache_key(digest)
+    @crossruby.cache_key(digest)
+    digest << @build_dir
+    digest << @rubies_dir
+    digest << @target
+    digest << @toolchain.name
+    digest << @libyaml.name
+    digest << @zlib.name
+    digest << @openssl.name
+    digest << @wasi_vfs.name
+  end
+end

data/lib/ruby_wasm/cli.rb

@@ -0,0 +1,217 @@
+require "optparse"
+require "rbconfig"
+
+module RubyWasm
+  class CLI
+    def initialize(stdout:, stderr:)
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    def run(args)
+      available_commands = %w[build pack]
+      parser =
+        OptionParser.new do |opts|
+          opts.banner = <<~USAGE
+          Usage: rbwasm [options...] [command]
+
+          Available commands: #{available_commands.join(", ")}
+        USAGE
+          opts.version = RubyWasm::VERSION
+          opts.on("-h", "--help", "Prints this help") do
+            @stderr.puts opts
+            exit
+          end
+          opts.on("--log-level LEVEL", "Log level") do |level|
+            RubyWasm.log_level = level.to_sym
+          end
+        end
+      parser.order!(args)
+
+      command = args.shift
+      case command
+      when "build"
+        build(args)
+      when "pack"
+        pack(args)
+      else
+        @stderr.puts "Unknown command: #{command}"
+        @stderr.puts parser
+        exit
+      end
+    end
+
+    def build(args)
+      # @type var options: Hash[Symbol, untyped]
+      options = {
+        save_temps: false,
+        optimize: false,
+        remake: false,
+        reconfigure: false,
+        clean: false,
+        ruby_version: "3.3",
+        target_triplet: "wasm32-unknown-wasi",
+        profile: "full",
+        stdlib: true,
+        disable_gems: false
+      }
+      OptionParser
+        .new do |opts|
+          opts.banner = "Usage: rbwasm componentize [options]"
+          opts.on("-h", "--help", "Prints this help") do
+            @stdout.puts opts
+            exit
+          end
+
+          opts.on("--save-temps", "Save temporary files") do
+            options[:save_temps] = true
+          end
+
+          opts.on("--ruby-version VERSION", "Ruby version") do |version|
+            options[:ruby_version] = version
+          end
+
+          opts.on("--target TRIPLET", "Target triplet") do |triplet|
+            options[:target_triplet] = triplet
+          end
+
+          opts.on(
+            "--build-profile PROFILE",
+            "Build profile. full or minimal"
+          ) { |profile| options[:profile] = profile }
+
+          opts.on("--optimize", "Optimize the output") do
+            options[:optimize] = true
+          end
+
+          opts.on("--remake", "Re-execute make for Ruby") do
+            options[:remake] = true
+          end
+
+          opts.on("--reconfigure", "Re-execute configure for Ruby") do
+            options[:reconfigure] = true
+          end
+
+          opts.on("--clean", "Clean build artifacts") { options[:clean] = true }
+
+          opts.on("-o", "--output FILE", "Output file") do |file|
+            options[:output] = file
+          end
+
+          opts.on("--[no-]stdlib", "Include stdlib") do |stdlib|
+            options[:stdlib] = stdlib
+          end
+
+          opts.on("--disable-gems", "Disable gems") do
+            options[:disable_gems] = true
+          end
+
+          opts.on("--format FORMAT", "Output format") do |format|
+            options[:format] = format
+          end
+
+          opts.on("--print-ruby-cache-key", "Print Ruby cache key") do
+            options[:print_ruby_cache_key] = true
+          end
+        end
+        .parse!(args)
+
+      verbose = RubyWasm.logger.level == :debug
+      executor = RubyWasm::BuildExecutor.new(verbose: verbose)
+      packager = self.derive_packager(options)
+
+      if options[:print_ruby_cache_key]
+        self.do_print_ruby_cache_key(packager)
+        exit
+      end
+
+      unless options[:output]
+        @stderr.puts "Output file is not specified"
+        exit 1
+      end
+
+      require "tmpdir"
+
+      if options[:save_temps]
+        tmpdir = Dir.mktmpdir
+        self.do_build(executor, tmpdir, packager, options)
+        @stderr.puts "Temporary files are saved to #{tmpdir}"
+        exit
+      else
+        Dir.mktmpdir do |tmpdir|
+          self.do_build(executor, tmpdir, packager, options)
+        end
+      end
+    end
+
+    def pack(args)
+      self.require_extension
+      RubyWasmExt::WasiVfs.run_cli([$0, "pack", *args])
+    end
+
+    private
+
+    def build_config(options)
+      config = { target: options[:target_triplet], src: options[:ruby_version] }
+      case options[:profile]
+      when "full"
+        config[:default_exts] = RubyWasm::Packager::ALL_DEFAULT_EXTS
+        env_additional_exts = ENV["RUBY_WASM_ADDITIONAL_EXTS"] || ""
+        unless env_additional_exts.empty?
+          config[:default_exts] += "," + env_additional_exts
+        end
+      when "minimal"
+        config[:default_exts] = ""
+      else
+        RubyWasm.logger.error "Unknown profile: #{options[:profile]} (available: full, minimal)"
+        exit 1
+      end
+      config[:suffix] = "-#{options[:profile]}"
+      config
+    end
+
+    def derive_packager(options)
+      __skip__ =
+        if defined?(Bundler) && !options[:disable_gems]
+          definition = Bundler.definition
+        end
+      RubyWasm::Packager.new(build_config(options), definition)
+    end
+
+    def do_print_ruby_cache_key(packager)
+      ruby_core_build = packager.ruby_core_build
+      require "digest"
+      digest = Digest::SHA256.new
+      ruby_core_build.cache_key(digest)
+      hexdigest = digest.hexdigest
+      require "json"
+      @stdout.puts JSON.generate(
+                     hexdigest: hexdigest,
+                     artifact: ruby_core_build.artifact
+                   )
+    end
+
+    def do_build(executor, tmpdir, packager, options)
+      self.require_extension
+      wasm_bytes = packager.package(executor, tmpdir, options)
+      RubyWasm.logger.info "Size: #{SizeFormatter.format(wasm_bytes.size)}"
+      case options[:output]
+      when "-"
+        @stdout.write wasm_bytes.pack("C*")
+      else
+        File.binwrite(options[:output], wasm_bytes.pack("C*"))
+        RubyWasm.logger.debug "Wrote #{options[:output]}"
+      end
+    end
+
+    def require_extension
+      # Tries to require the extension for the given Ruby version first
+      begin
+        RUBY_VERSION =~ /(\d+\.\d+)/
+        require_relative "#{Regexp.last_match(1)}/ruby_wasm.so"
+      rescue LoadError
+        require_relative "ruby_wasm.so"
+      end
+    end
+  end
+end