docs(website): add more language snippets

bindings/c/src/writer.rs

@@ -58,7 +58,7 @@ impl opendal_writer {
                 return opendal_result_writer_write {
                     size: 0,
                     error: opendal_error::new(e),
-                }
+                };
             }
         };
         match self.deref_mut().write(bytes) {

bindings/dart/rust/src/api/opendal_api.rs

@@ -92,24 +92,36 @@ impl Operator {
     }
 
     pub async fn read(&self, path: String) -> anyhow::Result<Vec<u8>> {
-        let buf = self.async_op.read(&path).await.map_err(|e| anyhow::anyhow!(e))?;
+        let buf = self
+            .async_op
+            .read(&path)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
         Ok(buf.to_vec())
     }
 
     #[frb(sync)]
     pub fn read_sync(&self, path: String) -> anyhow::Result<Vec<u8>> {
-        let buf = self.blocking_op.read(&path).map_err(|e| anyhow::anyhow!(e))?;
+        let buf = self
+            .blocking_op
+            .read(&path)
+            .map_err(|e| anyhow::anyhow!(e))?;
         Ok(buf.to_vec())
     }
 
     pub async fn write(&self, path: String, data: Vec<u8>) -> anyhow::Result<()> {
-        self.async_op.write(&path, data).await.map_err(|e| anyhow::anyhow!(e))?;
+        self.async_op
+            .write(&path, data)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
         Ok(())
     }
 
     #[frb(sync)]
     pub fn write_sync(&self, path: String, data: Vec<u8>) -> anyhow::Result<()> {
-        self.blocking_op.write(&path, data).map_err(|e| anyhow::anyhow!(e))?;
+        self.blocking_op
+            .write(&path, data)
+            .map_err(|e| anyhow::anyhow!(e))?;
         Ok(())
     }
 }

bindings/dart/rust/src/frb_generated.rs

@@ -28,7 +28,7 @@
 
 use crate::api::opendal_api::*;
 use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
+use flutter_rust_bridge::for_generated::{Lifetimeable, Lockable, transform_result_dco};
 use flutter_rust_bridge::{Handler, IntoIntoDart};
 
 // Section: boilerplate
@@ -1734,7 +1734,7 @@ mod io {
     use flutter_rust_bridge::for_generated::byteorder::{
         NativeEndian, ReadBytesExt, WriteBytesExt,
     };
-    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
+    use flutter_rust_bridge::for_generated::{Lifetimeable, Lockable, transform_result_dco};
     use flutter_rust_bridge::{Handler, IntoIntoDart};
 
     // Section: boilerplate
@@ -1787,7 +1787,7 @@ mod web {
     };
     use flutter_rust_bridge::for_generated::wasm_bindgen;
     use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*;
-    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
+    use flutter_rust_bridge::for_generated::{Lifetimeable, Lockable, transform_result_dco};
     use flutter_rust_bridge::{Handler, IntoIntoDart};
 
     // Section: boilerplate

bindings/java/src/main/java/org/apache/opendal/ServiceConfig.java

@@ -1575,6 +1575,10 @@ public Map<String, String> configMap() {
     class Hf implements ServiceConfig {
         /**
          * <p>Download mode. Either <code>xet</code> (default) or <code>http</code>.</p>
+         * <p>When unset, the mode is resolved from the <code>HF_HUB_DISABLE_XET</code>
+         * environment variable: a non-empty value forces <code>http</code>, otherwise it
+         * defaults to <code>xet</code>. An explicit value here takes precedence.</p>
+         * <p>See <a href="https://huggingface.co/docs/huggingface_hub/package_reference/environment_variables#hfhubdisablexet">https://huggingface.co/docs/huggingface_hub/package_reference/environment_variables#hfhubdisablexet</a>.</p>
          */
         public final String downloadMode;
         /**

dev/src/generate/docs.rs

@@ -56,6 +56,12 @@ const BINDINGS: &[Binding] = &[
         language: "rust",
         cargo: None,
     },
+    Binding {
+        id: "java",
+        label: "Java",
+        language: "java",
+        cargo: Some("bindings/java/Cargo.toml"),
+    },
     Binding {
         id: "python",
         label: "Python",
@@ -69,10 +75,28 @@ const BINDINGS: &[Binding] = &[
         cargo: Some("bindings/nodejs/Cargo.toml"),
     },
     Binding {
-        id: "java",
-        label: "Java",
-        language: "java",
-        cargo: Some("bindings/java/Cargo.toml"),
+        id: "ruby",
+        label: "Ruby",
+        language: "ruby",
+        cargo: Some("bindings/ruby/Cargo.toml"),
+    },
+    Binding {
+        id: "go",
+        label: "Go",
+        language: "go",
+        cargo: None,
+    },
+    Binding {
+        id: "c",
+        label: "C",
+        language: "c",
+        cargo: Some("bindings/c/Cargo.toml"),
+    },
+    Binding {
+        id: "cpp",
+        label: "C++",
+        language: "cpp",
+        cargo: Some("bindings/cpp/Cargo.toml"),
     },
 ];
 
@@ -393,15 +417,23 @@ fn build(required: &[&Field], grouped: &[(&str, Vec<&Field>)], s: &Syntax) -> (S
         if multi {
             full.push_str(&format!("{}{}--- {group} ---\n", s.indent, s.comment));
         }
-        for f in fields {
-            comment_block(f.comments, &mut full);
-            let assign = (s.assign)(f);
-            if f.required {
-                full.push_str(&format!("{}{assign}\n\n", s.indent));
+        let mut config_options = vec![];
+        for field in fields {
+            let mut field_comment = String::new();
+            comment_block(field.comments, &mut field_comment);
+            let assign = (s.assign)(field);
+            // field have block indententation
+            if field.required {
+                config_options.push(format!("{field_comment}{}{assign}", s.indent));
             } else {
-                full.push_str(&format!("{}{}{assign}\n\n", s.indent, s.comment));
+                config_options.push(format!("{field_comment}{}{}{assign}", s.indent, s.comment));
             }
         }
+
+        if !config_options.is_empty() {
+            full.push_str(config_options.join("\n\n").trim_end());
+            full.push('\n');
+        }
     }
     full.push_str(&s.close);
 
@@ -416,7 +448,7 @@ fn render_examples(
 ) -> (String, String) {
     let syntax = match binding {
         "rust" => Syntax {
-            open: format!("use opendal::Operator;\n\nlet op = Operator::via_iter(\"{scheme}\", [\n"),
+            open: format!("use opendal::Operator;\n\nlet operator = Operator::via_iter(\"{scheme}\", [\n"),
             close: "])?;".to_string(),
             indent: "    ",
             comment: "// ",
@@ -429,27 +461,67 @@ fn render_examples(
             },
         },
         "python" => Syntax {
-            open: format!("import opendal\n\nop = opendal.Operator(\n    \"{scheme}\",\n"),
+            open: format!("import opendal\n\noperator = opendal.Operator(\n    \"{scheme}\",\n"),
             close: ")".to_string(),
             indent: "    ",
             comment: "# ",
             assign: |f| format!("{}=\"{}\",", f.name, value_of(f)),
         },
         "nodejs" => Syntax {
             open: format!(
-                "import {{ Operator }} from \"opendal\";\n\nconst op = new Operator(\"{scheme}\", {{\n"
+                "import {{ Operator }} from \"opendal\";\n\nconst operator = new Operator(\"{scheme}\", {{\n"
             ),
             close: "});".to_string(),
             indent: "  ",
             comment: "// ",
             assign: |f| format!("{}: \"{}\",", f.name, value_of(f)),
         },
         "java" => Syntax {
-            open: "import java.util.HashMap;\nimport java.util.Map;\nimport org.apache.opendal.Operator;\n\nMap<String, String> conf = new HashMap<>();\n".to_string(),
-            close: format!("Operator op = Operator.of(\"{scheme}\", conf);"),
+            open: "import java.util.HashMap;\nimport java.util.Map;\nimport org.apache.opendal.Operator;\n\nMap<String, String> config = new HashMap<>();\n".to_string(),
+            close: format!("Operator operator = Operator.of(\"{scheme}\", config);"),
             indent: "",
             comment: "// ",
-            assign: |f| format!("conf.put(\"{}\", \"{}\");", f.name, value_of(f)),
+            assign: |f| format!("config.put(\"{}\", \"{}\");", f.name, value_of(f)),
+        },
+        "go" => Syntax {
+            open: format!(
+                "import (\n	\"github.com/apache/opendal-go-services/{scheme}\"\n	opendal \"github.com/apache/opendal/bindings/go\"\n)\n\noperator, err := opendal.NewOperator({scheme}.Scheme, opendal.OperatorOptions{{\n",
+            ),
+            close: "})".to_string(),
+            indent: "	",
+            comment: "// ",
+            assign: |f| format!("\"{}\": \"{}\",", f.name, value_of(f)),
+        },
+        "c" => Syntax {
+            open: "#include \"opendal.h\"\n\nopendal_operator_options *options = opendal_operator_options_new();\n".to_string(),
+            close: format!(
+                "opendal_result_operator_new result = opendal_operator_new(\"{scheme}\", options);\nopendal_operator *operator = result.op;\n\n/* ... use operator ... */\n\nopendal_operator_free(operator);\nopendal_operator_options_free(options);"
+            ),
+            indent: "",
+            comment: "// ",
+            assign: |f| {
+                format!(
+                    "opendal_operator_options_set(options, \"{}\", \"{}\");",
+                    f.name,
+                    value_of(f)
+                )
+            },
+        },
+        "cpp" => Syntax {
+            open: "#include \"opendal.hpp\"\n\nstd::unordered_map<std::string, std::string> config{\n".to_string(),
+            close: format!("}};\nopendal::Operator operator(\"{scheme}\", config);"),
+            indent: "    ",
+            comment: "// ",
+            assign: |f| format!("{{\"{}\", \"{}\"}},", f.name, value_of(f)),
+        },
+        "ruby" => Syntax {
+            open: format!(
+                "require \"opendal\"\n\noperator = OpenDal::Operator.new(\"{scheme}\", {{\n"
+            ),
+            close: "})".to_string(),
+            indent: "  ",
+            comment: "# ",
+            assign: |f| format!("\"{}\" => \"{}\",", f.name, value_of(f)),
         },
         other => unreachable!("no renderer for binding {other}"),
     };

dev/src/generate/java.rs

@@ -136,10 +136,7 @@ fn make_populate_map(field: ViaDeserialize<Config>) -> Result<String, minijinja:
             field.name,
             case_java_field_name(&field.name)
         ),
-        ConfigType::HashMap => format!(
-            "map.putAll({});",
-            case_java_field_name(&field.name)
-        ),
+        ConfigType::HashMap => format!("map.putAll({});", case_java_field_name(&field.name)),
     };
 
     if field.optional {