ruby_wasm_ic_minimal 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc18f5b18fe43d51c78dccd18e8065cb1dc22d3ed9dbfcec7e03e34c84cbeb99
+  data.tar.gz: 310d256e55b950d1091d0093f90707a189bccde91063171dda295294e4a4a985
+SHA512:
+  metadata.gz: 8d1d198fd172fc2fda92b76d7da1e1ed8c3de301cc90b5ccd25f3e661bbf448c3cdb546388b58d8d2d2da040d2501fa5b041d92f8d81896abdac74c5fa5b3ff2
+  data.tar.gz: 4173adeef1c2ee9435dcc27bbb1c110f07aaad4a9f4d744737f8f4ce898a7bb4220612c791f935ad809561115c69685679b0ad5b3070f1e2c2b21187e25b738f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the ruby_wasm_builder authors
+
+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

@@ -0,0 +1,64 @@
+# ruby_wasm_ic_minimal
+
+Pure-Ruby stand-ins for four things a **`minimal`** Ruby canister lacks, for
+canisters packed by [ruby_wasm_builder](https://gitlab.com/phrug/ruby_wasm_builder)
+on its `minimal` Build. That Build links no C extension and defines no
+`Encoding` constant, and Rack and Roda need all four:
+
+| file | stands in for | why Rack needs it |
+| --- | --- | --- |
+| `encoding_constants.rb` | `Encoding::UTF_8`, `US_ASCII`, `ASCII_8BIT` (and `BINARY`, `ASCII`) | it decodes every query parameter as UTF-8 |
+| `stringio.rb` | `StringIO` (a C extension in CRuby) | `rack.input`, `Rack::MockRequest` |
+| `strscan.rb` | `StringScanner` (a C extension) | the multipart parser, loaded by `Rack::Request` |
+| `date.rb` | `date` (its work is the C extension `date_core`) | only because `time` requires it; **a stub** |
+
+`stringio.rb` and `strscan.rb` are checked against CRuby's C extensions on
+MRI, operation by operation, and `StringScanner` keeps Ruby 3.3's meaning (a
+`String` in `scan_until` is a `TypeError`). `date.rb` is a stub: Rack only
+formats and reads HTTP dates, which need nothing from `Date`; `Time.parse`,
+`Time.strptime` and `Date` itself raise `NotImplementedError` when called.
+
+## Only in a `minimal` canister
+
+**Do not put this gem in a Gemfile.** Each file shadows a real library by its
+name, and `date.rb` is a stub. So every file refuses to load anywhere but a
+`minimal` canister, raising `LoadError`. A `minimal` canister is one where the
+builder's wrapper gem has defined `IC::DATA_DIR` and the core knows no more
+than its three built-in encodings (`Encoding.list.size <= 3`). On the `full`
+Build, which links the real libraries and every encoding, it refuses too:
+carry none of it there.
+
+## Carrying it
+
+Copy its `lib/` into your Application and put it first on the load path,
+before Rack is required:
+
+```bash
+gem fetch ruby_wasm_ic_minimal && gem unpack ruby_wasm_ic_minimal-*.gem
+cp -r ruby_wasm_ic_minimal-*/lib my_app/vendor/ruby_wasm_ic_minimal
+```
+
+```ruby
+# app.rb
+here = __dir__
+$LOAD_PATH.unshift(File.join(here, "vendor/ruby_wasm_ic_minimal"), File.join(here, "vendor/rack"))
+require "encoding_constants"
+require "stringio"
+require "rack"
+```
+
+`require "ruby_wasm_ic_minimal"` loads all four at once. Otherwise Rack's own
+`require "strscan"` and `time`'s `require "date"` find them by name.
+
+## Development
+
+The gem lives in the ruby_wasm_builder repository, `gems/ruby_wasm_ic_minimal/`. Its
+specs are in that repository's `spec/gems/`, and run with the builder's suite,
+including the 0.7.0 `roda_on_minimal` Script played as `minimal` with this
+gem in place of the Challenge's own `carried/` files.
+
+**Not yet observed on a canister:** that `Encoding.list.size` is 3 or less on
+`minimal`. The first deploy that carries this gem checks it; if the guard
+refuses there, the rule is what needs changing.
+
+MIT licensed.

data/lib/date.rb

@@ -0,0 +1,22 @@
+# date.rb (ruby_wasm_ic_minimal): a stand-in for CRuby's `date`, whose work is done by the
+# C extension date_core, which the `minimal` Build does not link. `time`
+# requires `date` at load, and Rack requires `time`, so without this file
+# `require "rack"` fails. Rack only formats and reads HTTP dates
+# (Time#httpdate, Time.httpdate), and those need nothing from Date.
+#
+# What needs a real Date fails here, loudly and only when called:
+# Time.parse and Time.strptime (through Date._parse and Date._strptime), and
+# Date itself. Under `full` this file is not carried.
+require_relative "ruby_wasm_ic_minimal/guard"
+RubyWasmIcMinimal.guard!("date")
+class Date
+  def self.unavailable(what)
+    raise NotImplementedError, "#{what} needs the date C extension, which the minimal Build lacks"
+  end
+
+  def self._parse(*) = unavailable("Date._parse (Time.parse)")
+  def self._strptime(*) = unavailable("Date._strptime (Time.strptime)")
+  def self.new(*) = unavailable("Date.new")
+  def self.today(*) = unavailable("Date.today")
+  def self.parse(*) = unavailable("Date.parse")
+end

data/lib/encoding_constants.rb

@@ -0,0 +1,16 @@
+# encoding_constants.rb (ruby_wasm_ic_minimal): the Encoding constants a canister lacks.
+# The `minimal` Build has three encodings, UTF-8, US-ASCII and ASCII-8BIT,
+# and no constant naming any of them (ADR-0060). Rack names
+# Encoding::UTF_8 to decode every query parameter, and `cgi/util` names it as
+# it loads. Each is found here from a literal, without naming a constant:
+# a "\u" escape is always UTF-8, a Symbol's text US-ASCII, String#b binary.
+# Only these three: there is no transcoding to any other (ADR-0053).
+require_relative "ruby_wasm_ic_minimal/guard"
+RubyWasmIcMinimal.guard!("encoding_constants")
+class Encoding
+  UTF_8      = "\u0000".encoding unless const_defined?(:UTF_8, false)
+  US_ASCII   = :a.to_s.encoding unless const_defined?(:US_ASCII, false)
+  ASCII_8BIT = "".b.encoding unless const_defined?(:ASCII_8BIT, false)
+  BINARY     = ASCII_8BIT unless const_defined?(:BINARY, false)
+  ASCII      = US_ASCII unless const_defined?(:ASCII, false)
+end

data/lib/ruby_wasm_ic_minimal/guard.rb

@@ -0,0 +1,24 @@
+# The guard every stand-in in ruby_wasm_ic_minimal requires first. A stand-in shadows a
+# real library by its name (`date`, `stringio`, `strscan`), and `date.rb` here
+# is a stub, so loading one anywhere but a `minimal` canister would quietly
+# take the real library away. The guard refuses that instead, with LoadError.
+#
+# A `minimal` canister is one where the wrapper gem has defined IC::DATA_DIR
+# (every canister packed by ruby_wasm_builder) and the core knows no more than
+# its three built-in encodings (UTF-8, US-ASCII, ASCII-8BIT). It counts the
+# encodings rather than looking for Encoding::UTF_8, which this gem's own
+# encoding_constants.rb defines. Decided once, at the first stand-in loaded,
+# and kept in RubyWasmIcMinimal::ON_MINIMAL; a test harness may set that constant
+# first (the builder's MRI player does, for `minimal: true`).
+module RubyWasmIcMinimal
+  unless const_defined?(:ON_MINIMAL, false)
+    ON_MINIMAL = !defined?(IC::DATA_DIR).nil? && Encoding.list.size <= 3
+  end
+
+  def self.guard!(feature)
+    return if ON_MINIMAL
+
+    raise LoadError, "ruby_wasm_ic_minimal's #{feature} is a stand-in only for a minimal canister, and this is not " \
+                     "one; remove ruby_wasm_ic_minimal from $LOAD_PATH so the real #{feature} loads"
+  end
+end

data/lib/ruby_wasm_ic_minimal/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyWasmIcMinimal
+  VERSION = "0.1.1"
+end

data/lib/ruby_wasm_ic_minimal.rb

@@ -0,0 +1,10 @@
+# ruby_wasm_ic_minimal: pure-Ruby stand-ins for what Rack and Roda need and a `minimal`
+# canister lacks, for canisters packed by ruby_wasm_builder on its `minimal`
+# Build only. Requiring this file loads all four; each can be required alone
+# by its library's own name. Each refuses to load anywhere else (see
+# ruby_wasm_ic_minimal/guard.rb).
+require_relative "ruby_wasm_ic_minimal/version"
+require_relative "encoding_constants"
+require_relative "stringio"
+require_relative "strscan"
+require_relative "date"

data/lib/stringio.rb

@@ -0,0 +1,270 @@
+# stringio.rb (ruby_wasm_ic_minimal): a pure-Ruby StringIO for the `minimal` Build, where
+# CRuby's is a C extension it does not link. Rack names it for request bodies
+# (rack.input) and in Rack::MockRequest; an Application may use it as any
+# in-memory IO.
+#
+# The common reading and writing API, by bytes, with CRuby's meaning. Not
+# here: the encoding conversions (set_encoding only tags), fcntl, and the
+# *_nonblock methods.
+require_relative "ruby_wasm_ic_minimal/guard"
+RubyWasmIcMinimal.guard!("stringio")
+class StringIO
+  include Enumerable
+
+  attr_reader :string, :lineno
+  attr_writer :lineno
+
+  def self.open(*args)
+    io = new(*args)
+    return io unless block_given?
+
+    begin
+      yield io
+    ensure
+      io.close
+    end
+  end
+
+  def initialize(string = +"", mode = nil)
+    @string = string
+    @pos = 0
+    @lineno = 0
+    @closed_read = @closed_write = false
+    @readonly = string.frozen? || mode.to_s.start_with?("r") && !mode.to_s.include?("+")
+    @string.replace("") if mode.to_s.start_with?("w") && !@string.frozen?
+    @pos = @string.bytesize if mode.to_s.start_with?("a")
+  end
+
+  def string=(s)
+    @string = s
+    @pos = 0
+    @lineno = 0
+    s
+  end
+
+  def pos = @pos
+  alias tell pos
+
+  def pos=(n)
+    raise Errno::EINVAL, "negative position" if n.negative?
+
+    @pos = n
+  end
+
+  def seek(offset, whence = IO::SEEK_SET)
+    base = case whence
+           when IO::SEEK_SET, :SET then 0
+           when IO::SEEK_CUR, :CUR then @pos
+           when IO::SEEK_END, :END then @string.bytesize
+           else raise Errno::EINVAL, "invalid whence"
+           end
+    self.pos = base + offset
+    0
+  end
+
+  def rewind
+    @pos = 0
+    @lineno = 0
+    0
+  end
+
+  def size = @string.bytesize
+  alias length size
+  def eof? = @pos >= @string.bytesize
+  alias eof eof?
+
+  def read(length = nil, buffer = nil)
+    readable!
+    if length.nil?
+      out = (@string.byteslice(@pos, @string.bytesize - @pos) || "").dup
+      @pos = [@pos, @string.bytesize].max
+      out.force_encoding(@string.encoding)
+    else
+      raise ArgumentError, "negative length #{length} given" if length.negative?
+
+      out = (@string.byteslice(@pos, length) || "").b
+      @pos += out.bytesize
+      return (buffer&.replace("") && nil) if length.positive? && out.empty?
+    end
+    buffer ? buffer.replace(out) : out
+  end
+
+  def read_nonblock(length, buffer = nil, exception: true)
+    out = read(length, buffer)
+    return out unless out.nil?
+    raise EOFError, "end of file reached" if exception
+
+    nil
+  end
+
+  def readpartial(length, buffer = nil)
+    out = read(length, buffer)
+    raise EOFError, "end of file reached" if out.nil?
+
+    out
+  end
+
+  def getc
+    readable!
+    return nil if eof?
+
+    ch = (@string.byteslice(@pos, @string.bytesize - @pos) || "").force_encoding(@string.encoding)[0]
+    @pos += ch.bytesize
+    ch
+  end
+
+  def getbyte
+    readable!
+    return nil if eof?
+
+    b = @string.getbyte(@pos)
+    @pos += 1
+    b
+  end
+
+  def each_byte
+    return enum_for(:each_byte) unless block_given?
+
+    while (b = getbyte)
+      yield b
+    end
+    self
+  end
+
+  def ungetc(s)
+    readable!
+    return nil if s.nil?
+
+    s = s.chr if s.is_a?(Integer)
+    if @pos.zero?
+      @string.prepend(s)
+    else
+      @pos -= s.bytesize
+      @string.bytesplice(@pos, s.bytesize, s)
+    end
+    nil
+  end
+  alias ungetbyte ungetc
+
+  def gets(sep = $/, limit = nil, chomp: false)
+    readable!
+    sep, limit = nil, sep if sep.is_a?(Integer)
+    return nil if eof?
+
+    rest = (@string.byteslice(@pos, @string.bytesize - @pos) || "").force_encoding(@string.encoding)
+    line =
+      if sep.nil?
+        rest
+      elsif sep.empty?
+        rest.sub!(/\A\n+/) { |nl| @pos += nl.bytesize; "" }
+        (i = rest.index(/\n\n+/)) ? rest[0, i] + rest[i..][/\A\n+/] : rest
+      else
+        (i = rest.index(sep)) ? rest[0, i + sep.length] : rest
+      end
+    line = line.byteslice(0, limit) if limit && limit >= 0 && line.bytesize > limit
+    @pos += line.bytesize
+    @lineno += 1
+    $_ = chomp && sep ? line.chomp(sep.empty? ? "\n" : sep) : line
+  end
+
+  def readline(*args, **kw) = gets(*args, **kw) || raise(EOFError, "end of file reached")
+
+  def each_line(sep = $/, limit = nil, chomp: false)
+    return enum_for(:each_line, sep, limit, chomp: chomp) unless block_given?
+
+    while (line = gets(sep, limit, chomp: chomp))
+      yield line
+    end
+    self
+  end
+  alias each each_line
+
+  def readlines(*args, **kw) = each_line(*args, **kw).to_a
+
+  def write(*objs)
+    writable!
+    objs.sum do |obj|
+      s = obj.to_s
+      if @pos > @string.bytesize
+        @string << ("\0" * (@pos - @string.bytesize))
+      end
+      @string.bytesplice(@pos, [s.bytesize, @string.bytesize - @pos].min, s.b.force_encoding(@string.encoding))
+      @pos += s.bytesize
+      s.bytesize
+    end
+  end
+  alias syswrite write
+  alias write_nonblock write
+
+  def <<(obj)
+    write(obj)
+    self
+  end
+
+  def print(*objs)
+    objs = [$_] if objs.empty?
+    objs.each { write(_1) }
+    write($\) if $\
+    nil
+  end
+
+  def puts(*objs)
+    return write("\n") && nil if objs.empty?
+
+    objs.flatten.each do |o|
+      s = o.nil? ? "" : o.to_s
+      write(s.end_with?("\n") ? s : "#{s}\n")
+    end
+    nil
+  end
+
+  def printf(fmt, *args) = write(format(fmt, *args)) && nil
+  def putc(c) = (write(c.is_a?(Integer) ? (c & 0xff).chr : c.to_s[0]) && c)
+
+  def truncate(n)
+    writable!
+    @string.replace(n < @string.bytesize ? @string.byteslice(0, n) : @string + ("\0" * (n - @string.bytesize)))
+    0
+  end
+
+  def close
+    @closed_read = @closed_write = true
+    nil
+  end
+
+  def close_read = (@closed_read = true) && nil
+  def close_write = (@closed_write = true) && nil
+  def closed? = @closed_read && @closed_write
+  def closed_read? = @closed_read
+  def closed_write? = @closed_write
+
+  def binmode
+    @string.force_encoding("".b.encoding) unless @string.frozen?
+    self
+  end
+
+  def set_encoding(*) = self
+  def external_encoding = @string.encoding
+  def internal_encoding = nil
+  def sync = true
+  def sync=(value)
+    value
+  end
+  def flush = self
+  def fsync = 0
+  def fileno = nil
+  def isatty = false
+  alias tty? isatty
+  def pid = nil
+  def fcntl(*) = raise(NotImplementedError, "fcntl")
+
+  private
+
+  def readable!
+    raise IOError, "not opened for reading" if @closed_read
+  end
+
+  def writable!
+    raise IOError, "not opened for writing" if @closed_write || @readonly
+  end
+end

data/lib/strscan.rb

@@ -0,0 +1,197 @@
+# strscan.rb (ruby_wasm_ic_minimal): a pure-Ruby StringScanner for the `minimal` Build,
+# where CRuby's is a C extension it does not link. Rack's multipart parser
+# requires it at load, so Rack::Request cannot load without it, and it is what
+# reads a multipart body.
+#
+# The common API, with CRuby's meaning: positions are byte offsets, a pattern
+# is matched only at the scan pointer (scan, skip, match?, check; a Regexp
+# or a String) or anywhere after it (*_until, exist?; a Regexp only, as in
+# Ruby 3.3). As in CRuby's default mode, the text begins at the pointer: \A
+# and ^ match there, which Rack's boundary pattern depends on. Not here: the
+# fixed_anchor: mode, named_captures, scan_byte and peek_byte. Checked
+# against CRuby's on MRI, operation by operation.
+require_relative "ruby_wasm_ic_minimal/guard"
+RubyWasmIcMinimal.guard!("strscan")
+class StringScanner
+  class Error < StandardError; end
+
+  attr_reader :string
+
+  def initialize(string, _dup = false, fixed_anchor: false)
+    raise ArgumentError, "fixed_anchor: true is not supported here" if fixed_anchor
+
+    @string = string
+    @pos = 0
+    clear
+  end
+
+  def string=(s)
+    @string = s
+    @pos = 0
+    clear
+    s
+  end
+
+  def concat(s)
+    @string << s
+    self
+  end
+  alias << concat
+
+  def pos = @pos
+
+  def pos=(n)
+    n += @string.bytesize if n.negative?
+    raise RangeError, "index out of range" unless n.between?(0, @string.bytesize)
+
+    @pos = n
+  end
+  alias pointer pos
+  alias pointer= pos=
+
+  def charpos = @string.byteslice(0, @pos).length
+
+  def reset
+    @pos = 0
+    clear
+    self
+  end
+
+  def terminate
+    @pos = @string.bytesize
+    clear
+    self
+  end
+  alias clear_terminate terminate
+
+  def eos? = @pos >= @string.bytesize
+  def rest = @string.byteslice(@pos, @string.bytesize - @pos) || ""
+  def rest? = !eos?
+  def rest_size = @string.bytesize - @pos
+  def beginning_of_line? = @pos.zero? || @string.getbyte(@pos - 1) == 10
+  alias bol? beginning_of_line?
+
+  # At the pointer: advance, return the match.
+  def scan(pattern) = go(pattern, anchored: true, advance: true, string: true)
+  # At the pointer: advance, return its length.
+  def skip(pattern) = go(pattern, anchored: true, advance: true, string: false)
+  # At the pointer: do not advance, return its length.
+  def match?(pattern) = go(pattern, anchored: true, advance: false, string: false)
+  # At the pointer: do not advance, return the match.
+  def check(pattern) = go(pattern, anchored: true, advance: false, string: true)
+  # Anywhere after it: advance past the match, return what was passed over.
+  def scan_until(pattern) = go(pattern, anchored: false, advance: true, string: true)
+  def skip_until(pattern) = go(pattern, anchored: false, advance: true, string: false)
+  def check_until(pattern) = go(pattern, anchored: false, advance: false, string: true)
+  def exist?(pattern) = go(pattern, anchored: false, advance: false, string: false)
+
+  def search_full(pattern, advance, return_string)
+    go(pattern, anchored: false, advance: advance, string: return_string)
+  end
+
+  def scan_full(pattern, advance, return_string)
+    go(pattern, anchored: true, advance: advance, string: return_string)
+  end
+
+  def getch
+    return nil if eos?
+
+    ch = rest[0]
+    set_match(@pos, @pos + ch.bytesize, nil)
+    @pos += ch.bytesize
+    ch
+  end
+
+  def get_byte
+    return nil if eos?
+
+    b = @string.byteslice(@pos, 1)
+    set_match(@pos, @pos + 1, nil)
+    @pos += 1
+    b
+  end
+
+  def peek(n) = @string.byteslice(@pos, n) || ""
+
+  def unscan
+    raise Error, "unscan error: nothing to unscan" unless @last
+
+    @pos = @last
+    clear
+    self
+  end
+
+  def matched? = !@m_end.nil?
+  def matched = matched? ? @string.byteslice(@m_start, @m_end - @m_start) : nil
+  def matched_size = matched? ? @m_end - @m_start : nil
+  def pre_match = matched? ? @string.byteslice(0, @m_start) : nil
+  def post_match = matched? ? @string.byteslice(@m_end, @string.bytesize - @m_end) : nil
+
+  def [](i)
+    return nil unless matched?
+    return (i.zero? ? matched : nil) unless @md
+
+    @md[i]
+  end
+
+  def size = matched? ? (@md ? @md.size : 1) : nil
+  def captures = @md ? @md.captures : (matched? ? [] : nil)
+  def values_at(*is) = matched? ? is.map { self[_1] } : nil
+
+  def inspect
+    return "#<StringScanner fin>" if eos?
+
+    "#<StringScanner #{@pos}/#{@string.bytesize} @ #{peek(5).inspect}>"
+  end
+
+  private
+
+  def clear
+    @m_start = @m_end = @md = @last = nil
+  end
+
+  def set_match(from, to, md)
+    @last = @pos
+    @m_start = from
+    @m_end = to
+    @md = md
+  end
+
+  def go(pattern, anchored:, advance:, string:)
+    start = @pos
+    if pattern.is_a?(String)
+      # As Ruby 3.3's strscan: a String only where the match is at the pointer.
+      raise TypeError, "wrong argument type String (expected Regexp)" unless anchored
+      return fail_match unless @string.byteslice(start, pattern.bytesize) == pattern
+
+      from = start
+      to = from + pattern.bytesize
+      md = nil
+    else
+      # As CRuby's (fixed_anchor: false): the text begins at the pointer, so
+      # \A and ^ match there and nothing before it is seen.
+      md = regexp(pattern, anchored).match(rest)
+      return fail_match unless md
+
+      from = start + md.byteoffset(0)[0]
+      to = start + md.byteoffset(0)[1]
+    end
+    set_match(from, to, md)
+    @pos = to if advance
+    length = to - start
+    return length unless string
+
+    anchored ? @string.byteslice(from, to - from) : @string.byteslice(start, length)
+  end
+
+  def fail_match
+    clear
+    nil
+  end
+
+  def regexp(re, anchored)
+    return re unless anchored
+
+    (@anchored ||= {})[re] ||= Regexp.new("\\A(?:#{re.source})", re.options)
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: ruby_wasm_ic_minimal
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- graial
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: This gem contains the four carried files required for running rack and
+  roda on the minimal ruby.wasm build.
+email:
+- graial@paglalayag.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/date.rb
+- lib/encoding_constants.rb
+- lib/ruby_wasm_ic_minimal.rb
+- lib/ruby_wasm_ic_minimal/guard.rb
+- lib/ruby_wasm_ic_minimal/version.rb
+- lib/stringio.rb
+- lib/strscan.rb
+homepage: https://github.com/graial/ruby_wasm_ic_minimal
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Four carried files required for running rack and roda on the minimal ruby.wasm
+  build
+test_files: []