style: use 2-space indentation across entire codebase

Add rustfmt.toml with tab_spaces = 2 and reformat all source files,
tests, and README code examples to use 2-space indentation.

tests/test_records.rs

@@ -7,220 +7,220 @@ use wiremock::{Mock, ResponseTemplate};
 
 #[tokio::test]
 async fn test_list_records() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("GET"))
-        .and(path("/Records/appId/1"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "pageNumber": 1,
-            "pageSize": 50,
-            "totalPages": 1,
-            "totalRecords": 1,
-            "items": [
-                {
-                    "appId": 1,
-                    "recordId": 100,
-                    "fieldData": [
-                        {"type": "String", "fieldId": 10, "value": "hello"}
-                    ]
-                }
-            ]
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("GET"))
+    .and(path("/Records/appId/1"))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "pageNumber": 1,
+        "pageSize": 50,
+        "totalPages": 1,
+        "totalRecords": 1,
+        "items": [
+            {
+                "appId": 1,
+                "recordId": 100,
+                "fieldData": [
+                    {"type": "String", "fieldId": 10, "value": "hello"}
+                ]
+            }
+        ]
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let result = client.list_records(1, None, None, None).await.unwrap();
-    assert_eq!(result.total_records, Some(1));
-    let items = result.items.unwrap();
-    assert_eq!(items[0].record_id, 100);
-    let field_data = items[0].field_data.as_ref().unwrap();
-    assert_eq!(field_data[0].field_id, 10);
-    assert_eq!(field_data[0].value, serde_json::json!("hello"));
+  let result = client.list_records(1, None, None, None).await.unwrap();
+  assert_eq!(result.total_records, Some(1));
+  let items = result.items.unwrap();
+  assert_eq!(items[0].record_id, 100);
+  let field_data = items[0].field_data.as_ref().unwrap();
+  assert_eq!(field_data[0].field_id, 10);
+  assert_eq!(field_data[0].value, serde_json::json!("hello"));
 }
 
 #[tokio::test]
 async fn test_list_records_with_params() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("GET"))
-        .and(path("/Records/appId/1"))
-        .and(query_param("fieldIds", "10,20"))
-        .and(query_param("dataFormat", "Formatted"))
-        .and(query_param("PageNumber", "2"))
-        .and(query_param("PageSize", "10"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "pageNumber": 2,
-            "pageSize": 10,
-            "totalPages": 5,
-            "totalRecords": 50,
-            "items": []
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("GET"))
+    .and(path("/Records/appId/1"))
+    .and(query_param("fieldIds", "10,20"))
+    .and(query_param("dataFormat", "Formatted"))
+    .and(query_param("PageNumber", "2"))
+    .and(query_param("PageSize", "10"))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "pageNumber": 2,
+        "pageSize": 10,
+        "totalPages": 5,
+        "totalRecords": 50,
+        "items": []
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let paging = onspring::PagingRequest {
-        page_number: 2,
-        page_size: 10,
-    };
-    let result = client
-        .list_records(
-            1,
-            Some(paging),
-            Some(&[10, 20]),
-            Some(onspring::DataFormat::Formatted),
-        )
-        .await
-        .unwrap();
-    assert_eq!(result.page_number, Some(2));
+  let paging = onspring::PagingRequest {
+    page_number: 2,
+    page_size: 10,
+  };
+  let result = client
+    .list_records(
+      1,
+      Some(paging),
+      Some(&[10, 20]),
+      Some(onspring::DataFormat::Formatted),
+    )
+    .await
+    .unwrap();
+  assert_eq!(result.page_number, Some(2));
 }
 
 #[tokio::test]
 async fn test_get_record() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("GET"))
-        .and(path("/Records/appId/1/recordId/42"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "appId": 1,
-            "recordId": 42,
-            "fieldData": [
-                {"type": "Integer", "fieldId": 5, "value": 123}
-            ]
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("GET"))
+    .and(path("/Records/appId/1/recordId/42"))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "appId": 1,
+        "recordId": 42,
+        "fieldData": [
+            {"type": "Integer", "fieldId": 5, "value": 123}
+        ]
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let record = client.get_record(1, 42, None, None).await.unwrap();
-    assert_eq!(record.record_id, 42);
-    assert_eq!(record.app_id, 1);
+  let record = client.get_record(1, 42, None, None).await.unwrap();
+  assert_eq!(record.record_id, 42);
+  assert_eq!(record.app_id, 1);
 }
 
 #[tokio::test]
 async fn test_save_record_create() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("PUT"))
-        .and(path("/Records"))
-        .respond_with(ResponseTemplate::new(201).set_body_json(serde_json::json!({
-            "id": 99,
-            "warnings": []
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("PUT"))
+    .and(path("/Records"))
+    .respond_with(ResponseTemplate::new(201).set_body_json(serde_json::json!({
+        "id": 99,
+        "warnings": []
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let mut fields = HashMap::new();
-    fields.insert("10".to_string(), serde_json::json!("test value"));
+  let mut fields = HashMap::new();
+  fields.insert("10".to_string(), serde_json::json!("test value"));
 
-    let request = onspring::models::record::SaveRecordRequest {
-        app_id: 1,
-        record_id: None,
-        fields,
-    };
-    let result = client.save_record(request).await.unwrap();
-    assert_eq!(result.id, 99);
+  let request = onspring::models::record::SaveRecordRequest {
+    app_id: 1,
+    record_id: None,
+    fields,
+  };
+  let result = client.save_record(request).await.unwrap();
+  assert_eq!(result.id, 99);
 }
 
 #[tokio::test]
 async fn test_delete_record() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("DELETE"))
-        .and(path("/Records/appId/1/recordId/42"))
-        .respond_with(ResponseTemplate::new(204))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("DELETE"))
+    .and(path("/Records/appId/1/recordId/42"))
+    .respond_with(ResponseTemplate::new(204))
+    .mount(&mock_server)
+    .await;
 
-    let result = client.delete_record(1, 42).await;
-    assert!(result.is_ok());
+  let result = client.delete_record(1, 42).await;
+  assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_batch_get_records() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("POST"))
-        .and(path("/Records/batch-get"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "count": 2,
-            "items": [
-                {"appId": 1, "recordId": 1, "fieldData": []},
-                {"appId": 1, "recordId": 2, "fieldData": []}
-            ]
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("POST"))
+    .and(path("/Records/batch-get"))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "count": 2,
+        "items": [
+            {"appId": 1, "recordId": 1, "fieldData": []},
+            {"appId": 1, "recordId": 2, "fieldData": []}
+        ]
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let request = onspring::models::record::BatchGetRecordsRequest {
-        app_id: 1,
-        record_ids: vec![1, 2],
-        field_ids: None,
-        data_format: None,
-    };
-    let result = client.batch_get_records(request).await.unwrap();
-    assert_eq!(result.count, Some(2));
+  let request = onspring::models::record::BatchGetRecordsRequest {
+    app_id: 1,
+    record_ids: vec![1, 2],
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.batch_get_records(request).await.unwrap();
+  assert_eq!(result.count, Some(2));
 }
 
 #[tokio::test]
 async fn test_query_records() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("POST"))
-        .and(path("/Records/Query"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-            "pageNumber": 1,
-            "pageSize": 50,
-            "totalPages": 1,
-            "totalRecords": 1,
-            "items": [
-                {"appId": 1, "recordId": 5, "fieldData": []}
-            ]
-        })))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("POST"))
+    .and(path("/Records/Query"))
+    .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+        "pageNumber": 1,
+        "pageSize": 50,
+        "totalPages": 1,
+        "totalRecords": 1,
+        "items": [
+            {"appId": 1, "recordId": 5, "fieldData": []}
+        ]
+    })))
+    .mount(&mock_server)
+    .await;
 
-    let request = onspring::models::record::QueryRecordsRequest {
-        app_id: 1,
-        filter: "fieldId eq 'test'".to_string(),
-        field_ids: None,
-        data_format: None,
-    };
-    let result = client.query_records(request, None).await.unwrap();
-    assert_eq!(result.total_records, Some(1));
+  let request = onspring::models::record::QueryRecordsRequest {
+    app_id: 1,
+    filter: "fieldId eq 'test'".to_string(),
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.query_records(request, None).await.unwrap();
+  assert_eq!(result.total_records, Some(1));
 }
 
 #[tokio::test]
 async fn test_batch_delete_records() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("POST"))
-        .and(path("/Records/batch-delete"))
-        .respond_with(ResponseTemplate::new(204))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("POST"))
+    .and(path("/Records/batch-delete"))
+    .respond_with(ResponseTemplate::new(204))
+    .mount(&mock_server)
+    .await;
 
-    let request = onspring::models::record::BatchDeleteRecordsRequest {
-        app_id: 1,
-        record_ids: vec![1, 2, 3],
-    };
-    let result = client.batch_delete_records(request).await;
-    assert!(result.is_ok());
+  let request = onspring::models::record::BatchDeleteRecordsRequest {
+    app_id: 1,
+    record_ids: vec![1, 2, 3],
+  };
+  let result = client.batch_delete_records(request).await;
+  assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_get_record_not_found() {
-    let (mock_server, client) = common::setup().await;
+  let (mock_server, client) = common::setup().await;
 
-    Mock::given(method("GET"))
-        .and(path("/Records/appId/1/recordId/999"))
-        .respond_with(ResponseTemplate::new(404))
-        .mount(&mock_server)
-        .await;
+  Mock::given(method("GET"))
+    .and(path("/Records/appId/1/recordId/999"))
+    .respond_with(ResponseTemplate::new(404))
+    .mount(&mock_server)
+    .await;
 
-    let result = client.get_record(1, 999, None, None).await;
-    assert!(result.is_err());
-    if let Err(onspring::OnspringError::Api { status_code, .. }) = result {
-        assert_eq!(status_code, 404);
-    } else {
-        panic!("Expected Api error");
-    }
+  let result = client.get_record(1, 999, None, None).await;
+  assert!(result.is_err());
+  if let Err(onspring::OnspringError::Api { status_code, .. }) = result {
+    assert_eq!(status_code, 404);
+  } else {
+    panic!("Expected Api error");
+  }
 }