haveapi-rust-client 0.31.2 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98e92e7d6c1f69e9a4f37ffea0d246af9b242170f951b523c19db89fb0fc9bda
-  data.tar.gz: 80614d87719c4bba512d3cf4c8b34f5f91c5db0517813c60784ab359feee3d42
+  metadata.gz: 680519d92eeac2f6ea9c1f6eb7c73fc03f197068a329c933db47cb9db42d6fc4
+  data.tar.gz: 05ac7f3e221583754c716d048f61ac585e89e47a0a1bd9b10ac9e8a533be6a95
 SHA512:
-  metadata.gz: 0704356421435f6e4d5100de5904c8b0e2a4542a4e45cdfa8126b52bdb9b019e7ec1532441e5230f491a54ac29a0964ac100e4a4e952cdae42068eb6f9711f6c
-  data.tar.gz: 6388b1c3f653abdf2fb1184127dd8e6e137a421d77fdf0aa3fa07d22fccc070af1107b479ce71c6b75c2e8c474c1d6b93d25de277b05c8becbfd6076099b7f69
+  metadata.gz: 7b0a52816bfa919ebfe50d35aad9c4405ddeaa145a93c326ba6f92daf7d31efb6c81c27550576e1b917463a9d5c33264cb0d7d6c33f1a6df1b1c9e117e74d7bd
+  data.tar.gz: a3f6d9e91b0c247e9930d614b95c53af5ef219aadd35cc09f2f2fe9f2b4a46f769883498a334f08ad5391d01e93c6d68eebe023128fd8212d8d35a4c614befb5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../ruby
   specs:
-    haveapi-client (0.31.2)
+    haveapi-client (0.32.0)
       activesupport (>= 7.0)
       highline (~> 3.1)
       json
@@ -12,9 +12,9 @@ PATH
 PATH
   remote: .
   specs:
-    haveapi-rust-client (0.31.2)
+    haveapi-rust-client (0.32.0)
       fiddle (~> 1.1, >= 1.1.8)
-      haveapi-client (~> 0.31.2)
+      haveapi-client (~> 0.32.0)
       tomlrb (~> 2.0)
 
 GEM
@@ -50,7 +50,7 @@ GEM
       domain_name (~> 0.5)
     i18n (1.15.2)
       concurrent-ruby (~> 1.0)
-    io-console (0.9.4)
+    io-console (0.9.5)
     json (2.21.2)
     json_schemer (2.5.0)
       bigdecimal
@@ -65,7 +65,7 @@ GEM
     mime-types (3.7.0)
       logger
       mime-types-data (~> 3.2025, >= 3.2025.0507)
-    mime-types-data (3.2026.1020)
+    mime-types-data (3.2026.1027)
     minitest (6.0.6)
       drb (~> 2.0)
       prism (~> 1.5)
@@ -156,13 +156,13 @@ CHECKSUMS
   drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
   fiddle (1.1.8) sha256=7fa8ee3627271497f3add5503acdbc3f40b32f610fc1cf49634f083ef3f32eee
   hana (1.3.7) sha256=5425db42d651fea08859811c29d20446f16af196308162894db208cac5ce9b0d
-  haveapi-client (0.31.2)
-  haveapi-rust-client (0.31.2)
+  haveapi-client (0.32.0)
+  haveapi-rust-client (0.32.0)
   highline (3.1.2) sha256=67cbd34d19f6ef11a7ee1d82ffab5d36dfd5b3be861f450fc1716c7125f4bb4a
   http-accept (1.7.0) sha256=c626860682bfbb3b46462f8c39cd470fd7b0584f61b3cc9df5b2e9eb9972a126
   http-cookie (1.1.6) sha256=ba4b82be64de61dc281243dac70e3c382c45142f20268ed9276a3670c93feaa9
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
-  io-console (0.9.4) sha256=a403304f32928ee85e56d457b4612ca43f2703b561a3258844992bd24085fbb1
+  io-console (0.9.5) sha256=83dd9bbf4c4680416629245b39cd4212eb5f4d9a4ea91804870c1f6b846414d5
   json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
   json_schemer (2.5.0) sha256=2f01fb4cce721a4e08dd068fc2030cffd0702a7f333f1ea2be6e8991f00ae396
   language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
@@ -170,7 +170,7 @@ CHECKSUMS
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   mcp (0.25.0) sha256=8acf3a5f3b60b6fd6e5d9b8ac5eb85ac504766976cbadaca182d2ffe7d795d98
   mime-types (3.7.0) sha256=dcebf61c246f08e15a4de34e386ebe8233791e868564a470c3fe77c00eed5e56
-  mime-types-data (3.2026.1020) sha256=6b3bcc776c1e3591267727700467e02fb9c12b503fcce4e0e964516d7c1e0d06
+  mime-types-data (3.2026.1027) sha256=4568729e44974c1c8a8ceb76f7a5fc164e8c9553335455688bb3c00020f5d83f
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
   netrc (0.11.0) sha256=de1ce33da8c99ab1d97871726cba75151113f117146becbe45aa85cb3dabee3f
   parallel (1.28.0) sha256=33e6de1484baf2524792d178b0913fc8eb94c628d6cfe45599ad4458c638c970

data/docs/development.md

@@ -6,7 +6,14 @@ From the HaveAPI root:
 nix develop .#client-rust
 cd clients/rust
 bundle exec rspec spec/unit
-bundle exec rubocop lib bin spec/unit spec/spec_helper.rb haveapi-rust-client.gemspec
+```
+
+Run Ruby style checks from the HaveAPI root in the default Nix shell, using the
+root bundle:
+
+```sh
+BUNDLE_GEMFILE="$PWD/Gemfile" bundle exec rubocop clients/rust/lib clients/rust/bin \
+  clients/rust/spec clients/rust/haveapi-rust-client.gemspec
 ```
 
 The component shell runs `bundle install` for this library's dependency ranges
@@ -22,11 +29,21 @@ The root Git hooks also need the root shell's dependencies: prepare them with
 Overcommit hooks enabled. Do not install gems concurrently in the same gem home.
 
 From the HaveAPI root, `make test-rust-unit` runs the generator specs.
-`make test-rust` additionally runs both runtime feature configurations and the
-generated-client protocol harness. Unit specs never start a server or invoke
-Cargo. Compilation, Rust linting, server integration, MSRV and packaging checks
-can take longer; follow the development workspace's verification procedure when
-working there.
+The specs check generated Rust with the recorded formatter, including failures
+after a successful version probe, without starting Cargo or a server. They also
+verify that every copied runtime file retains its maintained source bytes.
+`make check-rust` runs the runtime's read-only `cargo fmt` check.
+`make test-rust` additionally checks formatting and runs both runtime feature
+configurations, the prepared server fixture contracts and the generated-client
+protocol harness.
+Quick unit specs need only the Rust component bundle; they never load the server
+application, start a listener or invoke Cargo. Compilation, Rust linting, server
+integration, MSRV and packaging checks can take longer; follow the development
+workspace's verification procedure when working there.
+
+The generated-client harness also runs `cargo fmt --check` over its complete
+temporary crate, including the copied acceptance tests. This check precedes its
+compilation and protocol tests. Clippy remains a separate runtime lint check.
 
 The Nix shell supplies the development compiler and formatter. New test
 fixtures record that formatter; existing clients retain their own exact

data/docs/documentation.md

@@ -110,8 +110,15 @@ Their internal structural URL is not an SDK provenance source or emitted request
 URL. Requests use the real server context. Actual SDK generation still requires
 its full versioned packaging configuration; these factories do not relax it.
 
-Both variants show a complete program and Cargo dependency comments. Async
-programs use Tokio and `.send().await?`. Blocking programs enable the SDK's
+Simple action examples assume that initialization and authentication have
+established `api`. They show the actual call and sample output. Async fragments
+belong in an async function returning `Result<(), Box<dyn std::error::Error>>`;
+blocking fragments use a synchronous function with that return type, outside
+async runtime threads. The `?` operator propagates request and conversion errors.
+Both detail levels share sample validation and limitations.
+
+**With error handling** shows a complete program and Cargo dependency comments.
+Async programs use Tokio and `.send().await?`. Blocking programs enable the SDK's
 `blocking` feature and construct, use and drop the client in a synchronous
 `main`, outside async runtime threads. `HAVEAPI_BASE_URL` can override the shown
 mounted root. Authenticated actions use advertised existing credentials from
@@ -149,13 +156,15 @@ authentication rendering separately. These lanes do not generate or compile an
 SDK. Compare the same fixture, runtime, dependency inputs and output digests
 against both implementation revisions before claiming a measured improvement.
 
-The acceptance runner extracts actual `RustAsyncClient.render` and
-`RustBlockingClient.render` source. It generates a matching temporary fixture
+The context must expose `detail` as `:simple` or `:thorough`. The acceptance runner
+extracts actual `RustAsyncClient.render` and `RustBlockingClient.render` source.
+It generates a matching temporary fixture
 SDK, compiles the emitted imports, paths, methods and types, and executes the
-programs against the existing disposable HaveAPI fixture at `/` and
-`/mounted/api/`. It adds output assertions without replacing emitted requests.
-Authentication checks compose the emitted authentication builder with the
-emitted action body. It tests both modes with the development compiler and
+programs for both detail levels against the existing disposable HaveAPI fixture
+at `/` and `/mounted/api/`. It adds output assertions without replacing emitted
+requests. Simple fragments use separately rendered setup. Authentication checks
+compose the emitted authentication builder with the emitted action body.
+It tests both modes with the development compiler and
 Rust 1.95, including zero/false/empty/null/omitted inputs, nested Custom, lists,
 nested resources, failure branches, metadata, existing credentials and an
 action-state reference. The fixture uses local test credentials and in-memory

data/lib/haveapi/rust_client/documentation.rb

@@ -2,10 +2,13 @@ require 'haveapi/rust_client'
 require 'date'
 
 module HaveAPI::RustClient
-  # Resolves the complete SDK model before checking a request's authorized help.
+  # Resolves the complete API client model before checking a request's authorized help.
   class Documentation
     include Model
 
+    SIMPLE_DETAIL_LEVELS = [:simple].freeze
+    DETAIL_LEVELS = %i[simple thorough].freeze
+
     class Unsupported < StandardError; end
 
     def self.from_description(description:, api_version:, protocol_version:, mount_path:,
@@ -24,29 +27,29 @@ module HaveAPI::RustClient
 
     def self.validate_source(source)
       return nil if source.nil?
-      raise Error, 'invalid Rust SDK source' unless source.is_a?(Hash) && source.length == 2
+      raise Error, 'invalid Rust API client source' unless source.is_a?(Hash) && source.length == 2
 
       values = source.to_h { |key, value| [key.to_s, value] }
       url, revision = values.values_at('git', 'rev')
       unless values.keys.sort == %w[git rev] && url.is_a?(String) && !url.match?(/[\x00-\x20\x7f]/) &&
              revision.is_a?(String) && revision.match?(/\A[0-9a-fA-F]{40}\z/)
-        raise Error, 'invalid Rust SDK source'
+        raise Error, 'invalid Rust API client source'
       end
 
       uri = URI.parse(url)
       unless uri.is_a?(URI::HTTPS) && uri.host && !uri.host.empty? &&
              uri.userinfo.nil? && uri.query.nil? && uri.fragment.nil?
-        raise Error, 'invalid Rust SDK source'
+        raise Error, 'invalid Rust API client source'
       end
 
       values.transform_values { |value| value.dup.freeze }.freeze
     rescue URI::InvalidURIError
-      raise Error, 'invalid Rust SDK source'
+      raise Error, 'invalid Rust API client source'
     end
 
     def initialize(snapshot:, config: nil, crate_name: nil, crate_version: nil, source: nil)
       if config
-        raise Error, 'conflicting Rust SDK package settings' unless crate_name.nil? && crate_version.nil?
+        raise Error, 'conflicting Rust API client package settings' unless crate_name.nil? && crate_version.nil?
 
         config = JSON.parse(Snapshot.canonical(config))
         Generator.validate_config(config)
@@ -74,7 +77,7 @@ module HaveAPI::RustClient
 
     def render(kind:, context:, mode:, auth_method: nil, auth_description: nil)
       unsupported!('Unsupported Rust execution mode.') unless %i[async blocking].include?(mode)
-      unsupported!('The Rust SDK targets a different API version.') unless context.version.to_s == @snapshot['api_version']
+      unsupported!('The Rust API client targets a different API version.') unless context.version.to_s == @snapshot['api_version']
 
       source = case kind
                when :init then program(context, mode, [])
@@ -87,8 +90,16 @@ module HaveAPI::RustClient
       { status: :limitation, reason: e.message.freeze }.freeze
     end
 
+    def detail_levels_for(kind:, context:, result:, mode:, auth_method: nil, auth_description: nil)
+      result[:status] == :code && %i[init auth example].include?(kind) && %i[async blocking].include?(mode) ? DETAIL_LEVELS : SIMPLE_DETAIL_LEVELS
+    end
+
     private
 
+    def failed_sample?(sample)
+      sample['status'] == false || (sample['http_status'].is_a?(Integer) && sample['http_status'] >= 400)
+    end
+
     def unsupported!(reason)
       raise Unsupported, reason
     end
@@ -130,14 +141,21 @@ module HaveAPI::RustClient
       lines = dependencies + ["use #{client};", '']
       lines << '#[tokio::main]' if mode == :async
       lines << "#{'async ' if mode == :async}fn main() -> Result<(), Box<dyn std::error::Error>> {"
-      lines << "    let base = std::env::var(\"HAVEAPI_BASE_URL\").unwrap_or_else(|_| #{literal(context.base_url)}.to_owned());"
-      lines << '    let api = Client::builder(&base)'
-      lines.concat(credentials.map { |line| "        #{line}" })
-      lines << '        .build()?;'
+      construction = "#{["Client::builder(#{literal(context.base_url)})", *credentials].join("\n    ")}\n    .build()"
+      lines.concat(result_lines(context, 'api', construction, 'Client configuration failed').flat_map { |line| line.lines(chomp: true).map { |part| "    #{part}" } })
       lines.concat((body.empty? ? ['let _ = &api;'] : body).map { |line| line.empty? ? '' : "    #{line}" })
       lines.push('    Ok(())', '}', '').join("\n")
     end
 
+    def result_lines(context, name, expression, label)
+      return ["let #{name} = #{expression}?;"] unless context.detail == :thorough
+
+      ["let #{name} = match #{expression} {", "    Ok(#{name}) => #{name},", '    Err(error) => {',
+       "        eprintln!(\"#{label}: {}\", error);",
+       '        eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());',
+       '        return Err(error.into());', '    }', '};']
+    end
+
     def dependency_lines(mode)
       unless @source || @crate_version
         return ["// cargo add #{@crate_name}#{' --features blocking' if mode == :blocking}"]
@@ -155,23 +173,23 @@ module HaveAPI::RustClient
       live = normalized_members(providers)[provider]
       saved = @snapshot.fetch('description').fetch('authentication')[provider]
       unless live.is_a?(Hash) && saved
-        unsupported!('This authentication provider is unavailable in the authorized Rust SDK profile.')
+        unsupported!('This authentication provider is unavailable in the authorized Rust API client profile.')
       end
       live = normalize(live)
       unsupported!('The authentication description differs from the authorized help.') unless normalize(description) == live
 
       credentials = case provider
                     when 'basic'
-                      ['.basic_auth(std::env::var("HAVEAPI_USER")?, std::env::var("HAVEAPI_PASSWORD")?)']
+                      ['.basic_auth("user", "secret")']
                     when 'token', 'oauth2'
                       unless saved['http_header'] == live['http_header']
-                        unsupported!('The Rust SDK authentication header differs from this API.')
+                        unsupported!('The Rust API client authentication header differs from this API.')
                       end
                       setter = provider == 'token' ? 'token' : 'oauth2_token'
-                      [".#{setter}(std::env::var(\"HAVEAPI_TOKEN\")?)"]
+                      [".#{setter}(#{literal(provider == 'token' ? 'example-token' : 'example-access-token')})"]
                     else unsupported!('This authentication provider is unsupported by the Rust client.')
                     end
-      body = ['// Existing credentials only. Token acquisition and challenges require explicit advertised actions.',
+      body = ['// Configure existing credentials only; building does not validate them with the server.',
               'let _ = &api;']
       program(context, mode, body, credentials:)
     end
@@ -179,7 +197,7 @@ module HaveAPI::RustClient
     def example(context, mode)
       saved = resolve(resource_path: context.resource_path, action_name: context.action_name)
       live = authorized_action(context)
-      unsupported!('This action is unavailable in the authorized Rust SDK profile.') unless saved && live
+      unsupported!('This action is unavailable in the authorized Rust API client profile.') unless saved && live
       sample = normalize(context.sample)
       unless sample.is_a?(Hash) && (%w[path_params request response errors].any? { |key| !sample[key].nil? } ||
                                     sample['status'] == false || (sample['http_status'] && sample['http_status'] != 200))
@@ -188,7 +206,7 @@ module HaveAPI::RustClient
       compatible_action!(saved, live, context)
       paths = sample['path_params'] || []
       unless paths.is_a?(Array) && paths.length == saved[:placeholders].length && paths.all? { |value| valid_path?(value) }
-        unsupported!('The sample path arguments cannot be represented by this Rust SDK.')
+        unsupported!('The sample path arguments cannot be represented by this Rust API client.')
       end
       inputs = input_lines(saved, live, sample['request'])
       validate_response!(saved, live, sample['response']) unless sample['response'].nil?
@@ -198,18 +216,31 @@ module HaveAPI::RustClient
       call << inputs.fetch(:chain)
       send = mode == :async ? '.send().await' : '.send()'
       body = inputs.fetch(:before)
-      if sample['status'] == false || (sample['http_status'].is_a?(Integer) && sample['http_status'] >= 400)
+      if failed_sample?(sample)
         body += ["match #{call}#{send} {", '    Ok(_) => return Err("expected the documented request to fail".into()),',
-                 '    Err(error) => {', '        let _ = error.http_status();',
-                 '        // Inspect these explicitly; server diagnostics can contain sensitive values.',
-                 '        let _ = (error.server_message(), error.validation_errors());', '    }', '}']
+                 '    Err(error) => {', '        eprintln!("HTTP status: {:?}", error.http_status());']
+        if context.detail == :thorough
+          body += ['        eprintln!("Request failed: {}; timeout: {}", error, error.is_timeout());',
+                   '        // Inspect these explicitly; server diagnostics can contain sensitive values.',
+                   '        let _ = (error.server_message(), error.validation_errors());']
+        end
+        body += ['    }', '}']
       else
-        body += ["let response = #{call}#{send}?;", 'let _ = response.http_status;', 'let _ = &response.meta;']
+        body.concat(result_lines(context, 'response', "#{call}#{send}", 'Request failed'))
+        body += ['let _ = response.http_status;', 'let _ = &response.meta;'] if context.detail == :thorough
         body.concat(output_lines(saved, sample['response']))
       end
-      body << '// Request success or a timeout does not establish completion of a server-side operation.'
-      body << '// Use only the separately documented action-state action; this SDK has no automatic wait helper.'
-      program(context, mode, body, credentials: action_credentials(saved, context))
+      if saved[:desc]['blocking'] == true
+        body << '// Request success or a timeout does not establish completion of a server-side operation.'
+        if context.detail == :thorough
+          body << '// Use only the separately documented action-state action; this API client has no automatic wait helper.'
+        end
+      end
+      credentials = action_credentials(saved, context)
+      return program(context, mode, body, credentials:) if context.detail == :thorough
+
+      enclosing = mode == :async ? 'an async function' : 'a synchronous function outside async runtime threads'
+      (["// Use inside #{enclosing} returning Result<(), Box<dyn std::error::Error>>."] + body + ['']).join("\n")
     end
 
     def action_credentials(action, context)
@@ -218,7 +249,7 @@ module HaveAPI::RustClient
       live = normalized_members(normalized_members(context.description)['authentication'])
       saved = @snapshot.fetch('description').fetch('authentication')
       if live.has_key?('basic') && saved.has_key?('basic')
-        return ['.basic_auth(std::env::var("HAVEAPI_USER")?, std::env::var("HAVEAPI_PASSWORD")?)']
+        return ['.basic_auth("user", "secret")']
       end
 
       %w[token oauth2].each do |provider|
@@ -227,9 +258,9 @@ module HaveAPI::RustClient
         next unless normalize(normalized_members(advertised)['http_header']) == saved[provider]['http_header']
 
         setter = provider == 'token' ? 'token' : 'oauth2_token'
-        return [".#{setter}(std::env::var(\"HAVEAPI_TOKEN\")?)"]
+        return [".#{setter}(#{literal(provider == 'token' ? 'example-token' : 'example-access-token')})"]
       end
-      unsupported!('This action requires authentication unavailable in the authorized Rust SDK profile.')
+      unsupported!('This action requires authentication unavailable in the authorized Rust API client profile.')
     end
 
     def authorized_action(context)
@@ -251,7 +282,7 @@ module HaveAPI::RustClient
       mount += '/' unless mount.end_with?('/')
       unless live['method'] == saved[:desc]['method'] && live['path'] == mount + saved[:route] &&
              (live['auth'] == false) == (saved[:desc]['auth'] == false)
-        unsupported!('The Rust SDK route or HTTP method differs from this API action.')
+        unsupported!('The Rust API client route or HTTP method differs from this API action.')
       end
       %w[input output].each do |direction|
         saved_io = saved[direction.to_sym]
@@ -260,13 +291,13 @@ module HaveAPI::RustClient
 
         unless saved_io && live_io && saved_io[:desc]['layout'] == live_io['layout'] &&
                saved_io[:desc]['namespace'] == live_io['namespace'] && saved_io[:desc]['format'] == live_io['format']
-          unsupported!('The Rust SDK input or output layout differs from this API action.')
+          unsupported!('The Rust API client input or output layout differs from this API action.')
         end
       end
       %i[global_input object_input].each do |key|
         next unless saved[key] && saved[key][:parameters].any? { |parameter| parameter[:desc]['required'] == true }
 
-        unsupported!('This Rust SDK action requires metadata that is absent from the sample.')
+        unsupported!('This Rust API client action requires metadata that is absent from the sample.')
       end
       %w[global object].each do |role|
         if live.dig('meta', role, 'input', 'parameters')&.any? { |_name, parameter| parameter['required'] == true }
@@ -282,7 +313,7 @@ module HaveAPI::RustClient
     def input_lines(saved, live, request)
       io = saved[:input]
       if io.nil?
-        unsupported!('This Rust SDK action cannot represent the sample input.') unless request.nil? || request == {}
+        unsupported!('This Rust API client action cannot represent the sample input.') unless request.nil? || request == {}
         return { before: [], chain: '' }
       end
       list = io[:layout].end_with?('_list')
@@ -293,7 +324,7 @@ module HaveAPI::RustClient
                  request
                end
       unless list ? values.is_a?(Array) && values.all?(Hash) : values.is_a?(Hash)
-        unsupported!('The sample input does not match the Rust SDK layout.')
+        unsupported!('The sample input does not match the Rust API client layout.')
       end
       objects = list ? values : [values]
       objects.each { |object| validate_object!(io, live['input'], object, required: true, method: saved[:desc]['method']) }
@@ -321,10 +352,10 @@ module HaveAPI::RustClient
         parameter = saved_io[:parameters].find { |item| item[:name] == name }
         live_parameter = live_params && live_params[name]
         unless parameter && live_parameter && compatible_parameter?(parameter[:desc], live_parameter)
-          unsupported!('A sample parameter is unavailable or has changed in this Rust SDK.')
+          unsupported!('A sample parameter is unavailable or has changed in this Rust API client.')
         end
         unless valid_value?(parameter[:desc], value, output: !required)
-          unsupported!('A sample value cannot be represented by this Rust SDK.')
+          unsupported!('A sample value cannot be represented by this Rust API client.')
         end
         if method == 'GET' && parameter[:desc]['type'] == 'Custom' && (value.is_a?(Hash) || value.is_a?(Array))
           unsupported!('Rust GET requests do not support nested Custom query values.')
@@ -334,7 +365,7 @@ module HaveAPI::RustClient
 
       [saved_io[:desc].fetch('parameters'), live_params || {}].each do |parameters|
         if parameters.any? { |name, desc| desc['required'] == true && !object.has_key?(name) }
-          unsupported!('The sample omits a required Rust SDK input.')
+          unsupported!('The sample omits a required Rust API client input.')
         end
       end
     end
@@ -394,18 +425,18 @@ module HaveAPI::RustClient
     def validate_response!(saved, live, response)
       io = saved[:output]
       unless io
-        unsupported!('The sample response does not match this Rust SDK.') unless response == {}
+        unsupported!('The sample response does not match this Rust API client.') unless response == {}
         return
       end
       list = io[:layout].end_with?('_list')
       unless list ? response.is_a?(Array) && response.all?(Hash) : response.is_a?(Hash)
-        unsupported!('The sample response does not match this Rust SDK layout.')
+        unsupported!('The sample response does not match this Rust API client layout.')
       end
       (list ? response : [response]).each { |object| validate_object!(io, live['output'], object, required: false) }
     end
 
     def output_lines(action, response)
-      return ['let _ = &response.output;'] unless action[:output] && response
+      return [] unless action[:output] && response
 
       list = action[:output][:layout].end_with?('_list')
       names = (list ? response : [response]).flat_map(&:keys).uniq
@@ -413,7 +444,7 @@ module HaveAPI::RustClient
       names.each do |name|
         parameter = action[:output][:parameters].find { |item| item[:name] == name }
         target = list ? 'item' : 'response.output'
-        lines << "#{'    ' if list}let _ = &#{target}.#{parameter[:field]};"
+        lines << "#{'    ' if list}println!(\"{:?}\", &#{target}.#{parameter[:field]});"
       end
       lines << '}' if list
       lines

data/lib/haveapi/rust_client/version.rb

@@ -1,5 +1,5 @@
 module HaveAPI
   module RustClient
-    VERSION = '0.31.2'.freeze
+    VERSION = '0.32.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haveapi-rust-client
 version: !ruby/object:Gem::Version
-  version: 0.31.2
+  version: 0.32.0
 platform: ruby
 authors:
 - Jakub Skokan
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.31.2
+        version: 0.32.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.31.2
+        version: 0.32.0
 - !ruby/object:Gem::Dependency
   name: tomlrb
   requirement: !ruby/object:Gem::Requirement