add --full-names option and refactor public API

`clippy` finally convinced me there were too many arguments to the
`componentize` function, so now we have methods on structs with named fields
instead.

Also, print all known worlds and WIT paths if the specified world can't be
found.

Author: dicej

bundled/poll_loop.py

@@ -2,9 +2,8 @@
 
 This also includes helper classes and functions for working with `wasi:http`.
 
-As of WASI Preview 2, there is not yet a standard for first-class, composable
-asynchronous functions and streams.  We expect that little or none of this
-boilerplate will be needed once those features arrive in Preview 3.
+This is only useful for `wasi:http@0.2.x`; `wasi:http@0.3.x` uses a different
+mechanism to model concurrency.
 """
 
 import asyncio

src/command.rs

@@ -1,4 +1,5 @@
 use {
+    crate::{BindingsGenerator, ComponentGenerator},
     anyhow::{Context, Result},
     clap::Parser as _,
     std::{
@@ -82,6 +83,16 @@ pub struct Common {
     /// If this is not specified, the module name will default to "wit_world".
     #[arg(long)]
     pub world_module: Option<String>,
+
+    /// When generating Python module names, include the WIT package name and
+    /// version even if only one version of that package is referenced by the
+    /// specified world or only one package uses that name.
+    ///
+    /// By default, the package name and version will only be included in the
+    /// name if the world references more than one version of the WIT package or
+    /// the name is used by more than one package.
+    #[arg(long)]
+    pub full_names: bool,
 }
 
 #[derive(clap::Subcommand, Debug)]
@@ -171,28 +182,34 @@ pub fn run<T: Into<OsString> + Clone, I: IntoIterator<Item = T>>(args: I) -> Res
 }
 
 fn generate_bindings(common: Common, bindings: Bindings) -> Result<()> {
-    crate::generate_bindings(
-        &common.wit_path,
-        &common.world.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
-        &common
+    BindingsGenerator {
+        wit_path: &common
+            .wit_path
+            .iter()
+            .map(|v| v.as_path())
+            .collect::<Vec<_>>(),
+        worlds: &common.world.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
+        features: &common
             .features
             .iter()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        common.all_features,
-        common.world_module.as_deref(),
-        &bindings.output_dir,
-        &common
+        all_features: common.all_features,
+        world_module: common.world_module.as_deref(),
+        output_dir: &bindings.output_dir,
+        import_interface_names: &common
             .import_interface_name
             .iter()
             .map(|(a, b)| (a.as_str(), b.as_str()))
             .collect(),
-        &common
+        export_interface_names: &common
             .export_interface_name
             .iter()
             .map(|(a, b)| (a.as_str(), b.as_str()))
             .collect(),
-    )
+        full_names: common.full_names,
+    }
+    .generate()
 }
 
 fn componentize(common: Common, componentize: Componentize) -> Result<()> {
@@ -207,40 +224,48 @@ fn componentize(common: Common, componentize: Componentize) -> Result<()> {
         );
     }
 
-    Runtime::new()?.block_on(crate::componentize(
-        &common.wit_path,
-        &common.world.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
-        &common
-            .features
-            .iter()
-            .map(|v| v.as_str())
-            .collect::<Vec<_>>(),
-        common.all_features,
-        common.world_module.as_deref(),
-        &python_path.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
-        &componentize
-            .module_worlds
-            .iter()
-            .map(|(k, v)| (k.as_str(), [v.as_str()]))
-            .collect::<Vec<_>>()
-            .iter()
-            .map(|(k, v)| (*k, v as &[_]))
-            .collect::<Vec<_>>(),
-        &componentize.app_name,
-        &componentize.output,
-        None,
-        componentize.stub_wasi,
-        &common
-            .import_interface_name
-            .iter()
-            .map(|(a, b)| (a.as_str(), b.as_str()))
-            .collect(),
-        &common
-            .export_interface_name
-            .iter()
-            .map(|(a, b)| (a.as_str(), b.as_str()))
-            .collect(),
-    ))?;
+    Runtime::new()?.block_on(
+        ComponentGenerator {
+            wit_path: &common
+                .wit_path
+                .iter()
+                .map(|v| v.as_path())
+                .collect::<Vec<_>>(),
+            worlds: &common.world.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
+            features: &common
+                .features
+                .iter()
+                .map(|v| v.as_str())
+                .collect::<Vec<_>>(),
+            all_features: common.all_features,
+            world_module: common.world_module.as_deref(),
+            python_path: &python_path.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+            module_worlds: &componentize
+                .module_worlds
+                .iter()
+                .map(|(k, v)| (k.as_str(), [v.as_str()]))
+                .collect::<Vec<_>>()
+                .iter()
+                .map(|(k, v)| (*k, v as &[_]))
+                .collect::<Vec<_>>(),
+            app_name: &componentize.app_name,
+            output_path: &componentize.output,
+            add_to_linker: None,
+            stub_wasi: componentize.stub_wasi,
+            import_interface_names: &common
+                .import_interface_name
+                .iter()
+                .map(|(a, b)| (a.as_str(), b.as_str()))
+                .collect(),
+            export_interface_names: &common
+                .export_interface_name
+                .iter()
+                .map(|(a, b)| (a.as_str(), b.as_str()))
+                .collect(),
+            full_names: common.full_names,
+        }
+        .generate(),
+    )?;
 
     if !common.quiet {
         println!("Component built successfully");
@@ -376,6 +401,7 @@ mod tests {
             all_features: false,
             import_interface_name: Vec::new(),
             export_interface_name: Vec::new(),
+            full_names: false,
         };
         let bindings = Bindings {
             output_dir: out_dir.path().into(),
@@ -406,6 +432,7 @@ mod tests {
             all_features: false,
             import_interface_name: Vec::new(),
             export_interface_name: Vec::new(),
+            full_names: false,
         };
         let bindings = Bindings {
             output_dir: out_dir.path().into(),
@@ -436,6 +463,7 @@ mod tests {
             all_features: true,
             import_interface_name: Vec::new(),
             export_interface_name: Vec::new(),
+            full_names: false,
         };
         let bindings = Bindings {
             output_dir: out_dir.path().into(),
@@ -465,6 +493,7 @@ mod tests {
             all_features: false,
             import_interface_name: Vec::new(),
             export_interface_name: Vec::new(),
+            full_names: false,
         };
         let bindings = Bindings {
             output_dir: out_dir.path().into(),