Merge pull request #397 from bytecodealliance/components-more-types

Support component `enum`, `variant`, `flags` types

Author: jbourassa

ext/src/ruby_api/component/convert.rs

@@ -5,14 +5,22 @@ use crate::{define_rb_intern, err, error, not_implemented};
 use magnus::exception::type_error;
 use magnus::rb_sys::AsRawValue;
 use magnus::value::{IntoId, Lazy, ReprValue};
-use magnus::{prelude::*, value, Error, IntoValue, RArray, RClass, RHash, RString, Ruby, Value};
+use magnus::{
+    prelude::*, try_convert, value, Error, IntoValue, RArray, RClass, RHash, RString, Ruby, Value,
+};
 use wasmtime::component::{Type, Val};
 
 define_rb_intern!(
+    // For Component::Result
     OK => "ok",
     ERROR => "error",
     IS_ERROR => "error?",
     IS_OK => "ok?",
+
+    // For Component::Variant
+    NEW => "new",
+    NAME => "name",
+    VALUE => "value",
 );
 
 pub(crate) fn component_val_to_rb(val: Val, _store: &StoreContextValue) -> Result<Value, Error> {
@@ -54,7 +62,18 @@ pub(crate) fn component_val_to_rb(val: Val, _store: &StoreContextValue) -> Resul
             }
             Ok(array.into_value())
         }
-        Val::Variant(_kind, _val) => not_implemented!("Variant not implemented"),
+        Val::Variant(kind, val) => {
+            let ruby = Ruby::get().unwrap();
+            let payload = match val {
+                Some(val) => component_val_to_rb(*val, _store)?,
+                None => ruby.qnil().into_value(),
+            };
+
+            variant_class(&ruby).funcall(
+                NEW.into_id_with(&ruby),
+                (kind.into_value_with(&ruby), payload),
+            )
+        }
         Val::Enum(kind) => Ok(kind.as_str().into_value()),
         Val::Option(val) => match val {
             Some(val) => Ok(component_val_to_rb(*val, _store)?),
@@ -72,7 +91,7 @@ pub(crate) fn component_val_to_rb(val: Val, _store: &StoreContextValue) -> Resul
             };
             result_class(&ruby).funcall(ruby_method, (ruby_argument,))
         }
-        Val::Flags(_vec) => not_implemented!("Flags not implemented"),
+        Val::Flags(vec) => Ok(vec.into_value()),
         Val::Resource(_resource_any) => not_implemented!("Resource not implemented"),
     }
 }
@@ -168,8 +187,46 @@ pub(crate) fn rb_to_component_val(
 
             Ok(Val::Tuple(vals))
         }
-        Type::Variant(_variant) => not_implemented!("Variant not implemented"),
-        Type::Enum(_enum) => not_implemented!("Enum not implementend"),
+        Type::Variant(variant) => {
+            let ruby = Ruby::get().unwrap();
+
+            let name: RString = value.funcall(NAME.into_id_with(&ruby), ())?;
+            let name = name.to_string()?;
+
+            let case = variant
+                .cases()
+                .find(|case| case.name == name.as_str())
+                .ok_or_else(|| {
+                    error!(
+                        "invalid variant case \"{}\", valid cases: {:?}",
+                        name,
+                        RArray::from_iter(variant.cases().map(|c| c.name))
+                    )
+                })?;
+
+            let payload_rb: Value = value.funcall(VALUE.into_id_with(&ruby), ())?;
+            let payload_val = match (&case.ty, payload_rb.is_nil()) {
+                (Some(ty), _) => rb_to_component_val(payload_rb, _store, ty)
+                    .map(|val| Some(Box::new(val)))
+                    .map_err(|e| e.append(format!(" (variant value for \"{}\")", &name))),
+
+                // case doesn't have payload and Variant#value *is nil*
+                (None, true) => Ok(None),
+
+                // case doesn't have payload and Variant#value *is not nil*
+                (None, false) => err!(
+                    "expected no value for variant case \"{}\", got {}",
+                    &name,
+                    payload_rb.inspect()
+                ),
+            }?;
+
+            Ok(Val::Variant(name, payload_val))
+        }
+        Type::Enum(_) => {
+            let rstring = RString::try_convert(value)?;
+            rstring.to_string().map(Val::Enum)
+        }
         Type::Option(option_type) => {
             if value.is_nil() {
                 Ok(Val::Option(None))
@@ -220,7 +277,7 @@ pub(crate) fn rb_to_component_val(
                 }
             }
         }
-        Type::Flags(_flags) => not_implemented!("Flags not implemented"),
+        Type::Flags(_) => Vec::<String>::try_convert(value).map(Val::Flags),
         Type::Own(_resource_type) => not_implemented!("Resource not implemented"),
         Type::Borrow(_resource_type) => not_implemented!("Resource not implemented"),
     }
@@ -232,6 +289,12 @@ fn result_class(ruby: &Ruby) -> RClass {
     ruby.get_inner(&RESULT_CLASS)
 }
 
+fn variant_class(ruby: &Ruby) -> RClass {
+    static VARIANT_CLASS: Lazy<RClass> =
+        Lazy::new(|ruby| component_namespace(ruby).const_get("Variant").unwrap());
+    ruby.get_inner(&VARIANT_CLASS)
+}
+
 pub fn init(ruby: &Ruby) -> Result<(), Error> {
     // Warm up
     let _ = result_class(ruby);
@@ -240,5 +303,10 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     let _ = IS_ERROR;
     let _ = IS_OK;
 
+    let _ = result_class(ruby);
+    let _ = NEW;
+    let _ = NAME;
+    let _ = VALUE;
+
     Ok(())
 }

lib/wasmtime/component.rb

@@ -82,5 +82,51 @@ class UncheckedResult < Wasmtime::Error; end
       # `.error` is used over `.new`.
       private :initialize
     end
+
+    # Represents a value for component model's variant case.
+    # A variant case has a name that uniquely identify the case within the
+    # variant and optionally a value.
+    #
+    # @example Constructing variants
+    #   # Given the following variant:
+    #   # variant filter {
+    #   #     all,
+    #   #     none,
+    #   #     lt(u32),
+    #   # }
+    #
+    #   Variant.new("all")
+    #   Variant.new("none")
+    #   Variant.new("lt", 100)
+    class Variant
+      # The name of the variant case
+      # @return [String]
+      attr_reader :name
+
+      # The optional payload of the variant case
+      # @return [Object]
+      attr_reader :value
+
+      # @param name [String] the name of variant case
+      # @param value [Object] the optional payload of the variant case
+      def initialize(name, value = nil)
+        @name = name
+        @value = value
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          name == other.name &&
+          value == other.value
+      end
+
+      def hash
+        [self.class, @name, @value].hash
+      end
+    end
   end
 end

spec/unit/component/convert_spec.rb

@@ -28,12 +28,12 @@ module Component
           ["list", [1, 2, 2**32 - 1]], # list<u32>
           ["record", {"x" => 1, "y" => 2}],
           ["tuple", [1, "foo"]], # tuple<u32, string>
-          # TODO variant
-          # TODO enum
+          ["variant", Variant.new("all"), Variant.new("lt", 12)],
+          ["enum", "l"],
           ["option", 0, nil], # option<u32>
           ["result", Result.ok(1), Result.error(2)], # result<u32, u32>
-          ["result-unit", Result.ok(nil), Result.error(nil)]
-          # TODO flags
+          ["result-unit", Result.ok(nil), Result.error(nil)],
+          ["flags", [], ["read"], ["read", "write", "exec"]]
         ].each do |type, *values|
           values.each do |v|
             it "#{type} #{v.inspect}" do
@@ -84,9 +84,15 @@ module Component
           ["record", {"x" => 1}, /struct field missing: y/],
           ["record", nil, /no implicit conversion of NilClass into Hash/],
           ["tuple", nil, /no implicit conversion of NilClass into Array/],
+          ["variant", Variant.new("no"), /invalid variant case "no", valid cases: \["all", "none", "lt"\]/],
+          ["variant", Variant.new("lt", "nah"), /(variant value for "lt")/],
+          ["enum", "no", /enum variant name `no` is not valid/],
           ["result", nil, /undefined method `ok\?/],
           ["result-unit", Result.ok(""), /expected nil for result<_, E> ok branch/],
-          ["result-unit", Result.error(""), /expected nil for result<O, _> error branch/]
+          ["result-unit", Result.error(""), /expected nil for result<O, _> error branch/],
+          ["flags", ["no"], /unknown flag: `no`/],
+          ["flags", [1], /no implicit conversion of Integer into String/],
+          ["flags", 1, /no implicit conversion of Integer into Array/]
         ].each do |type, value, klass, msg|
           it "fails on #{type} #{value.inspect}" do
             expect { instance.invoke("id-#{type}", value) }.to raise_error(klass, msg)

spec/unit/component/variant_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+module Wasmtime
+  module Component
+    RSpec.describe Variant do
+      it "has name" do
+        expect(Variant.new("a", 1).name).to eq("a")
+      end
+
+      it "has value" do
+        expect(Variant.new("a", 1).value).to eq(1)
+      end
+
+      it "behaves like a value object" do
+        expect(Variant.new("a", 1)).to eq(Variant.new("a", 1))
+        expect(Variant.new("a", 1).hash).to eq(Variant.new("a", 1).hash)
+
+        expect(Variant.new("a")).not_to eq(Variant.new("b"))
+        expect(Variant.new("a", 1)).not_to eq(Variant.new("a", 2))
+        expect(Variant.new("a").hash).not_to eq(Variant.new("b").hash)
+        expect(Variant.new("a", 1).hash).not_to eq(Variant.new("a", 2).hash)
+      end
+    end
+  end
+end